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 "gstutils.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 gint __default_level;
 125 static gint __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_MESSAGE = NULL;
 160 GstDebugCategory *GST_CAT_PARAMS = NULL;
 161 GstDebugCategory *GST_CAT_CALL_TRACE = NULL;
 162 GstDebugCategory *GST_CAT_SEEK = NULL;
 163 GstDebugCategory *GST_CAT_SIGNAL = NULL;
 164 GstDebugCategory *GST_CAT_PROBE = NULL;
 165
 166 /* FIXME: export this? */
 167 gboolean
 168 __gst_in_valgrind (void)
 169 {
 170   static enum
 171   {
 172     GST_VG_UNCHECKED,
 173     GST_VG_NO_VALGRIND,
 174     GST_VG_INSIDE
 175   }
 176   in_valgrind = GST_VG_UNCHECKED;
 177
 178   if (in_valgrind == GST_VG_UNCHECKED) {
 179 #ifdef HAVE_VALGRIND
 180     if (RUNNING_ON_VALGRIND) {
 181       GST_CAT_INFO (GST_CAT_GST_INIT, "we're running inside valgrind");
 182       VALGRIND_PRINTF
 183           ("GStreamer has detected that it is running inside valgrind.");
 184       VALGRIND_PRINTF
 185           ("It might now take different code paths to ease debugging.");
 186       VALGRIND_PRINTF ("Of course, this may also lead to different bugs.");
 187       in_valgrind = GST_VG_INSIDE;
 188     } else {
 189       GST_CAT_LOG (GST_CAT_GST_INIT, "not doing extra valgrind stuff");
 190       in_valgrind = GST_VG_NO_VALGRIND;
 191     }
 192 #else
 193     in_valgrind = GST_VG_NO_VALGRIND;
 194 #endif
 195     g_assert (in_valgrind == GST_VG_NO_VALGRIND ||
 196         in_valgrind == GST_VG_INSIDE);
 197   }
 198   return (in_valgrind == GST_VG_INSIDE) ? TRUE : FALSE;
 199 }
 200
 201 /**
 202  * _gst_debug_init:
 203  *
 204  * Initializes the debugging system.
 205  * Normally you don't want to call this, because gst_init does it for you.
 206  */
 207 void
 208 _gst_debug_init (void)
 209 {
 210   GTimeVal current;
 211
 212   gst_atomic_int_set (&__default_level, GST_LEVEL_DEFAULT);
 213   gst_atomic_int_set (&__use_color, 1);
 214
 215   /* get time we started for debugging messages */
 216   g_get_current_time (&current);
 217   start_time = GST_TIMEVAL_TO_TIME (current);
 218
 219 #ifdef HAVE_PRINTF_EXTENSION
 220   register_printf_function (GST_PTR_FORMAT[0], _gst_info_printf_extension,
 221       _gst_info_printf_extension_arginfo);
 222 #endif
 223
 224   /* do NOT use a single debug function before this line has been run */
 225   GST_CAT_DEFAULT = _gst_debug_category_new ("default",
 226       GST_DEBUG_UNDERLINE, NULL);
 227   _GST_CAT_DEBUG = _gst_debug_category_new ("GST_DEBUG",
 228       GST_DEBUG_BOLD | GST_DEBUG_FG_YELLOW, "debugging subsystem");
 229
 230   gst_debug_add_log_function (gst_debug_log_default, NULL);
 231
 232   /* FIXME: add descriptions here */
 233   GST_CAT_GST_INIT = _gst_debug_category_new ("GST_INIT",
 234       GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);
 235   GST_CAT_COTHREADS = _gst_debug_category_new ("GST_COTHREADS",
 236       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, NULL);
 237   GST_CAT_COTHREAD_SWITCH = _gst_debug_category_new ("GST_COTHREAD_SWITCH",
 238       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_GREEN, NULL);
 239   GST_CAT_AUTOPLUG = _gst_debug_category_new ("GST_AUTOPLUG",
 240       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 241   GST_CAT_AUTOPLUG_ATTEMPT = _gst_debug_category_new ("GST_AUTOPLUG_ATTEMPT",
 242       GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN | GST_DEBUG_BG_BLUE, NULL);
 243   GST_CAT_PARENTAGE = _gst_debug_category_new ("GST_PARENTAGE",
 244       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 245   GST_CAT_STATES = _gst_debug_category_new ("GST_STATES",
 246       GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);
 247   GST_CAT_PLANNING = _gst_debug_category_new ("GST_PLANNING",
 248       GST_DEBUG_BOLD | GST_DEBUG_FG_MAGENTA, NULL);
 249   GST_CAT_SCHEDULING = _gst_debug_category_new ("GST_SCHEDULING",
 250       GST_DEBUG_BOLD | GST_DEBUG_FG_MAGENTA, NULL);
 251 /* FIXME: remove GST_CAT_DATAFLOW in 0.9 */
 252   GST_CAT_DATAFLOW = _gst_debug_category_new ("GST_DATAFLOW",
 253       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "dataflow inside pads");
 254   GST_CAT_BUFFER = _gst_debug_category_new ("GST_BUFFER",
 255       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, NULL);
 256   GST_CAT_CAPS = _gst_debug_category_new ("GST_CAPS",
 257       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 258   GST_CAT_CLOCK = _gst_debug_category_new ("GST_CLOCK",
 259       GST_DEBUG_BOLD | GST_DEBUG_FG_YELLOW, NULL);
 260   GST_CAT_ELEMENT_PADS = _gst_debug_category_new ("GST_ELEMENT_PADS",
 261       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 262   GST_CAT_PADS = _gst_debug_category_new ("GST_PADS",
 263       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 264   GST_CAT_PIPELINE = _gst_debug_category_new ("GST_PIPELINE",
 265       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 266   GST_CAT_PLUGIN_LOADING = _gst_debug_category_new ("GST_PLUGIN_LOADING",
 267       GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN, NULL);
 268   GST_CAT_PLUGIN_INFO = _gst_debug_category_new ("GST_PLUGIN_INFO",
 269       GST_DEBUG_BOLD | GST_DEBUG_FG_CYAN, NULL);
 270   GST_CAT_PROPERTIES = _gst_debug_category_new ("GST_PROPERTIES",
 271       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_BLUE, NULL);
 272   GST_CAT_THREAD = _gst_debug_category_new ("GST_THREAD",
 273       GST_DEBUG_BOLD | GST_DEBUG_FG_RED, NULL);
 274   GST_CAT_TYPES = _gst_debug_category_new ("GST_TYPES",
 275       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 276   GST_CAT_XML = _gst_debug_category_new ("GST_XML",
 277       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 278   GST_CAT_NEGOTIATION = _gst_debug_category_new ("GST_NEGOTIATION",
 279       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 280   GST_CAT_REFCOUNTING = _gst_debug_category_new ("GST_REFCOUNTING",
 281       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE | GST_DEBUG_BG_GREEN, NULL);
 282   GST_CAT_ERROR_SYSTEM = _gst_debug_category_new ("GST_ERROR_SYSTEM",
 283       GST_DEBUG_BOLD | GST_DEBUG_FG_RED | GST_DEBUG_BG_WHITE, NULL);
 284
 285   GST_CAT_EVENT = _gst_debug_category_new ("GST_EVENT",
 286       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, NULL);
 287   GST_CAT_MESSAGE = _gst_debug_category_new ("GST_MESSAGE",
 288       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 289   GST_CAT_PARAMS = _gst_debug_category_new ("GST_PARAMS",
 290       GST_DEBUG_BOLD | GST_DEBUG_FG_BLACK | GST_DEBUG_BG_YELLOW, NULL);
 291   GST_CAT_CALL_TRACE = _gst_debug_category_new ("GST_CALL_TRACE",
 292       GST_DEBUG_BOLD, NULL);
 293   /* FIXME: fold back to GST_CAT_EVENT in 0.9 */
 294   GST_CAT_SEEK = _gst_debug_category_new ("GST_SEEK",
 295       GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE, "plugins reacting to seek events");
 296   GST_CAT_SIGNAL = _gst_debug_category_new ("GST_SIGNAL",
 297       GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED, NULL);
 298   GST_CAT_PROBE = _gst_debug_category_new ("GST_PROBE",
 299       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "pad probes");
 300
 301
 302   /* print out the valgrind message if we're in valgrind */
 303   __gst_in_valgrind ();
 304 }
 305
 306 /* we can't do this further above, because we initialize the GST_CAT_DEFAULT struct */
 307 #define GST_CAT_DEFAULT _GST_CAT_DEBUG
 308
 309 /**
 310  * gst_debug_log:
 311  * @category: category to log
 312  * @level: level of the message is in
 313  * @file: the file that emitted the message, usually the __FILE__ identifier
 314  * @function: the function that emitted the message
 315  * @line: the line from that the message was emitted, usually __LINE__
 316  * @object: the object this message relates to or NULL if none
 317  * @format: a printf style format string
 318  * @...: optional arguments for the format
 319  *
 320  * Logs the given message using the currently registered debugging handlers.
 321  */
 322 void
 323 gst_debug_log (GstDebugCategory * category, GstDebugLevel level,
 324     const gchar * file, const gchar * function, gint line,
 325     GObject * object, const gchar * format, ...)
 326 {
 327   va_list var_args;
 328
 329   va_start (var_args, format);
 330   gst_debug_log_valist (category, level, file, function, line, object, format,
 331       var_args);
 332   va_end (var_args);
 333 }
 334
 335 /**
 336  * gst_debug_log_valist:
 337  * @category: category to log
 338  * @level: level of the message is in
 339  * @file: the file that emitted the message, usually the __FILE__ identifier
 340  * @function: the function that emitted the message
 341  * @line: the line from that the message was emitted, usually __LINE__
 342  * @object: the object this message relates to or NULL if none
 343  * @format: a printf style format string
 344  * @args: optional arguments for the format
 345  *
 346  * Logs the given message using the currently registered debugging handlers.
 347  */
 348 void
 349 gst_debug_log_valist (GstDebugCategory * category, GstDebugLevel level,
 350     const gchar * file, const gchar * function, gint line,
 351     GObject * object, const gchar * format, va_list args)
 352 {
 353   GstDebugMessage message;
 354   LogFuncEntry *entry;
 355   GSList *handler;
 356
 357   g_return_if_fail (category != NULL);
 358   g_return_if_fail (file != NULL);
 359   g_return_if_fail (function != NULL);
 360   g_return_if_fail (format != NULL);
 361
 362   message.message = NULL;
 363   message.format = format;
 364   G_VA_COPY (message.arguments, args);
 365
 366   handler = __log_functions;
 367   while (handler) {
 368     entry = handler->data;
 369     handler = g_slist_next (handler);
 370     entry->func (category, level, file, function, line, object, &message,
 371         entry->user_data);
 372   }
 373   g_free (message.message);
 374   va_end (message.arguments);
 375 }
 376
 377 /**
 378  * gst_debug_message_get:
 379  * @message: a debug message
 380  *
 381  * Gets the string representation of a #GstDebugMessage. This function is used
 382  * in debug handlers to extract the message.
 383  *
 384  * Returns: the string representation of a #GstDebugMessage.
 385  */
 386 const gchar *
 387 gst_debug_message_get (GstDebugMessage * message)
 388 {
 389   if (message->message == NULL) {
 390     message->message = g_strdup_vprintf (message->format, message->arguments);
 391   }
 392   return message->message;
 393 }
 394
 395
 396 static gchar *
 397 gst_debug_print_object (gpointer ptr)
 398 {
 399   GObject *object = (GObject *) ptr;
 400
 401 #ifdef unused
 402   /* This is a cute trick to detect unmapped memory, but is unportable,
 403    * slow, screws around with madvise, and not actually that useful. */
 404   {
 405     int ret;
 406
 407     ret = madvise ((void *) ((unsigned long) ptr & (~0xfff)), 4096, 0);
 408     if (ret == -1 && errno == ENOMEM) {
 409       buffer = g_strdup_printf ("%p (unmapped memory)", ptr);
 410     }
 411   }
 412 #endif
 413
 414   /* nicely printed object */
 415   if (object == NULL) {
 416     return g_strdup ("(NULL)");
 417   }
 418   if (*(GType *) ptr == GST_TYPE_CAPS) {
 419     return gst_caps_to_string ((GstCaps *) ptr);
 420   }
 421   if (*(GType *) ptr == GST_TYPE_STRUCTURE) {
 422     return gst_structure_to_string ((GstStructure *) ptr);
 423   }
 424 #ifdef USE_POISONING
 425   if (*(guint32 *) ptr == 0xffffffff) {
 426     return g_strdup_printf ("<poisoned@%p>", ptr);
 427   }
 428 #endif
 429   if (GST_IS_PAD (object) && GST_OBJECT_NAME (object)) {
 430     return g_strdup_printf ("<%s:%s>", GST_DEBUG_PAD_NAME (object));
 431   }
 432   if (GST_IS_OBJECT (object) && GST_OBJECT_NAME (object)) {
 433     return g_strdup_printf ("<%s>", GST_OBJECT_NAME (object));
 434   }
 435   if (G_IS_OBJECT (object)) {
 436     return g_strdup_printf ("<%s@%p>", G_OBJECT_TYPE_NAME (object), object);
 437   }
 438
 439   return g_strdup_printf ("%p", ptr);
 440 }
 441
 442 /**
 443  * gst_debug_construct_term_color:
 444  * @colorinfo: the color info
 445  *
 446  * Constructs a string that can be used for getting the desired color in color
 447  * terminals.
 448  * You need to free the string after use.
 449  *
 450  * Returns: a string containing the color definition
 451  */
 452 gchar *
 453 gst_debug_construct_term_color (guint colorinfo)
 454 {
 455   GString *color;
 456   gchar *ret;
 457
 458   color = g_string_new ("\033[00");
 459
 460   if (colorinfo & GST_DEBUG_BOLD) {
 461     g_string_append (color, ";01");
 462   }
 463   if (colorinfo & GST_DEBUG_UNDERLINE) {
 464     g_string_append (color, ";04");
 465   }
 466   if (colorinfo & GST_DEBUG_FG_MASK) {
 467     g_string_append_printf (color, ";3%1d", colorinfo & GST_DEBUG_FG_MASK);
 468   }
 469   if (colorinfo & GST_DEBUG_BG_MASK) {
 470     g_string_append_printf (color, ";4%1d",
 471         (colorinfo & GST_DEBUG_BG_MASK) >> 4);
 472   }
 473   g_string_append (color, "m");
 474
 475   ret = color->str;
 476   g_string_free (color, FALSE);
 477   return ret;
 478 }
 479
 480 /**
 481  * gst_debug_log_default:
 482  * @category: category to log
 483  * @level: level of the message
 484  * @file: the file that emitted the message, usually the __FILE__ identifier
 485  * @function: the function that emitted the message
 486  * @line: the line from that the message was emitted, usually __LINE__
 487  * @message: the actual message
 488  * @object: the object this message relates to or NULL if none
 489  * @unused: an unused variable, reserved for some user_data.
 490  *
 491  * The default logging handler used by GStreamer. Logging functions get called
 492  * whenever a macro like GST_DEBUG or similar is used. This function outputs the
 493  * message and additional info using the glib error handler.
 494  * You can add other handlers by using #gst_debug_add_log_function.
 495  * And you can remove this handler by calling
 496  * gst_debug_remove_log_function (gst_debug_log_default);
 497  */
 498 void
 499 gst_debug_log_default (GstDebugCategory * category, GstDebugLevel level,
 500     const gchar * file, const gchar * function, gint line,
 501     GObject * object, GstDebugMessage * message, gpointer unused)
 502 {
 503   gchar *color;
 504   gchar *clear;
 505   gchar *obj;
 506   gchar *pidcolor;
 507   gint pid;
 508   GTimeVal now;
 509   GstClockTime elapsed;
 510
 511   if (level > gst_debug_category_get_threshold (category))
 512     return;
 513
 514   pid = getpid ();
 515
 516   /* color info */
 517   if (gst_debug_is_colored ()) {
 518     color =
 519         gst_debug_construct_term_color (gst_debug_category_get_color
 520         (category));
 521     clear = "\033[00m";
 522     pidcolor = g_strdup_printf ("\033[3%1dm", pid % 6 + 31);
 523   } else {
 524     color = g_strdup ("");
 525     clear = "";
 526     pidcolor = g_strdup ("");
 527   }
 528
 529   obj = object ? gst_debug_print_object (object) : g_strdup ("");
 530
 531   g_get_current_time (&now);
 532   elapsed = GST_TIMEVAL_TO_TIME (now) - start_time;
 533   g_printerr ("%s (%p - %" GST_TIME_FORMAT
 534       ") %s%15s%s(%s%5d%s) %s%s(%d):%s:%s%s %s\n",
 535       gst_debug_level_get_name (level), g_thread_self (),
 536       GST_TIME_ARGS (elapsed), color,
 537       gst_debug_category_get_name (category), clear, pidcolor, pid, clear,
 538       color, file, line, function, obj, clear, gst_debug_message_get (message));
 539
 540   g_free (color);
 541   g_free (pidcolor);
 542   g_free (obj);
 543 }
 544
 545 /**
 546  * gst_debug_level_get_name:
 547  * @level: the level to get the name for
 548  *
 549  * Get the string trepresentation of a debugging level
 550  *
 551  * Returns: the name
 552  */
 553 const gchar *
 554 gst_debug_level_get_name (GstDebugLevel level)
 555 {
 556   switch (level) {
 557     case GST_LEVEL_NONE:
 558       return "";
 559     case GST_LEVEL_ERROR:
 560       return "ERROR";
 561     case GST_LEVEL_WARNING:
 562       return "WARN ";
 563     case GST_LEVEL_INFO:
 564       return "INFO ";
 565     case GST_LEVEL_DEBUG:
 566       return "DEBUG";
 567     case GST_LEVEL_LOG:
 568       return "LOG  ";
 569     default:
 570       g_warning ("invalid level specified for gst_debug_level_get_name");
 571       return "";
 572   }
 573 }
 574
 575 /**
 576  * gst_debug_add_log_function:
 577  * @func: the function to use
 578  * @data: user data
 579  *
 580  * Adds the logging function to the list of logging functions.
 581  * Be sure to use G_GNUC_NO_INSTRUMENT on that function, it is needed.
 582  */
 583 void
 584 gst_debug_add_log_function (GstLogFunction func, gpointer data)
 585 {
 586   LogFuncEntry *entry;
 587   GSList *list;
 588
 589   g_return_if_fail (func != NULL);
 590
 591   entry = g_new (LogFuncEntry, 1);
 592   entry->func = func;
 593   entry->user_data = data;
 594   /* FIXME: we leak the old list here - other threads might access it right now
 595    * in gst_debug_logv. Another solution is to lock the mutex in gst_debug_logv,
 596    * but that is waaay costly.
 597    * It'd probably be clever to use some kind of RCU here, but I don't know
 598    * anything about that.
 599    */
 600   g_static_mutex_lock (&__log_func_mutex);
 601   list = g_slist_copy (__log_functions);
 602   __log_functions = g_slist_prepend (list, entry);
 603   g_static_mutex_unlock (&__log_func_mutex);
 604
 605   GST_DEBUG ("prepended log function %p (user data %p) to log functions",
 606       func, data);
 607 }
 608
 609 static gint
 610 gst_debug_compare_log_function_by_func (gconstpointer entry, gconstpointer func)
 611 {
 612   gpointer entryfunc = ((LogFuncEntry *) entry)->func;
 613
 614   return (entryfunc < func) ? -1 : (entryfunc > func) ? 1 : 0;
 615 }
 616
 617 static gint
 618 gst_debug_compare_log_function_by_data (gconstpointer entry, gconstpointer data)
 619 {
 620   gpointer entrydata = ((LogFuncEntry *) entry)->user_data;
 621
 622   return (entrydata < data) ? -1 : (entrydata > data) ? 1 : 0;
 623 }
 624
 625 static guint
 626 gst_debug_remove_with_compare_func (GCompareFunc func, gpointer data)
 627 {
 628   GSList *found;
 629   GSList *new;
 630   guint removals = 0;
 631
 632   g_static_mutex_lock (&__log_func_mutex);
 633   new = __log_functions;
 634   while ((found = g_slist_find_custom (new, data, func))) {
 635     if (new == __log_functions) {
 636       new = g_slist_copy (new);
 637       continue;
 638     }
 639     g_free (found->data);
 640     new = g_slist_delete_link (new, found);
 641     removals++;
 642   }
 643   /* FIXME: We leak the old list here. See _add_log_function for why. */
 644   __log_functions = new;
 645   g_static_mutex_unlock (&__log_func_mutex);
 646
 647   return removals;
 648 }
 649
 650 /**
 651  * gst_debug_remove_log_function:
 652  * @func: the log function to remove
 653  *
 654  * Removes all registrered instances of the given logging functions.
 655  *
 656  * Returns: How many instances of the function were removed
 657  */
 658 guint
 659 gst_debug_remove_log_function (GstLogFunction func)
 660 {
 661   guint removals;
 662
 663   g_return_val_if_fail (func != NULL, 0);
 664
 665   removals =
 666       gst_debug_remove_with_compare_func
 667       (gst_debug_compare_log_function_by_func, func);
 668   GST_DEBUG ("removed log function %p %d times from log function list", func,
 669       removals);
 670
 671   return removals;
 672 }
 673
 674 /**
 675  * gst_debug_remove_log_function_by_data:
 676  * @data: user data of the log function to remove
 677  *
 678  * Removes all registrered instances of log functions with the given user data.
 679  *
 680  * Returns: How many instances of the function were removed
 681  */
 682 guint
 683 gst_debug_remove_log_function_by_data (gpointer data)
 684 {
 685   guint removals;
 686
 687   removals =
 688       gst_debug_remove_with_compare_func
 689       (gst_debug_compare_log_function_by_data, data);
 690   GST_DEBUG
 691       ("removed %d log functions with user data %p from log function list",
 692       removals, data);
 693
 694   return removals;
 695 }
 696
 697 /**
 698  * gst_debug_set_colored:
 699  * @colored: Whether to use colored output or not
 700  *
 701  * Sets or unsets the use of coloured debugging output.
 702  */
 703 void
 704 gst_debug_set_colored (gboolean colored)
 705 {
 706   gst_atomic_int_set (&__use_color, colored ? 1 : 0);
 707 }
 708
 709 /**
 710  * gst_debug_is_colored:
 711  *
 712  * Checks if the debugging output should be colored.
 713  *
 714  * Returns: TRUE, if the debug output should be colored.
 715  */
 716 gboolean
 717 gst_debug_is_colored (void)
 718 {
 719   return g_atomic_int_get (&__use_color) == 0 ? FALSE : TRUE;
 720 }
 721
 722 /**
 723  * gst_debug_set_active:
 724  * @active: Whether to use debugging output or not
 725  *
 726  * If activated, debugging messages are sent to the debugging
 727  * handlers.
 728  * It makes sense to deactivate it for speed issues.
 729  * <note><para>This function is not threadsafe. It makes sense to only call it
 730  * during initialization.</para></note>
 731  */
 732 void
 733 gst_debug_set_active (gboolean active)
 734 {
 735   __gst_debug_enabled = active;
 736 }
 737
 738 /**
 739  * gst_debug_is_active:
 740  *
 741  * Checks if debugging output is activated.
 742  *
 743  * Returns: TRUE, if debugging is activated
 744  */
 745 gboolean
 746 gst_debug_is_active (void)
 747 {
 748   return __gst_debug_enabled;
 749 }
 750
 751 /**
 752  * gst_debug_set_default_threshold:
 753  * @level: level to set
 754  *
 755  * Sets the default threshold to the given level and updates all categories to
 756  * use this threshold.
 757  */
 758 void
 759 gst_debug_set_default_threshold (GstDebugLevel level)
 760 {
 761   gst_atomic_int_set (&__default_level, level);
 762   gst_debug_reset_all_thresholds ();
 763 }
 764
 765 /**
 766  * gst_debug_get_default_threshold:
 767  *
 768  * Returns the default threshold that is used for new categories.
 769  *
 770  * Returns: the default threshold level
 771  */
 772 GstDebugLevel
 773 gst_debug_get_default_threshold (void)
 774 {
 775   return (GstDebugLevel) g_atomic_int_get (&__default_level);
 776 }
 777 static void
 778 gst_debug_reset_threshold (gpointer category, gpointer unused)
 779 {
 780   GstDebugCategory *cat = (GstDebugCategory *) category;
 781   GSList *walk;
 782
 783   g_static_mutex_lock (&__level_name_mutex);
 784   walk = __level_name;
 785   while (walk) {
 786     LevelNameEntry *entry = walk->data;
 787
 788     walk = g_slist_next (walk);
 789     if (g_pattern_match_string (entry->pat, cat->name)) {
 790       GST_LOG ("category %s matches pattern %p - gets set to level %d",
 791           cat->name, entry->pat, entry->level);
 792       gst_debug_category_set_threshold (cat, entry->level);
 793       goto exit;
 794     }
 795   }
 796   gst_debug_category_set_threshold (cat, gst_debug_get_default_threshold ());
 797
 798 exit:
 799   g_static_mutex_unlock (&__level_name_mutex);
 800 }
 801 static void
 802 gst_debug_reset_all_thresholds (void)
 803 {
 804   g_static_mutex_lock (&__cat_mutex);
 805   g_slist_foreach (__categories, gst_debug_reset_threshold, NULL);
 806   g_static_mutex_unlock (&__cat_mutex);
 807 }
 808 static void
 809 for_each_threshold_by_entry (gpointer data, gpointer user_data)
 810 {
 811   GstDebugCategory *cat = (GstDebugCategory *) data;
 812   LevelNameEntry *entry = (LevelNameEntry *) user_data;
 813
 814   if (g_pattern_match_string (entry->pat, cat->name)) {
 815     GST_LOG ("category %s matches pattern %p - gets set to level %d",
 816         cat->name, entry->pat, entry->level);
 817     gst_debug_category_set_threshold (cat, entry->level);
 818   }
 819 }
 820
 821 /**
 822  * gst_debug_set_threshold_for_name:
 823  * @name: name of the categories to set
 824  * @level: level to set them to
 825  *
 826  * Sets all categories which match the given glob style pattern to the given
 827  * level.
 828  */
 829 void
 830 gst_debug_set_threshold_for_name (const gchar * name, GstDebugLevel level)
 831 {
 832   GPatternSpec *pat;
 833   LevelNameEntry *entry;
 834
 835   g_return_if_fail (name != NULL);
 836
 837   pat = g_pattern_spec_new (name);
 838   entry = g_new (LevelNameEntry, 1);
 839   entry->pat = pat;
 840   entry->level = level;
 841   g_static_mutex_lock (&__level_name_mutex);
 842   __level_name = g_slist_prepend (__level_name, entry);
 843   g_static_mutex_unlock (&__level_name_mutex);
 844   g_static_mutex_lock (&__cat_mutex);
 845   g_slist_foreach (__categories, for_each_threshold_by_entry, entry);
 846   g_static_mutex_unlock (&__cat_mutex);
 847 }
 848
 849 /**
 850  * gst_debug_unset_threshold_for_name:
 851  * @name: name of the categories to set
 852  *
 853  * Resets all categories with the given name back to the default level.
 854  */
 855 void
 856 gst_debug_unset_threshold_for_name (const gchar * name)
 857 {
 858   GSList *walk;
 859   GPatternSpec *pat;
 860
 861   g_return_if_fail (name != NULL);
 862
 863   pat = g_pattern_spec_new (name);
 864   g_static_mutex_lock (&__level_name_mutex);
 865   walk = __level_name;
 866   /* improve this if you want, it's mighty slow */
 867   while (walk) {
 868     LevelNameEntry *entry = walk->data;
 869
 870     if (g_pattern_spec_equal (entry->pat, pat)) {
 871       __level_name = g_slist_remove_link (__level_name, walk);
 872       g_pattern_spec_free (entry->pat);
 873       g_free (entry);
 874       g_slist_free_1 (walk);
 875       walk = __level_name;
 876     }
 877   }
 878   g_static_mutex_unlock (&__level_name_mutex);
 879   g_pattern_spec_free (pat);
 880   gst_debug_reset_all_thresholds ();
 881 }
 882
 883 GstDebugCategory *
 884 _gst_debug_category_new (gchar * name, guint color, gchar * description)
 885 {
 886   GstDebugCategory *cat;
 887
 888   g_return_val_if_fail (name != NULL, NULL);
 889
 890   cat = g_new (GstDebugCategory, 1);
 891   cat->name = g_strdup (name);
 892   cat->color = color;
 893   if (description != NULL) {
 894     cat->description = g_strdup (description);
 895   } else {
 896     cat->description = g_strdup ("no description");
 897   }
 898   gst_atomic_int_set (&cat->threshold, 0);
 899   gst_debug_reset_threshold (cat, NULL);
 900
 901   /* add to category list */
 902   g_static_mutex_lock (&__cat_mutex);
 903   __categories = g_slist_prepend (__categories, cat);
 904   g_static_mutex_unlock (&__cat_mutex);
 905
 906   return cat;
 907 }
 908
 909 /**
 910  * gst_debug_category_free:
 911  * @category: #GstDebugCategory to free.
 912  *
 913  * Removes and frees the category and all associated resources.
 914  */
 915 void
 916 gst_debug_category_free (GstDebugCategory * category)
 917 {
 918   if (category == NULL)
 919     return;
 920
 921   /* remove from category list */
 922   g_static_mutex_lock (&__cat_mutex);
 923   __categories = g_slist_remove (__categories, category);
 924   g_static_mutex_unlock (&__cat_mutex);
 925
 926   g_free ((gpointer) category->name);
 927   g_free ((gpointer) category->description);
 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 g_atomic_int_get (&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 */