refactor(input): consume cvmmap-core package

src/ipc/contracts.cpp

@@ -1,5 +1,7 @@
 #include "cvmmap_streamer/ipc/contracts.hpp"
 
+#include <cvmmap/parser.hpp>
+
 #include <algorithm>
 #include <limits>
 
@@ -109,6 +111,40 @@ namespace {
 		}
 	}
 
+	[[nodiscard]]
+	ParseError map_core_parser_error(const std::string_view error) {
+		if (error.contains("magic")) {
+			return ParseError::InvalidMagic;
+		}
+		if (error.contains("version")) {
+			return ParseError::UnsupportedVersion;
+		}
+		if (error.contains("depth")) {
+			return ParseError::InvalidDepth;
+		}
+		if (error.contains("pixel_format")) {
+			return ParseError::InvalidPixelFormat;
+		}
+		return ParseError::InvalidSize;
+	}
+
+	[[nodiscard]]
+	FrameMetadata from_core_metadata(const cvmmap::frame_metadata_t &metadata) {
+		FrameMetadata converted{};
+		std::copy_n(metadata.magic, converted.magic.size(), converted.magic.begin());
+		converted.versions_major     = metadata.versions_major;
+		converted.versions_minor     = metadata.versions_minor;
+		converted.frame_count        = metadata.frame_count;
+		converted.timestamp_ns       = metadata.timestamp_ns;
+		converted.info.width         = metadata.info.width;
+		converted.info.height        = metadata.info.height;
+		converted.info.channels      = metadata.info.channels;
+		converted.info.depth         = static_cast<Depth>(metadata.info.depth);
+		converted.info.pixel_format  = static_cast<PixelFormat>(metadata.info.pixel_format);
+		converted.info.buffer_size   = metadata.info.buffer_size;
+		return converted;
+	}
+
 }
 
 std::string_view to_string(ParseError error) {
@@ -301,22 +337,16 @@ std::expected<ValidatedShmView, ParseError> validate_shm_region(std::span<const
 		return std::unexpected(ParseError::BufferTooSmall);
 	}
 
-	auto metadata_result = parse_frame_metadata(shm_region);
+	auto metadata_result = cvmmap::parse_frame_metadata_regions(
+		shm_region.first(kShmPayloadOffset),
+		shm_region.subspan(kShmPayloadOffset));
 	if (!metadata_result) {
-		return std::unexpected(metadata_result.error());
-	}
-
-	const auto payload_size = static_cast<std::size_t>(metadata_result->info.buffer_size);
-	if (payload_size > std::numeric_limits<std::size_t>::max() - kShmPayloadOffset) {
-		return std::unexpected(ParseError::InvalidSize);
-	}
-	if (payload_size > shm_region.size() - kShmPayloadOffset) {
-		return std::unexpected(ParseError::InvalidSize);
+		return std::unexpected(map_core_parser_error(metadata_result.error()));
 	}
 
 	return ValidatedShmView{
-		.metadata = *metadata_result,
-		.payload  = shm_region.subspan(kShmPayloadOffset, payload_size)};
+		.metadata = from_core_metadata(metadata_result->normalized_metadata),
+		.payload  = metadata_result->left_plane};
 }
 
 std::expected<CoherentSnapshot, SnapshotError> read_coherent_snapshot(