add support for 1, 8 and 32 bit bmps

lib/BmpReader/BmpReader.cpp

@@ -0,0 +1,210 @@
+#include "BmpReader.h"
+
+#include <cstdlib>
+#include <cstring>
+
+uint16_t BmpReader::readLE16(File& f) {
+  const int c0 = f.read();
+  const int c1 = f.read();
+  const uint8_t b0 = (uint8_t)(c0 < 0 ? 0 : c0);
+  const uint8_t b1 = (uint8_t)(c1 < 0 ? 0 : c1);
+  return (uint16_t)b0 | ((uint16_t)b1 << 8);
+}
+
+uint32_t BmpReader::readLE32(File& f) {
+  const int c0 = f.read();
+  const int c1 = f.read();
+  const int c2 = f.read();
+  const int c3 = f.read();
+
+  const uint8_t b0 = (uint8_t)(c0 < 0 ? 0 : c0);
+  const uint8_t b1 = (uint8_t)(c1 < 0 ? 0 : c1);
+  const uint8_t b2 = (uint8_t)(c2 < 0 ? 0 : c2);
+  const uint8_t b3 = (uint8_t)(c3 < 0 ? 0 : c3);
+
+  return (uint32_t)b0 | ((uint32_t)b1 << 8) | ((uint32_t)b2 << 16) | ((uint32_t)b3 << 24);
+}
+
+void BmpReader::freeMonoBitmap(MonoBitmap& bmp) {
+  if (bmp.data) {
+    free(bmp.data);
+    bmp.data = nullptr;
+  }
+  bmp.width = 0;
+  bmp.height = 0;
+  bmp.len = 0;
+}
+
+const char* BmpReader::errorToString(BmpReaderError err) {
+  switch (err) {
+    case BmpReaderError::Ok:
+      return "Ok";
+    case BmpReaderError::FileInvalid:
+      return "FileInvalid";
+    case BmpReaderError::SeekStartFailed:
+      return "SeekStartFailed";
+    case BmpReaderError::NotBMP:
+      return "NotBMP (missing 'BM')";
+    case BmpReaderError::DIBTooSmall:
+      return "DIBTooSmall (<40 bytes)";
+    case BmpReaderError::BadPlanes:
+      return "BadPlanes (!= 1)";
+    case BmpReaderError::UnsupportedBpp:
+      return "UnsupportedBpp (expected 24, 32 or 1)";
+    case BmpReaderError::UnsupportedCompression:
+      return "UnsupportedCompression (expected BI_RGB or BI_BITFIELDS for 32bpp)";
+    case BmpReaderError::BadDimensions:
+      return "BadDimensions";
+    case BmpReaderError::SeekPixelDataFailed:
+      return "SeekPixelDataFailed";
+    case BmpReaderError::OomOutput:
+      return "OomOutput";
+    case BmpReaderError::OomRowBuffer:
+      return "OomRowBuffer";
+    case BmpReaderError::ShortReadRow:
+      return "ShortReadRow";
+  }
+  return "Unknown";
+}
+
+BmpReaderError BmpReader::read(File& file, MonoBitmap& out, uint8_t threshold) {
+  freeMonoBitmap(out);
+
+  if (!file) return BmpReaderError::FileInvalid;
+  if (!file.seek(0)) return BmpReaderError::SeekStartFailed;
+
+  // --- BMP FILE HEADER ---
+  const uint16_t bfType = readLE16(file);
+  if (bfType != 0x4D42) return BmpReaderError::NotBMP;
+
+  (void)readLE32(file);
+  (void)readLE16(file);
+  (void)readLE16(file);
+  const uint32_t bfOffBits = readLE32(file);
+
+  // --- DIB HEADER ---
+  const uint32_t biSize = readLE32(file);
+  if (biSize < 40) return BmpReaderError::DIBTooSmall;
+
+  const int32_t srcW = (int32_t)readLE32(file);
+  int32_t srcHRaw = (int32_t)readLE32(file);
+  const uint16_t planes = readLE16(file);
+  const uint16_t bpp = readLE16(file);
+  const uint32_t comp = readLE32(file);
+  const bool is24Bit = (bpp == 24);
+  const bool is32Bit = (bpp == 32);
+  const bool is8Bit = (bpp == 8);
+  const bool is1Bit = (bpp == 1);
+
+  if (planes != 1) return BmpReaderError::BadPlanes;
+  if (!is24Bit && !is32Bit && !is8Bit && !is1Bit) return BmpReaderError::UnsupportedBpp;
+  // Allow BI_RGB (0) for all, and BI_BITFIELDS (3) for 32bpp which is common for BGRA masks.
+  if (!(comp == 0 || (is32Bit && comp == 3))) return BmpReaderError::UnsupportedCompression;
+
+  (void)readLE32(file);  // biSizeImage
+  (void)readLE32(file);  // biXPelsPerMeter
+  (void)readLE32(file);  // biYPelsPerMeter
+  const uint32_t clrUsed = readLE32(file);
+  (void)readLE32(file);  // biClrImportant
+
+  if (srcW <= 0) return BmpReaderError::BadDimensions;
+
+  const bool topDown = (srcHRaw < 0);
+  const int32_t srcH = topDown ? -srcHRaw : srcHRaw;
+  if (srcH <= 0) return BmpReaderError::BadDimensions;
+
+  // Output dimensions after 90° CCW rotation
+  out.width = (int)srcH;
+  out.height = (int)srcW;
+
+  const size_t outBytesPerRow = (size_t)(out.width + 7) / 8;
+  out.len = outBytesPerRow * (size_t)out.height;
+
+  out.data = (uint8_t*)malloc(out.len);
+  if (!out.data) return BmpReaderError::OomOutput;
+  memset(out.data, 0xFF, out.len);
+
+  // Palette for 8-bit indexed images
+  uint8_t paletteLum[256];
+  if (is8Bit) {
+    for (int i = 0; i < 256; i++) paletteLum[i] = (uint8_t)i;  // default grayscale ramp
+    uint32_t paletteCount = (clrUsed == 0) ? 256u : clrUsed;
+    if (paletteCount > 256u) paletteCount = 256u;
+    for (uint32_t i = 0; i < paletteCount; i++) {
+      const int b = file.read();
+      const int g = file.read();
+      const int r = file.read();
+      (void)file.read();  // reserved
+      const uint8_t bb = (uint8_t)(b < 0 ? 0 : b);
+      const uint8_t gg = (uint8_t)(g < 0 ? 0 : g);
+      const uint8_t rr = (uint8_t)(r < 0 ? 0 : r);
+      paletteLum[i] = (uint8_t)((77u * rr + 150u * gg + 29u * bb) >> 8);
+    }
+  }
+
+  // Source row stride (padded to 4 bytes)
+  uint32_t bytesPerPixel = 0u;
+  if (is8Bit) {
+    bytesPerPixel = 1u;
+  } else if (is32Bit) {
+    bytesPerPixel = 4u;
+  } else if (is24Bit) {
+    bytesPerPixel = 3u;
+  }
+  const uint32_t srcBytesPerRow =
+      is1Bit ? ((uint32_t)srcW + 7u) / 8u : (uint32_t)srcW * bytesPerPixel;  // bpp==1 ignores bytesPerPixel
+  const uint32_t srcRowStride = (srcBytesPerRow + 3u) & ~3u;
+
+  if (!file.seek(bfOffBits)) {
+    freeMonoBitmap(out);
+    return BmpReaderError::SeekPixelDataFailed;
+  }
+
+  uint8_t* rowBuf = (uint8_t*)malloc(srcRowStride);
+  if (!rowBuf) {
+    freeMonoBitmap(out);
+    return BmpReaderError::OomRowBuffer;
+  }
+
+  for (int fileRow = 0; fileRow < (int)srcH; fileRow++) {
+    if (file.read(rowBuf, srcRowStride) != (int)srcRowStride) {
+      free(rowBuf);
+      freeMonoBitmap(out);
+      return BmpReaderError::ShortReadRow;
+    }
+
+    const int srcY = topDown ? fileRow : ((int)srcH - 1 - fileRow);
+
+    for (int srcX = 0; srcX < (int)srcW; srcX++) {
+      bool isBlack;
+      if (is1Bit) {
+        const uint8_t byte = rowBuf[srcX >> 3];
+        const uint8_t mask = (uint8_t)(0x80u >> (srcX & 7));
+        const bool bitSet = (byte & mask) != 0;
+        // In 1bpp BMPs, palette index 0 is conventionally black and index 1 is white.
+        isBlack = !bitSet;
+      } else if (is8Bit) {
+        const uint8_t idx = rowBuf[srcX];
+        const uint8_t lum = paletteLum[idx];
+        isBlack = (lum < threshold);
+      } else {
+        const uint8_t* px = &rowBuf[srcX * bytesPerPixel];
+        const uint8_t b = px[0];
+        const uint8_t g = px[1];
+        const uint8_t r = px[2];
+
+        const uint8_t lum = (uint8_t)((77u * r + 150u * g + 29u * b) >> 8);
+        isBlack = (lum < threshold);
+      }
+
+      // 90° counter-clockwise: (x,y) -> (y, w-1-x)
+      const int outX = srcY;
+      const int outY = (int)srcW - 1 - srcX;
+
+      setMonoPixel(out.data, out.width, outX, outY, isBlack);
+    }
+  }
+
+  free(rowBuf);
+  return BmpReaderError::Ok;
+}

