Add support for the SeratoMarkers_ GEOB tag (Hotcues/Loops/Track Color)

CMakeLists.txt

@@ -510,7 +510,8 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/track/keyutils.cpp
   src/track/playcounter.cpp
   src/track/replaygain.cpp
-  src/track/seratomarkers2.cpp
+  src/track/serato/markers.cpp
+  src/track/serato/markers2.cpp
   src/track/track.cpp
   src/track/trackfile.cpp
   src/track/trackinfo.cpp
@@ -961,6 +962,7 @@ add_executable(mixxx-test
   src/test/sampleutiltest.cpp
   src/test/schemamanager_test.cpp
   src/test/searchqueryparsertest.cpp
+  src/test/seratomarkerstest.cpp
   src/test/seratomarkers2test.cpp
   src/test/signalpathtest.cpp
   src/test/skincontext_test.cpp

build/depends.py

@@ -1205,7 +1205,8 @@ def sources(self, build):
                    "src/track/keyutils.cpp",
                    "src/track/playcounter.cpp",
                    "src/track/replaygain.cpp",
-                   "src/track/seratomarkers2.cpp",
+                   "src/track/serato/markers.cpp",
+                   "src/track/serato/markers2.cpp",
                    "src/track/track.cpp",
                    "src/track/globaltrackcache.cpp",
                    "src/track/trackfile.cpp",

src/test/seratomarkers2test.cpp

@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 
-#include "track/seratomarkers2.h"
+#include "track/serato/markers2.h"
 #include "util/memory.h"
 
 #include <taglib/tstring.h>
@@ -213,7 +213,7 @@ TEST_F(SeratoMarkers2Test, ParseLoopEntry) {
 }
 
 TEST_F(SeratoMarkers2Test, ParseMarkers2Data) {
-    QDir dir("src/test/seratomarkers2-data");
+    QDir dir("src/test/serato/data/markers2");
     dir.setFilter(QDir::Files);
     dir.setNameFilters(QStringList() << "*.octet-stream");
 

src/test/seratomarkerstest.cpp

@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+#include <taglib/textidentificationframe.h>
+#include <taglib/tstring.h>
+
+#include <QDir>
+#include <QtDebug>
+
+#include "track/serato/markers.h"
+#include "util/memory.h"
+
+namespace {
+
+class SeratoMarkersTest : public testing::Test {
+  protected:
+    void parseEntry(const QByteArray inputValue, bool valid, bool isSet, quint32 startPosition, quint32 endPosition, QRgb color, bool isLocked, quint8 type) {
+        const mixxx::SeratoMarkersEntry* pEntry = mixxx::SeratoMarkersEntry::parse(inputValue);
+        if (!pEntry) {
+            EXPECT_FALSE(valid);
+            return;
+        }
+        EXPECT_TRUE(valid);
+
+        EXPECT_EQ(isSet, pEntry->isSet());
+        EXPECT_EQ(startPosition, pEntry->getStartPosition());
+        EXPECT_EQ(endPosition, pEntry->getEndPosition());
+        EXPECT_EQ(color, pEntry->getColor());
+        EXPECT_EQ(isLocked, pEntry->isLocked());
+        EXPECT_EQ(type, pEntry->type());
+
+        EXPECT_EQ(inputValue, pEntry->data());
+    }
+
+    void parseMarkersData(const QByteArray inputValue, bool valid) {
+        mixxx::SeratoMarkers seratoMarkers;
+        bool parseOk = mixxx::SeratoMarkers::parse(&seratoMarkers, inputValue);
+        EXPECT_EQ(valid, parseOk);
+        if (!parseOk) {
+            return;
+        }
+
+        EXPECT_EQ(inputValue, seratoMarkers.data());
+    }
+};
+
+TEST_F(SeratoMarkersTest, ParseEntry) {
+    parseEntry(QByteArray("\x00\x00\x00\x00\x00\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x06\x30\x00\x00\x01", 21), false, false, -1, -1, QRgb(0x000000), false, 0);
+    parseEntry(QByteArray("\x00\x00\x00\x00\x00\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x06\x30\x00\x00\x01\x00", 22), true, true, 0, -1, QRgb(0xcc0000), false, 1);
+    parseEntry(QByteArray("\x00\x00\x0d\x2a\x58\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x06\x32\x10\x00\x01\x00", 22), true, true, 862808, -1, QRgb(0xcc8800), false, 1);
+    parseEntry(QByteArray("\x00\x00\x03\x54\x64\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x00\x00\x01\x4c\x01\x00", 22), true, true, 218212, -1, QRgb(0x0000cc), false, 1);
+    parseEntry(QByteArray("\x00\x00\x00\x00\x6c\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x06\x33\x18\x00\x01\x00", 22), true, true, 108, -1, QRgb(0xcccc00), false, 1);
+    parseEntry(QByteArray("\x00\x00\x00\x07\x77\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x00\x03\x18\x00\x01\x00", 22), true, true, 1911, -1, QRgb(0x00cc00), false, 1);
+    parseEntry(QByteArray("\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x00\x00\x00\x00\x01\x00", 22), true, false, -1, -1, QRgb(0x000000), false, 1);
+    parseEntry(QByteArray("\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x00\x7f\x7f\x7f\x7f\x7f\x00\x00\x00\x00\x03\x00", 22), true, false, -1, -1, QRgb(0x000000), false, 3);
+}
+
+TEST_F(SeratoMarkersTest, ParseMarkersData) {
+    QDir dir("src/test/serato/data/markers_");
+    dir.setFilter(QDir::Files);
+    dir.setNameFilters(QStringList() << "*.octet-stream");
+
+    QFileInfoList list = dir.entryInfoList();
+    for (int i = 0; i < list.size(); i++) {
+        QFileInfo fileInfo = list.at(i);
+        qDebug() << "--- File:" << fileInfo.fileName();
+        QFile file(dir.filePath(fileInfo.fileName()));
+        bool openOk = file.open(QIODevice::ReadOnly);
+        EXPECT_TRUE(openOk);
+        if (!openOk) {
+            continue;
+        }
+        QByteArray data = file.readAll();
+        parseMarkersData(data, true);
+    }
+}
+
+} // namespace

src/track/serato/markers.cpp

@@ -0,0 +1,179 @@
+#include "track/serato/markers.h"
+
+#include <QtEndian>
+#include <QStringLiteral>
+
+namespace {
+
+const int kEntrySize = 22;
+const char* kVersion = "\x02\x05";
+const int kVersionSize = 2;
+
+inline
+quint32 bytesToUInt32(const QByteArray& data) {
+    DEBUG_ASSERT(data.size() == sizeof(quint32));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
+    return qFromBigEndian<quint32>(data.constData());
+#else
+    return qFromBigEndian<quint32>(
+            reinterpret_cast<const uchar*>(data.constData()));
+#endif
+}
+
+QRgb colorToRgb(quint8 w, quint8 x, quint8 y, quint8 z) {
+    quint8 b = (z & 0x7F) | ((y & 0x01) << 7);
+    quint8 g = ((y & 0x7F) >> 1) | ((x & 0x03) << 6);
+    quint8 r = ((x & 0x7F) >> 2) | ((w & 0x07) << 5);
+    return QRgb(r << 16) | (g << 8) | b;
+}
+
+QRgb colorToRgb(const QByteArray& data) {
+    DEBUG_ASSERT(data.size() == 4);
+    return colorToRgb(data.at(0), data.at(1), data.at(2), data.at(3));
+}
+
+quint32 colorFromRgb(quint8 r, quint8 g, quint8 b) {
+    quint8 z = b & 0x7F;
+    quint8 y = ((b >> 7) | (g << 1)) & 0x7F;
+    quint8 x = ((g >> 6) | (r << 2)) & 0x7F;
+    quint8 w = (r >> 5);
+    return (w << 24) | (x << 16) | (y << 8) | z;
+}
+
+quint32 colorFromRgb(QRgb rgb) {
+    return colorFromRgb(qRed(rgb), qGreen(rgb), qBlue(rgb));
+}
+
+}
+
+namespace mixxx {
+
+QByteArray SeratoMarkersEntry::data() const {
+    QByteArray data;
+    data.resize(kEntrySize);
+
+    QDataStream stream(&data, QIODevice::WriteOnly);
+    stream.setVersion(QDataStream::Qt_5_0);
+    stream.setByteOrder(QDataStream::BigEndian);
+    stream << (quint8)(m_isSet ? '\x00' : '\x7F')
+           << (quint32)((m_startPosition == -1) ? 0x7F7F7F7F : m_startPosition)
+           << (quint8)((!m_isSet || m_type == 1) ? '\x7F' : m_isEnabled)
+           << (quint32)((m_endPosition == -1) ? 0x7F7F7F7F : m_endPosition);
+    stream.writeRawData("\x00\x7F\x7F\x7F\x7F\x7F", 6);
+    stream << (quint32)colorFromRgb(m_color)
+           << (quint8)m_type
+           << (quint8)m_isLocked;
+    return data;
+}
+
+SeratoMarkersEntry* SeratoMarkersEntry::parse(const QByteArray& data) {
+    if (data.length() != kEntrySize) {
+        qWarning() << "Parsing SeratoMarkersEntry failed:"
+                   << "Length" << data.length() << "!=" << kEntrySize;
+        return nullptr;
+    }
+
+    const bool isSet = (data.at(0) == '\x7F') ? false : true;
+    const quint32 uStartPosition = bytesToUInt32(data.mid(1, 4));
+    if (uStartPosition > 0x7FFFFFFF) {
+        qWarning() << "Parsing SeratoMarkersEntry failed:"
+                   << "startPosition > 0x7FFFFFF";
+        return nullptr;
+    }
+    const int startPosition = (uStartPosition == 0x7F7F7F7F) ? -1 : static_cast<int>(uStartPosition);
+
+    const bool isEnabled = static_cast<bool>(data.at(5));
+
+    const quint32 uEndPosition = bytesToUInt32(data.mid(6, 4));
+    if (uEndPosition > 0x7FFFFFFF) {
+        qWarning() << "Parsing SeratoMarkersEntry failed:"
+                   << "endPosition > 0x7FFFFFF";
+        return nullptr;
+    }
+    const int endPosition = (uEndPosition == 0x7F7F7F7F) ? -1 : static_cast<int>(uEndPosition);
+
+    if (data.mid(10, 6).compare("\x00\x7F\x7F\x7F\x7F") == 0) {
+        qWarning() << "Parsing SeratoMarkersEntry failed:"
+                   << "Unexpected value at offset 10";
+        return nullptr;
+    }
+
+    const QRgb color = colorToRgb(data.mid(16, 4));
+    const quint8 type = data.at(20);
+    const bool isLocked = static_cast<bool>(data.at(21));
+
+    SeratoMarkersEntry* pEntry = new SeratoMarkersEntry(
+            isSet,
+            startPosition,
+            isEnabled,
+            endPosition,
+            color,
+            type,
+            isLocked);
+    qDebug() << "SeratoMarkersEntry" << *pEntry;
+    return pEntry;
+}
+
+bool SeratoMarkers::parse(SeratoMarkers* seratoMarkers, const QByteArray& data) {
+    if (!data.startsWith(kVersion)) {
+        qWarning() << "Parsing SeratoMarkers_ failed:"
+                   << "Unknown Serato Markers_ tag version";
+        return false;
+    }
+
+    quint32 numEntries = bytesToUInt32(data.mid(2, 4));
+    QList<std::shared_ptr<SeratoMarkersEntry>> entries;
+
+    int offset = 6;
+    for (quint32 i = 0; i < numEntries; i++) {
+        if (data.size() <= (offset + kEntrySize)) {
+            qWarning() << "Parsing SeratoMarkers_ failed:"
+                       << "Incomplete entry" << data.mid(offset);
+            return false;
+        }
+
+        QByteArray entryData = data.mid(offset, kEntrySize);
+        SeratoMarkersEntryPointer pEntry = SeratoMarkersEntryPointer(
+                SeratoMarkersEntry::parse(entryData));
+        if (!pEntry) {
+            qWarning() << "Parsing SeratoMarkers_ failed:"
+                       << "Unable to parse entry!";
+            return false;
+        }
+        entries.append(pEntry);
+
+        offset += kEntrySize;
+    }
+
+    if (data.mid(offset).size() != 4) {
+        qWarning() << "Parsing SeratoMarkers_ failed:"
+                   << "Invalid footer" << data.mid(offset);
+        return false;
+    }
+
+    QRgb color = colorToRgb(data.mid(offset));
+
+    seratoMarkers->setEntries(entries);
+    seratoMarkers->setTrackColor(color);
+
+    return true;
+}
+
+QByteArray SeratoMarkers::data() const {
+    QByteArray data;
+    data.resize(kVersionSize + 2 * sizeof(quint32) + kEntrySize * m_entries.size());
+
+    QDataStream stream(&data, QIODevice::WriteOnly);
+    stream.setVersion(QDataStream::Qt_5_0);
+    stream.setByteOrder(QDataStream::BigEndian);
+    stream.writeRawData(kVersion, kVersionSize);
+    stream << m_entries.size();
+    for (int i = 0; i < m_entries.size(); i++) {
+        SeratoMarkersEntryPointer pEntry = m_entries.at(i);
+        stream.writeRawData(pEntry->data(), kEntrySize);
+    }
+    stream << colorFromRgb(m_trackColor);
+    return data;
+}
+
+} //namespace mixxx