From d064c69e1c958514c3ef4d7871bcd92c8ff92de9 Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Tue, 11 Jun 2013 12:07:04 +0200
Subject: demux: don't require fill_buffer callback

---
 demux/demux.c     | 2 +-
 demux/demux_cue.c | 6 ------
 demux/demux_edl.c | 6 ------
 3 files changed, 1 insertion(+), 13 deletions(-)

(limited to 'demux')

diff --git a/demux/demux.c b/demux/demux.c
index 5de6b84745..d9b41e2c99 100644
--- a/demux/demux.c
+++ b/demux/demux.c
@@ -599,7 +599,7 @@ static bool demux_check_queue_full(demuxer_t *demux)
 int demux_fill_buffer(demuxer_t *demux, demux_stream_t *ds)
 {
     // Note: parameter 'ds' can be NULL!
-    return demux->desc->fill_buffer(demux, ds);
+    return demux->desc->fill_buffer ? demux->desc->fill_buffer(demux, ds) : 0;
 }
 
 // return value:
diff --git a/demux/demux_cue.c b/demux/demux_cue.c
index 31a3e00e40..04cc3229f3 100644
--- a/demux/demux_cue.c
+++ b/demux/demux_cue.c
@@ -47,11 +47,6 @@ static int try_open_file(struct demuxer *demuxer)
     return DEMUXER_TYPE_CUE;
 }
 
-static int dummy_fill_buffer(struct demuxer *demuxer, struct demux_stream *ds)
-{
-    return 0;
-}
-
 const struct demuxer_desc demuxer_desc_cue = {
     .info = "CUE file demuxer",
     .name = "cue",
@@ -61,5 +56,4 @@ const struct demuxer_desc demuxer_desc_cue = {
     .type = DEMUXER_TYPE_CUE,
     .safe_check = true,
     .check_file = try_open_file,       // no separate .open
-    .fill_buffer = dummy_fill_buffer,
 };
diff --git a/demux/demux_edl.c b/demux/demux_edl.c
index 1e1db5be93..71d75e7f38 100644
--- a/demux/demux_edl.c
+++ b/demux/demux_edl.c
@@ -40,11 +40,6 @@ static int try_open_file(struct demuxer *demuxer)
     return DEMUXER_TYPE_EDL;
 }
 
-static int dummy_fill_buffer(struct demuxer *demuxer, struct demux_stream *ds)
-{
-    return 0;
-}
-
 const struct demuxer_desc demuxer_desc_edl = {
     .info = "EDL file demuxer",
     .name = "edl",
@@ -54,5 +49,4 @@ const struct demuxer_desc demuxer_desc_edl = {
     .type = DEMUXER_TYPE_EDL,
     .safe_check = true,
     .check_file = try_open_file,       // no separate .open
-    .fill_buffer = dummy_fill_buffer,
 };
-- 
cgit v1.2.3


From 4f5e12136de717896bf322e75d42de1af09e1c3e Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Tue, 11 Jun 2013 12:16:42 +0200
Subject: stream: remove padding parameter from stream_read_complete()

Seems like a completely unnecessary complication. Instead, always add a
1 byte padding (could be extended if a caller needs it), and clear it.

Also add some documentation. There was some, but it was outdated and
incomplete.
---
 demux/demux_cue.c | 2 +-
 demux/demux_edl.c | 2 +-
 demux/demux_mf.c  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'demux')

diff --git a/demux/demux_cue.c b/demux/demux_cue.c
index 04cc3229f3..073fa9d336 100644
--- a/demux/demux_cue.c
+++ b/demux/demux_cue.c
@@ -39,7 +39,7 @@ static int try_open_file(struct demuxer *demuxer)
     if (!mp_probe_cue((struct bstr) { buf, len }))
         return 0;
     stream_seek(s, 0);
-    demuxer->file_contents = stream_read_complete(s, demuxer, 1000000, 0);
+    demuxer->file_contents = stream_read_complete(s, demuxer, 1000000);
     if (demuxer->file_contents.start == NULL)
         return 0;
     if (!mp_probe_cue((struct bstr) { buf, len }))
diff --git a/demux/demux_edl.c b/demux/demux_edl.c
index 71d75e7f38..c35137ffb2 100644
--- a/demux/demux_edl.c
+++ b/demux/demux_edl.c
@@ -34,7 +34,7 @@ static int try_open_file(struct demuxer *demuxer)
     if (strncmp(buf, header, len))
         return 0;
     stream_seek(s, 0);
-    demuxer->file_contents = stream_read_complete(s, demuxer, 1000000, 0);
+    demuxer->file_contents = stream_read_complete(s, demuxer, 1000000);
     if (demuxer->file_contents.start == NULL)
         return 0;
     return DEMUXER_TYPE_EDL;
