FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
log.c
Go to the documentation of this file.
1 /*
2  * log functions
3  * Copyright (c) 2003 Michel Bardiaux
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * logging functions
25  */
26 
27 #include "config.h"
28 
29 #if HAVE_UNISTD_H
30 #include <unistd.h>
31 #endif
32 #if HAVE_IO_H
33 #include <io.h>
34 #endif
35 #include <stdarg.h>
36 #include <stdlib.h>
37 #include "avutil.h"
38 #include "bprint.h"
39 #include "common.h"
40 #include "internal.h"
41 #include "log.h"
42 #include "thread.h"
43 
45 
46 #define LINE_SZ 1024
47 
48 #if HAVE_VALGRIND_VALGRIND_H
49 #include <valgrind/valgrind.h>
50 /* this is the log level at which valgrind will output a full backtrace */
51 #define BACKTRACE_LOGLEVEL AV_LOG_ERROR
52 #endif
53 
55 static int flags;
56 
57 #define NB_LEVELS 8
58 #if defined(_WIN32) && HAVE_SETCONSOLETEXTATTRIBUTE
59 #include <windows.h>
60 static const uint8_t color[16 + AV_CLASS_CATEGORY_NB] = {
61  [AV_LOG_PANIC /8] = 12,
62  [AV_LOG_FATAL /8] = 12,
63  [AV_LOG_ERROR /8] = 12,
64  [AV_LOG_WARNING/8] = 14,
65  [AV_LOG_INFO /8] = 7,
66  [AV_LOG_VERBOSE/8] = 10,
67  [AV_LOG_DEBUG /8] = 10,
68  [AV_LOG_TRACE /8] = 8,
69  [16+AV_CLASS_CATEGORY_NA ] = 7,
70  [16+AV_CLASS_CATEGORY_INPUT ] = 13,
71  [16+AV_CLASS_CATEGORY_OUTPUT ] = 5,
72  [16+AV_CLASS_CATEGORY_MUXER ] = 13,
73  [16+AV_CLASS_CATEGORY_DEMUXER ] = 5,
74  [16+AV_CLASS_CATEGORY_ENCODER ] = 11,
75  [16+AV_CLASS_CATEGORY_DECODER ] = 3,
76  [16+AV_CLASS_CATEGORY_FILTER ] = 10,
86 };
87 
88 static int16_t background, attr_orig;
89 static HANDLE con;
90 #else
91 
92 static const uint32_t color[16 + AV_CLASS_CATEGORY_NB] = {
93  [AV_LOG_PANIC /8] = 52 << 16 | 196 << 8 | 0x41,
94  [AV_LOG_FATAL /8] = 208 << 8 | 0x41,
95  [AV_LOG_ERROR /8] = 196 << 8 | 0x11,
96  [AV_LOG_WARNING/8] = 226 << 8 | 0x03,
97  [AV_LOG_INFO /8] = 253 << 8 | 0x09,
98  [AV_LOG_VERBOSE/8] = 40 << 8 | 0x02,
99  [AV_LOG_DEBUG /8] = 34 << 8 | 0x02,
100  [AV_LOG_TRACE /8] = 34 << 8 | 0x07,
101  [16+AV_CLASS_CATEGORY_NA ] = 250 << 8 | 0x09,
102  [16+AV_CLASS_CATEGORY_INPUT ] = 219 << 8 | 0x15,
103  [16+AV_CLASS_CATEGORY_OUTPUT ] = 201 << 8 | 0x05,
104  [16+AV_CLASS_CATEGORY_MUXER ] = 213 << 8 | 0x15,
105  [16+AV_CLASS_CATEGORY_DEMUXER ] = 207 << 8 | 0x05,
106  [16+AV_CLASS_CATEGORY_ENCODER ] = 51 << 8 | 0x16,
107  [16+AV_CLASS_CATEGORY_DECODER ] = 39 << 8 | 0x06,
108  [16+AV_CLASS_CATEGORY_FILTER ] = 155 << 8 | 0x12,
109  [16+AV_CLASS_CATEGORY_BITSTREAM_FILTER] = 192 << 8 | 0x14,
110  [16+AV_CLASS_CATEGORY_SWSCALER ] = 153 << 8 | 0x14,
111  [16+AV_CLASS_CATEGORY_SWRESAMPLER ] = 147 << 8 | 0x14,
112  [16+AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT ] = 213 << 8 | 0x15,
113  [16+AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT ] = 207 << 8 | 0x05,
114  [16+AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT ] = 213 << 8 | 0x15,
115  [16+AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT ] = 207 << 8 | 0x05,
116  [16+AV_CLASS_CATEGORY_DEVICE_OUTPUT ] = 213 << 8 | 0x15,
117  [16+AV_CLASS_CATEGORY_DEVICE_INPUT ] = 207 << 8 | 0x05,
118 };
119 
120 #endif
121 static int use_color = -1;
122 
123 static void check_color_terminal(void)
124 {
125 #if defined(_WIN32) && HAVE_SETCONSOLETEXTATTRIBUTE
126  CONSOLE_SCREEN_BUFFER_INFO con_info;
127  con = GetStdHandle(STD_ERROR_HANDLE);
128  use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
129  !getenv("AV_LOG_FORCE_NOCOLOR");
130  if (use_color) {
131  GetConsoleScreenBufferInfo(con, &con_info);
132  attr_orig = con_info.wAttributes;
133  background = attr_orig & 0xF0;
134  }
135 #elif HAVE_ISATTY
136  char *term = getenv("TERM");
137  use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
138  (getenv("TERM") && isatty(2) || getenv("AV_LOG_FORCE_COLOR"));
139  if ( getenv("AV_LOG_FORCE_256COLOR")
140  || (term && strstr(term, "256color")))
141  use_color *= 256;
142 #else
143  use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
144  !getenv("AV_LOG_FORCE_NOCOLOR");
145 #endif
146 }
147 
148 static void colored_fputs(int level, int tint, const char *str)
149 {
150  int local_use_color;
151  if (!*str)
152  return;
153 
154  if (use_color < 0)
156 
157  if (level == AV_LOG_INFO/8) local_use_color = 0;
158  else local_use_color = use_color;
159 
160 #if defined(_WIN32) && HAVE_SETCONSOLETEXTATTRIBUTE
161  if (local_use_color)
162  SetConsoleTextAttribute(con, background | color[level]);
163  fputs(str, stderr);
164  if (local_use_color)
165  SetConsoleTextAttribute(con, attr_orig);
166 #else
167  if (local_use_color == 1) {
168  fprintf(stderr,
169  "\033[%"PRIu32";3%"PRIu32"m%s\033[0m",
170  (color[level] >> 4) & 15,
171  color[level] & 15,
172  str);
173  } else if (tint && use_color == 256) {
174  fprintf(stderr,
175  "\033[48;5;%"PRIu32"m\033[38;5;%dm%s\033[0m",
176  (color[level] >> 16) & 0xff,
177  tint,
178  str);
179  } else if (local_use_color == 256) {
180  fprintf(stderr,
181  "\033[48;5;%"PRIu32"m\033[38;5;%"PRIu32"m%s\033[0m",
182  (color[level] >> 16) & 0xff,
183  (color[level] >> 8) & 0xff,
184  str);
185  } else
186  fputs(str, stderr);
187 #endif
188 
189 }
190 
191 const char *av_default_item_name(void *ptr)
192 {
193  return (*(AVClass **) ptr)->class_name;
194 }
195 
197 {
198  return (*(AVClass **) ptr)->category;
199 }
200 
201 static void sanitize(uint8_t *line){
202  while(*line){
203  if(*line < 0x08 || (*line > 0x0D && *line < 0x20))
204  *line='?';
205  line++;
206  }
207 }
208 
209 static int get_category(void *ptr){
210  AVClass *avc = *(AVClass **) ptr;
211  if( !avc
212  || (avc->version&0xFF)<100
213  || avc->version < (51 << 16 | 59 << 8)
214  || avc->category >= AV_CLASS_CATEGORY_NB) return AV_CLASS_CATEGORY_NA + 16;
215 
216  if(avc->get_category)
217  return avc->get_category(ptr) + 16;
218 
219  return avc->category + 16;
220 }
221 
222 static const char *get_level_str(int level)
223 {
224  switch (level) {
225  case AV_LOG_QUIET:
226  return "quiet";
227  case AV_LOG_DEBUG:
228  return "debug";
229  case AV_LOG_VERBOSE:
230  return "verbose";
231  case AV_LOG_INFO:
232  return "info";
233  case AV_LOG_WARNING:
234  return "warning";
235  case AV_LOG_ERROR:
236  return "error";
237  case AV_LOG_FATAL:
238  return "fatal";
239  case AV_LOG_PANIC:
240  return "panic";
241  default:
242  return "";
243  }
244 }
245 
246 static void format_line(void *avcl, int level, const char *fmt, va_list vl,
247  AVBPrint part[4], int *print_prefix, int type[2])
248 {
249  AVClass* avc = avcl ? *(AVClass **) avcl : NULL;
250  av_bprint_init(part+0, 0, 1);
251  av_bprint_init(part+1, 0, 1);
252  av_bprint_init(part+2, 0, 1);
253  av_bprint_init(part+3, 0, 65536);
254 
255  if(type) type[0] = type[1] = AV_CLASS_CATEGORY_NA + 16;
256  if (*print_prefix && avc) {
257  if (avc->parent_log_context_offset) {
258  AVClass** parent = *(AVClass ***) (((uint8_t *) avcl) +
260  if (parent && *parent) {
261  av_bprintf(part+0, "[%s @ %p] ",
262  (*parent)->item_name(parent), parent);
263  if(type) type[0] = get_category(parent);
264  }
265  }
266  av_bprintf(part+1, "[%s @ %p] ",
267  avc->item_name(avcl), avcl);
268  if(type) type[1] = get_category(avcl);
269 
271  av_bprintf(part+2, "[%s] ", get_level_str(level));
272  }
273 
274  av_vbprintf(part+3, fmt, vl);
275 
276  if(*part[0].str || *part[1].str || *part[2].str || *part[3].str) {
277  char lastc = part[3].len && part[3].len <= part[3].size ? part[3].str[part[3].len - 1] : 0;
278  *print_prefix = lastc == '\n' || lastc == '\r';
279  }
280 }
281 
282 void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
283  char *line, int line_size, int *print_prefix)
284 {
285  av_log_format_line2(ptr, level, fmt, vl, line, line_size, print_prefix);
286 }
287 
288 int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl,
289  char *line, int line_size, int *print_prefix)
290 {
291  AVBPrint part[4];
292  int ret;
293 
294  format_line(ptr, level, fmt, vl, part, print_prefix, NULL);
295  ret = snprintf(line, line_size, "%s%s%s%s", part[0].str, part[1].str, part[2].str, part[3].str);
296  av_bprint_finalize(part+3, NULL);
297  return ret;
298 }
299 
300 void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
301 {
302  static int print_prefix = 1;
303  static int count;
304  static char prev[LINE_SZ];
305  AVBPrint part[4];
306  char line[LINE_SZ];
307  static int is_atty;
308  int type[2];
309  unsigned tint = 0;
310 
311  if (level >= 0) {
312  tint = level & 0xff00;
313  level &= 0xff;
314  }
315 
316  if (level > av_log_level)
317  return;
319 
320  format_line(ptr, level, fmt, vl, part, &print_prefix, type);
321  snprintf(line, sizeof(line), "%s%s%s%s", part[0].str, part[1].str, part[2].str, part[3].str);
322 
323 #if HAVE_ISATTY
324  if (!is_atty)
325  is_atty = isatty(2) ? 1 : -1;
326 #endif
327 
328  if (print_prefix && (flags & AV_LOG_SKIP_REPEATED) && !strcmp(line, prev) &&
329  *line && line[strlen(line) - 1] != '\r'){
330  count++;
331  if (is_atty == 1)
332  fprintf(stderr, " Last message repeated %d times\r", count);
333  goto end;
334  }
335  if (count > 0) {
336  fprintf(stderr, " Last message repeated %d times\n", count);
337  count = 0;
338  }
339  strcpy(prev, line);
340  sanitize(part[0].str);
341  colored_fputs(type[0], 0, part[0].str);
342  sanitize(part[1].str);
343  colored_fputs(type[1], 0, part[1].str);
344  sanitize(part[2].str);
345  colored_fputs(av_clip(level >> 3, 0, NB_LEVELS - 1), tint >> 8, part[2].str);
346  sanitize(part[3].str);
347  colored_fputs(av_clip(level >> 3, 0, NB_LEVELS - 1), tint >> 8, part[3].str);
348 
349 #if CONFIG_VALGRIND_BACKTRACE
350  if (level <= BACKTRACE_LOGLEVEL)
351  VALGRIND_PRINTF_BACKTRACE("%s", "");
352 #endif
353 end:
354  av_bprint_finalize(part+3, NULL);
356 }
357 
358 static void (*av_log_callback)(void*, int, const char*, va_list) =
360 
361 void av_log(void* avcl, int level, const char *fmt, ...)
362 {
363  AVClass* avc = avcl ? *(AVClass **) avcl : NULL;
364  va_list vl;
365  va_start(vl, fmt);
366  if (avc && avc->version >= (50 << 16 | 15 << 8 | 2) &&
367  avc->log_level_offset_offset && level >= AV_LOG_FATAL)
368  level += *(int *) (((uint8_t *) avcl) + avc->log_level_offset_offset);
369  av_vlog(avcl, level, fmt, vl);
370  va_end(vl);
371 }
372 
373 void av_vlog(void* avcl, int level, const char *fmt, va_list vl)
374 {
375  void (*log_callback)(void*, int, const char*, va_list) = av_log_callback;
376  if (log_callback)
377  log_callback(avcl, level, fmt, vl);
378 }
379 
381 {
382  return av_log_level;
383 }
384 
386 {
388 }
389 
391 {
392  flags = arg;
393 }
394 
396 {
397  return flags;
398 }
399 
400 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))
401 {
403 }
404 
405 static void missing_feature_sample(int sample, void *avc, const char *msg,
406  va_list argument_list)
407 {
408  av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
409  av_log(avc, AV_LOG_WARNING, " is not implemented. Update your FFmpeg "
410  "version to the newest one from Git. If the problem still "
411  "occurs, it means that your file has a feature which has not "
412  "been implemented.\n");
413  if (sample)
414  av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
415  "of this file to ftp://upload.ffmpeg.org/incoming/ "
416  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n");
417 }
418 
419 void avpriv_request_sample(void *avc, const char *msg, ...)
420 {
421  va_list argument_list;
422 
423  va_start(argument_list, msg);
424  missing_feature_sample(1, avc, msg, argument_list);
425  va_end(argument_list);
426 }
427 
428 void avpriv_report_missing_feature(void *avc, const char *msg, ...)
429 {
430  va_list argument_list;
431 
432  va_start(argument_list, msg);
433  missing_feature_sample(0, avc, msg, argument_list);
434  va_end(argument_list);
435 }
#define NULL
Definition: coverity.c:32
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
static AVMutex mutex
Definition: log.c:44
const char * fmt
Definition: avisynth_c.h:769
static const char * get_level_str(int level)
Definition: log.c:222
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
void av_log_set_level(int level)
Set the log level.
Definition: log.c:385
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:155
static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
Definition: ffprobe.c:296
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
Convenience header that includes libavutil's core.
#define sample
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
#define AV_LOG_QUIET
Print no output.
Definition: log.h:158
static void missing_feature_sample(int sample, void *avc, const char *msg, va_list argument_list)
Definition: log.c:405
uint8_t
#define AV_LOG_PANIC
Something went really wrong and we will crash now.
Definition: log.h:163
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int log_level_offset_offset
Offset in the structure where log_level_offset is stored.
Definition: log.h:99
static void sanitize(uint8_t *line)
Definition: log.c:201
static int flags
Definition: log.c:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
static int get_category(void *ptr)
Definition: log.c:209
#define isatty(fd)
Definition: checkasm.c:61
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVMutex
Definition: thread.h:151
void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix)
Format a line of log the same way as the default callback.
Definition: log.c:282
static void format_line(void *avcl, int level, const char *fmt, va_list vl, AVBPrint part[4], int *print_prefix, int type[2])
Definition: log.c:246
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * arg
Definition: jacosubdec.c:66
Definition: graph2dot.c:48
#define AV_LOG_SKIP_REPEATED
Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 woul...
Definition: log.h:345
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:361
int av_log_get_level(void)
Get the current log level.
Definition: log.c:380
static int av_log_level
Definition: log.c:54
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:130
GLsizei count
Definition: opengl_enc.c:109
void av_log_default_callback(void *ptr, int level, const char *fmt, va_list vl)
Default logging callback.
Definition: log.c:300
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:156
int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix)
Format a line of log the same way as the default callback.
Definition: log.c:288
common internal API header
static void check_color_terminal(void)
Definition: log.c:123
void avpriv_report_missing_feature(void *avc, const char *msg,...)
Definition: log.c:428
static void callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time, enum dshowDeviceType devtype)
Definition: dshow.c:161
#define AV_MUTEX_INITIALIZER
Definition: thread.h:152
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:400
not part of ABI/API
Definition: log.h:47
PVOID HANDLE
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void(* av_log_callback)(void *, int, const char *, va_list)
Definition: log.c:358
AVClassCategory(* get_category)(void *ctx)
Callback to return the category.
Definition: log.h:136
#define NB_LEVELS
Definition: log.c:57
const char *(* item_name)(void *ctx)
A pointer to a function which returns the name of a context instance ctx associated with the class...
Definition: log.h:78
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int av_log_get_flags(void)
Definition: log.c:395
GLint GLenum type
Definition: opengl_enc.c:105
void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg)
Append a formatted string to a print buffer.
Definition: bprint.c:117
Describe the class of an AVClass context structure.
Definition: log.h:67
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level...
Definition: log.c:373
#define snprintf
Definition: snprintf.h:34
uint8_t level
Definition: svq3.c:207
int version
LIBAVUTIL_VERSION with which this structure was created.
Definition: log.h:93
int
common internal and external API header
int parent_log_context_offset
Offset in the structure where a pointer to the parent context for logging is stored.
Definition: log.h:108
static int use_color
Definition: log.c:121
AVClassCategory av_default_get_category(void *ptr)
Definition: log.c:196
AVClassCategory
Definition: log.h:29
void avpriv_request_sample(void *avc, const char *msg,...)
Definition: log.c:419
void av_log_set_flags(int arg)
Definition: log.c:390
#define LINE_SZ
Definition: log.c:46
#define AV_LOG_PRINT_LEVEL
Include the log severity in messages originating from codecs.
Definition: log.h:353
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
#define INVALID_HANDLE_VALUE
Definition: windows2linux.h:47
static void colored_fputs(int level, int tint, const char *str)
Definition: log.c:148