-/*******************************************************************************
+/*****************************************************************************
* intf_msg.c: messages interface
- * (c)1998 VideoLAN
- *******************************************************************************
* This library provides basic functions for threads to interact with user
* interface, such as message output. See config.h for output configuration.
- *******************************************************************************/
+ *****************************************************************************
+ * Copyright (C) 1998, 1999, 2000 VideoLAN
+ * $Id: intf_msg.c,v 1.36 2001/06/02 01:09:03 sam Exp $
+ *
+ * Authors: Vincent Seguin <seguin@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ *****************************************************************************/
-/*******************************************************************************
+/*****************************************************************************
* Preamble
- *******************************************************************************/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
+ *****************************************************************************/
+#include "defs.h"
+
+#include <errno.h> /* errno */
+#include <fcntl.h> /* O_CREAT, O_TRUNC, O_WRONLY, O_SYNC */
+#include <stdio.h> /* required */
+#include <stdarg.h> /* va_list for BSD */
+#include <stdlib.h> /* malloc() */
+#include <string.h> /* strerror() */
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h> /* close(), write() */
+#endif
#include "config.h"
#include "common.h"
+#include "threads.h"
#include "mtime.h"
-#include "vlc_thread.h"
+
#include "intf_msg.h"
#include "interface.h"
-#include "intf_console.h"
+
#include "main.h"
-/*******************************************************************************
- * intf_msg_item_t
- *******************************************************************************
+#ifdef WIN32
+#ifndef snprintf
+#define snprintf _snprintf /* snprintf not defined in mingw32 (bug?) */
+#endif
+#endif
+
+/*****************************************************************************
+ * intf_msg_item_t
+ *****************************************************************************
* Store a single message. Messages have a maximal size of INTF_MSG_MSGSIZE.
- * If DEBUG is defined, messages have a date field and debug messages are
+ * If TRACE is defined, messages have a date field and debug messages are
* printed with a date to allow more precise profiling.
- *******************************************************************************/
+ *****************************************************************************/
typedef struct
{
- int i_type; /* message type, see below */
- char * psz_msg; /* the message itself */
+ int i_type; /* message type, see below */
+ char * psz_msg; /* the message itself */
-#ifdef DEBUG
- /* Debugging informations - in DEBUG mode, debug messages have calling
+#ifdef TRACE
+ /* Debugging informations - in TRACE mode, debug messages have calling
* location informations printed */
- mtime_t date; /* date of the message */
- char * psz_file; /* file in which the function was called */
- char * psz_function; /* function from which the function was called */
- int i_line; /* line at which the function was called */
+ mtime_t date; /* date of the message */
+ char * psz_file; /* file in which the function was called */
+ char * psz_function; /* function from which the function was called */
+ int i_line; /* line at which the function was called */
#endif
} intf_msg_item_t;
/* Message types */
-#define INTF_MSG_STD 0 /* standard message */
-#define INTF_MSG_ERR 1 /* error message */
-#define INTF_MSG_INTF 2 /* interface message */
-#define INTF_MSG_DBG 3 /* debug message */
-
-/*******************************************************************************
- * intf_msg_t
- *******************************************************************************
+#define INTF_MSG_STD 0 /* standard message */
+#define INTF_MSG_ERR 1 /* error message */
+#define INTF_MSG_DBG 3 /* debug message */
+#define INTF_MSG_WARN 4 /* warning message*/
+
+
+/*****************************************************************************
+ * intf_msg_t
+ *****************************************************************************
* Store all data requiered by messages interfaces. It has a single reference
* int p_main.
- *******************************************************************************/
+ *****************************************************************************/
typedef struct intf_msg_s
{
#ifdef INTF_MSG_QUEUE
/* Message queue */
- vlc_mutex_t lock; /* message queue lock */
- int i_count; /* number of messages stored */
- intf_msg_item_t msg[INTF_MSG_QSIZE]; /* message queue */
+ vlc_mutex_t lock; /* message queue lock */
+ int i_count; /* number of messages stored */
+ intf_msg_item_t msg[INTF_MSG_QSIZE]; /* message queue */
#endif
-#ifdef DEBUG_LOG
+#ifdef TRACE_LOG
/* Log file */
- int i_log_file; /* log file */
+ FILE * p_log_file; /* log file */
#endif
-#if !defined(INTF_MSG_QUEUE) && !defined(DEBUG_LOG)
+#if !defined(INTF_MSG_QUEUE) && !defined(TRACE_LOG)
/* If neither messages queue, neither log file is used, then the structure
* is empty. However, empty structures are not allowed in C. Therefore, a
* dummy integer is used to fill it. */
- int i_dummy; /* unused filler */
+ int i_dummy; /* unused filler */
#endif
} intf_msg_t;
* Local prototypes
*****************************************************************************/
-static void QueueMsg ( intf_msg_t *p_msg, int i_type,
- char *psz_format, va_list ap );
+static void QueueMsg ( intf_msg_t *p_msg, int i_type,
+ char *psz_format, va_list ap );
static void PrintMsg ( intf_msg_item_t *p_msg );
-#ifdef DEBUG
-static void QueueDbgMsg ( intf_msg_t *p_msg, char *psz_file,
- char *psz_function, int i_line,
+#ifdef TRACE
+static void QueueDbgMsg ( intf_msg_t *p_msg, char *psz_file,
+ char *psz_function, int i_line,
char *psz_format, va_list ap );
#endif
#ifdef INTF_MSG_QUEUE
#endif
-/*******************************************************************************
- * intf_MsgCreate: initialize messages interface (ok ?)
- *******************************************************************************
+/*****************************************************************************
+ * intf_MsgCreate: initialize messages interface (ok ?)
+ *****************************************************************************
* This functions has to be called before any call to other intf_*Msg functions.
* It set up the locks and the message queue if it is used.
- *******************************************************************************/
+ *****************************************************************************/
p_intf_msg_t intf_MsgCreate( void )
{
p_intf_msg_t p_msg;
/* Allocate structure */
- p_msg = malloc( sizeof( intf_msg_t ) );
+ p_msg = malloc( sizeof( intf_msg_t ) );
if( p_msg == NULL )
{
- errno = ENOMEM;
+ errno = ENOMEM;
}
else
{
#ifdef INTF_MSG_QUEUE
/* Message queue initialization */
- vlc_mutex_init( &p_intf_msg->lock ); /* intialize lock */
- p_intf_msg->i_count = 0; /* queue is empty */
+ vlc_mutex_init( &p_msg->lock ); /* intialize lock */
+ p_msg->i_count = 0; /* queue is empty */
#endif
-#ifdef DEBUG_LOG
- /* Log file initialization - on failure, file pointer will be null,
- * and no log will be issued, but this is not considered as an
- * error */
- p_msg->i_log_file = open( DEBUG_LOG,
- O_CREAT | O_APPEND | O_SYNC | O_WRONLY,
- 0777 );
+
+#ifdef TRACE_LOG
+ /* Log file initialization - on failure, file pointer will be null,
+ * and no log will be issued, but this is not considered as an
+ * error */
+ p_msg->p_log_file = fopen( TRACE_LOG, "w" );
#endif
}
return( p_msg );
}
-/*******************************************************************************
+/*****************************************************************************
* intf_MsgDestroy: free resources allocated by intf_InitMsg (ok ?)
- *******************************************************************************
- * This functions prints all messages remaining in queue, then free all the
+ *****************************************************************************
+ * This functions prints all messages remaining in queue, then free all the
* resources allocated by intf_InitMsg.
* No other messages interface functions should be called after this one.
- *******************************************************************************/
+ *****************************************************************************/
void intf_MsgDestroy( void )
{
- intf_FlushMsg(); /* print all remaining messages */
+ intf_FlushMsg(); /* print all remaining messages */
-#ifdef DEBUG_LOG
+#ifdef TRACE_LOG
/* Close log file if any */
- if( p_main->p_msg->i_log_file >= 0 )
+ if( p_main->p_msg->p_log_file != NULL )
{
- close( p_main->p_msg->i_log_file );
+ fclose( p_main->p_msg->p_log_file );
}
#endif
+#ifdef INTF_MSG_QUEUE
+ /* destroy lock */
+ vlc_mutex_destroy( &p_main->p_msg->lock );
+#endif
+
/* Free structure */
free( p_main->p_msg );
}
-/*******************************************************************************
- * intf_Msg: print a message (ok ?)
- *******************************************************************************
+/*****************************************************************************
+ * intf_Msg: print a message (ok ?)
+ *****************************************************************************
* This function queue a message for later printing, or print it immediately
* if the queue isn't used.
- *******************************************************************************/
+ *****************************************************************************/
void intf_Msg( char *psz_format, ... )
{
va_list ap;
QueueMsg( p_main->p_msg, INTF_MSG_STD, psz_format, ap );
va_end( ap );
}
-
-/*******************************************************************************
- * intf_ErrMsg : print an error message (ok ?)
- *******************************************************************************
+
+/*****************************************************************************
+ * intf_ErrMsg : print an error message (ok ?)
+ *****************************************************************************
* This function is the same as intf_Msg, except that it prints its messages
* on stderr.
- *******************************************************************************/
-void intf_ErrMsg( char *psz_format, ...)
+ *****************************************************************************/
+void intf_ErrMsg( char *psz_format, ... )
{
va_list ap;
va_end( ap );
}
-/*******************************************************************************
- * intf_IntfMsg : print an interface message (ok ?)
- *******************************************************************************
- * In opposition to all other intf_*Msg function, this function does not print
- * it's message on default terminal (stdout or stderr), but send it to
- * interface (in fact to the X11 console). This means that the interface MUST
- * be initialized and a X11 console openned before this function is used, and
- * that once the console is closed, this call is vorbidden.
- * Practically, only the interface thread itself should call this function, and
- * flush all messages before intf_CloseX11Console() is called.
- *******************************************************************************/
-void intf_IntfMsg(char *psz_format, ...)
+/*****************************************************************************
+ * intf_WarnMsg : print a warning message
+ *****************************************************************************
+ * This function is the same as intf_Msg, except that it concerns warning
+ * messages for testing purpose.
+ *****************************************************************************/
+void intf_WarnMsg( int i_level, char *psz_format, ... )
{
va_list ap;
-
- va_start( ap, psz_format );
- QueueMsg( p_main->p_msg, INTF_MSG_INTF, psz_format, ap );
- va_end( ap );
+
+ if( i_level <= p_main->i_warning_level )
+ {
+ va_start( ap, psz_format );
+ QueueMsg( p_main->p_msg, INTF_MSG_WARN, psz_format, ap );
+ va_end( ap );
+ }
}
-/*******************************************************************************
- * _intf_DbgMsg: print a debugging message (ok ?)
- *******************************************************************************
- * This function prints a debugging message. Compared to other intf_*Msg
- * functions, it is only defined if DEBUG is defined and require a file name,
+
+/*****************************************************************************
+ * _intf_DbgMsg: print a debugging message (ok ?)
+ *****************************************************************************
+ * This function prints a debugging message. Compared to other intf_*Msg
+ * functions, it is only defined if TRACE is defined and require a file name,
* a function name and a line number as additionnal debugging informations. It
* also prints a debugging header for each received line.
- *******************************************************************************/
-#ifdef DEBUG
-void _intf_DbgMsg( char *psz_file, char *psz_function, int i_line,
+ *****************************************************************************/
+#ifdef TRACE
+void _intf_DbgMsg( char *psz_file, char *psz_function, int i_line,
char *psz_format, ...)
{
va_list ap;
va_start( ap, psz_format );
- QueueDbgMsg( p_main->p_msg, psz_file, psz_function, i_line,
+ QueueDbgMsg( p_main->p_msg, psz_file, psz_function, i_line,
psz_format, ap );
va_end( ap );
}
#endif
-/*******************************************************************************
- * intf_ErrMsgImm: print a message (ok ?)
- *******************************************************************************
- * This function prints a message immediately. If the queue is used, all
+/*****************************************************************************
+ * intf_MsgImm: print a message (ok ?)
+ *****************************************************************************
+ * This function prints a message immediately. If the queue is used, all
* waiting messages are also printed.
- *******************************************************************************/
+ *****************************************************************************/
void intf_MsgImm( char *psz_format, ... )
{
va_list ap;
va_end( ap );
intf_FlushMsg();
}
-
-/*******************************************************************************
- * intf_ErrMsgImm: print an error message immediately (ok ?)
- *******************************************************************************
+
+/*****************************************************************************
+ * intf_ErrMsgImm: print an error message immediately (ok ?)
+ *****************************************************************************
* This function is the same as intf_MsgImm, except that it prints its message
* on stderr.
- *******************************************************************************/
+ *****************************************************************************/
void intf_ErrMsgImm(char *psz_format, ...)
{
va_list ap;
intf_FlushMsg();
}
-/*******************************************************************************
- * _intf_DbgMsgImm: print a debugging message immediately (ok ?)
- *******************************************************************************
+/*****************************************************************************
+ * intf_WarnMsgImm : print a warning message
+ *****************************************************************************
+ * This function is the same as intf_MsgImm, except that it concerns warning
+ * messages for testing purpose.
+ *****************************************************************************/
+void intf_WarnMsgImm( int i_level, char *psz_format, ... )
+{
+ va_list ap;
+
+ if( i_level <= p_main->i_warning_level )
+ {
+ va_start( ap, psz_format );
+ QueueMsg( p_main->p_msg, INTF_MSG_WARN, psz_format, ap );
+ va_end( ap );
+ }
+ intf_FlushMsg();
+}
+
+
+
+/*****************************************************************************
+ * _intf_DbgMsgImm: print a debugging message immediately (ok ?)
+ *****************************************************************************
* This function is the same as intf_DbgMsgImm, except that it prints its
- * message immediately. It should only be called through the macro
+ * message immediately. It should only be called through the macro
* intf_DbgMsgImm().
- *******************************************************************************/
-#ifdef DEBUG
-void _intf_DbgMsgImm( char *psz_file, char *psz_function, int i_line,
+ *****************************************************************************/
+#ifdef TRACE
+void _intf_DbgMsgImm( char *psz_file, char *psz_function, int i_line,
char *psz_format, ...)
{
va_list ap;
va_start( ap, psz_format );
- QueueDbgMsg( p_main->p_msg, psz_file, psz_function, i_line,
+ QueueDbgMsg( p_main->p_msg, psz_file, psz_function, i_line,
psz_format, ap );
va_end( ap );
intf_FlushMsg();
}
#endif
-/*******************************************************************************
- * intf_FlushMsg (ok ?)
- *******************************************************************************
+/*****************************************************************************
+ * intf_WarnHexDump : print a hexadecimal dump of a memory area
+ *****************************************************************************
+ * This is convenient for debugging purposes.
+ *****************************************************************************/
+void intf_WarnHexDump( int i_level, void *p_data, int i_size )
+{
+ int i_index = 0;
+ int i_subindex;
+ char p_string[75];
+ u8 *p_area = (u8 *)p_data;
+
+ intf_WarnMsg( i_level, "hexdump: dumping %i bytes at address %p",
+ i_size, p_data );
+
+ while( i_index < i_size )
+ {
+ i_subindex = 0;
+
+ while( ( i_subindex < 24 ) && ( i_index + i_subindex < i_size ) )
+ {
+ sprintf( p_string + 3 * i_subindex, "%.2x ",
+ p_area[ i_index + i_subindex ] );
+
+ i_subindex++;
+ }
+
+ /* -1 here is safe because we know we printed at least one */
+ p_string[ 3 * i_subindex - 1 ] = '\0';
+ intf_WarnMsg( i_level, "0x%.4x: %s", i_index, p_string );
+
+ i_index += 24;
+ }
+
+ intf_WarnMsg( i_level, "hexdump: %i bytes dumped", i_size );
+}
+
+/*****************************************************************************
+ * intf_FlushMsg (ok ?)
+ *****************************************************************************
* Print all messages remaining in queue: get lock and call FlushLockedMsg.
* This function does nothing if the message queue isn't used.
- * This function is only implemented if message queue is used. If not, it is an
- * empty macro.
- *******************************************************************************/
+ * This function is only implemented if message queue is used. If not, it is
+ * an empty macro.
+ *****************************************************************************/
#ifdef INTF_MSG_QUEUE
void intf_FlushMsg( void )
{
- vlc_mutex_lock( &p_program_data->intf_msg.lock ); /* get lock */
- FlushLockedMsg( &p_program_data->intf_msg ); /* flush messages */
- vlc_mutex_unlock( &p_program_data->intf_msg.lock ); /* give lock back */
+ vlc_mutex_lock( &p_main->p_msg->lock ); /* get lock */
+ FlushLockedMsg( p_main->p_msg ); /* flush messages */
+ vlc_mutex_unlock( &p_main->p_msg->lock ); /* give lock back */
}
#endif
/* following functions are local */
-/*******************************************************************************
+/*****************************************************************************
* QueueMsg: add a message to a queue
- *******************************************************************************
+ *****************************************************************************
* This function provide basic functionnalities to other intf_*Msg functions.
* It add a message to a queue (after having printed all stored messages if it
- * is full. If the message can't be converted to string in memory, it exit the
+ * is full. If the message can't be converted to string in memory, it exit the
* program. If the queue is not used, it prints the message immediately.
- *******************************************************************************/
+ *****************************************************************************/
static void QueueMsg( intf_msg_t *p_msg, int i_type, char *psz_format, va_list ap )
{
- char * psz_str; /* formatted message string */
- intf_msg_item_t * p_msg_item; /* pointer to message */
+ char * psz_str; /* formatted message string */
+ intf_msg_item_t * p_msg_item; /* pointer to message */
-#ifndef INTF_MSG_QUEUE /*..................................... instant mode ...*/
- intf_msg_item_t msg_item; /* message */
+#ifndef INTF_MSG_QUEUE /*................................... instant mode ...*/
+ intf_msg_item_t msg_item; /* message */
p_msg_item = &msg_item;
-#endif /*......................................................................*/
+#endif /*....................................................................*/
- /*
- * Convert message to string
- */
+ /*
+ * Convert message to string
+ */
+#ifdef HAVE_VASPRINTF
vasprintf( &psz_str, psz_format, ap );
+#else
+ psz_str = (char*) malloc( strlen(psz_format) + INTF_MAX_MSG_SIZE );
+#endif
if( psz_str == NULL )
{
- fprintf(stderr, "Warning: can't store following message (%s): ",
+ fprintf(stderr, "warning: can't store following message (%s): ",
strerror(errno) );
vfprintf(stderr, psz_format, ap );
+ fprintf(stderr, "\n" );
exit( errno );
}
+#ifdef HAVE_VASPRINTF
+#else
+ vsprintf( psz_str, psz_format, ap );
+#endif
-#ifdef INTF_MSG_QUEUE /*........................................ queue mode ...*/
- vlc_mutex_lock( &p_msg->lock ); /* get lock */
- if( p_msg->i_count == INTF_MSG_QSIZE ) /* flush queue if needed */
- {
-#ifdef DEBUG /* in debug mode, queue overflow causes a warning */
- fprintf(stderr, "Warning: message queue overflow\n" );
+#ifdef INTF_MSG_QUEUE /*...................................... queue mode ...*/
+ vlc_mutex_lock( &p_msg->lock ); /* get lock */
+ if( p_msg->i_count == INTF_MSG_QSIZE ) /* flush queue if needed */
+ {
+#ifdef DEBUG /* in debug mode, queue overflow causes a warning */
+ fprintf(stderr, "warning: message queue overflow\n" );
#endif
FlushLockedMsg( p_msg );
}
- p_msg_item = p_msg->msg + p_msg->i_count++; /* select message */
-#endif /*................................................ end of queue mode ...*/
+ p_msg_item = p_msg->msg + p_msg->i_count++; /* select message */
+#endif /*.............................................. end of queue mode ...*/
- /*
- * Fill message information fields
+ /*
+ * Fill message information fields
*/
p_msg_item->i_type = i_type;
- p_msg_item->psz_msg = psz_str;
-
-#ifdef INTF_MSG_QUEUE /*........................................... queue mode */
- vlc_mutex_unlock( &p_msg->lock ); /* give lock back */
-#else /*......................................................... instant mode */
- PrintMsg( p_msg_item ); /* print message */
- free( psz_str ); /* free message data */
-#endif /*......................................................................*/
+ p_msg_item->psz_msg = psz_str;
+#ifdef TRACE
+ p_msg_item->date = mdate();
+#endif
+
+#ifdef INTF_MSG_QUEUE /*......................................... queue mode */
+ vlc_mutex_unlock( &p_msg->lock ); /* give lock back */
+#else /*....................................................... instant mode */
+ PrintMsg( p_msg_item ); /* print message */
+ free( psz_str ); /* free message data */
+#endif /*....................................................................*/
}
-/*******************************************************************************
+/*****************************************************************************
* QueueDbgMsg: add a message to a queue with debugging informations
- *******************************************************************************
+ *****************************************************************************
* This function is the same as QueueMsg, except that it is only defined when
- * DEBUG is define, and require additionnal debugging informations.
- *******************************************************************************/
-#ifdef DEBUG
+ * TRACE is define, and require additionnal debugging informations.
+ *****************************************************************************/
+#ifdef TRACE
static void QueueDbgMsg(intf_msg_t *p_msg, char *psz_file, char *psz_function,
- int i_line, char *psz_format, va_list ap)
+ int i_line, char *psz_format, va_list ap)
{
- char * psz_str; /* formatted message string */
- intf_msg_item_t * p_msg_item; /* pointer to message */
+ char * psz_str; /* formatted message string */
+ intf_msg_item_t * p_msg_item; /* pointer to message */
-#ifndef INTF_MSG_QUEUE /*..................................... instant mode ...*/
- intf_msg_item_t msg_item; /* message */
+#ifndef INTF_MSG_QUEUE /*................................... instant mode ...*/
+ intf_msg_item_t msg_item; /* message */
p_msg_item = &msg_item;
-#endif /*......................................................................*/
+#endif /*....................................................................*/
- /*
- * Convert message to string
- */
+ /*
+ * Convert message to string
+ */
+#ifdef HAVE_VASPRINTF
vasprintf( &psz_str, psz_format, ap );
+#else
+ psz_str = (char*) malloc( INTF_MAX_MSG_SIZE );
+ vsprintf( psz_str, psz_format, ap );
+#endif
if( psz_str == NULL )
{
- fprintf(stderr, "Warning: can't store following message (%s): ",
+ fprintf(stderr, "warning: can't store following message (%s): ",
strerror(errno) );
fprintf(stderr, INTF_MSG_DBG_FORMAT, psz_file, psz_function, i_line );
- vfprintf(stderr, psz_format, ap );
+ vfprintf(stderr, psz_format, ap );
+ fprintf(stderr, "\n" );
exit( errno );
}
-#ifdef INTF_MSG_QUEUE /*........................................ queue mode ...*/
- vlc_mutex_lock( &p_msg->lock ); /* get lock */
- if( p_msg->i_count == INTF_MSG_QSIZE ) /* flush queue if needed */
- {
-#ifdef DEBUG /* in debug mode, queue overflow causes a warning */
- fprintf(stderr, "Warning: message queue overflow\n" );
-#endif
+#ifdef INTF_MSG_QUEUE /*...................................... queue mode ...*/
+ vlc_mutex_lock( &p_msg->lock ); /* get lock */
+ if( p_msg->i_count == INTF_MSG_QSIZE ) /* flush queue if needed */
+ {
+ fprintf(stderr, "warning: message queue overflow\n" );
FlushLockedMsg( p_msg );
}
- p_msg_item = p_msg->msg + p_msg->i_count++; /* select message */
-#endif /*................................................ end of queue mode ...*/
+ p_msg_item = p_msg->msg + p_msg->i_count++; /* select message */
+#endif /*.............................................. end of queue mode ...*/
- /*
- * Fill message information fields
+ /*
+ * Fill message information fields
*/
p_msg_item->i_type = INTF_MSG_DBG;
- p_msg_item->psz_msg = psz_str;
+ p_msg_item->psz_msg = psz_str;
p_msg_item->psz_file = psz_file;
p_msg_item->psz_function = psz_function;
p_msg_item->i_line = i_line;
p_msg_item->date = mdate();
-#ifdef INTF_MSG_QUEUE /*........................................... queue mode */
- vlc_mutex_unlock( &p_msg->lock ); /* give lock back */
-#else /*......................................................... instant mode */
- PrintMsg( p_msg_item ); /* print message */
- free( psz_str ); /* free message data */
-#endif /*......................................................................*/
+#ifdef INTF_MSG_QUEUE /*......................................... queue mode */
+ vlc_mutex_unlock( &p_msg->lock ); /* give lock back */
+#else /*....................................................... instant mode */
+ PrintMsg( p_msg_item ); /* print message */
+ free( psz_str ); /* free message data */
+#endif /*....................................................................*/
}
#endif
-/*******************************************************************************
- * FlushLockedMsg (ok ?)
- *******************************************************************************
+/*****************************************************************************
+ * FlushLockedMsg (ok ?)
+ *****************************************************************************
* Print all messages remaining in queue. MESSAGE QUEUE MUST BE LOCKED, since
* this function does not check the lock. This function is only defined if
* INTF_MSG_QUEUE is defined.
- *******************************************************************************/
+ *****************************************************************************/
#ifdef INTF_MSG_QUEUE
static void FlushLockedMsg ( intf_msg_t *p_msg )
{
for( i_index = 0; i_index < p_msg->i_count; i_index++ )
{
/* Print message and free message data */
- PrintMsg( &p_msg->msg[i_index] );
+ PrintMsg( &p_msg->msg[i_index] );
free( p_msg->msg[i_index].psz_msg );
}
-
+
p_msg->i_count = 0;
}
#endif
-/*******************************************************************************
- * PrintMsg: print a message (ok ?)
- *******************************************************************************
+/*****************************************************************************
+ * PrintMsg: print a message (ok ?)
+ *****************************************************************************
* Print a single message. The message data is not freed. This function exists
- * in two version. The DEBUG version prints a date with each message, and is
- * able to log messages (if DEBUG_LOG is defined).
+ * in two version. The TRACE version prints a date with each message, and is
+ * able to log messages (if TRACE_LOG is defined).
* The normal one just prints messages to the screen.
- *******************************************************************************/
-#ifdef DEBUG
+ *****************************************************************************/
+#ifdef TRACE
static void PrintMsg( intf_msg_item_t *p_msg )
{
- char psz_date[MSTRTIME_MAX_SIZE]; /* formatted time buffer */
- char * psz_msg; /* message buffer */
-
+ char psz_date[MSTRTIME_MAX_SIZE]; /* formatted time buffer */
+ int i_msg_len = MSTRTIME_MAX_SIZE + strlen(p_msg->psz_msg) + 200;
+ char *psz_msg; /* message buffer */
+
+ psz_msg = malloc( sizeof( char ) * i_msg_len );
+
+ /* Check if allocation succeeded */
+ if( psz_msg == NULL )
+ {
+ fprintf( stderr, "error: not enough memory for message %s\n",
+ p_msg->psz_msg );
+ return;
+ }
+
/* Format message - the message is formatted here because in case the log
* file is used, it avoids another format string parsing */
switch( p_msg->i_type )
{
- case INTF_MSG_STD: /* regular messages */
+ case INTF_MSG_STD: /* regular messages */
case INTF_MSG_ERR:
- asprintf( &psz_msg, "%s", p_msg->psz_msg );
+ snprintf( psz_msg, i_msg_len, "%s", p_msg->psz_msg );
break;
- case INTF_MSG_INTF: /* interface messages */
- asprintf( &psz_msg, "%s", p_msg->psz_msg );
- break;
+ case INTF_MSG_WARN: /* Warning message */
+ mstrtime( psz_date, p_msg->date );
+ snprintf( psz_msg, i_msg_len, "(%s) %s",
+ psz_date, p_msg->psz_msg );
- case INTF_MSG_DBG: /* debug messages */
+ break;
+
+ case INTF_MSG_DBG: /* debug messages */
mstrtime( psz_date, p_msg->date );
- asprintf( &psz_msg, "(%s) " INTF_MSG_DBG_FORMAT "%s",
- psz_date, p_msg->psz_file, p_msg->psz_function, p_msg->i_line,
- p_msg->psz_msg );
- break;
- }
-
- /* Check if formatting function suceeded */
- if( psz_msg == NULL )
- {
- fprintf( stderr, "intf error: *** can not format message (%s): %s ***\n",
- strerror( errno ), p_msg->psz_msg );
- return;
+ snprintf( psz_msg, i_msg_len, "(%s) " INTF_MSG_DBG_FORMAT "%s",
+ psz_date, p_msg->psz_file, p_msg->psz_function, p_msg->i_line,
+ p_msg->psz_msg );
+ break;
}
/*
*/
switch( p_msg->i_type )
{
- case INTF_MSG_STD: /* standard messages */
- fprintf( stdout, psz_msg );
+ case INTF_MSG_STD: /* standard messages */
+ fprintf( stdout, "%s\n", psz_msg );
break;
- case INTF_MSG_ERR: /* error messages */
-#ifndef DEBUG_LOG_ONLY
- case INTF_MSG_DBG: /* debugging messages */
+ case INTF_MSG_ERR: /* error messages */
+ case INTF_MSG_WARN:
+#ifndef TRACE_LOG_ONLY
+ case INTF_MSG_DBG: /* debugging messages */
#endif
- fprintf( stderr, psz_msg );
- break;
- case INTF_MSG_INTF: /* interface messages */
- intf_ConsolePrint( p_main->p_intf->p_console, psz_msg );
+ fprintf( stderr, "%s\n", psz_msg );
break;
}
-
-#ifdef DEBUG_LOG
+
+#ifdef TRACE_LOG
/* Append all messages to log file */
- if( p_main->p_msg->i_log_file >= 0 )
+ if( p_main->p_msg->p_log_file != NULL )
{
- write( p_main->p_msg->i_log_file, psz_msg, strlen( psz_msg ) );
+ fwrite( psz_msg, strlen( psz_msg ), 1, p_main->p_msg->p_log_file );
+ fwrite( "\n", 1, 1, p_main->p_msg->p_log_file );
}
#endif
- /* Free formatted message */
- free( psz_msg );
+ /* Free the message */
+ free( psz_msg );
}
#else
-static void PrintMsg( interface_msg_message_t *p_msg )
+static void PrintMsg( intf_msg_item_t *p_msg )
{
/*
- * Print messages on screen
+ * Print messages on screen
*/
switch( p_msg->i_type )
{
- case INTF_MSG_STD: /* standard messages */
- case INTF_MSG_DBG: /* debug messages */
- fprintf( stdout, p_msg->psz_msg );
+ case INTF_MSG_STD: /* standard messages */
+ case INTF_MSG_DBG: /* debug messages */
+ fprintf( stdout, "%s\n", p_msg->psz_msg );
break;
- case INTF_MSG_ERR: /* error messages */
- fprintf( stderr, p_msg->psz_msg );
+ case INTF_MSG_ERR: /* error messages */
+ case INTF_MSG_WARN:
+ fprintf( stderr, "%s\n", p_msg->psz_msg ); /* warning message */
break;
- case INTF_MSG_INTF: /* interface messages */
- intf_PrintXConsole( &p_main->intf_thread.xconsole,
- p_msg->psz_msg );
- break;
- }
+ }
}
#endif
+
projects / vlc / blobdiff