libvpx: Pull from upstream

source/libvpx/third_party/libwebm/mkvparser.cpp

 // Copyright (c) 2012 The WebM project authors. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the LICENSE file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS.  All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 
 #include "mkvparser.hpp"
 #include <cassert>
 #include <cstring>
 #include <new>
 #include <climits>
 
 #ifdef _MSC_VER
 // Disable MSVC warnings that suggest making code non-portable.
 #pragma warning(disable : 4996)
 #endif
 
 mkvparser::IMkvReader::~IMkvReader() {}
 
 void mkvparser::GetVersion(int& major, int& minor, int& build, int& revision) {
   major = 1;
   minor = 0;
   build = 0;
-  revision = 28;
+  revision = 30;
 }
 
 long long mkvparser::ReadUInt(IMkvReader* pReader, long long pos, long& len) {
   assert(pReader);
   assert(pos >= 0);
 
   int status;
 
   //#ifdef _DEBUG
   //    long long total, available;
@@ skipping 86 matching lines @@
   unsigned char m = 0x80;
 
   while (!(b & m)) {
     m >>= 1;
     ++len;
   }
 
   return 0;  // success
 }
 
+// TODO(vigneshv): This function assumes that unsigned values never have their
+// high bit set.
 long long mkvparser::UnserializeUInt(IMkvReader* pReader, long long pos,
                                      long long size) {
   assert(pReader);
   assert(pos >= 0);
 
   if ((size <= 0) || (size > 8))
     return E_FILE_FORMAT_INVALID;
 
   long long result = 0;
 
@@ skipping 67 matching lines @@
 
       dd <<= 8;
     }
 
     result = d;
   }
 
   return 0;
 }
 
-long mkvparser::UnserializeInt(IMkvReader* pReader, long long pos, long size,
-                               long long& result) {
+long mkvparser::UnserializeInt(IMkvReader* pReader, long long pos,
+                               long long size, long long& result) {
   assert(pReader);
   assert(pos >= 0);
   assert(size > 0);
   assert(size <= 8);
 
   {
     signed char b;
 
     const long status = pReader->Read(pos, 1, (unsigned char*)&b);
 
@@ skipping 366 matching lines @@
       // m_element_size(elem_size),
       m_start(start),
       m_size(size),
       m_pos(start),
       m_pUnknownSize(0),
       m_pSeekHead(NULL),
       m_pInfo(NULL),
       m_pTracks(NULL),
       m_pCues(NULL),
       m_pChapters(NULL),
+      m_pTags(NULL),
       m_clusters(NULL),
       m_clusterCount(0),
       m_clusterPreloadCount(0),
       m_clusterSize(0) {}
 
 Segment::~Segment() {
   const long count = m_clusterCount + m_clusterPreloadCount;
 
   Cluster** i = m_clusters;
   Cluster** j = m_clusters + count;
 
   while (i != j) {
     Cluster* const p = *i++;
     assert(p);
 
     delete p;
   }
 
   delete[] m_clusters;
 
   delete m_pTracks;
   delete m_pInfo;
   delete m_pCues;
   delete m_pChapters;
+  delete m_pTags;
   delete m_pSeekHead;
 }
 
 long long Segment::CreateInstance(IMkvReader* pReader, long long pos,
                                   Segment*& pSegment) {
   assert(pReader);
   assert(pos >= 0);
 
   pSegment = NULL;
 
@@ skipping 258 matching lines @@
             Chapters(this, pos, size, element_start, element_size);
 
         if (m_pChapters == NULL)
           return -1;
 
         const long status = m_pChapters->Parse();
 
         if (status)
           return status;
       }
+    } else if (id == 0x0254C367) {  // Tags ID
+      if (m_pTags == NULL) {
+        m_pTags = new (std::nothrow)
+            Tags(this, pos, size, element_start, element_size);
+
+        if (m_pTags == NULL)
+          return -1;
+
+        const long status = m_pTags->Parse();
+
+        if (status)
+          return status;
+      }
     }
 
     m_pos = pos + size;  // consume payload
   }
 
   assert((segment_stop < 0) || (m_pos <= segment_stop));
 
   if (m_pInfo == NULL)  // TODO: liberalize this behavior
     return E_FILE_FORMAT_INVALID;
 
@@ skipping 98 matching lines @@
 
     // pos now points to start of payload
 
     if (size == 0) {  // weird
       m_pos = pos;
       continue;
     }
 
     const long long unknown_size = (1LL << (7 * len)) - 1;
 
-#if 0  // we must handle this to support live webm
-        if (size == unknown_size)
-            return E_FILE_FORMAT_INVALID;  //TODO: allow this
-#endif
-
     if ((segment_stop >= 0) && (size != unknown_size) &&
         ((pos + size) > segment_stop)) {
       return E_FILE_FORMAT_INVALID;
     }
 
-#if 0  // commented-out, to support incremental cluster parsing
-        len = static_cast<long>(size);
-
-        if ((pos + size) > avail)
-            return E_BUFFER_NOT_FULL;
-#endif
-
     if (id == 0x0C53BB6B) {  // Cues ID
       if (size == unknown_size)
         return E_FILE_FORMAT_INVALID;  // TODO: liberalize
 
       if (m_pCues == NULL) {
         const long long element_size = (pos - idpos) + size;
 
         m_pCues = new Cues(this, pos, size, idpos, element_size);
         assert(m_pCues);  // TODO
       }
@@ skipping 95 matching lines @@
       --m_clusterPreloadCount;
 
       m_pos = pos;  // consume payload
       assert((segment_stop < 0) || (m_pos <= segment_stop));
 
       return 0;  // success
     }
   }
 
   if (status == 0) {  // no entries found
-    if (cluster_size < 0)
-      return E_FILE_FORMAT_INVALID;  // TODO: handle this
-
-    pos += cluster_size;
+    if (cluster_size >= 0)
+      pos += cluster_size;
 
     if ((total >= 0) && (pos >= total)) {
       m_pos = total;
       return 1;  // no more clusters
     }
 
     if ((segment_stop >= 0) && (pos >= segment_stop)) {
       m_pos = segment_stop;
       return 1;  // no more clusters
     }
@@ skipping 20 matching lines @@
     assert((segment_stop < 0) || (m_pos <= segment_stop));
 
     return 0;
   }
 
   m_pUnknownSize = pCluster;
   m_pos = -pos;
 
   return 0;  // partial success, since we have a new cluster
 