diff --git a/demux/demux_mf.c b/demux/demux_mf.c
index 0db3fb8add..127ee8474e 100644
--- a/demux/demux_mf.c
+++ b/demux/demux_mf.c
@@ -78,7 +78,7 @@ static int demux_mf_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds){
 
     if (stream) {
         stream_seek(stream, 0);
-        bstr data = stream_read_complete(stream, NULL, MF_MAX_FILE_SIZE, 0);
+        bstr data = stream_read_complete(stream, NULL, MF_MAX_FILE_SIZE);
         if (data.len) {
             demux_packet_t *dp = new_demux_packet(data.len);
             memcpy(dp->buffer, data.start, data.len);
-- 
cgit v1.2.3


From a70d575291d48289669ee8989e0597a94189dd8d Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Tue, 11 Jun 2013 21:39:54 +0200
Subject: sub: preload external text subtitles

If a subtitle is external, read it completely and add all subtitle
events in advance when the subtitle track is selected. This is done
for text subtitles only. (Note that subreader.c and subtitles loaded
with libass are different and don't have anything to do with this
commit.)
---
 demux/demux.c | 38 +++++++++++++++++++++++++++++++++++++-
 demux/demux.h |  1 +
 2 files changed, 38 insertions(+), 1 deletion(-)

(limited to 'demux')

diff --git a/demux/demux.c b/demux/demux.c
index d9b41e2c99..23c4a28706 100644
--- a/demux/demux.c
+++ b/demux/demux.c
@@ -40,7 +40,8 @@
 
 #include "audio/format.h"
 
-#include "libavcodec/avcodec.h"
+#include <libavcodec/avcodec.h>
+
 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE
 #error MP_INPUT_BUFFER_PADDING_SIZE is too small!
 #endif
@@ -183,6 +184,41 @@ void free_demux_packet(struct demux_packet *dp)
     talloc_free(dp);
 }
 
+static int destroy_avpacket(void *pkt)
+{
+    av_free_packet(pkt);
+    return 0;
+}
+
+struct demux_packet *demux_copy_packet(struct demux_packet *dp)
+{
+    struct demux_packet *new = NULL;
+    // No av_copy_packet() in Libav
+#if LIBAVCODEC_VERSION_MICRO >= 100
+    if (dp->avpacket) {
+        assert(dp->buffer == dp->avpacket->data);
+        assert(dp->len == dp->avpacket->size);
+        AVPacket *newavp = talloc_zero(NULL, AVPacket);
+        talloc_set_destructor(newavp, destroy_avpacket);
+        av_init_packet(newavp);
+        if (av_copy_packet(newavp, dp->avpacket) < 0)
+            abort();
+        new = new_demux_packet_fromdata(newavp->data, newavp->size);
+        new->avpacket = newavp;
+    }
+#endif
+    if (!new) {
+        new = new_demux_packet(dp->len);
+        memcpy(new->buffer, dp->buffer, new->len);
+    }
+    new->pts = dp->pts;
+    new->duration = dp->duration;
+    new->stream_pts = dp->stream_pts;
+    new->pos = dp->pos;
+    new->keyframe = dp->keyframe;
+    return new;
+}
+
 static void free_demuxer_stream(struct demux_stream *ds)
 {
     ds_free_packs(ds);
diff --git a/demux/demux.h b/demux/demux.h
index 9ec6d0c6f0..a82fbea91a 100644
--- a/demux/demux.h
+++ b/demux/demux.h
@@ -291,6 +291,7 @@ struct demux_packet *new_demux_packet_fromdata(void *data, size_t len);
 struct demux_packet *new_demux_packet_from(void *data, size_t len);
 void resize_demux_packet(struct demux_packet *dp, size_t len);
 void free_demux_packet(struct demux_packet *dp);
+struct demux_packet *demux_copy_packet(struct demux_packet *dp);
 
 #ifndef SIZE_MAX
 #define SIZE_MAX ((size_t)-1)
-- 
cgit v1.2.3


From db2e1ef4d210f5a8a4a2555d0a78b0a4dea103ec Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Fri, 21 Jun 2013 00:26:05 +0200
Subject: Move/rename subreader.c

---
 demux/demux_subreader.c | 1378 +++++++++++++++++++++++++++++++++++++++++++++++
 demux/subreader.h       |   79 +++
 2 files changed, 1457 insertions(+)
 create mode 100644 demux/demux_subreader.c
 create mode 100644 demux/subreader.h

(limited to 'demux')

diff --git a/demux/demux_subreader.c b/demux/demux_subreader.c
new file mode 100644
index 0000000000..befac689a4
--- /dev/null
+++ b/demux/demux_subreader.c
@@ -0,0 +1,1378 @@
+/*
+ * Subtitle reader with format autodetection
+ *
+ * Copyright (c) 2001 laaz
+ * Some code cleanup & realloc() by A'rpi/ESP-team
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <ctype.h>
+
+#include "config.h"
+#include "core/mp_msg.h"
+#include "subreader.h"
+#include "core/mp_common.h"
+#include "core/options.h"
+#include "stream/stream.h"
+#include "libavutil/common.h"
+#include "libavutil/avstring.h"
+
+#ifdef CONFIG_ENCA
+#include <enca.h>
+#endif
+
+#define ERR ((void *) -1)
+
+#ifdef CONFIG_ICONV
+#include <iconv.h>
+#endif
+
+// Parameter struct for the format-specific readline functions
+struct readline_args {
+    int utf16;
+    struct MPOpts *opts;
+
+    // subtitle reader state used by some formats
+
+    float mpsub_multiplier;
+    float mpsub_position;
+    int sub_slacktime;
+
+    /*
+    Some subtitling formats, namely AQT and Subrip09, define the end of a
+    subtitle as the beginning of the following. Since currently we read one
+    subtitle at time, for these format we keep two global *subtitle,
+    previous_aqt_sub and previous_subrip09_sub, pointing to previous subtitle,
+    so we can change its end when we read current subtitle starting time.
+    We use a single global unsigned long,
+    previous_sub_end, for both (and even future) formats, to store the end of
+    the previous sub: it is initialized to 0 in sub_read_file and eventually
+    modified by sub_read_aqt_line or sub_read_subrip09_line.
+    */
+    unsigned long previous_sub_end;
+};
+
+/* Maximal length of line of a subtitle */
+#define LINE_LEN 1000
+
+static int eol(char p) {
+	return p=='\r' || p=='\n' || p=='\0';
+}
+
+/* Remove leading and trailing space */
+static void trail_space(char *s) {
+	int i = 0;
+	while (isspace(s[i])) ++i;
+	if (i) strcpy(s, s + i);
+	i = strlen(s) - 1;
+	while (i > 0 && isspace(s[i])) s[i--] = '\0';
+}
+
+static char *stristr(const char *haystack, const char *needle) {
+    int len = 0;
+    const char *p = haystack;
+
+    if (!(haystack && needle)) return NULL;
+
+    len=strlen(needle);
+    while (*p != '\0') {
+	if (strncasecmp(p, needle, len) == 0) return (char*)p;
+	p++;
+    }
+
+    return NULL;
+}
+
+static void sami_add_line(subtitle *current, char *buffer, char **pos) {
+    char *p = *pos;
+    *p = 0;
+    trail_space(buffer);
+    if (*buffer && current->lines < SUB_MAX_TEXT)
+        current->text[current->lines++] = strdup(buffer);
+    *pos = buffer;
+}
+
+static subtitle *sub_read_line_sami(stream_t* st, subtitle *current,
+                                    struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    static char line[LINE_LEN+1];
+    static char *s = NULL, *slacktime_s;
+    char text[LINE_LEN+1], *p=NULL, *q;
+    int state;
+
+    current->lines = current->start = current->end = 0;
+    current->alignment = SUB_ALIGNMENT_BOTTOMCENTER;
+    state = 0;
+
+    /* read the first line */
+    if (!s)
+	    if (!(s = stream_read_line(st, line, LINE_LEN, utf16))) return 0;
+
+    do {
+	switch (state) {
+
+	case 0: /* find "START=" or "Slacktime:" */
+	    slacktime_s = stristr (s, "Slacktime:");
+	    if (slacktime_s)
+                args->sub_slacktime = strtol (slacktime_s+10, NULL, 0) / 10;
+
+	    s = stristr (s, "Start=");
+	    if (s) {
+		current->start = strtol (s + 6, &s, 0) / 10;
+                /* eat '>' */
+                for (; *s != '>' && *s != '\0'; s++);
+                s++;
+		state = 1; continue;
+	    }
+	    break;
+
+	case 1: /* find (optional) "<P", skip other TAGs */
+	    for  (; *s == ' ' || *s == '\t'; s++); /* strip blanks, if any */
+	    if (*s == '\0') break;
+	    if (*s != '<') { state = 3; p = text; continue; } /* not a TAG */
+	    s++;
+	    if (*s == 'P' || *s == 'p') { s++; state = 2; continue; } /* found '<P' */
+	    for (; *s != '>' && *s != '\0'; s++); /* skip remains of non-<P> TAG */
+	    if (*s == '\0')
+	      break;
+	    s++;
+	    continue;
+
+	case 2: /* find ">" */
+	    if ((s = strchr (s, '>'))) { s++; state = 3; p = text; continue; }
+	    break;
+
+	case 3: /* get all text until '<' appears */
+	    if (p - text >= LINE_LEN)
+	        sami_add_line(current, text, &p);
+	    if (*s == '\0') break;
+	    else if (!strncasecmp (s, "<br>", 4)) {
+                sami_add_line(current, text, &p);
+		s += 4;
+	    }
+	    else if ((*s == '{') && !args->opts->sub_no_text_pp) { state = 5; ++s; continue; }
+	    else if (*s == '<') { state = 4; }
+	    else if (!strncasecmp (s, "&nbsp;", 6)) { *p++ = ' '; s += 6; }
+	    else if (*s == '\t') { *p++ = ' '; s++; }
+	    else if (*s == '\r' || *s == '\n') { s++; }
+	    else *p++ = *s++;
+
+	    /* skip duplicated space */
+	    if (p > text + 2) if (*(p-1) == ' ' && *(p-2) == ' ') p--;
+
+	    continue;
+
+	case 4: /* get current->end or skip <TAG> */
+	    q = stristr (s, "Start=");
+	    if (q) {
+		current->end = strtol (q + 6, &q, 0) / 10 - 1;
+		*p = '\0'; trail_space (text);
+		if (text[0] != '\0')
+		    current->text[current->lines++] = strdup (text);
+		if (current->lines > 0) { state = 99; break; }
+		state = 0; continue;
+	    }
+	    s = strchr (s, '>');
+	    if (s) { s++; state = 3; continue; }
+	    break;
+       case 5: /* get rid of {...} text, but read the alignment code */
+	    if ((*s == '\\') && (*(s + 1) == 'a') && !args->opts->sub_no_text_pp) {
+               if (stristr(s, "\\a1") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_BOTTOMLEFT;
+                   s = s + 3;
+               }
+               if (stristr(s, "\\a2") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_BOTTOMCENTER;
+                   s = s + 3;
+               } else if (stristr(s, "\\a3") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_BOTTOMRIGHT;
+                   s = s + 3;
+               } else if ((stristr(s, "\\a4") != NULL) || (stristr(s, "\\a5") != NULL) || (stristr(s, "\\a8") != NULL)) {
+                   current->alignment = SUB_ALIGNMENT_TOPLEFT;
+                   s = s + 3;
+               } else if (stristr(s, "\\a6") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_TOPCENTER;
+                   s = s + 3;
+               } else if (stristr(s, "\\a7") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_TOPRIGHT;
+                   s = s + 3;
+               } else if (stristr(s, "\\a9") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_MIDDLELEFT;
+                   s = s + 3;
+               } else if (stristr(s, "\\a10") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_MIDDLECENTER;
+                   s = s + 4;
+               } else if (stristr(s, "\\a11") != NULL) {
+                   current->alignment = SUB_ALIGNMENT_MIDDLERIGHT;
+                   s = s + 4;
+               }
+	    }
+	    if (*s == '}') state = 3;
+	    ++s;
+	    continue;
+	}
+
+	/* read next line */
+	if (state != 99 && !(s = stream_read_line (st, line, LINE_LEN, utf16))) {
+	    if (current->start > 0) {
+		break; // if it is the last subtitle
+	    } else {
+		return 0;
+	    }
+	}
+
+    } while (state != 99);
+
+    // For the last subtitle
+    if (current->end <= 0) {
+        current->end = current->start + args->sub_slacktime;
+        sami_add_line(current, text, &p);
+    }
+
+    return current;
+}
+
+
+static const char *sub_readtext(const char *source, char **dest) {
+    int len=0;
+    const char *p=source;
+
+//    printf("src=%p  dest=%p  \n",source,dest);
+
+    while ( !eol(*p) && *p!= '|' ) {
+	p++,len++;
+    }
+
+    *dest= malloc (len+1);
+    if (!*dest) {return ERR;}
+
+    strncpy(*dest, source, len);
+    (*dest)[len]=0;
+
+    while (*p=='\r' || *p=='\n' || *p=='|') p++;
+
+    if (*p) return p;  // not-last text field
+    else return NULL;  // last text field
+}
+
+static subtitle *set_multiline_text(subtitle *current, const char *text, int start)
+{
+    int i = start;
+    while ((text = sub_readtext(text, current->text + i))) {
+        if (current->text[i] == ERR) return ERR;
+        i++;
+        if (i >= SUB_MAX_TEXT) {
+            mp_msg(MSGT_SUBREADER, MSGL_WARN, "Too many lines in a subtitle\n");
+            current->lines = i;
+            return current;
+        }
+    }
+    current->lines = i + 1;
+    return current;
+}
+
+static subtitle *sub_read_line_microdvd(stream_t *st,subtitle *current,
+                                        struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+    char line2[LINE_LEN+1];
+
+    do {
+	if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+    } while ((sscanf (line,
+		      "{%ld}{}%[^\r\n]",
+		      &(current->start), line2) < 2) &&
+	     (sscanf (line,
+		      "{%ld}{%ld}%[^\r\n]",
+		      &(current->start), &(current->end), line2) < 3));
+
+    return set_multiline_text(current, line2, 0);
+}
+
+static subtitle *sub_read_line_mpl2(stream_t *st,subtitle *current,
+                                    struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+    char line2[LINE_LEN+1];
+
+    do {
+	if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+    } while ((sscanf (line,
+		      "[%ld][%ld]%[^\r\n]",
+		      &(current->start), &(current->end), line2) < 3));
+    current->start *= 10;
+    current->end *= 10;
+
+    return set_multiline_text(current, line2, 0);
+}
+
+static subtitle *sub_read_line_subrip(stream_t* st, subtitle *current,
+                                    struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+    int a1,a2,a3,a4,b1,b2,b3,b4;
+    char *p=NULL, *q=NULL;
+    int len;
+
+    while (1) {
+	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,&a4,&b1,&b2,&b3,&b4) < 8) continue;
+	current->start = a1*360000+a2*6000+a3*100+a4;
+	current->end   = b1*360000+b2*6000+b3*100+b4;
+
+	if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+
+	p=q=line;
+	for (current->lines=1; current->lines < SUB_MAX_TEXT; current->lines++) {
+	    for (q=p,len=0; *p && *p!='\r' && *p!='\n' && *p!='|' && strncmp(p,"[br]",4); p++,len++);
+	    current->text[current->lines-1]=malloc (len+1);
+	    if (!current->text[current->lines-1]) return ERR;
+	    strncpy (current->text[current->lines-1], q, len);
+	    current->text[current->lines-1][len]='\0';
+	    if (!*p || *p=='\r' || *p=='\n') break;
+	    if (*p=='|') p++;
+	    else while (*p++!=']');
+	}
+	break;
+    }
+    return current;
+}
+
+static subtitle *sub_read_line_subviewer(stream_t *st, subtitle *current,
+                                         struct readline_args *args)
+{
+    int utf16 = args->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];
+        int i;
+
+        /* Parse SubRip header */
+        if (!stream_read_line(st, line, LINE_LEN, utf16))
+            return NULL;
+        if (sscanf(line, "%d:%d:%d%*1[,.:]%d --> %d:%d:%d%*1[,.:]%d",
+                     &a1, &a2, &a3, &a4, &b1, &b2, &b3, &b4) < 8)
+            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;
+        }
+
+        if (full_line[0]) {
+            current->text[0] = strdup(full_line);
+            current->lines = 1;
+        }
+    }
+    return current;
+}
+
+static subtitle *sub_read_line_subviewer2(stream_t *st,subtitle *current,
+                                          struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+    int a1,a2,a3,a4;
+    char *p=NULL;
+    int i,len;
+
+    while (!current->text[0]) {
+        if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+	if (line[0]!='{')
+	    continue;
+        if ((len=sscanf (line, "{T %d:%d:%d:%d",&a1,&a2,&a3,&a4)) < 4)
+            continue;
+        current->start = a1*360000+a2*6000+a3*100+a4/10;
+        for (i=0; i<SUB_MAX_TEXT;) {
+            if (!stream_read_line (st, line, LINE_LEN, utf16)) break;
+            if (line[0]=='}') break;
+            len=0;
+            for (p=line; *p!='\n' && *p!='\r' && *p; ++p,++len);
+            if (len) {
+                current->text[i]=malloc (len+1);
+                if (!current->text[i]) return ERR;
+                strncpy (current->text[i], line, len); current->text[i][len]='\0';
+                ++i;
+            } else {
+                break;
+            }
+        }
+        current->lines=i;
+    }
+    return current;
+}
+
+
+static subtitle *sub_read_line_vplayer(stream_t *st,subtitle *current,
+                                       struct readline_args *args)
+{
+        int utf16 = args->utf16;
+	char line[LINE_LEN+1];
+	int a1,a2,a3;
+	char *p=NULL, separator;
+	int len,plen;
+
+	while (!current->text[0]) {
+		if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+		if ((len=sscanf (line, "%d:%d:%d%c%n",&a1,&a2,&a3,&separator,&plen)) < 4)
+			continue;
+
+		if (!(current->start = a1*360000+a2*6000+a3*100))
+			continue;
+                /* removed by wodzu
+		p=line;
+ 		// finds the body of the subtitle
+ 		for (i=0; i<3; i++){
+		   p=strchr(p,':');
+		   if (p==NULL) break;
+		   ++p;
+		}
+		if (p==NULL) {
+		    printf("SUB: Skipping incorrect subtitle line!\n");
+		    continue;
+		}
+                */
+                // by wodzu: hey! this time we know what length it has! what is
+                // that magic for? it can't deal with space instead of third
+                // colon! look, what simple it can be:
+                p = &line[ plen ];
+
+		if (*p!='|') {
+			//
+                        return set_multiline_text(current, p, 0);
+		}
+	}
+	return current;
+}
+
+static subtitle *sub_read_line_rt(stream_t *st,subtitle *current,
+                                    struct readline_args *args)
+{
+    int utf16 = args->utf16;
+
+	//TODO: This format uses quite rich (sub/super)set of xhtml
+	// I couldn't check it since DTD is not included.
+	// WARNING: full XML parses can be required for proper parsing
+    char line[LINE_LEN+1];
+    int a1,a2,a3,a4,b1,b2,b3,b4;
+    char *p=NULL,*next=NULL;
+    int len,plen;
+
+    while (!current->text[0]) {
+	if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+	//TODO: it seems that format of time is not easily determined, it may be 1:12, 1:12.0 or 0:1:12.0
+	//to describe the same moment in time. Maybe there are even more formats in use.
+	//if ((len=sscanf (line, "<Time Begin=\"%d:%d:%d.%d\" End=\"%d:%d:%d.%d\"",&a1,&a2,&a3,&a4,&b1,&b2,&b3,&b4)) < 8)
+	plen=a1=a2=a3=a4=b1=b2=b3=b4=0;
+	if (
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d.%d\" %*[Ee]nd=\"%d.%d\"%*[^<]<clear/>%n",&a3,&a4,&b3,&b4,&plen)) < 4) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d.%d\" %*[Ee]nd=\"%d:%d.%d\"%*[^<]<clear/>%n",&a3,&a4,&b2,&b3,&b4,&plen)) < 5) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d\" %*[Ee]nd=\"%d:%d\"%*[^<]<clear/>%n",&a2,&a3,&b2,&b3,&plen)) < 4) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d\" %*[Ee]nd=\"%d:%d.%d\"%*[^<]<clear/>%n",&a2,&a3,&b2,&b3,&b4,&plen)) < 5) &&
+//	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d.%d\" %*[Ee]nd=\"%d:%d\"%*[^<]<clear/>%n",&a2,&a3,&a4,&b2,&b3,&plen)) < 5) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d.%d\" %*[Ee]nd=\"%d:%d.%d\"%*[^<]<clear/>%n",&a2,&a3,&a4,&b2,&b3,&b4,&plen)) < 6) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d:%d.%d\" %*[Ee]nd=\"%d:%d:%d.%d\"%*[^<]<clear/>%n",&a1,&a2,&a3,&a4,&b1,&b2,&b3,&b4,&plen)) < 8) &&
+	//now try it without end time
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d.%d\"%*[^<]<clear/>%n",&a3,&a4,&plen)) < 2) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d\"%*[^<]<clear/>%n",&a2,&a3,&plen)) < 2) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d.%d\"%*[^<]<clear/>%n",&a2,&a3,&a4,&plen)) < 3) &&
+	((len=sscanf (line, "<%*[tT]ime %*[bB]egin=\"%d:%d:%d.%d\"%*[^<]<clear/>%n",&a1,&a2,&a3,&a4,&plen)) < 4)
+	)
+	    continue;
+	current->start = a1*360000+a2*6000+a3*100+a4/10;
+	current->end   = b1*360000+b2*6000+b3*100+b4/10;
+	if (b1 == 0 && b2 == 0 && b3 == 0 && b4 == 0)
+	  current->end = current->start+200;
+	p=line;	p+=plen;
+	// TODO: I don't know what kind of convention is here for marking multiline subs, maybe <br/> like in xml?
+	next = strstr(line,"<clear/>");
+	if(next && strlen(next)>8){
+	  next+=8;
+          return set_multiline_text(current, next, 0);
+	}
+    }
+    return current;
+}
+
+static subtitle *sub_read_line_ssa(stream_t *st,subtitle *current,
+                                    struct readline_args *args)
+{
+    /* Instead of hardcoding the expected fields and their order on
+     * each dialogue line, this code should parse the "Format: " line
+     * which lists the fields used in the script. As is, this may not
+     * work correctly with all scripts.
+     */
+
+        int utf16 = args->utf16;
+        int comma;
+
+	int hour1, min1, sec1, hunsec1,
+	    hour2, min2, sec2, hunsec2, nothing;
+	int num;
+
+	char line[LINE_LEN+1],
+	     line3[LINE_LEN+1],
+	     *line2;
+	char *tmp;
+
+	do {
+		if (!stream_read_line (st, line, LINE_LEN, utf16)) return NULL;
+	} while (sscanf (line, "Dialogue: Marked=%d,%d:%d:%d.%d,%d:%d:%d.%d"
+			"%[^\n\r]", &nothing,
+			&hour1, &min1, &sec1, &hunsec1,
+			&hour2, &min2, &sec2, &hunsec2,
+			line3) < 9
+		 &&
+		 sscanf (line, "Dialogue: %d,%d:%d:%d.%d,%d:%d:%d.%d"
+			 "%[^\n\r]", &nothing,
+			 &hour1, &min1, &sec1, &hunsec1,
+			 &hour2, &min2, &sec2, &hunsec2,
+			 line3) < 9	    );
+
+        line2=strchr(line3, ',');
+        if (!line2) return NULL;
+
+        for (comma = 3; comma < 9; comma ++)
+            if (!(line2 = strchr(++line2, ',')))
+                return NULL;
+        line2++;
+
+	current->lines=0;num=0;
+	current->start = 360000*hour1 + 6000*min1 + 100*sec1 + hunsec1;
+	current->end   = 360000*hour2 + 6000*min2 + 100*sec2 + hunsec2;
+
+        while (((tmp=strstr(line2, "\\n")) != NULL) || ((tmp=strstr(line2, "\\N")) != NULL) ){
+		current->text[num]=malloc(tmp-line2+1);
+		strncpy (current->text[num], line2, tmp-line2);
+		current->text[num][tmp-line2]='\0';
+		line2=tmp+2;
+		num++;
+		current->lines++;
+		if (current->lines >=  SUB_MAX_TEXT) return current;
+	}
+
+	current->text[num]=strdup(line2);
+	current->lines++;
+
+	return current;
+}
+
+/*
+ * PJS subtitles reader.
+ * That's the "Phoenix Japanimation Society" format.
+ * I found some of them in http://www.scriptsclub.org/ (used for anime).
+ * The time is in tenths of second.
+ *
+ * by set, based on code by szabi (dunnowhat sub format ;-)
+ */
+static subtitle *sub_read_line_pjs(stream_t *st,subtitle *current,
+                                   struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+    char text[LINE_LEN+1], *s, *d;
+
+    if (!stream_read_line (st, line, LINE_LEN, utf16))
+	return NULL;
+    /* skip spaces */
+    for (s=line; *s && isspace(*s); s++);
+    /* allow empty lines at the end of the file */
+    if (*s==0)
+	return NULL;
+    /* get the time */
+    if (sscanf (s, "%ld,%ld,", &(current->start),
+		&(current->end)) <2) {
+	return ERR;
+    }
+    /* the files I have are in tenths of second */
+    current->start *= 10;
+    current->end *= 10;
+    /* walk to the beggining of the string */
+    for (; *s; s++) if (*s==',') break;
+    if (*s) {
+	for (s++; *s; s++) if (*s==',') break;
+	if (*s) s++;
+    }
+    if (*s!='"') {
+	return ERR;
+    }
+    /* copy the string to the text buffer */
+    for (s++, d=text; *s && *s!='"'; s++, d++)
+	*d=*s;
+    *d=0;
+    current->text[0] = strdup(text);
+    current->lines = 1;
+
+    return current;
+}
+
+static subtitle *sub_read_line_mpsub(stream_t *st, subtitle *current,
+                                     struct readline_args *args)
+{
+        int utf16 = args->utf16;
+	char line[LINE_LEN+1];
+	float a,b;
+	int num=0;
+	char *p, *q;
+
+	do
+	{
+		if (!stream_read_line(st, line, LINE_LEN, utf16)) return NULL;
+	} while (sscanf (line, "%f %f", &a, &b) !=2);
+
+	args->mpsub_position += a*args->mpsub_multiplier;
+	current->start=(int) args->mpsub_position;
+	args->mpsub_position += b*args->mpsub_multiplier;
+	current->end=(int) args->mpsub_position;
+
+	while (num < SUB_MAX_TEXT) {
+		if (!stream_read_line (st, line, LINE_LEN, utf16)) {
+			if (num == 0) return NULL;
+			else return current;
+		}
+		p=line;
+		while (isspace(*p)) p++;
+		if (eol(*p) && num > 0) return current;
+		if (eol(*p)) return NULL;
+
+		for (q=p; !eol(*q); q++);
+		*q='\0';
+		if (strlen(p)) {
+			current->text[num]=strdup(p);
+//			printf (">%s<\n",p);
+			current->lines = ++num;
+		} else {
+			if (num) return current;
+			else return NULL;
+		}
+	}
+	return NULL; // we should have returned before if it's OK
+}
+
+static subtitle *sub_read_line_aqt(stream_t *st,subtitle *current,
+                                   struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+
+retry:
+    while (1) {
+    // try to locate next subtitle
+        if (!stream_read_line (st, line, LINE_LEN, utf16))
+		return NULL;
+        if (!(sscanf (line, "-->> %ld", &(current->start)) <1))
+		break;
+    }
+
+    if (!args->previous_sub_end)
+    args->previous_sub_end = (current->start) ? current->start - 1 : 0;
+
+    if (!stream_read_line (st, line, LINE_LEN, utf16))
+	return NULL;
+
+    sub_readtext((char *) &line,&current->text[0]);
+    current->lines = 1;
+    current->end = current->start; // will be corrected by next subtitle
+
+    if (!stream_read_line (st, line, LINE_LEN, utf16))
+	return current;
+
+    if (set_multiline_text(current, line, 1) == ERR)
+        return ERR;
+
+    if (!strlen(current->text[0]) && !strlen(current->text[1]))
+	goto retry;
+
+    return current;
+}
+
+static subtitle *sub_read_line_subrip09(stream_t *st,subtitle *current,
+                                    struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line[LINE_LEN+1];
+    int a1,a2,a3;
+    int len;
+
+retry:
+    while (1) {
+    // try to locate next subtitle
+        if (!stream_read_line (st, line, LINE_LEN, utf16))
+		return NULL;
+        if (!((len=sscanf (line, "[%d:%d:%d]",&a1,&a2,&a3)) < 3))
+		break;
+    }
+
+    current->start = a1*360000+a2*6000+a3*100;
+
+    if (!args->previous_sub_end)
+        args->previous_sub_end = (current->start) ? current->start - 1 : 0;
+
+    if (!stream_read_line (st, line, LINE_LEN, utf16))
+	return NULL;
+
+    current->text[0]=""; // just to be sure that string is clear
+
+    if (set_multiline_text(current, line, 0) == ERR)
+        return ERR;
+
+    if (!strlen(current->text[0]) && current->lines <= 1)
+	goto retry;
+
+    return current;
+}
+
+static subtitle *sub_read_line_jacosub(stream_t* st, subtitle * current,
+                                       struct readline_args *args)
+{
+    int utf16 = args->utf16;
+    char line1[LINE_LEN], line2[LINE_LEN], directive[LINE_LEN], *p, *q;
+    unsigned a1, a2, a3, a4, b1, b2, b3, b4, comment = 0;
+    static unsigned jacoTimeres = 30;
+    static int jacoShift = 0;
+
+    memset(current, 0, sizeof(subtitle));
+    memset(line1, 0, LINE_LEN);
+    memset(line2, 0, LINE_LEN);
+    memset(directive, 0, LINE_LEN);
+    while (!current->text[0]) {
+	if (!stream_read_line(st, line1, LINE_LEN, utf16)) {
+	    return NULL;
+	}
+	if (sscanf
+	    (line1, "%u:%u:%u.%u %u:%u:%u.%u %[^\n\r]", &a1, &a2, &a3, &a4,
+	     &b1, &b2, &b3, &b4, line2) < 9) {
+	    if (sscanf(line1, "@%u @%u %[^\n\r]", &a4, &b4, line2) < 3) {
+		if (line1[0] == '#') {
+		    int hours = 0, minutes = 0, seconds, delta, inverter =
+			1;
+		    unsigned units = jacoShift;
+		    switch (toupper(line1[1])) {
+		    case 'S':
+			if (isalpha(line1[2])) {
+			    delta = 6;
+			} else {
+			    delta = 2;
+			}
+			if (sscanf(&line1[delta], "%d", &hours)) {
+			    if (hours < 0) {
+				hours *= -1;
+				inverter = -1;
+			    }
+			    if (sscanf(&line1[delta], "%*d:%d", &minutes)) {
+				if (sscanf
+				    (&line1[delta], "%*d:%*d:%d",
+				     &seconds)) {
+				    sscanf(&line1[delta], "%*d:%*d:%*d.%d",
+					   &units);
+				} else {
+				    hours = 0;
+				    sscanf(&line1[delta], "%d:%d.%d",
+					   &minutes, &seconds, &units);
+				    minutes *= inverter;
+				}
+			    } else {
+				hours = minutes = 0;
+				sscanf(&line1[delta], "%d.%d", &seconds,
+				       &units);
+				seconds *= inverter;
+			    }
+			    jacoShift =
+				((hours * 3600 + minutes * 60 +
+				  seconds) * jacoTimeres +
+				 units) * inverter;
+			}
+			break;
+		    case 'T':
+			if (isalpha(line1[2])) {
+			    delta = 8;
+			} else {
+			    delta = 2;
+			}
+			sscanf(&line1[delta], "%u", &jacoTimeres);
+			break;
+		    }
+		}
+		continue;
+	    } else {
+		current->start =
+		    (unsigned long) ((a4 + jacoShift) * 100.0 /
+				     jacoTimeres);
+		current->end =
+		    (unsigned long) ((b4 + jacoShift) * 100.0 /
+				     jacoTimeres);
+	    }
+	} else {
+	    current->start =
+		(unsigned
+		 long) (((a1 * 3600 + a2 * 60 + a3) * jacoTimeres + a4 +
+			 jacoShift) * 100.0 / jacoTimeres);
+	    current->end =
+		(unsigned
+		 long) (((b1 * 3600 + b2 * 60 + b3) * jacoTimeres + b4 +
+			 jacoShift) * 100.0 / jacoTimeres);
+	}
+	current->lines = 0;
+	p = line2;
+	while ((*p == ' ') || (*p == '\t')) {
+	    ++p;
+	}
+	if (isalpha(*p)||*p == '[') {
+	    int cont, jLength;
+
+	    if (sscanf(p, "%s %[^\n\r]", directive, line1) < 2)
+		return (subtitle *) ERR;
+	    jLength = strlen(directive);
+	    for (cont = 0; cont < jLength; ++cont) {
+		if (isalpha(*(directive + cont)))
+		    *(directive + cont) = toupper(*(directive + cont));
+	    }
+	    if ((strstr(directive, "RDB") != NULL)
+		|| (strstr(directive, "RDC") != NULL)
+		|| (strstr(directive, "RLB") != NULL)
+		|| (strstr(directive, "RLG") != NULL)) {
+		continue;
+	    }
+	    if (strstr(directive, "JL") != NULL) {
+		current->alignment = SUB_ALIGNMENT_BOTTOMLEFT;
+	    } else if (strstr(directive, "JR") != NULL) {
+		current->alignment = SUB_ALIGNMENT_BOTTOMRIGHT;
+	    } else {
+		current->alignment = SUB_ALIGNMENT_BOTTOMCENTER;
+	    }
+	    strcpy(line2, line1);
+	    p = line2;
+	}
+	for (q = line1; (!eol(*p)) && (current->lines < SUB_MAX_TEXT); ++p) {
+	    switch (*p) {
+	    case '{':
+		comment++;
+		break;
+	    case '}':
+		if (comment) {
+		    --comment;
+		    //the next line to get rid of a blank after the comment
+		    if ((*(p + 1)) == ' ')
+			p++;
+		}
+		break;
+	    case '~':
+		if (!comment) {
+		    *q = ' ';
+		    ++q;
+		}
+		break;
+	    case ' ':
+	    case '\t':
+		if ((*(p + 1) == ' ') || (*(p + 1) == '\t'))
+		    break;
+		if (!comment) {
+		    *q = ' ';
+		    ++q;
+		}
+		break;
+	    case '\\':
+		if (*(p + 1) == 'n') {
+		    *q = '\0';
+		    q = line1;
+		    current->text[current->lines++] = strdup(line1);
+		    ++p;
+		    break;
+		}
+		if ((toupper(*(p + 1)) == 'C')
+		    || (toupper(*(p + 1)) == 'F')) {
+		    ++p,++p;
+		    break;
+		}
+		if ((*(p + 1) == 'B') || (*(p + 1) == 'b') || (*(p + 1) == 'D') ||	//actually this means "insert current date here"
+		    (*(p + 1) == 'I') || (*(p + 1) == 'i') || (*(p + 1) == 'N') || (*(p + 1) == 'T') ||	//actually this means "insert current time here"
+		    (*(p + 1) == 'U') || (*(p + 1) == 'u')) {
+		    ++p;
+		    break;
+		}
+		if ((*(p + 1) == '\\') ||
+		    (*(p + 1) == '~') || (*(p + 1) == '{')) {
+		    ++p;
+		} else if (eol(*(p + 1))) {
+		    if (!stream_read_line(st, directive, LINE_LEN, utf16))
+			return NULL;
+		    trail_space(directive);
+		    av_strlcat(line2, directive, LINE_LEN);
+		    break;
+		}
+	    default:
+		if (!comment) {
+		    *q = *p;
+		    ++q;
+		}
+	    }			//-- switch
+	}			//-- for
+	*q = '\0';
+	if (current->lines < SUB_MAX_TEXT)
+	    current->text[current->lines] = strdup(line1);
+    }				//-- while
+    if (current->lines < SUB_MAX_TEXT)
+        current->lines++;
+    return current;
+}
+
+static int sub_autodetect (stream_t* st, int *uses_time, int utf16) {
+    char line[LINE_LEN+1];
+    int i,j=0;
+
+    while (j < 100) {
+	j++;
+	if (!stream_read_line (st, line, LINE_LEN, utf16))
+	    return SUB_INVALID;
+
+	if (sscanf (line, "{%d}{%d}", &i, &i)==2)
+		{*uses_time=0;return SUB_MICRODVD;}
+	if (sscanf (line, "{%d}{}", &i)==1)
+		{*uses_time=0;return SUB_MICRODVD;}
+	if (sscanf (line, "[%d][%d]", &i, &i)==2)
+		{*uses_time=1;return SUB_MPL2;}
+	if (sscanf (line, "%d:%d:%d.%d,%d:%d:%d.%d",     &i, &i, &i, &i, &i, &i, &i, &i)==8)
+		{*uses_time=1;return SUB_SUBRIP;}
+	if (sscanf (line, "%d:%d:%d%*1[,.:]%d --> %d:%d:%d%*1[,.:]%d", &i, &i, &i, &i, &i, &i, &i, &i) == 8)
+		{*uses_time=1;return SUB_SUBVIEWER;}
+	if (sscanf (line, "{T %d:%d:%d:%d",&i, &i, &i, &i)==4)
+		{*uses_time=1;return SUB_SUBVIEWER2;}
+	if (strstr (line, "<SAMI>"))
+		{*uses_time=1; return SUB_SAMI;}
+	if (sscanf(line, "%d:%d:%d.%d %d:%d:%d.%d", &i, &i, &i, &i, &i, &i, &i, &i) == 8)
+		{*uses_time = 1; return SUB_JACOSUB;}
+	if (sscanf(line, "@%d @%d", &i, &i) == 2)
+		{*uses_time = 1; return SUB_JACOSUB;}
+	if (sscanf (line, "%d:%d:%d:",     &i, &i, &i )==3)
+		{*uses_time=1;return SUB_VPLAYER;}
+	if (sscanf (line, "%d:%d:%d ",     &i, &i, &i )==3)
+		{*uses_time=1;return SUB_VPLAYER;}
+	if (!strncasecmp(line, "<window", 7))
+		{*uses_time=1;return SUB_RT;}
+	if (!memcmp(line, "Dialogue: Marked", 16))
+		{*uses_time=1; return SUB_SSA;}
+	if (!memcmp(line, "Dialogue: ", 10))
+		{*uses_time=1; return SUB_SSA;}
+	if (sscanf (line, "%d,%d,\"%c", &i, &i, (char *) &i) == 3)
+		{*uses_time=1;return SUB_PJS;}
+	if (sscanf (line, "FORMAT=%d", &i) == 1)
+		{*uses_time=0; return SUB_MPSUB;}
+	if (!memcmp(line, "FORMAT=TIME", 11))
+		{*uses_time=1; return SUB_MPSUB;}
+	if (strstr (line, "-->>"))
+		{*uses_time=0; return SUB_AQTITLE;}
+	if (sscanf (line, "[%d:%d:%d]", &i, &i, &i)==3)
+		{*uses_time=1;return SUB_SUBRIP09;}
+    }
+
+    return SUB_INVALID;  // too many bad lines
+}
+
+#ifdef CONFIG_ICONV
+static const char* guess_cp(stream_t *st, const char *preferred_language, const char *fallback);
+
+static iconv_t	subcp_open (stream_t *st, const char *sub_cp)
+{
+        iconv_t icdsc = (iconv_t)(-1);
+	char *tocp = "UTF-8";
+
+	if (sub_cp){
+		const char *cp_tmp = sub_cp;
+#ifdef CONFIG_ENCA
+		char enca_lang[3], enca_fallback[100];
+		if (sscanf(sub_cp, "enca:%2s:%99s", enca_lang, enca_fallback) == 2
+		     || sscanf(sub_cp, "ENCA:%2s:%99s", enca_lang, enca_fallback) == 2) {
+		  if (st && st->flags & MP_STREAM_SEEK ) {
+		    cp_tmp = guess_cp(st, enca_lang, enca_fallback);
+		  } else {
+		    cp_tmp = enca_fallback;
+		    if (st)
+		      mp_msg(MSGT_SUBREADER,MSGL_WARN,"SUB: enca failed, stream must be seekable.\n");
+		  }
+		}
+#endif
+		if ((icdsc = iconv_open (tocp, cp_tmp)) != (iconv_t)(-1)){
+			mp_msg(MSGT_SUBREADER,MSGL_V,"SUB: opened iconv descriptor.\n");
+		} else
+			mp_msg(MSGT_SUBREADER,MSGL_ERR,"SUB: error opening iconv descriptor.\n");
+	}
+	return icdsc;
+}
+
+static void	subcp_close (iconv_t icdsc)
+{
+	if (icdsc != (iconv_t)(-1)){
+		(void) iconv_close (icdsc);
+	   	mp_msg(MSGT_SUBREADER,MSGL_V,"SUB: closed iconv descriptor.\n");
+	}
+}
+
+static subtitle* subcp_recode (iconv_t icdsc, subtitle *sub)
+{
+	int l=sub->lines;
+	size_t ileft, oleft;
+	char *op, *ip, *ot;
+	if(icdsc == (iconv_t)(-1)) return sub;
+
+	while (l){
+		ip = sub->text[--l];
+		ileft = strlen(ip);
+		oleft = 4 * ileft;
+
+		if (!(ot = malloc(oleft + 1)))
+                    abort();
+		op = ot;
+		if (iconv(icdsc, &ip, &ileft,
+			  &op, &oleft) == (size_t)(-1)) {
+			mp_msg(MSGT_SUBREADER,MSGL_WARN,"SUB: error recoding line.\n");
+			free(ot);
+			continue;
+		}
+		// In some stateful encodings, we must clear the state to handle the last character
+		if (iconv(icdsc, NULL, NULL,
+			  &op, &oleft) == (size_t)(-1)) {
+			mp_msg(MSGT_SUBREADER,MSGL_WARN,"SUB: error recoding line, can't clear encoding state.\n");
+		}
+		*op='\0' ;
+		free (sub->text[l]);
+		sub->text[l] = ot;
+	}
+	return sub;
+}
+#endif
+
+static void adjust_subs_time(subtitle* sub, float subtime, float fps,
+                             float sub_fps, int block,
+                             int sub_num, int sub_uses_time) {
+	int n,m;
+	subtitle* nextsub;
+	int i = sub_num;
+	unsigned long subfms = (sub_uses_time ? 100 : fps) * subtime;
+
+	n=m=0;
+	if (i)	for (;;){
+		if (sub->end <= sub->start){
+			sub->end = sub->start + subfms;
+			m++;
+			n++;
+		}
+		if (!--i) break;
+		nextsub = sub + 1;
+	    if(block){
+		if (sub->end >= nextsub->start){
+			sub->end = nextsub->start - 1;
+			if (sub->end - sub->start > subfms)
+				sub->end = sub->start + subfms;
+			if (!m)
+				n++;
+		}
+	    }
+
+		sub = nextsub;
+		m = 0;
+	}
+	if (n) mp_msg(MSGT_SUBREADER,MSGL_V,"SUB: Adjusted %d subtitle(s).\n", n);
+}
+
+struct subreader {
+    subtitle * (*read)(stream_t *st, subtitle *dest,
+                       struct readline_args *args);
+    void       (*post)(subtitle *dest);
+    const char *name;
+    const char *codec_name;
+};
+
+#ifdef CONFIG_ENCA
+static const char* guess_buffer_cp(unsigned char* buffer, int buflen, const char *preferred_language, const char *fallback)
+{
+    const char **languages;
+    size_t langcnt;
+    EncaAnalyser analyser;
+    EncaEncoding encoding;
+    const char *detected_sub_cp = NULL;
+    int i;
+
+    languages = enca_get_languages(&langcnt);
+    mp_msg(MSGT_SUBREADER, MSGL_V, "ENCA supported languages: ");
+    for (i = 0; i < langcnt; i++) {
+	mp_msg(MSGT_SUBREADER, MSGL_V, "%s ", languages[i]);
+    }
+    mp_msg(MSGT_SUBREADER, MSGL_V, "\n");
+
+    for (i = 0; i < langcnt; i++) {
+	if (strcasecmp(languages[i], preferred_language) != 0) continue;
+	analyser = enca_analyser_alloc(languages[i]);
+	encoding = enca_analyse_const(analyser, buffer, buflen);
+	enca_analyser_free(analyser);
+	if (encoding.charset != ENCA_CS_UNKNOWN) {
+	    detected_sub_cp = enca_charset_name(encoding.charset, ENCA_NAME_STYLE_ICONV);
+	    break;
+	}
+    }
+
+    free(languages);
+
+    if (!detected_sub_cp) {
+	detected_sub_cp = fallback;
+	mp_msg(MSGT_SUBREADER, MSGL_INFO, "ENCA detection failed: fallback to %s\n", fallback);
+    }else{
+	mp_msg(MSGT_SUBREADER, MSGL_INFO, "ENCA detected charset: %s\n", detected_sub_cp);
+    }
+
+    return detected_sub_cp;
+}
+
+#define MAX_GUESS_BUFFER_SIZE (256*1024)
+static const char* guess_cp(stream_t *st, const char *preferred_language, const char *fallback)
+{
+    size_t buflen;
+    unsigned char *buffer;
+    const char *detected_sub_cp = NULL;
+
+    buffer = malloc(MAX_GUESS_BUFFER_SIZE);
+    buflen = stream_read(st,buffer, MAX_GUESS_BUFFER_SIZE);
+
+    detected_sub_cp = guess_buffer_cp(buffer, buflen, preferred_language, fallback);
+
+    free(buffer);
+    stream_seek(st,0);
+
+    return detected_sub_cp;
+}
+#undef MAX_GUESS_BUFFER_SIZE
+#endif
+
+static int sub_destroy(void *ptr);
+
+sub_data* sub_read_file(char *filename, float fps, struct MPOpts *opts)
+{
+    int utf16;
+    stream_t* fd;
+    int n_max, i, j;
+    subtitle *first, *sub, *return_sub, *alloced_sub = NULL;
+    sub_data *subt_data;
+    int uses_time = 0, sub_num = 0, sub_errs = 0;
+    static const struct subreader sr[]=
+    {
+	    { sub_read_line_microdvd, NULL, "microdvd", "microdvd" },
+	    { sub_read_line_subrip, NULL, "subviewer" },
+	    { sub_read_line_subviewer, NULL, "subrip", "subrip" },
+	    { sub_read_line_sami, NULL, "sami" },
+	    { sub_read_line_vplayer, NULL, "vplayer" },
+	    { sub_read_line_rt, NULL, "rt" },
+	    { sub_read_line_ssa, NULL, "ssa", "ass-text" },
+	    { sub_read_line_pjs, NULL, "pjs" },
+	    { sub_read_line_mpsub, NULL, "mpsub" },
+	    { sub_read_line_aqt, NULL, "aqt" },
+	    { sub_read_line_subviewer2, NULL, "subviewer 2.0" },
+	    { sub_read_line_subrip09, NULL, "subrip 0.9" },
+	    { sub_read_line_jacosub, NULL, "jacosub" },
+	    { sub_read_line_mpl2, NULL, "mpl2" }
+    };
+    const struct subreader *srp;
+
+    if(filename==NULL) return NULL; //qnx segfault
+    fd=open_stream (filename, NULL, NULL); if (!fd) return NULL;
+
+    int sub_format = SUB_INVALID;
+    for (utf16 = 0; sub_format == SUB_INVALID && utf16 < 3; utf16++) {
+        sub_format=sub_autodetect (fd, &uses_time, utf16);
+        stream_seek(fd,0);
+    }
+    utf16--;
+
+    struct readline_args args = {utf16, opts};
+    args.sub_slacktime = 20000; //20 sec
+    args.mpsub_multiplier = (uses_time ? 100.0 : 1.0);
+
+    if (sub_format==SUB_INVALID) {
+        mp_msg(MSGT_SUBREADER,MSGL_WARN,"SUB: Could not determine file format\n");
+        free_stream(fd);
+        return NULL;
+    }
+    srp=sr+sub_format;
+    mp_msg(MSGT_SUBREADER, MSGL_V, "SUB: Detected subtitle file format: %s\n", srp->name);
+
+#ifdef CONFIG_ICONV
+    iconv_t icdsc = (iconv_t)(-1);
+    {
+	    int l,k;
+	    k = -1;
+	    if ((l=strlen(filename))>4){
+		    char *exts[] = {".utf", ".utf8", ".utf-8" };
+		    for (k=3;--k>=0;)
+			if (l >= strlen(exts[k]) && !strcasecmp(filename+(l - strlen(exts[k])), exts[k])){
+			    break;
+			}
+	    }
+	    if (k<0) icdsc = subcp_open(fd, opts->sub_cp);
+    }
+#endif
+
+    sub_num=0;n_max=32;
+    first=malloc(n_max*sizeof(subtitle));
+    if (!first)
+        abort();
+
+    alloced_sub =
+    sub = malloc(sizeof(subtitle));
+    //This is to deal with those formats (AQT & Subrip) which define the end of a subtitle
+    //as the beginning of the following
+    args.previous_sub_end = 0;
+    while(1){
+        if(sub_num>=n_max){
+            n_max+=16;
+            first=realloc(first,n_max*sizeof(subtitle));
+        }
+	memset(sub, '\0', sizeof(subtitle));
+        sub=srp->read(fd, sub, &args);
+        if(!sub) break;   // EOF
+#ifdef CONFIG_ICONV
+	if (sub!=ERR) sub=subcp_recode(icdsc, sub);
+#endif
+	if ( sub == ERR )
+	 {
+#ifdef CONFIG_ICONV
+          subcp_close(icdsc);
+#endif
+	  free(first);
+	  free(alloced_sub);
+          free_stream(fd);
+	  return NULL;
+	 }
+        // Apply any post processing that needs recoding first
+        if ((sub!=ERR) && !args.opts->sub_no_text_pp && srp->post) srp->post(sub);
+	if(!sub_num || (first[sub_num - 1].start <= sub->start)){
+	    first[sub_num].start = sub->start;
+  	    first[sub_num].end   = sub->end;
+	    first[sub_num].lines = sub->lines;
+	    first[sub_num].alignment = sub->alignment;
+  	    for(i = 0; i < sub->lines; ++i){
+		first[sub_num].text[i] = sub->text[i];
+  	    }
+	    if (args.previous_sub_end){
+  		first[sub_num - 1].end = args.previous_sub_end;
+    		args.previous_sub_end = 0;
+	    }
+	} else {
+	    for(j = sub_num - 1; j >= 0; --j){
+    		first[j + 1].start = first[j].start;
+    		first[j + 1].end   = first[j].end;
+		first[j + 1].lines = first[j].lines;
+		first[j + 1].alignment = first[j].alignment;
+    		for(i = 0; i < first[j].lines; ++i){
+      		    first[j + 1].text[i] = first[j].text[i];
+		}
+		if(!j || (first[j - 1].start <= sub->start)){
+	    	    first[j].start = sub->start;
+	    	    first[j].end   = sub->end;
+	    	    first[j].lines = sub->lines;
+	    	    first[j].alignment = sub->alignment;
+	    	    for(i = 0; i < SUB_MAX_TEXT; ++i){
+			first[j].text[i] = sub->text[i];
+		    }
+		    if (args.previous_sub_end){
+			first[j].end = first[j - 1].end;
+			first[j - 1].end = args.previous_sub_end;
+			args.previous_sub_end = 0;
+		    }
+		    break;
+    		}
+	    }
+	}
+        if(sub==ERR) ++sub_errs; else ++sub_num; // Error vs. Valid
+    }
+
+    free_stream(fd);
+
+#ifdef CONFIG_ICONV
+    subcp_close(icdsc);
+#endif
+    free(alloced_sub);
+
+//    printf ("SUB: Subtitle format %s time.\n", uses_time?"uses":"doesn't use");
+    mp_msg(MSGT_SUBREADER, MSGL_V,"SUB: Read %i subtitles, %i bad line(s).\n",
+           sub_num, sub_errs);
+
+    if(sub_num<=0){
+	free(first);
+	return NULL;
+    }
+
+    adjust_subs_time(first, 6.0, fps, opts->sub_fps, 1, sub_num, uses_time);/*~6 secs AST*/
+    return_sub = first;
+
+    if (return_sub == NULL) return NULL;
+    subt_data = talloc_zero(NULL, sub_data);
+    talloc_set_destructor(subt_data, sub_destroy);
+    subt_data->codec = srp->codec_name ? srp->codec_name : "text";
+    subt_data->filename = strdup(filename);
+    subt_data->sub_uses_time = uses_time;
+    subt_data->sub_num = sub_num;
+    subt_data->sub_errs = sub_errs;
+    subt_data->subtitles = return_sub;
+    subt_data->fallback_fps = fps;
+    return subt_data;
+}
+
+static int sub_destroy(void *ptr)
+{
+    sub_data *subd = ptr;
+    int i, j;
+    for (i = 0; i < subd->sub_num; i++)
+        for (j = 0; j < subd->subtitles[i].lines; j++)
+            free( subd->subtitles[i].text[j] );
+    free( subd->subtitles );
+    free( subd->filename );
+    return 0;
+}
diff --git a/demux/subreader.h b/demux/subreader.h
new file mode 100644
index 0000000000..3b2e53efd8
--- /dev/null
+++ b/demux/subreader.h
@@ -0,0 +1,79 @@
+/*
+ * 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_SUBREADER_H
+#define MPLAYER_SUBREADER_H
+
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "config.h"
+
+// subtitle formats
+#define SUB_INVALID   -1
+#define SUB_MICRODVD  0
+#define SUB_SUBRIP    1
+#define SUB_SUBVIEWER 2
+#define SUB_SAMI      3
+#define SUB_VPLAYER   4
+#define SUB_RT        5
+#define SUB_SSA       6
+#define SUB_PJS       7
+#define SUB_MPSUB     8
+#define SUB_AQTITLE   9
+#define SUB_SUBVIEWER2 10
+#define SUB_SUBRIP09 11
+#define SUB_JACOSUB  12
+#define SUB_MPL2     13
+
+#define SUB_MAX_TEXT 12
+#define SUB_ALIGNMENT_BOTTOMLEFT       1
+#define SUB_ALIGNMENT_BOTTOMCENTER     2
+#define SUB_ALIGNMENT_BOTTOMRIGHT      3
+#define SUB_ALIGNMENT_MIDDLELEFT       4
+#define SUB_ALIGNMENT_MIDDLECENTER     5
+#define SUB_ALIGNMENT_MIDDLERIGHT      6
+#define SUB_ALIGNMENT_TOPLEFT          7
+#define SUB_ALIGNMENT_TOPCENTER        8
+#define SUB_ALIGNMENT_TOPRIGHT         9
+
+typedef struct subtitle {
+
+    int lines;
+
+    unsigned long start;
+    unsigned long end;
+
+    char *text[SUB_MAX_TEXT];
+    unsigned char alignment;
+} subtitle;
+
+typedef struct sub_data {
+    const char *codec;
+    subtitle *subtitles;
+    char *filename;
+    int sub_uses_time;
+    int sub_num;          // number of subtitle structs
+    int sub_errs;
+    double fallback_fps;
+} sub_data;
+
+struct MPOpts;
+sub_data* sub_read_file (char *filename, float pts, struct MPOpts *opts);
+
+#endif /* MPLAYER_SUBREADER_H */
-- 
cgit v1.2.3


