Rename mp_msg to ass_msg

diff --git a/libass/ass.c b/libass/ass.c
index 53f5d97b9f0e30d2161168b987383a1f4ce1c992..19e3fd3646cbf33daae90f91c2ece6b8bad5c2f2 100644 (file)
--- a/libass/ass.c
+++ b/libass/ass.c
@@ -183,7 +183,7 @@ static int lookup_style(ass_track_t *track, char *name)
             return i;
     }
     i = track->default_style;
-    mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NoStyleNamedXFoundUsingY,
+    ass_msg(MSGL_WARN, MSGTR_LIBASS_NoStyleNamedXFoundUsingY,
            track, name, track->styles[i].Name);
     return i;                   // use the first style
 }
@@ -201,7 +201,7 @@ static long long string2timecode(char *p)
     long long tm;
     int res = sscanf(p, "%1d:%2d:%2d.%2d", &h, &m, &s, &ms);
     if (res < 4) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_BadTimestamp);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_BadTimestamp);
         return 0;
     }
     tm = ((h * 60 + m) * 60 + s) * 1000 + ms * 10;
@@ -229,13 +229,13 @@ static int numpad2align(int val)
 #define ANYVAL(name,func) \
        } else if (strcasecmp(tname, #name) == 0) { \
                target->name = func(token); \
-               mp_msg(MSGT_ASS, MSGL_DBG2, "%s = %s\n", #name, token);
+               ass_msg(MSGL_DBG2, "%s = %s\n", #name, token);
 
 #define STRVAL(name) \
        } else if (strcasecmp(tname, #name) == 0) { \
                if (target->name != NULL) free(target->name); \
                target->name = strdup(token); \
-               mp_msg(MSGT_ASS, MSGL_DBG2, "%s = %s\n", #name, token);
+               ass_msg(MSGL_DBG2, "%s = %s\n", #name, token);
 
 #define COLORVAL(name) ANYVAL(name,string2color)
 #define INTVAL(name) ANYVAL(name,atoi)
@@ -244,7 +244,7 @@ static int numpad2align(int val)
 #define STYLEVAL(name) \
        } else if (strcasecmp(tname, #name) == 0) { \
                target->name = lookup_style(track, token); \
-               mp_msg(MSGT_ASS, MSGL_DBG2, "%s = %s\n", #name, token);
+               ass_msg(MSGL_DBG2, "%s = %s\n", #name, token);
 
 #define ALIAS(alias,name) \
        if (strcasecmp(tname, #alias) == 0) {tname = #name;}
@@ -318,7 +318,7 @@ static int process_event_tail(ass_track_t *track, ass_event_t *event,
                 if (last >= event->Text && *last == '\r')
                     *last = 0;
             }
-            mp_msg(MSGT_ASS, MSGL_DBG2, "Text = %s\n", event->Text);
+            ass_msg(MSGL_DBG2, "Text = %s\n", event->Text);
             event->Duration -= event->Start;
             free(format);
             return 0;           // "Text" is always the last
@@ -458,7 +458,7 @@ static int process_style(ass_track_t *track, char *str)
 
     q = format = strdup(track->style_format);
 
-    mp_msg(MSGT_ASS, MSGL_V, "[%p] Style: %s\n", track, str);
+    ass_msg(MSGL_V, "[%p] Style: %s\n", track, str);
 
     sid = ass_alloc_style(track);
 
@@ -535,7 +535,7 @@ static int process_styles_line(ass_track_t *track, char *str)
         char *p = str + 7;
         skip_spaces(&p);
         track->style_format = strdup(p);
-        mp_msg(MSGT_ASS, MSGL_DBG2, "Style format: %s\n",
+        ass_msg(MSGL_DBG2, "Style format: %s\n",
                track->style_format);
     } else if (!strncmp(str, "Style:", 6)) {
         char *p = str + 6;
@@ -567,7 +567,7 @@ static int process_events_line(ass_track_t *track, char *str)
         char *p = str + 7;
         skip_spaces(&p);
         track->event_format = strdup(p);
-        mp_msg(MSGT_ASS, MSGL_DBG2, "Event format: %s\n",
+        ass_msg(MSGL_DBG2, "Event format: %s\n",
                track->event_format);
     } else if (!strncmp(str, "Dialogue:", 9)) {
         // This should never be reached for embedded subtitles.
@@ -584,7 +584,7 @@ static int process_events_line(ass_track_t *track, char *str)
 
         process_event_tail(track, event, str, 0);
     } else {
-        mp_msg(MSGT_ASS, MSGL_V, "Not understood: %s  \n", str);
+        ass_msg(MSGL_V, "Not understood: %s  \n", str);
     }
     return 0;
 }
@@ -619,11 +619,11 @@ static int decode_font(ass_track_t *track)
     int dsize;                  // decoded size
     unsigned char *buf = 0;
 
-    mp_msg(MSGT_ASS, MSGL_V, "font: %d bytes encoded data \n",
+    ass_msg(MSGL_V, "font: %d bytes encoded data \n",
            track->parser_priv->fontdata_used);
     size = track->parser_priv->fontdata_used;
     if (size % 4 == 1) {
-        mp_msg(MSGT_ASS, MSGL_ERR, MSGTR_LIBASS_BadEncodedDataSize);
+        ass_msg(MSGL_ERR, MSGTR_LIBASS_BadEncodedDataSize);
         goto error_decode_font;
     }
     buf = malloc(size / 4 * 3 + 2);
@@ -669,19 +669,19 @@ static int process_fonts_line(ass_track_t *track, char *str)
             decode_font(track);
         }
         track->parser_priv->fontname = strdup(p);
-        mp_msg(MSGT_ASS, MSGL_V, "fontname: %s\n",
+        ass_msg(MSGL_V, "fontname: %s\n",
                track->parser_priv->fontname);
         return 0;
     }
 
     if (!track->parser_priv->fontname) {
-        mp_msg(MSGT_ASS, MSGL_V, "Not understood: %s  \n", str);
+        ass_msg(MSGL_V, "Not understood: %s  \n", str);
         return 0;
     }
 
     len = strlen(str);
     if (len > 80) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FontLineTooLong, len, str);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_FontLineTooLong, len, str);
         return 0;
     }
     if (track->parser_priv->fontdata_used + len >
@@ -784,7 +784,7 @@ void ass_process_data(ass_track_t *track, char *data, int size)
     memcpy(str, data, size);
     str[size] = '\0';
 
-    mp_msg(MSGT_ASS, MSGL_V, "event: %s\n", str);
+    ass_msg(MSGL_V, "event: %s\n", str);
     process_text(track, str);
     free(str);
 }
@@ -844,14 +844,14 @@ void ass_process_chunk(ass_track_t *track, char *data, int size,
     ass_event_t *event;
 
     if (!track->event_format) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_EventFormatHeaderMissing);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_EventFormatHeaderMissing);
         return;
     }
 
     str = malloc(size + 1);
     memcpy(str, data, size);
     str[size] = '\0';
-    mp_msg(MSGT_ASS, MSGL_V, "event at %" PRId64 ", +%" PRId64 ": %s  \n",
+    ass_msg(MSGL_V, "event at %" PRId64 ", +%" PRId64 ": %s  \n",
            (int64_t) timecode, (int64_t) duration, str);
 
     eid = ass_alloc_event(track);
@@ -910,9 +910,9 @@ static char *sub_recode(char *data, size_t size, char *codepage)
         }
 #endif
         if ((icdsc = iconv_open(tocp, cp_tmp)) != (iconv_t) (-1)) {
-            mp_msg(MSGT_ASS, MSGL_V, "LIBSUB: opened iconv descriptor.\n");
+            ass_msg(MSGL_V, "LIBSUB: opened iconv descriptor.\n");
         } else
-            mp_msg(MSGT_ASS, MSGL_ERR,
+            ass_msg(MSGL_ERR,
                    MSGTR_LIBASS_ErrorOpeningIconvDescriptor);
     }
 
@@ -944,7 +944,7 @@ static char *sub_recode(char *data, size_t size, char *codepage)
                     osize += size;
                     oleft += size;
                 } else {
-                    mp_msg(MSGT_ASS, MSGL_WARN,
+                    ass_msg(MSGL_WARN,
                            MSGTR_LIBASS_ErrorRecodingFile);
                     return NULL;
                 }
@@ -957,7 +957,7 @@ static char *sub_recode(char *data, size_t size, char *codepage)
     if (icdsc != (iconv_t) (-1)) {
         (void) iconv_close(icdsc);
         icdsc = (iconv_t) (-1);
-        mp_msg(MSGT_ASS, MSGL_V, "LIBSUB: closed iconv descriptor.\n");
+        ass_msg(MSGL_V, "LIBSUB: closed iconv descriptor.\n");
     }
 
     return outbuf;
@@ -979,12 +979,12 @@ static char *read_file(char *fname, size_t *bufsize)
 
     FILE *fp = fopen(fname, "rb");
     if (!fp) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FopenFailed, fname);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_FopenFailed, fname);
         return 0;
     }
     res = fseek(fp, 0, SEEK_END);
     if (res == -1) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FseekFailed, fname);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_FseekFailed, fname);
         fclose(fp);
         return 0;
     }
@@ -993,13 +993,13 @@ static char *read_file(char *fname, size_t *bufsize)
     rewind(fp);
 
     if (sz > 10 * 1024 * 1024) {
-        mp_msg(MSGT_ASS, MSGL_INFO,
+        ass_msg(MSGL_INFO,
                MSGTR_LIBASS_RefusingToLoadSubtitlesLargerThan10M, fname);
         fclose(fp);
         return 0;
     }
 
-    mp_msg(MSGT_ASS, MSGL_V, "file size: %ld\n", sz);
+    ass_msg(MSGL_V, "file size: %ld\n", sz);
 
     buf = malloc(sz + 1);
     assert(buf);
@@ -1007,7 +1007,7 @@ static char *read_file(char *fname, size_t *bufsize)
     do {
         res = fread(buf + bytes_read, 1, sz - bytes_read, fp);
         if (res <= 0) {
-            mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_ReadFailed, errno,
+            ass_msg(MSGL_INFO, MSGTR_LIBASS_ReadFailed, errno,
                    strerror(errno));
             fclose(fp);
             free(buf);
@@ -1085,7 +1085,7 @@ ass_track_t *ass_read_memory(ass_library_t *library, char *buf,
     if (!track)
         return 0;
 
-    mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_AddedSubtitleFileMemory,
+    ass_msg(MSGL_INFO, MSGTR_LIBASS_AddedSubtitleFileMemory,
            track->n_styles, track->n_events);
     return track;
 }
@@ -1135,7 +1135,7 @@ ass_track_t *ass_read_file(ass_library_t *library, char *fname,
 
     track->name = strdup(fname);
 
-    mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_AddedSubtitleFileFname, fname,
+    ass_msg(MSGL_INFO, MSGTR_LIBASS_AddedSubtitleFileFname, fname,
            track->n_styles, track->n_events);
 
 //      dump_events(forced_tid);

diff --git a/libass/ass_bitmap.c b/libass/ass_bitmap.c
index 8df24f6e08d45a2a9646a5f527b3c3ff5335d873..75281dbe14180ff5c5ce7190a323412fe3ca4ccd 100644 (file)
--- a/libass/ass_bitmap.c
+++ b/libass/ass_bitmap.c
@@ -173,7 +173,7 @@ static int check_glyph_area(FT_Glyph glyph)
     dx = bbox.xMax - bbox.xMin;
     dy = bbox.yMax - bbox.yMin;
     if (dx * dy > 8000000) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_GlyphBBoxTooLarge,
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_GlyphBBoxTooLarge,
                (int) dx, (int) dy);
         return 1;
     } else
@@ -195,7 +195,7 @@ static bitmap_t *glyph_to_bitmap_internal(FT_Glyph glyph, int bord)
         return 0;
     error = FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 0);
     if (error) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FT_Glyph_To_BitmapError,
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_FT_Glyph_To_BitmapError,
                error);
         return 0;
     }