-// status == 0 means "no block entries found"
-
-// pos designates start of payload
-// m_pos has NOT been adjusted yet (in case we need to come back here)
-
-#if 0
-
-    if (cluster_size < 0) {  //unknown size
-        const long long payload_pos = pos;  //absolute pos of cluster payload
-
-        for (;;) {  //determine cluster size
-            if ((total >= 0) && (pos >= total))
-                break;
-
-            if ((segment_stop >= 0) && (pos >= segment_stop))
-                break;  //no more clusters
-
-            //Read ID
-
-            if ((pos + 1) > avail)
-            {
-                len = 1;
-                return E_BUFFER_NOT_FULL;
-            }
-
-            long long result = GetUIntLength(m_pReader, pos, len);
-
-            if (result < 0)  //error
-                return static_cast<long>(result);
-
-            if (result > 0)  //weird
-                return E_BUFFER_NOT_FULL;
-
-            if ((segment_stop >= 0) && ((pos + len) > segment_stop))
-                return E_FILE_FORMAT_INVALID;
-
-            if ((pos + len) > avail)
-                return E_BUFFER_NOT_FULL;
-
-            const long long idpos = pos;
-            const long long id = ReadUInt(m_pReader, idpos, len);
-
-            if (id < 0)  //error (or underflow)
-                return static_cast<long>(id);
-
-            //This is the distinguished set of ID's we use to determine
-            //that we have exhausted the sub-element's inside the cluster
-            //whose ID we parsed earlier.
-
-            if (id == 0x0F43B675)  //Cluster ID
-                break;
-
-            if (id == 0x0C53BB6B)  //Cues ID
-                break;
-
-            switch (id)
-            {
-                case 0x20:  //BlockGroup
-                case 0x23:  //Simple Block
-                case 0x67:  //TimeCode
-                case 0x2B:  //PrevSize
-                    break;
-
-                default:
-                    assert(false);
-                    break;
-            }
-
-            pos += len;  //consume ID (of sub-element)
-
-            //Read Size
-
-            if ((pos + 1) > avail)
-            {
-                len = 1;
-                return E_BUFFER_NOT_FULL;
-            }
-
-            result = GetUIntLength(m_pReader, pos, len);
-
-            if (result < 0)  //error
-                return static_cast<long>(result);
-
-            if (result > 0)  //weird
-                return E_BUFFER_NOT_FULL;
-
-            if ((segment_stop >= 0) && ((pos + len) > segment_stop))
-                return E_FILE_FORMAT_INVALID;
-
-            if ((pos + len) > avail)
-                return E_BUFFER_NOT_FULL;
-
-            const long long size = ReadUInt(m_pReader, pos, len);
-
-            if (size < 0)  //error
-                return static_cast<long>(size);
-
-            pos += len;  //consume size field of element
-
-            //pos now points to start of sub-element's payload
-
-            if (size == 0)  //weird
-                continue;
-
-            const long long unknown_size = (1LL << (7 * len)) - 1;
-
-            if (size == unknown_size)
-                return E_FILE_FORMAT_INVALID;  //not allowed for sub-elements
-
-            if ((segment_stop >= 0) && ((pos + size) > segment_stop))  //weird
-                return E_FILE_FORMAT_INVALID;
-
-            pos += size;  //consume payload of sub-element
-            assert((segment_stop < 0) || (pos <= segment_stop));
-        }  //determine cluster size
-
-        cluster_size = pos - payload_pos;
-        assert(cluster_size >= 0);
-
-        pos = payload_pos;  //reset and re-parse original cluster
-    }
-
-    if (m_clusterPreloadCount > 0)
-    {
-        assert(idx < m_clusterSize);
-
-        Cluster* const pCluster = m_clusters[idx];
-        assert(pCluster);
-        assert(pCluster->m_index < 0);
-
-        const long long off = pCluster->GetPosition();
-        assert(off >= 0);
-
-        if (off == cluster_off)  //preloaded already
-            return E_FILE_FORMAT_INVALID;  //subtle
-    }
-
-    m_pos = pos + cluster_size;  //consume payload
-    assert((segment_stop < 0) || (m_pos <= segment_stop));
-
-    return 2;     //try to find another cluster
-
-#endif
+  // status == 0 means "no block entries found"
+  // pos designates start of payload
+  // m_pos has NOT been adjusted yet (in case we need to come back here)
 }
 
 long Segment::DoLoadClusterUnknownSize(long long& pos, long& len) {
   assert(m_pos < 0);
   assert(m_pUnknownSize);
 
-#if 0
-    assert(m_pUnknownSize->GetElementSize() < 0);  //TODO: verify this
-
-    const long long element_start = m_pUnknownSize->m_element_start;
-
-    pos = -m_pos;
-    assert(pos > element_start);
-
-    //We have already consumed the (cluster) ID and size fields.
-    //We just need to consume the blocks and other sub-elements
-    //of this cluster, until we discover the boundary.
-
-    long long total, avail;
-
-    long status = m_pReader->Length(&total, &avail);
-
-    if (status < 0)  //error
-        return status;
-
-    assert((total < 0) || (avail <= total));
-
-    const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
-
-    long long element_size = -1;
-
-    for (;;) {  //determine cluster size
-        if ((total >= 0) && (pos >= total))
-        {
-            element_size = total - element_start;
-            assert(element_size > 0);
-
-            break;
-        }
-
-        if ((segment_stop >= 0) && (pos >= segment_stop))
-        {
-            element_size = segment_stop - element_start;
-            assert(element_size > 0);
-
-            break;
-        }
-
-        //Read ID
-
-        if ((pos + 1) > avail)
-        {
-            len = 1;
-            return E_BUFFER_NOT_FULL;
-        }
-
-        long long result = GetUIntLength(m_pReader, pos, len);
-
-        if (result < 0)  //error
-            return static_cast<long>(result);
-
-        if (result > 0)  //weird
-            return E_BUFFER_NOT_FULL;
-
-        if ((segment_stop >= 0) && ((pos + len) > segment_stop))
-            return E_FILE_FORMAT_INVALID;
-
-        if ((pos + len) > avail)
-            return E_BUFFER_NOT_FULL;
-
-        const long long idpos = pos;
-        const long long id = ReadUInt(m_pReader, idpos, len);
-
-        if (id < 0)  //error (or underflow)
-            return static_cast<long>(id);
-
-        //This is the distinguished set of ID's we use to determine
-        //that we have exhausted the sub-element's inside the cluster
-        //whose ID we parsed earlier.
-
-        if ((id == 0x0F43B675) || (id == 0x0C53BB6B)) {  //Cluster ID or Cues ID
-            element_size = pos - element_start;
-            assert(element_size > 0);
-
-            break;
-        }
-
-#ifdef _DEBUG
-        switch (id)
-        {
-            case 0x20:  //BlockGroup
-            case 0x23:  //Simple Block
-            case 0x67:  //TimeCode
-            case 0x2B:  //PrevSize
-                break;
-
-            default:
-                assert(false);
-                break;
-        }
-#endif
-
-        pos += len;  //consume ID (of sub-element)
-
-        //Read Size
-
-        if ((pos + 1) > avail)
-        {
-            len = 1;
-            return E_BUFFER_NOT_FULL;
-        }
-
-        result = GetUIntLength(m_pReader, pos, len);
-
-        if (result < 0)  //error
-            return static_cast<long>(result);
-
-        if (result > 0)  //weird
-            return E_BUFFER_NOT_FULL;
-
-        if ((segment_stop >= 0) && ((pos + len) > segment_stop))
-            return E_FILE_FORMAT_INVALID;
-
-        if ((pos + len) > avail)
-            return E_BUFFER_NOT_FULL;
-
-        const long long size = ReadUInt(m_pReader, pos, len);
-
-        if (size < 0)  //error
-            return static_cast<long>(size);
-
-        pos += len;  //consume size field of element
-
-        //pos now points to start of sub-element's payload
-
-        if (size == 0)  //weird
-            continue;
-
-        const long long unknown_size = (1LL << (7 * len)) - 1;
-
-        if (size == unknown_size)
-            return E_FILE_FORMAT_INVALID;  //not allowed for sub-elements
-
-        if ((segment_stop >= 0) && ((pos + size) > segment_stop))  //weird
-            return E_FILE_FORMAT_INVALID;
-
-        pos += size;  //consume payload of sub-element
-        assert((segment_stop < 0) || (pos <= segment_stop));
-    }  //determine cluster size
-
-    assert(element_size >= 0);
-
-    m_pos = element_start + element_size;
-    m_pUnknownSize = 0;
-
-    return 2;  //continue parsing
-#else
   const long status = m_pUnknownSize->Parse(pos, len);
 
   if (status < 0)  // error or underflow
     return status;
 
   if (status == 0)  // parsed a block
     return 2;  // continue parsing
 
   assert(status > 0);  // nothing left to parse of this cluster
 
   const long long start = m_pUnknownSize->m_element_start;
 
   const long long size = m_pUnknownSize->GetElementSize();
   assert(size >= 0);
 
   pos = start + size;
   m_pos = pos;
 
   m_pUnknownSize = 0;
 
   return 2;  // continue parsing
-#endif
 }
 
 void Segment::AppendCluster(Cluster* pCluster) {
   assert(pCluster);
   assert(pCluster->m_index >= 0);
 
   const long count = m_clusterCount + m_clusterPreloadCount;
 
   long& size = m_clusterSize;
   assert(size >= count);
 
   const long idx = pCluster->m_index;
   assert(idx == m_clusterCount);
 
   if (count >= size) {
     const long n = (size <= 0) ? 2048 : 2 * size;
 
-    Cluster** const qq = new Cluster* [n];
+    Cluster** const qq = new Cluster*[n];
     Cluster** q = qq;
 
     Cluster** p = m_clusters;
     Cluster** const pp = p + count;
 
     while (p != pp)
       *q++ = *p++;
 
     delete[] m_clusters;
 
@@ skipping 33 matching lines @@
   assert(idx >= m_clusterCount);
 
   const long count = m_clusterCount + m_clusterPreloadCount;
 
   long& size = m_clusterSize;
   assert(size >= count);
 
   if (count >= size) {
     const long n = (size <= 0) ? 2048 : 2 * size;
 
-    Cluster** const qq = new Cluster* [n];
+    Cluster** const qq = new Cluster*[n];
     Cluster** q = qq;
 
     Cluster** p = m_clusters;
     Cluster** const pp = p + count;
 
     while (p != pp)
       *q++ = *p++;
 
     delete[] m_clusters;
 
@@ skipping 179 matching lines @@
 const SeekHead::VoidElement* SeekHead::GetVoidElement(int idx) const {
   if (idx < 0)
     return 0;
 
   if (idx >= m_void_element_count)
     return 0;
 
   return m_void_elements + idx;
 }
 
-#if 0
-void Segment::ParseCues(long long off)
-{
-    if (m_pCues)
-        return;
-
-    //odbgstream os;
-    //os << "Segment::ParseCues (begin)" << endl;
-
-    long long pos = m_start + off;
-    const long long element_start = pos;
-    const long long stop = m_start + m_size;
-
-    long len;
-
-    long long result = GetUIntLength(m_pReader, pos, len);
-    assert(result == 0);
-    assert((pos + len) <= stop);
-
-    const long long idpos = pos;
-
-    const long long id = ReadUInt(m_pReader, idpos, len);
-    assert(id == 0x0C53BB6B);  //Cues ID
-
-    pos += len;  //consume ID
-    assert(pos < stop);
-
-    //Read Size
-
-    result = GetUIntLength(m_pReader, pos, len);
-    assert(result == 0);
-    assert((pos + len) <= stop);
-
-    const long long size = ReadUInt(m_pReader, pos, len);
-    assert(size >= 0);
-
-    pos += len;  //consume length of size of element
-    assert((pos + size) <= stop);
-
-    const long long element_size = size + pos - element_start;
-
-    //Pos now points to start of payload
-
-    m_pCues = new Cues(this, pos, size, element_start, element_size);
-    assert(m_pCues);  //TODO
-
-    //os << "Segment::ParseCues (end)" << endl;
-}
-#else
 long Segment::ParseCues(long long off, long long& pos, long& len) {
   if (m_pCues)
     return 0;  // success
 
   if (off < 0)
     return -1;
 
   long long total, avail;
 
   const int status = m_pReader->Length(&total, &avail);
@@ skipping 94 matching lines @@
     return E_BUFFER_NOT_FULL;
 
   const long long element_size = element_stop - element_start;
 
   m_pCues =
       new (std::nothrow) Cues(this, pos, size, element_start, element_size);
   assert(m_pCues);  // TODO
 
   return 0;  // success
 }
-#endif
 
-#if 0
-void Segment::ParseSeekEntry(
-    long long start,
-    long long size_)
-{
-    long long pos = start;
-
-    const long long stop = start + size_;
-
-    long len;
-
-    const long long seekIdId = ReadUInt(m_pReader, pos, len);
-    //seekIdId;
-    assert(seekIdId == 0x13AB);  //SeekID ID
-    assert((pos + len) <= stop);
-
-    pos += len;  //consume id
-
-    const long long seekIdSize = ReadUInt(m_pReader, pos, len);
-    assert(seekIdSize >= 0);
-    assert((pos + len) <= stop);
-
-    pos += len;  //consume size
-
-    const long long seekId = ReadUInt(m_pReader, pos, len);  //payload
-    assert(seekId >= 0);
-    assert(len == seekIdSize);
-    assert((pos + len) <= stop);
-
-    pos += seekIdSize;  //consume payload
-
-    const long long seekPosId = ReadUInt(m_pReader, pos, len);
-    //seekPosId;
-    assert(seekPosId == 0x13AC);  //SeekPos ID
-    assert((pos + len) <= stop);
-
-    pos += len;  //consume id
-
-    const long long seekPosSize = ReadUInt(m_pReader, pos, len);
-    assert(seekPosSize >= 0);
-    assert((pos + len) <= stop);
-
-    pos += len;  //consume size
-    assert((pos + seekPosSize) <= stop);
-
-    const long long seekOff = UnserializeUInt(m_pReader, pos, seekPosSize);
-    assert(seekOff >= 0);
-    assert(seekOff < m_size);
-
-    pos += seekPosSize;  //consume payload
-    assert(pos == stop);
-
-    const long long seekPos = m_start + seekOff;
-    assert(seekPos < (m_start + m_size));
-
-    if (seekId == 0x0C53BB6B)  //Cues ID
-        ParseCues(seekOff);
-}
-#else
 bool SeekHead::ParseEntry(IMkvReader* pReader, long long start, long long size_,
                           Entry* pEntry) {
   if (size_ <= 0)
     return false;
 
   long long pos = start;
   const long long stop = start + size_;
 
   long len;
 
@@ skipping 72 matching lines @@
   if (pEntry->pos < 0)
     return false;
 
   pos += seekPosSize;  // consume payload
 
   if (pos != stop)
     return false;
 
   return true;
 }
-#endif
 
 Cues::Cues(Segment* pSegment, long long start_, long long size_,
            long long element_start, long long element_size)
     : m_pSegment(pSegment),
       m_start(start_),
       m_size(size_),
       m_element_start(element_start),
       m_element_size(element_size),
       m_cue_points(NULL),
       m_count(0),
@@ skipping 21 matching lines @@
     return -1;
 
   return m_count;  // TODO: really ignore preload count?
 }
 
 bool Cues::DoneParsing() const {
   const long long stop = m_start + m_size;
   return (m_pos >= stop);
 }
 
-void Cues::Init() const {
+bool Cues::Init() const {
   if (m_cue_points)
-    return;
+    return true;
 
   assert(m_count == 0);
   assert(m_preload_count == 0);
 
   IMkvReader* const pReader = m_pSegment->m_pReader;
 
   const long long stop = m_start + m_size;
   long long pos = m_start;
 
   long cue_points_size = 0;
 
   while (pos < stop) {
     const long long idpos = pos;
 
     long len;
 
     const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);  // TODO
-    assert((pos + len) <= stop);
+    if (id < 0 || (pos + len) > stop) {
+      return false;
+    }
 
     pos += len;  // consume ID
 
     const long long size = ReadUInt(pReader, pos, len);
-    assert(size >= 0);
-    assert((pos + len) <= stop);
+    if (size < 0 || (pos + len > stop)) {
+      return false;
+    }
 
     pos += len;  // consume Size field
-    assert((pos + size) <= stop);
+    if (pos + size > stop) {
+      return false;
+    }
 
     if (id == 0x3B)  // CuePoint ID
       PreloadCuePoint(cue_points_size, idpos);
 
-    pos += size;  // consume payload
-    assert(pos <= stop);
+    pos += size;  // skip payload
   }
+  return true;
 }
 
 void Cues::PreloadCuePoint(long& cue_points_size, long long pos) const {
   assert(m_count == 0);
 
   if (m_preload_count >= cue_points_size) {
     const long n = (cue_points_size <= 0) ? 2048 : 2 * cue_points_size;
 
-    CuePoint** const qq = new CuePoint* [n];
+    CuePoint** const qq = new CuePoint*[n];
     CuePoint** q = qq;  // beginning of target
 
     CuePoint** p = m_cue_points;  // beginning of source
     CuePoint** const pp = p + m_preload_count;  // end of source
 
     while (p != pp)
       *q++ = *p++;
 
     delete[] m_cue_points;
 
     m_cue_points = qq;
     cue_points_size = n;
   }
 
   CuePoint* const pCP = new CuePoint(m_preload_count, pos);
   m_cue_points[m_preload_count++] = pCP;
 }
 
 bool Cues::LoadCuePoint() const {
   // odbgstream os;
   // os << "Cues::LoadCuePoint" << endl;
 
   const long long stop = m_start + m_size;
 
   if (m_pos >= stop)
     return false;  // nothing else to do
 
-  Init();
+  if (!Init()) {
+    m_pos = stop;
+    return false;
+  }
 
   IMkvReader* const pReader = m_pSegment->m_pReader;
 
   while (m_pos < stop) {
     const long long idpos = m_pos;
 
     long len;
 
     const long long id = ReadUInt(pReader, m_pos, len);
     assert(id >= 0);  // TODO
@@ skipping 16 matching lines @@
     }
 
     assert(m_preload_count > 0);
 
     CuePoint* const pCP = m_cue_points[m_count];
     assert(pCP);
     assert((pCP->GetTimeCode() >= 0) || (-pCP->GetTimeCode() == idpos));
     if (pCP->GetTimeCode() < 0 && (-pCP->GetTimeCode() != idpos))
       return false;
 
-    pCP->Load(pReader);
+    if (!pCP->Load(pReader)) {
+      m_pos = stop;
+      return false;
+    }
     ++m_count;
     --m_preload_count;
 
     m_pos += size;  // consume payload
     assert(m_pos <= stop);
 
     return true;  // yes, we loaded a cue point
   }
 
   // return (m_pos < stop);
   return false;  // no, we did not load a cue point
 }
 
 bool Cues::Find(long long time_ns, const Track* pTrack, const CuePoint*& pCP,
                 const CuePoint::TrackPosition*& pTP) const {
   assert(time_ns >= 0);
   assert(pTrack);
 
-#if 0
-    LoadCuePoint();  //establish invariant
-
-    assert(m_cue_points);
-    assert(m_count > 0);
-
-    CuePoint** const ii = m_cue_points;
-    CuePoint** i = ii;
-
-    CuePoint** const jj = ii + m_count + m_preload_count;
-    CuePoint** j = jj;
-
-    pCP = *i;
-    assert(pCP);
-
-    if (time_ns <= pCP->GetTime(m_pSegment))
-    {
-        pTP = pCP->Find(pTrack);
-        return (pTP != NULL);
-    }
-
-    IMkvReader* const pReader = m_pSegment->m_pReader;
-
-    while (i < j)
-    {
-        //INVARIANT:
-        //[ii, i) <= time_ns
-        //[i, j)  ?
-        //[j, jj) > time_ns
-
-        CuePoint** const k = i + (j - i) / 2;
-        assert(k < jj);
-
-        CuePoint* const pCP = *k;
-        assert(pCP);
-
-        pCP->Load(pReader);
-
-        const long long t = pCP->GetTime(m_pSegment);
-
-        if (t <= time_ns)
-            i = k + 1;
-        else
-            j = k;
-
-        assert(i <= j);
-    }
-
-    assert(i == j);
-    assert(i <= jj);
-    assert(i > ii);
-
-    pCP = *--i;
-    assert(pCP);
-    assert(pCP->GetTime(m_pSegment) <= time_ns);
-#else
   if (m_cue_points == NULL)
     return false;
 
   if (m_count == 0)
     return false;
 
   CuePoint** const ii = m_cue_points;
   CuePoint** i = ii;
 
   CuePoint** const jj = ii + m_count;
@@ skipping 29 matching lines @@
     assert(i <= j);
   }
 
   assert(i == j);
   assert(i <= jj);
   assert(i > ii);
 
   pCP = *--i;
   assert(pCP);
   assert(pCP->GetTime(m_pSegment) <= time_ns);
-#endif
 
   // TODO: here and elsewhere, it's probably not correct to search
   // for the cue point with this time, and then search for a matching
   // track.  In principle, the matching track could be on some earlier
   // cue point, and with our current algorithm, we'd miss it.  To make
   // this bullet-proof, we'd need to create a secondary structure,
   // with a list of cue points that apply to a track, and then search
   // that track-based structure for a matching cue point.
 
   pTP = pCP->Find(pTrack);
   return (pTP != NULL);
 }
 
