mp_msg.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <stdarg.h>
  22 #include <string.h>
  23
  24 #include "config.h"
  25 #include "osdep/getch2.h"
  26
  27 #ifdef CONFIG_TRANSLATION
  28 #include <locale.h>
  29 #include <libintl.h>
  30 #endif
  31
  32 #ifdef CONFIG_ICONV
  33 #include <iconv.h>
  34 #include <errno.h>
  35 #endif
  36
  37 #include "mp_msg.h"
  38
  39 /* maximum message length of mp_msg */
  40 #define MSGSIZE_MAX 3072
  41
  42 int mp_msg_levels[MSGT_MAX]; // verbose level of this module. initialized to -2
  43 int mp_msg_level_all = MSGL_STATUS;
  44 int verbose = 0;
  45 int mp_msg_color = 0;
  46 int mp_msg_module = 0;
  47 #ifdef CONFIG_ICONV
  48 char *mp_msg_charset = NULL;
  49 static char *old_charset = NULL;
  50 static iconv_t msgiconv;
  51 #endif
  52
  53 const char* filename_recode(const char* filename)
  54 {
  55 #if !defined(CONFIG_ICONV) || !defined(MSG_CHARSET)
  56     return filename;
  57 #else
  58     static iconv_t inv_msgiconv = (iconv_t)(-1);
  59     static char recoded_filename[MSGSIZE_MAX];
  60     size_t filename_len, max_path;
  61     char* precoded;
  62     if (!mp_msg_charset ||
  63         !strcasecmp(mp_msg_charset, MSG_CHARSET) ||
  64         !strcasecmp(mp_msg_charset, "noconv"))
  65         return filename;
  66     if (inv_msgiconv == (iconv_t)(-1)) {
  67         inv_msgiconv = iconv_open(MSG_CHARSET, mp_msg_charset);
  68         if (inv_msgiconv == (iconv_t)(-1))
  69             return filename;
  70     }
  71     filename_len = strlen(filename);
  72     max_path = MSGSIZE_MAX - 4;
  73     precoded = recoded_filename;
  74     if (iconv(inv_msgiconv, &filename, &filename_len,
  75               &precoded, &max_path) == (size_t)(-1) && errno == E2BIG) {
  76         precoded[0] = precoded[1] = precoded[2] = '.';
  77         precoded += 3;
  78     }
  79     *precoded = '\0';
  80     return recoded_filename;
  81 #endif
  82 }
  83
  84 void mp_msg_init(void){
  85     int i;
  86     char *env = getenv("MPLAYER_VERBOSE");
  87     if (env)
  88         verbose = atoi(env);
  89     for(i=0;i<MSGT_MAX;i++) mp_msg_levels[i] = -2;
  90     mp_msg_levels[MSGT_IDENTIFY] = -1; // no -identify output by default
  91 #ifdef CONFIG_ICONV
  92     mp_msg_charset = getenv("MPLAYER_CHARSET");
  93     if (!mp_msg_charset)
  94       mp_msg_charset = get_term_charset();
  95 #endif
  96 #ifdef CONFIG_TRANSLATION
  97     textdomain("mplayer");
  98     char *localedir = getenv("MPLAYER_LOCALEDIR");
  99     if (localedir == NULL && strlen(MPLAYER_LOCALEDIR))
 100         localedir = MPLAYER_LOCALEDIR;
 101     bindtextdomain("mplayer", localedir);
 102     bind_textdomain_codeset("mplayer", "UTF-8");
 103 #endif
 104 }
 105
 106 int mp_msg_test(int mod, int lev)
 107 {
 108     return lev <= (mp_msg_levels[mod] == -2 ? mp_msg_level_all + verbose : mp_msg_levels[mod]);
 109 }
 110
 111 static void set_msg_color(FILE* stream, int lev)
 112 {
 113     static const unsigned char v_colors[10] = {9, 1, 3, 15, 7, 2, 2, 8, 8, 8};
 114     int c = v_colors[lev];
 115 #ifdef MP_ANNOY_ME
 116     /* that's only a silly color test */
 117     {
 118         int c;
 119         static int flag = 1;
 120         if (flag)
 121             for(c = 0; c < 24; c++)
 122                 printf("\033[%d;3%dm***  COLOR TEST %d  ***\n", c>7, c&7, c);
 123         flag = 0;
 124     }
 125 #endif
 126     if (mp_msg_color)
 127         fprintf(stream, "\033[%d;3%dm", c >> 3, c & 7);
 128 }
 129
 130 static void print_msg_module(FILE* stream, int mod)
 131 {
 132     static const char *module_text[MSGT_MAX] = {
 133         "GLOBAL",
 134         "CPLAYER",
 135         "GPLAYER",
 136         "VIDEOOUT",
 137         "AUDIOOUT",
 138         "DEMUXER",
 139         "DS",
 140         "DEMUX",
 141         "HEADER",
 142         "AVSYNC",
 143         "AUTOQ",
 144         "CFGPARSER",
 145         "DECAUDIO",
 146         "DECVIDEO",
 147         "SEEK",
 148         "WIN32",
 149         "OPEN",
 150         "DVD",
 151         "PARSEES",
 152         "LIRC",
 153         "STREAM",
 154         "CACHE",
 155         "MENCODER",
 156         "XACODEC",
 157         "TV",
 158         "OSDEP",
 159         "SPUDEC",
 160         "PLAYTREE",
 161         "INPUT",
 162         "VFILTER",
 163         "OSD",
 164         "NETWORK",
 165         "CPUDETECT",
 166         "CODECCFG",
 167         "SWS",
 168         "VOBSUB",
 169         "SUBREADER",
 170         "AFILTER",
 171         "NETST",
 172         "MUXER",
 173         "OSDMENU",
 174         "IDENTIFY",
 175         "RADIO",
 176         "ASS",
 177         "LOADER",
 178         "STATUSLINE",
 179     };
 180     int c2 = (mod + 1) % 15 + 1;
 181
 182     if (!mp_msg_module)
 183         return;
 184     if (mp_msg_color)
 185         fprintf(stream, "\033[%d;3%dm", c2 >> 3, c2 & 7);
 186     fprintf(stream, "%9s", module_text[mod]);
 187     if (mp_msg_color)
 188         fprintf(stream, "\033[0;37m");
 189     fprintf(stream, ": ");
 190 }
 191
 192 void mp_msg_va(int mod, int lev, const char *format, va_list va)
 193 {
 194     char tmp[MSGSIZE_MAX];
 195     FILE *stream = lev <= MSGL_WARN ? stderr : stdout;
 196     static int header = 1;
 197
 198     if (!mp_msg_test(mod, lev)) return; // do not display
 199     vsnprintf(tmp, MSGSIZE_MAX, format, va);
 200     tmp[MSGSIZE_MAX-2] = '\n';
 201     tmp[MSGSIZE_MAX-1] = 0;
 202
 203 #if defined(CONFIG_ICONV) && defined(MSG_CHARSET)
 204     if (mp_msg_charset && strcasecmp(mp_msg_charset, "noconv")) {
 205       char tmp2[MSGSIZE_MAX];
 206       size_t inlen = strlen(tmp), outlen = MSGSIZE_MAX;
 207       char *in = tmp, *out = tmp2;
 208       if (!old_charset || strcmp(old_charset, mp_msg_charset)) {
 209         if (old_charset) {
 210           free(old_charset);
 211           iconv_close(msgiconv);
 212         }
 213         msgiconv = iconv_open(mp_msg_charset, MSG_CHARSET);
 214         old_charset = strdup(mp_msg_charset);
 215       }
 216       if (msgiconv == (iconv_t)(-1)) {
 217         fprintf(stderr,"iconv: conversion from %s to %s unsupported\n"
 218                ,MSG_CHARSET,mp_msg_charset);
 219       }else{
 220       memset(tmp2, 0, MSGSIZE_MAX);
 221       while (iconv(msgiconv, &in, &inlen, &out, &outlen) == -1) {
 222         if (!inlen || !outlen)
 223           break;
 224         *out++ = *in++;
 225         outlen--; inlen--;
 226       }
 227       strncpy(tmp, tmp2, MSGSIZE_MAX);
 228       tmp[MSGSIZE_MAX-1] = 0;
 229       tmp[MSGSIZE_MAX-2] = '\n';
 230       }
 231     }
 232 #endif
 233
 234     if (header)
 235         print_msg_module(stream, mod);
 236     set_msg_color(stream, lev);
 237
 238     size_t len = strlen(tmp);
 239     header = len && (tmp[len-1] == '\n' || tmp[len-1] == '\r');
 240
 241     fprintf(stream, "%s", tmp);
 242     if (mp_msg_color)
 243         fprintf(stream, "\033[0m");
 244     fflush(stream);
 245 }
 246
 247 void mp_msg(int mod, int lev, const char *format, ...)
 248 {
 249     va_list va;
 250     va_start(va, format);
 251     mp_msg_va(mod, lev, format, va);
 252     va_end(va);
 253 }
 254
 255 char *mp_gtext(const char *string)
 256 {
 257 #ifdef CONFIG_TRANSLATION
 258     /* gettext expects the global locale to be set with
 259      * setlocale(LC_ALL, ""). However doing that would suck for a
 260      * couple of reasons (locale stuff is badly designed and sucks in
 261      * general).
 262      *
 263      * First setting the locale, especially LC_CTYPE, changes the
 264      * behavior of various C functions and we don't want that - we
 265      * want isalpha() for example to always behave like in the C
 266      * locale.
 267
 268      * Second, there is no way to enforce a sane character set. All
 269      * strings inside MPlayer must always be in utf-8, not in the
 270      * character set specified by the system locale which could be
 271      * something different and completely insane. The locale system
 272      * lacks any way to say "set LC_CTYPE to utf-8, ignoring the
 273      * default system locale if it specifies something different". We
 274      * could try to work around that flaw by leaving LC_CTYPE to the C
 275      * locale and only setting LC_MESSAGES (which is the variable that
 276      * must be set to tell gettext which language to translate
 277      * to). However if we leave LC_MESSAGES set then things like
 278      * strerror() may produce completely garbled output when they try
 279      * to translate their results but then try to convert some
 280      * translated non-ASCII text to the character set specified by
 281      * LC_CTYPE which would still be in the C locale (this doesn't
 282      * affect gettext itself because it supports specifying the
 283      * character set directly with bind_textdomain_codeset()).
 284      *
 285      * So the only solution (at leat short of trying to work around
 286      * things possibly producing non-utf-8 output) is to leave all the
 287      * locale variables unset. Note that this means it's not possible
 288      * to get translated output from any libraries we call if they
 289      * only rely on the broken locale system to specify the language
 290      * to use; this is the case with libc for example.
 291      *
 292      * The locale changing below is rather ugly, but hard to avoid.
 293      * gettext doesn't support specifying the translation target
 294      * directly, only through locale.
 295      * The main actual problem this could cause is interference with
 296      * other threads; that could be avoided with thread-specific
 297      * locale changes, but such functionality is less standard and I
 298      * think it's not worth adding pre-emptively unless someone sees
 299      * an actual problem case.
 300      */
 301     setlocale(LC_MESSAGES, "");
 302     string = gettext(string);
 303     setlocale(LC_MESSAGES, "C");
 304 #endif
 305     return string;
 306 }
 307
 308 void mp_tmsg(int mod, int lev, const char *format, ...)
 309 {
 310     va_list va;
 311     va_start(va, format);
 312     mp_msg_va(mod, lev, mp_gtext(format), va);
 313     va_end(va);
 314 }