@@ -203,7 +203,7 @@ static bitmap_t *glyph_to_bitmap_internal(FT_Glyph glyph, int bord)
     bg = (FT_BitmapGlyph) glyph;
     bit = &(bg->bitmap);
     if (bit->pixel_mode != FT_PIXEL_MODE_GRAY) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UnsupportedPixelMode,
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_UnsupportedPixelMode,
                (int) (bit->pixel_mode));
         FT_Done_Glyph(glyph);
         return 0;

diff --git a/libass/ass_cache.c b/libass/ass_cache.c
index 309d580147a501fc2d238b4485e1e5692416da7b..278b14ac9cb0ef28084f9c085138498ec3f227e9 100644 (file)
--- a/libass/ass_cache.c
+++ b/libass/ass_cache.c
@@ -99,7 +99,7 @@ void hashmap_done(hashmap_t *map)
     int i;
     // print stats
     if (map->count > 0 || map->hit_count + map->miss_count > 0)
-        mp_msg(MSGT_ASS, MSGL_V,
+        ass_msg(MSGL_V,
                "cache statistics: \n  total accesses: %d\n  hits: %d\n  misses: %d\n  object count: %d\n",
                map->hit_count + map->miss_count, map->hit_count,
                map->miss_count, map->count);

diff --git a/libass/ass_font.c b/libass/ass_font.c
index b34239356b613cc58c761909971620d251d5a5d6..7524b9875101b8f0bdbf18ca56ccb1bafe5dd1ff 100644 (file)
--- a/libass/ass_font.c
+++ b/libass/ass_font.c
@@ -57,10 +57,10 @@ static void charmap_magic(FT_Face face)
 
     if (!face->charmap) {
         if (face->num_charmaps == 0) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NoCharmaps);
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_NoCharmaps);
             return;
         }
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NoCharmapAutodetected);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_NoCharmapAutodetected);
         FT_Set_Charmap(face, face->charmaps[0]);
         return;
     }
