gst/gstinfo.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  *                    2003 Benjamin Otte <in7y118@public.uni-hamburg.de>
   5  *
   6  * gstinfo.c: debugging functions
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include "gst_private.h"
  25 #include "gstinfo.h"
  26
  27 #ifndef GST_DISABLE_GST_DEBUG
  28
  29 #ifdef HAVE_DLFCN_H
  30 #include <dlfcn.h>
  31 #endif
  32 #ifdef HAVE_PRINTF_EXTENSION
  33 #include <printf.h>
  34 #endif
  35 #include <stdio.h>              /* fprintf */
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39 #include <string.h>             /* G_VA_COPY */
  40 #include "gstelement.h"
  41 #include "gstpad.h"
  42 #include "gstscheduler.h"
  43 #include "gst_private.h"
  44 #include "gstatomic_impl.h"
  45 #ifdef HAVE_VALGRIND
  46 #include <valgrind/valgrind.h>
  47 #endif
  48
  49 /* underscore is to prevent conflict with GST_CAT_DEBUG define */
  50 GST_DEBUG_CATEGORY_STATIC (_GST_CAT_DEBUG);
  51 /* time of initialization, so we get useful debugging output times */
  52 GstClockTime start_time;
  53
  54 #if 0
  55 #if defined __sgi__
  56 #include <rld_interface.h>
  57 typedef struct DL_INFO
  58 {
  59   const char *dli_fname;
  60   void *dli_fbase;
  61   const char *dli_sname;
  62   void *dli_saddr;
  63   int dli_version;
  64   int dli_reserved1;
  65   long dli_reserved[4];
  66 }
  67 Dl_info;
  68
  69 #define _RLD_DLADDR             14
  70 int dladdr (void *address, Dl_info * dl);
  71
  72 int
  73 dladdr (void *address, Dl_info * dl)
  74 {
  75   void *v;
  76
  77   v = _rld_new_interface (_RLD_DLADDR, address, dl);
  78   return (int) v;
  79 }
  80 #endif /* __sgi__ */
  81 #endif
  82
  83 static void gst_debug_reset_threshold (gpointer category, gpointer unused);
  84 static void gst_debug_reset_all_thresholds (void);
  85
  86 #ifdef HAVE_PRINTF_EXTENSION
  87 static int _gst_info_printf_extension (FILE * stream,
  88     const struct printf_info *info, const void *const *args);
  89 static int _gst_info_printf_extension_arginfo (const struct printf_info *info,
  90     size_t n, int *argtypes);
  91 #endif
  92
  93 struct _GstDebugMessage
  94 {
  95   gchar *message;
  96   const gchar *format;
  97   va_list arguments;
  98 };
  99
 100 /* list of all name/level pairs from --gst-debug and GST_DEBUG */
 101 static GStaticMutex __level_name_mutex = G_STATIC_MUTEX_INIT;
 102 static GSList *__level_name = NULL;
 103 typedef struct
 104 {
 105   GPatternSpec *pat;
 106   GstDebugLevel level;
 107 }
 108 LevelNameEntry;
 109
 110 /* list of all categories */
 111 static GStaticMutex __cat_mutex = G_STATIC_MUTEX_INIT;
 112 static GSList *__categories = NULL;
 113
 114 /* all registered debug handlers */
 115 typedef struct
 116 {
 117   GstLogFunction func;
 118   gpointer user_data;
 119 }
 120 LogFuncEntry;
 121 static GStaticMutex __log_func_mutex = G_STATIC_MUTEX_INIT;
 122 static GSList *__log_functions = NULL;
 123
 124 static GstAtomicInt __default_level;
 125 static GstAtomicInt __use_color;
 126 gboolean __gst_debug_enabled = TRUE;
 127
 128
 129 GstDebugCategory *GST_CAT_DEFAULT = NULL;
 130
 131 GstDebugCategory *GST_CAT_GST_INIT = NULL;
 132 GstDebugCategory *GST_CAT_COTHREADS = NULL;
 133 GstDebugCategory *GST_CAT_COTHREAD_SWITCH = NULL;
 134 GstDebugCategory *GST_CAT_AUTOPLUG = NULL;
 135 GstDebugCategory *GST_CAT_AUTOPLUG_ATTEMPT = NULL;
 136 GstDebugCategory *GST_CAT_PARENTAGE = NULL;
 137 GstDebugCategory *GST_CAT_STATES = NULL;
 138 GstDebugCategory *GST_CAT_PLANNING = NULL;
 139 GstDebugCategory *GST_CAT_SCHEDULING = NULL;
 140
 141 /* FIXME: remove GST_CAT_DATAFLOW in 0.9 */
 142 GstDebugCategory *GST_CAT_DATAFLOW = NULL;
 143 GstDebugCategory *GST_CAT_BUFFER = NULL;
 144 GstDebugCategory *GST_CAT_CAPS = NULL;
 145 GstDebugCategory *GST_CAT_CLOCK = NULL;
 146 GstDebugCategory *GST_CAT_ELEMENT_PADS = NULL;
 147 GstDebugCategory *GST_CAT_PADS = NULL;
 148 GstDebugCategory *GST_CAT_PIPELINE = NULL;
 149 GstDebugCategory *GST_CAT_PLUGIN_LOADING = NULL;
 150 GstDebugCategory *GST_CAT_PLUGIN_INFO = NULL;
 151 GstDebugCategory *GST_CAT_PROPERTIES = NULL;
 152 GstDebugCategory *GST_CAT_THREAD = NULL;
 153 GstDebugCategory *GST_CAT_TYPES = NULL;
 154 GstDebugCategory *GST_CAT_XML = NULL;
 155 GstDebugCategory *GST_CAT_NEGOTIATION = NULL;
 156 GstDebugCategory *GST_CAT_REFCOUNTING = NULL;
 157 GstDebugCategory *GST_CAT_ERROR_SYSTEM = NULL;
 158 GstDebugCategory *GST_CAT_EVENT = NULL;
 159 GstDebugCategory *GST_CAT_PARAMS = NULL;
 160 GstDebugCategory *GST_CAT_CALL_TRACE = NULL;
 161 GstDebugCategory *GST_CAT_SEEK = NULL;
 162 GstDebugCategory *GST_CAT_SIGNAL = NULL;
 163 GstDebugCategory *GST_CAT_PROBE = NULL;
 164
 165 /* FIXME: export this? */
 166 gboolean
 167 __gst_in_valgrind (void)
 168 {
 169   static enum
 170   {
 171     GST_VG_UNCHECKED,
 172     GST_VG_NO_VALGRIND,
 173     GST_VG_INSIDE
 174   }
 175   in_valgrind = GST_VG_UNCHECKED;
 176
 177   if (in_valgrind == GST_VG_UNCHECKED) {
 178 #ifdef HAVE_VALGRIND
 179     if (RUNNING_ON_VALGRIND) {
 180       GST_CAT_INFO (GST_CAT_GST_INIT, "we're running inside valgrind");
 181       VALGRIND_PRINTF
 182           ("GStreamer has detected that it is running inside valgrind.");
 183       VALGRIND_PRINTF
 184           ("It might now take different code paths to ease debugging.");
 185       VALGRIND_PRINTF ("Of course, this may also lead to different bugs.");
 186       in_valgrind = GST_VG_INSIDE;
 187     } else {
 188       GST_CAT_LOG (GST_CAT_GST_INIT, "not doing extra valgrind stuff");
 189       in_valgrind = GST_VG_NO_VALGRIND;
 190     }
 191 #else
 192     in_valgrind = GST_VG_NO_VALGRIND;
 193 #endif
 194     g_assert (in_valgrind == GST_VG_NO_VALGRIND ||
 195         in_valgrind == GST_VG_INSIDE);
 196   }
 197   return (in_valgrind == GST_VG_INSIDE) ? TRUE : FALSE;
 198 }
 199
 200 /**
 201  * _gst_debug_init:
 202  *
 203  * Initializes the debugging system.
 204  * Normally you don't want to call this, because gst_init does it for you.
 205  */
 206 void
 207 _gst_debug_init (void)
 208 {
 209   GTimeVal current;
 210
 211   gst_atomic_int_init (&__default_level, GST_LEVEL_DEFAULT);
 212   gst_atomic_int_init (&__use_color, 1);
 213
 214   /* get time we started for debugging messages */
 215   g_get_current_time (&current);
 216   start_time = GST_TIMEVAL_TO_TIME (current);
 217
 218 #ifdef HAVE_PRINTF_EXTENSION
 219   register_printf_function (GST_PTR_FORMAT[0], _gst_info_printf_extension,
 220       _gst_info_printf_extension_arginfo);
 221 #endif
 222
 223   /* do NOT use a single debug function before this line has been run */
 224   GST_CAT_DEFAULT = _gst_debug_category_new ("default",
 225       GST_DEBUG_UNDERLINE, NULL);
 226   _GST_CAT_DEBUG = _gst_debug_category_new ("GST_DEBUG",
 227       GST_DEBUG_BOLD | GST_DEBUG_FG_YELLOW, "debugging subsystem");
 228
 229   gst_debug_add_log_function (gst_debug_log_default, NULL);
 230
 231   /* FIXME: add descriptions here */
 232   GST_CAT_GST_INIT = _gst_debug_category_new ("GST_INIT",
 233       GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);
 234   GST_CAT_COTHREADS = _gst_debug_category_new ("GST_COTHREADS",
 235       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, NULL);
 236   GST_CAT_COTHREAD_SWITCH = _gst_debug_category_new ("GST_COTHREAD_SWITCH",
 237       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_GREEN, NULL);
 238   GST_CAT_AUTOPLUG = _gst_debug_category_new ("GST_AUTOPLUG",
 239       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 240   GST_CAT_AUTOPLUG_ATTEMPT = _gst_debug_category_new ("GST_AUTOPLUG_ATTEMPT",
 241       GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN | GST_DEBUG_BG_BLUE, NULL);
 242   GST_CAT_PARENTAGE = _gst_debug_category_new ("GST_PARENTAGE",
 243       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 244   GST_CAT_STATES = _gst_debug_category_new ("GST_STATES",
 245       GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);
 246   GST_CAT_PLANNING = _gst_debug_category_new ("GST_PLANNING",
 247       GST_DEBUG_BOLD | GST_DEBUG_FG_MAGENTA, NULL);
 248   GST_CAT_SCHEDULING = _gst_debug_category_new ("GST_SCHEDULING",
 249       GST_DEBUG_BOLD | GST_DEBUG_FG_MAGENTA, NULL);
 250 /* FIXME: remove GST_CAT_DATAFLOW in 0.9 */
 251   GST_CAT_DATAFLOW = _gst_debug_category_new ("GST_DATAFLOW",
 252       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "dataflow inside pads");
 253   GST_CAT_BUFFER = _gst_debug_category_new ("GST_BUFFER",
 254       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, NULL);
 255   GST_CAT_CAPS = _gst_debug_category_new ("GST_CAPS",
 256       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 257   GST_CAT_CLOCK = _gst_debug_category_new ("GST_CLOCK",
 258       GST_DEBUG_BOLD | GST_DEBUG_FG_YELLOW, NULL);
 259   GST_CAT_ELEMENT_PADS = _gst_debug_category_new ("GST_ELEMENT_PADS",
 260       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 261   GST_CAT_PADS = _gst_debug_category_new ("GST_PADS",
 262       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 263   GST_CAT_PIPELINE = _gst_debug_category_new ("GST_PIPELINE",
 264       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 265   GST_CAT_PLUGIN_LOADING = _gst_debug_category_new ("GST_PLUGIN_LOADING",
 266       GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN, NULL);
 267   GST_CAT_PLUGIN_INFO = _gst_debug_category_new ("GST_PLUGIN_INFO",
 268       GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN, NULL);
 269   GST_CAT_PROPERTIES = _gst_debug_category_new ("GST_PROPERTIES",
 270       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_BLUE, NULL);
 271   GST_CAT_THREAD = _gst_debug_category_new ("GST_THREAD",
 272       GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);
 273   GST_CAT_TYPES = _gst_debug_category_new ("GST_TYPES",
 274       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 275   GST_CAT_XML = _gst_debug_category_new ("GST_XML",
 276       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 277   GST_CAT_NEGOTIATION = _gst_debug_category_new ("GST_NEGOTIATION",
 278       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 279   GST_CAT_REFCOUNTING = _gst_debug_category_new ("GST_REFCOUNTING",
 280       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE | GST_DEBUG_BG_GREEN, NULL);
 281   GST_CAT_ERROR_SYSTEM = _gst_debug_category_new ("GST_ERROR_SYSTEM",
 282       GST_DEBUG_BOLD | GST_DEBUG_FG_RED | GST_DEBUG_BG_WHITE, NULL);
 283
 284   GST_CAT_EVENT = _gst_debug_category_new ("GST_EVENT",
 285       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 286   GST_CAT_PARAMS = _gst_debug_category_new ("GST_PARAMS",
 287       GST_DEBUG_BOLD | GST_DEBUG_FG_BLACK | GST_DEBUG_BG_YELLOW, NULL);
 288   GST_CAT_CALL_TRACE = _gst_debug_category_new ("GST_CALL_TRACE",
 289       GST_DEBUG_BOLD, NULL);
 290   /* FIXME: fold back to GST_CAT_EVENT in 0.9 */
 291   GST_CAT_SEEK = _gst_debug_category_new ("GST_SEEK",
 292       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, "plugins reacting to seek events");
 293   GST_CAT_SIGNAL = _gst_debug_category_new ("GST_SIGNAL",
 294       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 295   GST_CAT_PROBE = _gst_debug_category_new ("GST_PROBE",
 296       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "pad probes");
 297
 298
 299   /* print out the valgrind message if we're in valgrind */
 300   __gst_in_valgrind ();
 301 }
 302
 303 /* we can't do this further above, because we initialize the GST_CAT_DEFAULT struct */
 304 #define GST_CAT_DEFAULT _GST_CAT_DEBUG
 305
 306 /**
 307  * gst_debug_log:
 308  * @category: category to log
 309  * @level: level of the message is in
 310  * @file: the file that emitted the message, usually the __FILE__ identifier
 311  * @function: the function that emitted the message
 312  * @line: the line from that the message was emitted, usually __LINE__
 313  * @object: the object this message relates to or NULL if none
 314  * @format: a printf style format string
 315  * @...: optional arguments for the format
 316  *
 317  * Logs the given message using the currently registered debugging handlers.
 318  */
 319 void
 320 gst_debug_log (GstDebugCategory * category, GstDebugLevel level,
 321     const gchar * file, const gchar * function, gint line,
 322     GObject * object, const gchar * format, ...)
 323 {
 324   va_list var_args;
 325
 326   va_start (var_args, format);
 327   gst_debug_log_valist (category, level, file, function, line, object, format,
 328       var_args);
 329   va_end (var_args);
 330 }
 331
 332 /**
 333  * gst_debug_log_valist:
 334  * @category: category to log
 335  * @level: level of the message is in
 336  * @file: the file that emitted the message, usually the __FILE__ identifier
 337  * @function: the function that emitted the message
 338  * @line: the line from that the message was emitted, usually __LINE__
 339  * @object: the object this message relates to or NULL if none
 340  * @format: a printf style format string
 341  * @args: optional arguments for the format
 342  *
 343  * Logs the given message using the currently registered debugging handlers.
 344  */
 345 void
 346 gst_debug_log_valist (GstDebugCategory * category, GstDebugLevel level,
 347     const gchar * file, const gchar * function, gint line,
 348     GObject * object, const gchar * format, va_list args)
 349 {
 350   GstDebugMessage message;
 351   LogFuncEntry *entry;
 352   GSList *handler;
 353
 354   g_return_if_fail (category != NULL);
 355   g_return_if_fail (file != NULL);
 356   g_return_if_fail (function != NULL);
 357   g_return_if_fail (format != NULL);
 358
 359   message.message = NULL;
 360   message.format = format;
 361   G_VA_COPY (message.arguments, args);
 362
 363   handler = __log_functions;
 364   while (handler) {
 365     entry = handler->data;
 366     handler = g_slist_next (handler);
 367     entry->func (category, level, file, function, line, object, &message,
 368         entry->user_data);
 369   }
 370   g_free (message.message);
 371   va_end (message.arguments);
 372 }
 373
 374 /**
 375  * gst_debug_message_get:
 376  * @message: a debug message
 377  *
 378  * Gets the string representation of a #GstDebugMessage. This function is used
 379  * in debug handlers to extract the message.
 380  *
 381  * Returns: the string representation of a #GstDebugMessage.
 382  */
 383 const gchar *
 384 gst_debug_message_get (GstDebugMessage * message)
 385 {
 386   if (message->message == NULL) {
 387     message->message = g_strdup_vprintf (message->format, message->arguments);
 388   }
 389   return message->message;
 390 }
 391
 392
 393 static gchar *
 394 gst_debug_print_object (gpointer ptr)
 395 {
 396   GObject *object = (GObject *) ptr;
 397
 398 #ifdef unused
 399   /* This is a cute trick to detect unmapped memory, but is unportable,
 400    * slow, screws around with madvise, and not actually that useful. */
 401   {
 402     int ret;
 403
 404     ret = madvise ((void *) ((unsigned long) ptr & (~0xfff)), 4096, 0);
 405     if (ret == -1 && errno == ENOMEM) {
 406       buffer = g_strdup_printf ("%p (unmapped memory)", ptr);
 407     }
 408   }
 409 #endif
 410
 411   /* nicely printed object */
 412   if (object == NULL) {
 413     return g_strdup ("(NULL)");
 414   }
 415   if (*(GType *) ptr == GST_TYPE_CAPS) {
 416     return gst_caps_to_string ((GstCaps *) ptr);
 417   }
 418   if (*(GType *) ptr == GST_TYPE_STRUCTURE) {
 419     return gst_structure_to_string ((GstStructure *) ptr);
 420   }
 421 #ifdef USE_POISONING
 422   if (*(guint32 *) ptr == 0xffffffff) {
 423     return g_strdup_printf ("<poisoned@%p>", ptr);
 424   }
 425 #endif
 426   if (GST_IS_PAD (object) && GST_OBJECT_NAME (object)) {
 427     return g_strdup_printf ("<%s:%s>", GST_DEBUG_PAD_NAME (object));
 428   }
 429   if (GST_IS_OBJECT (object) && GST_OBJECT_NAME (object)) {
 430     return g_strdup_printf ("<%s>", GST_OBJECT_NAME (object));
 431   }
 432   if (G_IS_OBJECT (object)) {
 433     return g_strdup_printf ("<%s@%p>", G_OBJECT_TYPE_NAME (object), object);
 434   }
 435
 436   return g_strdup_printf ("%p", ptr);
 437 }
 438
 439 /**
 440  * gst_debug_construct_term_color:
 441  * @colorinfo: the color info
 442  *
 443  * Constructs a string that can be used for getting the desired color in color
 444  * terminals.
 445  * You need to free the string after use.
 446  *
 447  * Returns: a string containing the color definition
 448  */
 449 gchar *
 450 gst_debug_construct_term_color (guint colorinfo)
 451 {
 452   GString *color;
 453   gchar *ret;
 454
 455   color = g_string_new ("\033[00");
 456
 457   if (colorinfo & GST_DEBUG_BOLD) {
 458     g_string_append (color, ";01");
 459   }
 460   if (colorinfo & GST_DEBUG_UNDERLINE) {
 461     g_string_append (color, ";04");
 462   }
 463   if (colorinfo & GST_DEBUG_FG_MASK) {
 464     g_string_append_printf (color, ";3%1d", colorinfo & GST_DEBUG_FG_MASK);
 465   }
 466   if (colorinfo & GST_DEBUG_BG_MASK) {
 467     g_string_append_printf (color, ";4%1d",
 468         (colorinfo & GST_DEBUG_BG_MASK) >> 4);
 469   }
 470   g_string_append (color, "m");
 471
 472   ret = color->str;
 473   g_string_free (color, FALSE);
 474   return ret;
 475 }
 476
 477 /**
 478  * gst_debug_log_default:
 479  * @category: category to log
 480  * @level: level of the message
 481  * @file: the file that emitted the message, usually the __FILE__ identifier
 482  * @function: the function that emitted the message
 483  * @line: the line from that the message was emitted, usually __LINE__
 484  * @message: the actual message
 485  * @object: the object this message relates to or NULL if none
 486  * @unused: an unused variable, reserved for some user_data.
 487  *
 488  * The default logging handler used by GStreamer. Logging functions get called
 489  * whenever a macro like GST_DEBUG or similar is used. This function outputs the
 490  * message and additional info using the glib error handler.
 491  * You can add other handlers by using #gst_debug_add_log_function.
 492  * And you can remove this handler by calling
 493  * gst_debug_remove_log_function (gst_debug_log_default);
 494  */
 495 void
 496 gst_debug_log_default (GstDebugCategory * category, GstDebugLevel level,
 497     const gchar * file, const gchar * function, gint line,
 498     GObject * object, GstDebugMessage * message, gpointer unused)
 499 {
 500   gchar *color;
 501   gchar *clear;
 502   gchar *obj;
 503   gchar *pidcolor;
 504   gint pid;
 505   GTimeVal now;
 506   GstClockTime elapsed;
 507
 508   if (level > gst_debug_category_get_threshold (category))
 509     return;
 510
 511   pid = getpid ();
 512
 513   /* color info */
 514   if (gst_debug_is_colored ()) {
 515     color =
 516         gst_debug_construct_term_color (gst_debug_category_get_color
 517         (category));
 518     clear = "\033[00m";
 519     pidcolor = g_strdup_printf ("\033[3%1dm", pid % 6 + 31);
 520   } else {
 521     color = g_strdup ("");
 522     clear = "";
 523     pidcolor = g_strdup ("");
 524   }
 525
 526   obj = object ? gst_debug_print_object (object) : g_strdup ("");
 527
 528   g_get_current_time (&now);
 529   elapsed = GST_TIMEVAL_TO_TIME (now) - start_time;
 530   g_printerr ("%s (%p - %" GST_TIME_FORMAT
 531       ") %s%15s%s(%s%5d%s) %s%s(%d):%s:%s%s %s\n",
 532       gst_debug_level_get_name (level), g_thread_self (),
 533       GST_TIME_ARGS (elapsed), color,
 534       gst_debug_category_get_name (category), clear, pidcolor, pid, clear,
 535       color, file, line, function, obj, clear, gst_debug_message_get (message));
 536
 537   g_free (color);
 538   g_free (pidcolor);
 539   g_free (obj);
 540 }
 541
 542 /**
 543  * gst_debug_level_get_name:
 544  * @level: the level to get the name for
 545  *
 546  * Get the string trepresentation of a debugging level
 547  *
 548  * Returns: the name
 549  */
 550 const gchar *
 551 gst_debug_level_get_name (GstDebugLevel level)
 552 {
 553   switch (level) {
 554     case GST_LEVEL_NONE:
 555       return "";
 556     case GST_LEVEL_ERROR:
 557       return "ERROR";
 558     case GST_LEVEL_WARNING:
 559       return "WARN ";
 560     case GST_LEVEL_INFO:
 561       return "INFO ";
 562     case GST_LEVEL_DEBUG:
 563       return "DEBUG";
 564     case GST_LEVEL_LOG:
 565       return "LOG  ";
 566     default:
 567       g_warning ("invalid level specified for gst_debug_level_get_name");
 568       return "";
 569   }
 570 }
 571
 572 /**
 573  * gst_debug_add_log_function:
 574  * @func: the function to use
 575  * @data: user data
 576  *
 577  * Adds the logging function to the list of logging functions.
 578  * Be sure to use G_GNUC_NO_INSTRUMENT on that function, it is needed.
 579  */
 580 void
 581 gst_debug_add_log_function (GstLogFunction func, gpointer data)
 582 {
 583   LogFuncEntry *entry;
 584   GSList *list;
 585
 586   g_return_if_fail (func != NULL);
 587
 588   entry = g_new (LogFuncEntry, 1);
 589   entry->func = func;
 590   entry->user_data = data;
 591   /* FIXME: we leak the old list here - other threads might access it right now
 592    * in gst_debug_logv. Another solution is to lock the mutex in gst_debug_logv,
 593    * but that is waaay costly.
 594    * It'd probably be clever to use some kind of RCU here, but I don't know
 595    * anything about that.
 596    */
 597   g_static_mutex_lock (&__log_func_mutex);
 598   list = g_slist_copy (__log_functions);
 599   __log_functions = g_slist_prepend (list, entry);
 600   g_static_mutex_unlock (&__log_func_mutex);
 601
 602   GST_DEBUG ("prepended log function %p (user data %p) to log functions",
 603       func, data);
 604 }
 605
 606 static gint
 607 gst_debug_compare_log_function_by_func (gconstpointer entry, gconstpointer func)
 608 {
 609   gpointer entryfunc = ((LogFuncEntry *) entry)->func;
 610
 611   return (entryfunc < func) ? -1 : (entryfunc > func) ? 1 : 0;
 612 }
 613
 614 static gint
 615 gst_debug_compare_log_function_by_data (gconstpointer entry, gconstpointer data)
 616 {
 617   gpointer entrydata = ((LogFuncEntry *) entry)->user_data;
 618
 619   return (entrydata < data) ? -1 : (entrydata > data) ? 1 : 0;
 620 }
 621
 622 static guint
 623 gst_debug_remove_with_compare_func (GCompareFunc func, gpointer data)
 624 {
 625   GSList *found;
 626   GSList *new;
 627   guint removals = 0;
 628
 629   g_static_mutex_lock (&__log_func_mutex);
 630   new = __log_functions;
 631   while ((found = g_slist_find_custom (new, data, func))) {
 632     if (new == __log_functions) {
 633       new = g_slist_copy (new);
 634       continue;
 635     }
 636     g_free (found->data);
 637     new = g_slist_delete_link (new, found);
 638     removals++;
 639   }
 640   /* FIXME: We leak the old list here. See _add_log_function for why. */
 641   __log_functions = new;
 642   g_static_mutex_unlock (&__log_func_mutex);
 643
 644   return removals;
 645 }
 646
 647 /**
 648  * gst_debug_remove_log_function:
 649  * @func: the log function to remove
 650  *
 651  * Removes all registrered instances of the given logging functions.
 652  *
 653  * Returns: How many instances of the function were removed
 654  */
 655 guint
 656 gst_debug_remove_log_function (GstLogFunction func)
 657 {
 658   guint removals;
 659
 660   g_return_val_if_fail (func != NULL, 0);
 661
 662   removals =
 663       gst_debug_remove_with_compare_func
 664       (gst_debug_compare_log_function_by_func, func);
 665   GST_DEBUG ("removed log function %p %d times from log function list", func,
 666       removals);
 667
 668   return removals;
 669 }
 670
 671 /**
 672  * gst_debug_remove_log_function_by_data:
 673  * @data: user data of the log function to remove
 674  *
 675  * Removes all registrered instances of log functions with the given user data.
 676  *
 677  * Returns: How many instances of the function were removed
 678  */
 679 guint
 680 gst_debug_remove_log_function_by_data (gpointer data)
 681 {
 682   guint removals;
 683
 684   removals =
 685       gst_debug_remove_with_compare_func
 686       (gst_debug_compare_log_function_by_data, data);
 687   GST_DEBUG
 688       ("removed %d log functions with user data %p from log function list",
 689       removals, data);
 690
 691   return removals;
 692 }
 693
 694 /**
 695  * gst_debug_set_colored:
 696  * @colored: Whether to use colored output or not
 697  *
 698  * Sets or unsets the use of coloured debugging output.
 699  */
 700 void
 701 gst_debug_set_colored (gboolean colored)
 702 {
 703   gst_atomic_int_set (&__use_color, colored ? 1 : 0);
 704 }
 705
 706 /**
 707  * gst_debug_is_colored:
 708  *
 709  * Checks if the debugging output should be colored.
 710  *
 711  * Returns: TRUE, if the debug output should be colored.
 712  */
 713 gboolean
 714 gst_debug_is_colored (void)
 715 {
 716   return gst_atomic_int_read (&__use_color) == 0 ? FALSE : TRUE;
 717 }
 718
 719 /**
 720  * gst_debug_set_active:
 721  * @active: Whether to use debugging output or not
 722  *
 723  * If activated, debugging messages are sent to the debugging
 724  * handlers.
 725  * It makes sense to deactivate it for speed issues.
 726  * <note><para>This function is not threadsafe. It makes sense to only call it
 727  * during initialization.</para></note>
 728  */
 729 void
 730 gst_debug_set_active (gboolean active)
 731 {
 732   __gst_debug_enabled = active;
 733 }
 734
 735 /**
 736  * gst_debug_is_active:
 737  *
 738  * Checks if debugging output is activated.
 739  *
 740  * Returns: TRUE, if debugging is activated
 741  */
 742 gboolean
 743 gst_debug_is_active (void)
 744 {
 745   return __gst_debug_enabled;
 746 }
 747
 748 /**
 749  * gst_debug_set_default_threshold:
 750  * @level: level to set
 751  *
 752  * Sets the default threshold to the given level and updates all categories to
 753  * use this threshold.
 754  */
 755 void
 756 gst_debug_set_default_threshold (GstDebugLevel level)
 757 {
 758   gst_atomic_int_set (&__default_level, level);
 759   gst_debug_reset_all_thresholds ();
 760 }
 761
 762 /**
 763  * gst_debug_get_default_threshold:
 764  *
 765  * Returns the default threshold that is used for new categories.
 766  *
 767  * Returns: the default threshold level
 768  */
 769 GstDebugLevel
 770 gst_debug_get_default_threshold (void)
 771 {
 772   return (GstDebugLevel) gst_atomic_int_read (&__default_level);
 773 }
 774 static void
 775 gst_debug_reset_threshold (gpointer category, gpointer unused)
 776 {
 777   GstDebugCategory *cat = (GstDebugCategory *) category;
 778   GSList *walk;
 779
 780   g_static_mutex_lock (&__level_name_mutex);
 781   walk = __level_name;
 782   while (walk) {
 783     LevelNameEntry *entry = walk->data;
 784
 785     walk = g_slist_next (walk);
 786     if (g_pattern_match_string (entry->pat, cat->name)) {
 787       GST_LOG ("category %s matches pattern %p - gets set to level %d",
 788           cat->name, entry->pat, entry->level);
 789       gst_debug_category_set_threshold (cat, entry->level);
 790       goto exit;
 791     }
 792   }
 793   gst_debug_category_set_threshold (cat, gst_debug_get_default_threshold ());
 794
 795 exit:
 796   g_static_mutex_unlock (&__level_name_mutex);
 797 }
 798 static void
 799 gst_debug_reset_all_thresholds (void)
 800 {
 801   g_static_mutex_lock (&__cat_mutex);
 802   g_slist_foreach (__categories, gst_debug_reset_threshold, NULL);
 803   g_static_mutex_unlock (&__cat_mutex);
 804 }
 805 static void
 806 for_each_threshold_by_entry (gpointer data, gpointer user_data)
 807 {
 808   GstDebugCategory *cat = (GstDebugCategory *) data;
 809   LevelNameEntry *entry = (LevelNameEntry *) user_data;
 810
 811   if (g_pattern_match_string (entry->pat, cat->name)) {
 812     GST_LOG ("category %s matches pattern %p - gets set to level %d",
 813         cat->name, entry->pat, entry->level);
 814     gst_debug_category_set_threshold (cat, entry->level);
 815   }
 816 }
 817
 818 /**
 819  * gst_debug_set_threshold_for_name:
 820  * @name: name of the categories to set
 821  * @level: level to set them to
 822  *
 823  * Sets all categories which match the given glob style pattern to the given
 824  * level.
 825  */
 826 void
 827 gst_debug_set_threshold_for_name (const gchar * name, GstDebugLevel level)
 828 {
 829   GPatternSpec *pat;
 830   LevelNameEntry *entry;
 831
 832   g_return_if_fail (name != NULL);
 833
 834   pat = g_pattern_spec_new (name);
 835   entry = g_new (LevelNameEntry, 1);
 836   entry->pat = pat;
 837   entry->level = level;
 838   g_static_mutex_lock (&__level_name_mutex);
 839   __level_name = g_slist_prepend (__level_name, entry);
 840   g_static_mutex_unlock (&__level_name_mutex);
 841   g_static_mutex_lock (&__cat_mutex);
 842   g_slist_foreach (__categories, for_each_threshold_by_entry, entry);
 843   g_static_mutex_unlock (&__cat_mutex);
 844 }
 845
 846 /**
 847  * gst_debug_unset_threshold_for_name:
 848  * @name: name of the categories to set
 849  *
 850  * Resets all categories with the given name back to the default level.
 851  */
 852 void
 853 gst_debug_unset_threshold_for_name (const gchar * name)
 854 {
 855   GSList *walk;
 856   GPatternSpec *pat;
 857
 858   g_return_if_fail (name != NULL);
 859
 860   pat = g_pattern_spec_new (name);
 861   g_static_mutex_lock (&__level_name_mutex);
 862   walk = __level_name;
 863   /* improve this if you want, it's mighty slow */
 864   while (walk) {
 865     LevelNameEntry *entry = walk->data;
 866
 867     if (g_pattern_spec_equal (entry->pat, pat)) {
 868       __level_name = g_slist_remove_link (__level_name, walk);
 869       g_pattern_spec_free (entry->pat);
 870       g_free (entry);
 871       g_slist_free_1 (walk);
 872       walk = __level_name;
 873     }
 874   }
 875   g_static_mutex_unlock (&__level_name_mutex);
 876   g_pattern_spec_free (pat);
 877   gst_debug_reset_all_thresholds ();
 878 }
 879
 880 GstDebugCategory *
 881 _gst_debug_category_new (gchar * name, guint color, gchar * description)
 882 {
 883   GstDebugCategory *cat;
 884
 885   g_return_val_if_fail (name != NULL, NULL);
 886
 887   cat = g_new (GstDebugCategory, 1);
 888   cat->name = g_strdup (name);
 889   cat->color = color;
 890   if (description != NULL) {
 891     cat->description = g_strdup (description);
 892   } else {
 893     cat->description = g_strdup ("no description");
 894   }
 895   cat->threshold = g_new (GstAtomicInt, 1);
 896   gst_atomic_int_init (cat->threshold, 0);
 897   gst_debug_reset_threshold (cat, NULL);
 898
 899   /* add to category list */
 900   g_static_mutex_lock (&__cat_mutex);
 901   __categories = g_slist_prepend (__categories, cat);
 902   g_static_mutex_unlock (&__cat_mutex);
 903
 904   return cat;
 905 }
 906
 907 /**
 908  * gst_debug_category_free:
 909  * @category: #GstDebugCategory to free.
 910  *
 911  * Removes and frees the category and all associated resources.
 912  */
 913 void
 914 gst_debug_category_free (GstDebugCategory * category)
 915 {
 916   if (category == NULL)
 917     return;
 918
 919   /* remove from category list */
 920   g_static_mutex_lock (&__cat_mutex);
 921   __categories = g_slist_remove (__categories, category);
 922   g_static_mutex_unlock (&__cat_mutex);
 923
 924   g_free ((gpointer) category->name);
 925   g_free ((gpointer) category->description);
 926   gst_atomic_int_destroy (category->threshold);
 927   g_free (category->threshold);
 928   g_free (category);
 929 }
 930
 931 /**
 932  * gst_debug_category_set_threshold:
 933  * @category: a #GstDebugCategory to set threshold of.
 934  * @level: the #GstDebugLevel threshold to set.
 935  *
 936  * Sets the threshold of the category to the given level. Debug information will
 937  * only be output if the threshold is lower or equal to the level of the
 938  * debugging message.
 939  * <note><para>
 940  * Do not use this function in production code, because other functions may
 941  * change the threshold of categories as side effect. It is however a nice
 942  * function to use when debugging (even from gdb).
 943  * </para></note>
 944  */
 945 void
 946 gst_debug_category_set_threshold (GstDebugCategory * category,
 947     GstDebugLevel level)
 948 {
 949   g_return_if_fail (category != NULL);
 950
 951   gst_atomic_int_set (category->threshold, level);
 952 }
 953
 954 /**
 955  * gst_debug_category_reset_threshold:
 956  * @category: a #GstDebugCategory to reset threshold of.
 957  *
 958  * Resets the threshold of the category to the default level. Debug information
 959  * will only be output if the threshold is lower or equal to the level of the
 960  * debugging message.
 961  * Use this function to set the threshold back to where it was after using
 962  * gst_debug_category_set_threshold().
 963  */
 964 void
 965 gst_debug_category_reset_threshold (GstDebugCategory * category)
 966 {
 967   gst_debug_reset_threshold (category, NULL);
 968 }
 969
 970 /**
 971  * gst_debug_category_get_threshold:
 972  * @category: a #GstDebugCategory to get threshold of.
 973  *
 974  * Returns the threshold of a #GstCategory.
 975  *
 976  * Returns: the #GstDebugLevel that is used as threshold.
 977  */
 978 GstDebugLevel
 979 gst_debug_category_get_threshold (GstDebugCategory * category)
 980 {
 981   return gst_atomic_int_read (category->threshold);
 982 }
 983
 984 /**
 985  * gst_debug_category_get_name:
 986  * @category: a #GstDebugCategory to get name of.
 987  *
 988  * Returns the name of a debug category.
 989  *
 990  * Returns: the name of the category.
 991  */
 992 const gchar *
 993 gst_debug_category_get_name (GstDebugCategory * category)
 994 {
 995   return category->name;
 996 }
 997
 998 /**
 999  * gst_debug_category_get_color:
1000  * @category: a #GstDebugCategory to get the color of.
1001  *
1002  * Returns the color of a debug category used when printing output in this
1003  * category.
1004  *
1005  * Returns: the color of the category.
1006  */
1007 guint
1008 gst_debug_category_get_color (GstDebugCategory * category)
1009 {
1010   return category->color;
1011 }
1012
1013 /**
1014  * gst_debug_category_get_description:
1015  * @category: a #GstDebugCategory to get the description of.
1016  *
1017  * Returns the description of a debug category.
1018  *
1019  * Returns: the description of the category.
1020  */
1021 const gchar *
1022 gst_debug_category_get_description (GstDebugCategory * category)
1023 {
1024   return category->description;
1025 }
1026
1027 /**
1028  * gst_debug_get_all_categories:
1029  *
1030  * Returns a snapshot of a all categories that are currently in use . This list
1031  * may change anytime.
1032  * The caller has to free the list after use.
1033  * <emphasis>This function is not threadsafe, so only use it while only the
1034  * main thread is running.</emphasis>
1035  *
1036  * Returns: the list of categories
1037  */
1038 GSList *
1039 gst_debug_get_all_categories (void)
1040 {
1041   GSList *ret;
1042
1043   g_static_mutex_lock (&__cat_mutex);
1044   ret = g_slist_copy (__categories);
1045   g_static_mutex_unlock (&__cat_mutex);
1046
1047   return ret;
1048 }
1049
1050 /*** FUNCTION POINTERS ********************************************************/
1051
1052 GHashTable *__gst_function_pointers = NULL;
1053 const gchar *
1054 _gst_debug_nameof_funcptr (void *ptr)
1055     G_GNUC_NO_INSTRUMENT;
1056
1057 /* This function MUST NOT return NULL */
1058      const gchar *_gst_debug_nameof_funcptr (void *ptr)
1059 {
1060   gchar *ptrname;
1061
1062 #ifdef HAVE_DLADDR
1063   Dl_info dlinfo;
1064 #endif
1065
1066   if (__gst_function_pointers
1067       && (ptrname = g_hash_table_lookup (__gst_function_pointers, ptr))) {
1068     return ptrname;
1069   }
1070   /* we need to create an entry in the hash table for this one so we don't leak
1071    * the name */
1072 #ifdef HAVE_DLADDR
1073   if (dladdr (ptr, &dlinfo) && dlinfo.dli_sname) {
1074     gchar *name = g_strdup (dlinfo.dli_sname);
1075
1076     _gst_debug_register_funcptr (ptr, name);
1077     return name;
1078   } else
1079 #endif
1080   {
1081     gchar *name = g_strdup_printf ("%p", ptr);
1082
1083     _gst_debug_register_funcptr (ptr, name);
1084     return name;
1085   }
1086 }
1087
1088 void *
1089 _gst_debug_register_funcptr (void *ptr, gchar * ptrname)
1090 {
1091   if (!__gst_function_pointers)
1092     __gst_function_pointers = g_hash_table_new (g_direct_hash, g_direct_equal);
1093   if (!g_hash_table_lookup (__gst_function_pointers, ptr))
1094     g_hash_table_insert (__gst_function_pointers, ptr, ptrname);
1095
1096   return ptr;
1097 }
1098
1099 #ifdef HAVE_PRINTF_EXTENSION
1100 static int
1101 _gst_info_printf_extension (FILE * stream, const struct printf_info *info,
1102     const void *const *args)
1103 {
1104   char *buffer;
1105   int len;
1106   void *ptr;
1107
1108   buffer = NULL;
1109   ptr = *(void **) args[0];
1110
1111   buffer = gst_debug_print_object (ptr);
1112   len = fprintf (stream, "%*s", (info->left ? -info->width : info->width),
1113       buffer);
1114
1115   free (buffer);
1116   return len;
1117 }
1118
1119 static int
1120 _gst_info_printf_extension_arginfo (const struct printf_info *info, size_t n,
1121     int *argtypes)
1122 {
1123   if (n > 0)
1124     argtypes[0] = PA_POINTER;
1125   return 1;
1126 }
1127 #endif /* HAVE_PRINTF_EXTENSION */
1128
1129 #else /* !GST_DISABLE_GST_DEBUG */
1130 guint
1131 gst_debug_remove_log_function (GstLogFunction func)
1132 {
1133   return 0;
1134 }
1135
1136 guint
1137 gst_debug_remove_log_function_by_data (gpointer data)
1138 {
1139   return 0;
1140 }
1141
1142 gboolean
1143 __gst_in_valgrind (void)
1144 {
1145   return FALSE;
1146 }
1147
1148 #endif /* GST_DISABLE_GST_DEBUG */
1149
1150
1151 #ifdef GST_ENABLE_FUNC_INSTRUMENTATION
1152 /* FIXME make this thread specific */
1153 static GSList *stack_trace = NULL;
1154
1155 void
1156 __cyg_profile_func_enter (void *this_fn, void *call_site)
1157     G_GNUC_NO_INSTRUMENT;
1158      void __cyg_profile_func_enter (void *this_fn, void *call_site)
1159 {
1160   gchar *name = _gst_debug_nameof_funcptr (this_fn);
1161   gchar *site = _gst_debug_nameof_funcptr (call_site);
1162
1163   GST_CAT_DEBUG (GST_CAT_CALL_TRACE, "entering function %s from %s", name,
1164       site);
1165   stack_trace =
1166       g_slist_prepend (stack_trace, g_strdup_printf ("%8p in %s from %p (%s)",
1167           this_fn, name, call_site, site));
1168
1169   g_free (name);
1170   g_free (site);
1171 }
1172
1173 void
1174 __cyg_profile_func_exit (void *this_fn, void *call_site)
1175     G_GNUC_NO_INSTRUMENT;
1176      void __cyg_profile_func_exit (void *this_fn, void *call_site)
1177 {
1178   gchar *name = _gst_debug_nameof_funcptr (this_fn);
1179
1180   GST_CAT_DEBUG (GST_CAT_CALL_TRACE, "leaving function %s", name);
1181   g_free (stack_trace->data);
1182   stack_trace = g_slist_delete_link (stack_trace, stack_trace);
1183
1184   g_free (name);
1185 }
1186
1187 void
1188 gst_debug_print_stack_trace (void)
1189 {
1190   GSList *walk = stack_trace;
1191   gint count = 0;
1192
1193   if (walk)
1194     walk = g_slist_next (walk);
1195
1196   while (walk) {
1197     gchar *name = (gchar *) walk->data;
1198
1199     g_print ("#%-2d %s\n", count++, name);
1200
1201     walk = g_slist_next (walk);
1202   }
1203 }
1204 #else
1205 void
1206 gst_debug_print_stack_trace (void)
1207 {
1208   /* nothing because it's compiled out */
1209 }
1210
1211 #endif /* GST_ENABLE_FUNC_INTSTRUMENTATION */