LibImage: Move userspace image parsing to its own library

The image utility now uses this tool instead of parsing images on its
own.

LibImage/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.26)
+
+project(libimage CXX)
+
+set(LIBIMAGE_SOURCES
+	Image.cpp
+	Netbpm.cpp
+)
+
+add_custom_target(libimage-headers
+	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
+	DEPENDS sysroot
+)
+
+add_library(libimage ${LIBIMAGE_SOURCES})
+add_dependencies(libimage headers libc-install)
+target_link_libraries(libimage PUBLIC libc)
+
+add_custom_target(libimage-install
+	COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/libimage.a ${BANAN_LIB}/
+	DEPENDS libimage
+	BYPRODUCTS ${BANAN_LIB}/libimage.a
+)
+
+set(CMAKE_STATIC_LIBRARY_PREFIX "")

LibImage/Image.cpp

@@ -0,0 +1,79 @@
+#include <BAN/ScopeGuard.h>
+#include <BAN/String.h>
+
+#include <LibImage/Image.h>
+#include <LibImage/Netbpm.h>
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+namespace LibImage
+{
+
+	BAN::ErrorOr<BAN::UniqPtr<Image>> Image::load_from_file(BAN::StringView path)
+	{
+		int fd = -1;
+
+		if (path.data()[path.size()] == '\0')
+		{
+			fd = open(path.data(), O_RDONLY);
+		}
+		else
+		{
+			BAN::String path_str;
+			TRY(path_str.append(path));
+			fd = open(path_str.data(), O_RDONLY);
+		}
+
+		if (fd == -1)
+		{
+			fprintf(stddbg, "open: %s\n", strerror(errno));
+			return BAN::Error::from_errno(errno);
+		}
+
+		BAN::ScopeGuard guard_file_close([fd] { close(fd); });
+
+		struct stat st;
+		if (fstat(fd, &st) == -1)
+		{
+			fprintf(stddbg, "fstat: %s\n", strerror(errno));
+			return BAN::Error::from_errno(errno);
+		}
+
+		if (st.st_size < 2)
+		{
+			fprintf(stddbg, "invalid image (too small)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+
+		void* addr = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+		if (addr == MAP_FAILED)
+		{
+			fprintf(stddbg, "mmap: %s\n", strerror(errno));
+			return BAN::Error::from_errno(errno);
+		}
+
+		BAN::ScopeGuard guard_munmap([&] { munmap(addr, st.st_size); });
+
+		auto image_data_span = BAN::ConstByteSpan(reinterpret_cast<uint8_t*>(addr), st.st_size);
+
+		uint16_t u16_signature = image_data_span.as<const uint16_t>();
+		switch (u16_signature)
+		{
+			case 0x3650:
+			case 0x3550:
+			case 0x3450:
+			case 0x3350:
+			case 0x3250:
+			case 0x3150:
+				return TRY(load_netbpm(image_data_span));
+			default:
+				fprintf(stderr, "unrecognized image format\n");
+				break;
+		}
+
+		return BAN::Error::from_errno(ENOTSUP);
+	}
+
+}

LibImage/Netbpm.cpp

@@ -0,0 +1,120 @@
+#include <BAN/Optional.h>
+
+#include <LibImage/Netbpm.h>
+
+#include <ctype.h>
+#include <inttypes.h>
+#include <stdio.h>
+
+namespace LibImage
+{
+
+	static BAN::Optional<uint64_t> parse_u64(BAN::ConstByteSpan& data)
+	{
+		size_t digit_count = 0;
+		while (digit_count < data.size() && isdigit(data[digit_count]))
+			digit_count++;
+		if (digit_count == 0)
+			return {};
+
+		uint64_t result = 0;
+		for (size_t i = 0; i < digit_count; i++)
+		{
+			if (BAN::Math::will_multiplication_overflow<uint64_t>(result, 10))
+				return {};
+			result *= 10;
+
+			if (BAN::Math::will_addition_overflow<uint64_t>(result, data[i] - '0'))
+				return {};
+			result += data[i] - '0';
+		}
+
+		data = data.slice(digit_count);
+
+		return result;
+	}
+
+	BAN::ErrorOr<BAN::UniqPtr<Image>> load_netbpm(BAN::ConstByteSpan image_data)
+	{
+		if (image_data.size() < 11)
+		{
+			fprintf(stddbg, "invalid Netbpm image (too small)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+
+		if (image_data[0] != 'P')
+		{
+			fprintf(stddbg, "not Netbpm image\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+		if (image_data[1] != '6')
+		{
+			fprintf(stddbg, "unsupported Netbpm image\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+		if (image_data[2] != '\n')
+		{
+			fprintf(stddbg, "invalid Netbpm image (invalid header)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+		image_data = image_data.slice(3);
+
+		auto opt_width = parse_u64(image_data);
+		if (!opt_width.has_value() || image_data[0] != ' ')
+		{
+			fprintf(stddbg, "invalid Netbpm image (invalid width)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+		image_data = image_data.slice(1);
+		auto width = opt_width.value();
+
+		auto opt_height = parse_u64(image_data);
+		if (!opt_height.has_value() || image_data[0] != '\n')
+		{
+			fprintf(stddbg, "invalid Netbpm image (invalid height)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+		image_data = image_data.slice(1);
+		auto height = opt_height.value();
+
+		if (BAN::Math::will_multiplication_overflow<uint64_t>(width, height) || BAN::Math::will_multiplication_overflow<uint64_t>(width * height, 3))
+		{
+			fprintf(stddbg, "invalid Netbpm image (size is over 64 bits overflows)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+
+		auto header_end = parse_u64(image_data);
+		if (!header_end.has_value() || *header_end != 255 || image_data[0] != '\n')
+		{
+			fprintf(stddbg, "invalid Netbpm image (invalid header end)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+		image_data = image_data.slice(1);
+
+		if (image_data.size() < width * height * 3)
+		{
+			fprintf(stddbg, "invalid Netbpm image (too small file size)\n");
+			return BAN::Error::from_errno(EINVAL);
+		}
+
+		BAN::Vector<Image::Color> bitmap;
+		TRY(bitmap.resize(width * height));
+
+		// Fill bitmap
+		for (uint64_t y = 0; y < height; y++)
+		{
+			for (uint64_t x = 0; x < width; x++)
+			{
+				const uint64_t index = y * width + x;
+				auto& pixel = bitmap[index];
+				pixel.r = image_data[index * 3 + 0];
+				pixel.g = image_data[index * 3 + 1];
+				pixel.b = image_data[index * 3 + 2];
+				pixel.a = 0xFF;
+			}
+		}
+
+		return TRY(BAN::UniqPtr<Image>::create(width, height, BAN::move(bitmap)));
+	}
+
+}

LibImage/include/LibImage/Image.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <BAN/StringView.h>
+#include <BAN/UniqPtr.h>
+#include <BAN/Vector.h>
+
+namespace LibImage
+{
+
+	class Image
+	{
+	public:
+		struct Color
+		{
+			uint8_t r;
+			uint8_t g;
+			uint8_t b;
+			uint8_t a;
+		};
+
+	public:
+		static BAN::ErrorOr<BAN::UniqPtr<Image>> load_from_file(BAN::StringView path);
+
+		Color get_color(uint64_t x, uint64_t y) const { return m_bitmap[y * width() + x]; }
+		const BAN::Vector<Color> bitmap() const { return m_bitmap; }
+
+		uint64_t width() const { return m_width; }
+		uint64_t height() const { return m_height; }
+
+	private:
+		Image(uint64_t width, uint64_t height, BAN::Vector<Color>&& bitmap)
+			: m_width(width)
+			, m_height(height)
+			, m_bitmap(BAN::move(bitmap))
+		{
+			ASSERT(m_bitmap.size() >= width * height);
+		}
+
+	private:
+		const uint64_t m_width;
+		const uint64_t m_height;
+		const BAN::Vector<Color> m_bitmap;
+
+		friend class BAN::UniqPtr<Image>;
+	};
+
+}

LibImage/include/LibImage/Netbpm.h

@@ -0,0 +1,10 @@
+#include <BAN/ByteSpan.h>
+
+#include <LibImage/Image.h>
+
+namespace LibImage
+{
+
+	BAN::ErrorOr<BAN::UniqPtr<Image>> load_netbpm(BAN::ConstByteSpan);
+
+}