Merge branch 'matroska'

10 files changed, 2286 insertions, 1273 deletions

diff --git a/Makefile b/Makefile
index f8d3982ac7..225caae09f 100644
--- a/Makefile
+++ b/Makefile
@@ -894,7 +894,9 @@ TAGS:
 tags:
 	rm -f $@; find . -name '*.[chS]' -o -name '*.asm' | xargs ctags -a
 
-
+generated_ebml:
+	TOOLS/matroska.py --generate-header >libmpdemux/ebml_types.h
+	TOOLS/matroska.py --generate-definitions >libmpdemux/ebml_defs.c
 
 ###### tests / tools #######
 
diff --git a/TOOLS/matroska.py b/TOOLS/matroska.py
new file mode 100755
index 0000000000..8368f35185
--- /dev/null
+++ b/TOOLS/matroska.py
@@ -0,0 +1,397 @@
+#!/usr/bin/python
+"""
+Generate C definitions for parsing Matroska files.
+Can also be used to directly parse Matroska files and display their contents.
+"""
+
+#
+# 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.
+#
+
+
+elements_ebml = (
+    'EBML, 1a45dfa3, sub', (
+        'EBMLVersion, 4286, uint',
+        'EBMLReadVersion, 42f7, uint',
+        'EBMLMaxIDLength, 42f2, uint',
+        'EBMLMaxSizeLength, 42f3, uint',
+        'DocType, 4282, str',
+        'DocTypeVersion, 4287, uint',
+        'DocTypeReadVersion, 4285, uint',
+    ),
+
+    'CRC32, bf, binary',
+    'Void, ec, binary',
+)
+
+elements_matroska = (
+    'Segment, 18538067, sub', (
+
+        'SeekHead*, 114d9b74, sub', (
+            'Seek*, 4dbb, sub', (
+                'SeekID, 53ab, ebml_id',
+                'SeekPosition, 53ac, uint',
+            ),
+        ),
+
+        'Info*, 1549a966, sub', (
+            'SegmentUID, 73a4, binary',
+            'PrevUID, 3cb923, binary',
+            'NextUID, 3eb923, binary',
+            'TimecodeScale, 2ad7b1, uint',
+            'DateUTC, 4461, sint',
+            'Title, 7ba9, str',
+            'MuxingApp, 4d80, str',
+            'WritingApp, 5741, str',
+            'Duration, 4489, float',
+        ),
+
+        'Cluster*, 1f43b675, sub', (
+            'Timecode, e7, uint',
+            'BlockGroup*, a0, sub', (
+                'Block, a1, binary',
+                'BlockDuration, 9b, uint',
+                'ReferenceBlock*, fb, sint',
+            ),
+            'SimpleBlock*, a3, binary',
+        ),
+
+        'Tracks*, 1654ae6b, sub', (
+            'TrackEntry*, ae, sub', (
+                'TrackNumber, d7, uint',
+                'TrackUID, 73c5, uint',
+                'TrackType, 83, uint',
+                'FlagEnabled, b9, uint',
+                'FlagDefault, 88, uint',
+                'FlagForced, 55aa, uint',
+                'FlagLacing, 9c, uint',
+                'MinCache, 6de7, uint',
+                'DefaultDuration, 23e383, uint',
+                'TrackTimecodeScale, 23314f, float',
+                'MaxBlockAdditionID, 55ee, uint',
+                'Name, 536e, str',
+                'Language, 22b59c, str',
+                'CodecID, 86, str',
+                'CodecPrivate, 63a2, binary',
+                'CodecDecodeAll, aa, uint',
+                'Video, e0, sub', (
+                    'FlagInterlaced, 9a, uint',
+                    'PixelWidth, b0, uint',
+                    'PixelHeight, ba, uint',
+                    'DisplayWidth, 54b0, uint',
+                    'DisplayHeight, 54ba, uint',
+                    'FrameRate, 2383e3, float',
+                ),
+                'Audio, e1, sub', (
+                    'SamplingFrequency, b5, float',
+                    'Channels, 9f, uint',
+                    'BitDepth, 6264, uint',
+                ),
+                'ContentEncodings, 6d80, sub', (
+                    'ContentEncoding*, 6240, sub', (
+                        'ContentEncodingOrder, 5031, uint',
+                        'ContentEncodingScope, 5032, uint',
+                        'ContentEncodingType, 5033, uint',
+                        'ContentCompression, 5034, sub', (
+                            'ContentCompAlgo, 4254, uint',
+                            'ContentCompSettings, 4255, binary',
+                        ),
+                    ),
+                ),
+            ),
+        ),
+
+        'Cues, 1c53bb6b, sub', (
+            'CuePoint*, bb, sub', (
+                'CueTime, b3, uint',
+                'CueTrackPositions*, b7, sub', (
+                    'CueTrack, f7, uint',
+                    'CueClusterPosition, f1, uint',
+                ),
+            ),
+        ),
+
+        'Attachments, 1941a469, sub', (
+            'AttachedFile*, 61a7, sub', (
+                'FileName, 466e, str',
+                'FileMimeType, 4660, str',
+                'FileData, 465c, binary',
+                'FileUID, 46ae, uint',
+            ),
+        ),
+
+        'Chapters, 1043a770, sub', (
+            'EditionEntry*, 45b9, sub', (
+                'EditionUID, 45bc, uint',
+                'EditionFlagHidden, 45bd, uint',
+                'EditionFlagDefault, 45db, uint',
+                'EditionFlagOrdered, 45dd, uint',
+                'ChapterAtom*, b6, sub', (
+                    'ChapterUID, 73c4, uint',
+                    'ChapterTimeStart, 91, uint',
+                    'ChapterTimeEnd, 92, uint',
+                    'ChapterFlagHidden, 98, uint',
+                    'ChapterFlagEnabled, 4598, uint',
+                    'ChapterSegmentUID, 6e67, binary',
+                    'ChapterSegmentEditionUID, 6ebc, uint',
+                    'ChapterDisplay*, 80, sub', (
+                        'ChapString, 85, str',
+                        'ChapLanguage*, 437c, str',
+                    ),
+                ),
+            ),
+        ),
+        'Tags*, 1254c367, sub', (
+            'Tag*, 7373, sub', (
+                'Targets, 63c0, sub', (
+                    'TargetTypeValue, 68ca, uint',
+                 ),
+            ),
+        ),
+    ),
+)
+
+
+import sys
+from math import ldexp
+
+def byte2num(s):
+    return int(s.encode('hex'), 16)
+
+def camelcase_to_words(name):
+    parts = []
+    start = 0
+    for i in range(1, len(name)):
+        if name[i].isupper() and (name[i-1].islower() or
+                                  name[i+1:i+2].islower()):
+            parts.append(name[start:i])
+            start = i
+    parts.append(name[start:])
+    return '_'.join(parts).lower()
+
+class MatroskaElement(object):
+
+    def __init__(self, name, elid, valtype, namespace):
+        self.name = name
+        self.definename = '%s_ID_%s' % (namespace, name.upper())
+        self.fieldname = camelcase_to_words(name)
+        self.structname = 'ebml_' + self.fieldname
+        self.elid = elid
+        self.valtype = valtype
+        if valtype == 'sub':
+            self.ebmltype = 'EBML_TYPE_SUBELEMENTS'
+            self.valname = 'struct %s' % self.structname
+        else:
+            self.ebmltype = 'EBML_TYPE_' + valtype.upper()
+            try:
+                self.valname = {'uint': 'uint64_t', 'str': 'struct bstr',
+                                'binary': 'struct bstr', 'ebml_id': 'uint32_t',
+                                'float': 'double', 'sint': 'int64_t',
+                                }[valtype]
+            except KeyError:
+                raise SyntaxError('Unrecognized value type ' + valtype)
+        self.subelements = ()
+
+    def add_subelements(self, subelements):
+        self.subelements = subelements
+        self.subids = set(x[0].elid for x in subelements)
+
+elementd = {}
+elementlist = []
+def parse_elems(l, namespace):
+    subelements = []
+    for el in l:
+        if isinstance(el, str):
+            name, hexid, eltype = [x.strip() for x in el.split(',')]
+            multiple = name.endswith('*')
+            name = name.strip('*')
+            new = MatroskaElement(name, hexid, eltype, namespace)
+            elementd[hexid] = new
+            elementlist.append(new)
+            subelements.append((new, multiple))
+        else:
+            new.add_subelements(parse_elems(el, namespace))
+    return subelements
+
+parse_elems(elements_ebml, 'EBML')
+parse_elems(elements_matroska, 'MATROSKA')
+
+def generate_C_header():
+    print('// Generated by TOOLS/matroska.py, do not edit manually')
+    print
+
+    for el in elementlist:
+        print('#define %-40s 0x%s' % (el.definename, el.elid))
+
+    print
+
+    for el in reversed(elementlist):
+        if not el.subelements:
+            continue
+        print
+        print('struct %s {' % el.structname)
+        l = max(len(subel.valname) for subel, multiple in el.subelements)+1
+        for subel, multiple in el.subelements:
+            print('    %-*s %s%s;' % (l, subel.valname, (' ', '*')[multiple],
+                                    subel.fieldname))
+        print
+        for subel, multiple in el.subelements:
+            print('    int  n_%s;' % (subel.fieldname))
+        print('};')
+
+    for el in elementlist:
+        if not el.subelements:
+            continue
+        print('extern const struct ebml_elem_desc %s_desc;' % el.structname)
+
+    print
+    print('#define MAX_EBML_SUBELEMENTS %d' % max(len(el.subelements)
+                                                  for el in elementlist))
+
+
+
+def generate_C_definitions():
+    print('// Generated by TOOLS/matroska.py, do not edit manually')
+    print
+    for el in reversed(elementlist):
+        print
+        if el.subelements:
+            print('#define N %s' % el.fieldname)
+            print('E_S("%s", %d)' % (el.name, len(el.subelements)))
+            for subel, multiple in el.subelements:
+                print('F(%s, %s, %d)' % (subel.definename, subel.fieldname,
+                                         multiple))
+            print('}};')
+            print('#undef N')
+        else:
+            print('E("%s", %s, %s)' % (el.name, el.fieldname, el.ebmltype))
+
+def read(s, length):
+    t = s.read(length)
+    if len(t) != length:
+        raise IOError
+    return t
+
+def read_id(s):
+    t = read(s, 1)
+    i = 0
+    mask = 128
+    if ord(t) == 0:
+        raise SyntaxError
+    while not ord(t) & mask:
+        i += 1
+        mask >>= 1
+    t += read(s, i)
+    return t
+
+def read_vint(s):
+    t = read(s, 1)
+    i = 0
+    mask = 128
+    if ord(t) == 0:
+        raise SyntaxError
+    while not ord(t) & mask:
+        i += 1
+        mask >>= 1
+    t = chr(ord(t) & (mask - 1))
+    t += read(s, i)
+    return i+1, byte2num(t)
+
+def read_str(s, length):
+    return read(s, length)
+
+def read_uint(s, length):
+    t = read(s, length)
+    return byte2num(t)
+
+def read_sint(s, length):
+    i = read_uint(s, length)
+    mask = 1 << (length * 8 - 1)
+    if i & mask:
+        i -= 2 * mask
+    return i
+
+def read_float(s, length):
+    t = read(s, length)
+    i = byte2num(t)
+    if length == 4:
+        f = ldexp((i & 0x7fffff) + (1 << 23), (i >> 23 & 0xff) - 150)
+        if i & (1 << 31):
+            f = -f
+        return f
+    raise SyntaxError
+
+def parse_one(s, depth, parent, maxlen):
+    elid = read_id(s).encode('hex')
+    elem = elementd.get(elid)
+    if parent is not None and elid not in parent.subids and elid not in ('ec', 'bf'):
+        print('Unexpected:', elid)
+        if 1:
+            raise NotImplementedError
+    size, length = read_vint(s)
+    this_length = len(elid) / 2 + size + length
+    if elem is not None:
+        if elem.valtype != 'skip':
+            print depth, elid, elem.name, 'size:', length, 'value:',
+        if elem.valtype == 'sub':
+            print('subelements:')
+            while length > 0:
+                length -= parse_one(s, depth + 1, elem, length)
+            if length < 0:
+                raise SyntaxError
+        elif elem.valtype == 'str':
+            print 'string', repr(read_str(s, length))
+        elif elem.valtype in ('binary', 'ebml_id'):
+            t = read_str(s, length)
+            dec = ''
+            if elem.valtype == 'ebml_id':
+                idelem = elementd.get(t.encode('hex'))
+                if idelem is None:
+                    dec = '(UNKNOWN)'
+                else:
+                    dec = '(%s)' % idelem.name
+            if len(t) < 20:
+                t = t.encode('hex')
+            else:
+                t = '<skipped %d bytes>' % len(t)
+            print 'binary', t, dec
+        elif elem.valtype == 'uint':
+            print 'uint', read_uint(s, length)
+        elif elem.valtype == 'sint':
+            print 'sint', read_sint(s, length)
+        elif elem.valtype == 'float':
+            print 'float', read_float(s, length)
+        elif elem.valtype == 'skip':
+            read(s, length)
+        else:
+            raise NotImplementedError
+    else:
+        print(depth, 'Unknown element:', elid, 'size:', length)
+        read(s, length)
+    return this_length
+
+def parse_toplevel(s):
+    parse_one(s, 0, None, 1 << 63)
+
+if sys.argv[1] == '--generate-header':
+    generate_C_header()
+elif sys.argv[1] == '--generate-definitions':
+    generate_C_definitions()
+else:
+    s = open(sys.argv[1])
+    while 1:
+        parse_toplevel(s)
diff --git a/libmpdemux/demux_lavf.c b/libmpdemux/demux_lavf.c
index 622b87d45a..ad958889ed 100644
--- a/libmpdemux/demux_lavf.c
+++ b/libmpdemux/demux_lavf.c
@@ -408,8 +408,8 @@ static void handle_stream(demuxer_t *demuxer, AVFormatContext *avfc, int i) {
         }
         case CODEC_TYPE_ATTACHMENT:{
             if (st->codec->codec_id == CODEC_ID_TTF)
-                demuxer_add_attachment(demuxer, st->filename,
-                                       "application/x-truetype-font",
+                demuxer_add_attachment(demuxer, st->filename, INT_MAX,
+                                       "application/x-truetype-font", INT_MAX,
                                        codec->extradata, codec->extradata_size);
             break;
         }
@@ -489,7 +489,7 @@ static demuxer_t* demux_open_lavf(demuxer_t *demuxer){
         uint64_t start = av_rescale_q(c->start, c->time_base, (AVRational){1,1000});
         uint64_t end   = av_rescale_q(c->end, c->time_base, (AVRational){1,1000});
         t = av_metadata_get(c->metadata, "title", NULL, 0);
-        demuxer_add_chapter(demuxer, t ? t->value : NULL, start, end);
+        demuxer_add_chapter(demuxer, t ? t->value : NULL, INT_MAX, start, end);
     }
 
     for(i=0; i<avfc->nb_streams; i++)
diff --git a/libmpdemux/demux_mkv.c b/libmpdemux/demux_mkv.c
index b4a17d036f..69bef825b4 100644
--- a/libmpdemux/demux_mkv.c
+++ b/libmpdemux/demux_mkv.c
@@ -82,9 +82,9 @@ static const int cook_fl2bps[COOK_FLAVORS] = {
     12016, 16408, 22911, 33506
 };
 
-typedef struct {
-    uint32_t order, type, scope;
-    uint32_t comp_algo;
+typedef struct mkv_content_encoding {
+    uint64_t order, type, scope;
+    uint64_t comp_algo;
     uint8_t *comp_settings;
     int comp_settings_len;
 } mkv_content_encoding_t;
@@ -175,10 +175,13 @@ typedef struct mkv_demuxer {
     mkv_index_t *indexes;
     int num_indexes;
 
-    off_t *parsed_cues;
-    int parsed_cues_num;
-    off_t *parsed_seekhead;
-    int parsed_seekhead_num;
+    off_t *parsed_pos;
+    int num_parsed_pos;
+    bool parsed_info;
+    bool parsed_tracks;
+    bool parsed_tags;
+    bool parsed_chapters;
+    bool parsed_attachments;
 
     struct cluster_pos {
         uint64_t filepos;
@@ -211,6 +214,29 @@ static void *grow_array(void *array, int nelem, size_t elsize)
     return array;
 }
 
+static bool is_parsed_header(struct mkv_demuxer *mkv_d, off_t pos)
+{
+    int low = 0;
+    int high = mkv_d->num_parsed_pos;
+    while (high > low + 1) {
+        int mid = high + low >> 1;
+        if (mkv_d->parsed_pos[mid] > pos)
+            high = mid;
+        else
+            low = mid;
+    }
+    if (mkv_d->num_parsed_pos && mkv_d->parsed_pos[low] == pos)
+        return true;
+    if (!(mkv_d->num_parsed_pos & 31))
+        mkv_d->parsed_pos = talloc_realloc(mkv_d, mkv_d->parsed_pos, off_t,
+                                       mkv_d->num_parsed_pos + 32);
+    mkv_d->num_parsed_pos++;
+    for (int i = mkv_d->num_parsed_pos - 1; i > low; i--)
+        mkv_d->parsed_pos[i] = mkv_d->parsed_pos[i - 1];
+    mkv_d->parsed_pos[low] = pos;
+    return false;
+}
+
 static mkv_track_t *demux_mkv_find_track_by_num(mkv_demuxer_t *d, int n,
                                                 int type)
 {
@@ -283,23 +309,29 @@ static void free_cached_dps(demuxer_t *demuxer)
     }
 }
 
-static int demux_mkv_decode(mkv_track_t *track, uint8_t *src,
-                            uint8_t **dest, uint32_t *size, uint32_t type)
+static void demux_mkv_decode(mkv_track_t *track, uint8_t *src,
+                             uint8_t **dest, uint32_t *size, uint32_t type)
 {
-    int i, result;
-    int modified = 0;
+    uint8_t *orig_src = src;
 
     *dest = src;
-    if (track->num_encodings <= 0)
-        return 0;
 
-    for (i = 0; i < track->num_encodings; i++) {
-        if (!(track->encodings[i].scope & type))
+    for (int i = 0; i < track->num_encodings; i++) {
+        struct mkv_content_encoding *enc = track->encodings + i;
+        if (!(enc->scope & type))
             continue;
 
+        if (src != *dest && src != orig_src)
+            free(src);
+        src = *dest;  // output from last iteration is new source
+
+        if (enc->comp_algo == 0) {
 #if CONFIG_ZLIB
-        if (track->encodings[i].comp_algo == 0) {
             /* zlib encoded track */
+
+            if (*size == 0)
+                continue;
+
             z_stream zstream;
 
             zstream.zalloc = (alloc_func) 0;
@@ -308,14 +340,14 @@ static int demux_mkv_decode(mkv_track_t *track, uint8_t *src,
             if (inflateInit(&zstream) != Z_OK) {
                 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
                         "[mkv] zlib initialization failed.\n");
-                return modified;
+                goto error;
             }
             zstream.next_in = (Bytef *) src;
             zstream.avail_in = *size;
 
-            modified = 1;
             *dest = NULL;
             zstream.avail_out = *size;
+            int result;
             do {
                 *size += 4000;
                 *dest = realloc(*dest, *size);
@@ -327,7 +359,7 @@ static int demux_mkv_decode(mkv_track_t *track, uint8_t *src,
                     free(*dest);
                     *dest = NULL;
                     inflateEnd(&zstream);
-                    return modified;
+                    goto error;
                 }
                 zstream.avail_out += 4000;
             } while (zstream.avail_out == 4000 && zstream.avail_in != 0
@@ -335,9 +367,8 @@ static int demux_mkv_decode(mkv_track_t *track, uint8_t *src,
 
             *size = zstream.total_out;
             inflateEnd(&zstream);
-        }
 #endif
-        if (track->encodings[i].comp_algo == 2) {
+        } else if (enc->comp_algo == 2) {
             /* lzo encoded track */
             int dstlen = *size * 3;
 
@@ -347,7 +378,7 @@ static int demux_mkv_decode(mkv_track_t *track, uint8_t *src,
                 if (dstlen > SIZE_MAX - AV_LZO_OUTPUT_PADDING)
                     goto lzo_fail;
                 *dest = realloc(*dest, dstlen + AV_LZO_OUTPUT_PADDING);
-                result = av_lzo1x_decode(*dest, &dstlen, src, &srclen);
+                int result = av_lzo1x_decode(*dest, &dstlen, src, &srclen);
                 if (result == 0)
                     break;
                 if (!(result & AV_LZO_OUTPUT_FULL)) {
@@ -356,17 +387,24 @@ static int demux_mkv_decode(mkv_track_t *track, uint8_t *src,
                             "[mkv] lzo decompression failed.\n");
                     free(*dest);
                     *dest = NULL;
-                    return modified;
+                    goto error;
                 }
                 mp_msg(MSGT_DEMUX, MSGL_DBG2,
                        "[mkv] lzo decompression buffer too small.\n");
                 dstlen *= 2;
             }
             *size = dstlen;
+        } else if (enc->comp_algo == 3) {
+            *dest = malloc(*size + enc->comp_settings_len);
+            memcpy(*dest, enc->comp_settings, enc->comp_settings_len);
+            memcpy(*dest + enc->comp_settings_len, src, *size);
+            *size += enc->comp_settings_len;
         }
     }
 
-    return modified;
+ error:
+    if (src != *dest && src != orig_src)
+        free(src);
 }
 
 
@@ -374,341 +412,164 @@ static int demux_mkv_read_info(demuxer_t *demuxer)
 {
     mkv_demuxer_t *mkv_d = demuxer->priv;
     stream_t *s = demuxer->stream;
-    uint64_t length, l;
-    int i;
-    uint64_t tc_scale = 1000000;
-    long double duration = 0.;
 
-    length = ebml_read_length(s, NULL);
-    while (length > 0) {
-        uint32_t id = ebml_read_id(s, &i);
-        length -= i;
-        switch (id) {
-        case MATROSKA_ID_TIMECODESCALE:
-            tc_scale = ebml_read_uint(s, &l);
-            length -= l;
-            if (tc_scale == EBML_UINT_INVALID)
-                return 1;
-            mp_msg(MSGT_DEMUX, MSGL_V,
-                   "[mkv] | + timecode scale: %" PRIu64 "\n", tc_scale);
-            break;
-
-        case MATROSKA_ID_DURATION:
-            duration = ebml_read_float(s, &l);
-            length -= l;
-            if (duration == EBML_FLOAT_INVALID)
-                return 1;
-            break;
-
-        case MATROSKA_ID_SEGMENTUID:;
-            l = ebml_read_length(s, &i);
-            length -= i;
-            if (l != sizeof(demuxer->matroska_data.segment_uid)) {
-                mp_msg(MSGT_DEMUX, MSGL_INFO,
-                       "[mkv] segment uid invalid length %" PRIu64 "\n", l);
-                stream_skip(s, l);
-            } else {
-                stream_read(s, demuxer->matroska_data.segment_uid, l);
-                mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + segment uid");
-                for (int i = 0; i < l; i++)
-                    mp_msg(MSGT_DEMUX, MSGL_V, " %02x",
-                           demuxer->matroska_data.segment_uid[i]);
-                mp_msg(MSGT_DEMUX, MSGL_V, "\n");
-            }
-            length -= l;
-            break;
+    mkv_d->tc_scale = 1000000;
+    mkv_d->duration = 0;
 
-        default:
-            ebml_read_skip(s, &l);
-            length -= l;
-            break;
-        }
+    struct ebml_info info = {};
+    struct ebml_parse_ctx parse_ctx = {};
+    if (ebml_read_element(s, &parse_ctx, &info, &ebml_info_desc) < 0)
+        return 1;
+    if (info.n_timecode_scale) {
+        mkv_d->tc_scale = info.timecode_scale;
+        mp_msg(MSGT_DEMUX, MSGL_V,
+               "[mkv] | + timecode scale: %" PRIu64 "\n", mkv_d->tc_scale);
     }
-    mkv_d->tc_scale = tc_scale;
-    mkv_d->duration = duration * tc_scale / 1000000000.0;
-    if (duration)
+    if (info.n_duration) {
+        mkv_d->duration = info.duration * mkv_d->tc_scale / 1e9;
         mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + duration: %.3fs\n",
                mkv_d->duration);
-
+    }
+    if (info.n_segment_uid) {
+        int len = info.segment_uid.len;
+        if (len != sizeof(demuxer->matroska_data.segment_uid)) {
+            mp_msg(MSGT_DEMUX, MSGL_INFO,
+                   "[mkv] segment uid invalid length %d\n", len);
+        } else {
+            memcpy(demuxer->matroska_data.segment_uid, info.segment_uid.start,
+                   len);
+            mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + segment uid");
+            for (int i = 0; i < len; i++)
+                mp_msg(MSGT_DEMUX, MSGL_V, " %02x",
+                       demuxer->matroska_data.segment_uid[i]);
+            mp_msg(MSGT_DEMUX, MSGL_V, "\n");
+        }
+    }
+    talloc_free(parse_ctx.talloc_ctx);
     return 0;
 }
 
-/**
- * \brief free array of kv_content_encoding_t
- * \param encodings pointer to array
- * \param numencodings number of encodings in array
- */
-static void demux_mkv_free_encodings(mkv_content_encoding_t *encodings,
-                                     int numencodings)
-{
-    while (numencodings-- > 0)
-        free(encodings[numencodings].comp_settings);
-    free(encodings);
-}
-
-static int demux_mkv_read_trackencodings(demuxer_t *demuxer,
-                                         mkv_track_t *track)
+static void parse_trackencodings(struct demuxer *demuxer,
+                                 struct mkv_track *track,
+                                 struct ebml_content_encodings *encodings)
 {
-    stream_t *s = demuxer->stream;
-    mkv_content_encoding_t *ce, e;
-    uint64_t len1, len2, length, l;
-    int i, il, n;
-
-    ce = malloc(sizeof(*ce));
-    n = 0;
-
-    len1 = length = ebml_read_length(s, &il);
-    len1 += il;
-    while (length > 0) {
-        switch (ebml_read_id(s, &il)) {
-        case MATROSKA_ID_CONTENTENCODING:
-            memset(&e, 0, sizeof(e));
+    // initial allocation to be a non-NULL context before realloc
+    mkv_content_encoding_t *ce = talloc_size(track, 1);
+
+    for (int n_enc = 0; n_enc < encodings->n_content_encoding; n_enc++) {
+        struct ebml_content_encoding *enc = encodings->content_encoding + n_enc;
+        struct mkv_content_encoding e = {};
+        e.order = enc->content_encoding_order;
+        if (enc->n_content_encoding_scope)
+            e.scope = enc->content_encoding_scope;
+        else
             e.scope = 1;
-
-            len2 = ebml_read_length(s, &i);
-            l = len2 + i;
-
-            while (len2 > 0) {
-                uint64_t num, l;
-                int il;
-
-                switch (ebml_read_id(s, &il)) {
-                case MATROSKA_ID_CONTENTENCODINGORDER:
-                    num = ebml_read_uint(s, &l);
-                    if (num == EBML_UINT_INVALID)
-                        goto err_out;
-                    e.order = num;
-                    break;
-
-                case MATROSKA_ID_CONTENTENCODINGSCOPE:
-                    num = ebml_read_uint(s, &l);
-                    if (num == EBML_UINT_INVALID)
-                        goto err_out;
-                    e.scope = num;
-                    break;
-
-                case MATROSKA_ID_CONTENTENCODINGTYPE:
-                    num = ebml_read_uint(s, &l);
-                    if (num == EBML_UINT_INVALID)
-                        goto err_out;
-                    e.type = num;
-                    break;
-
-                case MATROSKA_ID_CONTENTCOMPRESSION:;
-                    uint64_t le;
-
-                    le = ebml_read_length(s, &i);
-                    l = le + i;
-
-                    while (le > 0) {
-                        uint64_t l;
-                        int il;
-
-                        switch (ebml_read_id(s, &il)) {
-                        case MATROSKA_ID_CONTENTCOMPALGO:
-                            num = ebml_read_uint(s, &l);
-                            if (num == EBML_UINT_INVALID)
-                                goto err_out;
-                            e.comp_algo = num;
-                            break;
-
-                        case MATROSKA_ID_CONTENTCOMPSETTINGS:
-                            l = ebml_read_length(s, &i);
-                            e.comp_settings = malloc(l);
-                            stream_read(s, e.comp_settings, l);
-                            e.comp_settings_len = l;
-                            l += i;
-                            break;
-
-                        default:
-                            ebml_read_skip(s, &l);
-                            break;
-                        }
-                        le -= l + il;
-                    }
-
-                    if (e.type == 1) {
-                        mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Track "
-                                "number %u has been encrypted and "
-                                "decryption has not yet been\n"
-                                "[mkv] implemented. Skipping track.\n",
-                                track->tnum);
-                    } else if (e.type != 0) {
-                        mp_tmsg(MSGT_DEMUX, MSGL_WARN,
-                                "[mkv] Unknown content encoding type for "
-                                "track %u. Skipping track.\n",
-                                track->tnum);
-                    }
-
-                    if (e.comp_algo != 0 && e.comp_algo != 2) {
-                        mp_tmsg(MSGT_DEMUX, MSGL_WARN,
-                                "[mkv] Track %u has been compressed with "
-                                "an unknown/unsupported compression\n"
-                                "[mkv] algorithm (%u). Skipping track.\n",
-                                track->tnum, e.comp_algo);
-                    }
-#if !CONFIG_ZLIB
-                    else if (e.comp_algo == 0) {
-                        mp_tmsg(MSGT_DEMUX, MSGL_WARN,
-                                "[mkv] Track %u was compressed with zlib "
-                                "but mplayer has not been compiled\n"
-                                "[mkv] with support for zlib compression. "
-                                "Skipping track.\n",
-                                track->tnum);
-                    }
-#endif
-
-                    break;
-
-                default:
-                    ebml_read_skip(s, &l);
-                    break;
-                }
-                len2 -= l + il;
+        e.type = enc->content_encoding_type;
+
+        if (enc->n_content_compression) {
+            struct ebml_content_compression *z = &enc->content_compression;
+            e.comp_algo = z->content_comp_algo;
+            if (z->n_content_comp_settings) {
+                int sz = z->content_comp_settings.len;
+                e.comp_settings = talloc_size(ce, sz);
+                memcpy(e.comp_settings, z->content_comp_settings.start, sz);
+                e.comp_settings_len = sz;
             }
-            for (i = 0; i < n; i++)
-                if (e.order <= ce[i].order)
-                    break;
-            ce = realloc(ce, (n + 1) * sizeof(*ce));
-            memmove(ce + i + 1, ce + i, (n - i) * sizeof(*ce));
-            memcpy(ce + i, &e, sizeof(e));
-            n++;
-            break;
-
-        default:
-            ebml_read_skip(s, &l);
-            break;
         }
 
-        length -= l + il;
+        if (e.type == 1) {
+            mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Track "
+                    "number %u has been encrypted and "
+                    "decryption has not yet been\n"
+                    "[mkv] implemented. Skipping track.\n",
+                    track->tnum);
+        } else if (e.type != 0) {
+            mp_tmsg(MSGT_DEMUX, MSGL_WARN,
+                    "[mkv] Unknown content encoding type for "
+                    "track %u. Skipping track.\n",
+                    track->tnum);
+        } else if (e.comp_algo != 0 && e.comp_algo != 2) {
+            mp_tmsg(MSGT_DEMUX, MSGL_WARN,
+                    "[mkv] Track %u has been compressed with "
+                    "an unknown/unsupported compression\n"
+                    "[mkv] algorithm (%" PRIu64 "). Skipping track.\n",
+                    track->tnum, e.comp_algo);
+        }
+#if !CONFIG_ZLIB
+        else if (e.comp_algo == 0) {
+            mp_tmsg(MSGT_DEMUX, MSGL_WARN,
+                    "[mkv] Track %u was compressed with zlib "
+                    "but mplayer has not been compiled\n"
+                    "[mkv] with support for zlib compression. "
+                    "Skipping track.\n",
+                    track->tnum);
+        }
+#endif
+        int i;
+        for (i = 0; i < n_enc; i++)
+            if (e.order >= ce[i].order)
+                break;
+        ce = talloc_realloc_size(track, ce, (n_enc + 1) * sizeof(*ce));
+        me