lib/BmpReader/BmpReader.h

@@ -10,7 +10,7 @@ struct MonoBitmap {
   uint8_t* data = nullptr;  // row-aligned, MSB-first, 1=white 0=black
 };
 
-enum class BmpToMonoError : uint8_t {
+enum class BmpReaderError : uint8_t {
   Ok = 0,
   FileInvalid,
   SeekStartFailed,
@@ -30,14 +30,15 @@ enum class BmpToMonoError : uint8_t {
   ShortReadRow,
 };
 
-class BmpToMono {
+class BmpReader {
  public:
   // Rotate 90° counter-clockwise: (w,h) -> (h,w)
   // Used for converting portrait BMP (480x800) into landscape framebuffer (800x480)
-  static BmpToMonoError convert24BitRotate90CCW(File& file, MonoBitmap& out, uint8_t threshold = 160);
+  // Supports 8-bit, 24-bit, 32-bit color and 1-bit monochrome BMPs.
+  static BmpReaderError read(File& file, MonoBitmap& out, uint8_t threshold = 160);
 
   static void freeMonoBitmap(MonoBitmap& bmp);
-  static const char* errorToString(BmpToMonoError err);
+  static const char* errorToString(BmpReaderError err);
 
  private:
   static uint16_t readLE16(File& f);
@@ -53,6 +54,4 @@ class BmpToMono {
     else
       buf[idx] |= mask;
   }
-
-  static BmpToMonoError convert24BitImpl(File& file, MonoBitmap& out, uint8_t threshold, bool rotate90CW);
 };

lib/BmpToMono/BmpToMono.cpp

@@ -1,174 +0,0 @@
-#include "BmpToMono.h"
-
-#include <cstdlib>
-#include <cstring>
-
-uint16_t BmpToMono::readLE16(File& f) {
-  const int c0 = f.read();
-  const int c1 = f.read();
-  const uint8_t b0 = (uint8_t)(c0 < 0 ? 0 : c0);
-  const uint8_t b1 = (uint8_t)(c1 < 0 ? 0 : c1);
-  return (uint16_t)b0 | ((uint16_t)b1 << 8);
-}
-
-uint32_t BmpToMono::readLE32(File& f) {
-  const int c0 = f.read();
-  const int c1 = f.read();
-  const int c2 = f.read();
-  const int c3 = f.read();
-
-  const uint8_t b0 = (uint8_t)(c0 < 0 ? 0 : c0);
-  const uint8_t b1 = (uint8_t)(c1 < 0 ? 0 : c1);
-  const uint8_t b2 = (uint8_t)(c2 < 0 ? 0 : c2);
-  const uint8_t b3 = (uint8_t)(c3 < 0 ? 0 : c3);
-
-  return (uint32_t)b0 | ((uint32_t)b1 << 8) | ((uint32_t)b2 << 16) | ((uint32_t)b3 << 24);
-}
-
-void BmpToMono::freeMonoBitmap(MonoBitmap& bmp) {
-  if (bmp.data) {
-    free(bmp.data);
-    bmp.data = nullptr;
-  }
-  bmp.width = 0;
-  bmp.height = 0;
-  bmp.len = 0;
-}
-
-const char* BmpToMono::errorToString(BmpToMonoError err) {
-  switch (err) {
-    case BmpToMonoError::Ok:
-      return "Ok";
-    case BmpToMonoError::FileInvalid:
-      return "FileInvalid";
-    case BmpToMonoError::SeekStartFailed:
-      return "SeekStartFailed";
-    case BmpToMonoError::NotBMP:
-      return "NotBMP (missing 'BM')";
-    case BmpToMonoError::DIBTooSmall:
-      return "DIBTooSmall (<40 bytes)";
-    case BmpToMonoError::BadPlanes:
-      return "BadPlanes (!= 1)";
-    case BmpToMonoError::UnsupportedBpp:
-      return "UnsupportedBpp (expected 24)";
-    case BmpToMonoError::UnsupportedCompression:
-      return "UnsupportedCompression (expected BI_RGB)";
-    case BmpToMonoError::BadDimensions:
-      return "BadDimensions";
-    case BmpToMonoError::SeekPixelDataFailed:
-      return "SeekPixelDataFailed";
-    case BmpToMonoError::OomOutput:
-      return "OomOutput";
-    case BmpToMonoError::OomRowBuffer:
-      return "OomRowBuffer";
-    case BmpToMonoError::ShortReadRow:
-      return "ShortReadRow";
-  }
-  return "Unknown";
-}
-
-BmpToMonoError BmpToMono::convert24BitRotate90CCW(File& file, MonoBitmap& out, uint8_t threshold) {
-  return convert24BitImpl(file, out, threshold, true);
-}
-
-BmpToMonoError BmpToMono::convert24BitImpl(File& f, MonoBitmap& out, uint8_t threshold, bool rotate90CCW) {
-  freeMonoBitmap(out);
-
-  if (!f) return BmpToMonoError::FileInvalid;
-  if (!f.seek(0)) return BmpToMonoError::SeekStartFailed;
-
-  // --- BMP FILE HEADER ---
-  const uint16_t bfType = readLE16(f);
-  if (bfType != 0x4D42) return BmpToMonoError::NotBMP;
-
-  (void)readLE32(f);
-  (void)readLE16(f);
-  (void)readLE16(f);
-  const uint32_t bfOffBits = readLE32(f);
-
-  // --- DIB HEADER ---
-  const uint32_t biSize = readLE32(f);
-  if (biSize < 40) return BmpToMonoError::DIBTooSmall;
-
-  const int32_t srcW = (int32_t)readLE32(f);
-  int32_t srcHRaw = (int32_t)readLE32(f);
-  const uint16_t planes = readLE16(f);
-  const uint16_t bpp = readLE16(f);
-  const uint32_t comp = readLE32(f);
-
-  if (planes != 1) return BmpToMonoError::BadPlanes;
-  if (bpp != 24) return BmpToMonoError::UnsupportedBpp;
-  if (comp != 0) return BmpToMonoError::UnsupportedCompression;
-
-  (void)readLE32(f);
-  (void)readLE32(f);
-  (void)readLE32(f);
-  (void)readLE32(f);
-  (void)readLE32(f);
-
-  if (srcW <= 0) return BmpToMonoError::BadDimensions;
-
-  const bool topDown = (srcHRaw < 0);
-  const int32_t srcH = topDown ? -srcHRaw : srcHRaw;
-  if (srcH <= 0) return BmpToMonoError::BadDimensions;
-
-  // Output dimensions
-  out.width = rotate90CCW ? (int)srcH : (int)srcW;
-  out.height = rotate90CCW ? (int)srcW : (int)srcH;
-
-  const size_t outBytesPerRow = (size_t)(out.width + 7) / 8;
-  out.len = outBytesPerRow * (size_t)out.height;
-
-  out.data = (uint8_t*)malloc(out.len);
-  if (!out.data) return BmpToMonoError::OomOutput;
-  memset(out.data, 0xFF, out.len);
-
-  // Source row stride (padded to 4 bytes)
-  const uint32_t srcBytesPerRow24 = (uint32_t)srcW * 3u;
-  const uint32_t srcRowStride = (srcBytesPerRow24 + 3u) & ~3u;
-
-  if (!f.seek(bfOffBits)) {
-    freeMonoBitmap(out);
-    return BmpToMonoError::SeekPixelDataFailed;
-  }
-
-  uint8_t* rowBuf = (uint8_t*)malloc(srcRowStride);
-  if (!rowBuf) {
-    freeMonoBitmap(out);
-    return BmpToMonoError::OomRowBuffer;
-  }
-
-  for (int fileRow = 0; fileRow < (int)srcH; fileRow++) {
-    if (f.read(rowBuf, srcRowStride) != (int)srcRowStride) {
-      free(rowBuf);
-      freeMonoBitmap(out);
-      return BmpToMonoError::ShortReadRow;
-    }
-
-    const int srcY = topDown ? fileRow : ((int)srcH - 1 - fileRow);
-
-    for (int srcX = 0; srcX < (int)srcW; srcX++) {
-      const uint8_t b = rowBuf[srcX * 3 + 0];
-      const uint8_t g = rowBuf[srcX * 3 + 1];
-      const uint8_t r = rowBuf[srcX * 3 + 2];
-
-      const uint8_t lum = (uint8_t)((77u * r + 150u * g + 29u * b) >> 8);
-      bool isBlack = (lum < threshold);
-
-      int outX, outY;
-      if (!rotate90CCW) {
-        outX = srcX;
-        outY = srcY;
-      } else {
-        // 90° counter-clockwise: (x,y) -> (y, w-1-x)
-        outX = srcY;
-        outY = (int)srcW - 1 - srcX;
-      }
-
-      setMonoPixel(out.data, out.width, outX, outY, isBlack);
-    }
-  }
-
-  free(rowBuf);
-  return BmpToMonoError::Ok;
-}

lib/GfxRenderer/GfxRenderer.cpp

@@ -2,7 +2,7 @@
 
 #include <Utf8.h>
 
-#include "BmpToMono.h"
+#include "BmpReader.h"
 
 void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) { fontMap.insert({fontId, font}); }
 
@@ -130,10 +130,10 @@ bool GfxRenderer::drawFullScreenBmp(File& file) {
   file.seek(0);  // Ensure we're at the start of the file
 
   MonoBitmap bmp;
-  auto err = BmpToMono::convert24BitRotate90CCW(file, bmp);
+  auto err = BmpReader::read(file, bmp);
 
-  if (err != BmpToMonoError::Ok) {
-    Serial.printf("[%lu] [GFX] BMP convert failed: %s\n", millis(), BmpToMono::errorToString(err));
+  if (err != BmpReaderError::Ok) {
+    Serial.printf("[%lu] [GFX] BMP convert failed: %s\n", millis(), BmpReader::errorToString(err));
     return false;
   }
 
@@ -141,14 +141,14 @@ bool GfxRenderer::drawFullScreenBmp(File& file) {
   if (bmp.width != EInkDisplay::DISPLAY_WIDTH || bmp.height != EInkDisplay::DISPLAY_HEIGHT) {
     Serial.printf("[%lu] [GFX] drawFullScreenBmp: rotated BMP size %dx%d does not match panel %dx%d\n", millis(),
                   bmp.width, bmp.height, EInkDisplay::DISPLAY_WIDTH, EInkDisplay::DISPLAY_HEIGHT);
-    BmpToMono::freeMonoBitmap(bmp);
+    BmpReader::freeMonoBitmap(bmp);
     return false;
   }
 
   // Full-screen blit
   einkDisplay.drawImage(bmp.data, 0, 0, bmp.width, bmp.height);
 
-  BmpToMono::freeMonoBitmap(bmp);
+  BmpReader::freeMonoBitmap(bmp);
   return true;
 }