Added write support

Author: complexlogic

examples/CMakeLists.txt

@@ -44,6 +44,11 @@ target_link_libraries(strip-id3v1 tag)
 add_executable(matroskareader matroskareader.cpp)
 target_link_libraries(matroskareader tag)
 
+########### next target ###############
+
+add_executable(matroskawriter matroskawriter.cpp)
+target_link_libraries(matroskawriter tag)
+
 install(TARGETS tagreader tagreader_c tagwriter framelist strip-id3v1
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

examples/matroskawriter.cpp

@@ -0,0 +1,37 @@
+#include <cstdio>
+#include "matroskafile.h"
+#include "matroskatag.h"
+#include "matroskasimpletag.h"
+#include "tstring.h"
+#include "tutils.h"
+
+int main(int argc, char *argv[])
+{
+  if (argc != 2) {
+    printf("Usage: matroskawriter FILE\n");
+    return 1;
+  }
+  TagLib::Matroska::File file(argv[1]);
+  if (!file.isValid()) {
+    printf("File is not valid\n");
+    return 1;
+  }
+  auto tag = file.tag(true);
+  tag->clearSimpleTags();
+
+  auto simpleTag = new TagLib::Matroska::SimpleTagString();
+  simpleTag->setName("Test Name 1");
+  simpleTag->setTargetTypeValue(TagLib::Matroska::SimpleTag::TargetTypeValue::Track);
+  simpleTag->setValue("Test Value 1");
+  tag->addSimpleTag(simpleTag);
+
+  simpleTag = new TagLib::Matroska::SimpleTagString();
+  simpleTag->setName("Test Name 2");
+  simpleTag->setTargetTypeValue(TagLib::Matroska::SimpleTag::TargetTypeValue::Album);
+  simpleTag->setValue("Test Value 2");
+  tag->addSimpleTag(simpleTag);
+
+  file.save();
+
+  return 0;
+}

taglib/fileref.cpp

@@ -38,6 +38,7 @@
 #include "tstringlist.h"
 #include "tvariant.h"
 #include "tdebug.h"
+#include "matroskafile.h"
 #include "mpegfile.h"
 #ifdef TAGLIB_WITH_RIFF
 #include "aifffile.h"
@@ -220,6 +221,8 @@ namespace
     else if(ext == "SHN")
       file = new Shorten::File(stream, readAudioProperties, audioPropertiesStyle);
 #endif
+    else if(ext == "MKA" || ext == "MKV" || ext == "WEBM")
+      file = new Matroska::File(stream, readAudioProperties);
 
     // if file is not valid, leave it to content-based detection.
 

taglib/matroska/ebml/ebmlelement.cpp

@@ -29,6 +29,8 @@
 #include "tdebug.h"
 #include "tutils.h"
 
+#include <cstdint>
+
 using namespace TagLib;
 
 EBML::Element* EBML::Element::factory(File &file)
@@ -47,28 +49,28 @@ EBML::Element* EBML::Element::factory(File &file)
 
   // Return the subclass
   switch(id) {
-    case EBML_ID_HEAD:
+    case ElementIDs::EBMLHeader:
       return new Element(id, sizeLength, dataSize);
 
-    case EBML_ID_MK_SEGMENT:
+    case ElementIDs::MkSegment:
       return new MkSegment(sizeLength, dataSize);
 
-    case EBML_ID_MK_TAGS:
+    case ElementIDs::MkTags:
       return new MkTags(sizeLength, dataSize);
 
-    case EBML_ID_MK_TAG:
-    case EBML_ID_MK_TAG_TARGETS:
-    case EBML_ID_MK_SIMPLE_TAG:
+    case ElementIDs::MkTag:
+    case ElementIDs::MkTagTargets:
+    case ElementIDs::MkSimpleTag:
       return new MasterElement(id, sizeLength, dataSize);
 
-    case EBML_ID_MK_TAG_NAME:
-    case EBML_ID_MK_TAG_STRING:
+    case ElementIDs::MkTagName:
+    case ElementIDs::MkTagString:
       return new UTF8StringElement(id, sizeLength, dataSize);
 
-    case EBML_ID_MK_TAG_LANGUAGE:
+    case ElementIDs::MkTagLanguage:
       return new Latin1StringElement(id, sizeLength, dataSize);
 
-    case EBML_ID_MK_TARGET_TYPE_VALUE:
+    case ElementIDs::MkTagTargetTypeValue:
       return new UIntElement(id, sizeLength, dataSize);
 
     default:
@@ -78,7 +80,45 @@ EBML::Element* EBML::Element::factory(File &file)
   return nullptr;
 }
 
+EBML::Element::Id EBML::Element::readId(File &file)
+{
+  auto buffer = file.readBlock(1);
+  if (buffer.size() != 1) {
+    debug("Failed to read VINT size");
+    return 0;
+  }
+  unsigned int nb_bytes = VINTSizeLength<4>(*buffer.begin());
+  if (!nb_bytes)
+    return 0;
+  if (nb_bytes > 1)
+    buffer.append(file.readBlock(nb_bytes - 1));
+  if (buffer.size() != nb_bytes) {
+    debug("Failed to read VINT data");
+    return 0;
+  }
+  return buffer.toUInt(true);
+}
+
 void EBML::Element::skipData(File &file) 
 {
   file.seek(dataSize, File::Position::Current);
 }
+
+offset_t EBML::Element::headSize() const
+{ 
+  return EBML::idSize(id) + sizeLength;
+}
+
+ByteVector EBML::Element::render()
+{
+  ByteVector buffer = renderId();
+  buffer.append(renderVINT(0, 0));
+  return buffer;
+}
+
+ByteVector EBML::Element::renderId()
+{
+  int numBytes = idSize(id);
+  id = Utils::byteSwap(id);
+  return ByteVector((char*) &id + (4 - numBytes), numBytes);
+}

taglib/matroska/ebml/ebmlelement.h

@@ -23,14 +23,16 @@
 #ifndef DO_NOT_DOCUMENT
 
 #include "tfile.h"
-#include "ebmlutils.h"
+#include "tutils.h"
+//#include "ebmlutils.h"
 #include "taglib.h"
 
 namespace TagLib {
   namespace EBML {
     class Element
     {
     public:
+      using Id = unsigned int;
       Element(Id id, int sizeLength, offset_t dataSize)
       : id(id), sizeLength(sizeLength), dataSize(dataSize)
       {}
@@ -42,15 +44,32 @@ namespace TagLib {
       }
       void skipData(File &file);
       Id getId() const { return id; }
+      offset_t headSize() const;
       int getSizeLength() const { return sizeLength; }
       int64_t getDataSize() const { return dataSize; }
+      ByteVector renderId();
+      virtual ByteVector render();
       static Element* factory(File &file);
+      static Id readId(File &file);
 
     protected:
       Id id;
       int sizeLength;
       offset_t dataSize;
     };
+
+    namespace ElementIDs {
+      inline constexpr Element::Id EBMLHeader           = 0x1A45DFA3;
+      inline constexpr Element::Id MkSegment            = 0x18538067;
+      inline constexpr Element::Id MkTags               = 0x1254C367;
+      inline constexpr Element::Id MkTag                = 0x7373;
+      inline constexpr Element::Id MkTagTargets         = 0x63C0;
+      inline constexpr Element::Id MkTagTargetTypeValue = 0x68CA;
+      inline constexpr Element::Id MkSimpleTag          = 0x67C8;
+      inline constexpr Element::Id MkTagName            = 0x45A3;
+      inline constexpr Element::Id MkTagLanguage        = 0x447A;
+      inline constexpr Element::Id MkTagString          = 0x4487;
+    }
   }
 }
 

taglib/matroska/ebml/ebmlmasterelement.cpp

@@ -45,3 +45,15 @@ bool EBML::MasterElement::read(File &file)
   }
   return file.tell() == maxOffset;
 }
