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

3 files changed, 314 insertions, 259 deletions

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[ds->buffer_pos] ) )
-#if 1
-#define demux_getc(ds) (\
-     (likely(ds->buffer_pos<ds->buffer_size)) ? ds->buffer[ds->buffer_pos++] \
-     :((unlikely(!ds_fill_buffer(ds)))? (-1) : ds->buffer[ds->buffer_pos++] ) )
-#else
-static inline int demux_getc(demux_stream_t *ds){
-  if(ds->buffer_pos>=ds->buffer_size){
-    if(!ds_fill_buffer(ds)){
-//      printf("DEMUX_GETC: EOF reached!\n");
-      return -1; // EOF
-    }
-  }
-//  printf("[%02X]",ds->buffer[ds->buffer_pos]);
-  return ds->buffer[ds->buffer_pos++];
-}
-#endif
-
-void ds_free_packs(demux_stream_t *ds);
-int ds_get_packet(demux_stream_t *ds,unsigned char **start);
-int ds_get_packet_pts(demux_stream_t *ds, unsigned char **start, double *pts);
-int ds_get_packet_sub(demux_stream_t *ds,unsigned char **start);
-double ds_get_next_pts(demux_stream_t *ds);
-int ds_parse(demux_stream_t *sh, uint8_t **buffer, int *len, double pts, off_t pos);
-void ds_clear_parser(demux_stream_t *sh);
-
-// This is defined here because demux_stream_t ins't defined in stream.h
-stream_t* new_ds_stream(demux_stream_t *ds);
-
-static inline int avi_stream_id(unsigned int id){
-  unsigned char a,b;
-  a = id - '0';
-  b = (id >> 8) - '0';
-  if(a>9 || b>9) return 100; // invalid ID
-  return a*10+b;
+#define demux_peekc(ds) ( \
+        (likely(ds->buffer_pos<ds->buffer_size)) ? ds->buffer[ds->buffer_pos] \
+        : ((unlikely(!ds_fill_buffer(ds))) ? (-1) : ds->buffer[ds->buffer_pos]))
+#define demux_getc(ds) ( \
+        (likely(ds->buffer_pos<ds->buffer_size)) ? ds->buffer[ds->buffer_pos++] \
+        : ((unlikely(!ds_fill_buffer(ds))) ? (-1) : ds->buffer[ds->buffer_pos++]))
+
+void ds_free_packs(struct demux_stream *ds);
+int ds_get_packet(struct demux_stream *ds, unsigned char **start);
+int ds_get_packet_pts(struct demux_stream *ds, unsigned char **start,
+                      double *pts);
+int ds_get_packet_sub(struct demux_stream *ds, unsigned char **start);
+double ds_get_next_pts(struct demux_stream *ds);
+int ds_parse(struct demux_stream *sh, uint8_t **buffer, int *len, double pts,
+             off_t pos);
+void ds_clear_parser(struct demux_stream *sh);
+
+static inline int avi_stream_id(unsigned int id)
+{
+    unsigned char a, b;
+    a = id - '0';
+    b = (id >> 8) - '0';
+    if (a>9 || b>9)
+        return 100;          // invalid ID
+    return a * 10 + b;
 }
 
-demuxer_t* demux_open(struct MPOpts *opts, stream_t *stream,int file_format,int aid,int vid,int sid,char* filename);
-void demux_flush(demuxer_t *demuxer);
-int demux_seek(demuxer_t *demuxer,float rel_seek_secs,float audio_delay,int flags);
-demuxer_t*  new_demuxers_demuxer(demuxer_t* vd, demuxer_t* ad, demuxer_t* sd);
+struct demuxer *demux_open(struct MPOpts *opts, struct stream *stream,
+                           int file_format, int aid, int vid, int sid,
+                           char *filename);
+void demux_flush(struct demuxer *demuxer);
+int demux_seek(struct demuxer *demuxer, float rel_seek_secs, float audio_delay,
+               int flags);
+struct demuxer *new_demuxers_demuxer(struct demuxer *vd, struct demuxer *ad,
+                                     struct demuxer *sd);
 
 // AVI demuxer params:
 extern int index_mode;  // -1=untouched  0=don't use index  1=use (geneate) index
