taglib · complexlogic · Sep 19, 2023 · Oct 1, 2023 · Oct 7, 2023 · Oct 8, 2023
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -100,6 +100,7 @@ include(ConfigureChecks.cmake)
 option(WITH_APE "Build with APE, MPC, WavPack" ON)
 option(WITH_ASF "Build with ASF" ON)
 option(WITH_DSF "Build with DSF" ON)
+option(WITH_MATROSKA "Build with Matroska" ON)
 option(WITH_MOD "Build with Tracker modules" ON)
 option(WITH_MP4 "Build with MP4" ON)
 option(WITH_RIFF "Build with AIFF, RIFF, WAV" ON)
@@ -197,6 +198,9 @@ endif()
 if(WITH_DSF)
   set(TAGLIB_WITH_DSF TRUE)
 endif()
+if(WITH_MATROSKA)
+  set(TAGLIB_WITH_MATROSKA TRUE)
+endif()
 if(WITH_MOD)
   set(TAGLIB_WITH_MOD TRUE)
 endif()

diff --git a/INSTALL.md b/INSTALL.md
@@ -63,6 +63,7 @@ and ID3 tags cannot be disabled. The following CMake options are available:
 | `WITH_APE`              | Build with APE, MPC, WavPack (default ON)          |
 | `WITH_ASF`              | Build with ASF (default ON)                        |
 | `WITH_DSF`              | Build with DSF (default ON)                        |
+| `WITH_MATROSKA`         | Build with Matroska (default ON)                   |
 | `WITH_MOD`              | Build with Tracker modules (default ON)            |
 | `WITH_MP4`              | Build with MP4 (default ON)                        |
 | `WITH_RIFF`             | Build with AIFF, RIFF, WAV (default ON)            |

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
@@ -63,6 +63,12 @@ if(WITH_SHORTEN)
     ${CMAKE_CURRENT_SOURCE_DIR}/../../taglib/shorten
   )
 endif()
+if(WITH_MATROSKA)
+  set(tag_c_HDR_DIRS ${tag_c_HDR_DIRS}
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../taglib/matroska
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../taglib/matroska/ebml
+  )
+endif()
 include_directories(${tag_c_HDR_DIRS})
 
 set(tag_c_HDRS tag_c.h)

diff --git a/bindings/c/tag_c.cpp b/bindings/c/tag_c.cpp
@@ -80,6 +80,9 @@
 #ifdef TAGLIB_WITH_SHORTEN
 #include "shortenfile.h"
 #endif
+#ifdef TAGLIB_WITH_MATROSKA
+#include "matroskafile.h"
+#endif
 
 using namespace TagLib;
 