@@ -141,14 +141,14 @@ static int add_face(void *fc_priv, ass_font_t *font, uint32_t ch)
                                font->library->fontdata[mem_idx].size, 0,
                                &face);
         if (error) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_ErrorOpeningMemoryFont,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_ErrorOpeningMemoryFont,
                    path);
             return -1;
         }
     } else {
         error = FT_New_Face(font->ftlibrary, path, index, &face);
         if (error) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_ErrorOpeningFont, path,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_ErrorOpeningFont, path,
                    index);
             return -1;
         }
@@ -303,7 +303,7 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
 #ifdef CONFIG_FONTCONFIG
     if (index == 0) {
         int face_idx;
-        mp_msg(MSGT_ASS, MSGL_INFO,
+        ass_msg(MSGL_INFO,
                MSGTR_LIBASS_GlyphNotFoundReselectingFont, ch,
                font->desc.family, font->desc.bold, font->desc.italic);
         face_idx = add_face(fontconfig_priv, font, ch);
@@ -311,7 +311,7 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
             face = font->faces[face_idx];
             index = FT_Get_Char_Index(face, ch);
             if (index == 0) {
-                mp_msg(MSGT_ASS, MSGL_ERR, MSGTR_LIBASS_GlyphNotFound,
+                ass_msg(MSGL_ERR, MSGTR_LIBASS_GlyphNotFound,
                        ch, font->desc.family, font->desc.bold,
                        font->desc.italic);
             }
@@ -336,7 +336,7 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
 
     error = FT_Load_Glyph(face, index, FT_LOAD_NO_BITMAP | flags);
     if (error) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_ErrorLoadingGlyph);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_ErrorLoadingGlyph);
         return 0;
     }
 #if (FREETYPE_MAJOR > 2) || \
@@ -350,7 +350,7 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
 #endif
     error = FT_Get_Glyph(face->glyph, &glyph);
     if (error) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_ErrorLoadingGlyph);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_ErrorLoadingGlyph);
         return 0;
     }
 

