git.sesse.net Git - ffmpeg/blob - libavutil/log.c

   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 #include <stdlib.h>
  33 #include "avutil.h"
  34 #include "log.h"
  35
  36 #define LINE_SZ 1024
  37
  38 static int av_log_level = AV_LOG_INFO;
  39 static int flags;
  40
  41 #if defined(_WIN32) && !defined(__MINGW32CE__)
  42 #include <windows.h>
  43 #include <io.h>
  44 static const uint8_t color[16 + AV_CLASS_CATEGORY_NB] = {
  45     [AV_LOG_PANIC  /8] = 12,
  46     [AV_LOG_FATAL  /8] = 12,
  47     [AV_LOG_ERROR  /8] = 12,
  48     [AV_LOG_WARNING/8] = 14,
  49     [AV_LOG_INFO   /8] =  7,
  50     [AV_LOG_VERBOSE/8] = 10,
  51     [AV_LOG_DEBUG  /8] = 10,
  52     [16+AV_CLASS_CATEGORY_NA              ] =  7,
  53     [16+AV_CLASS_CATEGORY_INPUT           ] = 13,
  54     [16+AV_CLASS_CATEGORY_OUTPUT          ] =  5,
  55     [16+AV_CLASS_CATEGORY_MUXER           ] = 13,
  56     [16+AV_CLASS_CATEGORY_DEMUXER         ] =  5,
  57     [16+AV_CLASS_CATEGORY_ENCODER         ] = 11,
  58     [16+AV_CLASS_CATEGORY_DECODER         ] =  3,
  59     [16+AV_CLASS_CATEGORY_FILTER          ] =  1,
  60     [16+AV_CLASS_CATEGORY_BITSTREAM_FILTER] =  9,
  61 };
  62
  63 static int16_t background, attr_orig;
  64 static HANDLE con;
  65 #define set_color(x)  SetConsoleTextAttribute(con, background | color[x])
  66 #define reset_color() SetConsoleTextAttribute(con, attr_orig)
  67 #else
  68
  69 static const uint8_t color[16 + AV_CLASS_CATEGORY_NB] = {
  70     [AV_LOG_PANIC  /8] = 0x41,
  71     [AV_LOG_FATAL  /8] = 0x41,
  72     [AV_LOG_ERROR  /8] = 0x11,
  73     [AV_LOG_WARNING/8] = 0x03,
  74     [AV_LOG_INFO   /8] =    9,
  75     [AV_LOG_VERBOSE/8] = 0x02,
  76     [AV_LOG_DEBUG  /8] = 0x02,
  77     [16+AV_CLASS_CATEGORY_NA              ] =    9,
  78     [16+AV_CLASS_CATEGORY_INPUT           ] = 0x15,
  79     [16+AV_CLASS_CATEGORY_OUTPUT          ] = 0x05,
  80     [16+AV_CLASS_CATEGORY_MUXER           ] = 0x15,
  81     [16+AV_CLASS_CATEGORY_DEMUXER         ] = 0x05,
  82     [16+AV_CLASS_CATEGORY_ENCODER         ] = 0x16,
  83     [16+AV_CLASS_CATEGORY_DECODER         ] = 0x06,
  84     [16+AV_CLASS_CATEGORY_FILTER          ] = 0x04,
  85     [16+AV_CLASS_CATEGORY_BITSTREAM_FILTER] = 0x14,
  86 };
  87
  88 #define set_color(x)  fprintf(stderr, "\033[%d;3%dm", color[x] >> 4, color[x]&15)
  89 #define reset_color() fprintf(stderr, "\033[0m")
  90 #endif
  91 static int use_color = -1;
  92
  93 #undef fprintf
  94 static void colored_fputs(int level, const char *str)
  95 {
  96     if (use_color < 0) {
  97 #if defined(_WIN32) && !defined(__MINGW32CE__)
  98         CONSOLE_SCREEN_BUFFER_INFO con_info;
  99         con = GetStdHandle(STD_ERROR_HANDLE);
 100         use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
 101                     !getenv("AV_LOG_FORCE_NOCOLOR");
 102         if (use_color) {
 103             GetConsoleScreenBufferInfo(con, &con_info);
 104             attr_orig  = con_info.wAttributes;
 105             background = attr_orig & 0xF0;
 106         }
 107 #elif HAVE_ISATTY
 108         use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
 109                     (getenv("TERM") && isatty(2) ||
 110                      getenv("AV_LOG_FORCE_COLOR"));
 111 #else
 112         use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
 113                    !getenv("AV_LOG_FORCE_NOCOLOR");
 114 #endif
 115     }
 116
 117     if (use_color) {
 118         set_color(level);
 119     }
 120     fputs(str, stderr);
 121     if (use_color) {
 122         reset_color();
 123     }
 124 }
 125
 126 const char *av_default_item_name(void *ptr)
 127 {
 128     return (*(AVClass **) ptr)->class_name;
 129 }
 130
 131 AVClassCategory av_default_get_category(void *ptr)
 132 {
 133     return (*(AVClass **) ptr)->category;
 134 }
 135
 136 static void sanitize(uint8_t *line){
 137     while(*line){
 138         if(*line < 0x08 || (*line > 0x0D && *line < 0x20))
 139             *line='?';
 140         line++;
 141     }
 142 }
 143
 144 static int get_category(void *ptr){
 145     AVClass *avc = *(AVClass **) ptr;
 146     if(    !avc
 147         || (avc->version&0xFF)<100
 148         ||  avc->version < (51 << 16 | 59 << 8)
 149         ||  avc->category >= AV_CLASS_CATEGORY_NB) return AV_CLASS_CATEGORY_NA + 16;
 150
 151     if(avc->get_category)
 152         return avc->get_category(ptr) + 16;
 153
 154     return avc->category + 16;
 155 }
 156
 157 static void format_line(void *ptr, int level, const char *fmt, va_list vl,
 158                         char part[3][LINE_SZ], int part_size, int *print_prefix, int type[2])
 159 {
 160     AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
 161     part[0][0] = part[1][0] = part[2][0] = 0;
 162     if(type) type[0] = type[1] = AV_CLASS_CATEGORY_NA + 16;
 163     if (*print_prefix && avc) {
 164         if (avc->parent_log_context_offset) {
 165             AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
 166                                    avc->parent_log_context_offset);
 167             if (parent && *parent) {
 168                 snprintf(part[0], part_size, "[%s @ %p] ",
 169                          (*parent)->item_name(parent), parent);
 170                 if(type) type[0] = get_category(((uint8_t *) ptr) + avc->parent_log_context_offset);
 171             }
 172         }
 173         snprintf(part[1], part_size, "[%s @ %p] ",
 174                  avc->item_name(ptr), ptr);
 175         if(type) type[1] = get_category(ptr);
 176     }
 177
 178     vsnprintf(part[2], part_size, fmt, vl);
 179
 180     *print_prefix = strlen(part[2]) && part[2][strlen(part[2]) - 1] == '\n';
 181 }
 182
 183 void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
 184                         char *line, int line_size, int *print_prefix)
 185 {
 186     char part[3][LINE_SZ];
 187     format_line(ptr, level, fmt, vl, part, sizeof(part[0]), print_prefix, NULL);
 188     snprintf(line, line_size, "%s%s%s", part[0], part[1], part[2]);
 189 }
 190
 191 void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
 192 {
 193     static int print_prefix = 1;
 194     static int count;
 195     static char prev[LINE_SZ];
 196     char part[3][LINE_SZ];
 197     char line[LINE_SZ];
 198     static int is_atty;
 199     int type[2];
 200
 201     if (level > av_log_level)
 202         return;
 203     format_line(ptr, level, fmt, vl, part, sizeof(part[0]), &print_prefix, type);
 204     snprintf(line, sizeof(line), "%s%s%s", part[0], part[1], part[2]);
 205
 206 #if HAVE_ISATTY
 207     if (!is_atty)
 208         is_atty = isatty(2) ? 1 : -1;
 209 #endif
 210
 211 #undef fprintf
 212     if (print_prefix && (flags & AV_LOG_SKIP_REPEATED) && !strcmp(line, prev)){
 213         count++;
 214         if (is_atty == 1)
 215             fprintf(stderr, "    Last message repeated %d times\r", count);
 216         return;
 217     }
 218     if (count > 0) {
 219         fprintf(stderr, "    Last message repeated %d times\n", count);
 220         count = 0;
 221     }
 222     strcpy(prev, line);
 223     sanitize(part[0]);
 224     colored_fputs(type[0], part[0]);
 225     sanitize(part[1]);
 226     colored_fputs(type[1], part[1]);
 227     sanitize(part[2]);
 228     colored_fputs(av_clip(level >> 3, 0, 6), part[2]);
 229 }
 230
 231 static void (*av_log_callback)(void*, int, const char*, va_list) =
 232     av_log_default_callback;
 233
 234 void av_log(void* avcl, int level, const char *fmt, ...)
 235 {
 236     AVClass* avc = avcl ? *(AVClass **) avcl : NULL;
 237     va_list vl;
 238     va_start(vl, fmt);
 239     if (avc && avc->version >= (50 << 16 | 15 << 8 | 2) &&
 240         avc->log_level_offset_offset && level >= AV_LOG_FATAL)
 241         level += *(int *) (((uint8_t *) avcl) + avc->log_level_offset_offset);
 242     av_vlog(avcl, level, fmt, vl);
 243     va_end(vl);
 244 }
 245
 246 void av_vlog(void* avcl, int level, const char *fmt, va_list vl)
 247 {
 248     if(av_log_callback)
 249         av_log_callback(avcl, level, fmt, vl);
 250 }
 251
 252 int av_log_get_level(void)
 253 {
 254     return av_log_level;
 255 }
 256
 257 void av_log_set_level(int level)
 258 {
 259     av_log_level = level;
 260 }
 261
 262 void av_log_set_flags(int arg)
 263 {
 264     flags = arg;
 265 }
 266
 267 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))
 268 {
 269     av_log_callback = callback;
 270 }