+
+ByteVector EBML::MasterElement::render()
+{
+  ByteVector buffer = renderId();
+  ByteVector data;
+  for (auto element : elements)
+    data.append(element->render());
+  dataSize = data.size();
+  buffer.append(renderVINT(dataSize, 0));
+  buffer.append(data);
+  return buffer;
+}

taglib/matroska/ebml/ebmlmasterelement.h

@@ -22,8 +22,9 @@
 #define TAGLIB_EBMLMASTERELEMENT_H
 #ifndef DO_NOT_DOCUMENT
 
-#include "ebmlelement.h"
 #include "ebmlutils.h"
+#include "ebmlelement.h"
+#include "tbytevector.h"
 #include "tlist.h"
 #include "taglib.h"
 
@@ -35,9 +36,14 @@ namespace TagLib {
       MasterElement(Id id, int sizeLength, offset_t dataSize)
       : Element(id, sizeLength, dataSize)
       {}
+      MasterElement(Id id)
+      : Element(id, 0, 0)
+      {}
       ~MasterElement() override;
       virtual bool isMaster() const override { return true; }
       virtual 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(); }

taglib/matroska/ebml/ebmlmksegment.cpp

@@ -24,6 +24,7 @@
 #include "matroskafile.h"
 #include "matroskatag.h"
 #include "tutils.h"
+#include "tbytevector.h"
 #include "tdebug.h"
 
 using namespace TagLib;
@@ -36,13 +37,21 @@ EBML::MkSegment::~MkSegment()
 bool EBML::MkSegment::read(File &file)
 {
   offset_t maxOffset = file.tell() + dataSize;
-  tags = static_cast<MkTags*>(findElement(file, EBML_ID_MK_TAGS, maxOffset));
-  if (tags && !tags->read(file))
-    return false;
+  tags = static_cast<MkTags*>(findElement(file, ElementIDs::MkTags, maxOffset));
+  if (tags) {
+    offset_t tagsHeadSize = tags->headSize();
+    tagsOffset = file.tell() - tagsHeadSize;
+    tagsOriginalSize = tagsHeadSize + tags->getDataSize();
+    if (!tags->read(file))
+      return false;
+  }
   return true;
 }
 
