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     header = tmp[strlen(tmp)-1] == '\n' || tmp[strlen(tmp)-1] == '\r';
 238
 239     fprintf(stream, "%s", tmp);
 240     if (mp_msg_color)
 241         fprintf(stream, "\033[0m");
 242     fflush(stream);
 243 }
 244
 245 void mp_msg(int mod, int lev, const char *format, ...)
 246 {
 247     va_list va;
 248     va_start(va, format);
 249     mp_msg_va(mod, lev, format, va);
 250     va_end(va);
 251 }
 252
 253 char *mp_gtext(const char *string)
 254 {
 255 #ifdef CONFIG_TRANSLATION
 256     /* gettext expects the global locale to be set with
 257      * setlocale(LC_ALL, ""). However doing that would suck for a
 258      * couple of reasons (locale stuff is badly designed and sucks in
 259      * general).
 260      *
 261      * First setting the locale, especially LC_CTYPE, changes the
 262      * behavior of various C functions and we don't want that - we
 263      * want isalpha() for example to always behave like in the C
 264      * locale.
 265
 266      * Second, there is no way to enforce a sane character set. All
 267      * strings inside MPlayer must always be in utf-8, not in the
 268      * character set specified by the system locale which could be
 269      * something different and completely insane. The locale system
 270      * lacks any way to say "set LC_CTYPE to utf-8, ignoring the
 271      * default system locale if it specifies something different". We
 272      * could try to work around that flaw by leaving LC_CTYPE to the C
 273      * locale and only setting LC_MESSAGES (which is the variable that
 274      * must be set to tell gettext which language to translate
 275      * to). However if we leave LC_MESSAGES set then things like
 276      * strerror() may produce completely garbled output when they try
 277      * to translate their results but then try to convert some
 278      * translated non-ASCII text to the character set specified by
 279      * LC_CTYPE which would still be in the C locale (this doesn't
 280      * affect gettext itself because it supports specifying the
 281      * character set directly with bind_textdomain_codeset()).
 282      *
 283      * So the only solution (at leat short of trying to work around
 284      * things possibly producing non-utf-8 output) is to leave all the
 285      * locale variables unset. Note that this means it's not possible
 286      * to get translated output from any libraries we call if they
 287      * only rely on the broken locale system to specify the language
 288      * to use; this is the case with libc for example.
 289      *
 290      * The locale changing below is rather ugly, but hard to avoid.
 291      * gettext doesn't support specifying the translation target
 292      * directly, only through locale.
 293      * The main actual problem this could cause is interference with
 294      * other threads; that could be avoided with thread-specific
 295      * locale changes, but such functionality is less standard and I
 296      * think it's not worth adding pre-emptively unless someone sees
 297      * an actual problem case.
 298      */
 299     setlocale(LC_MESSAGES, "");
 300     string = gettext(string);
 301     setlocale(LC_MESSAGES, "C");
 302 #endif
 303     return string;
 304 }
 305
 306 void mp_tmsg(int mod, int lev, const char *format, ...)
 307 {
 308     va_list va;
 309     va_start(va, format);
 310     mp_msg_va(mod, lev, mp_gtext(format), va);
 311     va_end(va);
 312 }