First cut at native C++ MLT loader

cpp/include/mlt/metadata/stream.hpp

@@ -10,26 +10,28 @@
 
 namespace mlt::metadata::stream {
 
-enum class DictionaryType {
+enum class DictionaryType : std::uint32_t {
     NONE = 0,
     SINGLE = 1,
     SHARED = 2,
     VERTEX = 3,
     MORTON = 4,
     FSST = 5,
+    VALUE_COUNT = 6,
 };
 
-enum class LengthType {
+enum class LengthType : std::uint32_t {
     VAR_BINARY = 0,
     GEOMETRIES = 1,
     PARTS = 2,
     RINGS = 3,
     TRIANGLES = 4,
     SYMBOL = 5,
     DICTIONARY = 6,
+    VALUE_COUNT = 7,
 };
 
-enum class PhysicalLevelTechnique {
+enum class PhysicalLevelTechnique : std::uint32_t {
     NONE = 0,
     /// Preferred, tends to produce the best compression ratio and decoding performance.
     /// But currently limited to 32-bit integer.
@@ -39,29 +41,33 @@ enum class PhysicalLevelTechnique {
     VARINT = 2,
     /// Adaptive Lossless floating-Point Compression
     ALP = 3,
+    VALUE_COUNT = 4,
 };
 
-enum class LogicalLevelTechnique {
+enum class LogicalLevelTechnique : std::uint32_t {
     NONE = 0,
     DELTA = 1,
     COMPONENTWISE_DELTA = 2,
     RLE = 3,
     MORTON = 4,
     PSEUDODECIMAL = 5,
+    VALUE_COUNT = 6,
 };
 
-enum class OffsetType {
+enum class OffsetType : std::uint32_t {
     VERTEX = 0,
     INDEX = 1,
     STRING = 2,
     KEY = 3,
+    VALUE_COUNT = 4,
 };
 
-enum class PhysicalStreamType {
+enum class PhysicalStreamType : std::uint32_t {
     PRESENT = 0,
     DATA = 1,
     OFFSET = 2,
     LENGTH = 3,
+    VALUE_COUNT = 4,
 };
 
 class LogicalStreamType : public util::noncopyable {

cpp/src/mlt/decode/geometry.hpp

@@ -100,7 +100,6 @@ class GeometryDecoder {
                             switch (geomStreamMetadata->getPhysicalLevelTechnique()) {
                                 case PhysicalLevelTechnique::FAST_PFOR:
                                     throw std::runtime_error("FastPfor encoding for geometries is not yet supported.");
-                                    break;
                                 case PhysicalLevelTechnique::NONE:
                                 case PhysicalLevelTechnique::ALP:
                                     // TODO: other implementations are not clear on whether these are valid
@@ -109,6 +108,8 @@ class GeometryDecoder {
                                         .decodeIntStream<std::uint32_t, std::uint32_t, std::int32_t, /*isSigned=*/true>(
                                             tileData, geomColumn.vertices, *geomStreamMetadata);
                                     break;
+                                default:
+                                    throw std::runtime_error("Unsupported encoding for geometries: " + column.name);
                             };
                             break;
                         case DictionaryType::MORTON: {
@@ -119,6 +120,7 @@ class GeometryDecoder {
                                 tileData, geomColumn.vertices, mortonStreamMetadata);
                             break;
                         }
+                        default:
                         case DictionaryType::NONE:
                         case DictionaryType::SINGLE:
                         case DictionaryType::SHARED:
@@ -130,6 +132,8 @@ class GeometryDecoder {
                 }
                 case PhysicalStreamType::PRESENT:
                     break;
+                default:
+                    throw std::runtime_error("Unsupported logical stream type: " + column.name);
             }
         }
 
@@ -309,11 +313,11 @@ class GeometryDecoder {
                             rings.clear();
                         }
                     } else {
-                        if (partOffsetCounter + vertexOffsets.size() >= partOffsets.size() ||
-                            ringOffsetsCounter + vertexOffsets.size() >= ringOffsets.size()) {
+                        if (partOffsetCounter + numPolygons > partOffsets.size() ||
+                            ringOffsetsCounter + numPolygons > ringOffsets.size()) {
                             throw std::runtime_error("geometry error");
                         }
-                        for (std::size_t i = 0; i < vertexOffsets.size(); ++i) {
+                        for (std::size_t i = 0; i < numPolygons; ++i) {
                             const auto numRings = partOffsets[partOffsetCounter++];
                             const auto numVertices = ringOffsets[ringOffsetsCounter++];
                             rings.reserve(numRings - 1);
@@ -322,7 +326,7 @@ class GeometryDecoder {
                                 vertices, vertexOffsets, vertexOffsetsOffset, numVertices, true);
                             vertexOffsetsOffset += numVertices;
 
-                            if (ringOffsetsCounter + numRings > ringOffsets.size()) {
+                            if (ringOffsetsCounter + numRings - 1 > ringOffsets.size()) {
                                 throw std::runtime_error("geometry error");
                             }
                             for (count_t j = 1; j < numRings; ++j) {

cpp/src/mlt/decode/string.hpp

@@ -40,6 +40,8 @@ class StringDecoder {
         for (count_t i = 0; i < numStreams; ++i) {
             auto streamMetadata = StreamMetadata::decode(tileData);
             switch (streamMetadata->getPhysicalStreamType()) {
+                default:
+                    throw std::runtime_error("Unsupported stream type");
                 case PhysicalStreamType::PRESENT:
                     throw std::runtime_error("Present stream not supported for string columns");
                 case PhysicalStreamType::OFFSET:

cpp/src/mlt/metadata/stream.cpp

@@ -5,18 +5,35 @@
 namespace mlt::metadata::stream {
 
 namespace {
-std::optional<LogicalStreamType> decodeLogicalStreamType(PhysicalStreamType physicalStreamType, int value) noexcept {
+std::optional<LogicalStreamType> decodeLogicalStreamType(PhysicalStreamType physicalStreamType, int value) {
     switch (physicalStreamType) {
-        case PhysicalStreamType::DATA:
-            return static_cast<DictionaryType>(value);
-        case PhysicalStreamType::OFFSET:
-            return static_cast<OffsetType>(value);
-        case PhysicalStreamType::LENGTH:
-            return static_cast<LengthType>(value);
-        default:
+        case PhysicalStreamType::DATA: {
+            const auto type = static_cast<DictionaryType>(value);
+            if (type < DictionaryType::VALUE_COUNT) {
+                return type;
+            }
+            break;
+        }
+        case PhysicalStreamType::OFFSET: {
+            const auto type = static_cast<OffsetType>(value);
+            if (type < OffsetType::VALUE_COUNT) {
+                return type;
+            }
+            break;
+        }
+        case PhysicalStreamType::LENGTH: {
+            const auto type = static_cast<LengthType>(value);
+            if (type < LengthType::VALUE_COUNT) {
+                return type;
+            }
+            break;
+        }
         case PhysicalStreamType::PRESENT:
             return {};
+        default:
+            break;
     }
+    throw std::runtime_error("Invalid logical stream type: " + std::to_string(std::to_underlying(physicalStreamType)));
 }
 } // namespace
 
@@ -65,6 +82,13 @@ StreamMetadata StreamMetadata::decodeInternal(BufferStream& buffer) {
     const auto logicalLevelTechnique2 = static_cast<LogicalLevelTechnique>((encodingsHeader >> 2) & 0x7);
     const auto physicalLevelTechnique = static_cast<PhysicalLevelTechnique>(encodingsHeader & 0x3);
 
+    if (physicalStreamType >= PhysicalStreamType::VALUE_COUNT ||
+        logicalLevelTechnique1 >= LogicalLevelTechnique::VALUE_COUNT ||
+        logicalLevelTechnique2 >= LogicalLevelTechnique::VALUE_COUNT ||
+        physicalLevelTechnique >= PhysicalLevelTechnique::VALUE_COUNT) {
+        throw std::runtime_error("Invalid stream encoding");
+    }
+
     using namespace util::decoding;
     const auto [numValues, byteLength] = decodeVarints<std::uint32_t, 2>(buffer);