@@ -374,45 +382,43 @@ extern char *index_file_save, *index_file_load;
 extern int force_ni;
 extern int pts_from_bps;
 
-extern int extension_parsing;
-
-int demux_info_add(demuxer_t *demuxer, const char *opt, const char *param);
-int demux_info_add_bstr(demuxer_t *demuxer, struct bstr opt, struct bstr param);
-char* demux_info_get(demuxer_t *demuxer, const char *opt);
-int demux_info_print(demuxer_t *demuxer);
-int demux_control(demuxer_t *demuxer, int cmd, void *arg);
+int demux_info_add(struct demuxer *demuxer, const char *opt, const char *param);
+int demux_info_add_bstr(struct demuxer *demuxer, struct bstr opt,
+                        struct bstr param);
+char *demux_info_get(struct demuxer *demuxer, const char *opt);
+int demux_info_print(struct demuxer *demuxer);
+int demux_control(struct demuxer *demuxer, int cmd, void *arg);
 
-int demuxer_switch_audio(demuxer_t *demuxer, int index);
-int demuxer_switch_video(demuxer_t *demuxer, int index);
+int demuxer_switch_audio(struct demuxer *demuxer, int index);
+int demuxer_switch_video(struct demuxer *demuxer, int index);
 
-int demuxer_type_by_filename(char* filename);
+int demuxer_type_by_filename(char *filename);
 
 void demuxer_help(void);
-int get_demuxer_type_from_name(char *demuxer_name, int *force);
 
-int demuxer_add_attachment(demuxer_t *demuxer, struct bstr name,
+int demuxer_add_attachment(struct demuxer *demuxer, struct bstr name,
                            struct bstr type, struct bstr data);
-int demuxer_add_chapter(demuxer_t *demuxer, struct bstr name,
+int demuxer_add_chapter(struct demuxer *demuxer, struct bstr name,
                         uint64_t start, uint64_t end);
-int demuxer_seek_chapter(demuxer_t *demuxer, int chapter, double *seek_pts,
+int demuxer_seek_chapter(struct demuxer *demuxer, int chapter, double *seek_pts,
                          char **chapter_name);
 
 /// Get current chapter index if available.
-int demuxer_get_current_chapter(demuxer_t *demuxer, double time_now);
+int demuxer_get_current_chapter(struct demuxer *demuxer, double time_now);
 /// Get chapter name by index if available.
-char *demuxer_chapter_name(demuxer_t *demuxer, int chapter);
+char *demuxer_chapter_name(struct demuxer *demuxer, int chapter);
 /// Get chapter display name by index.
-char *demuxer_chapter_display_name(demuxer_t *demuxer, int chapter);
+char *demuxer_chapter_display_name(struct demuxer *demuxer, int chapter);
 /// Get chapter start time and end time by index if available.
-float demuxer_chapter_time(demuxer_t *demuxer, int chapter, float *end);
+float demuxer_chapter_time(struct demuxer *demuxer, int chapter, float *end);
 /// Get total chapter number.
-int demuxer_chapter_count(demuxer_t *demuxer);
+int demuxer_chapter_count(struct demuxer *demuxer);
 /// Get current angle index.
-int demuxer_get_current_angle(demuxer_t *demuxer);
+int demuxer_get_current_angle(struct demuxer *demuxer);
 /// Set angle.
-int demuxer_set_angle(demuxer_t *demuxer, int angle);
+int demuxer_set_angle(struct demuxer *demuxer, int angle);
 /// Get number of angles.
-int demuxer_angles_count(demuxer_t *demuxer);
+int demuxer_angles_count(struct demuxer *demuxer);
 
 /* Get the index of a track.
  * lang is a comma-separated list, NULL is same as empty list