Integrate cues, fix element rendering and resizing

Author: ufleisch

taglib/matroska/ebml/ebmlelement.h

@@ -130,6 +130,7 @@ namespace TagLib::EBML {
   class MkTags;
   class MkAttachments;
   class MkSeekHead;
+  class MkCues;
   class VoidElement;
 
   template <String::Type t>
@@ -157,7 +158,7 @@ namespace TagLib::EBML {
   template <> struct GetElementTypeById<Element::Id::MkCueTrackPositions> { using type = MasterElement; };
   template <> struct GetElementTypeById<Element::Id::MkCueReference> { using type = MasterElement; };
   template <> struct GetElementTypeById<Element::Id::MkCluster> { using type = MasterElement; };
-  template <> struct GetElementTypeById<Element::Id::MkCues> { using type = MasterElement; };
+  template <> struct GetElementTypeById<Element::Id::MkCues> { using type = MkCues; };
   template <> struct GetElementTypeById<Element::Id::MkTagName> { using type = UTF8StringElement; };
   template <> struct GetElementTypeById<Element::Id::MkTagString> { using type = UTF8StringElement; };
   template <> struct GetElementTypeById<Element::Id::MkAttachedFileName> { using type = UTF8StringElement; };

taglib/matroska/ebml/ebmlmkcues.cpp

@@ -24,9 +24,9 @@
 
 using namespace TagLib;
 
-Matroska::Cues *EBML::MkCues::parse()
+std::unique_ptr<Matroska::Cues> EBML::MkCues::parse(offset_t segmentDataOffset)
 {
-  auto cues = new Matroska::Cues();
+  auto cues = std::make_unique<Matroska::Cues>(segmentDataOffset);
   cues->setOffset(offset);
   cues->setSize(getSize());
   cues->setID(static_cast<Matroska::Element::ID>(id));

taglib/matroska/ebml/ebmlmkcues.h

@@ -39,12 +39,16 @@ namespace TagLib {
         MasterElement(Id::MkCues, sizeLength, dataSize, offset)
       {
       }
+      MkCues(Id, int sizeLength, offset_t dataSize, offset_t offset) :
+        MasterElement(Id::MkCues, sizeLength, dataSize, offset)
+      {
+      }
       MkCues() :
         MasterElement(Id::MkCues, 0, 0, 0)
       {
       }
 
-      Matroska::Cues *parse();
+      std::unique_ptr<Matroska::Cues> parse(offset_t segmentDataOffset);
     };
   }
 }

taglib/matroska/ebml/ebmlmkseekhead.cpp

@@ -25,9 +25,9 @@
 
 using namespace TagLib;
 
-std::unique_ptr<Matroska::SeekHead> EBML::MkSeekHead::parse()
+std::unique_ptr<Matroska::SeekHead> EBML::MkSeekHead::parse(offset_t segmentDataOffset)
 {
-  auto seekHead = std::make_unique<Matroska::SeekHead>();
+  auto seekHead = std::make_unique<Matroska::SeekHead>(segmentDataOffset);
   seekHead->setOffset(offset);
   seekHead->setSize(getSize() + padding);
 

taglib/matroska/ebml/ebmlmkseekhead.h

@@ -46,7 +46,7 @@ namespace TagLib {
       {
       }
 
-      std::unique_ptr<Matroska::SeekHead> parse();
+      std::unique_ptr<Matroska::SeekHead> parse(offset_t segmentDataOffset);
     };
   }
 }

taglib/matroska/ebml/ebmlmksegment.cpp

@@ -28,13 +28,19 @@
 #include "matroskafile.h"
 #include "matroskatag.h"
 #include "matroskaattachments.h"
+#include "matroskacues.h"
 #include "matroskaseekhead.h"
 #include "matroskasegment.h"
 
 using namespace TagLib;
 
 EBML::MkSegment::~MkSegment() = default;
 
+offset_t EBML::MkSegment::segmentDataOffset() const
+{
+  return offset + idSize(id) + sizeLength;
+}
+
 bool EBML::MkSegment::read(File &file)
 {
   offset_t maxOffset = file.tell() + dataSize;
@@ -49,6 +55,11 @@ bool EBML::MkSegment::read(File &file)
       if(!seekHead->read(file))
         return false;
     }
