Merge branch 'edl'

* edl:
  core: support timeline with audio-only files
  core: wake up a bit less often for audio-only files
  core: audio: cut audio writes at end of timeline part
  EDL: add support for new EDL file format
  stream.[ch], ass_mp: new stream function for whole-file reads
  tl_matroska.c: move the find_files() function here
  bstr.[ch], path.[ch]: add string and path handling functions
  core: ordered chapters: move timeline creation to timeline/
  options: drop support for numeric -demuxer values
  cleanup: demuxer.[ch]: remove unused code, make functions static
  cleanup: reindent demuxer.h, use struct names for types

19 files changed, 1347 insertions, 666 deletions

diff --git a/DOCS/man/en/mplayer.1 b/DOCS/man/en/mplayer.1
index 91ae431846..82d53b5d6d 100644
--- a/DOCS/man/en/mplayer.1
+++ b/DOCS/man/en/mplayer.1
@@ -1177,9 +1177,7 @@ Plays a Matroska file in Japanese.
 Force audio demuxer type for \-audiofile.
 Use a '+' before the name to force it, this will skip some checks!
 Give the demuxer name as printed by \-audio\-demuxer help.
-For backward compatibility it also accepts the demuxer ID as defined in
-libmpdemux/\:demuxer.h.
-\-audio\-demuxer audio or \-audio\-demuxer 17 forces MP3.
+\-audio\-demuxer audio forces MP3.
 .
 .TP
 .B \-audiofile <filename>
@@ -1356,8 +1354,6 @@ This nullifies stream delays.
 Force demuxer type.
 Use a '+' before the name to force it, this will skip some checks!
 Give the demuxer name as printed by \-demuxer help.
-For backward compatibility it also accepts the demuxer ID as defined in
-libmpdemux/\:demuxer.h.
 .
 .TP
 .B \-dumpaudio
@@ -2416,8 +2412,6 @@ intensity of the color.
 Force subtitle demuxer type for \-subfile.
 Use a '+' before the name to force it, this will skip some checks!
 Give the demuxer name as printed by \-sub\-demuxer help.
-For backward compatibility it also accepts the demuxer ID as defined in
-subreader.h.
 .
 .TP
 .B \-sub\-fuzziness <mode>
diff --git a/Makefile b/Makefile
index f362a814ee..2f4e668877 100644
--- a/Makefile
+++ b/Makefile
@@ -374,6 +374,7 @@ SRCS_COMMON = asxparser.c \
               libmpdemux/demux_audio.c \
               libmpdemux/demux_avi.c \
               libmpdemux/demux_demuxers.c \
+              libmpdemux/demux_edl.c \
               libmpdemux/demux_film.c \
               libmpdemux/demux_fli.c \
               libmpdemux/demux_lmlm4.c \
@@ -407,7 +408,6 @@ SRCS_COMMON = asxparser.c \
               libmpdemux/yuv4mpeg.c \
               libmpdemux/yuv4mpeg_ratio.c \
               libvo/osd.c \
-              osdep/findfiles.c \
               osdep/numcores.c \
               osdep/$(GETCH) \
               osdep/$(TIMER) \
@@ -426,6 +426,8 @@ SRCS_COMMON = asxparser.c \
               sub/subassconvert.c \
               sub/subreader.c \
               sub/vobsub.c \
+              timeline/tl_edl.c \
+              timeline/tl_matroska.c \
               $(SRCS_COMMON-yes)
 
 
@@ -569,6 +571,7 @@ DIRS =  . \
         stream/librtsp \
         stream/realrtsp \
         sub \
+        timeline \
         TOOLS \
 
 MOFILES := $(MSG_LANGS:%=locale/%/LC_MESSAGES/mplayer.mo)
diff --git a/bstr.c b/bstr.c
index 3cc3928086..d86b488912 100644
--- a/bstr.c
+++ b/bstr.c
@@ -18,6 +18,10 @@
 
 #include <string.h>
 #include <libavutil/avutil.h>
+#include <assert.h>
+
+#include "talloc.h"
+
 #include "bstr.h"
 
 int bstrcmp(struct bstr str1, struct bstr str2)
@@ -49,3 +53,90 @@ int bstrcasecmp(struct bstr str1, struct bstr str2)
     }
     return ret;
 }