diff --git a/libass/ass_fontconfig.c b/libass/ass_fontconfig.c
index 54479cf2b38955e2aeea665d8db81216b2207fc6..4fb2155718925c29b44870396c9244f348dc2eea 100644 (file)
--- a/libass/ass_fontconfig.c
+++ b/libass/ass_fontconfig.c
@@ -193,7 +193,7 @@ static char *_select_font(fc_instance_t *priv, const char *family,
     if (!treat_family_as_pattern &&
         !(r_family && strcasecmp((const char *) r_family, family) == 0) &&
         !(r_fullname && strcasecmp((const char *) r_fullname, family) == 0))
-        mp_msg(MSGT_ASS, MSGL_WARN,
+        ass_msg(MSGL_WARN,
                MSGTR_LIBASS_SelectedFontFamilyIsNotTheRequestedOne,
                (const char *) (r_fullname ? r_fullname : r_family), family);
 
@@ -213,7 +213,7 @@ static char *_select_font(fc_instance_t *priv, const char *family,
     if (result != FcResultMatch)
         r_embolden = 0;
 
-    mp_msg(MSGT_ASS, MSGL_V,
+    ass_msg(MSGL_V,
            "[ass] Font info: family '%s', style '%s', fullname '%s',"
            " slant %d, weight %d%s\n", (const char *) r_family,
            (const char *) r_style, (const char *) r_fullname, r_slant,
@@ -258,23 +258,23 @@ char *fontconfig_select(fc_instance_t *priv, const char *family,
             _select_font(priv, priv->family_default, 0, bold, italic, index,
                          code);
         if (res)
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UsingDefaultFontFamily,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_UsingDefaultFontFamily,
                    family, bold, italic, res, *index);
     }
     if (!res && priv->path_default) {
         res = priv->path_default;
         *index = priv->index_default;
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UsingDefaultFont,
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_UsingDefaultFont,
                family, bold, italic, res, *index);
     }
     if (!res) {
         res = _select_font(priv, "Arial", 0, bold, italic, index, code);
         if (res)
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UsingArialFontFamily,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_UsingArialFontFamily,
                    family, bold, italic, res, *index);
     }
     if (res)
-        mp_msg(MSGT_ASS, MSGL_V,
+        ass_msg(MSGL_V,
                "fontconfig_select: (%s, %d, %d) -> %s, %d\n", family, bold,
                italic, res, *index);
     return res;
@@ -350,11 +350,11 @@ static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
         res = mkdir(fonts_dir);
 #endif
         if (res) {
-            mp_msg(MSGT_ASS, MSGL_WARN,
+            ass_msg(MSGL_WARN,
                    MSGTR_LIBASS_FailedToCreateDirectory, fonts_dir);
         }
     } else if (!S_ISDIR(st.st_mode)) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NotADirectory, fonts_dir);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_NotADirectory, fonts_dir);
     }
 
     fname = validate_fname((char *) name);
@@ -380,7 +380,7 @@ static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
         rc = FT_New_Memory_Face(ftlibrary, (unsigned char *) data,
                                 data_size, face_index, &face);
         if (rc) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_ErrorOpeningMemoryFont,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_ErrorOpeningMemoryFont,
                    name);
             return;
         }
@@ -390,7 +390,7 @@ static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
             FcFreeTypeQueryFace(face, (unsigned char *) name, 0,
                                 FcConfigGetBlanks(priv->config));
         if (!pattern) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed,
                    "FcFreeTypeQueryFace");
             FT_Done_Face(face);
             return;
@@ -398,7 +398,7 @@ static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
 
         fset = FcConfigGetFonts(priv->config, FcSetSystem);     // somehow it failes when asked for FcSetApplication
         if (!fset) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed,
                    "FcConfigGetFonts");
             FT_Done_Face(face);
             return;
@@ -406,7 +406,7 @@ static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
 
         res = FcFontSetAdd(fset, pattern);
         if (!res) {
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed,
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed,
                    "FcFontSetAdd");
             FT_Done_Face(face);
             return;
