Fix seekhead

Author: complexlogic

taglib/CMakeLists.txt

@@ -230,15 +230,19 @@ if(WITH_SHORTEN)
 endif()
 
 set(tag_PRIVATE_HDRS
+  matroska/matroskaseekhead.h
+  matroska/matroskasegment.h
   matroska/ebml/ebmlbinaryelement.h
   matroska/ebml/ebmlelement.h
   matroska/ebml/ebmlmasterelement.h
   matroska/ebml/ebmlmkattachments.h
+  matroska/ebml/ebmlmkseekhead.h
   matroska/ebml/ebmlmksegment.h
   matroska/ebml/ebmlmktags.h
   matroska/ebml/ebmlstringelement.h
   matroska/ebml/ebmluintelement.h
   matroska/ebml/ebmlutils.h
+  matroska/ebml/ebmlvoidelement.h
 )
 
 set(tag_HDRS ${tag_PUBLIC_HDRS} ${tag_PRIVATE_HDRS})
@@ -248,6 +252,8 @@ set(matroska_SRCS
   matroska/matroskaattachments.cpp
   matroska/matroskaelement.cpp
   matroska/matroskafile.cpp
+  matroska/matroskaseekhead.cpp
+  matroska/matroskasegment.cpp
   matroska/matroskasimpletag.cpp
   matroska/matroskatag.cpp
 )