@@ -241,6 +244,11 @@ TagLib_File *taglib_file_new_type_any_char(const T *filename, TagLib_File_Type t
   case TagLib_File_SHORTEN:
     file = new Shorten::File(filename);
     break;
+#endif
+#ifdef TAGLIB_WITH_MATROSKA
+  case TagLib_File_MATROSKA:
+    file = new Matroska::File(filename);
+    break;
 #endif
   default:
     break;

diff --git a/bindings/c/tag_c.h b/bindings/c/tag_c.h
@@ -132,7 +132,8 @@ typedef enum {
   TagLib_File_Opus,
   TagLib_File_DSF,
   TagLib_File_DSDIFF,
-  TagLib_File_SHORTEN
+  TagLib_File_SHORTEN,
+  TagLib_File_MATROSKA
 } TagLib_File_Type;
 
 /*!

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -2,6 +2,7 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/toolkit
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/ape
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/matroska
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v1
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v2
@@ -38,6 +39,18 @@ target_link_libraries(framelist tag)
 add_executable(strip-id3v1 strip-id3v1.cpp)
 target_link_libraries(strip-id3v1 tag)
 
+if(WITH_MATROSKA)
+  ########### next target ###############
+
+  add_executable(matroskareader matroskareader.cpp)
+  target_link_libraries(matroskareader tag)
+
+  ########### next target ###############
+
+  add_executable(matroskawriter matroskawriter.cpp)
+  target_link_libraries(matroskawriter tag)
+endif()
+
 install(TARGETS tagreader tagreader_c tagwriter framelist strip-id3v1
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

diff --git a/examples/matroskareader.cpp b/examples/matroskareader.cpp
@@ -0,0 +1,90 @@
+#include <cstdio>
+#include "matroskafile.h"
+#include "matroskatag.h"
+#include "matroskasimpletag.h"
+#include "matroskaattachments.h"
+#include "matroskaattachedfile.h"
+#include "tstring.h"
+#include "tutils.h"
+#include "tbytevector.h"
+#define GREEN_TEXT(s) "[1;32m" s "[0m"
+#define PRINT_PRETTY(label, value) printf("  " GREEN_TEXT(label) ": %s\n", value)
+
+int main(int argc, char *argv[])
+{
+  if(argc != 2) {
+    printf("Usage: matroskareader FILE\n");
+    return 1;
+  }
+  TagLib::Matroska::File file(argv[1]);
+  if(!file.isValid()) {
+    printf("File is not valid\n");
+    return 1;
+  }
+  auto tag = dynamic_cast<TagLib::Matroska::Tag*>(file.tag());
+  if(!tag) {
+    printf("File has no tag\n");
+    return 0;
+  }
+
+  const TagLib::Matroska::SimpleTagsList &list = tag->simpleTagsList();
+  printf("Found %u tag(s):\n", list.size());
+
+  for(const TagLib::Matroska::SimpleTag &t : list) {
+    PRINT_PRETTY("Tag Name", t.name().toCString(true));
+
+    if(t.type() == TagLib::Matroska::SimpleTag::StringType)
+      PRINT_PRETTY("Tag Value", t.toString().toCString(true));
+    else if(t.type() == TagLib::Matroska::SimpleTag::BinaryType)
+      PRINT_PRETTY("Tag Value",
+        TagLib::Utils::formatString("Binary with size %i", t.toByteVector().size()).toCString(false)
+      );
+
+    auto targetTypeValue = static_cast<unsigned int>(t.targetTypeValue());
+    PRINT_PRETTY("Target Type Value",
+      targetTypeValue == 0 ? "None" : TagLib::Utils::formatString("%i", targetTypeValue).toCString(false)
+    );
+    if(auto trackUid = t.trackUid()) {
+      PRINT_PRETTY("Track UID",
+        TagLib::Utils::formatString("%llu",trackUid).toCString(false)
+      );
+    }
+    const TagLib::String &language = t.language();
+    PRINT_PRETTY("Language", !language.isEmpty() ? language.toCString(false) : "Not set");
+
+    printf("\n");
+  }
+
+  TagLib::Matroska::Attachments *attachments = file.attachments();
+  if(attachments) {
+    const TagLib::Matroska::Attachments::AttachedFileList &list = attachments->attachedFileList();
+    printf("Found %u attachment(s)\n", list.size());
+    for(const auto &attachedFile : list) {
+      PRINT_PRETTY("Filename", attachedFile.fileName().toCString(true));
+      const TagLib::String &description = attachedFile.description();
+      PRINT_PRETTY("Description", !description.isEmpty() ? description.toCString(true) : "None");
+      const TagLib::String &mediaType = attachedFile.mediaType();
+      PRINT_PRETTY("Media Type", !mediaType.isEmpty() ? mediaType.toCString(false) : "None");
+      PRINT_PRETTY("Data Size",
+        TagLib::Utils::formatString("%u byte(s)",attachedFile.data().size()).toCString(false)
+      );
+      PRINT_PRETTY("UID",
+        TagLib::Utils::formatString("%llu",attachedFile.uid()).toCString(false)
+      );
+    }
+  }
+  else
+    printf("File has no attachments\n");
+
+  if(auto properties = dynamic_cast<const TagLib::Matroska::Properties *>(file.audioProperties())) {
+    printf("Properties:\n");
+    PRINT_PRETTY("Doc Type", properties->docType().toCString(false));
+    PRINT_PRETTY("Doc Type Version", TagLib::String::number(properties->docTypeVersion()).toCString(false));
+    PRINT_PRETTY("Codec Name", properties->codecName().toCString(true));
+    PRINT_PRETTY("Bitrate", TagLib::String::number(properties->bitrate()).toCString(false));
+    PRINT_PRETTY("Sample Rate", TagLib::String::number(properties->sampleRate()).toCString(false));
+    PRINT_PRETTY("Channels", TagLib::String::number(properties->channels()).toCString(false));
+    PRINT_PRETTY("Length [ms]", TagLib::String::number(properties->lengthInMilliseconds()).toCString(false));
+  }
+  return 0;
+}
diff --git a/examples/matroskawriter.cpp b/examples/matroskawriter.cpp
@@ -0,0 +1,49 @@
+#include <cstdio>
+#include "matroskafile.h"
+#include "matroskatag.h"
+#include "matroskasimpletag.h"
+#include "matroskaattachments.h"
+#include "matroskaattachedfile.h"
+#include "tfilestream.h"
+#include "tstring.h"
+#include "tutils.h"
+
+int main(int argc, char *argv[])
+{
+  if(argc != 3) {
+    printf("Usage: matroskawriter FILE ARTWORK\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();
+
+  tag->addSimpleTag(TagLib::Matroska::SimpleTag(
+    "Test Name 1", TagLib::String("Test Value 1"),
+    TagLib::Matroska::SimpleTag::TargetTypeValue::Track, "en"));
+
+  tag->addSimpleTag(TagLib::Matroska::SimpleTag(
+    "Test Name 2", TagLib::String("Test Value 2"),
+    TagLib::Matroska::SimpleTag::TargetTypeValue::Album));
+  tag->setTitle("Test title");
+  tag->setArtist("Test artist");
+  tag->setYear(1969);
+
+  TagLib::FileStream image(argv[2]);
+  auto data = image.readBlock(image.length());
+  auto attachments = file.attachments(true);
+  TagLib::Matroska::AttachedFile attachedFile;
+  attachedFile.setFileName("cover.jpg");
+  attachedFile.setMediaType("image/jpeg");
+  attachedFile.setData(data);
+  //attachedFile.setUID(5081000385627515072ull);
+  attachments->addAttachedFile(attachedFile);
+
+  file.save();
+
+  return 0;
+}
diff --git a/examples/tagwriter.cpp b/examples/tagwriter.cpp
@@ -71,6 +71,7 @@ void usage()
   std::cout << "  -R <tagname> <tagvalue>"   << std::endl;
   std::cout << "  -I <tagname> <tagvalue>"   << std::endl;
   std::cout << "  -D <tagname>"   << std::endl;
+  std::cout << "  -C <complex-property-key> <key1=val1,key2=val2,...>" << std::endl;
   std::cout << "  -p <picturefile> <description> (\"\" \"\" to remove)" << std::endl;
   std::cout << std::endl;
 
@@ -95,6 +96,102 @@ void checkForRejectedProperties(const TagLib::PropertyMap &tags)
   }
 }
 
+/*!
+ * Create a list of variant maps from a string.
+ * The shorthand syntax in the string is kept simple, but should be sufficient
+ * for testing. Multiple maps are separated by ';', values within a map are
+ * assigned with key=value and separated by a ','. Types are detected, use
+ * double quotes to force a string. A ByteVector can be constructed from the
+ * contents of a file, the path is given after "file://". There is no escape
+ * character, use hex codes for ',' (\x2C) or ';' (\x3B).
+ */
+TagLib::List<TagLib::VariantMap> parseComplexPropertyValues(const TagLib::String &str)
+{
+  if(str.isEmpty() || str == "\"\"" || str == "''") {
+    return {};
+  }
+  TagLib::List<TagLib::VariantMap> values;
+  const auto valueStrs = str.split(";");
+  for(const auto &valueStr : valueStrs) {
+    TagLib::VariantMap value;
+    const auto keyValStrs = valueStr.split(",");
+    for(const auto &keyValStr : keyValStrs) {
+      if(int equalPos = keyValStr.find('='); equalPos != -1) {
+        TagLib::String key = keyValStr.substr(0, equalPos);
+        TagLib::String valStr = keyValStr.substr(equalPos + 1);
+        bool hasDot = false;
+        bool hasNonNumeric = false;
+        bool hasSign = false;
+        for(auto it = valStr.cbegin(); it != valStr.cend(); ++it) {
+          if(it == valStr.cbegin() && (*it == '-' || *it == '+')) {
+            hasSign = true;
+          }
+          else if(*it == '.') {
+            hasDot = true;
+          }
+          else if(*it < '0' || *it > '9') {
+            hasNonNumeric = true;
+          }
+        }
+        TagLib::Variant val;
+        if(valStr == "null") {
+          // keep empty variant
+        }
+        else if(valStr == "true" || valStr == "false") {
+          val = TagLib::Variant(valStr == "true");
+        }
+        else if(!hasNonNumeric && hasDot) {
+          val = TagLib::Variant(std::stod(valStr.to8Bit()));
+        }
+        else if(!hasNonNumeric && hasSign) {
+          val = valStr.toLongLong(nullptr);
+        }
+        else if(!hasNonNumeric) {
+          val = valStr.toULongLong(nullptr);
+        }
+        else if(valStr.startsWith("file://")) {
+          auto filePath = valStr.substr(7 );
+          if(isFile(filePath.toCString())) {
+            std::ifstream fs;
+            fs.open(filePath.toCString(), std::ios::in | std::ios::binary);
+            std::stringstream buffer;
+            buffer << fs.rdbuf();
+            fs.close();
+            TagLib::String buf(buffer.str());
+            val = TagLib::Variant(buf.data(TagLib::String::Latin1));
+          }
+          else {
+            std::cout << filePath.toCString() << " not found." << std::endl;
+            val = TagLib::Variant(TagLib::ByteVector());
+          }
+        }
+        else {
+          int len = valStr.size();
+          if(len >= 2 && valStr[0] == '"' && valStr[len - 1] == '"') {
+            valStr = valStr.substr(1, len - 2);
+          }
+          int hexPos = 0;
+          while((hexPos = valStr.find("\\x", hexPos)) != -1) {
+            char ch;
+            bool ok;
+            if(static_cast<int>(valStr.length()) < hexPos + 4 ||
+               (ch = static_cast<char>(
+                 valStr.substr(hexPos + 2, 2).toLongLong(&ok, 16)), !ok)) {
+              break;
+            }
+            valStr = valStr.substr(0, hexPos) + ch + valStr.substr(hexPos + 4);
+            ++hexPos;
+          }
+          val = TagLib::Variant(valStr);
+        }
+        value.insert(key, val);
+      }
+    }
+    values.append(value);
+  }
+  return values;
+}
+
 int main(int argc, char *argv[])
 {
   TagLib::List<TagLib::FileRef> fileList;
@@ -170,6 +267,19 @@ int main(int argc, char *argv[])
           checkForRejectedProperties(f.setProperties(map));
           break;
         }
+        case 'C': {
+          if(i + 2 < argc) {
+            numArgsConsumed = 3;
+            if(!value.isEmpty()) {
+              TagLib::List<TagLib::VariantMap> values = parseComplexPropertyValues(argv[i + 2]);
+              f.setComplexProperties(value, values);
+            }
+          }
+          else {
+            usage();
+          }
+          break;
+        }
         case 'p': {
           if(i + 2 < argc) {
             numArgsConsumed = 3;