@@ -435,7 +435,7 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
     int i;
 
     if (!fc) {
-        mp_msg(MSGT_ASS, MSGL_WARN,
+        ass_msg(MSGL_WARN,
                MSGTR_LIBASS_FontconfigDisabledDefaultFontWillBeUsed);
         goto exit;
     }
@@ -453,7 +453,7 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
     }
 
     if (!rc || !priv->config) {
-        mp_msg(MSGT_ASS, MSGL_FATAL,
+        ass_msg(MSGL_FATAL,
                MSGTR_LIBASS_FcInitLoadConfigAndFontsFailed);
         goto exit;
     }
@@ -463,9 +463,9 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
 
     if (dir) {
         if (FcDirCacheValid((const FcChar8 *) dir) == FcFalse) {
-            mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_UpdatingFontCache);
+            ass_msg(MSGL_INFO, MSGTR_LIBASS_UpdatingFontCache);
             if (FcGetVersion() >= 20390 && FcGetVersion() < 20400)
-                mp_msg(MSGT_ASS, MSGL_WARN,
+                ass_msg(MSGL_WARN,
                        MSGTR_LIBASS_BetaVersionsOfFontconfigAreNotSupported);
             // FontConfig >= 2.4.0 updates cache automatically in FcConfigAppFontAddDir()
             if (FcGetVersion() < 20390) {
@@ -475,7 +475,7 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
                 fss = FcStrSetCreate();
                 rc = FcStrSetAdd(fss, (const FcChar8 *) dir);
                 if (!rc) {
-                    mp_msg(MSGT_ASS, MSGL_WARN,
+                    ass_msg(MSGL_WARN,
                            MSGTR_LIBASS_FcStrSetAddFailed);
                     goto ErrorFontCache;
                 }
@@ -484,14 +484,14 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
                                FcConfigGetBlanks(priv->config),
                                (const FcChar8 *) dir, FcFalse);
                 if (!rc) {
-                    mp_msg(MSGT_ASS, MSGL_WARN,
+                    ass_msg(MSGL_WARN,
                            MSGTR_LIBASS_FcDirScanFailed);
                     goto ErrorFontCache;
                 }
 
                 rc = FcDirSave(fcs, fss, (const FcChar8 *) dir);
                 if (!rc) {
-                    mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcDirSave);
+                    ass_msg(MSGL_WARN, MSGTR_LIBASS_FcDirSave);
                     goto ErrorFontCache;
                 }
               ErrorFontCache:
@@ -501,7 +501,7 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
 
         rc = FcConfigAppFontAddDir(priv->config, (const FcChar8 *) dir);
         if (!rc) {
-            mp_msg(MSGT_ASS, MSGL_WARN,
+            ass_msg(MSGL_WARN,
                    MSGTR_LIBASS_FcConfigAppFontAddDirFailed);
         }
     }
@@ -530,7 +530,7 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
 {
     fc_instance_t *priv;
 
-    mp_msg(MSGT_ASS, MSGL_WARN,
+    ass_msg(MSGL_WARN,
            MSGTR_LIBASS_FontconfigDisabledDefaultFontWillBeUsed);
 
     priv = calloc(1, sizeof(fc_instance_t));

diff --git a/libass/ass_render.c b/libass/ass_render.c
index f99a8aa5cd9efbee68126828d20d35228cef7eb7..f21069d85f9c9e6dc0afd0b81619ebaf65a1b7be 100644 (file)
--- a/libass/ass_render.c
+++ b/libass/ass_render.c
@@ -239,7 +239,7 @@ static void ass_lazy_track_init(ass_renderer_t *render_priv)
     if (track->PlayResX && track->PlayResY)
         return;
     if (!track->PlayResX && !track->PlayResY) {
-        mp_msg(MSGT_ASS, MSGL_WARN,
+        ass_msg(MSGL_WARN,
                MSGTR_LIBASS_NeitherPlayResXNorPlayResYDefined);
         track->PlayResX = 384;
         track->PlayResY = 288;
@@ -250,19 +250,19 @@ static void ass_lazy_track_init(ass_renderer_t *render_priv)
             render_priv->width;
         if (!track->PlayResY && track->PlayResX == 1280) {
             track->PlayResY = 1024;
-            mp_msg(MSGT_ASS, MSGL_WARN,
+            ass_msg(MSGL_WARN,
                    MSGTR_LIBASS_PlayResYUndefinedSettingY, track->PlayResY);
         } else if (!track->PlayResY) {
             track->PlayResY = track->PlayResX / orig_aspect + .5;
-            mp_msg(MSGT_ASS, MSGL_WARN,
+            ass_msg(MSGL_WARN,
                    MSGTR_LIBASS_PlayResYUndefinedSettingY, track->PlayResY);
         } else if (!track->PlayResX && track->PlayResY == 1024) {
             track->PlayResX = 1280;
-            mp_msg(MSGT_ASS, MSGL_WARN,
+            ass_msg(MSGL_WARN,
                    MSGTR_LIBASS_PlayResXUndefinedSettingX, track->PlayResX);
         } else if (!track->PlayResX) {
             track->PlayResX = track->PlayResY * orig_aspect + .5;
-            mp_msg(MSGT_ASS, MSGL_WARN,
+            ass_msg(MSGL_WARN,
                    MSGTR_LIBASS_PlayResXUndefinedSettingX, track->PlayResX);
         }
     }
@@ -277,14 +277,14 @@ ass_renderer_t *ass_renderer_init(ass_library_t *library)
 
     error = FT_Init_FreeType(&ft);
     if (error) {
-        mp_msg(MSGT_ASS, MSGL_FATAL, MSGTR_LIBASS_FT_Init_FreeTypeFailed);
+        ass_msg(MSGL_FATAL, MSGTR_LIBASS_FT_Init_FreeTypeFailed);
         goto ass_init_exit;
     }
 
     FT_Library_Version(ft, &vmajor, &vminor, &vpatch);
-    mp_msg(MSGT_ASS, MSGL_V, "FreeType library version: %d.%d.%d\n",
+    ass_msg(MSGL_V, "FreeType library version: %d.%d.%d\n",
            vmajor, vminor, vpatch);
-    mp_msg(MSGT_ASS, MSGL_V, "FreeType headers version: %d.%d.%d\n",
+    ass_msg(MSGL_V, "FreeType headers version: %d.%d.%d\n",
            FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH);
 
     priv = calloc(1, sizeof(ass_renderer_t));
@@ -312,9 +312,9 @@ ass_renderer_t *ass_renderer_init(ass_library_t *library)
 
   ass_init_exit:
     if (priv)
-        mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_Init);
+        ass_msg(MSGL_INFO, MSGTR_LIBASS_Init);
     else
-        mp_msg(MSGT_ASS, MSGL_ERR, MSGTR_LIBASS_InitFailed);
+        ass_msg(MSGL_ERR, MSGTR_LIBASS_InitFailed);
 
     return priv;
 }
@@ -404,22 +404,22 @@ static ass_image_t **render_glyph(ass_renderer_t *render_priv,
 
     tmp = dst_x - clip_x0;
     if (tmp < 0) {
-        mp_msg(MSGT_ASS, MSGL_DBG2, "clip left\n");
+        ass_msg(MSGL_DBG2, "clip left\n");
         b_x0 = -tmp;
     }
     tmp = dst_y - clip_y0;
     if (tmp < 0) {
-        mp_msg(MSGT_ASS, MSGL_DBG2, "clip top\n");
+        ass_msg(MSGL_DBG2, "clip top\n");
         b_y0 = -tmp;
     }
     tmp = clip_x1 - dst_x - bm->w;
     if (tmp < 0) {
-        mp_msg(MSGT_ASS, MSGL_DBG2, "clip right\n");
+        ass_msg(MSGL_DBG2, "clip right\n");
         b_x1 = bm->w + tmp;
     }
     tmp = clip_y1 - dst_y - bm->h;
     if (tmp < 0) {
-        mp_msg(MSGT_ASS, MSGL_DBG2, "clip bottom\n");
+        ass_msg(MSGL_DBG2, "clip bottom\n");
         b_y1 = bm->h + tmp;
     }
 
@@ -816,7 +816,7 @@ static void change_border(ass_renderer_t *render_priv, double border)
                                memory, &render_priv->state.stroker);
 #endif
             if (error) {
-                mp_msg(MSGT_ASS, MSGL_V, "failed to get stroker\n");
+                ass_msg(MSGL_V, "failed to get stroker\n");
                 render_priv->state.stroker = 0;
             }
         }
@@ -915,19 +915,19 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
     if (mystrcmp(&p, "xbord")) {
         double val;
         if (mystrtod(&p, &val))
-            mp_msg(MSGT_ASS, MSGL_V, "stub: \\xbord%.2f\n", val);
+            ass_msg(MSGL_V, "stub: \\xbord%.2f\n", val);
     } else if (mystrcmp(&p, "ybord")) {
         double val;
         if (mystrtod(&p, &val))
-            mp_msg(MSGT_ASS, MSGL_V, "stub: \\ybord%.2f\n", val);
+            ass_msg(MSGL_V, "stub: \\ybord%.2f\n", val);
     } else if (mystrcmp(&p, "xshad")) {
         int val;
         if (mystrtoi(&p, &val))
-            mp_msg(MSGT_ASS, MSGL_V, "stub: \\xshad%d\n", val);
+            ass_msg(MSGL_V, "stub: \\xshad%d\n", val);
     } else if (mystrcmp(&p, "yshad")) {
         int val;
         if (mystrtoi(&p, &val))
-            mp_msg(MSGT_ASS, MSGL_V, "stub: \\yshad%d\n", val);
+            ass_msg(MSGL_V, "stub: \\yshad%d\n", val);
     } else if (mystrcmp(&p, "fax")) {
         double val;
         if (mystrtod(&p, &val))
@@ -952,7 +952,7 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
         skip(',');
         res &= mystrtoi(&p, &y1);
         skip(')');
-        mp_msg(MSGT_ASS, MSGL_V, "stub: \\iclip(%d,%d,%d,%d)\n", x0, y0,
+        ass_msg(MSGL_V, "stub: \\iclip(%d,%d,%d,%d)\n", x0, y0,
                x1, y1);
     } else if (mystrcmp(&p, "blur")) {
         double val;
@@ -1024,14 +1024,14 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
             mystrtoll(&p, &t1);
             skip(',');
             mystrtoll(&p, &t2);
-            mp_msg(MSGT_ASS, MSGL_DBG2,
+            ass_msg(MSGL_DBG2,
                    "movement6: (%f, %f) -> (%f, %f), (%" PRId64 " .. %"
                    PRId64 ")\n", x1, y1, x2, y2, (int64_t) t1,
                    (int64_t) t2);
         } else {
             t1 = 0;
             t2 = render_priv->state.event->Duration;
-            mp_msg(MSGT_ASS, MSGL_DBG2,
+            ass_msg(MSGL_DBG2,
                    "movement: (%f, %f) -> (%f, %f)\n", x1, y1, x2, y2);
         }
         skip(')');
@@ -1112,12 +1112,12 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
         int val;
         if (mystrtoi(&p, &val) && val) {
             int v = (val - 1) / 3;      // 0, 1 or 2 for vertical alignment
-            mp_msg(MSGT_ASS, MSGL_DBG2, "an %d\n", val);
+            ass_msg(MSGL_DBG2, "an %d\n", val);
             if (v != 0)
                 v = 3 - v;
             val = ((val - 1) % 3) + 1;  // horizontal alignment
             val += v * 4;
-            mp_msg(MSGT_ASS, MSGL_DBG2, "align %d\n", val);
+            ass_msg(MSGL_DBG2, "align %d\n", val);
             render_priv->state.alignment = val;
         } else
             render_priv->state.alignment =
@@ -1136,9 +1136,9 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
         skip(',');
         mystrtod(&p, &v2);
         skip(')');
-        mp_msg(MSGT_ASS, MSGL_DBG2, "pos(%f, %f)\n", v1, v2);
+        ass_msg(MSGL_DBG2, "pos(%f, %f)\n", v1, v2);
         if (render_priv->state.evt_type == EVENT_POSITIONED) {
-            mp_msg(MSGT_ASS, MSGL_V, "Subtitle has a new \\pos "
+            ass_msg(MSGL_V, "Subtitle has a new \\pos "
                    "after \\move or \\pos, ignoring\n");
         } else {
             render_priv->state.evt_type = EVENT_POSITIONED;
@@ -1191,7 +1191,7 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
         skip(',');
         mystrtoi(&p, &v2);
         skip(')');
-        mp_msg(MSGT_ASS, MSGL_DBG2, "org(%d, %d)\n", v1, v2);
+        ass_msg(MSGL_DBG2, "org(%d, %d)\n", v1, v2);
         //                              render_priv->state.evt_type = EVENT_POSITIONED;
         if (!render_priv->state.have_origin) {
             render_priv->state.org_x = v1;
@@ -1280,7 +1280,7 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
         uint32_t val;
         if (!strtocolor(&p, &val))
             val = render_priv->state.style->PrimaryColour;
-        mp_msg(MSGT_ASS, MSGL_DBG2, "color: %X\n", val);
+        ass_msg(MSGL_DBG2, "color: %X\n", val);
         change_color(&render_priv->state.c[0], val, pwr);
     } else if ((*p >= '1') && (*p <= '4') && (++p)
                && (mystrcmp(&p, "c") || mystrcmp(&p, "a"))) {
@@ -1315,10 +1315,10 @@ static char *parse_tag(ass_renderer_t *render_priv, char *p, double pwr)
             change_alpha(render_priv->state.c + cidx, val >> 24, pwr);
             break;
         default:
-            mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_BadCommand, n, cmd);
+            ass_msg(MSGL_WARN, MSGTR_LIBASS_BadCommand, n, cmd);
             break;
         }
-        mp_msg(MSGT_ASS, MSGL_DBG2, "single c/a at %f: %c%c = %X   \n",
+        ass_msg(MSGL_DBG2, "single c/a at %f: %c%c = %X   \n",
                pwr, n, cmd, render_priv->state.c[cidx]);
     } else if (mystrcmp(&p, "r")) {
         reset_render_context(render_priv);
@@ -1415,7 +1415,7 @@ static unsigned get_next_char(ass_renderer_t *render_priv, char **str)
                 } else
                     break;
             } else if (*p != '\\')
-                mp_msg(MSGT_ASS, MSGL_V, "Unable to parse: \"%s\" \n", p);
+                ass_msg(MSGL_V, "Unable to parse: \"%s\" \n", p);
             if (*p == 0)
                 break;
         }
@@ -1461,7 +1461,7 @@ apply_transition_effects(ass_renderer_t *render_priv, ass_event_t *event)
     if (strncmp(event->Effect, "Banner;", 7) == 0) {
         int delay;
         if (cnt < 1) {
-            mp_msg(MSGT_ASS, MSGL_V, "Error parsing effect: %s \n",
+            ass_msg(MSGL_V, "Error parsing effect: %s \n",
                    event->Effect);
             return;
         }
@@ -1484,7 +1484,7 @@ apply_transition_effects(ass_renderer_t *render_priv, ass_event_t *event)
     } else if (strncmp(event->Effect, "Scroll down;", 12) == 0) {
         render_priv->state.scroll_direction = SCROLL_TB;
     } else {
-        mp_msg(MSGT_ASS, MSGL_V, "Unknown transition effect: %s \n",
+        ass_msg(MSGL_V, "Unknown transition effect: %s \n",
                event->Effect);
         return;
     }
@@ -1493,7 +1493,7 @@ apply_transition_effects(ass_renderer_t *render_priv, ass_event_t *event)
         int delay;
         int y0, y1;
         if (cnt < 3) {
-            mp_msg(MSGT_ASS, MSGL_V, "Error parsing effect: %s \n",
+            ass_msg(MSGL_V, "Error parsing effect: %s \n",
                    event->Effect);
             return;
         }
@@ -1731,7 +1731,7 @@ get_outline_glyph(ass_renderer_t *render_priv, int symbol,
                 FT_Glyph_StrokeBorder(&(info->outline_glyph),
                                       render_priv->state.stroker, 0, 1);
             if (error) {
-                mp_msg(MSGT_ASS, MSGL_WARN,
+                ass_msg(MSGL_WARN,
                        MSGTR_LIBASS_FT_Glyph_Stroke_Error, error);
             }
         }
@@ -1881,7 +1881,7 @@ wrap_lines_smart(ass_renderer_t *render_priv, double max_text_width)
         if (cur->symbol == '\n') {
             break_type = 2;
             break_at = i;
-            mp_msg(MSGT_ASS, MSGL_DBG2, "forced line break at %d\n",
+            ass_msg(MSGL_DBG2, "forced line break at %d\n",
                    break_at);
         }
 
@@ -1893,8 +1893,8 @@ wrap_lines_smart(ass_renderer_t *render_priv, double max_text_width)
                 break_at = i - 1;
             if (break_at == -1)
                 break_at = 0;
-            mp_msg(MSGT_ASS, MSGL_DBG2, "overfill at %d\n", i);
-            mp_msg(MSGT_ASS, MSGL_DBG2, "line break at %d\n", break_at);
+            ass_msg(MSGL_DBG2, "overfill at %d\n", i);
+            ass_msg(MSGL_DBG2, "line break at %d\n", break_at);
         }
 
         if (break_at != -1) {
@@ -1993,7 +1993,7 @@ wrap_lines_smart(ass_renderer_t *render_priv, double max_text_width)
             cur_line++;
             pen_shift_x = d6_to_double(-cur->pos.x);
             pen_shift_y += height + render_priv->settings.line_spacing;
-            mp_msg(MSGT_ASS, MSGL_DBG2,
+            ass_msg(MSGL_DBG2,
                    "shifting from %d to %d by (%f, %f)\n", i,
                    text_info->length - 1, pen_shift_x, pen_shift_y);
         }
@@ -2058,7 +2058,7 @@ static void process_karaoke_effects(ass_renderer_t *render_priv)
                     dt /= (tm_end - tm_start);
                     x = x_start + (x_end - x_start) * dt;
                 } else {
-                    mp_msg(MSGT_ASS, MSGL_ERR,
+                    ass_msg(MSGL_ERR,
                            MSGTR_LIBASS_UnknownEffectType_InternalError);
                     continue;
                 }
@@ -2207,11 +2207,11 @@ ass_render_event(ass_renderer_t *render_priv, ass_event_t *event,
     text_info_t *text_info = &render_priv->text_info;
 
     if (event->Style >= render_priv->track->n_styles) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NoStyleFound);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_NoStyleFound);
         return 1;
     }
     if (!event->Text) {
-        mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_EmptyEvent);
+        ass_msg(MSGL_WARN, MSGTR_LIBASS_EmptyEvent);
         return 1;
     }
 
@@ -2465,7 +2465,7 @@ ass_render_event(ass_renderer_t *render_priv, ass_event_t *event,
         } else {                // subtitle
             double scr_y;
             if (valign != VALIGN_SUB)
-                mp_msg(MSGT_ASS, MSGL_V,
+                ass_msg(MSGL_V,
                        "Invalid valign, supposing 0 (subtitle)\n");
             scr_y =
                 y2scr_sub(render_priv,
@@ -2491,7 +2491,7 @@ ass_render_event(ass_renderer_t *render_priv, ass_event_t *event,
     if (render_priv->state.evt_type == EVENT_POSITIONED) {
         double base_x = 0;
         double base_y = 0;
-        mp_msg(MSGT_ASS, MSGL_DBG2, "positioned event at %f, %f\n",
+        ass_msg(MSGL_DBG2, "positioned event at %f, %f\n",
                render_priv->state.pos_x, render_priv->state.pos_y);
         get_base_point(&bbox, alignment, &base_x, &base_y);
         device_x =
@@ -2865,7 +2865,7 @@ fix_collisions(ass_renderer_t *render_priv, event_images_t *imgs, int cnt)
             s.a = priv->top;
             s.b = priv->top + priv->height;
             if (priv->height != imgs[i].height) {       // no, it's not
-                mp_msg(MSGT_ASS, MSGL_WARN,
+                ass_msg(MSGL_WARN,
                        MSGTR_LIBASS_EventHeightHasChanged);
                 priv->top = 0;
                 priv->height = 0;

diff --git a/libass/ass_utils.c b/libass/ass_utils.c
index 73e7433f96cb42c94fcef8c97719146baba67d51..072f325d39d6a58d2f291e65ce29688981c09591 100644 (file)
--- a/libass/ass_utils.c
+++ b/libass/ass_utils.c
@@ -82,7 +82,7 @@ int strtocolor(char **q, uint32_t *res)
     if (*p == '&')
         ++p;
     else
-        mp_msg(MSGT_ASS, MSGL_DBG2, "suspicious color format: \"%s\"\n", p);
+        ass_msg(MSGL_DBG2, "suspicious color format: \"%s\"\n", p);
 
     if (*p == 'H' || *p == 'h') {
         ++p;

diff --git a/libass/mputils.c b/libass/mputils.c
index 0818eb4addf28d2bca997d6ef385d98d0d9bc715..611a5154d301ab1882c61089408558b06aa8cda7 100644 (file)
--- a/libass/mputils.c
+++ b/libass/mputils.c
@@ -34,7 +34,7 @@
 #include <enca.h>
 #endif
 
-void my_mp_msg(int lvl, char *lvl_str, char *fmt, ...)
+void ass_msg(int lvl, char *fmt, ...)
 {
     va_list va;
     if (lvl > MSGL_INFO)
@@ -205,11 +205,11 @@ void *guess_buffer_cp(unsigned char *buffer, int buflen,
     int i;
 
     languages = enca_get_languages(&langcnt);
-    mp_msg(MSGT_ASS, MSGL_V, "ENCA supported languages: ");
+    ass_msg(MSGL_V, "ENCA supported languages: ");
     for (i = 0; i < langcnt; i++) {
-        mp_msg(MSGT_ASS, MSGL_V, "%s ", languages[i]);
+        ass_msg(MSGL_V, "%s ", languages[i]);
     }
-    mp_msg(MSGT_ASS, MSGL_V, "\n");
+    ass_msg(MSGL_V, "\n");
 
     for (i = 0; i < langcnt; i++) {
         const char *tmp;
@@ -221,7 +221,7 @@ void *guess_buffer_cp(unsigned char *buffer, int buflen,
         tmp = enca_charset_name(encoding.charset, ENCA_NAME_STYLE_ICONV);
         if (tmp && encoding.charset != ENCA_CS_UNKNOWN) {
             detected_sub_cp = strdup(tmp);
-            mp_msg(MSGT_ASS, MSGL_INFO, "ENCA detected charset: %s\n", tmp);
+            ass_msg(MSGL_INFO, "ENCA detected charset: %s\n", tmp);
         }
         enca_analyser_free(analyser);
     }
@@ -230,7 +230,7 @@ void *guess_buffer_cp(unsigned char *buffer, int buflen,
 
     if (!detected_sub_cp) {
         detected_sub_cp = strdup(fallback);
-        mp_msg(MSGT_ASS, MSGL_INFO,
+        ass_msg(MSGL_INFO,
                "ENCA detection failed: fallback to %s\n", fallback);
     }
 

diff --git a/libass/mputils.h b/libass/mputils.h
index a68f8a4b7d40ce69f2e712853b3c82c40787e5e2..d99167c981794e27eb54b74346416e530b628c4f 100644 (file)
--- a/libass/mputils.h
+++ b/libass/mputils.h
@@ -1,23 +1,6 @@
 #ifndef __MPUTILS_H__
 #define __MPUTILS_H__
 
-#include "help_mp.h"
-
-unsigned utf8_get_char(char **str);
-
-void my_mp_msg(int lvl, char *lvl_str, char *fmt, ...);
-
-#ifdef __VISUALC__
-static void mp_msg(int mod, int level, const char *fmt, ...)
-{
-    // MSVC doesn't like the # used all around for mp_msg, so it breaks va_arg
-}
-#else
-#define mp_msg(mod, level, args...) my_mp_msg(level, #level, args)
-#endif
-
-#define MSGT_ASS 43
-
 #define MSGL_FATAL 0
 #define MSGL_ERR 1
 #define MSGL_WARN 2
@@ -25,6 +8,12 @@ static void mp_msg(int mod, int level, const char *fmt, ...)
 #define MSGL_V 6
 #define MSGL_DBG2 7
 
+#include "help_mp.h"
+
+unsigned utf8_get_char(char **str);
+
+void ass_msg(int lvl, char *fmt, ...);
+
 void blur(unsigned char *buffer, unsigned short *tmp2, int width,
           int height, int stride, int *m2, int r, int mwidth);