+
+int bstrchr(struct bstr str, int c)
+{
+    for (int i = 0; i < str.len; i++)
+        if (str.start[i] == c)
+            return i;
+    return -1;
+}
+
+struct bstr bstr_strip(struct bstr str)
+{
+    while (str.len && isspace(*str.start)) {
+        str.start++;
+        str.len--;
+    }
+    while (str.len && isspace(str.start[str.len - 1]))
+        str.len--;
+    return str;
+}
+
+struct bstr bstr_split(struct bstr str, char *sep, struct bstr *rest)
+{
+    int start, end;
+    for (start = 0; start < str.len; start++)
+        if (!strchr(sep, str.start[start]))
+            break;
+    for (end = start; end < str.len; end++)
+        if (strchr(sep, str.start[end]))
+            break;
+    if (rest) {
+        *rest = bstr_cut(str, end);
+    }
+    str.start += start;
+    str.len = end - start;
+    return str;
+}
+
+
+struct bstr bstr_splice(struct bstr str, int start, int end)
+{
+    if (start < 0)
+        start += str.len;
+    if (end < 0)
+        end += str.len;
+    end = FFMIN(end, str.len);
+    start = FFMAX(start, 0);
+    if (start >= end)
+        return (struct bstr){NULL, 0};
+    str.start += start;
+    str.len = end - start;
+    return str;
+}
+
+long long bstrtoll(struct bstr str, struct bstr *rest, int base)
+{
+    char buf[51];
+    int len = FFMIN(str.len, 50);
+    memcpy(buf, str.start, len);
+    buf[len] = 0;
+    char *endptr;
+    long long r = strtoll(buf, &endptr, base);
+    if (rest)
+        *rest = bstr_cut(str, endptr - buf);
+    return r;
+}
+
+struct bstr *bstr_splitlines(void *talloc_ctx, struct bstr str)
+{
+    if (str.len == 0)
+        return NULL;
+    int count = 0;
+    for (int i = 0; i < str.len; i++)
+        if (str.start[i] == '\n')
+            count++;
+    if (str.start[str.len - 1] != '\n')
+        count++;
+    struct bstr *r = talloc_array_ptrtype(talloc_ctx, r, count);
+    unsigned char *p = str.start;
+    for (int i = 0; i < count - 1; i++) {
+        r[i].start = p;
+        while (*p++ != '\n');
+        r[i].len = p - r[i].start;
+    }
+    r[count - 1].start = p;
+    r[count - 1].len = str.start + str.len - p;
+    return r;
+}
diff --git a/bstr.h b/bstr.h
index 459bf70bef..33a47c0abc 100644
--- a/bstr.h
+++ b/bstr.h
@@ -22,18 +22,50 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <string.h>
+#include <stdbool.h>
 
+#include "talloc.h"
+
+/* NOTE: 'len' is size_t, but most string-handling functions below assume
+ * that input size has been sanity checked and len fits in an int.
+ */
 struct bstr {
-    const uint8_t *start;
+    unsigned char *start;
     size_t len;
 };
 
 int bstrcmp(struct bstr str1, struct bstr str2);
 int bstrcasecmp(struct bstr str1, struct bstr str2);
+int bstrchr(struct bstr str, int c);
+struct bstr *bstr_splitlines(void *talloc_ctx, struct bstr str);
+struct bstr bstr_strip(struct bstr str);
+struct bstr bstr_split(struct bstr str, char *sep, struct bstr *rest);
+struct bstr bstr_splice(struct bstr str, int start, int end);
+long long bstrtoll(struct bstr str, struct bstr *rest, int base);
+
+static inline struct bstr bstr_cut(struct bstr str, int n)
+{
+    return (struct bstr){str.start + n, str.len - n};
+}
+
+static inline bool bstr_startswith(struct bstr str, struct bstr prefix)
+{
+    if (str.len < prefix.len)
+        return false;
+    return !memcmp(str.start, prefix.start, prefix.len);
+}
+
+static inline char *bstrdup0(void *talloc_ctx, struct bstr str)
+{
+    // cast is live555 C++ compilation workaround
+    return talloc_strndup(talloc_ctx, (char *)str.start, str.len);
+}
 
 // Create bstr compound literal from null-terminated string
-#define BSTR(s) (struct bstr){(s), (s) ? strlen(s) : 0}
+#define BSTR(s) (struct bstr){(char *)(s), (s) ? strlen(s) : 0}
 // create a pair (not single value!) for "%.*s" printf syntax
 #define BSTR_P(bstr) (int)((bstr).len), (bstr).start
 