+    else if(id == Id::MkCues) {
+      cues = element_cast<Id::MkCues>(std::move(element));
+      if(!cues->read(file))
+        return false;
+    }
     else if(id == Id::MkInfo) {
       info = element_cast<Id::MkInfo>(std::move(element));
       if(!info->read(file))
@@ -94,7 +105,12 @@ std::unique_ptr<Matroska::Attachments> EBML::MkSegment::parseAttachments()
 
 std::unique_ptr<Matroska::SeekHead> EBML::MkSegment::parseSeekHead()
 {
-  return seekHead ? seekHead->parse() : nullptr;
+  return seekHead ? seekHead->parse(segmentDataOffset()) : nullptr;
+}
+
+std::unique_ptr<Matroska::Cues> EBML::MkSegment::parseCues()
+{
+  return cues ? cues->parse(segmentDataOffset()) : nullptr;
 }
 
 std::unique_ptr<Matroska::Segment> EBML::MkSegment::parseSegment()

taglib/matroska/ebml/ebmlmksegment.h

@@ -26,6 +26,7 @@
 #include "ebmlmktags.h"
 #include "ebmlmkattachments.h"
 #include "ebmlmkseekhead.h"
+#include "ebmlmkcues.h"
 #include "ebmlmkinfo.h"
 #include "ebmlmktracks.h"
 #include "taglib.h"
@@ -50,10 +51,12 @@ namespace TagLib {
       {
       }
       ~MkSegment() override;
+      offset_t segmentDataOffset() const;
       bool read(File &file) override;
       std::unique_ptr<Matroska::Tag> parseTag();
       std::unique_ptr<Matroska::Attachments> parseAttachments();
       std::unique_ptr<Matroska::SeekHead> parseSeekHead();
+      std::unique_ptr<Matroska::Cues> parseCues();
       std::unique_ptr<Matroska::Segment> parseSegment();
       void parseInfo(Matroska::Properties *properties);
       void parseTracks(Matroska::Properties *properties);
@@ -62,6 +65,7 @@ namespace TagLib {
       std::unique_ptr<MkTags> tags;
       std::unique_ptr<MkAttachments> attachments;
       std::unique_ptr<MkSeekHead> seekHead;
+      std::unique_ptr<MkCues> cues;
       std::unique_ptr<MkInfo> info;
       std::unique_ptr<MkTracks> tracks;
     };

taglib/matroska/matroskaattachments.cpp

@@ -56,6 +56,7 @@ Matroska::Attachments::~Attachments() = default;
 void Matroska::Attachments::addAttachedFile(const AttachedFile& file)
 {
   d->files.append(file);
+  setNeedsRender(true);
 }
 
 void Matroska::Attachments::removeAttachedFile(unsigned long long uid)
@@ -66,12 +67,14 @@ void Matroska::Attachments::removeAttachedFile(unsigned long long uid)
     });
   if(it != d->files.end()) {
     d->files.erase(it);
+    setNeedsRender(true);
   }
 }
 
 void Matroska::Attachments::clear()
 {
   d->files.clear();
+  setNeedsRender(true);
 }
 
 const Matroska::Attachments::AttachedFileList &Matroska::Attachments::attachedFileList() const
@@ -85,11 +88,17 @@ const Matroska::Attachments::AttachedFileList &Matroska::Attachments::attachedFi
 
 Matroska::Attachments::AttachedFileList &Matroska::Attachments::attachedFiles()
 {
+  setNeedsRender(true);
   return d->files;
 }
 
-bool Matroska::Attachments::render()
+ByteVector Matroska::Attachments::renderInternal()
 {
+  if(d->files.isEmpty()) {
+    // Avoid writing an Attachments element without AttachedFile element.
+    return {};
+  }
+
   EBML::MkAttachments attachments;
   for(const auto &attachedFile : std::as_const(d->files)) {
     auto attachedFileElement = EBML::make_unique_element<EBML::Element::Id::MkAttachedFile>();
@@ -127,14 +136,5 @@ bool Matroska::Attachments::render()
 
     attachments.appendElement(std::move(attachedFileElement));
   }
-
-  auto beforeSize = size();
-  auto data = attachments.render();
-  auto afterSize = data.size();
-  if(beforeSize != afterSize) {
-    if(!emitSizeChanged(afterSize - beforeSize))
-      return false;
-  }
-  setData(data);
-  return true;
+  return attachments.render();
 }

taglib/matroska/matroskaattachments.h