From e3c0fb1aee806758b1de8c148696afe5b0333701 Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Fri, 21 Jun 2013 21:14:38 +0200
Subject: demux_lavf: use stream_peek() instead of read/unread

Simpler, reduces the amount of copying.

We still have to malloc+memcpy the probe buffer though, because padding
with FF_INPUT_BUFFER_PADDING_SIZE is required by libavformat.
---
 demux/demux_lavf.c | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'demux')

diff --git a/demux/demux_lavf.c b/demux/demux_lavf.c
index d8e8109c93..48e79e949b 100644
--- a/demux/demux_lavf.c
+++ b/demux/demux_lavf.c
@@ -267,12 +267,11 @@ static int lavf_check_file(demuxer_t *demuxer)
     while (avpd.buf_size < PROBE_BUF_SIZE) {
         int nsize = av_clip(avpd.buf_size * 2, INITIAL_PROBE_SIZE,
                             PROBE_BUF_SIZE);
-        int read_size = stream_read(s, avpd.buf + avpd.buf_size,
-                                    nsize - avpd.buf_size);
-        if (read_size <= 0)
+        bstr buf = stream_peek(s, nsize);
+        if (buf.len <= avpd.buf_size)
             break;
-
-        avpd.buf_size += read_size;
+        memcpy(avpd.buf, buf.start, buf.len);
+        avpd.buf_size = buf.len;
 
         int score = 0;
         priv->avif = av_probe_input_format2(&avpd, avpd.buf_size > 0, &score);
@@ -294,7 +293,6 @@ static int lavf_check_file(demuxer_t *demuxer)
         priv->avif = NULL;
     }
 
