diff --git a/.gitignore b/.gitignore index 29bccdd..c989c30 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ .pio .idea .DS_Store +.vscode diff --git a/lib/BmpReader/BmpReader.cpp b/lib/BmpReader/BmpReader.cpp new file mode 100644 index 0000000..f71dbda --- /dev/null +++ b/lib/BmpReader/BmpReader.cpp @@ -0,0 +1,210 @@ +#include "BmpReader.h" + +#include +#include + +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; +} diff --git a/lib/BmpReader/BmpReader.h b/lib/BmpReader/BmpReader.h new file mode 100644 index 0000000..24ec1d3 --- /dev/null +++ b/lib/BmpReader/BmpReader.h @@ -0,0 +1,57 @@ +#pragma once + +#include +#include + +struct MonoBitmap { + int width = 0; + int height = 0; + size_t len = 0; // bytesPerRow * height + uint8_t* data = nullptr; // row-aligned, MSB-first, 1=white 0=black +}; + +enum class BmpReaderError : uint8_t { + Ok = 0, + FileInvalid, + SeekStartFailed, + + NotBMP, + DIBTooSmall, + + BadPlanes, + UnsupportedBpp, + UnsupportedCompression, + + BadDimensions, + + SeekPixelDataFailed, + OomOutput, + OomRowBuffer, + ShortReadRow, +}; + +class BmpReader { + public: + // Rotate 90° counter-clockwise: (w,h) -> (h,w) + // Used for converting portrait BMP (480x800) into landscape framebuffer (800x480) + // 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(BmpReaderError err); + + private: + static uint16_t readLE16(File& f); + static uint32_t readLE32(File& f); + + // Writes a single pixel into a row-aligned 1bpp buffer (MSB-first), 0=black, 1=white + static inline void setMonoPixel(uint8_t* buf, int w, int x, int y, bool isBlack) { + const size_t bytesPerRow = (size_t)(w + 7) / 8; + const size_t idx = (size_t)y * bytesPerRow + (size_t)(x >> 3); + const uint8_t mask = (uint8_t)(0x80u >> (x & 7)); + if (isBlack) + buf[idx] &= (uint8_t)~mask; + else + buf[idx] |= mask; + } +}; diff --git a/lib/GfxRenderer/GfxRenderer.cpp b/lib/GfxRenderer/GfxRenderer.cpp index dd33264..d9b4614 100644 --- a/lib/GfxRenderer/GfxRenderer.cpp +++ b/lib/GfxRenderer/GfxRenderer.cpp @@ -2,6 +2,8 @@ #include +#include "BmpReader.h" + void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) { fontMap.insert({fontId, font}); } void GfxRenderer::drawPixel(const int x, const int y, const bool state) const { @@ -119,6 +121,37 @@ void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, co einkDisplay.drawImage(bitmap, y, x, height, width); } +bool GfxRenderer::drawFullScreenBmp(File& file) { + if (!file) { + Serial.printf("[%lu] [GFX] drawFullScreenBmp: invalid file\n", millis()); + return false; + } + + file.seek(0); // Ensure we're at the start of the file + + MonoBitmap bmp; + auto err = BmpReader::read(file, bmp); + + if (err != BmpReaderError::Ok) { + Serial.printf("[%lu] [GFX] BMP convert failed: %s\n", millis(), BmpReader::errorToString(err)); + return false; + } + + // Hard requirement: must match panel exactly + 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); + BmpReader::freeMonoBitmap(bmp); + return false; + } + + // Full-screen blit + einkDisplay.drawImage(bmp.data, 0, 0, bmp.width, bmp.height); + + BmpReader::freeMonoBitmap(bmp); + return true; +} + void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); } void GfxRenderer::invertScreen() const { diff --git a/lib/GfxRenderer/GfxRenderer.h b/lib/GfxRenderer/GfxRenderer.h index d7b5925..0e716f4 100644 --- a/lib/GfxRenderer/GfxRenderer.h +++ b/lib/GfxRenderer/GfxRenderer.h @@ -2,6 +2,7 @@ #include #include +#include #include @@ -36,6 +37,7 @@ class GfxRenderer { void drawRect(int x, int y, int width, int height, bool state = true) const; void fillRect(int x, int y, int width, int height, bool state = true) const; void drawImage(const uint8_t bitmap[], int x, int y, int width, int height) const; + bool drawFullScreenBmp(File& file); // Text int getTextWidth(int fontId, const char* text, EpdFontStyle style = REGULAR) const; diff --git a/src/main.cpp b/src/main.cpp index f13e21c..9020c69 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -199,6 +199,12 @@ void setup() { // SD Card Initialization SD.begin(SD_SPI_CS, SPI, SPI_FQ); + // TODO: Remove testing code before merging + // exitScreen(); + // enterNewScreen(new SleepScreen(renderer, inputManager)); + // waitForPowerRelease(); + // return; + appState.loadFromFile(); if (!appState.openEpubPath.empty()) { auto epub = loadEpub(appState.openEpubPath); diff --git a/src/screens/SleepScreen.cpp b/src/screens/SleepScreen.cpp index cbcb411..b4972d1 100644 --- a/src/screens/SleepScreen.cpp +++ b/src/screens/SleepScreen.cpp @@ -2,10 +2,23 @@ #include +#include "SD.h" #include "config.h" #include "images/CrossLarge.h" void SleepScreen::onEnter() { + // Look for sleep.bmp on the root of the sd card to determine if we should + // render a custom sleep screen instead of the default. + auto file = SD.open("/sleep.bmp"); + if (file) { + renderCustomSleepScreen(file); + return; + } + + renderDefaultSleepScreen(); +} + +void SleepScreen::renderDefaultSleepScreen() { const auto pageWidth = GfxRenderer::getScreenWidth(); const auto pageHeight = GfxRenderer::getScreenHeight(); @@ -16,3 +29,15 @@ void SleepScreen::onEnter() { renderer.invertScreen(); renderer.displayBuffer(EInkDisplay::HALF_REFRESH); } + +void SleepScreen::renderCustomSleepScreen(File& file) { + renderer.clearScreen(); + bool didImageDrawSuccessfully = renderer.drawFullScreenBmp(file); + + if (!didImageDrawSuccessfully) { + renderer.clearScreen(); + renderer.drawCenteredText(UI_FONT_ID, GfxRenderer::getScreenHeight() / 2, "BAD CUSTOM SLEEP SCREEN", true, BOLD); + } + + renderer.displayBuffer(EInkDisplay::HALF_REFRESH); +} diff --git a/src/screens/SleepScreen.h b/src/screens/SleepScreen.h index b280087..49caa84 100644 --- a/src/screens/SleepScreen.h +++ b/src/screens/SleepScreen.h @@ -1,8 +1,11 @@ #pragma once +#include "SD.h" #include "Screen.h" class SleepScreen final : public Screen { public: explicit SleepScreen(GfxRenderer& renderer, InputManager& inputManager) : Screen(renderer, inputManager) {} void onEnter() override; + void renderDefaultSleepScreen(); + void renderCustomSleepScreen(File& file); };