-#if 0
-bool Cues::FindNext(
-    long long time_ns,
-    const Track* pTrack,
-    const CuePoint*& pCP,
-    const CuePoint::TrackPosition*& pTP) const
-{
-    pCP = 0;
-    pTP = 0;
-
-    if (m_count == 0)
-        return false;
-
-    assert(m_cue_points);
-
-    const CuePoint* const* const ii = m_cue_points;
-    const CuePoint* const* i = ii;
-
-    const CuePoint* const* const jj = ii + m_count;
-    const CuePoint* const* j = jj;
-
-    while (i < j)
-    {
-        //INVARIANT:
-        //[ii, i) <= time_ns
-        //[i, j)  ?
-        //[j, jj) > time_ns
-
-        const CuePoint* const* const k = i + (j - i) / 2;
-        assert(k < jj);
-
-        pCP = *k;
-        assert(pCP);
-
-        const long long t = pCP->GetTime(m_pSegment);
-
-        if (t <= time_ns)
-            i = k + 1;
-        else
-            j = k;
-
-        assert(i <= j);
-    }
-
-    assert(i == j);
-    assert(i <= jj);
-
-    if (i >= jj)  //time_ns is greater than max cue point
-        return false;
-
-    pCP = *i;
-    assert(pCP);
-    assert(pCP->GetTime(m_pSegment) > time_ns);
-
-    pTP = pCP->Find(pTrack);
-    return (pTP != NULL);
-}
-#endif
-
 const CuePoint* Cues::GetFirst() const {
   if (m_cue_points == NULL)
     return NULL;
 
   if (m_count == 0)
     return NULL;
 
-#if 0
-    LoadCuePoint();  //init cues
-
-    const size_t count = m_count + m_preload_count;
-
-    if (count == 0)  //weird
-        return NULL;
-#endif
-
   CuePoint* const* const pp = m_cue_points;
   assert(pp);
 
   CuePoint* const pCP = pp[0];
   assert(pCP);
   assert(pCP->GetTimeCode() >= 0);
 
   return pCP;
 }
 
 const CuePoint* Cues::GetLast() const {
   if (m_cue_points == NULL)
     return NULL;
 
   if (m_count <= 0)
     return NULL;
 
-#if 0
-    LoadCuePoint();  //init cues
-
-    const size_t count = m_count + m_preload_count;
-
-    if (count == 0)  //weird
-        return NULL;
-
-    const size_t index = count - 1;
-
-    CuePoint* const* const pp = m_cue_points;
-    assert(pp);
-
-    CuePoint* const pCP = pp[index];
-    assert(pCP);
-
-    pCP->Load(m_pSegment->m_pReader);
-    assert(pCP->GetTimeCode() >= 0);
-#else
   const long index = m_count - 1;
 
   CuePoint* const* const pp = m_cue_points;
   assert(pp);
 
   CuePoint* const pCP = pp[index];
   assert(pCP);
   assert(pCP->GetTimeCode() >= 0);
-#endif
 
   return pCP;
 }
 
 const CuePoint* Cues::GetNext(const CuePoint* pCurr) const {
   if (pCurr == NULL)
     return NULL;
 
   assert(pCurr->GetTimeCode() >= 0);
   assert(m_cue_points);
   assert(m_count >= 1);
 
-#if 0
-    const size_t count = m_count + m_preload_count;
-
-    size_t index = pCurr->m_index;
-    assert(index < count);
-
-    CuePoint* const* const pp = m_cue_points;
-    assert(pp);
-    assert(pp[index] == pCurr);
-
-    ++index;
-
-    if (index >= count)
-        return NULL;
-
-    CuePoint* const pNext = pp[index];
-    assert(pNext);
-
-    pNext->Load(m_pSegment->m_pReader);
-#else
   long index = pCurr->m_index;
   assert(index < m_count);
 
   CuePoint* const* const pp = m_cue_points;
   assert(pp);
   assert(pp[index] == pCurr);
 
   ++index;
 
   if (index >= m_count)
     return NULL;
 
   CuePoint* const pNext = pp[index];
   assert(pNext);
   assert(pNext->GetTimeCode() >= 0);
-#endif
 
   return pNext;
 }
 
 const BlockEntry* Cues::GetBlock(const CuePoint* pCP,
                                  const CuePoint::TrackPosition* pTP) const {
   if (pCP == NULL)
     return NULL;
 
   if (pTP == NULL)
@@ skipping 116 matching lines @@
       m_element_size(0),
       m_index(idx),
       m_timecode(-1 * pos),
       m_track_positions(NULL),
       m_track_positions_count(0) {
   assert(pos > 0);
 }
 
 CuePoint::~CuePoint() { delete[] m_track_positions; }
 
-void CuePoint::Load(IMkvReader* pReader) {
+bool CuePoint::Load(IMkvReader* pReader) {
   // odbgstream os;
   // os << "CuePoint::Load(begin): timecode=" << m_timecode << endl;
 
   if (m_timecode >= 0)  // already loaded
-    return;
+    return true;
 
   assert(m_track_positions == NULL);
   assert(m_track_positions_count == 0);
 
   long long pos_ = -m_timecode;
   const long long element_start = pos_;
 
   long long stop;
 
   {
     long len;
 
     const long long id = ReadUInt(pReader, pos_, len);
     assert(id == 0x3B);  // CuePoint ID
     if (id != 0x3B)
-      return;
+      return false;
 
     pos_ += len;  // consume ID
 
     const long long size = ReadUInt(pReader, pos_, len);
     assert(size >= 0);
 
     pos_ += len;  // consume Size field
     // pos_ now points to start of payload
 
     stop = pos_ + size;
   }
 
   const long long element_size = stop - element_start;
 
   long long pos = pos_;
 
   // First count number of track positions
 
   while (pos < stop) {
     long len;
 
     const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);  // TODO
-    assert((pos + len) <= stop);
+    if ((id < 0) || (pos + len > stop)) {
+      return false;
+    }
 
     pos += len;  // consume ID
 
     const long long size = ReadUInt(pReader, pos, len);
-    assert(size >= 0);
-    assert((pos + len) <= stop);
+    if ((size < 0) || (pos + len > stop)) {
+      return false;
+    }
 
     pos += len;  // consume Size field
-    assert((pos + size) <= stop);
+    if ((pos + size) > stop) {
+      return false;
+    }
 
     if (id == 0x33)  // CueTime ID
       m_timecode = UnserializeUInt(pReader, pos, size);
 
     else if (id == 0x37)  // CueTrackPosition(s) ID
       ++m_track_positions_count;
 
     pos += size;  // consume payload
-    assert(pos <= stop);
   }
 
-  assert(m_timecode >= 0);
-  assert(m_track_positions_count > 0);
+  if (m_timecode < 0 || m_track_positions_count <= 0) {
+    return false;
+  }
 
   // os << "CuePoint::Load(cont'd): idpos=" << idpos
   //   << " timecode=" << m_timecode
   //   << endl;
 
   m_track_positions = new TrackPosition[m_track_positions_count];
 
   // Now parse track positions
 
   TrackPosition* p = m_track_positions;
   pos = pos_;
 
   while (pos < stop) {
     long len;
 
     const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);  // TODO
+    assert(id >= 0);
     assert((pos + len) <= stop);
 
     pos += len;  // consume ID
 
     const long long size = ReadUInt(pReader, pos, len);
     assert(size >= 0);
     assert((pos + len) <= stop);
 
     pos += len;  // consume Size field
     assert((pos + size) <= stop);
 
     if (id == 0x37) {  // CueTrackPosition(s) ID
       TrackPosition& tp = *p++;
-      tp.Parse(pReader, pos, size);
+      if (!tp.Parse(pReader, pos, size)) {
+        return false;
+      }
     }
 
     pos += size;  // consume payload
     assert(pos <= stop);
   }
 
   assert(size_t(p - m_track_positions) == m_track_positions_count);
 
   m_element_start = element_start;
   m_element_size = element_size;
+
+  return true;
 }
 
