From 7874702f30d5855319faf197b10aed31f07f5e27 Mon Sep 17 00:00:00 2001 From: Hop311 Date: Mon, 22 May 2023 10:36:23 +0100 Subject: BMP palette parser + Logger macro --- src/openvic/utility/BMP.cpp | 162 +++++++++++++++++++++++++++++++++++++++++ src/openvic/utility/BMP.hpp | 48 ++++++++++++ src/openvic/utility/Logger.cpp | 18 +++++ src/openvic/utility/Logger.hpp | 80 ++++++++++++++++++++ 4 files changed, 308 insertions(+) create mode 100644 src/openvic/utility/BMP.cpp create mode 100644 src/openvic/utility/BMP.hpp create mode 100644 src/openvic/utility/Logger.cpp create mode 100644 src/openvic/utility/Logger.hpp (limited to 'src/openvic/utility') diff --git a/src/openvic/utility/BMP.cpp b/src/openvic/utility/BMP.cpp new file mode 100644 index 0000000..eb3e2b1 --- /dev/null +++ b/src/openvic/utility/BMP.cpp @@ -0,0 +1,162 @@ +#include "BMP.hpp" + +#include + +#include "Logger.hpp" + +using namespace OpenVic; + +BMP::~BMP() { + close(); +} + +return_t BMP::open(char const* filepath) { + reset(); + errno = 0; + file = fopen(filepath, "rb"); + if (file == nullptr || errno != 0) { + Logger::error("Failed to open BMP file \"", filepath, "\" (errno = ", errno, ")"); + file = nullptr; + return FAILURE; + } + return SUCCESS; +} + +return_t BMP::read_header() { + if (header_validated) { + Logger::error("BMP header already validated!"); + return FAILURE; + } + if (file == nullptr) { + Logger::error("Cannot read BMP header before opening a file"); + return FAILURE; + } + if (fseek(file, 0, SEEK_SET) != 0) { + Logger::error("Failed to move to the beginning of the BMP file!"); + return FAILURE; + } + if (fread(&header, sizeof(header), 1, file) != 1) { + Logger::error("Failed to read BMP header!"); + return FAILURE; + } + return_t ret = SUCCESS; + + // Validate constants + static constexpr uint16_t BMP_SIGNATURE = 0x4d42; + if (header.signature != BMP_SIGNATURE) { + Logger::error("Invalid BMP signature: ", header.signature, " (must be ", BMP_SIGNATURE, ")"); + ret = FAILURE; + } + static constexpr uint32_t DIB_HEADER_SIZE = 40; + if (header.dib_header_size != DIB_HEADER_SIZE) { + Logger::error("Invalid BMP DIB header size: ", header.dib_header_size, " (must be ", DIB_HEADER_SIZE, ")"); + ret = FAILURE; + } + static constexpr uint16_t NUM_PLANES = 1; + if (header.num_planes != NUM_PLANES) { + Logger::error("Invalid BMP plane count: ", header.num_planes, " (must be ", NUM_PLANES, ")"); + ret = FAILURE; + } + static constexpr uint16_t COMPRESSION = 0; // Only support uncompressed BMPs + if (header.compression != COMPRESSION) { + Logger::error("Invalid BMP compression method: ", header.compression, " (must be ", COMPRESSION, ")"); + ret = FAILURE; + } + + // Validate sizes and dimensions + // TODO - image_size_bytes can be 0 for non-compressed BMPs + if (header.file_size != header.offset + header.image_size_bytes) { + Logger::error("Invalid BMP memory sizes: file size = ", header.file_size, " != ", header.offset + header.image_size_bytes, + " = ", header.offset, " + ", header.image_size_bytes, " = image data offset + image data size"); + ret = FAILURE; + } + // TODO - support negative widths (i.e. horizontal flip) + if (header.width_px <= 0) { + Logger::error("Invalid BMP width: ", header.width_px, " (must be positive)"); + ret = FAILURE; + } + // TODO - support negative heights (i.e. vertical flip) + if (header.height_px <= 0) { + Logger::error("Invalid BMP height: ", header.height_px, " (must be positive)"); + ret = FAILURE; + } + // TODO - validate x_resolution_ppm + // TODO - validate y_resolution_ppm + + // Validate colours +#define VALID_BITS_PER_PIXEL 1, 2, 4, 8, 16, 24, 32 +#define STR(x) #x + static const std::set BITS_PER_PIXEL { VALID_BITS_PER_PIXEL }; + if (!BITS_PER_PIXEL.contains(header.bits_per_pixel)) { + Logger::error("Invalid BMP bits per pixel: ", header.bits_per_pixel, " (must be one of " STR(VALID_BITS_PER_PIXEL) ")"); + ret = FAILURE; + } +#undef VALID_BITS_PER_PIXEL +#undef STR + static constexpr uint16_t PALETTE_BITS_PER_PIXEL_LIMIT = 8; + if (header.num_colours != 0 && header.bits_per_pixel > PALETTE_BITS_PER_PIXEL_LIMIT) { + Logger::error("Invalid BMP palette size: ", header.num_colours, " (should be 0 as bits per pixel is ", header.bits_per_pixel, " > 8)"); + ret = FAILURE; + } + // TODO - validate important_colours + + palette_size = header.bits_per_pixel > PALETTE_BITS_PER_PIXEL_LIMIT ? 0 + // Use header.num_colours if it's greater than 0 and at most 1 << header.bits_per_pixel + : 0 < header.num_colours && header.num_colours - 1 >> header.bits_per_pixel == 0 ? header.num_colours + : 1 << header.bits_per_pixel; + + const uint32_t expected_offset = palette_size * PALETTE_COLOUR_SIZE + sizeof(header); + if (header.offset != expected_offset) { + Logger::error("Invalid BMP image data offset: ", header.offset, " (should be ", expected_offset, ")"); + ret = FAILURE; + } + + header_validated = ret == SUCCESS; + return ret; +} + +return_t BMP::read_palette() { + if (file == nullptr) { + Logger::error("Cannot read BMP palette before opening a file"); + return FAILURE; + } + if (!header_validated) { + Logger::error("Cannot read palette before BMP header is validated!"); + return FAILURE; + } + if (palette_size == 0) { + Logger::error("Cannot read BMP palette - header indicates this file doesn't have one"); + return FAILURE; + } + if (fseek(file, sizeof(header), SEEK_SET) != 0) { + Logger::error("Failed to move to the palette in the BMP file!"); + return FAILURE; + } + palette.resize(palette_size); + if (fread(palette.data(), palette_size * PALETTE_COLOUR_SIZE, 1, file) != 1) { + Logger::error("Failed to read BMP header!"); + palette.clear(); + return FAILURE; + } + return SUCCESS; +} + +void BMP::close() { + if (file != nullptr) { + if (fclose(file) != 0) + Logger::error("Failed to close BMP!"); + file = nullptr; + } +} + +void BMP::reset() { + close(); + memset(&header, 0, sizeof(header)); + header_validated = false; + palette_size = 0; + palette.clear(); +} + +std::vector const& BMP::get_palette() const { + return palette; +} diff --git a/src/openvic/utility/BMP.hpp b/src/openvic/utility/BMP.hpp new file mode 100644 index 0000000..c6f5815 --- /dev/null +++ b/src/openvic/utility/BMP.hpp @@ -0,0 +1,48 @@ +#pragma once + +#include "../Types.hpp" + +namespace OpenVic { + class BMP { +#pragma pack(push) +#pragma pack(1) + struct header_t { + uint16_t signature; // Signature: 0x4d42 (or 'B' 'M') + uint32_t file_size; // File size in bytes + uint16_t reserved1; // Not used + uint16_t reserved2; // Not used + uint32_t offset; // Offset to image data in bytes from beginning of file + uint32_t dib_header_size; // DIB header size in bytes + int32_t width_px; // Width of the image + int32_t height_px; // Height of image + uint16_t num_planes; // Number of colour planes + uint16_t bits_per_pixel; // Bits per pixel + uint32_t compression; // Compression type + uint32_t image_size_bytes; // Image size in bytes + int32_t x_resolution_ppm; // Pixels per meter + int32_t y_resolution_ppm; // Pixels per meter + uint32_t num_colours; // Number of colours + uint32_t important_colours; // Important colours + } header; +#pragma pack(pop) + + FILE* file = nullptr; + bool header_validated = false; + uint32_t palette_size = 0; + std::vector palette; + + public: + static constexpr uint32_t PALETTE_COLOUR_SIZE = sizeof(colour_t); + + BMP() = default; + ~BMP(); + + return_t open(char const* filepath); + return_t read_header(); + return_t read_palette(); + void close(); + void reset(); + + std::vector const& get_palette() const; + }; +} diff --git a/src/openvic/utility/Logger.cpp b/src/openvic/utility/Logger.cpp new file mode 100644 index 0000000..fe97473 --- /dev/null +++ b/src/openvic/utility/Logger.cpp @@ -0,0 +1,18 @@ +#include "Logger.hpp" + +#include + +using namespace OpenVic; + +Logger::log_func_t Logger::info_func = [](std::string&& str) { std::cout << str; }; +Logger::log_func_t Logger::error_func = [](std::string&& str) { std::cerr << str; }; + +char const* Logger::get_filename(char const* filepath) { + if (filepath == nullptr) return nullptr; + char const* last_slash = filepath; + while (*filepath != '\0') { + if (*filepath == '\\' || *filepath == '/') last_slash = filepath + 1; + filepath++; + } + return last_slash; +} diff --git a/src/openvic/utility/Logger.hpp b/src/openvic/utility/Logger.hpp new file mode 100644 index 0000000..ac82445 --- /dev/null +++ b/src/openvic/utility/Logger.hpp @@ -0,0 +1,80 @@ +#pragma once + +#include +#include +#ifdef __cpp_lib_source_location +#include +#endif + +namespace OpenVic { + +#ifndef __cpp_lib_source_location +#include + // Implementation of std::source_location for compilers that do not support it + // Note: uses non-standard extensions that are supported by Clang, GCC, and MSVC + // https://clang.llvm.org/docs/LanguageExtensions.html#source-location-builtins + // https://stackoverflow.com/a/67970107 + class source_location { + std::string _file; + int _line; + std::string _function; + + public: + source_location(std::string f, int l, std::string n) : _file(f), _line(l), _function(n) {} + static source_location current(std::string f = __builtin_FILE(), int l = __builtin_LINE(), std::string n = __builtin_FUNCTION()) { + return source_location(f, l, n); + } + + inline char const* file_name() const { return _file.c_str(); } + inline int line() const { return _line; } + inline char const* function_name() const { return _function.c_str(); } + }; +#endif + + class Logger { + using log_func_t = std::function; + +#ifdef __cpp_lib_source_location + using source_location = std::source_location; +#else + using source_location = OpenVic::source_location; +#endif + + static char const* get_filename(char const* filepath); + + template + struct log { + log(log_func_t log_func, Ts&&... ts, source_location const& location) { + if (log_func) { + std::stringstream stream; + stream << "\n" << get_filename(location.file_name()) << "(" + << location.line() << ") `" << location.function_name() << "`: "; + ((stream << std::forward(ts)), ...); + stream << std::endl; + log_func(stream.str()); + } + } + }; + +#define LOG_FUNC(name) \ + private: \ + static log_func_t name##_func; \ + public: \ + static void set_##name##_func(log_func_t log_func) { \ + name##_func = log_func; \ + } \ + template \ + struct name { \ + name(Ts&&... ts, source_location const& location = source_location::current()) { \ + log{ name##_func, std::forward(ts)..., location }; \ + } \ + }; \ + template \ + name(Ts&&...) -> name; + + LOG_FUNC(info) + LOG_FUNC(error) + +#undef LOG_FUNC + }; +} -- cgit v1.2.3-56-ga3b1