-    stream_unread_buffer(s, avpd.buf, avpd.buf_size);
     av_free(avpd.buf);
 
     if (!priv->avif) {
-- 
cgit v1.2.3


From b37147744e34c0f23acb391de6bd04a0a1dc8cca Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Fri, 21 Jun 2013 21:18:03 +0200
Subject: demux: add utility functions for preloading demuxers

These will be needed by subtitle demuxers, which read all data on
initialization.
---
 demux/demux.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 demux/demux.h | 11 +++++++--
 2 files changed, 81 insertions(+), 5 deletions(-)

(limited to 'demux')

diff --git a/demux/demux.c b/demux/demux.c
index 23c4a28706..be00f38bd7 100644
--- a/demux/demux.c
+++ b/demux/demux.c
@@ -482,13 +482,16 @@ void free_demuxer(demuxer_t *demuxer)
     talloc_free(demuxer);
 }
 
-void demuxer_add_packet(demuxer_t *demuxer, struct sh_stream *stream,
-                        demux_packet_t *dp)
+// Returns the same value as demuxer->fill_buffer: 1 ok, 0 EOF/not selected.
+int demuxer_add_packet(demuxer_t *demuxer, struct sh_stream *stream,
+                       demux_packet_t *dp)
 {
-    if (!demuxer_stream_is_selected(demuxer, stream)) {
+    if (!dp || !demuxer_stream_is_selected(demuxer, stream)) {
         free_demux_packet(dp);
+        return 0;
     } else {
         ds_add_packet(demuxer->ds[stream->type], dp);
+        return 1;
     }
 }
 
@@ -1518,3 +1521,69 @@ int demuxer_set_angle(demuxer_t *demuxer, int angle)
 
     return angle;
 }
