762 lines
26 KiB
C++
762 lines
26 KiB
C++
#include "GfxRenderer.h"
|
|
|
|
#include <Utf8.h>
|
|
#include <miniz.h>
|
|
|
|
namespace {
|
|
tinfl_decompressor* inflator = nullptr;
|
|
|
|
bool inflateOneShot(const uint8_t* inputBuf, const size_t deflatedSize, uint8_t* outputBuf, const size_t inflatedSize) {
|
|
if (!inflator) {
|
|
Serial.printf("[%lu] [GFX] Inflator not initialized\n", millis());
|
|
return false;
|
|
}
|
|
|
|
size_t inBytes = deflatedSize;
|
|
size_t outBytes = inflatedSize;
|
|
tinfl_init(inflator);
|
|
const tinfl_status status = tinfl_decompress(inflator, inputBuf, &inBytes, nullptr, outputBuf, &outBytes,
|
|
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
|
|
|
|
if (status != TINFL_STATUS_DONE) {
|
|
Serial.printf("[%lu] [GFX] tinfl_decompress() failed with status %d\n", millis(), status);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
void GfxRenderer::insertFont(const int fontId, EpdFontFamily font) { fontMap.insert({fontId, font}); }
|
|
|
|
void GfxRenderer::rotateCoordinates(const int x, const int y, int* rotatedX, int* rotatedY) const {
|
|
switch (orientation) {
|
|
case Portrait: {
|
|
// Logical portrait (480x800) → panel (800x480)
|
|
// Rotation: 90 degrees clockwise
|
|
*rotatedX = y;
|
|
*rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x;
|
|
break;
|
|
}
|
|
case LandscapeClockwise: {
|
|
// Logical landscape (800x480) rotated 180 degrees (swap top/bottom and left/right)
|
|
*rotatedX = EInkDisplay::DISPLAY_WIDTH - 1 - x;
|
|
*rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - y;
|
|
break;
|
|
}
|
|
case PortraitInverted: {
|
|
// Logical portrait (480x800) → panel (800x480)
|
|
// Rotation: 90 degrees counter-clockwise
|
|
*rotatedX = EInkDisplay::DISPLAY_WIDTH - 1 - y;
|
|
*rotatedY = x;
|
|
break;
|
|
}
|
|
case LandscapeCounterClockwise: {
|
|
// Logical landscape (800x480) aligned with panel orientation
|
|
*rotatedX = x;
|
|
*rotatedY = y;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
|
|
uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
|
|
|
|
// Early return if no framebuffer is set
|
|
if (!frameBuffer) {
|
|
Serial.printf("[%lu] [GFX] !! No framebuffer\n", millis());
|
|
return;
|
|
}
|
|
|
|
int rotatedX = 0;
|
|
int rotatedY = 0;
|
|
rotateCoordinates(x, y, &rotatedX, &rotatedY);
|
|
|
|
// Bounds checking against physical panel dimensions
|
|
if (rotatedX < 0 || rotatedX >= EInkDisplay::DISPLAY_WIDTH || rotatedY < 0 ||
|
|
rotatedY >= EInkDisplay::DISPLAY_HEIGHT) {
|
|
Serial.printf("[%lu] [GFX] !! Outside range (%d, %d) -> (%d, %d)\n", millis(), x, y, rotatedX, rotatedY);
|
|
return;
|
|
}
|
|
|
|
// Calculate byte position and bit position
|
|
const uint16_t byteIndex = rotatedY * EInkDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
|
|
const uint8_t bitPosition = 7 - (rotatedX % 8); // MSB first
|
|
|
|
if (state) {
|
|
frameBuffer[byteIndex] &= ~(1 << bitPosition); // Clear bit
|
|
} else {
|
|
frameBuffer[byteIndex] |= 1 << bitPosition; // Set bit
|
|
}
|
|
}
|
|
|
|
int GfxRenderer::getTextWidth(const int fontId, const char* text, const EpdFontFamily::Style style) const {
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return 0;
|
|
}
|
|
|
|
int w = 0, h = 0;
|
|
fontMap.at(fontId).getTextDimensions(text, &w, &h, style);
|
|
return w;
|
|
}
|
|
|
|
void GfxRenderer::drawCenteredText(const int fontId, const int y, const char* text, const bool black,
|
|
const EpdFontFamily::Style style) const {
|
|
const int x = (getScreenWidth() - getTextWidth(fontId, text, style)) / 2;
|
|
drawText(fontId, x, y, text, black, style);
|
|
}
|
|
|
|
void GfxRenderer::drawText(const int fontId, const int x, const int y, const char* text, const bool black,
|
|
const EpdFontFamily::Style style) const {
|
|
const int yPos = y + getFontAscenderSize(fontId);
|
|
int xpos = x;
|
|
|
|
// cannot draw a NULL / empty string
|
|
if (text == nullptr || *text == '\0') {
|
|
return;
|
|
}
|
|
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return;
|
|
}
|
|
const auto font = fontMap.at(fontId);
|
|
|
|
// no printable characters
|
|
if (!font.hasPrintableChars(text, style)) {
|
|
return;
|
|
}
|
|
|
|
// Setup inflator
|
|
inflator = static_cast<tinfl_decompressor*>(malloc(sizeof(tinfl_decompressor)));
|
|
if (!inflator) {
|
|
Serial.printf("[%lu] [GFX] Failed to allocate memory for inflator\n", millis());
|
|
return;
|
|
}
|
|
memset(inflator, 0, sizeof(tinfl_decompressor));
|
|
|
|
uint32_t cp;
|
|
while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text)))) {
|
|
renderChar(font, cp, &xpos, &yPos, black, style);
|
|
}
|
|
|
|
free(inflator);
|
|
inflator = nullptr;
|
|
}
|
|
|
|
void GfxRenderer::drawLine(int x1, int y1, int x2, int y2, const bool state) const {
|
|
if (x1 == x2) {
|
|
if (y2 < y1) {
|
|
std::swap(y1, y2);
|
|
}
|
|
for (int y = y1; y <= y2; y++) {
|
|
drawPixel(x1, y, state);
|
|
}
|
|
} else if (y1 == y2) {
|
|
if (x2 < x1) {
|
|
std::swap(x1, x2);
|
|
}
|
|
for (int x = x1; x <= x2; x++) {
|
|
drawPixel(x, y1, state);
|
|
}
|
|
} else {
|
|
// TODO: Implement
|
|
Serial.printf("[%lu] [GFX] Line drawing not supported\n", millis());
|
|
}
|
|
}
|
|
|
|
void GfxRenderer::drawRect(const int x, const int y, const int width, const int height, const bool state) const {
|
|
drawLine(x, y, x + width - 1, y, state);
|
|
drawLine(x + width - 1, y, x + width - 1, y + height - 1, state);
|
|
drawLine(x + width - 1, y + height - 1, x, y + height - 1, state);
|
|
drawLine(x, y, x, y + height - 1, state);
|
|
}
|
|
|
|
void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const {
|
|
for (int fillY = y; fillY < y + height; fillY++) {
|
|
drawLine(x, fillY, x + width - 1, fillY, state);
|
|
}
|
|
}
|
|
|
|
void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const {
|
|
// TODO: Rotate bits
|
|
int rotatedX = 0;
|
|
int rotatedY = 0;
|
|
rotateCoordinates(x, y, &rotatedX, &rotatedY);
|
|
einkDisplay.drawImage(bitmap, rotatedX, rotatedY, width, height);
|
|
}
|
|
|
|
void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight,
|
|
const float cropX, const float cropY) const {
|
|
float scale = 1.0f;
|
|
bool isScaled = false;
|
|
int cropPixX = std::floor(bitmap.getWidth() * cropX / 2.0f);
|
|
int cropPixY = std::floor(bitmap.getHeight() * cropY / 2.0f);
|
|
Serial.printf("[%lu] [GFX] Cropping %dx%d by %dx%d pix, is %s\n", millis(), bitmap.getWidth(), bitmap.getHeight(),
|
|
cropPixX, cropPixY, bitmap.isTopDown() ? "top-down" : "bottom-up");
|
|
|
|
if (maxWidth > 0 && (1.0f - cropX) * bitmap.getWidth() > maxWidth) {
|
|
scale = static_cast<float>(maxWidth) / static_cast<float>((1.0f - cropX) * bitmap.getWidth());
|
|
isScaled = true;
|
|
}
|
|
if (maxHeight > 0 && (1.0f - cropY) * bitmap.getHeight() > maxHeight) {
|
|
scale = std::min(scale, static_cast<float>(maxHeight) / static_cast<float>((1.0f - cropY) * bitmap.getHeight()));
|
|
isScaled = true;
|
|
}
|
|
Serial.printf("[%lu] [GFX] Scaling by %f - %s\n", millis(), scale, isScaled ? "scaled" : "not scaled");
|
|
|
|
// Calculate output row size (2 bits per pixel, packed into bytes)
|
|
// IMPORTANT: Use int, not uint8_t, to avoid overflow for images > 1020 pixels wide
|
|
const int outputRowSize = (bitmap.getWidth() + 3) / 4;
|
|
auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize));
|
|
auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
|
|
|
|
if (!outputRow || !rowBytes) {
|
|
Serial.printf("[%lu] [GFX] !! Failed to allocate BMP row buffers\n", millis());
|
|
free(outputRow);
|
|
free(rowBytes);
|
|
return;
|
|
}
|
|
|
|
for (int bmpY = 0; bmpY < (bitmap.getHeight() - cropPixY); bmpY++) {
|
|
// The BMP's (0, 0) is the bottom-left corner (if the height is positive, top-left if negative).
|
|
// Screen's (0, 0) is the top-left corner.
|
|
int screenY = -cropPixY + (bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY);
|
|
if (isScaled) {
|
|
screenY = std::floor(screenY * scale);
|
|
}
|
|
screenY += y; // the offset should not be scaled
|
|
if (screenY >= getScreenHeight()) {
|
|
break;
|
|
}
|
|
|
|
if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) {
|
|
Serial.printf("[%lu] [GFX] Failed to read row %d from bitmap\n", millis(), bmpY);
|
|
free(outputRow);
|
|
free(rowBytes);
|
|
return;
|
|
}
|
|
|
|
if (bmpY < cropPixY) {
|
|
// Skip the row if it's outside the crop area
|
|
continue;
|
|
}
|
|
|
|
for (int bmpX = cropPixX; bmpX < bitmap.getWidth() - cropPixX; bmpX++) {
|
|
int screenX = bmpX - cropPixX;
|
|
if (isScaled) {
|
|
screenX = std::floor(screenX * scale);
|
|
}
|
|
screenX += x; // the offset should not be scaled
|
|
if (screenX >= getScreenWidth()) {
|
|
break;
|
|
}
|
|
|
|
const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
|
|
|
|
if (renderMode == BW && val < 3) {
|
|
drawPixel(screenX, screenY);
|
|
} else if (renderMode == GRAYSCALE_MSB && (val == 1 || val == 2)) {
|
|
drawPixel(screenX, screenY, false);
|
|
} else if (renderMode == GRAYSCALE_LSB && val == 1) {
|
|
drawPixel(screenX, screenY, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
free(outputRow);
|
|
free(rowBytes);
|
|
}
|
|
|
|
void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); }
|
|
|
|
void GfxRenderer::invertScreen() const {
|
|
uint8_t* buffer = einkDisplay.getFrameBuffer();
|
|
if (!buffer) {
|
|
Serial.printf("[%lu] [GFX] !! No framebuffer in invertScreen\n", millis());
|
|
return;
|
|
}
|
|
for (int i = 0; i < EInkDisplay::BUFFER_SIZE; i++) {
|
|
buffer[i] = ~buffer[i];
|
|
}
|
|
}
|
|
|
|
void GfxRenderer::displayBuffer(const EInkDisplay::RefreshMode refreshMode) const {
|
|
einkDisplay.displayBuffer(refreshMode);
|
|
}
|
|
|
|
std::string GfxRenderer::truncatedText(const int fontId, const char* text, const int maxWidth,
|
|
const EpdFontFamily::Style style) const {
|
|
std::string item = text;
|
|
int itemWidth = getTextWidth(fontId, item.c_str(), style);
|
|
while (itemWidth > maxWidth && item.length() > 8) {
|
|
item.replace(item.length() - 5, 5, "...");
|
|
itemWidth = getTextWidth(fontId, item.c_str(), style);
|
|
}
|
|
return item;
|
|
}
|
|
|
|
// Note: Internal driver treats screen in command orientation; this library exposes a logical orientation
|
|
int GfxRenderer::getScreenWidth() const {
|
|
switch (orientation) {
|
|
case Portrait:
|
|
case PortraitInverted:
|
|
// 480px wide in portrait logical coordinates
|
|
return EInkDisplay::DISPLAY_HEIGHT;
|
|
case LandscapeClockwise:
|
|
case LandscapeCounterClockwise:
|
|
// 800px wide in landscape logical coordinates
|
|
return EInkDisplay::DISPLAY_WIDTH;
|
|
}
|
|
return EInkDisplay::DISPLAY_HEIGHT;
|
|
}
|
|
|
|
int GfxRenderer::getScreenHeight() const {
|
|
switch (orientation) {
|
|
case Portrait:
|
|
case PortraitInverted:
|
|
// 800px tall in portrait logical coordinates
|
|
return EInkDisplay::DISPLAY_WIDTH;
|
|
case LandscapeClockwise:
|
|
case LandscapeCounterClockwise:
|
|
// 480px tall in landscape logical coordinates
|
|
return EInkDisplay::DISPLAY_HEIGHT;
|
|
}
|
|
return EInkDisplay::DISPLAY_WIDTH;
|
|
}
|
|
|
|
int GfxRenderer::getSpaceWidth(const int fontId) const {
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return 0;
|
|
}
|
|
|
|
return fontMap.at(fontId).getGlyph(' ', EpdFontFamily::REGULAR)->advanceX;
|
|
}
|
|
|
|
int GfxRenderer::getFontAscenderSize(const int fontId) const {
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return 0;
|
|
}
|
|
|
|
return fontMap.at(fontId).getData(EpdFontFamily::REGULAR)->ascender;
|
|
}
|
|
|
|
int GfxRenderer::getLineHeight(const int fontId) const {
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return 0;
|
|
}
|
|
|
|
return fontMap.at(fontId).getData(EpdFontFamily::REGULAR)->advanceY;
|
|
}
|
|
|
|
void GfxRenderer::drawButtonHints(const int fontId, const char* btn1, const char* btn2, const char* btn3,
|
|
const char* btn4) const {
|
|
const int pageHeight = getScreenHeight();
|
|
constexpr int buttonWidth = 106;
|
|
constexpr int buttonHeight = 40;
|
|
constexpr int buttonY = 40; // Distance from bottom
|
|
constexpr int textYOffset = 7; // Distance from top of button to text baseline
|
|
constexpr int buttonPositions[] = {25, 130, 245, 350};
|
|
const char* labels[] = {btn1, btn2, btn3, btn4};
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
// Only draw if the label is non-empty
|
|
if (labels[i] != nullptr && labels[i][0] != '\0') {
|
|
const int x = buttonPositions[i];
|
|
drawRect(x, pageHeight - buttonY, buttonWidth, buttonHeight);
|
|
const int textWidth = getTextWidth(fontId, labels[i]);
|
|
const int textX = x + (buttonWidth - 1 - textWidth) / 2;
|
|
drawText(fontId, textX, pageHeight - buttonY + textYOffset, labels[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GfxRenderer::drawSideButtonHints(const int fontId, const char* topBtn, const char* bottomBtn) const {
|
|
const int screenWidth = getScreenWidth();
|
|
constexpr int buttonWidth = 40; // Width on screen (height when rotated)
|
|
constexpr int buttonHeight = 80; // Height on screen (width when rotated)
|
|
constexpr int buttonX = 5; // Distance from right edge
|
|
// Position for the button group - buttons share a border so they're adjacent
|
|
constexpr int topButtonY = 345; // Top button position
|
|
|
|
const char* labels[] = {topBtn, bottomBtn};
|
|
|
|
// Draw the shared border for both buttons as one unit
|
|
const int x = screenWidth - buttonX - buttonWidth;
|
|
|
|
// Draw top button outline (3 sides, bottom open)
|
|
if (topBtn != nullptr && topBtn[0] != '\0') {
|
|
drawLine(x, topButtonY, x + buttonWidth - 1, topButtonY); // Top
|
|
drawLine(x, topButtonY, x, topButtonY + buttonHeight - 1); // Left
|
|
drawLine(x + buttonWidth - 1, topButtonY, x + buttonWidth - 1, topButtonY + buttonHeight - 1); // Right
|
|
}
|
|
|
|
// Draw shared middle border
|
|
if ((topBtn != nullptr && topBtn[0] != '\0') || (bottomBtn != nullptr && bottomBtn[0] != '\0')) {
|
|
drawLine(x, topButtonY + buttonHeight, x + buttonWidth - 1, topButtonY + buttonHeight); // Shared border
|
|
}
|
|
|
|
// Draw bottom button outline (3 sides, top is shared)
|
|
if (bottomBtn != nullptr && bottomBtn[0] != '\0') {
|
|
drawLine(x, topButtonY + buttonHeight, x, topButtonY + 2 * buttonHeight - 1); // Left
|
|
drawLine(x + buttonWidth - 1, topButtonY + buttonHeight, x + buttonWidth - 1,
|
|
topButtonY + 2 * buttonHeight - 1); // Right
|
|
drawLine(x, topButtonY + 2 * buttonHeight - 1, x + buttonWidth - 1, topButtonY + 2 * buttonHeight - 1); // Bottom
|
|
}
|
|
|
|
// Draw text for each button
|
|
for (int i = 0; i < 2; i++) {
|
|
if (labels[i] != nullptr && labels[i][0] != '\0') {
|
|
const int y = topButtonY + i * buttonHeight;
|
|
|
|
// Draw rotated text centered in the button
|
|
const int textWidth = getTextWidth(fontId, labels[i]);
|
|
const int textHeight = getTextHeight(fontId);
|
|
|
|
// Center the rotated text in the button
|
|
const int textX = x + (buttonWidth - textHeight) / 2;
|
|
const int textY = y + (buttonHeight + textWidth) / 2;
|
|
|
|
drawTextRotated90CW(fontId, textX, textY, labels[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
int GfxRenderer::getTextHeight(const int fontId) const {
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return 0;
|
|
}
|
|
return fontMap.at(fontId).getData(EpdFontFamily::REGULAR)->ascender;
|
|
}
|
|
|
|
void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y, const char* text, const bool black,
|
|
const EpdFontFamily::Style style) const {
|
|
// Cannot draw a NULL / empty string
|
|
if (text == nullptr || *text == '\0') {
|
|
return;
|
|
}
|
|
|
|
if (fontMap.count(fontId) == 0) {
|
|
Serial.printf("[%lu] [GFX] Font %d not found\n", millis(), fontId);
|
|
return;
|
|
}
|
|
const auto font = fontMap.at(fontId);
|
|
|
|
// No printable characters
|
|
if (!font.hasPrintableChars(text, style)) {
|
|
return;
|
|
}
|
|
|
|
// For 90° clockwise rotation:
|
|
// Original (glyphX, glyphY) -> Rotated (glyphY, -glyphX)
|
|
// Text reads from bottom to top
|
|
|
|
int yPos = y; // Current Y position (decreases as we draw characters)
|
|
|
|
uint32_t cp;
|
|
while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&text)))) {
|
|
const EpdGlyph* glyph = font.getGlyph(cp, style);
|
|
if (!glyph) {
|
|
glyph = font.getGlyph('?', style);
|
|
}
|
|
if (!glyph) {
|
|
continue;
|
|
}
|
|
|
|
const int is2Bit = font.getData(style)->is2Bit;
|
|
const uint32_t offset = glyph->dataOffset;
|
|
const uint8_t width = glyph->width;
|
|
const uint8_t height = glyph->height;
|
|
const int left = glyph->left;
|
|
const int top = glyph->top;
|
|
|
|
const uint8_t* bitmap = &font.getData(style)->bitmap[offset];
|
|
|
|
if (bitmap != nullptr) {
|
|
for (int glyphY = 0; glyphY < height; glyphY++) {
|
|
for (int glyphX = 0; glyphX < width; glyphX++) {
|
|
const int pixelPosition = glyphY * width + glyphX;
|
|
|
|
// 90° clockwise rotation transformation:
|
|
// screenX = x + (ascender - top + glyphY)
|
|
// screenY = yPos - (left + glyphX)
|
|
const int screenX = x + (font.getData(style)->ascender - top + glyphY);
|
|
const int screenY = yPos - left - glyphX;
|
|
|
|
if (is2Bit) {
|
|
const uint8_t byte = bitmap[pixelPosition / 4];
|
|
const uint8_t bit_index = (3 - pixelPosition % 4) * 2;
|
|
const uint8_t bmpVal = 3 - (byte >> bit_index) & 0x3;
|
|
|
|
if (renderMode == BW && bmpVal < 3) {
|
|
drawPixel(screenX, screenY, black);
|
|
} else if (renderMode == GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) {
|
|
drawPixel(screenX, screenY, false);
|
|
} else if (renderMode == GRAYSCALE_LSB && bmpVal == 1) {
|
|
drawPixel(screenX, screenY, false);
|
|
}
|
|
} else {
|
|
const uint8_t byte = bitmap[pixelPosition / 8];
|
|
const uint8_t bit_index = 7 - (pixelPosition % 8);
|
|
|
|
if ((byte >> bit_index) & 1) {
|
|
drawPixel(screenX, screenY, black);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Move to next character position (going up, so decrease Y)
|
|
yPos -= glyph->advanceX;
|
|
}
|
|
}
|
|
|
|
uint8_t* GfxRenderer::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
|
|
|
|
size_t GfxRenderer::getBufferSize() { return EInkDisplay::BUFFER_SIZE; }
|
|
|
|
void GfxRenderer::grayscaleRevert() const { einkDisplay.grayscaleRevert(); }
|
|
|
|
void GfxRenderer::copyGrayscaleLsbBuffers() const { einkDisplay.copyGrayscaleLsbBuffers(einkDisplay.getFrameBuffer()); }
|
|
|
|
void GfxRenderer::copyGrayscaleMsbBuffers() const { einkDisplay.copyGrayscaleMsbBuffers(einkDisplay.getFrameBuffer()); }
|
|
|
|
void GfxRenderer::displayGrayBuffer() const { einkDisplay.displayGrayBuffer(); }
|
|
|
|
void GfxRenderer::freeBwBufferChunks() {
|
|
for (auto& bwBufferChunk : bwBufferChunks) {
|
|
if (bwBufferChunk) {
|
|
free(bwBufferChunk);
|
|
bwBufferChunk = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This should be called before grayscale buffers are populated.
|
|
* A `restoreBwBuffer` call should always follow the grayscale render if this method was called.
|
|
* Uses chunked allocation to avoid needing 48KB of contiguous memory.
|
|
* Returns true if buffer was stored successfully, false if allocation failed.
|
|
*/
|
|
bool GfxRenderer::storeBwBuffer() {
|
|
const uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
|
|
if (!frameBuffer) {
|
|
Serial.printf("[%lu] [GFX] !! No framebuffer in storeBwBuffer\n", millis());
|
|
return false;
|
|
}
|
|
|
|
// Allocate and copy each chunk
|
|
for (size_t i = 0; i < BW_BUFFER_NUM_CHUNKS; i++) {
|
|
// Check if any chunks are already allocated
|
|
if (bwBufferChunks[i]) {
|
|
Serial.printf("[%lu] [GFX] !! BW buffer chunk %zu already stored - this is likely a bug, freeing chunk\n",
|
|
millis(), i);
|
|
free(bwBufferChunks[i]);
|
|
bwBufferChunks[i] = nullptr;
|
|
}
|
|
|
|
const size_t offset = i * BW_BUFFER_CHUNK_SIZE;
|
|
bwBufferChunks[i] = static_cast<uint8_t*>(malloc(BW_BUFFER_CHUNK_SIZE));
|
|
|
|
if (!bwBufferChunks[i]) {
|
|
Serial.printf("[%lu] [GFX] !! Failed to allocate BW buffer chunk %zu (%zu bytes)\n", millis(), i,
|
|
BW_BUFFER_CHUNK_SIZE);
|
|
// Free previously allocated chunks
|
|
freeBwBufferChunks();
|
|
return false;
|
|
}
|
|
|
|
memcpy(bwBufferChunks[i], frameBuffer + offset, BW_BUFFER_CHUNK_SIZE);
|
|
}
|
|
|
|
Serial.printf("[%lu] [GFX] Stored BW buffer in %zu chunks (%zu bytes each)\n", millis(), BW_BUFFER_NUM_CHUNKS,
|
|
BW_BUFFER_CHUNK_SIZE);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This can only be called if `storeBwBuffer` was called prior to the grayscale render.
|
|
* It should be called to restore the BW buffer state after grayscale rendering is complete.
|
|
* Uses chunked restoration to match chunked storage.
|
|
*/
|
|
void GfxRenderer::restoreBwBuffer() {
|
|
// Check if any all chunks are allocated
|
|
bool missingChunks = false;
|
|
for (const auto& bwBufferChunk : bwBufferChunks) {
|
|
if (!bwBufferChunk) {
|
|
missingChunks = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (missingChunks) {
|
|
freeBwBufferChunks();
|
|
return;
|
|
}
|
|
|
|
uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
|
|
if (!frameBuffer) {
|
|
Serial.printf("[%lu] [GFX] !! No framebuffer in restoreBwBuffer\n", millis());
|
|
freeBwBufferChunks();
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < BW_BUFFER_NUM_CHUNKS; i++) {
|
|
// Check if chunk is missing
|
|
if (!bwBufferChunks[i]) {
|
|
Serial.printf("[%lu] [GFX] !! BW buffer chunks not stored - this is likely a bug\n", millis());
|
|
freeBwBufferChunks();
|
|
return;
|
|
}
|
|
|
|
const size_t offset = i * BW_BUFFER_CHUNK_SIZE;
|
|
memcpy(frameBuffer + offset, bwBufferChunks[i], BW_BUFFER_CHUNK_SIZE);
|
|
}
|
|
|
|
einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
|
|
|
|
freeBwBufferChunks();
|
|
Serial.printf("[%lu] [GFX] Restored and freed BW buffer chunks\n", millis());
|
|
}
|
|
|
|
/**
|
|
* Cleanup grayscale buffers using the current frame buffer.
|
|
* Use this when BW buffer was re-rendered instead of stored/restored.
|
|
*/
|
|
void GfxRenderer::cleanupGrayscaleWithFrameBuffer() const {
|
|
uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
|
|
if (frameBuffer) {
|
|
einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
|
|
}
|
|
}
|
|
|
|
void GfxRenderer::renderChar(const EpdFontFamily& fontFamily, const uint32_t cp, int* x, const int* y,
|
|
const bool pixelState, const EpdFontFamily::Style style) const {
|
|
const EpdGlyph* glyph = fontFamily.getGlyph(cp, style);
|
|
if (!glyph) {
|
|
// TODO: Replace with fallback glyph property?
|
|
glyph = fontFamily.getGlyph('?', style);
|
|
}
|
|
|
|
// no glyph?
|
|
if (!glyph) {
|
|
Serial.printf("[%lu] [GFX] No glyph for codepoint %d\n", millis(), cp);
|
|
return;
|
|
}
|
|
|
|
const int is2Bit = fontFamily.getData(style)->is2Bit;
|
|
// const uint32_t offset = glyph->dataOffset;
|
|
// const uint32_t dataLength = glyph->dataLength;
|
|
const uint8_t width = glyph->width;
|
|
const uint8_t height = glyph->height;
|
|
const int left = glyph->left;
|
|
const size_t outputDataSize = is2Bit ? ((width * height + 3) / 4) : ((width * height + 7) / 8);
|
|
|
|
if (outputDataSize != glyph->dataLength && !glyph->compressed) {
|
|
Serial.printf("[%lu] [GFX] Glyph bitmap size mismatch for codepoint %d (expected %zu, got %d)\n", millis(), cp,
|
|
outputDataSize, glyph->dataLength);
|
|
}
|
|
|
|
uint8_t* bitmapData = nullptr;
|
|
const uint8_t* bitmap;
|
|
|
|
if (glyph->compressed) {
|
|
bitmapData = static_cast<uint8_t*>(malloc(outputDataSize));
|
|
if (!bitmapData) {
|
|
Serial.printf("[%lu] [GFX] Failed to allocate memory for glyph bitmap for codepoint %d\n", millis(), cp);
|
|
return;
|
|
}
|
|
|
|
const auto success = inflateOneShot(&fontFamily.getData(style)->bitmap[glyph->dataOffset], glyph->dataLength,
|
|
bitmapData, outputDataSize);
|
|
if (!success) {
|
|
Serial.printf("[%lu] [GFX] Failed to inflate glyph bitmap for codepoint %d\n", millis(), cp);
|
|
free(bitmapData);
|
|
*x += glyph->advanceX;
|
|
return;
|
|
}
|
|
|
|
bitmap = bitmapData;
|
|
} else {
|
|
bitmap = &fontFamily.getData(style)->bitmap[glyph->dataOffset];
|
|
}
|
|
|
|
for (int glyphY = 0; glyphY < height; glyphY++) {
|
|
const int screenY = *y - glyph->top + glyphY;
|
|
for (int glyphX = 0; glyphX < width; glyphX++) {
|
|
const int pixelPosition = glyphY * width + glyphX;
|
|
const int screenX = *x + left + glyphX;
|
|
|
|
if (is2Bit) {
|
|
const uint8_t byte = bitmap[pixelPosition / 4];
|
|
const uint8_t bit_index = (3 - pixelPosition % 4) * 2;
|
|
// the direct bit from the font is 0 -> white, 1 -> light gray, 2 -> dark gray, 3 -> black
|
|
// we swap this to better match the way images and screen think about colors:
|
|
// 0 -> black, 1 -> dark grey, 2 -> light grey, 3 -> white
|
|
const uint8_t bmpVal = 3 - (byte >> bit_index) & 0x3;
|
|
|
|
if (renderMode == BW && bmpVal < 3) {
|
|
// Black (also paints over the grays in BW mode)
|
|
drawPixel(screenX, screenY, pixelState);
|
|
} else if (renderMode == GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) {
|
|
// Light gray (also mark the MSB if it's going to be a dark gray too)
|
|
// We have to flag pixels in reverse for the gray buffers, as 0 leave alone, 1 update
|
|
drawPixel(screenX, screenY, false);
|
|
} else if (renderMode == GRAYSCALE_LSB && bmpVal == 1) {
|
|
// Dark gray
|
|
drawPixel(screenX, screenY, false);
|
|
}
|
|
} else {
|
|
const uint8_t byte = bitmap[pixelPosition / 8];
|
|
const uint8_t bit_index = 7 - (pixelPosition % 8);
|
|
|
|
if ((byte >> bit_index) & 1) {
|
|
drawPixel(screenX, screenY, pixelState);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bitmapData) {
|
|
free(bitmapData);
|
|
}
|
|
|
|
*x += glyph->advanceX;
|
|
}
|
|
|
|
void GfxRenderer::getOrientedViewableTRBL(int* outTop, int* outRight, int* outBottom, int* outLeft) const {
|
|
switch (orientation) {
|
|
case Portrait:
|
|
*outTop = VIEWABLE_MARGIN_TOP;
|
|
*outRight = VIEWABLE_MARGIN_RIGHT;
|
|
*outBottom = VIEWABLE_MARGIN_BOTTOM;
|
|
*outLeft = VIEWABLE_MARGIN_LEFT;
|
|
break;
|
|
case LandscapeClockwise:
|
|
*outTop = VIEWABLE_MARGIN_LEFT;
|
|
*outRight = VIEWABLE_MARGIN_TOP;
|
|
*outBottom = VIEWABLE_MARGIN_RIGHT;
|
|
*outLeft = VIEWABLE_MARGIN_BOTTOM;
|
|
break;
|
|
case PortraitInverted:
|
|
*outTop = VIEWABLE_MARGIN_BOTTOM;
|
|
*outRight = VIEWABLE_MARGIN_LEFT;
|
|
*outBottom = VIEWABLE_MARGIN_TOP;
|
|
*outLeft = VIEWABLE_MARGIN_RIGHT;
|
|
break;
|
|
case LandscapeCounterClockwise:
|
|
*outTop = VIEWABLE_MARGIN_RIGHT;
|
|
*outRight = VIEWABLE_MARGIN_BOTTOM;
|
|
*outBottom = VIEWABLE_MARGIN_LEFT;
|
|
*outLeft = VIEWABLE_MARGIN_TOP;
|
|
break;
|
|
}
|
|
}
|