-void CuePoint::TrackPosition::Parse(IMkvReader* pReader, long long start_,
+bool CuePoint::TrackPosition::Parse(IMkvReader* pReader, long long start_,
                                     long long size_) {
   const long long stop = start_ + size_;
   long long pos = start_;
 
   m_track = -1;
   m_pos = -1;
   m_block = 1;  // default
 
   while (pos < stop) {
     long len;
 
     const long long id = ReadUInt(pReader, pos, len);
-    assert(id >= 0);  // TODO
-    assert((pos + len) <= stop);
+    if ((id < 0) || ((pos + len) > stop)) {
+      return false;
+    }
 
     pos += len;  // consume ID
 
     const long long size = ReadUInt(pReader, pos, len);
-    assert(size >= 0);
-    assert((pos + len) <= stop);
+    if ((size < 0) || ((pos + len) > stop)) {
+      return false;
+    }
 
     pos += len;  // consume Size field
-    assert((pos + size) <= stop);
+    if ((pos + size) > stop) {
+      return false;
+    }
 
     if (id == 0x77)  // CueTrack ID
       m_track = UnserializeUInt(pReader, pos, size);
 
     else if (id == 0x71)  // CueClusterPos ID
       m_pos = UnserializeUInt(pReader, pos, size);
 
     else if (id == 0x1378)  // CueBlockNumber
       m_block = UnserializeUInt(pReader, pos, size);
 
     pos += size;  // consume payload
-    assert(pos <= stop);
   }
 
-  assert(m_pos >= 0);
-  assert(m_track > 0);
-  // assert(m_block > 0);
+  if ((m_pos < 0) || (m_track <= 0)) {
+    return false;
+  }
+
+  return true;
 }
 
 const CuePoint::TrackPosition* CuePoint::Find(const Track* pTrack) const {
   assert(pTrack);
 
   const long long n = pTrack->GetNumber();
 
   const TrackPosition* i = m_track_positions;
   const TrackPosition* const j = i + m_track_positions_count;
 
@@ skipping 17 matching lines @@
   assert(pInfo);
 
   const long long scale = pInfo->GetTimeCodeScale();
   assert(scale >= 1);
 
   const long long time = scale * m_timecode;
 
   return time;
 }
 
-#if 0
-long long Segment::Unparsed() const
-{
-    if (m_size < 0)
-        return LLONG_MAX;
-
-    const long long stop = m_start + m_size;
-
-    const long long result = stop - m_pos;
-    assert(result >= 0);
-
-    return result;
-}
-#else
 bool Segment::DoneParsing() const {
   if (m_size < 0) {
     long long total, avail;
 
     const int status = m_pReader->Length(&total, &avail);
 
     if (status < 0)  // error
       return true;  // must assume done
 
     if (total < 0)
       return false;  // assume live stream
 
     return (m_pos >= total);
   }
 
   const long long stop = m_start + m_size;
 
   return (m_pos >= stop);
 }
-#endif
 
 const Cluster* Segment::GetFirst() const {
   if ((m_clusters == NULL) || (m_clusterCount <= 0))
     return &m_eos;
 
   Cluster* const pCluster = m_clusters[0];
   assert(pCluster);
 
   return pCluster;
 }
@@ skipping 447 matching lines @@
     if (id != 0x0F43B675) {  // not a Cluster ID
       if (size == unknown_size)
         return E_FILE_FORMAT_INVALID;
 
       pos += size;  // consume payload
       assert((segment_stop < 0) || (pos <= segment_stop));
 
       continue;
     }
 
-#if 0  // this is commented-out to support incremental cluster parsing
-        len = static_cast<long>(size);
-
-        if (element_stop > avail)
-            return E_BUFFER_NOT_FULL;
-#endif
-
     // We have a cluster.
-
     off_next = idoff;
 
     if (size != unknown_size)
       cluster_size = size;
 
     break;
   }
 
   assert(off_next > 0);  // have cluster
 
@@ skipping 223 matching lines @@
   const long k = i - 1;
 
   Cluster* const pCluster = m_clusters[k];
   assert(pCluster);
   assert(pCluster->m_index == k);
   assert(pCluster->GetTime() <= time_ns);
 
   return pCluster;
 }
 
-#if 0
-const BlockEntry* Segment::Seek(
-    long long time_ns,
-    const Track* pTrack) const
-{
-    assert(pTrack);
-
-    if ((m_clusters == NULL) || (m_clusterCount <= 0))
-        return pTrack->GetEOS();
-
-    Cluster** const i = m_clusters;
-    assert(i);
-
-    {
-        Cluster* const pCluster = *i;
-        assert(pCluster);
-        assert(pCluster->m_index == 0);  //m_clusterCount > 0
-        assert(pCluster->m_pSegment == this);
-
-        if (time_ns <= pCluster->GetTime())
-            return pCluster->GetEntry(pTrack);
-    }
-
-    Cluster** const j = i + m_clusterCount;
-
-    if (pTrack->GetType() == 2) {  //audio
-        //TODO: we could decide to use cues for this, as we do for video.
-        //But we only use it for video because looking around for a keyframe
-        //can get expensive.  Audio doesn't require anything special so a
-        //straight cluster search is good enough (we assume).
-
-        Cluster** lo = i;
-        Cluster** hi = j;
-
-        while (lo < hi)
-        {
-            //INVARIANT:
-            //[i, lo) <= time_ns
-            //[lo, hi) ?
-            //[hi, j)  > time_ns
-
-            Cluster** const mid = lo + (hi - lo) / 2;
-            assert(mid < hi);
-
-            Cluster* const pCluster = *mid;
-            assert(pCluster);
-            assert(pCluster->m_index == long(mid - m_clusters));
-            assert(pCluster->m_pSegment == this);
-
-            const long long t = pCluster->GetTime();
-
-            if (t <= time_ns)
-                lo = mid + 1;
-            else
-                hi = mid;
-
-            assert(lo <= hi);
-        }
-
-        assert(lo == hi);
-        assert(lo > i);
-        assert(lo <= j);
-
-        while (lo > i)
-        {
-            Cluster* const pCluster = *--lo;
-            assert(pCluster);
-            assert(pCluster->GetTime() <= time_ns);
-
-            const BlockEntry* const pBE = pCluster->GetEntry(pTrack);
-
-            if ((pBE != 0) && !pBE->EOS())
-                return pBE;
-
-            //landed on empty cluster (no entries)
-        }
-
-        return pTrack->GetEOS();  //weird
-    }
-
-    assert(pTrack->GetType() == 1);  //video
-
-    Cluster** lo = i;
-    Cluster** hi = j;
-
-    while (lo < hi)
-    {
-        //INVARIANT:
-        //[i, lo) <= time_ns
-        //[lo, hi) ?
-        //[hi, j)  > time_ns
-
-        Cluster** const mid = lo + (hi - lo) / 2;
-        assert(mid < hi);
-
-        Cluster* const pCluster = *mid;
-        assert(pCluster);
-
-        const long long t = pCluster->GetTime();
-
-        if (t <= time_ns)
-            lo = mid + 1;
-        else
-            hi = mid;
-
-        assert(lo <= hi);
-    }
-
-    assert(lo == hi);
-    assert(lo > i);
-    assert(lo <= j);
-
-    Cluster* pCluster = *--lo;
-    assert(pCluster);
-    assert(pCluster->GetTime() <= time_ns);
-
-    {
-        const BlockEntry* const pBE = pCluster->GetEntry(pTrack, time_ns);
-
-        if ((pBE != 0) && !pBE->EOS())  //found a keyframe
-            return pBE;
-    }
-
-    const VideoTrack* const pVideo = static_cast<const VideoTrack*>(pTrack);
-
-    while (lo != i)
-    {
-        pCluster = *--lo;
-        assert(pCluster);
-        assert(pCluster->GetTime() <= time_ns);
-
-        const BlockEntry* const pBlockEntry = pCluster->GetMaxKey(pVideo);
-
-        if ((pBlockEntry != 0) && !pBlockEntry->EOS())
-            return pBlockEntry;
-    }
-
-    //weird: we're on the first cluster, but no keyframe found
-    //should never happen but we must return something anyway
-
-    return pTrack->GetEOS();
-}
-#endif
-
-#if 0
-bool Segment::SearchCues(
-    long long time_ns,
-    Track* pTrack,
-    Cluster*& pCluster,
-    const BlockEntry*& pBlockEntry,
-    const CuePoint*& pCP,
-    const CuePoint::TrackPosition*& pTP)
-{
-    if (pTrack->GetType() != 1)  //not video
-        return false;  //TODO: for now, just handle video stream
-
-    if (m_pCues == NULL)
-        return false;
-
-    if (!m_pCues->Find(time_ns, pTrack, pCP, pTP))
-        return false;  //weird
-
-    assert(pCP);
-    assert(pTP);
-    assert(pTP->m_track == pTrack->GetNumber());
-
-    //We have the cue point and track position we want,
-    //so we now need to search for the cluster having
-    //the indicated position.
-
-    return GetCluster(pCP, pTP, pCluster, pBlockEntry);
-}
-#endif
-
 const Tracks* Segment::GetTracks() const { return m_pTracks; }
-
 const SegmentInfo* Segment::GetInfo() const { return m_pInfo; }
-
 const Cues* Segment::GetCues() const { return m_pCues; }
-
 const Chapters* Segment::GetChapters() const { return m_pChapters; }