+
+static int packet_sort_compare(const void *p1, const void *p2)
+{
+    struct demux_packet *c1 = *(struct demux_packet **)p1;
+    struct demux_packet *c2 = *(struct demux_packet **)p2;
+
+    if (c1->pts > c2->pts)
+        return 1;
+    else if (c1->pts < c2->pts)
+        return -1;
+    return 0;
+}
+
+void demux_packet_list_sort(struct demux_packet **pkts, int num_pkts)
+{
+    qsort(pkts, num_pkts, sizeof(struct demux_packet *), packet_sort_compare);
+}
+
+void demux_packet_list_seek(struct demux_packet **pkts, int num_pkts,
+                            int *current, float rel_seek_secs, int flags)
+{
+    double ref_time = 0;
+    if (*current >= 0 && *current < num_pkts) {
+        ref_time = pkts[*current]->pts;
+    } else if (*current == num_pkts && num_pkts > 0) {
+        ref_time = pkts[num_pkts - 1]->pts + pkts[num_pkts - 1]->duration;
+    }
+
+    if (flags & SEEK_ABSOLUTE)
+        ref_time = 0;
+
+    if (flags & SEEK_FACTOR) {
+        ref_time += demux_packet_list_duration(pkts, num_pkts) * rel_seek_secs;
+    } else {
+        ref_time += rel_seek_secs;
+    }
+
+    // Could do binary search, but it's probably not worth the complexity.
+    int last_index = 0;
+    for (int n = 0; n < num_pkts; n++) {
+        if (pkts[n]->pts > ref_time)
+            break;
+        last_index = n;
+    }
+    *current = last_index;
+}
+
+double demux_packet_list_duration(struct demux_packet **pkts, int num_pkts)
+{
+    if (num_pkts > 0)
+        return pkts[num_pkts - 1]->pts + pkts[num_pkts - 1]->duration;
+    return 0;
+}
+
+struct demux_packet *demux_packet_list_fill(struct demux_packet **pkts,
+                                            int num_pkts, int *current)
+{
+    if (*current < 0)
+        *current = 0;
+    if (*current >= num_pkts)
+        return NULL;
+    struct demux_packet *new = talloc(NULL, struct demux_packet);
+    *new = *pkts[*current];
+    *current += 1;
+    return new;
+}
diff --git a/demux/demux.h b/demux/demux.h
index a82fbea91a..bf16001c0f 100644
--- a/demux/demux.h
+++ b/demux/demux.h
@@ -311,8 +311,8 @@ demuxer_t *new_sub_pseudo_demuxer(struct MPOpts *opts);
 
 void free_demuxer(struct demuxer *demuxer);
 