+#define WHITESPACE " \f\n\r\t\v"
+
 #endif /* MPLAYER_BSTR_H */
diff --git a/libmpdemux/demux_edl.c b/libmpdemux/demux_edl.c
new file mode 100644
index 0000000000..4c864cfe42
--- /dev/null
+++ b/libmpdemux/demux_edl.c
@@ -0,0 +1,58 @@
+/*
+ * 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 <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "demuxer.h"
+#include "stream/stream.h"
+
+static int try_open_file(struct demuxer *demuxer)
+{
+    struct stream *s = demuxer->stream;
+    const char header[] = "mplayer EDL file";
+    const int len = sizeof(header) - 1;
+    char buf[len];
+    if (stream_read(s, buf, len) < len)
+        return 0;
+    if (strncmp(buf, header, len))
+        return 0;
+    stream_seek(s, 0);
+    demuxer->file_contents = stream_read_complete(s, demuxer, 1000000, 0);
+    if (demuxer->file_contents.start == NULL)
+        return 0;
+    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",
+    .shortdesc = "EDL",
+    .author = "Uoti Urpala",
+    .comment = "",
+    .type = DEMUXER_TYPE_EDL,
+    .safe_check = true,
+    .check_file = try_open_file,       // no separate .open
+    .fill_buffer = dummy_fill_buffer,
+};
diff --git a/libmpdemux/demuxer.c b/libmpdemux/demuxer.c
index 9b38af9452..9efcf91862 100644
--- a/libmpdemux/demuxer.c
+++ b/libmpdemux/demuxer.c
@@ -53,6 +53,7 @@
 static void clear_parser(sh_common_t *sh);
 
 // Demuxer list
+extern const struct demuxer_desc demuxer_desc_edl;
 extern const demuxer_desc_t demuxer_desc_rawaudio;
 extern const demuxer_desc_t demuxer_desc_rawvideo;
 extern const demuxer_desc_t demuxer_desc_tv;
@@ -101,6 +102,7 @@ extern const demuxer_desc_t demuxer_desc_mng;
  * libraries and demuxers requiring binary support. */
 
 const demuxer_desc_t *const demuxer_list[] = {
+    &demuxer_desc_edl,
     &demuxer_desc_rawaudio,
     &demuxer_desc_rawvideo,
 #ifdef CONFIG_TV
@@ -253,13 +255,13 @@ void free_demux_packet(struct demux_packet *dp)
     free(dp);
 }
 
-void free_demuxer_stream(demux_stream_t *ds)
+static void free_demuxer_stream(struct demux_stream *ds)
 {
     ds_free_packs(ds);
     free(ds);
 }
 
-demux_stream_t *new_demuxer_stream(struct demuxer *demuxer, int id)
+static struct demux_stream *new_demuxer_stream(struct demuxer *demuxer, int id)
 {
     demux_stream_t *ds = malloc(sizeof(demux_stream_t));
     *ds = (demux_stream_t){
@@ -881,19 +883,18 @@ void demuxer_help(void)
     int i;
 
     mp_msg(MSGT_DEMUXER, MSGL_INFO, "Available demuxers:\n");
-    mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer:  type  info:  (comment)\n");
+    mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer:   info:  (comment)\n");
     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DEMUXERS\n");
     for (i = 0; demuxer_list[i]; i++) {
-        if (demuxer_list[i]->type > DEMUXER_TYPE_MAX)   // Don't display special demuxers
+        if (demuxer_list[i]->type >= DEMUXER_TYPE_END)  // internal type
             continue;
         if (demuxer_list[i]->comment && strlen(demuxer_list[i]->comment))
-            mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s (%s)\n",
-                   demuxer_list[i]->name, demuxer_list[i]->type,
-                   demuxer_list[i]->info, demuxer_list[i]->comment);
+            mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %s (%s)\n",
+                   demuxer_list[i]->name, demuxer_list[i]->info,
+                   demuxer_list[i]->comment);
         else
-            mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s\n",
-                   demuxer_list[i]->name, demuxer_list[i]->type,
-                   demuxer_list[i]->info);
+            mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %s\n",
+                   demuxer_list[i]->name, demuxer_list[i]->info);
     }
 }
 
@@ -906,32 +907,22 @@ void demuxer_help(void)
  *                        May be NULL.
  * @return                DEMUXER_TYPE_xxx, -1 if error or not found
  */
