[MPlayer-dev-eng] [PATCH] Tags support for SubRip and MicroDVD subtitles [v3]

ubitux ubitux at gmail.com
Sat Jun 19 12:12:04 CEST 2010


On Sat, Jun 19, 2010 at 12:07:38PM +0200, ubitux wrote:
> Hi,
> 
> The patch is about to be done; the only thing that can be missing is an
> option to enable/disable the style. At the moment, the -ass switch makes
> it available or not (old parsing, stripping tags).
> 
> A lot of the changes are not mine since it's a port of the tmp_sub branch
> from Uoti's mplayer-git.
> 
> The code has been tested a few times, most of SubRip & MicroDVD tags are
> supported, stylising is also available if muxed subtitle (it tries to parse
> SubRip), and it does not require modifications to the libass.
> 
> Regards,
> 

Oups I forgot bstr.{c,h} in the patch, fixed in this one.

-- 
ubitux
-------------- next part --------------
Index: Makefile
===================================================================
--- Makefile	(revision 31471)
+++ Makefile	(working copy)
@@ -329,6 +329,7 @@
 SRCS_COMMON-$(ZR)                    += libmpcodecs/vd_zrmjpeg.c \
                                         libmpcodecs/vf_zrmjpeg.c
 SRCS_COMMON = asxparser.c \
+              bstr.c \
               codec-cfg.c \
               cpudetect.c \
               edl.c \
@@ -345,6 +346,7 @@
               playtreeparser.c \
               spudec.c \
               sub_cc.c \
+              subassconvert.c \
               subopt-helper.c \
               subreader.c \
               vobsub.c \