@@ -257,11 +263,13 @@ set(ebml_SRCS
   matroska/ebml/ebmlelement.cpp
   matroska/ebml/ebmlmasterelement.cpp
   matroska/ebml/ebmlmkattachments.cpp
+  matroska/ebml/ebmlmkseekhead.cpp
   matroska/ebml/ebmlmksegment.cpp
   matroska/ebml/ebmlmktags.cpp
   matroska/ebml/ebmlstringelement.cpp
   matroska/ebml/ebmluintelement.cpp
   matroska/ebml/ebmlutils.cpp
+  matroska/ebml/ebmlvoidelement.cpp
 )
 
 set(mpeg_SRCS

taglib/matroska/ebml/ebmlelement.cpp

@@ -19,8 +19,10 @@
  ***************************************************************************/
 
 #include "ebmlelement.h"
+#include "ebmlvoidelement.h"
 #include "ebmlmasterelement.h"
 #include "ebmlbinaryelement.h"
+#include "ebmlmkseekhead.h"
 #include "ebmlmksegment.h"
 #include "ebmlmktags.h"
 #include "ebmlmkattachments.h"
@@ -68,6 +70,7 @@ EBML::Element* EBML::Element::factory(File &file)
     case ElementIDs::MkTagTargets:
     case ElementIDs::MkSimpleTag:
     case ElementIDs::MkAttachedFile:
+    case ElementIDs::MkSeek:
       return new MasterElement(id, sizeLength, dataSize, offset);
 
     case ElementIDs::MkTagName:
@@ -82,10 +85,18 @@ EBML::Element* EBML::Element::factory(File &file)
 
     case ElementIDs::MkTagTargetTypeValue:
     case ElementIDs::MkAttachedFileUID:
+    case ElementIDs::MkSeekPosition:
       return new UIntElement(id, sizeLength, dataSize);
 
     case ElementIDs::MkAttachedFileData:
+    case ElementIDs::MkSeekID:
       return new BinaryElement(id, sizeLength, dataSize);
+    
+    case ElementIDs::MkSeekHead:
+      return new MkSeekHead(sizeLength, dataSize, offset);
+
+    case ElementIDs::VoidElement:
+      return new VoidElement(sizeLength, dataSize);
 
     default:
       return new Element(id, sizeLength, dataSize);

taglib/matroska/ebml/ebmlelement.h

@@ -43,6 +43,7 @@ namespace TagLib {
       void skipData(File &file);
       Id getId() const { return id; }
       offset_t headSize() const;
+      offset_t getSize() const { return headSize() + dataSize; }
       int getSizeLength() const { return sizeLength; }
       int64_t getDataSize() const { return dataSize; }
       ByteVector renderId();
@@ -58,6 +59,7 @@ namespace TagLib {
 
     namespace ElementIDs {
       inline constexpr Element::Id EBMLHeader                = 0x1A45DFA3;
+      inline constexpr Element::Id VoidElement               = 0xEC;
       inline constexpr Element::Id MkSegment                 = 0x18538067;
       inline constexpr Element::Id MkTags                    = 0x1254C367;
       inline constexpr Element::Id MkTag                     = 0x7373;
@@ -76,6 +78,10 @@ namespace TagLib {
       inline constexpr Element::Id MkAttachedFileMediaType   = 0x4660;
       inline constexpr Element::Id MkAttachedFileData        = 0x465C;
       inline constexpr Element::Id MkAttachedFileUID         = 0x46AE;
+      inline constexpr Element::Id MkSeekHead                = 0x114D9B74;
+      inline constexpr Element::Id MkSeek                    = 0x4DBB;
+      inline constexpr Element::Id MkSeekID                  = 0x53AB;
+      inline constexpr Element::Id MkSeekPosition            = 0x53AC;
 
     }
   }

taglib/matroska/ebml/ebmlmasterelement.cpp

@@ -19,6 +19,7 @@
  ***************************************************************************/
 
 #include "ebmlmasterelement.h"
+#include "ebmlvoidelement.h"
 #include "ebmlutils.h"
 #include "matroskafile.h"
 
@@ -55,5 +56,10 @@ ByteVector EBML::MasterElement::render()
   dataSize = data.size();
   buffer.append(renderVINT(dataSize, 0));
   buffer.append(data);
+  if (minRenderSize) {
+    auto bufferSize = buffer.size();
+    if(minRenderSize >= (bufferSize + MIN_VOID_ELEMENT_SIZE))
+      buffer.append(VoidElement::renderSize(minRenderSize - bufferSize));
+  }
   return buffer;
 }

taglib/matroska/ebml/ebmlmasterelement.h

@@ -41,17 +41,23 @@ namespace TagLib {
       {}
       ~MasterElement() override;
       offset_t getOffset() const { return offset; }
-      offset_t getSize() const { return headSize() + dataSize; }
       bool read(File &file) override;
       ByteVector render() override;
       void appendElement(Element *element) { elements.append(element); }
       List<Element*>::Iterator begin () { return elements.begin(); }
       List<Element*>::Iterator end () { return elements.end(); }
       List<Element*>::ConstIterator cbegin () const { return elements.cbegin(); }
       List<Element*>::ConstIterator cend () const { return elements.cend(); }
+      offset_t getPadding() const { return padding; }
+      void setPadding(offset_t padding) { this->padding = padding; }
+      offset_t getMinRenderSize() const { return minRenderSize; }
+      void setMinRenderSize(offset_t minRenderSize) { this->minRenderSize = minRenderSize; }
+
 
     protected:
       offset_t offset;
+      offset_t padding = 0;
+      offset_t minRenderSize = 0;
       List<Element*> elements;
     };
 

taglib/matroska/ebml/ebmlmkseekhead.cpp

@@ -0,0 +1,59 @@
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   This library 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     *
+ *   Lesser General Public License for more details.                       *
+ *                                                                         *
+ *   You should have received a copy of the GNU Lesser General Public      *
+ *   License along with this library; if not, write to the Free Software   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  USA                                                       *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#include "ebmlmkseekhead.h"
+#include "matroskaseekhead.h"
+#include "ebmluintelement.h"
+#include "ebmlbinaryelement.h"
+
+using namespace TagLib;
+
+Matroska::SeekHead* EBML::MkSeekHead::parse()
+{
+  auto seekHead = new Matroska::SeekHead();
+  seekHead->setOffset(offset);
+  seekHead->setSize(getSize() + padding);
+
+  for(auto element : elements) {
+    if(element->getId() != ElementIDs::MkSeek)
+      continue;
+    auto seekElement = static_cast<MasterElement*>(element);
+    Matroska::Element::ID entryId = 0;
+    offset_t offset = 0;
+    for(auto seekElementChild : *seekElement) {
+      Id id = seekElementChild->getId();
+      if(id == ElementIDs::MkSeekID && !entryId) {
+        auto data = static_cast<BinaryElement*>(seekElementChild)->getValue();
+        if(data.size() == 4)
+          entryId = data.toUInt(true);
+      }
+      else if(id == ElementIDs::MkSeekPosition && !offset)
+        offset = static_cast<UIntElement*>(seekElementChild)->getValue();
+    }
+    if(entryId && offset)
+      seekHead->addEntry(entryId, offset);
+    else {
+      delete seekHead;
+      return nullptr;
+    }
+  }
+
+  return seekHead;
+}

taglib/matroska/ebml/ebmlmkseekhead.h

@@ -0,0 +1,49 @@
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   This library 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     *
+ *   Lesser General Public License for more details.                       *
+ *                                                                         *
+ *   You should have received a copy of the GNU Lesser General Public      *
+ *   License along with this library; if not, write to the Free Software   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  USA                                                       *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#include "ebmlmasterelement.h"
+#include "taglib.h"
+
+#ifndef TAGLIB_EBMLMKSEEKHEAD_H
+#define TAGLIB_EBMLMKSEEKHEAD_H
+#ifndef DO_NOT_DOCUMENT
+
+namespace TagLib {
+  namespace Matroska {
+    class SeekHead;
+  }
+  namespace EBML {
+    class MkSeekHead : public MasterElement
+    {
+    public:
+      MkSeekHead(int sizeLength, offset_t dataSize, offset_t offset)
+      : MasterElement(ElementIDs::MkSeekHead, sizeLength, dataSize, offset)
+      {}
+      MkSeekHead()
+      : MasterElement(ElementIDs::MkSeekHead, 0, 0, 0)
+      {}
+
+      Matroska::SeekHead* parse();
+
+    };
+  }
+}
+#endif
+#endif

taglib/matroska/ebml/ebmlmksegment.cpp

@@ -21,10 +21,13 @@
 #include "ebmlmksegment.h"
 #include "ebmlmktags.h"
 #include "ebmlmkattachments.h"
+#include "ebmlmkseekhead.h"
 #include "ebmlutils.h"
 #include "matroskafile.h"
 #include "matroskatag.h"
 #include "matroskaattachments.h"
+#include "matroskaseekhead.h"
+#include "matroskasegment.h"
 #include "tutils.h"
 #include "tbytevector.h"
 #include "tdebug.h"
@@ -35,16 +38,24 @@ EBML::MkSegment::~MkSegment()
 {
   delete tags;
   delete attachments;
+  delete seekHead;
 }
 
 bool EBML::MkSegment::read(File &file)
 {
   offset_t maxOffset = file.tell() + dataSize;
   EBML::Element *element = nullptr;
-
+  int i = 0;
+  int seekHeadIndex = -1;
   while((element = findNextElement(file, maxOffset))) {
     Id id = element->getId();
-    if(id == ElementIDs::MkTags) {
+    if(id == ElementIDs::MkSeekHead) {
+      seekHeadIndex = i;
+      seekHead = static_cast<MkSeekHead*>(element);
+      if(!seekHead->read(file))
+        return false;
+    }
+    else if(id == ElementIDs::MkTags) {
       tags = static_cast<MkTags*>(element);
       if(!tags->read(file))
         return false;
@@ -55,9 +66,15 @@ bool EBML::MkSegment::read(File &file)
         return false;
     }
     else {
+      if(id == ElementIDs::VoidElement
+         && seekHead 
+         && seekHeadIndex == (i - 1))
+        seekHead->setPadding(element->getSize());
+
       element->skipData(file);
       delete element;
     }
+    i++;
   }
   return true;
 }
@@ -71,3 +88,13 @@ Matroska::Attachments* EBML::MkSegment::parseAttachments()
 {
   return attachments ? attachments->parse() : nullptr;
 }
+
+Matroska::SeekHead* EBML::MkSegment::parseSeekHead()
+{
+  return seekHead ? seekHead->parse() : nullptr;
+}
+
+Matroska::Segment* EBML::MkSegment::parseSegment()
+{
+  return new Matroska::Segment(sizeLength, dataSize, offset + idSize(id));
+}

taglib/matroska/ebml/ebmlmksegment.h

@@ -30,10 +30,13 @@ namespace TagLib {
   namespace Matroska {
     class Tag;
     class Attachments;
+    class SeekHead;
+    class Segment;
   }
   namespace EBML {
     class MkTags;
     class MkAttachments;
+    class MkSeekHead;
     class MkSegment : public MasterElement
     {
     public:
@@ -44,10 +47,14 @@ namespace TagLib {
       bool read(File &file) override;
       Matroska::Tag* parseTag();
       Matroska::Attachments* parseAttachments();
+      Matroska::SeekHead* parseSeekHead();
+      Matroska::Segment* parseSegment();
 
     private:
+      offset_t dataOffset = 0;
       MkTags *tags = nullptr;
       MkAttachments *attachments = nullptr;
+      MkSeekHead *seekHead = nullptr;
 
     };
   }

taglib/matroska/ebml/ebmlmktags.cpp

@@ -36,6 +36,7 @@ Matroska::Tag* EBML::MkTags::parse()
   auto mTag = new Matroska::Tag();
   mTag->setOffset(offset);
   mTag->setSize(getSize());
+  mTag->setID(id);
 
   // Loop through each <Tag> element
   for(auto tagsChild : elements) {