-int get_demuxer_type_from_name(char *demuxer_name, int *force)
+static int get_demuxer_type_from_name(char *demuxer_name, int *force)
 {
-    int i;
-    long type_int;
-    char *endptr;
-
     if (!demuxer_name || !demuxer_name[0])
         return DEMUXER_TYPE_UNKNOWN;
     if (force)
         *force = demuxer_name[0] == '+';
     if (demuxer_name[0] == '+')
         demuxer_name = &demuxer_name[1];
-    for (i = 0; demuxer_list[i]; i++) {
-        if (demuxer_list[i]->type > DEMUXER_TYPE_MAX)   // Can't select special demuxers from commandline
+    for (int i = 0; demuxer_list[i]; i++) {
+        if (demuxer_list[i]->type >= DEMUXER_TYPE_END)
+            // Can't select special demuxers from commandline
             continue;
         if (strcmp(demuxer_name, demuxer_list[i]->name) == 0)
             return demuxer_list[i]->type;
     }
 
-    // No match found, try to parse name as an integer (demuxer number)
-    type_int = strtol(demuxer_name, &endptr, 0);
-    if (*endptr)  // Conversion failed
-        return -1;
-    if ((type_int > 0) && (type_int <= DEMUXER_TYPE_MAX))
-        return (int) type_int;
-
     return -1;
 }
 
diff --git a/libmpdemux/demuxer.h b/libmpdemux/demuxer.h
index e66b8f8a12..4a8a7545d1 100644
--- a/libmpdemux/demuxer.h
+++ b/libmpdemux/demuxer.h
@@ -32,8 +32,8 @@
 struct MPOpts;
 
 #ifdef HAVE_BUILTIN_EXPECT
-#define likely(x) __builtin_expect ((x) != 0, 1)
-#define unlikely(x) __builtin_expect ((x) != 0, 0)
+#define likely(x) __builtin_expect((x) != 0, 1)
+#define unlikely(x) __builtin_expect((x) != 0, 0)
 #else
 #define likely(x) (x)
 #define unlikely(x) (x)
@@ -42,60 +42,61 @@ struct MPOpts;
 #define MAX_PACKS 4096
 #define MAX_PACK_BYTES 0x8000000  // 128 MiB
 
-#define DEMUXER_TYPE_UNKNOWN 0
-#define DEMUXER_TYPE_MPEG_ES 1
-#define DEMUXER_TYPE_MPEG_PS 2
-#define DEMUXER_TYPE_AVI 3
-#define DEMUXER_TYPE_AVI_NI 4
-#define DEMUXER_TYPE_AVI_NINI 5
-#define DEMUXER_TYPE_ASF 6
-#define DEMUXER_TYPE_MOV 7
-#define DEMUXER_TYPE_VIVO 8
-#define DEMUXER_TYPE_TV 9
-#define DEMUXER_TYPE_FLI 10
-#define DEMUXER_TYPE_REAL 11
-#define DEMUXER_TYPE_Y4M 12
-#define DEMUXER_TYPE_FILM 14
-#define DEMUXER_TYPE_ROQ 15
-#define DEMUXER_TYPE_MF 16
-#define DEMUXER_TYPE_AUDIO 17
-#define DEMUXER_TYPE_OGG 18
-#define DEMUXER_TYPE_RAWAUDIO 20
-#define DEMUXER_TYPE_RTP 21
-#define DEMUXER_TYPE_RAWDV 22
-#define DEMUXER_TYPE_PVA 23
-#define DEMUXER_TYPE_SMJPEG 24
-#define DEMUXER_TYPE_XMMS 25
-#define DEMUXER_TYPE_RAWVIDEO 26
-#define DEMUXER_TYPE_MPEG4_ES 27
-#define DEMUXER_TYPE_GIF 28
-#define DEMUXER_TYPE_MPEG_TS 29
-#define DEMUXER_TYPE_H264_ES 30
-#define DEMUXER_TYPE_MATROSKA 31
-#define DEMUXER_TYPE_REALAUDIO 32
-#define DEMUXER_TYPE_MPEG_TY 33
-#define DEMUXER_TYPE_LMLM4 34
-#define DEMUXER_TYPE_LAVF 35
-#define DEMUXER_TYPE_NSV 36
-#define DEMUXER_TYPE_VQF 37
-#define DEMUXER_TYPE_AVS 38
-#define DEMUXER_TYPE_AAC 39
-#define DEMUXER_TYPE_MPC 40
-#define DEMUXER_TYPE_MPEG_PES 41
-#define DEMUXER_TYPE_MPEG_GXF 42
-#define DEMUXER_TYPE_NUT 43
-#define DEMUXER_TYPE_LAVF_PREFERRED 44
-#define DEMUXER_TYPE_RTP_NEMESI 45
-#define DEMUXER_TYPE_MNG 46
-
-// This should always match the higest demuxer type number.
-// Unless you want to disallow users to force the demuxer to some types
-#define DEMUXER_TYPE_MIN 0
-#define DEMUXER_TYPE_MAX 46
-
-#define DEMUXER_TYPE_DEMUXERS (1<<16)
-// A virtual demuxer type for the network code
-#define DEMUXER_TYPE_PLAYLIST (2<<16)
+enum demuxer_type {
+    DEMUXER_TYPE_UNKNOWN = 0,
+    DEMUXER_TYPE_MPEG_ES,
+    DEMUXER_TYPE_MPEG_PS,
+    DEMUXER_TYPE_AVI,
+    DEMUXER_TYPE_AVI_NI,
+    DEMUXER_TYPE_AVI_NINI,
+    DEMUXER_TYPE_ASF,
+    DEMUXER_TYPE_MOV,
+    DEMUXER_TYPE_VIVO,
+    DEMUXER_TYPE_TV,
+    DEMUXER_TYPE_FLI,
+    DEMUXER_TYPE_REAL,
+    DEMUXER_TYPE_Y4M,
+    DEMUXER_TYPE_FILM,
+    DEMUXER_TYPE_ROQ,
+    DEMUXER_TYPE_MF,
+    DEMUXER_TYPE_AUDIO,
+    DEMUXER_TYPE_OGG,
+    DEMUXER_TYPE_RAWAUDIO,
+    DEMUXER_TYPE_RTP,
+    DEMUXER_TYPE_RAWDV,
+    DEMUXER_TYPE_PVA,
+    DEMUXER_TYPE_SMJPEG,
+    DEMUXER_TYPE_XMMS,
+    DEMUXER_TYPE_RAWVIDEO,
+    DEMUXER_TYPE_MPEG4_ES,
+    DEMUXER_TYPE_GIF,
+    DEMUXER_TYPE_MPEG_TS,
+    DEMUXER_TYPE_H264_ES,
+    DEMUXER_TYPE_MATROSKA,
+    DEMUXER_TYPE_REALAUDIO,
+    DEMUXER_TYPE_MPEG_TY,
+    DEMUXER_TYPE_LMLM4,
+    DEMUXER_TYPE_LAVF,
+    DEMUXER_TYPE_NSV,
+    DEMUXER_TYPE_VQF,
+    DEMUXER_TYPE_AVS,
+    DEMUXER_TYPE_AAC,
+    DEMUXER_TYPE_MPC,
+    DEMUXER_TYPE_MPEG_PES,
+    DEMUXER_TYPE_MPEG_GXF,
+    DEMUXER_TYPE_NUT,
+    DEMUXER_TYPE_LAVF_PREFERRED,
+    DEMUXER_TYPE_RTP_NEMESI,
+    DEMUXER_TYPE_MNG,
+    DEMUXER_TYPE_EDL,
+
+    /* Values after this are for internal use and can not be selected
+     * as demuxer type by the user (-demuxer option). */
+    DEMUXER_TYPE_END,
+
+    DEMUXER_TYPE_DEMUXERS,
+    DEMUXER_TYPE_PLAYLIST,
+};
 
 enum timestamp_type {
     TIMESTAMP_TYPE_PTS,
@@ -125,54 +126,54 @@ enum timestamp_type {
 
 // Holds one packet/frame/whatever
 typedef struct demux_packet {
-  int len;
-  double pts;
-  double duration;
-  double stream_pts;
-  off_t pos;  // position in index (AVI) or file (MPG)
-  unsigned char* buffer;
-  int flags; // keyframe, etc
-  int refcount;   //refcounter for the master packet, if 0, buffer can be free()d
-  struct demux_packet *master; //pointer to the master packet if this one is a cloned one
-  struct demux_packet *next;
+    int len;
+    double pts;
+    double duration;
+    double stream_pts;
+    off_t pos; // position in index (AVI) or file (MPG)
+    unsigned char *buffer;
+    int flags; // keyframe, etc
+    int refcount; // counter for the master packet, if 0, buffer can be free()d
+    struct demux_packet *master; //in clones, pointer to the master packet
+    struct demux_packet *next;
 } demux_packet_t;
 
 typedef struct demux_stream {
-  int buffer_pos;          // current buffer position
-  int buffer_size;         // current buffer size
-  unsigned char* buffer;   // current buffer, never free() it, always use free_demux_packet(buffer_ref);
-  double pts;              // current buffer's pts
-  int pts_bytes;           // number of bytes read after last pts stamp
-  int eof;                 // end of demuxed stream? (true if all buffer empty)
-  off_t pos;                 // position in the input stream (file)
-  off_t dpos;                // position in the demuxed stream
-  int pack_no;		   // serial number of packet
-  int flags;               // flags of current packet (keyframe etc)
-  int non_interleaved;     // 1 if this stream is not properly interleaved,
+    int buffer_pos;        // current buffer position
+    int buffer_size;       // current buffer size
+    unsigned char *buffer; // current buffer, never free() it, always use free_demux_packet(buffer_ref);
+    double pts;            // current buffer's pts
+    int pts_bytes;         // number of bytes read after last pts stamp
+    int eof;               // end of demuxed stream? (true if all buffer empty)
+    off_t pos;               // position in the input stream (file)
+    off_t dpos;              // position in the demuxed stream
+    int pack_no;           // serial number of packet
+    int flags;             // flags of current packet (keyframe etc)
+    int non_interleaved;   // 1 if this stream is not properly interleaved,
                            // so e.g. subtitle handling must do explicit reads.
 //---------------
-  int packs;              // number of packets in buffer
-  int bytes;              // total bytes of packets in buffer
-  demux_packet_t *first;  // read to current buffer from here
-  demux_packet_t *last;   // append new packets from input stream to here
-  demux_packet_t *current;// needed for refcounting of the buffer
-  int id;                 // stream ID  (for multiple audio/video streams)
-  struct demuxer *demuxer; // parent demuxer structure (stream handler)
+    int packs;            // number of packets in buffer
+    int bytes;            // total bytes of packets in buffer
+    demux_packet_t *first; // read to current buffer from here
+    demux_packet_t *last; // append new packets from input stream to here
+    demux_packet_t *current; // needed for refcounting of the buffer
+    int id;               // stream ID  (for multiple audio/video streams)
+    struct demuxer *demuxer; // parent demuxer structure (stream handler)
 // ---- asf -----
-  demux_packet_t *asf_packet;  // read asf fragments here
-  int asf_seq;
+    struct demux_packet *asf_packet; // read asf fragments here
+    int asf_seq;
 // ---- mov -----
-  unsigned int ss_mul,ss_div;
+    unsigned int ss_mul, ss_div;
 // ---- stream header ----
-  void* sh;
+    void *sh;
 } demux_stream_t;
 
 typedef struct demuxer_info {
-  char *name;
-  char *author;
-  char *encoder;
-  char *comments;
-  char *copyright;
+    char *name;
+    char *author;
+    char *encoder;
+    char *comments;
+    char *copyright;
 } demuxer_info_t;
 
 #define MAX_A_STREAMS 256
@@ -185,33 +186,36 @@ struct demuxer;
  * Demuxer description structure
  */
 typedef struct demuxer_desc {
-  const char *info; ///< What is it (long name and/or description)
-  const char *name; ///< Demuxer name, used with -demuxer switch
-  const char *shortdesc; ///< Description printed at demuxer detection
-  const char *author; ///< Demuxer author(s)
-  const char *comment; ///< Comment, printed with -demuxer help
-
-  int type; ///< DEMUXER_TYPE_xxx
-  int safe_check; ///< If 1 detection is safe and fast, do it before file extension check
-
-  /// Check if can demux the file, return DEMUXER_TYPE_xxx on success
-  int (*check_file)(struct demuxer *demuxer); ///< Mandatory if safe_check == 1, else optional
-  /// Get packets from file, return 0 on eof
-  int (*fill_buffer)(struct demuxer *demuxer, demux_stream_t *ds); ///< Mandatory
-  /// Open the demuxer, return demuxer on success, NULL on failure
-  struct demuxer* (*open)(struct demuxer *demuxer); ///< Optional
-  /// Close the demuxer
-  void (*close)(struct demuxer *demuxer); ///< Optional
-  // Seek
-  void (*seek)(struct demuxer *demuxer, float rel_seek_secs, float audio_delay, int flags); ///< Optional
-  // Control
-  int (*control)(struct demuxer *demuxer, int cmd, void *arg); ///< Optional
+    const char *info;      // What is it (long name and/or description)
+    const char *name;      // Demuxer name, used with -demuxer switch
+    const char *shortdesc; // Description printed at demuxer detection
+    const char *author;    // Demuxer author(s)
+    const char *comment;   // Comment, printed with -demuxer help
+
+    enum demuxer_type type;
+    // If 1 detection is safe and fast, do it before file extension check
+    int safe_check;
+
+    // Check if can demux the file, return DEMUXER_TYPE_xxx on success
+    // Mandatory if safe_check == 1, else optional
+    int (*check_file)(struct demuxer *demuxer);
+    /// Get packets from file, return 0 on eof. Mandatory
+    int (*fill_buffer)(struct demuxer *demuxer, struct demux_stream *ds);
+    /// Open the demuxer, return demuxer on success, NULL on failure
+    struct demuxer *(*open)(struct demuxer *demuxer); // Optional
+    /// Close the demuxer
+    void (*close)(struct demuxer *demuxer); // Optional
+    // Seek. Optional
+    void (*seek)(struct demuxer *demuxer, float rel_seek_secs,
+                 float audio_delay, int flags);
+    // Various control functions. Optional
+    int (*control)(struct demuxer *demuxer, int cmd, void *arg);
 } demuxer_desc_t;
 
 typedef struct demux_chapter
 {
-  uint64_t start, end;
-  char* name;
+    uint64_t start, end;
+    char *name;
 } demux_chapter_t;
 
 struct matroska_data {
@@ -229,59 +233,67 @@ struct matroska_data {
 
 typedef struct demux_attachment
 {
-  char* name;
-  char* type;
-  void* data;
-  unsigned int data_size;
+    char *name;
+    char *type;
+    void *data;
+    unsigned int data_size;
 } demux_attachment_t;
 
 typedef struct demuxer {
-  const demuxer_desc_t *desc;  ///< Demuxer description structure
-  char *filetype; // format name when not identified by demuxer (libavformat)
-  off_t filepos; // input stream current pos.
-  off_t movi_start;
-  off_t movi_end;
-  stream_t *stream;
-  double stream_pts;       // current stream pts, if applicable (e.g. dvd)
-  double reference_clock;
-  char *filename; ///< Needed by avs_check_file
-  int synced;  // stream synced (used by mpeg)
-  int type;    // demuxer type: mpeg PS, mpeg ES, avi, avi-ni, avi-nini, asf
-  int file_format;  // file format: mpeg/avi/asf
-  int seekable;  // flag
+    const demuxer_desc_t *desc; ///< Demuxer description structure
+    char *filetype; // format name when not identified by demuxer (libavformat)
+    off_t filepos;  // input stream current pos.
+    off_t movi_start;
+    off_t movi_end;
+    struct stream *stream;
+    double stream_pts;     // current stream pts, if applicable (e.g. dvd)
+    double reference_clock;
+    char *filename;  // Needed by avs_check_file
+    int synced;      // stream synced (used by mpeg)
+    enum demuxer_type type;
+    /* Normally the file_format field is just a copy of the type field above.
+     * There are 2 exceptions I noticed. Internal demux_avi may force
+     * ->type to DEMUXER_TYPE_AVI_[NI|NINI] while leaving ->file_format at
+     * DEMUXER_TYPE_AVI. Internal demux_mov may set ->type to
+     * DEMUXER_TYPE_PLAYLIST and also return that from the check function
+     * or not (looks potentially buggy). */
+    enum demuxer_type file_format;
+    int seekable; // flag
     /* Set if using absolute seeks for small movements is OK (no pts resets
      * that would make pts ambigious, preferably supports back/forward flags */
     bool accurate_seek;
     enum timestamp_type timestamp_type;
-  //
-  demux_stream_t *audio; // audio buffer/demuxer
-  demux_stream_t *video; // video buffer/demuxer
-  demux_stream_t *sub;   // dvd subtitle buffer/demuxer
 
-  // stream headers:
-  struct sh_audio *a_streams[MAX_A_STREAMS];
-  struct sh_video *v_streams[MAX_V_STREAMS];
-  struct sh_sub   *s_streams[MAX_S_STREAMS];
+    struct demux_stream *audio; // audio buffer/demuxer
+    struct demux_stream *video; // video buffer/demuxer
+    struct demux_stream *sub;   // dvd subtitle buffer/demuxer
+
+    // stream headers:
+    struct sh_audio *a_streams[MAX_A_STREAMS];
+    struct sh_video *v_streams[MAX_V_STREAMS];
+    struct sh_sub   *s_streams[MAX_S_STREAMS];
 
-  // pointer to teletext decoder private data, if demuxer stream contains teletext
-  void *teletext;
+    // teletext decoder private data, if demuxer stream contains teletext
+    void *teletext;
 
-  demux_chapter_t* chapters;
-  int num_chapters;
+    struct demux_chapter *chapters;
+    int num_chapters;
 
-  demux_attachment_t* attachments;
-  int num_attachments;
+    struct demux_attachment *attachments;
+    int num_attachments;
 
     struct matroska_data matroska_data;
+    // for trivial demuxers which just read the whole file for codec to use
+    struct bstr file_contents;
 
-  void* priv;  // fileformat-dependent data
-  char** info;
-  struct MPOpts *opts;
+    void *priv;   // demuxer-specific internal data
+    char **info;  // metadata
+    struct MPOpts *opts;
 } demuxer_t;
 
 typedef struct {
-  int progid;        //program id
-  int aid, vid, sid; //audio, video and subtitle id
+    int progid;      //program id
+    int aid, vid, sid; //audio, video and subtitle id
 } demux_program_t;
 
 struct demux_packet *new_demux_packet(size_t len);
@@ -293,80 +305,76 @@ void free_demux_packet(struct demux_packet *dp);
 #define SIZE_MAX ((size_t)-1)
 #endif
 
-static inline void *realloc_struct(void *ptr, size_t nmemb, size_t size) {
-  if (nmemb > SIZE_MAX / size) {
-    free(ptr);
-    return NULL;
-  }
-  return realloc(ptr, nmemb * size);
+static inline void *realloc_struct(void *ptr, size_t nmemb, size_t size)
+{
+    if (nmemb > SIZE_MAX / size) {
+        free(ptr);
+        return NULL;
+    }
+    return realloc(ptr, nmemb * size);
 }
 
-demux_stream_t* new_demuxer_stream(struct demuxer *demuxer,int id);
-demuxer_t* new_demuxer(struct MPOpts *opts, stream_t *stream,int type,int a_id,int v_id,int s_id,char *filename);
-void free_demuxer_stream(demux_stream_t *ds);
-void free_demuxer(demuxer_t *demuxer);
+struct demuxer *new_demuxer(struct MPOpts *opts, struct stream *stream,
+                            int type, int a_id, int v_id, int s_id,
+                            char *filename);
+void free_demuxer(struct demuxer *demuxer);
 
-void ds_add_packet(demux_stream_t *ds,demux_packet_t* dp);
-void ds_read_packet(demux_stream_t *ds, stream_t *stream, int len, double pts, off_t pos, int flags);
+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, off_t pos, int flags);
 
-int demux_fill_buffer(demuxer_t *demux,demux_stream_t *ds);
-int ds_fill_buffer(demux_stream_t *ds);
+int demux_fill_buffer(struct demuxer *demux, struct demux_stream *ds);
+int ds_fill_buffer(struct demux_stream *ds);
 
-static inline off_t ds_tell(demux_stream_t *ds){
-  return (ds->dpos-ds->buffer_size)+ds->buffer_pos;
+static inline off_t ds_tell(struct demux_stream *ds)
+{
+    return (ds->dpos - ds->buffer_size) + ds->buffer_pos;
 }
 
-static inline int ds_tell_pts(demux_stream_t *ds){
-  return (ds->pts_bytes-ds->buffer_size)+ds->buffer_pos;
+static inline int ds_tell_pts(struct demux_stream *ds)
+{
+    return (ds->pts_bytes - ds->buffer_size) + ds->buffer_pos;
 }
 
-int demux_read_data(demux_stream_t *ds,unsigned char* mem,int len);
-int demux_pattern_3(demux_stream_t *ds, unsigned char *mem, int maxlen,
+int demux_read_data(struct demux_stream *ds, unsigned char *mem, int len);
+int demux_pattern_3(struct demux_stream *ds, unsigned char *mem, int maxlen,
                     int *read, uint32_t pattern);
 
-#define demux_peekc(ds) (\
-     (likely(ds->buffer_pos<ds->buffer_size)) ? ds->buffer[ds->buffer_pos] \
-     :((unlikely(!ds_fill_buffer(ds)))? (-1) : ds->buffer