Index: bstr.c
===================================================================
--- bstr.c	(revision 0)
+++ bstr.c	(revision 0)
@@ -0,0 +1,51 @@
+/*
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <string.h>
+#include <libavutil/avutil.h>
+#include "bstr.h"
+
+int bstrcmp(struct bstr str1, struct bstr str2)
+{
+    int ret = memcmp(str1.start, str2.start, FFMIN(str1.len, str2.len));
+
+    if (!ret) {
+        if (str1.len == str2.len)
+            return 0;
+        else if (str1.len > str2.len)
+            return 1;
+        else
+            return -1;
+    }
+    return ret;
+}
+
+int bstrcasecmp(struct bstr str1, struct bstr str2)
+{
+    int ret = strncasecmp(str1.start, str2.start, FFMIN(str1.len, str2.len));
+
+    if (!ret) {
+        if (str1.len == str2.len)
+            return 0;
+        else if (str1.len > str2.len)
+            return 1;
+        else
+            return -1;
+    }
+    return ret;
+}
Index: bstr.h
===================================================================
--- bstr.h	(revision 0)
+++ bstr.h	(revision 0)
@@ -0,0 +1,39 @@
+/*
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPLAYER_BSTR_H
+#define MPLAYER_BSTR_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+struct bstr {
+    const uint8_t *start;
+    size_t len;
+};
+
+int bstrcmp(struct bstr str1, struct bstr str2);
+int bstrcasecmp(struct bstr str1, struct bstr str2);
+
+// Create bstr compound literal from null-terminated string
+#define BSTR(s) (struct bstr){(s), (s) ? strlen(s) : 0}
+// create a pair (not single value!) for "%.*s" printf syntax
+#define BSTR_P(bstr) (int)((bstr).len), (bstr).start
+
+#endif /* MPLAYER_BSTR_H */
Index: subassconvert.c
===================================================================
--- subassconvert.c	(revision 0)
+++ subassconvert.c	(revision 0)
@@ -0,0 +1,496 @@
+/*
+ * Subtitles converter to SSA/ASS in order to allow special formatting
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdbool.h>
+
+#include "subassconvert.h"
+#include "bstr.h"
+
+#define NB_ELEMS(s)         (sizeof(s) / sizeof((s)[0]))
+
+struct line {
+    char *buf;
+    int bufsize;
+    int len;
+};
+
+#ifdef __GNUC__
+static void append_text(struct line *dst, char *fmt, ...) __attribute__ ((format(printf, 2, 3)));
+#endif
+
+static void append_text(struct line *dst, char *fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    int ret = vsnprintf(dst->buf + dst->len, dst->bufsize - dst->len, fmt, va);
+    if (ret < 0)
+        return;
+    dst->len += ret;
+    if (dst->len > dst->bufsize)
+        dst->len = dst->bufsize;
+    va_end(va);
+}
+
+static int indexof(const char *s, int c)
+{
+    char *f = strchr(s, c);
+    return f ? (f - s) : -1;
+}
+
+
+
+/*
+ *      SubRip
+ *
+ *      Support basic tags (italic, bold, underline, strike-through)
+ *      and font tag with size, color and face attributes.
+ *
+ */
+
+struct font_tag {
+    int size;
+    uint32_t color;
+    struct bstr face;
+    bool has_size : 1;
+    bool has_color : 1;
+    bool has_face : 1;
+};
+
+static const struct tag_conv {
+    char *from;
+    char *to;
+} subrip_basic_tags[] = {
+    {"<i>", "{\\i1}"}, {"</i>", "{\\i0}"},
+    {"<b>", "{\\b1}"}, {"</b>", "{\\b0}"},
+    {"<u>", "{\\u1}"}, {"</u>", "{\\u0}"},
+    {"<s>", "{\\s1}"}, {"</s>", "{\\s0}"},
+    {"{", "\\{"}, {"}", "\\}"},
+    {"\n", "\\N"}
+};
+
+static const struct {
+    char *s;
+    uint32_t v;
+} subrip_web_colors[] = {
+    /* 16 named html colors in BGR format */
+    {"red",     0x0000ff}, {"blue",   0xff0000}, {"lime",   0x00ff00},
+    {"aqua",    0xffff00}, {"purple", 0x800080}, {"yellow", 0x00ffff},
+    {"fuchsia", 0xff00ff}, {"white",  0xffffff}, {"gray",   0x808080},
+    {"maroon",  0x000080}, {"olive",  0x008080}, {"black",  0x000000},
+    {"silver",  0xc0c0c0}, {"teal",   0x808000}, {"green",  0x008000},
+    {"navy",    0x800000}
+};
+
+#define SUBRIP_MAX_STACKED_FONT_TAGS    16
+
+void subassconvert_subrip(const char *orig, char *dest, int dest_buffer_size)
+{
+    /* line is not const to avoid warnings with strtol, etc.
+     * orig content won't be changed */
+    char *line = (char *)orig;
+    struct line new_line = {
+        .buf = dest,
+        .bufsize = dest_buffer_size,
+    };
+    struct font_tag font_stack[SUBRIP_MAX_STACKED_FONT_TAGS + 1];
+    font_stack[0] = (struct font_tag){}; // type with all defaults
+    int sp = 0;
+
+    while (*line && new_line.len < new_line.bufsize - 1) {
+        char *orig_line = line;
+
+        for (int i = 0; i < NB_ELEMS(subrip_basic_tags); i++) {
+            const struct tag_conv *tag = &subrip_basic_tags[i];
+            int from_len = strlen(tag->from);
+            if (strncmp(line, tag->from, from_len) == 0) {
+                append_text(&new_line, "%s", tag->to);
+                line += from_len;
+            }
+        }
+
+        if (strncmp(line, "</font>", 7) == 0) {
+            /* Closing font tag */
+            line += 7;
+
+            if (sp > 0) {
+                struct font_tag *tag = &font_stack[sp];
+                struct font_tag *last_tag = &tag[-1];
+                sp--;
+
+                if (tag->has_size) {
+                    if (!last_tag->has_size)
+                        append_text(&new_line, "{\\fs}");
+                    else if (last_tag->size != tag->size)
+                        append_text(&new_line, "{\\fs%d}", last_tag->size);
+                }
+
+                if (tag->has_color) {
+                    if (!last_tag->has_color)
+                        append_text(&new_line, "{\\c}");
+                    else if (last_tag->color != tag->color)
+                        append_text(&new_line, "{\\c&H%06X&}", last_tag->color);
+                }
+
+                if (tag->has_face) {
+                    if (!last_tag->has_face)
+                        append_text(&new_line, "{\\fn}");
+                    else if (bstrcmp(last_tag->face, tag->face) != 0)
+                        append_text(&new_line, "{\\fn%.*s}",
+                                    BSTR_P(last_tag->face));
+                }
+            }
+        } else if (strncmp(line, "<font ", 6) == 0
+                   && sp + 1 < NB_ELEMS(font_stack)) {
+            /* Opening font tag */
+            char *potential_font_tag_start = line;
+            int len_backup = new_line.len;
+            struct font_tag *tag = &font_stack[sp + 1];
+            bool has_valid_attr = false;
+
+            *tag = tag[-1]; // keep values from previous tag
+            line += 6;
+
+            while (*line && *line != '>') {
+                if (strncmp(line, "size=\"", 6) == 0) {
+                    line += 6;
+                    tag->size = strtol(line, &line, 10);
+                    if (*line != '"')
+                        break;
+                    append_text(&new_line, "{\\fs%d}", tag->size);
+                    tag->has_size = true;
+                    has_valid_attr = true;
+                } else if (strncmp(line, "color=\"", 7) == 0) {
+                    line += 7;
+                    if (*line == '#') {
+                        // #RRGGBB format
+                        line++;
+                        tag->color = strtol(line, &line, 16) & 0x00ffffff;
+                        if (*line != '"')
+                            break;
+                        tag->color = ((tag->color & 0xff) << 16)
+                            | (tag->color & 0xff00)
+                            | ((tag->color & 0xff0000) >> 16);
+                    } else {
+                        // Standard web colors
+                        int len = indexof(line, '"');
+                        if (len <= 0)
+                            break;
+                        /* Let's put some white in case we didn't find
+                         * any matching colors */
+                        tag->color = 0x00ffffff;
+
+                        for (int i = 0; i < NB_ELEMS(subrip_web_colors); i++) {
+                            char *color = subrip_web_colors[i].s;
+                            if (strlen(color) == len
+                                && strncasecmp(line, color, len) == 0) {
+                                tag->color = subrip_web_colors[i].v;
+                                break;
+                            }
+                        }
+                        line += len;
+                    }
+                    append_text(&new_line, "{\\c&H%06X&}", tag->color);
+                    tag->has_color = true;
+                    has_valid_attr = true;
+                } else if (strncmp(line, "face=\"", 6) == 0) {
+                    /* Font face attribute */
+                    line += 6;
+                    int len = indexof(line, '"');
+                    if (len <= 0)
+                        break;
+                    tag->face.start = line;
+                    tag->face.len = len;
+                    line += len;
+                    append_text(&new_line, "{\\fn%.*s}", BSTR_P(tag->face));
+                    tag->has_face = true;
+                    has_valid_attr = true;
+                }
+                line++;
+            }
+
+            if (!has_valid_attr || *line != '>') { /* Not valid font tag */
+                line = potential_font_tag_start;
+                new_line.len = len_backup;
+            } else {
+                sp++;
+                line++;
+            }
+        }
+
+        /* Tag conversion code didn't match */
+        if (line == orig_line)
+            new_line.buf[new_line.len++] = *line++;
+    }
+    new_line.buf[new_line.len] = 0;
+}
+
+
+/*
+ *      MicroDVD
+ *
+ *      Based on the specifications found here:
+ *      https://trac.videolan.org/vlc/ticket/1825#comment:6
+ */
+
+struct microdvd_tag {
+    char key;
+    int persistent;
+    uint32_t data1;
+    uint32_t data2;
+    struct bstr data_string;
+};
+
+#define MICRODVD_PERSISTENT_OFF     0
+#define MICRODVD_PERSISTENT_ON      1
+#define MICRODVD_PERSISTENT_OPENED  2
+
+// Color, Font, Size, cHarset, stYle, Position, cOordinate
+#define MICRODVD_TAGS               "cfshyYpo"
+
+static void microdvd_set_tag(struct microdvd_tag *tags, struct microdvd_tag tag)
+{
+    int tag_index = indexof(MICRODVD_TAGS, tag.key);
+
+    if (tag_index < 0)
+        return;
+    memcpy(&tags[tag_index], &tag, sizeof(tag));
+}
+
+// italic, bold, underline, strike-through
+#define MICRODVD_STYLES             "ibus"
+
+static char *microdvd_load_tags(struct microdvd_tag *tags, char *s)
+{
+    while (*s == '{') {
+        char *start = s;
+        char tag_char = *(s + 1);
+        struct microdvd_tag tag = {};
+
+        if (!tag_char || *(s + 2) != ':')
+            break;
+        s += 3;
+
+        switch (tag_char) {
+
+        /* Style */
+        case 'Y':
+            tag.persistent = MICRODVD_PERSISTENT_ON;
+        case 'y':
+            while (*s && *s != '}') {
+                int style_index = indexof(MICRODVD_STYLES, *s);
+
+                if (style_index >= 0)
+                    tag.data1 |= (1 << style_index);
+                s++;
+            }
+            if (*s != '}')
+                break;
+            /* We must distinguish persistent and non-persistent styles
+             * to handle this kind of style tags: {y:ib}{Y:us} */
+            tag.key = tag_char;
+            break;
+
+        /* Color */
+        case 'C':
+            tag.persistent = MICRODVD_PERSISTENT_ON;
+        case 'c':
+            tag.data1 = strtol(s, &s, 16) & 0x00ffffff;
+            if (*s != '}')
+                break;
+            tag.key = 'c';
+            break;
+
+        /* Font name */
+        case 'F':
+            tag.persistent = MICRODVD_PERSISTENT_ON;
+        case 'f':
+        {
+            int len = indexof(s, '}');
+            if (len < 0)
+                break;
+            tag.data_string.start = s;
+            tag.data_string.len = len;
+            s += len;
+            tag.key = 'f';
+            break;
+        }
+
+        /* Font size */
+        case 'S':
+            tag.persistent = MICRODVD_PERSISTENT_ON;
+        case 's':
+            tag.data1 = strtol(s, &s, 10);
+            if (*s != '}')
+                break;
+            tag.key = 's';
+            break;
+
+        /* Charset */
+        case 'H':
+        {
+            //TODO: not yet handled, just parsed.
+            int len = indexof(s, '}');
+            if (len < 0)
+                break;
+            tag.data_string.start = s;
+            tag.data_string.len = len;
+            s += len;
+            tag.key = 'h';
+            break;
+        }
+
+        /* Position */
+        case 'P':
+            tag.persistent = MICRODVD_PERSISTENT_ON;
+            tag.data1 = (*s++ == '1');
+            if (*s != '}')
+                break;
+            tag.key = 'p';
+            break;
+
+        /* Coordinates */
+        case 'o':
+            tag.persistent = MICRODVD_PERSISTENT_ON;
+            tag.data1 = strtol(s, &s, 10);
+            if (*s != ',')
+                break;
+            s++;
+            tag.data2 = strtol(s, &s, 10);
+            if (*s != '}')
+                break;
+            tag.key = 'o';
+            break;
+
+        default:    /* Unknown tag, we considere it's text */
+            break;
+        }
+
+        if (tag.key == 0)
+            return start;
+
+        microdvd_set_tag(tags, tag);
+        s++;
+    }
+    return s;
+}
+
+static void microdvd_open_tags(struct line *new_line, struct microdvd_tag *tags)
+{
+    for (int i = 0; i < sizeof(MICRODVD_TAGS) - 1; i++) {
+        if (tags[i].persistent == MICRODVD_PERSISTENT_OPENED)
+            continue;
+        switch (tags[i].key) {
+        case 'Y':
+        case 'y':
+            for (int sidx = 0; sidx < sizeof(MICRODVD_STYLES) - 1; sidx++)
+                if (tags[i].data1 & (1 << sidx))
+                    append_text(new_line, "{\\%c1}", MICRODVD_STYLES[sidx]);
+            break;
+
+        case 'c':
+            append_text(new_line, "{\\c&H%06X&}", tags[i].data1);
+            break;
+
+        case 'f':
+            append_text(new_line, "{\\fn%.*s}", BSTR_P(tags[i].data_string));
+            break;
+
+        case 's':
+            append_text(new_line, "{\\fs%d}", tags[i].data1);
+            break;
+
+        case 'p':
+            if (tags[i].data1 == 0)
+                append_text(new_line, "{\\an8}");
+            break;
+
+        case 'o':
+            append_text(new_line, "{\\pos(%d,%d)}",
+                        tags[i].data1, tags[i].data2);
+            break;
+        }
+        if (tags[i].persistent == MICRODVD_PERSISTENT_ON)
+            tags[i].persistent = MICRODVD_PERSISTENT_OPENED;
+    }
+}
+
+static void microdvd_close_no_persistent_tags(struct line *new_line,
+                                              struct microdvd_tag *tags)
+{
+    int i;
+
+    for (i = sizeof(MICRODVD_TAGS) - 2; i; i--) {
+        if (tags[i].persistent != MICRODVD_PERSISTENT_OFF)
+            continue;
+        switch (tags[i].key) {
+
+        case 'y':
+            for (int sidx = sizeof(MICRODVD_STYLES) - 2; sidx >= 0; sidx--)
+                if (tags[i].data1 & (1 << sidx))
+                    append_text(new_line, "{\\%c0}", MICRODVD_STYLES[sidx]);
+            break;
+
+        case 'c':
+            append_text(new_line, "{\\c}");
+            break;
+
+        case 'f':
+            append_text(new_line, "{\\fn}");
+            break;
+
+        case 's':
+            append_text(new_line, "{\\fs}");
+            break;
+        }
+        tags[i].key = 0;
+    }
+}
+
+void subassconvert_microdvd(const char *orig, char *dest, int dest_buffer_size)
+{
+    /* line is not const to avoid warnings with strtol, etc.
+     * orig content won't be changed */
+    char *line = (char *)orig;
+    struct line new_line = {
+        .buf = dest,
+        .bufsize = dest_buffer_size,
+    };
+    struct microdvd_tag tags[sizeof(MICRODVD_TAGS) - 1] = {};
+
+    while (*line) {
+        line = microdvd_load_tags(tags, line);
+        microdvd_open_tags(&new_line, tags);
+
+        while (*line && *line != '|')
+            new_line.buf[new_line.len++] = *line++;
+
+        if (*line == '|') {
+            microdvd_close_no_persistent_tags(&new_line, tags);
+            append_text(&new_line, "\\N");
+            line++;
+        }
+    }
+    new_line.buf[new_line.len] = 0;
+}
Index: subassconvert.h
===================================================================
--- subassconvert.h	(revision 0)
+++ subassconvert.h	(revision 0)
@@ -0,0 +1,27 @@
+/*
+ * Header for subtitles converter to SSA/ASS
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPLAYER_SUBASSCONVERT_H
+#define MPLAYER_SUBASSCONVERT_H
+
+void subassconvert_subrip(const char *orig, char *dest, int dest_buffer_size);
+void subassconvert_microdvd(const char *orig, char *dest, int dest_buffer_size);
+
+#endif
Index: subreader.c
===================================================================
--- subreader.c	(revision 31471)
+++ subreader.c	(working copy)
@@ -32,9 +32,11 @@
 #include "config.h"
 #include "mp_msg.h"
 #include "subreader.h"
+#include "subassconvert.h"
 #include "stream/stream.h"
 #include "libavutil/common.h"
 #include "libavutil/avstring.h"
+#include "libass/ass_mp.h"
 
 #ifdef CONFIG_ENCA
 #include <enca.h>
@@ -294,7 +296,11 @@
 		      "{%ld}{%ld}%[^\r\n]",
 		      &(current->start), &(current->end), line2) < 3));
 
-    p=line2;
+    if (ass_enabled) {
+        subassconvert_microdvd(line2, line, LINE_LEN + 1);
+        p = line;
+    } else
+        p = line2;
 
     next=p, i=0;
     while ((next =sub_readtext (next, &(current->text[i])))) {
@@ -363,12 +369,70 @@
     return current;
 }
 
+static subtitle *sub_ass_read_line_subviewer(stream_t *st, subtitle *current, int utf16)
+{
+    int a1, a2, a3, a4, b1, b2, b3, b4, j = 0;
+
+    while (!current->text[0]) {
+        char line[LINE_LEN + 1], full_line[LINE_LEN + 1], sep;
+        int i;
+
+        /* Parse SubRip header */
+        if (!stream_read_line(st, line, LINE_LEN, utf16))
+            return NULL;
+        if (sscanf(line, "%d:%d:%d%[,.:]%d --> %d:%d:%d%[,.:]%d",
+                     &a1, &a2, &a3, &sep, &a4, &b1, &b2, &b3, &sep, &b4) < 10)
+            continue;
+
+        current->start = a1 * 360000 + a2 * 6000 + a3 * 100 + a4 / 10;
+        current->end   = b1 * 360000 + b2 * 6000 + b3 * 100 + b4 / 10;
+
+        /* Concat lines */
+        full_line[0] = 0;
+        for (i = 0; i < SUB_MAX_TEXT; i++) {
+            int blank = 1, len = 0;
+            char *p;
+
+            if (!stream_read_line(st, line, LINE_LEN, utf16))
+                break;
+
+            for (p = line; *p != '\n' && *p != '\r' && *p; p++, len++)
+                if (*p != ' ' && *p != '\t')
+                    blank = 0;
+
+            if (blank)
+                break;
+
+            *p = 0;
+
+            if (!(j + 1 + len < sizeof(full_line) - 1))
+                break;
+
+            if (j != 0)
+                full_line[j++] = '\n';
+            strcpy(&full_line[j], line);
+            j += len;
+        }
+
+        /* Use the ASS/SSA converter to transform the whole lines */
+        if (full_line[0]) {
+            char converted_line[LINE_LEN + 1];
+            subassconvert_subrip(full_line, converted_line, LINE_LEN + 1);
+            current->text[0] = strdup(converted_line);
+            current->lines = 1;
+        }
+    }
+    return current;
+}
+
 static subtitle *sub_read_line_subviewer(stream_t *st,subtitle *current, int utf16) {
     char line[LINE_LEN+1];
     int a1,a2,a3,a4,b1,b2,b3,b4;
     char *p=NULL;
     int i,len;
 
+    if (ass_enabled)
+        return sub_ass_read_line_subviewer(st, current, utf16);
     while (!current->text[0]) {
 	if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
 	if ((len=sscanf (line, "%d:%d:%d%[,.:]%d --> %d:%d:%d%[,.:]%d",&a1,&a2,&a3,(char *)&i,&a4,&b1,&b2,&b3,(char *)&i,&b4)) < 10)
@@ -2292,12 +2356,13 @@
  * \param txt text to parse
  * \param len length of text in txt
  * \param endpts pts at which this subtitle text should be removed again
+ * \param strip_markup if strip markup is set, markup tags like <b></b> are ignored
  *
  * <> and {} are interpreted as comment delimiters, "\n", "\N", '\n', '\r'
  * and '\0' are interpreted as newlines, duplicate, leading and trailing
  * newlines are ignored.
  */
-void sub_add_text(subtitle *sub, const char *txt, int len, double endpts) {
+void sub_add_text(subtitle *sub, const char *txt, int len, double endpts, bool strip_markup) {
   int comment = 0;
   int double_newline = 1; // ignore newlines at the beginning
   int i, pos;
@@ -2308,42 +2373,48 @@
   buf = malloc(MAX_SUBLINE + 1);
   sub->text[sub->lines] = buf;
   sub->endpts[sub->lines] = endpts;
-  for (i = 0; i < len && pos < MAX_SUBLINE; i++) {
-    char c = txt[i];
-    if (c == '<') comment |= 1;
-    if (c == '{') comment |= 2;
-    if (comment) {
-      if (c == '}') comment &= ~2;
-      if (c == '>') comment &= ~1;
-      continue;
-    }
-    if (pos == MAX_SUBLINE - 1) {
-      i--;
-      c = 0;
-    }
-    if (c == '\\' && i + 1 < len) {
-      c = txt[++i];
-      if (c == 'n' || c == 'N') c = 0;
-    }
-    if (c == '\n' || c == '\r') c = 0;
-    if (c) {
-      double_newline = 0;
-      buf[pos++] = c;
-    } else if (!double_newline) {
-      if (sub->lines >= SUB_MAX_TEXT - 1) {
-        mp_msg(MSGT_VO, MSGL_WARN, "Too many subtitle lines\n");
-        break;
+
+  if (!strip_markup) {
+    subassconvert_subrip(txt, buf, MAX_SUBLINE + 1);
+    sub->text[sub->lines] = buf;
+  } else {
+    for (i = 0; i < len && pos < MAX_SUBLINE; i++) {
+      char c = txt[i];
+      if (c == '<') comment |= 1;
+      if (c == '{') comment |= 2;
+      if (comment) {
+        if (c == '}') comment &= ~2;
+        if (c == '>') comment &= ~1;
+        continue;
       }
-      double_newline = 1;
-      buf[pos] = 0;
-      sub->lines++;
-      pos = 0;
-      buf = malloc(MAX_SUBLINE + 1);
-      sub->text[sub->lines] = buf;
-      sub->endpts[sub->lines] = endpts;
+      if (pos == MAX_SUBLINE - 1) {
+        i--;
+        c = 0;
+      }
+      if (c == '\\' && i + 1 < len) {
+        c = txt[++i];
+        if (c == 'n' || c == 'N') c = 0;
+      }
+      if (c == '\n' || c == '\r') c = 0;
+      if (c) {
+        double_newline = 0;
+        buf[pos++] = c;
+      } else if (!double_newline) {
+        if (sub->lines >= SUB_MAX_TEXT - 1) {
+          mp_msg(MSGT_VO, MSGL_WARN, "Too many subtitle lines\n");
+          break;
+        }
+        double_newline = 1;
+        buf[pos] = 0;
+        sub->lines++;
+        pos = 0;
+        buf = malloc(MAX_SUBLINE + 1);
+        sub->text[sub->lines] = buf;
+        sub->endpts[sub->lines] = endpts;
+      }
     }
+    buf[pos] = 0;
   }
-  buf[pos] = 0;
   if (sub->lines < SUB_MAX_TEXT &&
       strlen(sub->text[sub->lines]))
     sub->lines++;
Index: subreader.h
===================================================================
--- subreader.h	(revision 31471)
+++ subreader.h	(working copy)
@@ -20,6 +20,7 @@
 #define MPLAYER_SUBREADER_H
 
 #include <stdio.h>
+#include <stdbool.h>
 
 #include "config.h"
 
@@ -105,7 +106,7 @@
 void sub_free( sub_data * subd );
 void find_sub(sub_data* subd,int key);
 void step_sub(sub_data *subd, float pts, int movement);
-void sub_add_text(subtitle *sub, const char *txt, int len, double endpts);
+void sub_add_text(subtitle *sub, const char *txt, int len, double endpts, bool strip_markup);
 int sub_clear_text(subtitle *sub, double pts);
 
 #endif /* MPLAYER_SUBREADER_H */
Index: libmpdemux/demux_ogg.c
===================================================================
--- libmpdemux/demux_ogg.c	(revision 31471)
+++ libmpdemux/demux_ogg.c	(working copy)
@@ -212,7 +212,7 @@
             endpts = 1.0 + pts + (float)duration / 1000.0;
         }
         sub_clear_text(&ogg_sub, MP_NOPTS_VALUE);
-        sub_add_text(&ogg_sub, &packet[lcv], pack->bytes - lcv, endpts);
+        sub_add_text(&ogg_sub, &packet[lcv], pack->bytes - lcv, endpts, true);
     }
 
     mp_msg(MSGT_DEMUX, MSGL_DBG2, "Ogg sub lines: %d  first: '%s'\n",
Index: mpcommon.c
===================================================================
--- mpcommon.c	(revision 31471)
+++ mpcommon.c	(working copy)
@@ -212,7 +212,7 @@
                     if (subpts != MP_NOPTS_VALUE) {
                         subtitle tmp_subs = {0};
                         if (endpts == MP_NOPTS_VALUE) endpts = subpts + 3;
-                        sub_add_text(&tmp_subs, packet, len, endpts);
+                        sub_add_text(&tmp_subs, packet, len, endpts, false);
                         tmp_subs.start = subpts * 100;
                         tmp_subs.end = endpts * 100;
                         ass_process_subtitle(ass_track, &tmp_subs);
@@ -239,7 +239,7 @@
                     len -= p - packet;
                     packet = p;
                 }
-                sub_add_text(&subs, packet, len, endpts);
+                sub_add_text(&subs, packet, len, endpts, true);
                 set_osd_subtitle(&subs);
             }
             if (d_dvdsub->non_interleaved)


More information about the MPlayer-dev-eng mailing list