@@ -47,7 +47,7 @@ namespace TagLib {
       Attachments();
 
       //! Destroy attachements.
-      ~Attachments();
+      virtual ~Attachments();
 
       //! Add an attached file.
       void addAttachedFile(const AttachedFile &file);
@@ -67,7 +67,7 @@ namespace TagLib {
       class AttachmentsPrivate;
 
       // private Element implementation
-      bool render() override;
+      ByteVector renderInternal() override;
       AttachedFileList &attachedFiles();
 
       TAGLIB_MSVC_SUPPRESS_WARNING_NEEDS_TO_HAVE_DLL_INTERFACE

taglib/matroska/matroskacues.cpp

@@ -29,14 +29,18 @@
 
 using namespace TagLib;
 
-Matroska::Cues::Cues() :
-  Element(static_cast<ID>(EBML::Element::Id::MkCues))
+Matroska::Cues::Cues(offset_t segmentDataOffset) :
+  Element(static_cast<ID>(EBML::Element::Id::MkCues)),
+  segmentDataOffset(segmentDataOffset)
 {
+  setNeedsRender(false);
 }
 
 ByteVector Matroska::Cues::renderInternal()
 {
+  auto beforeSize = sizeRenderedOrWritten();
   EBML::MkCues cues;
+  cues.setMinRenderSize(beforeSize);
   for(const auto &cuePoint : cuePoints) {
     auto cuePointElement = EBML::make_unique_element<EBML::Element::Id::MkCuePoint>();
     auto timestamp = EBML::make_unique_element<EBML::Element::Id::MkCueTime>();
@@ -57,7 +61,33 @@ ByteVector Matroska::Cues::renderInternal()
       clusterPosition->setValue(cueTrack->getClusterPosition());
       cueTrackElement->appendElement(std::move(clusterPosition));
 
-      // Todo - other elements
+      // Relative position, optional
+      if(cueTrack->getRelativePosition().has_value()) {
+        auto relativePosition = EBML::make_unique_element<EBML::Element::Id::MkCueRelativePosition>();
+        relativePosition->setValue(cueTrack->getRelativePosition().value());
+        cueTrackElement->appendElement(std::move(relativePosition));
+      }
+
+      // Duration, optional
+      if(cueTrack->getDuration().has_value()) {
+        auto duration = EBML::make_unique_element<EBML::Element::Id::MkCueDuration>();
+        duration->setValue(cueTrack->getDuration().value());
+        cueTrackElement->appendElement(std::move(duration));
+      }
+
+      // Block number, optional
+      if(cueTrack->getBlockNumber().has_value()) {
+        auto blockNumber = EBML::make_unique_element<EBML::Element::Id::MkCueBlockNumber>();
+        blockNumber->setValue(cueTrack->getBlockNumber().value());
+        cueTrackElement->appendElement(std::move(blockNumber));
+      }
+
+      // Codec state, not in version 1
+      if(cueTrack->getCodecState().has_value()) {
+        auto codecState = EBML::make_unique_element<EBML::Element::Id::MkCueCodecState>();
+        codecState->setValue(cueTrack->getCodecState().value());
+        cueTrackElement->appendElement(std::move(codecState));
+      }
 
       // Reference times
       auto referenceTimes = cueTrack->referenceTimes();
@@ -72,29 +102,33 @@ ByteVector Matroska::Cues::renderInternal()
       }
       cuePointElement->appendElement(std::move(cueTrackElement));
     }
+    cues.appendElement(std::move(cuePointElement));
   }
   return cues.render();
 }
 
-bool Matroska::Cues::render()
+void Matroska::Cues::write(TagLib::File& file)
 {
-  if(!needsRender)
-    return true;
-
-  setData(renderInternal());
-  needsRender = false;
-  return true;
+  if(!data().isEmpty())
+    Element::write(file);
 }
 
 bool Matroska::Cues::sizeChanged(Element &caller, offset_t delta)
 {
-  offset_t offset = caller.offset();
-  for(auto &cuePoint : cuePoints)
-    needsRender |= cuePoint->adjustOffset(offset, delta);
+  // Adjust own offset
+  if(!Element::sizeChanged(caller, delta))
+    return false;
+
+  offset_t offset = caller.offset() - segmentDataOffset;
+  for(auto &cuePoint : cuePoints) {
+    if(cuePoint->adjustOffset(offset, delta)) {
+      setNeedsRender(true);
+    }
+  }
   return true;
 }
 
-bool Matroska::Cues::isValid(TagLib::File &file, offset_t segmentDataOffset) const
+bool Matroska::Cues::isValid(TagLib::File &file) const
 {
   for(const auto &cuePoint : cuePoints) {
     if(!cuePoint->isValid(file, segmentDataOffset))
@@ -150,8 +184,8 @@ bool Matroska::CueTrack::isValid(TagLib::File &file, offset_t segmentDataOffset)
     debug("No cluster found at position");
     return false;
   }
-  if(codecState) {
-    file.seek(segmentDataOffset + codecState);
+  if(codecState.has_value() && codecState.value() != 0) {
+    file.seek(segmentDataOffset + codecState.value());
     if(EBML::Element::readId(file) != static_cast<unsigned int>(EBML::Element::Id::MkCodecState)) {
       debug("No codec state found at position");
       return false;
@@ -160,8 +194,18 @@ bool Matroska::CueTrack::isValid(TagLib::File &file, offset_t segmentDataOffset)
   return true;
 }
 
-bool Matroska::CueTrack::adjustOffset(offset_t, offset_t)
+bool Matroska::CueTrack::adjustOffset(offset_t offset, offset_t delta)
 {
-  // TODO implement
-  return false;
+  bool ret = false;
+  if(clusterPosition > offset) {
+    clusterPosition += delta;
+    ret = true;
+  }
+  offset_t codecStateValue;
+  if(codecState.has_value() && (codecStateValue = codecState.value()) != 0 &&
+     codecStateValue > offset) {
+    codecState = codecStateValue + delta;
+    ret = true;
+  }
+  return ret;
 }