-Matroska::Tag* EBML::MkSegment::parseTag()
+std::tuple<Matroska::Tag*, offset_t, offset_t> EBML::MkSegment::parseTag()
 {
-  return tags ? tags->parse() : nullptr;
+  if (tags)
+    return {tags->parse(), tagsOffset, tagsOriginalSize};
+  else
+    return {nullptr, 0, 0};
 }

taglib/matroska/ebml/ebmlmksegment.h

@@ -20,6 +20,7 @@
 
 #include "ebmlmasterelement.h"
 #include "taglib.h"
+#include <tuple>
 
 #ifndef TAGLIB_EBMLMKSEGMENT_H
 #define TAGLIB_EBMLMKSEGMENT_H
@@ -36,14 +37,16 @@ namespace TagLib {
     {
     public:
       MkSegment(int sizeLength, offset_t dataSize)
-      : MasterElement(EBML_ID_MK_SEGMENT, sizeLength, dataSize)
+      : MasterElement(ElementIDs::MkSegment, sizeLength, dataSize)
       {}
       ~MkSegment() override;
       bool read(File &file) override;
-      Matroska::Tag* parseTag();
+      std::tuple<Matroska::Tag*, offset_t, offset_t> parseTag();
 
     private:
       MkTags *tags = nullptr;
+      offset_t tagsOffset = 0;
+      offset_t tagsOriginalSize = 0;
 
     };
   }

taglib/matroska/ebml/ebmlmktags.cpp

@@ -37,7 +37,7 @@ Matroska::Tag* EBML::MkTags::parse()
 
   // Loop through each <Tag> element
   for (auto tagsChild : elements) {
-    if (tagsChild->getId() != EBML_ID_MK_TAG)
+    if (tagsChild->getId() != ElementIDs::MkTag)
       continue;
     auto tag = static_cast<MasterElement*>(tagsChild);
     List<MasterElement*> simpleTags;
@@ -46,20 +46,20 @@ Matroska::Tag* EBML::MkTags::parse()
     // Identify the <Targets> element and the <SimpleTag> elements
     for (auto tagChild : *tag) {
       Id tagChildId = tagChild->getId();
-      if (!targets && tagChildId == EBML_ID_MK_TAG_TARGETS)
+      if (!targets && tagChildId == ElementIDs::MkTagTargets)
         targets = static_cast<MasterElement*>(tagChild);
-      else if (tagChildId == EBML_ID_MK_SIMPLE_TAG)
+      else if (tagChildId == ElementIDs::MkSimpleTag)
         simpleTags.append(static_cast<MasterElement*>(tagChild));
     }
 
     // Parse the <Targets> element
-    Matroska::Tag::TargetTypeValue targetTypeValue = Matroska::Tag::TargetTypeValue::None;
+    Matroska::SimpleTag::TargetTypeValue targetTypeValue = Matroska::SimpleTag::TargetTypeValue::None;
     if (targets) {
       for (auto targetsChild : *targets) {
         Id id = targetsChild->getId();
-        if (id == EBML_ID_MK_TARGET_TYPE_VALUE
-            && targetTypeValue == Matroska::Tag::TargetTypeValue::None) {
-          targetTypeValue = static_cast<Matroska::Tag::TargetTypeValue>(
+        if (id == ElementIDs::MkTagTargetTypeValue
+            && targetTypeValue == Matroska::SimpleTag::TargetTypeValue::None) {
+          targetTypeValue = static_cast<Matroska::SimpleTag::TargetTypeValue>(
             static_cast<UIntElement*>(targetsChild)->getValue()
           );            
         }
@@ -74,9 +74,9 @@ Matroska::Tag* EBML::MkTags::parse()
 
       for (auto simpleTagChild : *simpleTag) {
         Id id = simpleTagChild->getId();
-        if (id == EBML_ID_MK_TAG_NAME && !tagName)
+        if (id == ElementIDs::MkTagName && !tagName)
           tagName = &(static_cast<UTF8StringElement*>(simpleTagChild)->getValue());
-        else if (id == EBML_ID_MK_TAG_STRING && !tagValueString)
+        else if (id == ElementIDs::MkTagString && !tagValueString)
           tagValueString = &(static_cast<UTF8StringElement*>(simpleTagChild)->getValue());
       }
       if (!tagName || (tagValueString && tagValueBinary) || (!tagValueString && !tagValueBinary))
@@ -85,12 +85,14 @@ Matroska::Tag* EBML::MkTags::parse()
       // Create a Simple Tag object and add it to the Tag object
       Matroska::SimpleTag *sTag = nullptr;
       if (tagValueString) {
-        auto sTagString = new Matroska::SimpleTagString(targetTypeValue);
+        auto sTagString = new Matroska::SimpleTagString();
+        sTagString->setTargetTypeValue(targetTypeValue);
         sTagString->setValue(*tagValueString);
         sTag = sTagString;
       }
       else if (tagValueBinary) {
-        auto sTagBinary = new Matroska::SimpleTagBinary(targetTypeValue);
+        auto sTagBinary = new Matroska::SimpleTagBinary();
+        sTagBinary->setTargetTypeValue(targetTypeValue);
         sTagBinary->setValue(*tagValueBinary);
         sTag = sTagBinary;
       }