-void demuxer_add_packet(demuxer_t *demuxer, struct sh_stream *stream,
-                        demux_packet_t *dp);
+int demuxer_add_packet(demuxer_t *demuxer, struct sh_stream *stream,
+                       demux_packet_t *dp);
 void ds_add_packet(struct demux_stream *ds, struct demux_packet *dp);
 void ds_read_packet(struct demux_stream *ds, struct stream *stream, int len,
                     double pts, int64_t pos, bool keyframe);
@@ -426,4 +426,11 @@ struct sh_stream *demuxer_stream_by_demuxer_id(struct demuxer *d,
 
 bool demuxer_stream_is_selected(struct demuxer *d, struct sh_stream *stream);
 
+void demux_packet_list_sort(struct demux_packet **pkts, int num_pkts);
+void demux_packet_list_seek(struct demux_packet **pkts, int num_pkts,
+                            int *current, float rel_seek_secs, int flags);
+double demux_packet_list_duration(struct demux_packet **pkts, int num_pkts);
+struct demux_packet *demux_packet_list_fill(struct demux_packet **pkts,
+                                            int num_pkts, int *current);
+
 #endif /* MPLAYER_DEMUXER_H */
-- 
cgit v1.2.3


From 98388c0c073906f4485420485e27a14e8d957a2d Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Fri, 21 Jun 2013 21:34:55 +0200
Subject: subreader: turn into actual demuxer

subreader.c (before this commit renamed to demux_subreader.c) was
special cased to the -sub option. The plan is using the normal demuxer
codepath for all subtitle formats (so we can prefer libavformat demuxers
for most formats).

There are some subtle changes. The probe size is restricted to 32 KB
(instead of unlimitted + giving up after 100 lines of input). For
formats like MicroDVD, the video FPS isn't used anymore, because it's
not available on the subtitle demuxer level. Instead, hardcode it to
23.976 FPS (libavformat seems to do the same). The user can probably
still use -sub-fps to fix the timing. Checking the file extension for
".utf"/".utf8"/".utf-8" is simply removed (seems worthless, was in the
way, and I've never seen this anywhere).
---
 demux/demux.c           |   2 +
 demux/demux.h           |   1 +
 demux/demux_subreader.c | 273 +++++++++++++++++++++++++++++++++++++++---------
 demux/stheader.h        |   1 -
 demux/subreader.h       |  79 --------------
 5 files changed, 227 insertions(+), 129 deletions(-)
 delete mode 100644 demux/subreader.h

(limited to 'demux')

diff --git a/demux/demux.c b/demux/demux.c
index be00f38bd7..379a74f654 100644
--- a/demux/demux.c
+++ b/demux/demux.c
@@ -68,6 +68,7 @@ extern const demuxer_desc_t demuxer_desc_mpeg4_es;
 extern const demuxer_desc_t demuxer_desc_h264_es;
 extern const demuxer_desc_t demuxer_desc_mpeg_ts;
 extern const demuxer_desc_t demuxer_desc_sub;
+extern const demuxer_desc_t demuxer_desc_subreader;
 
 /* Please do not add any new demuxers here. If you want to implement a new
  * demuxer, add it to libavformat, except for wrappers around external
@@ -83,6 +84,7 @@ const demuxer_desc_t *const demuxer_list[] = {
 #endif
     &demuxer_desc_matroska,
     &demuxer_desc_lavf,
+    &demuxer_desc_subreader,
     &demuxer_desc_avi,
     &demuxer_desc_asf,
 #ifdef CONFIG_MNG
diff --git a/demux/demux.h b/demux/demux.h
index bf16001c0f..9c10ca0201 100644
--- a/demux/demux.h
+++ b/demux/demux.h
@@ -71,6 +71,7 @@ enum demuxer_type {
     DEMUXER_TYPE_MNG,
     DEMUXER_TYPE_EDL,
     DEMUXER_TYPE_CUE,
+    DEMUXER_TYPE_SUBREADER,
 
     /* Values after this are for internal use and can not be selected
      * as demuxer type by the user (-demuxer option). */
diff --git a/demux/demux_subreader.c b/demux/demux_subreader.c
index befac689a4..e95ffda976 100644
--- a/demux/demux_subreader.c
+++ b/demux/demux_subreader.c
@@ -28,14 +28,15 @@
 #include <dirent.h>
 #include <ctype.h>
 
+#include <libavutil/common.h>
+#include <libavutil/avstring.h>
+
 #include "config.h"
 #include "core/mp_msg.h"
-#include "subreader.h"
 #include "core/mp_common.h"
 #include "core/options.h"
 #include "stream/stream.h"
-#include "libavutil/common.h"
-#include "libavutil/avstring.h"
+#include "demux/demux.h"
 
 #ifdef CONFIG_ENCA
 #include <enca.h>
@@ -47,6 +48,54 @@
 #include <iconv.h>
 #endif
 
+// subtitle formats
+#define SUB_INVALID   -1
+#define SUB_MICRODVD  0
+#define SUB_SUBRIP    1
+#define SUB_SUBVIEWER 2
+#define SUB_SAMI      3
+#define SUB_VPLAYER   4
+#define SUB_RT        5
+#define SUB_SSA       6
+#define SUB_PJS       7
+#define SUB_MPSUB     8
+#define SUB_AQTITLE   9
+#define SUB_SUBVIEWER2 10
+#define SUB_SUBRIP09 11
+#define SUB_JACOSUB  12
+#define SUB_MPL2     13
+
+#define SUB_MAX_TEXT 12
+#define SUB_ALIGNMENT_BOTTOMLEFT       1
+#define SUB_ALIGNMENT_BOTTOMCENTER     2
+#define SUB_ALIGNMENT_BOTTOMRIGHT      3
+#define SUB_ALIGNMENT_MIDDLELEFT       4
+#define SUB_ALIGNMENT_MIDDLECENTER     5
+#define SUB_ALIGNMENT_MIDDLERIGHT      6
+#define SUB_ALIGNMENT_TOPLEFT          7
+#define SUB_ALIGNMENT_TOPCENTER        8
+#define SUB_ALIGNMENT_TOPRIGHT         9
+
+typedef struct subtitle {
+
+    int lines;
+
+    unsigned long start;
+    unsigned long end;
+
+    char *text[SUB_MAX_TEXT];
+    unsigned char alignment;
+} subtitle;
+
+typedef struct sub_data {
+    const char *codec;
+    subtitle *subtitles;
+    int sub_uses_time;
+    int sub_num;          // number of subtitle structs
+    int sub_errs;
+    double fallback_fps;
+} sub_data;
+
 // Parameter struct for the format-specific readline functions
 struct readline_args {
     int utf16;
@@ -58,6 +107,8 @@ struct readline_args {
     float mpsub_position;
     int sub_slacktime;
 
+    int uses_time;
+
     /*
     Some subtitling formats, namely AQT and Subrip09, define the end of a
     subtitle as the beginning of the following. Since currently we read one
@@ -171,7 +222,7 @@ static subtitle *sub_read_line_sami(stream_t* st, subtitle *current,
                 sami_add_line(current, text, &p);
 		s += 4;
 	    }
-	    else if ((*s == '{') && !args->opts->sub_no_text_pp) { state = 5; ++s; continue; }
+	    else if ((*s == '{')) { state = 5; ++s; continue; }
 	    else if (*s == '<') { state = 4; }
 	    else if (!strncasecmp (s, "&nbsp;", 6)) { *p++ = ' '; s += 6; }
 	    else if (*s == '\t') { *p++ = ' '; s++; }
@@ -197,7 +248,7 @@ static subtitle *sub_read_line_sami(stream_t* st, subtitle *current,
 	    if (s) { s++; state = 3; continue; }
 	    break;
        case 5: /* get rid of {...} text, but read the alignment code */
-	    if ((*s == '\\') && (*(s + 1) == 'a') && !args->opts->sub_no_text_pp) {
+	    if ((*s == '\\') && (*(s + 1) == 'a')) {
                if (stristr(s, "\\a1") != NULL) {
                    current->alignment = SUB_ALIGNMENT_BOTTOMLEFT;
                    s = s + 3;
@@ -1130,6 +1181,7 @@ struct subreader {
     void       (*post)(subtitle *dest);
     const char *name;
     const char *codec_name;
+    struct readline_args args;
 };
 
 #ifdef CONFIG_ENCA
@@ -1192,16 +1244,9 @@ static const char* guess_cp(stream_t *st, const char *preferred_language, const
 #undef MAX_GUESS_BUFFER_SIZE
 #endif
 
-static int sub_destroy(void *ptr);
-
-sub_data* sub_read_file(char *filename, float fps, struct MPOpts *opts)
+static bool subreader_autodetect(stream_t *fd, struct MPOpts *opts,
+                                 struct subreader *out)
 {
-    int utf16;
-    stream_t* fd;
-    int n_max, i, j;
-    subtitle *first, *sub, *return_sub, *alloced_sub = NULL;
-    sub_data *subt_data;
-    int uses_time = 0, sub_num = 0, sub_errs = 0;
     static const struct subreader sr[]