-
+const Tags* Segment::GetTags() const { return m_pTags; }
 const SeekHead* Segment::GetSeekHead() const { return m_pSeekHead; }
 
 long long Segment::GetDuration() const {
   assert(m_pInfo);
   return m_pInfo->GetDuration();
 }
 
 Chapters::Chapters(Segment* pSegment, long long payload_start,
                    long long payload_size, long long element_start,
                    long long element_size)
     : m_pSegment(pSegment),
       m_start(payload_start),
       m_size(payload_size),
       m_element_start(element_start),
       m_element_size(element_size),
       m_editions(NULL),
       m_editions_size(0),
       m_editions_count(0) {}
 
 Chapters::~Chapters() {
   while (m_editions_count > 0) {
     Edition& e = m_editions[--m_editions_count];
     e.Clear();
   }
+  delete[] m_editions;
 }
 
 long Chapters::Parse() {
   IMkvReader* const pReader = m_pSegment->m_pReader;
 
   long long pos = m_start;  // payload start
   const long long stop = pos + m_size;  // payload stop
 
   while (pos < stop) {
     long long id, size;
@@ skipping 255 matching lines @@
       status = ParseDisplay(pReader, pos, size);
 
       if (status < 0)  // error
         return status;
     } else if (id == 0x1654) {  // StringUID ID
       status = UnserializeString(pReader, pos, size, m_string_uid);
 
       if (status < 0)  // error
         return status;
     } else if (id == 0x33C4) {  // UID ID
-      const long long val = UnserializeUInt(pReader, pos, size);
+      long long val;
+      status = UnserializeInt(pReader, pos, size, val);
 
-      if (val < 0)  // error
-        return static_cast<long>(val);
+      if (status < 0)  // error
+        return status;
 
-      m_uid = val;
+      m_uid = static_cast<unsigned long long>(val);
     } else if (id == 0x11) {  // TimeStart ID
       const long long val = UnserializeUInt(pReader, pos, size);
 
       if (val < 0)  // error
         return static_cast<long>(val);
 
       m_start_timecode = val;
     } else if (id == 0x12) {  // TimeEnd ID
       const long long val = UnserializeUInt(pReader, pos, size);
 
@@ skipping 103 matching lines @@
 
   delete[] m_country;
   m_country = NULL;
 }
 
 long Chapters::Display::Parse(IMkvReader* pReader, long long pos,
                               long long size) {
   const long long stop = pos + size;
 
   while (pos < stop) {
+    long long id, size;
+
+    long status = ParseElementHeader(pReader, pos, stop, id, size);
+
+    if (status < 0)  // error
+      return status;
+
+    if (size == 0)  // weird
+      continue;
+
+    if (id == 0x05) {  // ChapterString ID
+      status = UnserializeString(pReader, pos, size, m_string);
+
+      if (status)
+        return status;
+    } else if (id == 0x037C) {  // ChapterLanguage ID
+      status = UnserializeString(pReader, pos, size, m_language);
+
+      if (status)
+        return status;
+    } else if (id == 0x037E) {  // ChapterCountry ID
+      status = UnserializeString(pReader, pos, size, m_country);
+
+      if (status)
+        return status;
+    }
+
+    pos += size;
+    assert(pos <= stop);
+  }
+
+  assert(pos == stop);
+  return 0;
+}
+
+Tags::Tags(Segment* pSegment, long long payload_start, long long payload_size,
+           long long element_start, long long element_size)
+    : m_pSegment(pSegment),
+      m_start(payload_start),
+      m_size(payload_size),
+      m_element_start(element_start),
+      m_element_size(element_size),
+      m_tags(NULL),
+      m_tags_size(0),
+      m_tags_count(0) {}
+
+Tags::~Tags() {
+  while (m_tags_count > 0) {
+    Tag& t = m_tags[--m_tags_count];
+    t.Clear();
+  }
+  delete[] m_tags;
+}
+
+long Tags::Parse() {
+  IMkvReader* const pReader = m_pSegment->m_pReader;
+
+  long long pos = m_start;  // payload start
+  const long long stop = pos + m_size;  // payload stop
+
+  while (pos < stop) {
+    long long id, size;
+
+    long status = ParseElementHeader(pReader, pos, stop, id, size);
+
+    if (status < 0)
+      return status;
+
+    if (size == 0)  // 0 length tag, read another
+      continue;
+
+    if (id == 0x3373) {  // Tag ID
+      status = ParseTag(pos, size);
+
+      if (status < 0)
+        return status;
+    }
+
+    pos += size;
+    assert(pos <= stop);
+    if (pos > stop)
+      return -1;
+  }
+
+  assert(pos == stop);
+  if (pos != stop)
+    return -1;
+
+  return 0;
+}
+
+int Tags::GetTagCount() const { return m_tags_count; }
+
+const Tags::Tag* Tags::GetTag(int idx) const {
+  if (idx < 0)
+    return NULL;
+
+  if (idx >= m_tags_count)
+    return NULL;
+
+  return m_tags + idx;
+}
+
+bool Tags::ExpandTagsArray() {
+  if (m_tags_size > m_tags_count)
+    return true;  // nothing else to do
+
+  const int size = (m_tags_size == 0) ? 1 : 2 * m_tags_size;
+
+  Tag* const tags = new (std::nothrow) Tag[size];
+
+  if (tags == NULL)
+    return false;
+
+  for (int idx = 0; idx < m_tags_count; ++idx) {
+    m_tags[idx].ShallowCopy(tags[idx]);
+  }
+
+  delete[] m_tags;
+  m_tags = tags;
+
+  m_tags_size = size;
+  return true;
+}
+
+long Tags::ParseTag(long long pos, long long size) {
+  if (!ExpandTagsArray())
+    return -1;
+
+  Tag& t = m_tags[m_tags_count++];
+  t.Init();
+
+  return t.Parse(m_pSegment->m_pReader, pos, size);
+}
+
+Tags::Tag::Tag() {}
+
+Tags::Tag::~Tag() {}
+
+int Tags::Tag::GetSimpleTagCount() const { return m_simple_tags_count; }
+
+const Tags::SimpleTag* Tags::Tag::GetSimpleTag(int index) const {
+  if (index < 0)
+    return NULL;
+
+  if (index >= m_simple_tags_count)
+    return NULL;
+
+  return m_simple_tags + index;
+}
+
+void Tags::Tag::Init() {
+  m_simple_tags = NULL;
+  m_simple_tags_size = 0;
+  m_simple_tags_count = 0;
+}
+
+void Tags::Tag::ShallowCopy(Tag& rhs) const {
+  rhs.m_simple_tags = m_simple_tags;
+  rhs.m_simple_tags_size = m_simple_tags_size;
+  rhs.m_simple_tags_count = m_simple_tags_count;
+}
+
+void Tags::Tag::Clear() {
+  while (m_simple_tags_count > 0) {
+    SimpleTag& d = m_simple_tags[--m_simple_tags_count];
+    d.Clear();
+  }
+
+  delete[] m_simple_tags;
+  m_simple_tags = NULL;
+
+  m_simple_tags_size = 0;
+}
+
+long Tags::Tag::Parse(IMkvReader* pReader, long long pos, long long size) {
+  const long long stop = pos + size;
+
+  while (pos < stop) {
+    long long id, size;
+
+    long status = ParseElementHeader(pReader, pos, stop, id, size);
+
+    if (status < 0)
+      return status;
+
+    if (size == 0)  // 0 length tag, read another
+      continue;
+
+    if (id == 0x27C8) {  // SimpleTag ID
+      status = ParseSimpleTag(pReader, pos, size);
+
+      if (status < 0)
+        return status;
+    }
+
+    pos += size;
+    assert(pos <= stop);
+    if (pos > stop)
+      return -1;
+  }
+
+  assert(pos == stop);
+  if (pos != stop)
+    return -1;
+  return 0;
+}
+
+long Tags::Tag::ParseSimpleTag(IMkvReader* pReader, long long pos,
+                               long long size) {
+  if (!ExpandSimpleTagsArray())
+    return -1;
+
+  SimpleTag& st = m_simple_tags[m_simple_tags_count++];
+  st.Init();
+
+  return st.Parse(pReader, pos, size);
+}
+
+bool Tags::Tag::ExpandSimpleTagsArray() {
+  if (m_simple_tags_size > m_simple_tags_count)
+    return true;  // nothing else to do
+
+  const int size = (m_simple_tags_size == 0) ? 1 : 2 * m_simple_tags_size;
+
+  SimpleTag* const displays = new (std::nothrow) SimpleTag[size];
+
+  if (displays == NULL)
+    return false;
+
+  for (int idx = 0; idx < m_simple_tags_count; ++idx) {
+    m_simple_tags[idx].ShallowCopy(displays[idx]);
+  }
+
+  delete[] m_simple_tags;
+  m_simple_tags = displays;
+
+  m_simple_tags_size = size;
+  return true;
+}
+
+Tags::SimpleTag::SimpleTag() {}
+
+Tags::SimpleTag::~SimpleTag() {}
+
+const char* Tags::SimpleTag::GetTagName() const { return m_tag_name; }
+
+const char* Tags::SimpleTag::GetTagString() const { return m_tag_string; }
+
+void Tags::SimpleTag::Init() {
+  m_tag_name = NULL;
+  m_tag_string = NULL;
+}
+
+void Tags::SimpleTag::ShallowCopy(SimpleTag& rhs) const {
+  rhs.m_tag_name = m_tag_name;
+  rhs.m_tag_string = m_tag_string;
+}
+
+void Tags::SimpleTag::Clear() {
+  delete[] m_tag_name;
+  m_tag_name = NULL;
+
+  delete[] m_tag_string;
+  m_tag_string = NULL;
+}
+
+long Tags::SimpleTag::Parse(IMkvReader* pReader, long long pos,
+                            long long size) {
+  const long long stop = pos + size;
+
+  while (pos < stop) {
     long long id, size;
 
     long status = ParseElementHeader(pReader, pos, stop, id, size);
 
     if (status < 0)  // error
       return status;
 
     if (size == 0)  // weird
       continue;
 
-    if (id == 0x05) {  // ChapterString ID
-      status = UnserializeString(pReader, pos, size, m_string);
+    if (id == 0x5A3) {  // TagName ID
+      status = UnserializeString(pReader, pos, size, m_tag_name);
 
       if (status)
         return status;
-    } else if (id == 0x037C) {  // ChapterLanguage ID
-      status = UnserializeString(pReader, pos, size, m_language);
+    } else if (id == 0x487) {  // TagString ID
+      status = UnserializeString(pReader, pos, size, m_tag_string);
 
       if (status)
         return status;
-    } else if (id == 0x037E) {  // ChapterCountry ID
-      status = UnserializeString(pReader, pos, size, m_country);
-
-      if (status)
-        return status;
     }
 
     pos += size;
     assert(pos <= stop);
+    if (pos > stop)
+      return -1;
   }
 
   assert(pos == stop);
+  if (pos != stop)
+    return -1;
   return 0;
 }
 
 SegmentInfo::SegmentInfo(Segment* pSegment, long long start, long long size_,
                          long long element_start, long long element_size)
     : m_pSegment(pSegment),
       m_start(start),
       m_size(size_),
       m_element_start(element_start),
       m_element_size(element_size),
@@ skipping 149 matching lines @@
 
   while (enc_i != enc_j) {
     ContentEncryption* const enc = *enc_i++;
     delete enc;
   }
 
   delete[] encryption_entries_;
 }
 
 const ContentEncoding::ContentCompression*
-ContentEncoding::GetCompressionByIndex(unsigned long idx) const {
+    ContentEncoding::GetCompressionByIndex(unsigned long idx) const {
   const ptrdiff_t count = compression_entries_end_ - compression_entries_;
   assert(count >= 0);
 
   if (idx >= static_cast<unsigned long>(count))
     return NULL;
 
   return compression_entries_[idx];
 }
 
 unsigned long ContentEncoding::GetCompressionCount() const {
@@ skipping 75 matching lines @@
 
     pos += size;  // consume payload
     assert(pos <= stop);
   }
 
   if (compression_count <= 0 && encryption_count <= 0)
     return -1;
 
   if (compression_count > 0) {
     compression_entries_ =
-        new (std::nothrow) ContentCompression* [compression_count];
+        new (std::nothrow) ContentCompression*[compression_count];
     if (!compression_entries_)
       return -1;
     compression_entries_end_ = compression_entries_;
   }
 
   if (encryption_count > 0) {
     encryption_entries_ =
-        new (std::nothrow) ContentEncryption* [encryption_count];
+        new (std::nothrow) ContentEncryption*[encryption_count];
     if (!encryption_entries_) {
       delete[] compression_entries_;
       return -1;
     }
     encryption_entries_end_ = encryption_entries_;
   }
 
   pos = start;
   while (pos < stop) {
     long long id, size;
@@ skipping 120 matching lines @@
     if (status < 0)  // error
       return status;
 
     if (id == 0x7E1) {
       // ContentEncAlgo
       encryption->algo = UnserializeUInt(pReader, pos, size);
       if (encryption->algo != 5)
         return E_FILE_FORMAT_INVALID;
     } else if (id == 0x7E2) {
       // ContentEncKeyID
-      delete[] encryption -> key_id;
+      delete[] encryption->key_id;
       encryption->key_id = NULL;
       encryption->key_id_len = 0;
 
       if (size <= 0)
         return E_FILE_FORMAT_INVALID;
 
       const size_t buflen = static_cast<size_t>(size);
       typedef unsigned char* buf_t;
       const buf_t buf = new (std::nothrow) unsigned char[buflen];
       if (buf == NULL)
         return -1;
 
       const int read_status =
           pReader->Read(pos, static_cast<long>(buflen), buf);
       if (read_status) {
         delete[] buf;
         return status;
       }
 
       encryption->key_id = buf;
       encryption->key_id_len = buflen;
     } else if (id == 0x7E3) {
       // ContentSignature
-      delete[] encryption -> signature;
+      delete[] encryption->signature;
       encryption->signature = NULL;
       encryption->signature_len = 0;
 
       if (size <= 0)
         return E_FILE_FORMAT_INVALID;
 
       const size_t buflen = static_cast<size_t>(size);
       typedef unsigned char* buf_t;
       const buf_t buf = new (std::nothrow) unsigned char[buflen];
       if (buf == NULL)
         return -1;
 
       const int read_status =
           pReader->Read(pos, static_cast<long>(buflen), buf);
       if (read_status) {
         delete[] buf;
         return status;
       }
 
       encryption->signature = buf;
       encryption->signature_len = buflen;
     } else if (id == 0x7E4) {
       // ContentSigKeyID
-      delete[] encryption -> sig_key_id;
+      delete[] encryption->sig_key_id;
       encryption->sig_key_id = NULL;
       encryption->sig_key_id_len = 0;
 
       if (size <= 0)
         return E_FILE_FORMAT_INVALID;
 
       const size_t buflen = static_cast<size_t>(size);
       typedef unsigned char* buf_t;
       const buf_t buf = new (std::nothrow) unsigned char[buflen];
       if (buf == NULL)
@@ skipping 219 matching lines @@
 long Track::GetFirst(const BlockEntry*& pBlockEntry) const {
   const Cluster* pCluster = m_pSegment->GetFirst();
 
   for (int i = 0;;) {
     if (pCluster == NULL) {
       pBlockEntry = GetEOS();
       return 1;
     }
 
     if (pCluster->EOS()) {
-#if 0
-            if (m_pSegment->Unparsed() <= 0) {  //all clusters have been loaded
-                pBlockEntry = GetEOS();
-                return 1;
-            }
-#else
       if (m_pSegment->DoneParsing()) {
         pBlockEntry = GetEOS();
         return 1;
       }
-#endif
 
       pBlockEntry = 0;
       return E_BUFFER_NOT_FULL;
     }
 
     long status = pCluster->GetFirst(pBlockEntry);
 
     if (status < 0)  // error
       return status;
 
@@ skipping 76 matching lines @@
     }
 
     pCluster = m_pSegment->GetNext(pCluster);
 
     if (pCluster == NULL) {
       pNextEntry = GetEOS();
       return 1;
     }
 
     if (pCluster->EOS()) {
-#if 0
-            if (m_pSegment->Unparsed() <= 0)   //all clusters have been loaded
-            {
-                pNextEntry = GetEOS();
-                return 1;
-            }
-#else
       if (m_pSegment->DoneParsing()) {
         pNextEntry = GetEOS();
         return 1;
       }
-#endif
 
       // TODO: there is a potential O(n^2) problem here: we tell the
       // caller to (pre)load another cluster, which he does, but then he
       // calls GetNext again, which repeats the same search.  This is
       // a pathological case, since the only way it can happen is if
       // there exists a long sequence of clusters none of which contain a
       // block from this track.  One way around this problem is for the
       // caller to be smarter when he loads another cluster: don't call
       // us back until you have a cluster that contains a block from this
       // track. (Of course, that's not cheap either, since our caller
@@ skipping 161 matching lines @@
     if (id == 0x2240)  // ContentEncoding ID
       ++count;
 
     pos += size;  // consume payload
     assert(pos <= stop);
   }
 
   if (count <= 0)
     return -1;
 
-  content_encoding_entries_ = new (std::nothrow) ContentEncoding* [count];
+  content_encoding_entries_ = new (std::nothrow) ContentEncoding*[count];
   if (!content_encoding_entries_)
     return -1;
 
   content_encoding_entries_end_ = content_encoding_entries_;
 
   pos = start;
   while (pos < stop) {
     long long id, size;
     long status = ParseElementHeader(pReader, pos, stop, id, size);
     if (status < 0)  // error
@@ skipping 38 matching lines @@
                        long long element_start, long long element_size,
                        VideoTrack*& pResult) {
   if (pResult)
     return -1;
 
   if (info.type != Track::kVideo)
     return -1;
 
   long long width = 0;
   long long height = 0;
+  long long display_width = 0;
+  long long display_height = 0;
+  long long display_unit = 0;
+  long long stereo_mode = 0;
+
   double rate = 0.0;
 
   IMkvReader* const pReader = pSegment->m_pReader;
 
   const Settings& s = info.settings;
   assert(s.start >= 0);
   assert(s.size >= 0);
 
   long long pos = s.start;
   assert(pos >= 0);
@@ skipping 11 matching lines @@
     if (id == 0x30) {  // pixel width
       width = UnserializeUInt(pReader, pos, size);
 
       if (width <= 0)
         return E_FILE_FORMAT_INVALID;
     } else if (id == 0x3A) {  // pixel height
       height = UnserializeUInt(pReader, pos, size);
 
       if (height <= 0)
         return E_FILE_FORMAT_INVALID;
+    } else if (id == 0x14B0) {  // display width
+      display_width = UnserializeUInt(pReader, pos, size);
+
+      if (display_width <= 0)
+        return E_FILE_FORMAT_INVALID;
+    } else if (id == 0x14BA) {  // display height
+      display_height = UnserializeUInt(pReader, pos, size);
+
+      if (display_height <= 0)
+        return E_FILE_FORMAT_INVALID;
+    } else if (id == 0x14B2) {  // display unit
+      display_unit = UnserializeUInt(pReader, pos, size);
+
+      if (display_unit < 0)
+        return E_FILE_FORMAT_INVALID;
+    } else if (id == 0x13B8) {  // stereo mode
+      stereo_mode = UnserializeUInt(pReader, pos, size);
+
+      if (stereo_mode < 0)
+        return E_FILE_FORMAT_INVALID;
     } else if (id == 0x0383E3) {  // frame rate
       const long status = UnserializeFloat(pReader, pos, size, rate);
 
       if (status < 0)
         return status;
 
       if (rate <= 0)
         return E_FILE_FORMAT_INVALID;
     }
 
@@ skipping 11 matching lines @@
 
   const int status = info.Copy(pTrack->m_info);
 
   if (status) {  // error
     delete pTrack;
     return status;
   }
 
   pTrack->m_width = width;
   pTrack->m_height = height;
+  pTrack->m_display_width = display_width;
+  pTrack->m_display_height = display_height;
+  pTrack->m_display_unit = display_unit;
+  pTrack->m_stereo_mode = stereo_mode;
   pTrack->m_rate = rate;
 
   pResult = pTrack;
   return 0;  // success
 }
 
 bool VideoTrack::VetEntry(const BlockEntry* pBlockEntry) const {
   return Track::VetEntry(pBlockEntry) && pBlockEntry->GetBlock()->IsKey();
 }
 
@@ skipping 66 matching lines @@
   pResult = pCluster->GetEntry(this, time_ns);
 
   if ((pResult != 0) && !pResult->EOS())  // found a keyframe
     return 0;
 
   while (lo != i) {
     pCluster = *--lo;
     assert(pCluster);
     assert(pCluster->GetTime() <= time_ns);
 
-#if 0
-        //TODO:
-        //We need to handle the case when a cluster
-        //contains multiple keyframes.  Simply returning
-        //the largest keyframe on the cluster isn't
-        //good enough.
-        pResult = pCluster->GetMaxKey(this);
-#else
     pResult = pCluster->GetEntry(this, time_ns);
-#endif
 
     if ((pResult != 0) && !pResult->EOS())
       return 0;
   }
 
   // weird: we're on the first cluster, but no keyframe found
   // should never happen but we must return something anyway
 
   pResult = GetEOS();
   return 0;
 }
 
 long long VideoTrack::GetWidth() const { return m_width; }
 
 long long VideoTrack::GetHeight() const { return m_height; }
 
+long long VideoTrack::GetDisplayWidth() const {
+  return m_display_width > 0 ? m_display_width : GetWidth();
+}
+
+long long VideoTrack::GetDisplayHeight() const {
+  return m_display_height > 0 ? m_display_height : GetHeight();
+}
+
+long long VideoTrack::GetDisplayUnit() const { return m_display_unit; }
+
+long long VideoTrack::GetStereoMode() const { return m_stereo_mode; }
+
 double VideoTrack::GetFrameRate() const { return m_rate; }
 
 AudioTrack::AudioTrack(Segment* pSegment, long long element_start,
                        long long element_size)
     : Track(pSegment, element_start, element_size) {}
 
 long AudioTrack::Parse(Segment* pSegment, const Info& info,
                        long long element_start, long long element_size,
                        AudioTrack*& pResult) {
   if (pResult)
@@ skipping 114 matching lines @@
 
     pos += size;  // consume payload
     assert(pos <= stop);
   }
 
   assert(pos == stop);
 
   if (count <= 0)
     return 0;  // success
 
-  m_trackEntries = new (std::nothrow) Track* [count];
+  m_trackEntries = new (std::nothrow) Track*[count];
 
   if (m_trackEntries == NULL)
     return -1;
 
   m_trackEntriesEnd = m_trackEntries;
 
   pos = m_start;
 
   while (pos < stop) {
     const long long element_start = pos;
@@ skipping 262 matching lines @@
       pResult->ParseContentEncodingsEntry(e.start, e.size);
   } else {
     // neither video nor audio - probably metadata or subtitles
 
     if (a.start >= 0)
       return E_FILE_FORMAT_INVALID;
 
     if (v.start >= 0)
       return E_FILE_FORMAT_INVALID;
 
-    if (e.start >= 0)
+    if (info.type == Track::kMetadata && e.start >= 0)
       return E_FILE_FORMAT_INVALID;
 
     info.settings.start = -1;
     info.settings.size = 0;
 
     Track* pTrack = NULL;
 
     const long status =
         Track::Create(m_pSegment, info, element_start, element_size, pTrack);
 
@@ skipping 41 matching lines @@
 
 const Track* Tracks::GetTrackByIndex(unsigned long idx) const {
   const ptrdiff_t count = m_trackEntriesEnd - m_trackEntries;
 
   if (idx >= static_cast<unsigned long>(count))
     return NULL;
 
   return m_trackEntries[idx];
 }
 
-#if 0
-long long Cluster::Unparsed() const
-{
-    if (m_timecode < 0)  //not even partially loaded
-        return LLONG_MAX;
-
-    assert(m_pos >= m_element_start);
-    //assert(m_element_size > m_size);
-
-    const long long element_stop = m_element_start + m_element_size;
-    assert(m_pos <= element_stop);
-
-    const long long result = element_stop - m_pos;
-    assert(result >= 0);
-
-    return result;
-}
-#endif
-
 long Cluster::Load(long long& pos, long& len) const {
   assert(m_pSegment);
   assert(m_pos >= m_element_start);
 
   if (m_timecode >= 0)  // at least partially loaded
     return 0;
 
   assert(m_pos == m_element_start);
   assert(m_element_size < 0);
 
@@ skipping 73 matching lines @@
       return E_FILE_FORMAT_INVALID;  // TODO: verify this
 
     pos += len;  // consume length of size of element
 
     const long long unknown_size = (1LL << (7 * len)) - 1;
 
     if (size != unknown_size)
       cluster_size = size;
   }
 
-// pos points to start of payload
-
-#if 0
-    len = static_cast<long>(size_);
-
-    if (cluster_stop > avail)
-        return E_BUFFER_NOT_FULL;
-#endif
-
+  // pos points to start of payload
   long long timecode = -1;
   long long new_pos = -1;
   bool bBlock = false;
 
   long long cluster_stop = (cluster_size < 0) ? -1 : pos + cluster_size;
 
   for (;;) {
     if ((cluster_stop >= 0) && (pos >= cluster_stop))
       break;
 
@@ skipping 351 matching lines @@
     return E_BUFFER_NOT_FULL;
 
   const long long track = ReadUInt(pReader, pos, len);
 
   if (track < 0)  // error
     return static_cast<long>(track);
 
   if (track == 0)
     return E_FILE_FORMAT_INVALID;
 
-#if 0
-    //TODO(matthewjheaney)
-    //This turned out to be too conservative.  The problem is that
-    //if we see a track header in the tracks element with an unsupported
-    //track type, we throw that track header away, so it is not present
-    //in the track map.  But even though we don't understand the track
-    //header, there are still blocks in the cluster with that track
-    //number.  It was our decision to ignore that track header, so it's
-    //up to us to deal with blocks associated with that track -- we
-    //cannot simply report an error since technically there's nothing
-    //wrong with the file.
-    //
-    //For now we go ahead and finish the parse, creating a block entry
-    //for this block.  This is somewhat wasteful, because without a
-    //track header there's nothing you can do with the block. What
-    //we really need here is a special return value that indicates to
-    //the caller that he should ignore this particular block, and
-    //continue parsing.
-
-    const Tracks* const pTracks = m_pSegment->GetTracks();
-    assert(pTracks);
-
-    const long tn = static_cast<long>(track);
-
-    const Track* const pTrack = pTracks->GetTrackByNumber(tn);
-
-    if (pTrack == NULL)
-        return E_FILE_FORMAT_INVALID;
-#endif
-
   pos += len;  // consume track number
 
   if ((pos + 2) > block_stop)
     return E_FILE_FORMAT_INVALID;
 
   if ((pos + 2) > avail) {
     len = 2;
     return E_BUFFER_NOT_FULL;
   }
 
@@ skipping 134 matching lines @@
 
     if (size == 0)  // weird
       continue;
 
     const long long unknown_size = (1LL << (7 * len)) - 1;
 
     if (size == unknown_size)
       return E_FILE_FORMAT_INVALID;
 
     if (id == 0x35A2) {  // DiscardPadding
-      result = GetUIntLength(pReader, pos, len);
-
-      if (result < 0)  // error
-        return static_cast<long>(result);
-
-      status = UnserializeInt(pReader, pos, len, discard_padding);
+      status = UnserializeInt(pReader, pos, size, discard_padding);
 
       if (status < 0)  // error
         return status;
     }
 
     if (id != 0x21) {  // sub-part of BlockGroup is not a Block
       pos += size;  // consume sub-part of block group
 
       if (pos > payload_stop)
         return E_FILE_FORMAT_INVALID;
@@ skipping 28 matching lines @@
       return E_BUFFER_NOT_FULL;
 
     const long long track = ReadUInt(pReader, pos, len);
 
     if (track < 0)  // error
       return static_cast<long>(track);
 
     if (track == 0)
       return E_FILE_FORMAT_INVALID;
 
-#if 0
-        //TODO(matthewjheaney)
-        //This turned out to be too conservative.  The problem is that
-        //if we see a track header in the tracks element with an unsupported
-        //track type, we throw that track header away, so it is not present
-        //in the track map.  But even though we don't understand the track
-        //header, there are still blocks in the cluster with that track
-        //number.  It was our decision to ignore that track header, so it's
-        //up to us to deal with blocks associated with that track -- we
-        //cannot simply report an error since technically there's nothing
-        //wrong with the file.
-        //
-        //For now we go ahead and finish the parse, creating a block entry
-        //for this block.  This is somewhat wasteful, because without a
-        //track header there's nothing you can do with the block. What
-        //we really need here is a special return value that indicates to
-        //the caller that he should ignore this particular block, and
-        //continue parsing.
-
-        const Tracks* const pTracks = m_pSegment->GetTracks();
-        assert(pTracks);
-
-        const long tn = static_cast<long>(track);
-
-        const Track* const pTrack = pTracks->GetTrackByNumber(tn);
-
-        if (pTrack == NULL)
-            return E_FILE_FORMAT_INVALID;
-#endif
-
     pos += len;  // consume track number
 
     if ((pos + 2) > block_stop)
       return E_FILE_FORMAT_INVALID;
 
     if ((pos + 2) > avail) {
       len = 2;
       return E_BUFFER_NOT_FULL;
     }
 
@@ skipping 141 matching lines @@
 
 long long Cluster::GetPosition() const {
   const long long pos = m_element_start - m_pSegment->m_start;
   assert(pos >= 0);
 
   return pos;
 }
 
 long long Cluster::GetElementSize() const { return m_element_size; }
 
-#if 0
-bool Cluster::HasBlockEntries(
-    const Segment* pSegment,
-    long long off) {
-    assert(pSegment);
-    assert(off >= 0);  //relative to start of segment payload
-
-    IMkvReader* const pReader = pSegment->m_pReader;
-
-    long long pos = pSegment->m_start + off;  //absolute
-    long long size;
-
-    {
-        long len;
-
-        const long long id = ReadUInt(pReader, pos, len);
-        (void)id;
-        assert(id >= 0);
-        assert(id == 0x0F43B675);  //Cluster ID
-
-        pos += len;  //consume id
-
-        size = ReadUInt(pReader, pos, len);
-        assert(size > 0);
-
-        pos += len;  //consume size
-
-        //pos now points to start of payload
-    }
-
-    const long long stop = pos + size;
-
-    while (pos < stop)
-    {
-        long len;
-
-        const long long id = ReadUInt(pReader, pos, len);
-        assert(id >= 0);  //TODO
-        assert((pos + len) <= stop);
-
-        pos += len;  //consume id
-
-        const long long size = ReadUInt(pReader, pos, len);
-        assert(size >= 0);  //TODO
-        assert((pos + len) <= stop);
-
-        pos += len;  //consume size
-
-        if (id == 0x20)  //BlockGroup ID
-            return true;
-
-        if (id == 0x23)  //SimpleBlock ID
-            return true;
-
-        pos += size;  //consume payload
-        assert(pos <= stop);
-    }
-
-    return false;
-}
-#endif
-
 long Cluster::HasBlockEntries(
     const Segment* pSegment,
     long long off,  // relative to start of segment payload
     long long& pos, long& len) {
   assert(pSegment);
   assert(off >= 0);  // relative to segment
 
   IMkvReader* const pReader = pSegment->m_pReader;
 
   long long total, avail;
@@ skipping 263 matching lines @@
 long Cluster::CreateBlock(long long id,
                           long long pos,  // absolute pos of payload
                           long long size, long long discard_padding) {
   assert((id == 0x20) || (id == 0x23));  // BlockGroup or SimpleBlock
 
   if (m_entries_count < 0) {  // haven't parsed anything yet
     assert(m_entries == NULL);
     assert(m_entries_size == 0);
 
     m_entries_size = 1024;
-    m_entries = new BlockEntry* [m_entries_size];
+    m_entries = new BlockEntry*[m_entries_size];
 
     m_entries_count = 0;
   } else {
     assert(m_entries);
     assert(m_entries_size > 0);
     assert(m_entries_count <= m_entries_size);
 
     if (m_entries_count >= m_entries_size) {
       const long entries_size = 2 * m_entries_size;
 
-      BlockEntry** const entries = new BlockEntry* [entries_size];
+      BlockEntry** const entries = new BlockEntry*[entries_size];
       assert(entries);
 
       BlockEntry** src = m_entries;
       BlockEntry** const src_end = src + m_entries_count;
 
       BlockEntry** dst = entries;
 
       while (src != src_end)
         *dst++ = *src++;
 
@@ skipping 48 matching lines @@
     assert((pos + len) <= stop);
 
     pos += len;  // consume size
 
     if (id == 0x21) {  // Block ID
       if (bpos < 0) {  // Block ID
         bpos = pos;
         bsize = size;
       }
     } else if (id == 0x1B) {  // Duration ID
-      assert(size <= 8);
+      if (size > 8)
+        return E_FILE_FORMAT_INVALID;
 
       duration = UnserializeUInt(pReader, pos, size);
-      assert(duration >= 0);  // TODO
+
+      if (duration < 0)
+        return E_FILE_FORMAT_INVALID;
     } else if (id == 0x7B) {  // ReferenceBlock
-      assert(size <= 8);
+      if (size > 8 || size <= 0)
+        return E_FILE_FORMAT_INVALID;
       const long size_ = static_cast<long>(size);
 
       long long time;
 
       long status = UnserializeInt(pReader, pos, size_, time);
       assert(status == 0);
       if (status != 0)
         return -1;
 
       if (time <= 0)  // see note above
         prev = time;
       else  // weird
         next = time;
     }
 
     pos += size;  // consume payload
     assert(pos <= stop);
   }
+  if (bpos < 0)
+    return E_FILE_FORMAT_INVALID;
 
   assert(pos == stop);
-  assert(bpos >= 0);
   assert(bsize >= 0);
 
   const long idx = m_entries_count;
 
   BlockEntry** const ppEntry = m_entries + idx;
   BlockEntry*& pEntry = *ppEntry;
 
   pEntry = new (std::nothrow)
       BlockGroup(this, idx, bpos, bsize, prev, next, duration, discard_padding);
 
@@ skipping 143 matching lines @@
 
 long Cluster::GetEntryCount() const { return m_entries_count; }
 
 const BlockEntry* Cluster::GetEntry(const Track* pTrack,
                                     long long time_ns) const {
   assert(pTrack);
 
   if (m_pSegment == NULL)  // this is the special EOS cluster
     return pTrack->GetEOS();
 
-#if 0
-
-    LoadBlockEntries();
-
-    if ((m_entries == NULL) || (m_entries_count <= 0))
-        return NULL;  //return EOS here?
-
-    const BlockEntry* pResult = pTrack->GetEOS();
-
-    BlockEntry** i = m_entries;
-    assert(i);
-
-    BlockEntry** const j = i + m_entries_count;
-
-    while (i != j)
-    {
-        const BlockEntry* const pEntry = *i++;
-        assert(pEntry);
-        assert(!pEntry->EOS());
-
-        const Block* const pBlock = pEntry->GetBlock();
-        assert(pBlock);
-
-        if (pBlock->GetTrackNumber() != pTrack->GetNumber())
-            continue;
-
-        if (pTrack->VetEntry(pEntry))
-        {
-            if (time_ns < 0)  //just want first candidate block
-                return pEntry;
-
-            const long long ns = pBlock->GetTime(this);
-
-            if (ns > time_ns)
-                break;
-
-            pResult = pEntry;
-        }
-        else if (time_ns >= 0)
-        {
-            const long long ns = pBlock->GetTime(this);
-
-            if (ns > time_ns)
-                break;
-        }
-    }
-
-    return pResult;
-
-#else
-
   const BlockEntry* pResult = pTrack->GetEOS();
 
   long index = 0;
 
   for (;;) {
     if (index >= m_entries_count) {
       long long pos;
       long len;
 
       const long status = Parse(pos, len);
@@ skipping 33 matching lines @@
       pResult = pEntry;  // have a candidate
     } else if (time_ns >= 0) {
       const long long ns = pBlock->GetTime(this);
 
       if (ns > time_ns)
         return pResult;
     }
 
     ++index;
   }
-
-#endif
 }
 
 const BlockEntry* Cluster::GetEntry(const CuePoint& cp,
                                     const CuePoint::TrackPosition& tp) const {
   assert(m_pSegment);
-
-#if 0
-
-    LoadBlockEntries();
-
-    if (m_entries == NULL)
-        return NULL;
-
-    const long long count = m_entries_count;
-
-    if (count <= 0)
-        return NULL;
-
-    const long long tc = cp.GetTimeCode();
-
-    if ((tp.m_block > 0) && (tp.m_block <= count))
-    {
-        const size_t block = static_cast<size_t>(tp.m_block);
-        const size_t index = block - 1;
-
-        const BlockEntry* const pEntry = m_entries[index];
-        assert(pEntry);
-        assert(!pEntry->EOS());
-
-        const Block* const pBlock = pEntry->GetBlock();
-        assert(pBlock);
-
-        if ((pBlock->GetTrackNumber() == tp.m_track) &&
-            (pBlock->GetTimeCode(this) == tc))
-        {
-            return pEntry;
-        }
-    }
-
-    const BlockEntry* const* i = m_entries;
-    const BlockEntry* const* const j = i + count;
-
-    while (i != j)
-    {
-#ifdef _DEBUG
-        const ptrdiff_t idx = i - m_entries;
-        idx;
-#endif
-
-        const BlockEntry* const pEntry = *i++;
-        assert(pEntry);
-        assert(!pEntry->EOS());
-
-        const Block* const pBlock = pEntry->GetBlock();
-        assert(pBlock);
-
-        if (pBlock->GetTrackNumber() != tp.m_track)
-            continue;
-
-        const long long tc_ = pBlock->GetTimeCode(this);
-        assert(tc_ >= 0);
-
-        if (tc_ < tc)
-            continue;
-
-        if (tc_ > tc)
-            return NULL;
-
-        const Tracks* const pTracks = m_pSegment->GetTracks();
-        assert(pTracks);
-
-        const long tn = static_cast<long>(tp.m_track);
-        const Track* const pTrack = pTracks->GetTrackByNumber(tn);
-
-        if (pTrack == NULL)
-            return NULL;
-
-        const long long type = pTrack->GetType();
-
-        if (type == 2)  //audio
-            return pEntry;
-
-        if (type != 1)  //not video
-            return NULL;
-
-        if (!pBlock->IsKey())
-            return NULL;
-
-        return pEntry;
-    }
-
-    return NULL;
-
-#else
-
   const long long tc = cp.GetTimeCode();
 
   if (tp.m_block > 0) {
     const long block = static_cast<long>(tp.m_block);
     const long index = block - 1;
 
     while (index >= m_entries_count) {
       long long pos;
       long len;
 
@@ skipping 75 matching lines @@
       return pEntry;
 
     if (type != 1)  // not video
       return NULL;
 
     if (!pBlock->IsKey())
       return NULL;
 
     return pEntry;
   }
-
-#endif
 }
 
-#if 0
-const BlockEntry* Cluster::GetMaxKey(const VideoTrack* pTrack) const
-{
-    assert(pTrack);
-
-    if (m_pSegment == NULL)  //EOS
-        return pTrack->GetEOS();
-
-    LoadBlockEntries();
-
-    if ((m_entries == NULL) || (m_entries_count <= 0))
-        return pTrack->GetEOS();
-
-    BlockEntry** i = m_entries + m_entries_count;
-    BlockEntry** const j = m_entries;
-
-    while (i != j)
-    {
-        const BlockEntry* const pEntry = *--i;
-        assert(pEntry);
-        assert(!pEntry->EOS());
-
-        const Block* const pBlock = pEntry->GetBlock();
-        assert(pBlock);
-
-        if (pBlock->GetTrackNumber() != pTrack->GetNumber())
-            continue;
-
-        if (pBlock->IsKey())
-            return pEntry;
-    }
-
-    return pTrack->GetEOS();  //no satisfactory block found
-}
-#endif
-
 BlockEntry::BlockEntry(Cluster* p, long idx) : m_pCluster(p), m_index(idx) {}
-
 BlockEntry::~BlockEntry() {}
-
 bool BlockEntry::EOS() const { return (GetKind() == kBlockEOS); }
-
 const Cluster* BlockEntry::GetCluster() const { return m_pCluster; }
-
 long BlockEntry::GetIndex() const { return m_index; }
 
 SimpleBlock::SimpleBlock(Cluster* pCluster, long idx, long long start,
                          long long size)
     : BlockEntry(pCluster, idx), m_block(start, size, 0) {}
 
 long SimpleBlock::Parse() { return m_block.Parse(m_pCluster); }
-
 BlockEntry::Kind SimpleBlock::GetKind() const { return kBlockSimple; }
-
 const Block* SimpleBlock::GetBlock() const { return &m_block; }
 
 BlockGroup::BlockGroup(Cluster* pCluster, long idx, long long block_start,
                        long long block_size, long long prev, long long next,
                        long long duration, long long discard_padding)
     : BlockEntry(pCluster, idx),
       m_block(block_start, block_size, discard_padding),
       m_prev(prev),
       m_next(next),
       m_duration(duration) {}
 
 long BlockGroup::Parse() {
   const long status = m_block.Parse(m_pCluster);
 
   if (status)
     return status;
 
   m_block.SetKey((m_prev > 0) && (m_next <= 0));
 
   return 0;
 }
 
-#if 0
-void BlockGroup::ParseBlock(long long start, long long size)
-{
-    IMkvReader* const pReader = m_pCluster->m_pSegment->m_pReader;
-
-    Block* const pBlock = new Block(start, size, pReader);
-    assert(pBlock);  //TODO
-
-    //TODO: the Matroska spec says you have multiple blocks within the
-    //same block group, with blocks ranked by priority (the flag bits).
-
-    assert(m_pBlock == NULL);
-    m_pBlock = pBlock;
-}
-#endif
-
 BlockEntry::Kind BlockGroup::GetKind() const { return kBlockGroup; }
-
 const Block* BlockGroup::GetBlock() const { return &m_block; }
-
 long long BlockGroup::GetPrevTimeCode() const { return m_prev; }
-
 long long BlockGroup::GetNextTimeCode() const { return m_next; }
-
 long long BlockGroup::GetDurationTimeCode() const { return m_duration; }
 
 Block::Block(long long start, long long size_, long long discard_padding)
     : m_start(start),
       m_size(size_),
       m_track(0),
       m_timecode(-1),
       m_flags(0),
       m_frames(NULL),
       m_frame_count(-1),
@@ skipping 69 matching lines @@
       return E_FILE_FORMAT_INVALID;
 
     m_frame_count = 1;
     m_frames = new Frame[m_frame_count];
 
     Frame& f = m_frames[0];
     f.pos = pos;
 
     const long long frame_size = stop - pos;
 
-    if (frame_size > LONG_MAX)
+    if (frame_size > LONG_MAX || frame_size <= 0)
       return E_FILE_FORMAT_INVALID;
 
     f.len = static_cast<long>(frame_size);
 
     return 0;  // success
   }
 
   if (pos >= stop)
     return E_FILE_FORMAT_INVALID;
 
@@ skipping 39 matching lines @@
 
         if (val < 255)
           break;
       }
 
       Frame& f = *pf++;
       assert(pf < pf_end);
 
       f.pos = 0;  // patch later
 
+      if (frame_size <= 0)
+        return E_FILE_FORMAT_INVALID;
+
       f.len = frame_size;
       size += frame_size;  // contribution of this frame
 
       --frame_count;
     }
 
     assert(pf < pf_end);
     assert(pos <= stop);
 
     {
       Frame& f = *pf++;
 
       if (pf != pf_end)
         return E_FILE_FORMAT_INVALID;
 
       f.pos = 0;  // patch later
 
       const long long total_size = stop - pos;
 
       if (total_size < size)
         return E_FILE_FORMAT_INVALID;
 
       const long long frame_size = total_size - size;
 
-      if (frame_size > LONG_MAX)
+      if (frame_size > LONG_MAX || frame_size <= 0)
         return E_FILE_FORMAT_INVALID;
 
       f.len = static_cast<long>(frame_size);
     }
 
     pf = m_frames;
     while (pf != pf_end) {
       Frame& f = *pf++;
       assert((pos + f.len) <= stop);
 
       f.pos = pos;
       pos += f.len;
     }
 
     assert(pos == stop);
   } else if (lacing == 2) {  // fixed-size lacing
+    if (pos >= stop)
+      return E_FILE_FORMAT_INVALID;
+
     const long long total_size = stop - pos;
 
     if ((total_size % m_frame_count) != 0)
       return E_FILE_FORMAT_INVALID;
 
     const long long frame_size = total_size / m_frame_count;
 
-    if (frame_size > LONG_MAX)
+    if (frame_size > LONG_MAX || frame_size <= 0)
       return E_FILE_FORMAT_INVALID;
 
     Frame* pf = m_frames;
     Frame* const pf_end = pf + m_frame_count;
 
     while (pf != pf_end) {
       assert((pos + frame_size) <= stop);
 
       Frame& f = *pf++;
 
       f.pos = pos;
       f.len = static_cast<long>(frame_size);
 
       pos += frame_size;
     }
 
     assert(pos == stop);
   } else {
     assert(lacing == 3);  // EBML lacing
 
     if (pos >= stop)
       return E_FILE_FORMAT_INVALID;
 
     long size = 0;
     int frame_count = m_frame_count;
 
     long long frame_size = ReadUInt(pReader, pos, len);
 
-    if (frame_size < 0)
+    if (frame_size <= 0)
       return E_FILE_FORMAT_INVALID;
 
     if (frame_size > LONG_MAX)
       return E_FILE_FORMAT_INVALID;
 
     if ((pos + len) > stop)
       return E_FILE_FORMAT_INVALID;
 
     pos += len;  // consume length of size of first frame
 
@@ skipping 41 matching lines @@
 
       pos += len;  // consume length of (delta) size
       assert(pos <= stop);
 
       const int exp = 7 * len - 1;
       const long long bias = (1LL << exp) - 1LL;
       const long long delta_size = delta_size_ - bias;
 
       frame_size += delta_size;
 
-      if (frame_size < 0)
+      if (frame_size <= 0)
         return E_FILE_FORMAT_INVALID;
 
       if (frame_size > LONG_MAX)
         return E_FILE_FORMAT_INVALID;
 
       curr.len = static_cast<long>(frame_size);
       size += curr.len;  // contribution of this frame
 
       --frame_count;
     }
 
-    {
+    // parse last frame
+    if (frame_count > 0) {
       assert(pos <= stop);
       assert(pf < pf_end);
 
       const Frame& prev = *pf++;
       assert(prev.len == frame_size);
       if (prev.len != frame_size)
         return E_FILE_FORMAT_INVALID;
 
       assert(pf < pf_end);
 
       Frame& curr = *pf++;
       assert(pf == pf_end);
 
       curr.pos = 0;  // patch later
 
       const long long total_size = stop - pos;
 
       if (total_size < size)
         return E_FILE_FORMAT_INVALID;
 
       frame_size = total_size - size;
 
-      if (frame_size > LONG_MAX)
+      if (frame_size > LONG_MAX || frame_size <= 0)
         return E_FILE_FORMAT_INVALID;
 
       curr.len = static_cast<long>(frame_size);
     }
 
     pf = m_frames;
     while (pf != pf_end) {
       Frame& f = *pf++;
       assert((pos + f.len) <= stop);
 
       f.pos = pos;
       pos += f.len;
     }
 
-    assert(pos == stop);
+    if (pos != stop)
+      return E_FILE_FORMAT_INVALID;
   }
 
   return 0;  // success
 }
 
 long long Block::GetTimeCode(const Cluster* pCluster) const {
   if (pCluster == 0)
     return m_timecode;
 
   const long long tc0 = pCluster->GetTimeCode();
@@ skipping 58 matching lines @@
   assert(pReader);
   assert(buf);
 
   const long status = pReader->Read(pos, len, buf);
   return status;
 }
 
 long long Block::GetDiscardPadding() const { return m_discard_padding; }
 
 }  // end namespace mkvparser