git.sesse.net Git - vlc/blob - src/misc/messages.c

   1 /*****************************************************************************
   2  * messages.c: messages interface
   3  * This library provides an interface to the message queue to be used by other
   4  * modules, especially intf modules. See vlc_config.h for output configuration.
   5  *****************************************************************************
   6  * Copyright (C) 1998-2005 VLC authors and VideoLAN
   7  * $Id$
   8  *
   9  * Authors: Vincent Seguin <seguin@via.ecp.fr>
  10  *          Samuel Hocevar <sam@zoy.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU Lesser General Public License as published by
  14  * the Free Software Foundation; either version 2.1 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <stdarg.h>                                       /* va_list for BSD */
  37 #include <unistd.h>
  38 #include <assert.h>
  39
  40 #include <vlc_common.h>
  41 #include <vlc_interface.h>
  42 #include <vlc_charset.h>
  43 #include "../libvlc.h"
  44
  45 #ifdef __ANDROID__
  46 #include <android/log.h>
  47 #endif
  48
  49 struct vlc_logger_t
  50 {
  51     vlc_rwlock_t lock;
  52     vlc_log_cb log;
  53     void *sys;
  54 };
  55
  56 static void vlc_vaLogCallback(libvlc_int_t *vlc, int type,
  57                               const vlc_log_t *item, const char *format,
  58                               va_list ap)
  59 {
  60     vlc_logger_t *logger = libvlc_priv(vlc)->logger;
  61
  62     assert(logger != NULL);
  63     vlc_rwlock_rdlock(&logger->lock);
  64     logger->log(logger->sys, type, item, format, ap);
  65     vlc_rwlock_unlock(&logger->lock);
  66 }
  67
  68 static void vlc_LogCallback(libvlc_int_t *vlc, int type, const vlc_log_t *item,
  69                             const char *format, ...)
  70 {
  71     va_list ap;
  72
  73     va_start(ap, format);
  74     vlc_vaLogCallback(vlc, type, item, format, ap);
  75     va_end(ap);
  76 }
  77
  78 #ifdef _WIN32
  79 static void Win32DebugOutputMsg (void *, int , const vlc_log_t *,
  80                                  const char *, va_list);
  81 #endif
  82
  83 /**
  84  * Emit a log message. This function is the variable argument list equivalent
  85  * to vlc_Log().
  86  */
  87 void vlc_vaLog (vlc_object_t *obj, int type, const char *module,
  88                 const char *format, va_list args)
  89 {
  90     if (obj != NULL && obj->i_flags & OBJECT_FLAGS_QUIET)
  91         return;
  92
  93     /* Get basename from the module filename */
  94     char *p = strrchr(module, '/');
  95     if (p != NULL)
  96         module = p;
  97     p = strchr(module, '.');
  98
  99     size_t modlen = (p != NULL) ? (p - module) : 0;
 100     char modulebuf[modlen + 1];
 101     if (p != NULL)
 102     {
 103         memcpy(modulebuf, module, modlen);
 104         modulebuf[modlen] = '\0';
 105         module = modulebuf;
 106     }
 107
 108     /* Fill message information fields */
 109     vlc_log_t msg;
 110
 111     msg.i_object_id = (uintptr_t)obj;
 112     msg.psz_object_type = (obj != NULL) ? obj->psz_object_type : "generic";
 113     msg.psz_module = module;
 114     msg.psz_header = NULL;
 115
 116     for (vlc_object_t *o = obj; o != NULL; o = o->p_parent)
 117         if (o->psz_header != NULL)
 118         {
 119             msg.psz_header = o->psz_header;
 120             break;
 121         }
 122
 123 #ifdef _WIN32
 124     va_list ap;
 125
 126     va_copy (ap, args);
 127     Win32DebugOutputMsg (NULL, type, &msg, format, ap);
 128     va_end (ap);
 129 #endif
 130
 131     /* Pass message to the callback */
 132     if (obj != NULL)
 133         vlc_vaLogCallback(obj->p_libvlc, type, &msg, format, args);
 134 }
 135
 136 /**
 137  * Emit a log message.
 138  * \param obj VLC object emitting the message or NULL
 139  * \param type VLC_MSG_* message type (info, error, warning or debug)
 140  * \param module name of module from which the message come
 141  *               (normally MODULE_STRING)
 142  * \param format printf-like message format
 143  */
 144 void vlc_Log(vlc_object_t *obj, int type, const char *module,
 145              const char *format, ... )
 146 {
 147     va_list ap;
 148
 149     va_start(ap, format);
 150     vlc_vaLog(obj, type, module, format, ap);
 151     va_end(ap);
 152 }
 153
 154 static const char msg_type[4][9] = { "", " error", " warning", " debug" };
 155 #define COL(x,y)  "\033[" #x ";" #y "m"
 156 #define RED     COL(31,1)
 157 #define GREEN   COL(32,1)
 158 #define YELLOW  COL(0,33)
 159 #define WHITE   COL(0,1)
 160 #define GRAY    "\033[0m"
 161 static const char msg_color[4][8] = { WHITE, RED, YELLOW, GRAY };
 162
 163 /* Display size of a pointer */
 164 static const int ptr_width = 2 * /* hex digits */ sizeof(uintptr_t);
 165
 166 static void PrintColorMsg (void *d, int type, const vlc_log_t *p_item,
 167                            const char *format, va_list ap)
 168 {
 169     FILE *stream = stderr;
 170     int verbose = (intptr_t)d;
 171
 172     if (verbose < 0 || verbose < (type - VLC_MSG_ERR))
 173         return;
 174
 175     int canc = vlc_savecancel ();
 176
 177     flockfile (stream);
 178     utf8_fprintf (stream, "["GREEN"%0*"PRIxPTR""GRAY"] ", ptr_width, p_item->i_object_id);
 179     if (p_item->psz_header != NULL)
 180         utf8_fprintf (stream, "[%s] ", p_item->psz_header);
 181     utf8_fprintf (stream, "%s %s%s: %s", p_item->psz_module,
 182                   p_item->psz_object_type, msg_type[type], msg_color[type]);
 183     utf8_vfprintf (stream, format, ap);
 184     fputs (GRAY"\n", stream);
 185 #if defined (_WIN32) || defined (__OS2__)
 186     fflush (stream);
 187 #endif
 188     funlockfile (stream);
 189     vlc_restorecancel (canc);
 190 }
 191
 192 static void PrintMsg (void *d, int type, const vlc_log_t *p_item,
 193                       const char *format, va_list ap)
 194 {
 195     FILE *stream = stderr;
 196     int verbose = (intptr_t)d;
 197
 198     if (verbose < 0 || verbose < (type - VLC_MSG_ERR))
 199         return;
 200
 201     int canc = vlc_savecancel ();
 202
 203     flockfile (stream);
 204     utf8_fprintf (stream, "[%0*"PRIxPTR"] ", ptr_width, p_item->i_object_id);
 205     if (p_item->psz_header != NULL)
 206         utf8_fprintf (stream, "[%s] ", p_item->psz_header);
 207     utf8_fprintf (stream, "%s %s%s: ", p_item->psz_module,
 208                   p_item->psz_object_type, msg_type[type]);
 209     utf8_vfprintf (stream, format, ap);
 210     putc_unlocked ('\n', stream);
 211 #if defined (_WIN32) || defined (__OS2__)
 212     fflush (stream);
 213 #endif
 214     funlockfile (stream);
 215     vlc_restorecancel (canc);
 216 }
 217
 218 #ifdef _WIN32
 219 static void Win32DebugOutputMsg (void* d, int type, const vlc_log_t *p_item,
 220                                  const char *format, va_list dol)
 221 {
 222     VLC_UNUSED(p_item);
 223
 224     const signed char *pverbose = d;
 225     if (pverbose && (*pverbose < 0 || *pverbose < (type - VLC_MSG_ERR)))
 226         return;
 227
 228     va_list dol2;
 229     va_copy (dol2, dol);
 230     int msg_len = vsnprintf(NULL, 0, format, dol2);
 231     va_end (dol2);
 232
 233     if(msg_len <= 0)
 234         return;
 235
 236     char *msg = malloc(msg_len + 1 + 1);
 237     if (!msg)
 238         return;
 239
 240     msg_len = vsnprintf(msg, msg_len+1, format, dol);
 241     if (msg_len > 0){
 242         if(msg[msg_len-1] != '\n'){
 243             msg[msg_len] = '\n';
 244             msg[msg_len + 1] = '\0';
 245         }
 246         char* psz_msg = NULL;
 247         if(asprintf(&psz_msg, "%s %s%s: %s", p_item->psz_module,
 248                     p_item->psz_object_type, msg_type[type], msg) > 0) {
 249             wchar_t* wmsg = ToWide(psz_msg);
 250             OutputDebugStringW(wmsg);
 251             free(wmsg);
 252             free(psz_msg);
 253         }
 254     }
 255     free(msg);
 256 }
 257 #endif
 258
 259 #ifdef __ANDROID__
 260 static void AndroidPrintMsg (void *d, int type, const vlc_log_t *p_item,
 261                              const char *format, va_list ap)
 262 {
 263     int verbose = (intptr_t)d;
 264     int prio;
 265
 266     if (verbose < 0 || verbose < (type - VLC_MSG_ERR))
 267         return;
 268
 269     int canc = vlc_savecancel ();
 270
 271     char *format2;
 272     if (asprintf (&format2, "[%0*"PRIxPTR"] %s %s: %s",
 273                   ptr_width, p_item->i_object_id, p_item->psz_module,
 274                   p_item->psz_object_type, format) < 0)
 275         return;
 276     switch (type) {
 277         case VLC_MSG_INFO:
 278             prio = ANDROID_LOG_INFO;
 279             break;
 280         case VLC_MSG_ERR:
 281             prio = ANDROID_LOG_ERROR;
 282             break;
 283         case VLC_MSG_WARN:
 284             prio = ANDROID_LOG_WARN;
 285             break;
 286         default:
 287         case VLC_MSG_DBG:
 288             prio = ANDROID_LOG_DEBUG;
 289     }
 290     __android_log_vprint (prio, "VLC", format2, ap);
 291     free (format2);
 292     vlc_restorecancel (canc);
 293 }
 294 #endif
 295
 296 typedef struct vlc_log_early_t
 297 {
 298     struct vlc_log_early_t *next;
 299     int type;
 300     vlc_log_t meta;
 301     char *msg;
 302 } vlc_log_early_t;
 303
 304 typedef struct
 305 {
 306     vlc_mutex_t lock;
 307     vlc_log_early_t *head;
 308     vlc_log_early_t **tailp;
 309 } vlc_logger_early_t;
 310
 311 static void vlc_vaLogEarly(void *d, int type, const vlc_log_t *item,
 312                            const char *format, va_list ap)
 313 {
 314     vlc_logger_early_t *sys = d;
 315
 316     vlc_log_early_t *log = malloc(sizeof (*log));
 317     if (unlikely(log == NULL))
 318         return;
 319
 320     log->next = NULL;
 321     log->type = type;
 322     log->meta.i_object_id = item->i_object_id;
 323     /* NOTE: Object types MUST be static constant - no need to copy them. */
 324     log->meta.psz_object_type = item->psz_object_type;
 325     log->meta.psz_module = item->psz_module; /* Ditto. */
 326     log->meta.psz_header = item->psz_header ? strdup(item->psz_header) : NULL;
 327
 328     int canc = vlc_savecancel(); /* XXX: needed for vasprintf() ? */
 329     if (vasprintf(&log->msg, format, ap) == -1)
 330         log->msg = NULL;
 331     vlc_restorecancel(canc);
 332
 333     vlc_mutex_lock(&sys->lock);
 334     assert(sys->tailp != NULL);
 335     assert(*(sys->tailp) == NULL);
 336     *(sys->tailp) = log;
 337     sys->tailp = &log->next;
 338     vlc_mutex_unlock(&sys->lock);
 339 }
 340
 341 static int vlc_LogEarlyOpen(vlc_logger_t *logger)
 342 {
 343     vlc_logger_early_t *sys = malloc(sizeof (*sys));
 344
 345     if (unlikely(sys == NULL))
 346         return -1;
 347
 348     vlc_mutex_init(&sys->lock);
 349     sys->head = NULL;
 350     sys->tailp = &sys->head;
 351
 352     logger->log = vlc_vaLogEarly;
 353     logger->sys = sys;
 354     return 0;
 355 }
 356
 357 static void vlc_LogEarlyClose(libvlc_int_t *vlc, void *d)
 358 {
 359     vlc_logger_early_t *sys = d;
 360
 361     /* Drain early log messages */
 362     for (vlc_log_early_t *log = sys->head, *next; log != NULL; log = next)
 363     {
 364         vlc_LogCallback(vlc, log->type, &log->meta, "%s",
 365                         (log->msg != NULL) ? log->msg : "message lost");
 366         free(log->msg);
 367         next = log->next;
 368         free(log);
 369     }
 370
 371     vlc_mutex_destroy(&sys->lock);
 372     free(sys);
 373 }
 374
 375 static void vlc_vaLogDiscard(void *d, int type, const vlc_log_t *item,
 376                              const char *format, va_list ap)
 377 {
 378     (void) d; (void) type; (void) item; (void) format; (void) ap;
 379 }
 380
 381 /**
 382  * Performs preinitialization of the messages logging subsystem.
 383  *
 384  * Early log messages will be stored in memory until the subsystem is fully
 385  * initialized with vlc_LogInit(). This enables logging before the
 386  * configuration and modules bank are ready.
 387  *
 388  * \return 0 on success, -1 on error.
 389  */
 390 int vlc_LogPreinit(libvlc_int_t *vlc)
 391 {
 392     vlc_logger_t *logger = malloc(sizeof (*logger));
 393
 394     libvlc_priv(vlc)->logger = logger;
 395
 396     if (unlikely(logger == NULL))
 397         return -1;
 398
 399     vlc_rwlock_init(&logger->lock);
 400
 401     if (vlc_LogEarlyOpen(logger))
 402     {
 403         logger->log = vlc_vaLogDiscard;
 404         return -1;
 405     }
 406
 407     /* Announce who we are */
 408     msg_Dbg(vlc, "VLC media player - %s", VERSION_MESSAGE);
 409     msg_Dbg(vlc, "%s", COPYRIGHT_MESSAGE);
 410     msg_Dbg(vlc, "revision %s", psz_vlc_changeset);
 411     msg_Dbg(vlc, "configured with %s", CONFIGURE_LINE);
 412     return 0;
 413 }
 414
 415 /**
 416  * Initializes the messages logging subsystem and drain the early messages to
 417  * the configured log.
 418  *
 419  * \return 0 on success, -1 on error.
 420  */
 421 int vlc_LogInit(libvlc_int_t *vlc)
 422 {
 423     vlc_logger_t *logger = libvlc_priv(vlc)->logger;
 424     void *early_sys = NULL;
 425     vlc_log_cb cb = PrintMsg;
 426     signed char verbosity;
 427
 428     if (unlikely(logger == NULL))
 429         return -1;
 430
 431 #ifdef __ANDROID__
 432     cb = AndroidPrintMsg;
 433 #elif defined (HAVE_ISATTY) && !defined (_WIN32)
 434     if (isatty(STDERR_FILENO) && var_InheritBool(vlc, "color"))
 435         cb = PrintColorMsg;
 436 #endif
 437
 438     if (var_InheritBool(vlc, "quiet"))
 439         verbosity = -1;
 440     else
 441     {
 442         const char *str = getenv("VLC_VERBOSE");
 443
 444         if (str == NULL || sscanf(str, "%hhd", &verbosity) < 1)
 445             verbosity = var_InheritInteger(vlc, "verbose");
 446     }
 447
 448     vlc_rwlock_wrlock(&logger->lock);
 449
 450     if (logger->log == vlc_vaLogEarly)
 451         early_sys = logger->sys;
 452
 453     logger->log = cb;
 454     logger->sys = (void *)(intptr_t)verbosity;
 455     vlc_rwlock_unlock(&logger->lock);
 456
 457     if (early_sys != NULL)
 458         vlc_LogEarlyClose(vlc, early_sys);
 459
 460     return 0;
 461 }
 462
 463 /**
 464  * Sets the message logging callback.
 465  * \param cb message callback, or NULL to clear
 466  * \param data data pointer for the message callback
 467  */
 468 void vlc_LogSet(libvlc_int_t *vlc, vlc_log_cb cb, void *opaque)
 469 {
 470     vlc_logger_t *logger = libvlc_priv(vlc)->logger;
 471
 472     if (unlikely(logger == NULL))
 473         return;
 474
 475     if (cb == NULL)
 476         cb = vlc_vaLogDiscard;
 477
 478     vlc_rwlock_wrlock(&logger->lock);
 479     logger->log = cb;
 480     logger->sys = opaque;
 481     vlc_rwlock_unlock(&logger->lock);
 482
 483     /* Announce who we are */
 484     msg_Dbg (vlc, "VLC media player - %s", VERSION_MESSAGE);
 485     msg_Dbg (vlc, "%s", COPYRIGHT_MESSAGE);
 486     msg_Dbg (vlc, "revision %s", psz_vlc_changeset);
 487     msg_Dbg (vlc, "configured with %s", CONFIGURE_LINE);
 488 }
 489
 490 void vlc_LogDeinit(libvlc_int_t *vlc)
 491 {
 492     vlc_logger_t *logger = libvlc_priv(vlc)->logger;
 493
 494     if (unlikely(logger == NULL))
 495         return;
 496
 497     /* Flush early log messages (corner case: no call to vlc_LogInit()) */
 498     if (logger->log == vlc_vaLogEarly)
 499     {
 500         logger->log = vlc_vaLogDiscard;
 501         vlc_LogEarlyClose(vlc, logger->sys);
 502     }
 503
 504     vlc_rwlock_destroy(&logger->lock);
 505     free(logger);
 506 }