mirror of
https://github.com/daveallie/crosspoint-reader.git
synced 2026-02-06 15:47:39 +03:00
Compare commits
1 Commits
c9bd1c0838
...
4b23681ca5
| Author | SHA1 | Date | |
|---|---|---|---|
|
4b23681ca5 |
15
.github/PULL_REQUEST_TEMPLATE.md
vendored
15
.github/PULL_REQUEST_TEMPLATE.md
vendored
@ -1,18 +1,9 @@
|
||||
## Summary
|
||||
|
||||
* **What is the goal of this PR?** (e.g., Implements the new feature for file uploading.)
|
||||
* **What is the goal of this PR?** (e.g., Fixes a bug in the user authentication module, Implements the new feature for
|
||||
file uploading.)
|
||||
* **What changes are included?**
|
||||
|
||||
## Additional Context
|
||||
|
||||
* Add any other information that might be helpful for the reviewer (e.g., performance implications, potential risks,
|
||||
specific areas to focus on).
|
||||
|
||||
---
|
||||
|
||||
### AI Usage
|
||||
|
||||
While CrossPoint doesn't have restrictions on AI tools in contributing, please be transparent about their usage as it
|
||||
helps set the right context for reviewers.
|
||||
|
||||
Did you use AI tools to help write this code? _**< YES | PARTIALLY | NO >**_
|
||||
* Add any other information that might be helpful for the reviewer (e.g., performance implications, potential risks, specific areas to focus on).
|
||||
|
||||
2
.github/workflows/ci.yml
vendored
2
.github/workflows/ci.yml
vendored
@ -7,11 +7,11 @@ name: CI
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
with:
|
||||
submodules: recursive
|
||||
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: '3.14'
|
||||
|
||||
3
.github/workflows/release.yml
vendored
3
.github/workflows/release.yml
vendored
@ -7,18 +7,17 @@ on:
|
||||
jobs:
|
||||
build-release:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
with:
|
||||
submodules: recursive
|
||||
|
||||
- uses: actions/cache@v5
|
||||
with:
|
||||
path: |
|
||||
~/.cache/pip
|
||||
~/.platformio/.cache
|
||||
key: ${{ runner.os }}-pio
|
||||
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: '3.14'
|
||||
|
||||
@ -167,10 +167,7 @@ bool Epub::parseTocNavFile() const {
|
||||
}
|
||||
const auto navSize = tempNavFile.size();
|
||||
|
||||
// Note: We can't use `contentBasePath` here as the nav file may be in a different folder to the content.opf
|
||||
// and the HTMLX nav file will have hrefs relative to itself
|
||||
const std::string navContentBasePath = tocNavItem.substr(0, tocNavItem.find_last_of('/') + 1);
|
||||
TocNavParser navParser(navContentBasePath, navSize, bookMetadataCache.get());
|
||||
TocNavParser navParser(contentBasePath, navSize, bookMetadataCache.get());
|
||||
|
||||
if (!navParser.setup()) {
|
||||
Serial.printf("[%lu] [EBP] Could not setup toc nav parser\n", millis());
|
||||
@ -348,14 +345,11 @@ const std::string& Epub::getAuthor() const {
|
||||
return bookMetadataCache->coreMetadata.author;
|
||||
}
|
||||
|
||||
std::string Epub::getCoverBmpPath(bool cropped) const {
|
||||
const auto coverFileName = "cover" + cropped ? "_crop" : "";
|
||||
return cachePath + "/" + coverFileName + ".bmp";
|
||||
}
|
||||
std::string Epub::getCoverBmpPath() const { return cachePath + "/cover.bmp"; }
|
||||
|
||||
bool Epub::generateCoverBmp(bool cropped) const {
|
||||
bool Epub::generateCoverBmp() const {
|
||||
// Already generated, return true
|
||||
if (SdMan.exists(getCoverBmpPath(cropped).c_str())) {
|
||||
if (SdMan.exists(getCoverBmpPath().c_str())) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -387,7 +381,7 @@ bool Epub::generateCoverBmp(bool cropped) const {
|
||||
}
|
||||
|
||||
FsFile coverBmp;
|
||||
if (!SdMan.openFileForWrite("EBP", getCoverBmpPath(cropped), coverBmp)) {
|
||||
if (!SdMan.openFileForWrite("EBP", getCoverBmpPath(), coverBmp)) {
|
||||
coverJpg.close();
|
||||
return false;
|
||||
}
|
||||
@ -398,7 +392,7 @@ bool Epub::generateCoverBmp(bool cropped) const {
|
||||
|
||||
if (!success) {
|
||||
Serial.printf("[%lu] [EBP] Failed to generate BMP from JPG cover image\n", millis());
|
||||
SdMan.remove(getCoverBmpPath(cropped).c_str());
|
||||
SdMan.remove(getCoverBmpPath().c_str());
|
||||
}
|
||||
Serial.printf("[%lu] [EBP] Generated BMP from JPG cover image, success: %s\n", millis(), success ? "yes" : "no");
|
||||
return success;
|
||||
|
||||
@ -44,8 +44,8 @@ class Epub {
|
||||
const std::string& getPath() const;
|
||||
const std::string& getTitle() const;
|
||||
const std::string& getAuthor() const;
|
||||
std::string getCoverBmpPath(bool cropped = false) const;
|
||||
bool generateCoverBmp(bool cropped = false) const;
|
||||
std::string getCoverBmpPath() const;
|
||||
bool generateCoverBmp() const;
|
||||
uint8_t* readItemContentsToBytes(const std::string& itemHref, size_t* size = nullptr,
|
||||
bool trailingNullByte = false) const;
|
||||
bool readItemContentsToStream(const std::string& itemHref, Print& out, size_t chunkSize) const;
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
#include "FsHelpers.h"
|
||||
|
||||
namespace {
|
||||
constexpr uint8_t BOOK_CACHE_VERSION = 4;
|
||||
constexpr uint8_t BOOK_CACHE_VERSION = 3;
|
||||
constexpr char bookBinFile[] = "/book.bin";
|
||||
constexpr char tmpSpineBinFile[] = "/spine.bin.tmp";
|
||||
constexpr char tmpTocBinFile[] = "/toc.bin.tmp";
|
||||
|
||||
@ -167,7 +167,7 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
|
||||
if (strcmp(atts[i], "id") == 0) {
|
||||
itemId = atts[i + 1];
|
||||
} else if (strcmp(atts[i], "href") == 0) {
|
||||
href = FsHelpers::normalisePath(self->baseContentPath + atts[i + 1]);
|
||||
href = self->baseContentPath + atts[i + 1];
|
||||
} else if (strcmp(atts[i], "media-type") == 0) {
|
||||
mediaType = atts[i + 1];
|
||||
} else if (strcmp(atts[i], "properties") == 0) {
|
||||
@ -243,7 +243,7 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
|
||||
break;
|
||||
}
|
||||
} else if (strcmp(atts[i], "href") == 0) {
|
||||
textHref = FsHelpers::normalisePath(self->baseContentPath + atts[i + 1]);
|
||||
textHref = self->baseContentPath + atts[i + 1];
|
||||
}
|
||||
}
|
||||
if ((type == "text" || (type == "start" && !self->textReferenceHref.empty())) && (textHref.length() > 0)) {
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
#include "TocNavParser.h"
|
||||
|
||||
#include <FsHelpers.h>
|
||||
#include <HardwareSerial.h>
|
||||
|
||||
#include "../BookMetadataCache.h"
|
||||
@ -141,7 +140,7 @@ void XMLCALL TocNavParser::endElement(void* userData, const XML_Char* name) {
|
||||
if (strcmp(name, "a") == 0 && self->state == IN_ANCHOR) {
|
||||
// Create TOC entry when closing anchor tag (we have all data now)
|
||||
if (!self->currentLabel.empty() && !self->currentHref.empty()) {
|
||||
std::string href = FsHelpers::normalisePath(self->baseContentPath + self->currentHref);
|
||||
std::string href = self->baseContentPath + self->currentHref;
|
||||
std::string anchor;
|
||||
|
||||
const size_t pos = href.find('#');
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
#include "TocNcxParser.h"
|
||||
|
||||
#include <FsHelpers.h>
|
||||
#include <HardwareSerial.h>
|
||||
|
||||
#include "../BookMetadataCache.h"
|
||||
@ -160,7 +159,7 @@ void XMLCALL TocNcxParser::endElement(void* userData, const XML_Char* name) {
|
||||
// This is the safest place to push the data, assuming <navLabel> always comes before <content>.
|
||||
// NCX spec says navLabel comes before content.
|
||||
if (!self->currentLabel.empty() && !self->currentSrc.empty()) {
|
||||
std::string href = FsHelpers::normalisePath(self->baseContentPath + self->currentSrc);
|
||||
std::string href = self->baseContentPath + self->currentSrc;
|
||||
std::string anchor;
|
||||
|
||||
const size_t pos = href.find('#');
|
||||
|
||||
@ -8,15 +8,119 @@
|
||||
// ============================================================================
|
||||
// Note: For cover images, dithering is done in JpegToBmpConverter.cpp
|
||||
// This file handles BMP reading - use simple quantization to avoid double-dithering
|
||||
constexpr bool USE_ATKINSON = true; // Use Atkinson dithering instead of Floyd-Steinberg
|
||||
constexpr bool USE_FLOYD_STEINBERG = false; // Disabled - dithering done at JPEG conversion
|
||||
constexpr bool USE_NOISE_DITHERING = false; // Hash-based noise dithering
|
||||
// Brightness adjustments:
|
||||
constexpr bool USE_BRIGHTNESS = false; // true: apply brightness/gamma adjustments
|
||||
constexpr int BRIGHTNESS_BOOST = 20; // Brightness offset (0-50), only if USE_BRIGHTNESS=true
|
||||
constexpr bool GAMMA_CORRECTION = false; // Gamma curve, only if USE_BRIGHTNESS=true
|
||||
// ============================================================================
|
||||
|
||||
// Integer approximation of gamma correction (brightens midtones)
|
||||
static inline int applyGamma(int gray) {
|
||||
if (!GAMMA_CORRECTION) return gray;
|
||||
const int product = gray * 255;
|
||||
int x = gray;
|
||||
if (x > 0) {
|
||||
x = (x + product / x) >> 1;
|
||||
x = (x + product / x) >> 1;
|
||||
}
|
||||
return x > 255 ? 255 : x;
|
||||
}
|
||||
|
||||
// Simple quantization without dithering - just divide into 4 levels
|
||||
static inline uint8_t quantizeSimple(int gray) {
|
||||
if (USE_BRIGHTNESS) {
|
||||
gray += BRIGHTNESS_BOOST;
|
||||
if (gray > 255) gray = 255;
|
||||
gray = applyGamma(gray);
|
||||
}
|
||||
return static_cast<uint8_t>(gray >> 6);
|
||||
}
|
||||
|
||||
// Hash-based noise dithering - survives downsampling without moiré artifacts
|
||||
static inline uint8_t quantizeNoise(int gray, int x, int y) {
|
||||
if (USE_BRIGHTNESS) {
|
||||
gray += BRIGHTNESS_BOOST;
|
||||
if (gray > 255) gray = 255;
|
||||
gray = applyGamma(gray);
|
||||
}
|
||||
|
||||
uint32_t hash = static_cast<uint32_t>(x) * 374761393u + static_cast<uint32_t>(y) * 668265263u;
|
||||
hash = (hash ^ (hash >> 13)) * 1274126177u;
|
||||
const int threshold = static_cast<int>(hash >> 24);
|
||||
|
||||
const int scaled = gray * 3;
|
||||
if (scaled < 255) {
|
||||
return (scaled + threshold >= 255) ? 1 : 0;
|
||||
} else if (scaled < 510) {
|
||||
return ((scaled - 255) + threshold >= 255) ? 2 : 1;
|
||||
} else {
|
||||
return ((scaled - 510) + threshold >= 255) ? 3 : 2;
|
||||
}
|
||||
}
|
||||
|
||||
// Main quantization function
|
||||
static inline uint8_t quantize(int gray, int x, int y) {
|
||||
if (USE_NOISE_DITHERING) {
|
||||
return quantizeNoise(gray, x, y);
|
||||
} else {
|
||||
return quantizeSimple(gray);
|
||||
}
|
||||
}
|
||||
|
||||
// Floyd-Steinberg quantization with error diffusion and serpentine scanning
|
||||
// Returns 2-bit value (0-3) and updates error buffers
|
||||
static inline uint8_t quantizeFloydSteinberg(int gray, int x, int width, int16_t* errorCurRow, int16_t* errorNextRow,
|
||||
bool reverseDir) {
|
||||
// Add accumulated error to this pixel
|
||||
int adjusted = gray + errorCurRow[x + 1];
|
||||
|
||||
// Clamp to valid range
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
|
||||
// Quantize to 4 levels (0, 85, 170, 255)
|
||||
uint8_t quantized;
|
||||
int quantizedValue;
|
||||
if (adjusted < 43) {
|
||||
quantized = 0;
|
||||
quantizedValue = 0;
|
||||
} else if (adjusted < 128) {
|
||||
quantized = 1;
|
||||
quantizedValue = 85;
|
||||
} else if (adjusted < 213) {
|
||||
quantized = 2;
|
||||
quantizedValue = 170;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 255;
|
||||
}
|
||||
|
||||
// Calculate error
|
||||
int error = adjusted - quantizedValue;
|
||||
|
||||
// Distribute error to neighbors (serpentine: direction-aware)
|
||||
if (!reverseDir) {
|
||||
// Left to right
|
||||
errorCurRow[x + 2] += (error * 7) >> 4; // Right: 7/16
|
||||
errorNextRow[x] += (error * 3) >> 4; // Bottom-left: 3/16
|
||||
errorNextRow[x + 1] += (error * 5) >> 4; // Bottom: 5/16
|
||||
errorNextRow[x + 2] += (error) >> 4; // Bottom-right: 1/16
|
||||
} else {
|
||||
// Right to left (mirrored)
|
||||
errorCurRow[x] += (error * 7) >> 4; // Left: 7/16
|
||||
errorNextRow[x + 2] += (error * 3) >> 4; // Bottom-right: 3/16
|
||||
errorNextRow[x + 1] += (error * 5) >> 4; // Bottom: 5/16
|
||||
errorNextRow[x] += (error) >> 4; // Bottom-left: 1/16
|
||||
}
|
||||
|
||||
return quantized;
|
||||
}
|
||||
|
||||
Bitmap::~Bitmap() {
|
||||
delete[] errorCurRow;
|
||||
delete[] errorNextRow;
|
||||
|
||||
delete atkinsonDitherer;
|
||||
delete fsDitherer;
|
||||
}
|
||||
|
||||
uint16_t Bitmap::readLE16(FsFile& f) {
|
||||
@ -140,14 +244,13 @@ BmpReaderError Bitmap::parseHeaders() {
|
||||
return BmpReaderError::SeekPixelDataFailed;
|
||||
}
|
||||
|
||||
// Create ditherer if enabled (only for 2-bit output)
|
||||
// Use OUTPUT dimensions for dithering (after prescaling)
|
||||
if (bpp > 2 && dithering) {
|
||||
if (USE_ATKINSON) {
|
||||
atkinsonDitherer = new AtkinsonDitherer(width);
|
||||
} else {
|
||||
fsDitherer = new FloydSteinbergDitherer(width);
|
||||
}
|
||||
// Allocate Floyd-Steinberg error buffers if enabled
|
||||
if (USE_FLOYD_STEINBERG) {
|
||||
delete[] errorCurRow;
|
||||
delete[] errorNextRow;
|
||||
errorCurRow = new int16_t[width + 2](); // +2 for boundary handling
|
||||
errorNextRow = new int16_t[width + 2]();
|
||||
prevRowY = -1;
|
||||
}
|
||||
|
||||
return BmpReaderError::Ok;
|
||||
@ -158,6 +261,17 @@ BmpReaderError Bitmap::readNextRow(uint8_t* data, uint8_t* rowBuffer) const {
|
||||
// Note: rowBuffer should be pre-allocated by the caller to size 'rowBytes'
|
||||
if (file.read(rowBuffer, rowBytes) != rowBytes) return BmpReaderError::ShortReadRow;
|
||||
|
||||
// Handle Floyd-Steinberg error buffer progression
|
||||
const bool useFS = USE_FLOYD_STEINBERG && errorCurRow && errorNextRow;
|
||||
if (useFS) {
|
||||
if (prevRowY != -1) {
|
||||
// Sequential access - swap buffers
|
||||
int16_t* temp = errorCurRow;
|
||||
errorCurRow = errorNextRow;
|
||||
errorNextRow = temp;
|
||||
memset(errorNextRow, 0, (width + 2) * sizeof(int16_t));
|
||||
}
|
||||
}
|
||||
prevRowY += 1;
|
||||
|
||||
uint8_t* outPtr = data;
|
||||
@ -168,18 +282,12 @@ BmpReaderError Bitmap::readNextRow(uint8_t* data, uint8_t* rowBuffer) const {
|
||||
// Helper lambda to pack 2bpp color into the output stream
|
||||
auto packPixel = [&](const uint8_t lum) {
|
||||
uint8_t color;
|
||||
if (atkinsonDitherer) {
|
||||
color = atkinsonDitherer->processPixel(adjustPixel(lum), currentX);
|
||||
} else if (fsDitherer) {
|
||||
color = fsDitherer->processPixel(adjustPixel(lum), currentX);
|
||||
if (useFS) {
|
||||
// Floyd-Steinberg error diffusion
|
||||
color = quantizeFloydSteinberg(lum, currentX, width, errorCurRow, errorNextRow, false);
|
||||
} else {
|
||||
if (bpp > 2) {
|
||||
// Simple quantization or noise dithering
|
||||
color = quantize(adjustPixel(lum), currentX, prevRowY);
|
||||
} else {
|
||||
// do not quantize 2bpp image
|
||||
color = static_cast<uint8_t>(lum >> 6);
|
||||
}
|
||||
// Simple quantization or noise dithering
|
||||
color = quantize(lum, currentX, prevRowY);
|
||||
}
|
||||
currentOutByte |= (color << bitShift);
|
||||
if (bitShift == 0) {
|
||||
@ -237,11 +345,6 @@ BmpReaderError Bitmap::readNextRow(uint8_t* data, uint8_t* rowBuffer) const {
|
||||
return BmpReaderError::UnsupportedBpp;
|
||||
}
|
||||
|
||||
if (atkinsonDitherer)
|
||||
atkinsonDitherer->nextRow();
|
||||
else if (fsDitherer)
|
||||
fsDitherer->nextRow();
|
||||
|
||||
// Flush remaining bits if width is not a multiple of 4
|
||||
if (bitShift != 6) *outPtr = currentOutByte;
|
||||
|
||||
@ -253,9 +356,12 @@ BmpReaderError Bitmap::rewindToData() const {
|
||||
return BmpReaderError::SeekPixelDataFailed;
|
||||
}
|
||||
|
||||
// Reset dithering when rewinding
|
||||
if (fsDitherer) fsDitherer->reset();
|
||||
if (atkinsonDitherer) atkinsonDitherer->reset();
|
||||
// Reset Floyd-Steinberg error buffers when rewinding
|
||||
if (USE_FLOYD_STEINBERG && errorCurRow && errorNextRow) {
|
||||
memset(errorCurRow, 0, (width + 2) * sizeof(int16_t));
|
||||
memset(errorNextRow, 0, (width + 2) * sizeof(int16_t));
|
||||
prevRowY = -1;
|
||||
}
|
||||
|
||||
return BmpReaderError::Ok;
|
||||
}
|
||||
|
||||
@ -2,10 +2,6 @@
|
||||
|
||||
#include <SdFat.h>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#include "BitmapHelpers.h"
|
||||
|
||||
enum class BmpReaderError : uint8_t {
|
||||
Ok = 0,
|
||||
FileInvalid,
|
||||
@ -32,7 +28,7 @@ class Bitmap {
|
||||
public:
|
||||
static const char* errorToString(BmpReaderError err);
|
||||
|
||||
explicit Bitmap(FsFile& file, bool dithering = false) : file(file), dithering(dithering) {}
|
||||
explicit Bitmap(FsFile& file) : file(file) {}
|
||||
~Bitmap();
|
||||
BmpReaderError parseHeaders();
|
||||
BmpReaderError readNextRow(uint8_t* data, uint8_t* rowBuffer) const;
|
||||
@ -48,7 +44,6 @@ class Bitmap {
|
||||
static uint32_t readLE32(FsFile& f);
|
||||
|
||||
FsFile& file;
|
||||
bool dithering = false;
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
bool topDown = false;
|
||||
@ -61,7 +56,4 @@ class Bitmap {
|
||||
mutable int16_t* errorCurRow = nullptr;
|
||||
mutable int16_t* errorNextRow = nullptr;
|
||||
mutable int prevRowY = -1; // Track row progression for error propagation
|
||||
|
||||
mutable AtkinsonDitherer* atkinsonDitherer = nullptr;
|
||||
mutable FloydSteinbergDitherer* fsDitherer = nullptr;
|
||||
};
|
||||
|
||||
@ -1,90 +0,0 @@
|
||||
#include "BitmapHelpers.h"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
// Brightness/Contrast adjustments:
|
||||
constexpr bool USE_BRIGHTNESS = false; // true: apply brightness/gamma adjustments
|
||||
constexpr int BRIGHTNESS_BOOST = 10; // Brightness offset (0-50)
|
||||
constexpr bool GAMMA_CORRECTION = false; // Gamma curve (brightens midtones)
|
||||
constexpr float CONTRAST_FACTOR = 1.15f; // Contrast multiplier (1.0 = no change, >1 = more contrast)
|
||||
constexpr bool USE_NOISE_DITHERING = false; // Hash-based noise dithering
|
||||
|
||||
// Integer approximation of gamma correction (brightens midtones)
|
||||
// Uses a simple curve: out = 255 * sqrt(in/255) ≈ sqrt(in * 255)
|
||||
static inline int applyGamma(int gray) {
|
||||
if (!GAMMA_CORRECTION) return gray;
|
||||
// Fast integer square root approximation for gamma ~0.5 (brightening)
|
||||
// This brightens dark/mid tones while preserving highlights
|
||||
const int product = gray * 255;
|
||||
// Newton-Raphson integer sqrt (2 iterations for good accuracy)
|
||||
int x = gray;
|
||||
if (x > 0) {
|
||||
x = (x + product / x) >> 1;
|
||||
x = (x + product / x) >> 1;
|
||||
}
|
||||
return x > 255 ? 255 : x;
|
||||
}
|
||||
|
||||
// Apply contrast adjustment around midpoint (128)
|
||||
// factor > 1.0 increases contrast, < 1.0 decreases
|
||||
static inline int applyContrast(int gray) {
|
||||
// Integer-based contrast: (gray - 128) * factor + 128
|
||||
// Using fixed-point: factor 1.15 ≈ 115/100
|
||||
constexpr int factorNum = static_cast<int>(CONTRAST_FACTOR * 100);
|
||||
int adjusted = ((gray - 128) * factorNum) / 100 + 128;
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
return adjusted;
|
||||
}
|
||||
// Combined brightness/contrast/gamma adjustment
|
||||
int adjustPixel(int gray) {
|
||||
if (!USE_BRIGHTNESS) return gray;
|
||||
|
||||
// Order: contrast first, then brightness, then gamma
|
||||
gray = applyContrast(gray);
|
||||
gray += BRIGHTNESS_BOOST;
|
||||
if (gray > 255) gray = 255;
|
||||
if (gray < 0) gray = 0;
|
||||
gray = applyGamma(gray);
|
||||
|
||||
return gray;
|
||||
}
|
||||
// Simple quantization without dithering - divide into 4 levels
|
||||
// The thresholds are fine-tuned to the X4 display
|
||||
uint8_t quantizeSimple(int gray) {
|
||||
if (gray < 45) {
|
||||
return 0;
|
||||
} else if (gray < 70) {
|
||||
return 1;
|
||||
} else if (gray < 140) {
|
||||
return 2;
|
||||
} else {
|
||||
return 3;
|
||||
}
|
||||
}
|
||||
|
||||
// Hash-based noise dithering - survives downsampling without moiré artifacts
|
||||
// Uses integer hash to generate pseudo-random threshold per pixel
|
||||
static inline uint8_t quantizeNoise(int gray, int x, int y) {
|
||||
uint32_t hash = static_cast<uint32_t>(x) * 374761393u + static_cast<uint32_t>(y) * 668265263u;
|
||||
hash = (hash ^ (hash >> 13)) * 1274126177u;
|
||||
const int threshold = static_cast<int>(hash >> 24);
|
||||
|
||||
const int scaled = gray * 3;
|
||||
if (scaled < 255) {
|
||||
return (scaled + threshold >= 255) ? 1 : 0;
|
||||
} else if (scaled < 510) {
|
||||
return ((scaled - 255) + threshold >= 255) ? 2 : 1;
|
||||
} else {
|
||||
return ((scaled - 510) + threshold >= 255) ? 3 : 2;
|
||||
}
|
||||
}
|
||||
|
||||
// Main quantization function - selects between methods based on config
|
||||
uint8_t quantize(int gray, int x, int y) {
|
||||
if (USE_NOISE_DITHERING) {
|
||||
return quantizeNoise(gray, x, y);
|
||||
} else {
|
||||
return quantizeSimple(gray);
|
||||
}
|
||||
}
|
||||
@ -1,233 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstring>
|
||||
|
||||
// Helper functions
|
||||
uint8_t quantize(int gray, int x, int y);
|
||||
uint8_t quantizeSimple(int gray);
|
||||
int adjustPixel(int gray);
|
||||
|
||||
// Atkinson dithering - distributes only 6/8 (75%) of error for cleaner results
|
||||
// Error distribution pattern:
|
||||
// X 1/8 1/8
|
||||
// 1/8 1/8 1/8
|
||||
// 1/8
|
||||
// Less error buildup = fewer artifacts than Floyd-Steinberg
|
||||
class AtkinsonDitherer {
|
||||
public:
|
||||
explicit AtkinsonDitherer(int width) : width(width) {
|
||||
errorRow0 = new int16_t[width + 4](); // Current row
|
||||
errorRow1 = new int16_t[width + 4](); // Next row
|
||||
errorRow2 = new int16_t[width + 4](); // Row after next
|
||||
}
|
||||
|
||||
~AtkinsonDitherer() {
|
||||
delete[] errorRow0;
|
||||
delete[] errorRow1;
|
||||
delete[] errorRow2;
|
||||
}
|
||||
// **1. EXPLICITLY DELETE THE COPY CONSTRUCTOR**
|
||||
AtkinsonDitherer(const AtkinsonDitherer& other) = delete;
|
||||
|
||||
// **2. EXPLICITLY DELETE THE COPY ASSIGNMENT OPERATOR**
|
||||
AtkinsonDitherer& operator=(const AtkinsonDitherer& other) = delete;
|
||||
|
||||
uint8_t processPixel(int gray, int x) {
|
||||
// Add accumulated error
|
||||
int adjusted = gray + errorRow0[x + 2];
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
|
||||
// Quantize to 4 levels
|
||||
uint8_t quantized;
|
||||
int quantizedValue;
|
||||
if (false) { // original thresholds
|
||||
if (adjusted < 43) {
|
||||
quantized = 0;
|
||||
quantizedValue = 0;
|
||||
} else if (adjusted < 128) {
|
||||
quantized = 1;
|
||||
quantizedValue = 85;
|
||||
} else if (adjusted < 213) {
|
||||
quantized = 2;
|
||||
quantizedValue = 170;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 255;
|
||||
}
|
||||
} else { // fine-tuned to X4 eink display
|
||||
if (adjusted < 30) {
|
||||
quantized = 0;
|
||||
quantizedValue = 15;
|
||||
} else if (adjusted < 50) {
|
||||
quantized = 1;
|
||||
quantizedValue = 30;
|
||||
} else if (adjusted < 140) {
|
||||
quantized = 2;
|
||||
quantizedValue = 80;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 210;
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate error (only distribute 6/8 = 75%)
|
||||
int error = (adjusted - quantizedValue) >> 3; // error/8
|
||||
|
||||
// Distribute 1/8 to each of 6 neighbors
|
||||
errorRow0[x + 3] += error; // Right
|
||||
errorRow0[x + 4] += error; // Right+1
|
||||
errorRow1[x + 1] += error; // Bottom-left
|
||||
errorRow1[x + 2] += error; // Bottom
|
||||
errorRow1[x + 3] += error; // Bottom-right
|
||||
errorRow2[x + 2] += error; // Two rows down
|
||||
|
||||
return quantized;
|
||||
}
|
||||
|
||||
void nextRow() {
|
||||
int16_t* temp = errorRow0;
|
||||
errorRow0 = errorRow1;
|
||||
errorRow1 = errorRow2;
|
||||
errorRow2 = temp;
|
||||
memset(errorRow2, 0, (width + 4) * sizeof(int16_t));
|
||||
}
|
||||
|
||||
void reset() {
|
||||
memset(errorRow0, 0, (width + 4) * sizeof(int16_t));
|
||||
memset(errorRow1, 0, (width + 4) * sizeof(int16_t));
|
||||
memset(errorRow2, 0, (width + 4) * sizeof(int16_t));
|
||||
}
|
||||
|
||||
private:
|
||||
int width;
|
||||
int16_t* errorRow0;
|
||||
int16_t* errorRow1;
|
||||
int16_t* errorRow2;
|
||||
};
|
||||
|
||||
// Floyd-Steinberg error diffusion dithering with serpentine scanning
|
||||
// Serpentine scanning alternates direction each row to reduce "worm" artifacts
|
||||
// Error distribution pattern (left-to-right):
|
||||
// X 7/16
|
||||
// 3/16 5/16 1/16
|
||||
// Error distribution pattern (right-to-left, mirrored):
|
||||
// 1/16 5/16 3/16
|
||||
// 7/16 X
|
||||
class FloydSteinbergDitherer {
|
||||
public:
|
||||
explicit FloydSteinbergDitherer(int width) : width(width), rowCount(0) {
|
||||
errorCurRow = new int16_t[width + 2](); // +2 for boundary handling
|
||||
errorNextRow = new int16_t[width + 2]();
|
||||
}
|
||||
|
||||
~FloydSteinbergDitherer() {
|
||||
delete[] errorCurRow;
|
||||
delete[] errorNextRow;
|
||||
}
|
||||
|
||||
// **1. EXPLICITLY DELETE THE COPY CONSTRUCTOR**
|
||||
FloydSteinbergDitherer(const FloydSteinbergDitherer& other) = delete;
|
||||
|
||||
// **2. EXPLICITLY DELETE THE COPY ASSIGNMENT OPERATOR**
|
||||
FloydSteinbergDitherer& operator=(const FloydSteinbergDitherer& other) = delete;
|
||||
|
||||
// Process a single pixel and return quantized 2-bit value
|
||||
// x is the logical x position (0 to width-1), direction handled internally
|
||||
uint8_t processPixel(int gray, int x) {
|
||||
// Add accumulated error to this pixel
|
||||
int adjusted = gray + errorCurRow[x + 1];
|
||||
|
||||
// Clamp to valid range
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
|
||||
// Quantize to 4 levels (0, 85, 170, 255)
|
||||
uint8_t quantized;
|
||||
int quantizedValue;
|
||||
if (false) { // original thresholds
|
||||
if (adjusted < 43) {
|
||||
quantized = 0;
|
||||
quantizedValue = 0;
|
||||
} else if (adjusted < 128) {
|
||||
quantized = 1;
|
||||
quantizedValue = 85;
|
||||
} else if (adjusted < 213) {
|
||||
quantized = 2;
|
||||
quantizedValue = 170;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 255;
|
||||
}
|
||||
} else { // fine-tuned to X4 eink display
|
||||
if (adjusted < 30) {
|
||||
quantized = 0;
|
||||
quantizedValue = 15;
|
||||
} else if (adjusted < 50) {
|
||||
quantized = 1;
|
||||
quantizedValue = 30;
|
||||
} else if (adjusted < 140) {
|
||||
quantized = 2;
|
||||
quantizedValue = 80;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 210;
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate error
|
||||
int error = adjusted - quantizedValue;
|
||||
|
||||
// Distribute error to neighbors (serpentine: direction-aware)
|
||||
if (!isReverseRow()) {
|
||||
// Left to right: standard distribution
|
||||
// Right: 7/16
|
||||
errorCurRow[x + 2] += (error * 7) >> 4;
|
||||
// Bottom-left: 3/16
|
||||
errorNextRow[x] += (error * 3) >> 4;
|
||||
// Bottom: 5/16
|
||||
errorNextRow[x + 1] += (error * 5) >> 4;
|
||||
// Bottom-right: 1/16
|
||||
errorNextRow[x + 2] += (error) >> 4;
|
||||
} else {
|
||||
// Right to left: mirrored distribution
|
||||
// Left: 7/16
|
||||
errorCurRow[x] += (error * 7) >> 4;
|
||||
// Bottom-right: 3/16
|
||||
errorNextRow[x + 2] += (error * 3) >> 4;
|
||||
// Bottom: 5/16
|
||||
errorNextRow[x + 1] += (error * 5) >> 4;
|
||||
// Bottom-left: 1/16
|
||||
errorNextRow[x] += (error) >> 4;
|
||||
}
|
||||
|
||||
return quantized;
|
||||
}
|
||||
|
||||
// Call at the end of each row to swap buffers
|
||||
void nextRow() {
|
||||
// Swap buffers
|
||||
int16_t* temp = errorCurRow;
|
||||
errorCurRow = errorNextRow;
|
||||
errorNextRow = temp;
|
||||
// Clear the next row buffer
|
||||
memset(errorNextRow, 0, (width + 2) * sizeof(int16_t));
|
||||
rowCount++;
|
||||
}
|
||||
|
||||
// Check if current row should be processed in reverse
|
||||
bool isReverseRow() const { return (rowCount & 1) != 0; }
|
||||
|
||||
// Reset for a new image or MCU block
|
||||
void reset() {
|
||||
memset(errorCurRow, 0, (width + 2) * sizeof(int16_t));
|
||||
memset(errorNextRow, 0, (width + 2) * sizeof(int16_t));
|
||||
rowCount = 0;
|
||||
}
|
||||
|
||||
private:
|
||||
int width;
|
||||
int rowCount;
|
||||
int16_t* errorCurRow;
|
||||
int16_t* errorNextRow;
|
||||
};
|
||||
@ -7,8 +7,6 @@
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
|
||||
#include "BitmapHelpers.h"
|
||||
|
||||
// Context structure for picojpeg callback
|
||||
struct JpegReadContext {
|
||||
FsFile& file;
|
||||
@ -25,12 +23,282 @@ constexpr bool USE_8BIT_OUTPUT = false; // true: 8-bit grayscale (no quantizati
|
||||
constexpr bool USE_ATKINSON = true; // Atkinson dithering (cleaner than F-S, less error diffusion)
|
||||
constexpr bool USE_FLOYD_STEINBERG = false; // Floyd-Steinberg error diffusion (can cause "worm" artifacts)
|
||||
constexpr bool USE_NOISE_DITHERING = false; // Hash-based noise dithering (good for downsampling)
|
||||
// Brightness/Contrast adjustments:
|
||||
constexpr bool USE_BRIGHTNESS = true; // true: apply brightness/gamma adjustments
|
||||
constexpr int BRIGHTNESS_BOOST = 10; // Brightness offset (0-50)
|
||||
constexpr bool GAMMA_CORRECTION = true; // Gamma curve (brightens midtones)
|
||||
constexpr float CONTRAST_FACTOR = 1.15f; // Contrast multiplier (1.0 = no change, >1 = more contrast)
|
||||
// Pre-resize to target display size (CRITICAL: avoids dithering artifacts from post-downsampling)
|
||||
constexpr bool USE_PRESCALE = true; // true: scale image to target size before dithering
|
||||
constexpr int TARGET_MAX_WIDTH = 480; // Max width for cover images (portrait display width)
|
||||
constexpr int TARGET_MAX_HEIGHT = 800; // Max height for cover images (portrait display height)
|
||||
// ============================================================================
|
||||
|
||||
// Integer approximation of gamma correction (brightens midtones)
|
||||
// Uses a simple curve: out = 255 * sqrt(in/255) ≈ sqrt(in * 255)
|
||||
static inline int applyGamma(int gray) {
|
||||
if (!GAMMA_CORRECTION) return gray;
|
||||
// Fast integer square root approximation for gamma ~0.5 (brightening)
|
||||
// This brightens dark/mid tones while preserving highlights
|
||||
const int product = gray * 255;
|
||||
// Newton-Raphson integer sqrt (2 iterations for good accuracy)
|
||||
int x = gray;
|
||||
if (x > 0) {
|
||||
x = (x + product / x) >> 1;
|
||||
x = (x + product / x) >> 1;
|
||||
}
|
||||
return x > 255 ? 255 : x;
|
||||
}
|
||||
|
||||
// Apply contrast adjustment around midpoint (128)
|
||||
// factor > 1.0 increases contrast, < 1.0 decreases
|
||||
static inline int applyContrast(int gray) {
|
||||
// Integer-based contrast: (gray - 128) * factor + 128
|
||||
// Using fixed-point: factor 1.15 ≈ 115/100
|
||||
constexpr int factorNum = static_cast<int>(CONTRAST_FACTOR * 100);
|
||||
int adjusted = ((gray - 128) * factorNum) / 100 + 128;
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
return adjusted;
|
||||
}
|
||||
|
||||
// Combined brightness/contrast/gamma adjustment
|
||||
static inline int adjustPixel(int gray) {
|
||||
if (!USE_BRIGHTNESS) return gray;
|
||||
|
||||
// Order: contrast first, then brightness, then gamma
|
||||
gray = applyContrast(gray);
|
||||
gray += BRIGHTNESS_BOOST;
|
||||
if (gray > 255) gray = 255;
|
||||
if (gray < 0) gray = 0;
|
||||
gray = applyGamma(gray);
|
||||
|
||||
return gray;
|
||||
}
|
||||
|
||||
// Simple quantization without dithering - just divide into 4 levels
|
||||
static inline uint8_t quantizeSimple(int gray) {
|
||||
gray = adjustPixel(gray);
|
||||
// Simple 2-bit quantization: 0-63=0, 64-127=1, 128-191=2, 192-255=3
|
||||
return static_cast<uint8_t>(gray >> 6);
|
||||
}
|
||||
|
||||
// Hash-based noise dithering - survives downsampling without moiré artifacts
|
||||
// Uses integer hash to generate pseudo-random threshold per pixel
|
||||
static inline uint8_t quantizeNoise(int gray, int x, int y) {
|
||||
gray = adjustPixel(gray);
|
||||
|
||||
// Generate noise threshold using integer hash (no regular pattern to alias)
|
||||
uint32_t hash = static_cast<uint32_t>(x) * 374761393u + static_cast<uint32_t>(y) * 668265263u;
|
||||
hash = (hash ^ (hash >> 13)) * 1274126177u;
|
||||
const int threshold = static_cast<int>(hash >> 24); // 0-255
|
||||
|
||||
// Map gray (0-255) to 4 levels with dithering
|
||||
const int scaled = gray * 3;
|
||||
|
||||
if (scaled < 255) {
|
||||
return (scaled + threshold >= 255) ? 1 : 0;
|
||||
} else if (scaled < 510) {
|
||||
return ((scaled - 255) + threshold >= 255) ? 2 : 1;
|
||||
} else {
|
||||
return ((scaled - 510) + threshold >= 255) ? 3 : 2;
|
||||
}
|
||||
}
|
||||
|
||||
// Main quantization function - selects between methods based on config
|
||||
static inline uint8_t quantize(int gray, int x, int y) {
|
||||
if (USE_NOISE_DITHERING) {
|
||||
return quantizeNoise(gray, x, y);
|
||||
} else {
|
||||
return quantizeSimple(gray);
|
||||
}
|
||||
}
|
||||
|
||||
// Atkinson dithering - distributes only 6/8 (75%) of error for cleaner results
|
||||
// Error distribution pattern:
|
||||
// X 1/8 1/8
|
||||
// 1/8 1/8 1/8
|
||||
// 1/8
|
||||
// Less error buildup = fewer artifacts than Floyd-Steinberg
|
||||
class AtkinsonDitherer {
|
||||
public:
|
||||
AtkinsonDitherer(int width) : width(width) {
|
||||
errorRow0 = new int16_t[width + 4](); // Current row
|
||||
errorRow1 = new int16_t[width + 4](); // Next row
|
||||
errorRow2 = new int16_t[width + 4](); // Row after next
|
||||
}
|
||||
|
||||
~AtkinsonDitherer() {
|
||||
delete[] errorRow0;
|
||||
delete[] errorRow1;
|
||||
delete[] errorRow2;
|
||||
}
|
||||
|
||||
uint8_t processPixel(int gray, int x) {
|
||||
// Apply brightness/contrast/gamma adjustments
|
||||
gray = adjustPixel(gray);
|
||||
|
||||
// Add accumulated error
|
||||
int adjusted = gray + errorRow0[x + 2];
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
|
||||
// Quantize to 4 levels
|
||||
uint8_t quantized;
|
||||
int quantizedValue;
|
||||
if (adjusted < 43) {
|
||||
quantized = 0;
|
||||
quantizedValue = 0;
|
||||
} else if (adjusted < 128) {
|
||||
quantized = 1;
|
||||
quantizedValue = 85;
|
||||
} else if (adjusted < 213) {
|
||||
quantized = 2;
|
||||
quantizedValue = 170;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 255;
|
||||
}
|
||||
|
||||
// Calculate error (only distribute 6/8 = 75%)
|
||||
int error = (adjusted - quantizedValue) >> 3; // error/8
|
||||
|
||||
// Distribute 1/8 to each of 6 neighbors
|
||||
errorRow0[x + 3] += error; // Right
|
||||
errorRow0[x + 4] += error; // Right+1
|
||||
errorRow1[x + 1] += error; // Bottom-left
|
||||
errorRow1[x + 2] += error; // Bottom
|
||||
errorRow1[x + 3] += error; // Bottom-right
|
||||
errorRow2[x + 2] += error; // Two rows down
|
||||
|
||||
return quantized;
|
||||
}
|
||||
|
||||
void nextRow() {
|
||||
int16_t* temp = errorRow0;
|
||||
errorRow0 = errorRow1;
|
||||
errorRow1 = errorRow2;
|
||||
errorRow2 = temp;
|
||||
memset(errorRow2, 0, (width + 4) * sizeof(int16_t));
|
||||
}
|
||||
|
||||
void reset() {
|
||||
memset(errorRow0, 0, (width + 4) * sizeof(int16_t));
|
||||
memset(errorRow1, 0, (width + 4) * sizeof(int16_t));
|
||||
memset(errorRow2, 0, (width + 4) * sizeof(int16_t));
|
||||
}
|
||||
|
||||
private:
|
||||
int width;
|
||||
int16_t* errorRow0;
|
||||
int16_t* errorRow1;
|
||||
int16_t* errorRow2;
|
||||
};
|
||||
|
||||
// Floyd-Steinberg error diffusion dithering with serpentine scanning
|
||||
// Serpentine scanning alternates direction each row to reduce "worm" artifacts
|
||||
// Error distribution pattern (left-to-right):
|
||||
// X 7/16
|
||||
// 3/16 5/16 1/16
|
||||
// Error distribution pattern (right-to-left, mirrored):
|
||||
// 1/16 5/16 3/16
|
||||
// 7/16 X
|
||||
class FloydSteinbergDitherer {
|
||||
public:
|
||||
FloydSteinbergDitherer(int width) : width(width), rowCount(0) {
|
||||
errorCurRow = new int16_t[width + 2](); // +2 for boundary handling
|
||||
errorNextRow = new int16_t[width + 2]();
|
||||
}
|
||||
|
||||
~FloydSteinbergDitherer() {
|
||||
delete[] errorCurRow;
|
||||
delete[] errorNextRow;
|
||||
}
|
||||
|
||||
// Process a single pixel and return quantized 2-bit value
|
||||
// x is the logical x position (0 to width-1), direction handled internally
|
||||
uint8_t processPixel(int gray, int x, bool reverseDirection) {
|
||||
// Add accumulated error to this pixel
|
||||
int adjusted = gray + errorCurRow[x + 1];
|
||||
|
||||
// Clamp to valid range
|
||||
if (adjusted < 0) adjusted = 0;
|
||||
if (adjusted > 255) adjusted = 255;
|
||||
|
||||
// Quantize to 4 levels (0, 85, 170, 255)
|
||||
uint8_t quantized;
|
||||
int quantizedValue;
|
||||
if (adjusted < 43) {
|
||||
quantized = 0;
|
||||
quantizedValue = 0;
|
||||
} else if (adjusted < 128) {
|
||||
quantized = 1;
|
||||
quantizedValue = 85;
|
||||
} else if (adjusted < 213) {
|
||||
quantized = 2;
|
||||
quantizedValue = 170;
|
||||
} else {
|
||||
quantized = 3;
|
||||
quantizedValue = 255;
|
||||
}
|
||||
|
||||
// Calculate error
|
||||
int error = adjusted - quantizedValue;
|
||||
|
||||
// Distribute error to neighbors (serpentine: direction-aware)
|
||||
if (!reverseDirection) {
|
||||
// Left to right: standard distribution
|
||||
// Right: 7/16
|
||||
errorCurRow[x + 2] += (error * 7) >> 4;
|
||||
// Bottom-left: 3/16
|
||||
errorNextRow[x] += (error * 3) >> 4;
|
||||
// Bottom: 5/16
|
||||
errorNextRow[x + 1] += (error * 5) >> 4;
|
||||
// Bottom-right: 1/16
|
||||
errorNextRow[x + 2] += (error) >> 4;
|
||||
} else {
|
||||
// Right to left: mirrored distribution
|
||||
// Left: 7/16
|
||||
errorCurRow[x] += (error * 7) >> 4;
|
||||
// Bottom-right: 3/16
|
||||
errorNextRow[x + 2] += (error * 3) >> 4;
|
||||
// Bottom: 5/16
|
||||
errorNextRow[x + 1] += (error * 5) >> 4;
|
||||
// Bottom-left: 1/16
|
||||
errorNextRow[x] += (error) >> 4;
|
||||
}
|
||||
|
||||
return quantized;
|
||||
}
|
||||
|
||||
// Call at the end of each row to swap buffers
|
||||
void nextRow() {
|
||||
// Swap buffers
|
||||
int16_t* temp = errorCurRow;
|
||||
errorCurRow = errorNextRow;
|
||||
errorNextRow = temp;
|
||||
// Clear the next row buffer
|
||||
memset(errorNextRow, 0, (width + 2) * sizeof(int16_t));
|
||||
rowCount++;
|
||||
}
|
||||
|
||||
// Check if current row should be processed in reverse
|
||||
bool isReverseRow() const { return (rowCount & 1) != 0; }
|
||||
|
||||
// Reset for a new image or MCU block
|
||||
void reset() {
|
||||
memset(errorCurRow, 0, (width + 2) * sizeof(int16_t));
|
||||
memset(errorNextRow, 0, (width + 2) * sizeof(int16_t));
|
||||
rowCount = 0;
|
||||
}
|
||||
|
||||
private:
|
||||
int width;
|
||||
int rowCount;
|
||||
int16_t* errorCurRow;
|
||||
int16_t* errorNextRow;
|
||||
};
|
||||
|
||||
inline void write16(Print& out, const uint16_t value) {
|
||||
out.write(value & 0xFF);
|
||||
out.write((value >> 8) & 0xFF);
|
||||
@ -355,12 +623,12 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
|
||||
}
|
||||
} else {
|
||||
for (int x = 0; x < outWidth; x++) {
|
||||
const uint8_t gray = adjustPixel(mcuRowBuffer[bufferY * imageInfo.m_width + x]);
|
||||
const uint8_t gray = mcuRowBuffer[bufferY * imageInfo.m_width + x];
|
||||
uint8_t twoBit;
|
||||
if (atkinsonDitherer) {
|
||||
twoBit = atkinsonDitherer->processPixel(gray, x);
|
||||
} else if (fsDitherer) {
|
||||
twoBit = fsDitherer->processPixel(gray, x);
|
||||
twoBit = fsDitherer->processPixel(gray, x, fsDitherer->isReverseRow());
|
||||
} else {
|
||||
twoBit = quantize(gray, x, y);
|
||||
}
|
||||
@ -418,12 +686,12 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
|
||||
}
|
||||
} else {
|
||||
for (int x = 0; x < outWidth; x++) {
|
||||
const uint8_t gray = adjustPixel((rowCount[x] > 0) ? (rowAccum[x] / rowCount[x]) : 0);
|
||||
const uint8_t gray = (rowCount[x] > 0) ? (rowAccum[x] / rowCount[x]) : 0;
|
||||
uint8_t twoBit;
|
||||
if (atkinsonDitherer) {
|
||||
twoBit = atkinsonDitherer->processPixel(gray, x);
|
||||
} else if (fsDitherer) {
|
||||
twoBit = fsDitherer->processPixel(gray, x);
|
||||
twoBit = fsDitherer->processPixel(gray, x, fsDitherer->isReverseRow());
|
||||
} else {
|
||||
twoBit = quantize(gray, x, currentOutY);
|
||||
}
|
||||
|
||||
@ -1,9 +1,7 @@
|
||||
[platformio]
|
||||
crosspoint_version = 0.12.0
|
||||
default_envs = default
|
||||
|
||||
[crosspoint]
|
||||
version = 0.13.1
|
||||
|
||||
[base]
|
||||
platform = espressif32 @ 6.12.0
|
||||
board = esp32-c3-devkitm-1
|
||||
@ -52,10 +50,10 @@ lib_deps =
|
||||
extends = base
|
||||
build_flags =
|
||||
${base.build_flags}
|
||||
-DCROSSPOINT_VERSION=\"${crosspoint.version}-dev\"
|
||||
-DCROSSPOINT_VERSION=\"${platformio.crosspoint_version}-dev\"
|
||||
|
||||
[env:gh_release]
|
||||
extends = base
|
||||
build_flags =
|
||||
${base.build_flags}
|
||||
-DCROSSPOINT_VERSION=\"${crosspoint.version}\"
|
||||
-DCROSSPOINT_VERSION=\"${platformio.crosspoint_version}\"
|
||||
|
||||
@ -14,7 +14,7 @@ CrossPointSettings CrossPointSettings::instance;
|
||||
namespace {
|
||||
constexpr uint8_t SETTINGS_FILE_VERSION = 1;
|
||||
// Increment this when adding new persisted settings fields
|
||||
constexpr uint8_t SETTINGS_COUNT = 17;
|
||||
constexpr uint8_t SETTINGS_COUNT = 18;
|
||||
constexpr char SETTINGS_FILE[] = "/.crosspoint/settings.bin";
|
||||
} // namespace
|
||||
|
||||
@ -46,7 +46,7 @@ bool CrossPointSettings::saveToFile() const {
|
||||
serialization::writePod(outputFile, sleepScreenCoverMode);
|
||||
serialization::writeString(outputFile, std::string(opdsServerUrl));
|
||||
serialization::writePod(outputFile, textAntiAliasing);
|
||||
serialization::writePod(outputFile, hideBatteryPercentage);
|
||||
serialization::writePod(outputFile, lastUsedSleep);
|
||||
outputFile.close();
|
||||
|
||||
Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
|
||||
@ -111,7 +111,7 @@ bool CrossPointSettings::loadFromFile() {
|
||||
}
|
||||
serialization::readPod(inputFile, textAntiAliasing);
|
||||
if (++settingsRead >= fileSettingsCount) break;
|
||||
serialization::readPod(inputFile, hideBatteryPercentage);
|
||||
serialization::readPod(inputFile, lastUsedSleep);
|
||||
if (++settingsRead >= fileSettingsCount) break;
|
||||
} while (false);
|
||||
|
||||
|
||||
@ -55,9 +55,6 @@ class CrossPointSettings {
|
||||
// Short power button press actions
|
||||
enum SHORT_PWRBTN { IGNORE = 0, SLEEP = 1, PAGE_TURN = 2 };
|
||||
|
||||
// Hide battery percentage
|
||||
enum HIDE_BATTERY_PERCENTAGE { HIDE_NEVER = 0, HIDE_READER = 1, HIDE_ALWAYS = 2 };
|
||||
|
||||
// Sleep screen settings
|
||||
uint8_t sleepScreen = DARK;
|
||||
// Sleep screen cover mode settings
|
||||
@ -88,8 +85,8 @@ class CrossPointSettings {
|
||||
uint8_t screenMargin = 5;
|
||||
// OPDS browser settings
|
||||
char opdsServerUrl[128] = "";
|
||||
// Hide battery percentage
|
||||
uint8_t hideBatteryPercentage = HIDE_NEVER;
|
||||
// Last used sleep screen index (for custom screens)
|
||||
uint8_t lastUsedSleep = 0;
|
||||
|
||||
~CrossPointSettings() = default;
|
||||
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
#include <Serialization.h>
|
||||
|
||||
namespace {
|
||||
constexpr uint8_t STATE_FILE_VERSION = 2;
|
||||
constexpr uint8_t STATE_FILE_VERSION = 1;
|
||||
constexpr char STATE_FILE[] = "/.crosspoint/state.bin";
|
||||
} // namespace
|
||||
|
||||
@ -19,7 +19,6 @@ bool CrossPointState::saveToFile() const {
|
||||
|
||||
serialization::writePod(outputFile, STATE_FILE_VERSION);
|
||||
serialization::writeString(outputFile, openEpubPath);
|
||||
serialization::writePod(outputFile, lastSleepImage);
|
||||
outputFile.close();
|
||||
return true;
|
||||
}
|
||||
@ -32,18 +31,13 @@ bool CrossPointState::loadFromFile() {
|
||||
|
||||
uint8_t version;
|
||||
serialization::readPod(inputFile, version);
|
||||
if (version > STATE_FILE_VERSION) {
|
||||
if (version != STATE_FILE_VERSION) {
|
||||
Serial.printf("[%lu] [CPS] Deserialization failed: Unknown version %u\n", millis(), version);
|
||||
inputFile.close();
|
||||
return false;
|
||||
}
|
||||
|
||||
serialization::readString(inputFile, openEpubPath);
|
||||
if (version >= 2) {
|
||||
serialization::readPod(inputFile, lastSleepImage);
|
||||
} else {
|
||||
lastSleepImage = 0;
|
||||
}
|
||||
|
||||
inputFile.close();
|
||||
return true;
|
||||
|
||||
@ -8,7 +8,6 @@ class CrossPointState {
|
||||
|
||||
public:
|
||||
std::string openEpubPath;
|
||||
uint8_t lastSleepImage;
|
||||
~CrossPointState() = default;
|
||||
|
||||
// Get singleton instance
|
||||
|
||||
@ -8,11 +8,10 @@
|
||||
#include "Battery.h"
|
||||
#include "fontIds.h"
|
||||
|
||||
void ScreenComponents::drawBattery(const GfxRenderer& renderer, const int left, const int top,
|
||||
const bool showPercentage) {
|
||||
void ScreenComponents::drawBattery(const GfxRenderer& renderer, const int left, const int top) {
|
||||
// Left aligned battery icon and percentage
|
||||
const uint16_t percentage = battery.readPercentage();
|
||||
const auto percentageText = showPercentage ? std::to_string(percentage) + "%" : "";
|
||||
const auto percentageText = std::to_string(percentage) + "%";
|
||||
renderer.drawText(SMALL_FONT_ID, left + 20, top, percentageText.c_str());
|
||||
|
||||
// 1 column on left, 2 columns on right, 5 columns of battery body
|
||||
|
||||
@ -7,7 +7,7 @@ class GfxRenderer;
|
||||
|
||||
class ScreenComponents {
|
||||
public:
|
||||
static void drawBattery(const GfxRenderer& renderer, int left, int top, bool showPercentage = true);
|
||||
static void drawBattery(const GfxRenderer& renderer, int left, int top);
|
||||
|
||||
/**
|
||||
* Draw a progress bar with percentage text.
|
||||
|
||||
@ -80,19 +80,19 @@ void SleepActivity::renderCustomSleepScreen() const {
|
||||
const auto numFiles = files.size();
|
||||
if (numFiles > 0) {
|
||||
// Generate a random number between 1 and numFiles
|
||||
auto randomFileIndex = random(numFiles);
|
||||
// If we picked the same image as last time, reroll
|
||||
while (numFiles > 1 && randomFileIndex == APP_STATE.lastSleepImage) {
|
||||
randomFileIndex = random(numFiles);
|
||||
}
|
||||
APP_STATE.lastSleepImage = randomFileIndex;
|
||||
APP_STATE.saveToFile();
|
||||
const auto filename = "/sleep/" + files[randomFileIndex];
|
||||
const auto randomFileIndex = random(numFiles);
|
||||
// If we re-generated the same index as the last sleep screen,
|
||||
// use the next one (modulo the number of files we have)
|
||||
const auto realFileIndex =
|
||||
randomFileIndex == SETTINGS.lastUsedSleep ? randomFileIndex + 1 % numFiles : randomFileIndex;
|
||||
SETTINGS.lastUsedSleep = realFileIndex;
|
||||
SETTINGS.saveToFile();
|
||||
const auto filename = "/sleep/" + files[realFileIndex];
|
||||
FsFile file;
|
||||
if (SdMan.openFileForRead("SLP", filename, file)) {
|
||||
Serial.printf("[%lu] [SLP] Randomly loading: /sleep/%s\n", millis(), files[randomFileIndex].c_str());
|
||||
delay(100);
|
||||
Bitmap bitmap(file, true);
|
||||
Bitmap bitmap(file);
|
||||
if (bitmap.parseHeaders() == BmpReaderError::Ok) {
|
||||
renderBitmapSleepScreen(bitmap);
|
||||
dir.close();
|
||||
@ -107,7 +107,7 @@ void SleepActivity::renderCustomSleepScreen() const {
|
||||
// render a custom sleep screen instead of the default.
|
||||
FsFile file;
|
||||
if (SdMan.openFileForRead("SLP", "/sleep.bmp", file)) {
|
||||
Bitmap bitmap(file, true);
|
||||
Bitmap bitmap(file);
|
||||
if (bitmap.parseHeaders() == BmpReaderError::Ok) {
|
||||
Serial.printf("[%lu] [SLP] Loading: /sleep.bmp\n", millis());
|
||||
renderBitmapSleepScreen(bitmap);
|
||||
@ -205,7 +205,6 @@ void SleepActivity::renderCoverSleepScreen() const {
|
||||
}
|
||||
|
||||
std::string coverBmpPath;
|
||||
bool cropped = SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP;
|
||||
|
||||
if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtc") ||
|
||||
StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtch")) {
|
||||
@ -230,12 +229,12 @@ void SleepActivity::renderCoverSleepScreen() const {
|
||||
return renderDefaultSleepScreen();
|
||||
}
|
||||
|
||||
if (!lastEpub.generateCoverBmp(cropped)) {
|
||||
if (!lastEpub.generateCoverBmp()) {
|
||||
Serial.println("[SLP] Failed to generate cover bmp");
|
||||
return renderDefaultSleepScreen();
|
||||
}
|
||||
|
||||
coverBmpPath = lastEpub.getCoverBmpPath(cropped);
|
||||
coverBmpPath = lastEpub.getCoverBmpPath();
|
||||
} else {
|
||||
return renderDefaultSleepScreen();
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
#include "CrossPointSettings.h"
|
||||
#include "MappedInputManager.h"
|
||||
#include "ScreenComponents.h"
|
||||
#include "activities/network/WifiSelectionActivity.h"
|
||||
#include "WifiCredentialStore.h"
|
||||
#include "fontIds.h"
|
||||
#include "network/HttpDownloader.h"
|
||||
#include "util/StringUtils.h"
|
||||
@ -25,7 +25,7 @@ void OpdsBookBrowserActivity::taskTrampoline(void* param) {
|
||||
}
|
||||
|
||||
void OpdsBookBrowserActivity::onEnter() {
|
||||
ActivityWithSubactivity::onEnter();
|
||||
Activity::onEnter();
|
||||
|
||||
renderingMutex = xSemaphoreCreateMutex();
|
||||
state = BrowserState::CHECK_WIFI;
|
||||
@ -49,7 +49,7 @@ void OpdsBookBrowserActivity::onEnter() {
|
||||
}
|
||||
|
||||
void OpdsBookBrowserActivity::onExit() {
|
||||
ActivityWithSubactivity::onExit();
|
||||
Activity::onExit();
|
||||
|
||||
// Turn off WiFi when exiting
|
||||
WiFi.mode(WIFI_OFF);
|
||||
@ -66,28 +66,13 @@ void OpdsBookBrowserActivity::onExit() {
|
||||
}
|
||||
|
||||
void OpdsBookBrowserActivity::loop() {
|
||||
// Handle WiFi selection subactivity
|
||||
if (state == BrowserState::WIFI_SELECTION) {
|
||||
ActivityWithSubactivity::loop();
|
||||
return;
|
||||
}
|
||||
|
||||
// Handle error state - Confirm retries, Back goes back or home
|
||||
if (state == BrowserState::ERROR) {
|
||||
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
|
||||
// Check if WiFi is still connected
|
||||
if (WiFi.status() == WL_CONNECTED && WiFi.localIP() != IPAddress(0, 0, 0, 0)) {
|
||||
// WiFi connected - just retry fetching the feed
|
||||
Serial.printf("[%lu] [OPDS] Retry: WiFi connected, retrying fetch\n", millis());
|
||||
state = BrowserState::LOADING;
|
||||
statusMessage = "Loading...";
|
||||
updateRequired = true;
|
||||
fetchFeed(currentPath);
|
||||
} else {
|
||||
// WiFi not connected - launch WiFi selection
|
||||
Serial.printf("[%lu] [OPDS] Retry: WiFi not connected, launching selection\n", millis());
|
||||
launchWifiSelection();
|
||||
}
|
||||
state = BrowserState::LOADING;
|
||||
statusMessage = "Loading...";
|
||||
updateRequired = true;
|
||||
fetchFeed(currentPath);
|
||||
} else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
|
||||
navigateBack();
|
||||
}
|
||||
@ -365,8 +350,8 @@ void OpdsBookBrowserActivity::downloadBook(const OpdsEntry& book) {
|
||||
}
|
||||
|
||||
void OpdsBookBrowserActivity::checkAndConnectWifi() {
|
||||
// Already connected? Verify connection is valid by checking IP
|
||||
if (WiFi.status() == WL_CONNECTED && WiFi.localIP() != IPAddress(0, 0, 0, 0)) {
|
||||
// Already connected?
|
||||
if (WiFi.status() == WL_CONNECTED) {
|
||||
state = BrowserState::LOADING;
|
||||
statusMessage = "Loading...";
|
||||
updateRequired = true;
|
||||
@ -374,33 +359,38 @@ void OpdsBookBrowserActivity::checkAndConnectWifi() {
|
||||
return;
|
||||
}
|
||||
|
||||
// Not connected - launch WiFi selection screen directly
|
||||
launchWifiSelection();
|
||||
}
|
||||
|
||||
void OpdsBookBrowserActivity::launchWifiSelection() {
|
||||
state = BrowserState::WIFI_SELECTION;
|
||||
// Try to connect using saved credentials
|
||||
statusMessage = "Connecting to WiFi...";
|
||||
updateRequired = true;
|
||||
|
||||
enterNewActivity(new WifiSelectionActivity(renderer, mappedInput,
|
||||
[this](const bool connected) { onWifiSelectionComplete(connected); }));
|
||||
}
|
||||
WIFI_STORE.loadFromFile();
|
||||
const auto& credentials = WIFI_STORE.getCredentials();
|
||||
if (credentials.empty()) {
|
||||
state = BrowserState::ERROR;
|
||||
errorMessage = "No WiFi credentials saved";
|
||||
updateRequired = true;
|
||||
return;
|
||||
}
|
||||
|
||||
void OpdsBookBrowserActivity::onWifiSelectionComplete(const bool connected) {
|
||||
exitActivity();
|
||||
// Use the first saved credential
|
||||
const auto& cred = credentials[0];
|
||||
WiFi.mode(WIFI_STA);
|
||||
WiFi.begin(cred.ssid.c_str(), cred.password.c_str());
|
||||
|
||||
if (connected) {
|
||||
Serial.printf("[%lu] [OPDS] WiFi connected via selection, fetching feed\n", millis());
|
||||
// Wait for connection with timeout
|
||||
constexpr int WIFI_TIMEOUT_MS = 10000;
|
||||
const unsigned long startTime = millis();
|
||||
while (WiFi.status() != WL_CONNECTED && millis() - startTime < WIFI_TIMEOUT_MS) {
|
||||
vTaskDelay(100 / portTICK_PERIOD_MS);
|
||||
}
|
||||
|
||||
if (WiFi.status() == WL_CONNECTED) {
|
||||
Serial.printf("[%lu] [OPDS] WiFi connected: %s\n", millis(), WiFi.localIP().toString().c_str());
|
||||
state = BrowserState::LOADING;
|
||||
statusMessage = "Loading...";
|
||||
updateRequired = true;
|
||||
fetchFeed(currentPath);
|
||||
} else {
|
||||
Serial.printf("[%lu] [OPDS] WiFi selection cancelled/failed\n", millis());
|
||||
// Force disconnect to ensure clean state for next retry
|
||||
// This prevents stale connection status from interfering
|
||||
WiFi.disconnect();
|
||||
WiFi.mode(WIFI_OFF);
|
||||
state = BrowserState::ERROR;
|
||||
errorMessage = "WiFi connection failed";
|
||||
updateRequired = true;
|
||||
|
||||
@ -8,27 +8,25 @@
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../ActivityWithSubactivity.h"
|
||||
#include "../Activity.h"
|
||||
|
||||
/**
|
||||
* Activity for browsing and downloading books from an OPDS server.
|
||||
* Supports navigation through catalog hierarchy and downloading EPUBs.
|
||||
* When WiFi connection fails, launches WiFi selection to let user connect.
|
||||
*/
|
||||
class OpdsBookBrowserActivity final : public ActivityWithSubactivity {
|
||||
class OpdsBookBrowserActivity final : public Activity {
|
||||
public:
|
||||
enum class BrowserState {
|
||||
CHECK_WIFI, // Checking WiFi connection
|
||||
WIFI_SELECTION, // WiFi selection subactivity is active
|
||||
LOADING, // Fetching OPDS feed
|
||||
BROWSING, // Displaying entries (navigation or books)
|
||||
DOWNLOADING, // Downloading selected EPUB
|
||||
ERROR // Error state with message
|
||||
CHECK_WIFI, // Checking WiFi connection
|
||||
LOADING, // Fetching OPDS feed
|
||||
BROWSING, // Displaying entries (navigation or books)
|
||||
DOWNLOADING, // Downloading selected EPUB
|
||||
ERROR // Error state with message
|
||||
};
|
||||
|
||||
explicit OpdsBookBrowserActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
|
||||
const std::function<void()>& onGoHome)
|
||||
: ActivityWithSubactivity("OpdsBookBrowser", renderer, mappedInput), onGoHome(onGoHome) {}
|
||||
: Activity("OpdsBookBrowser", renderer, mappedInput), onGoHome(onGoHome) {}
|
||||
|
||||
void onEnter() override;
|
||||
void onExit() override;
|
||||
@ -56,8 +54,6 @@ class OpdsBookBrowserActivity final : public ActivityWithSubactivity {
|
||||
void render() const;
|
||||
|
||||
void checkAndConnectWifi();
|
||||
void launchWifiSelection();
|
||||
void onWifiSelectionComplete(bool connected);
|
||||
void fetchFeed(const std::string& path);
|
||||
void navigateToEntry(const OpdsEntry& entry);
|
||||
void navigateBack();
|
||||
|
||||
@ -7,7 +7,6 @@
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
|
||||
#include "Battery.h"
|
||||
#include "CrossPointSettings.h"
|
||||
#include "CrossPointState.h"
|
||||
#include "MappedInputManager.h"
|
||||
@ -69,7 +68,7 @@ void HomeActivity::onEnter() {
|
||||
updateRequired = true;
|
||||
|
||||
xTaskCreate(&HomeActivity::taskTrampoline, "HomeActivityTask",
|
||||
4096, // Stack size
|
||||
2048, // Stack size
|
||||
this, // Parameters
|
||||
1, // Priority
|
||||
&displayTaskHandle // Task handle
|
||||
@ -333,13 +332,8 @@ void HomeActivity::render() const {
|
||||
const auto labels = mappedInput.mapLabels("", "Confirm", "Up", "Down");
|
||||
renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
|
||||
|
||||
const bool showBatteryPercentage =
|
||||
SETTINGS.hideBatteryPercentage != CrossPointSettings::HIDE_BATTERY_PERCENTAGE::HIDE_ALWAYS;
|
||||
// get percentage so we can align text properly
|
||||
const uint16_t percentage = battery.readPercentage();
|
||||
const auto percentageText = showBatteryPercentage ? std::to_string(percentage) + "%" : "";
|
||||
const auto batteryX = pageWidth - 25 - renderer.getTextWidth(SMALL_FONT_ID, percentageText.c_str());
|
||||
ScreenComponents::drawBattery(renderer, batteryX, 10, showBatteryPercentage);
|
||||
const auto batteryX = pageWidth - 25 - renderer.getTextWidth(SMALL_FONT_ID, "100 %");
|
||||
ScreenComponents::drawBattery(renderer, batteryX, 10);
|
||||
|
||||
renderer.displayBuffer();
|
||||
}
|
||||
|
||||
@ -419,8 +419,6 @@ void EpubReaderActivity::renderStatusBar(const int orientedMarginRight, const in
|
||||
SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
|
||||
const bool showChapterTitle = SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::NO_PROGRESS ||
|
||||
SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
|
||||
const bool showBatteryPercentage =
|
||||
SETTINGS.hideBatteryPercentage == CrossPointSettings::HIDE_BATTERY_PERCENTAGE::HIDE_NEVER;
|
||||
|
||||
// Position status bar near the bottom of the logical screen, regardless of orientation
|
||||
const auto screenHeight = renderer.getScreenHeight();
|
||||
@ -441,7 +439,7 @@ void EpubReaderActivity::renderStatusBar(const int orientedMarginRight, const in
|
||||
}
|
||||
|
||||
if (showBattery) {
|
||||
ScreenComponents::drawBattery(renderer, orientedMarginLeft + 1, textY, showBatteryPercentage);
|
||||
ScreenComponents::drawBattery(renderer, orientedMarginLeft + 1, textY);
|
||||
}
|
||||
|
||||
if (showChapterTitle) {
|
||||
|
||||
@ -13,13 +13,12 @@
|
||||
|
||||
// Define the static settings list
|
||||
namespace {
|
||||
constexpr int settingsCount = 19;
|
||||
constexpr int settingsCount = 18;
|
||||
const SettingInfo settingsList[settingsCount] = {
|
||||
// Should match with SLEEP_SCREEN_MODE
|
||||
SettingInfo::Enum("Sleep Screen", &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover", "None"}),
|
||||
SettingInfo::Enum("Sleep Screen Cover Mode", &CrossPointSettings::sleepScreenCoverMode, {"Fit", "Crop"}),
|
||||
SettingInfo::Enum("Status Bar", &CrossPointSettings::statusBar, {"None", "No Progress", "Full"}),
|
||||
SettingInfo::Enum("Hide Battery %", &CrossPointSettings::hideBatteryPercentage, {"Never", "In Reader", "Always"}),
|
||||
SettingInfo::Toggle("Extra Paragraph Spacing", &CrossPointSettings::extraParagraphSpacing),
|
||||
SettingInfo::Toggle("Text Anti-Aliasing", &CrossPointSettings::textAntiAliasing),
|
||||
SettingInfo::Enum("Short Power Button Click", &CrossPointSettings::shortPwrBtn, {"Ignore", "Sleep", "Page Turn"}),
|
||||
|
||||
@ -303,7 +303,6 @@ void setup() {
|
||||
// Clear app state to avoid getting into a boot loop if the epub doesn't load
|
||||
const auto path = APP_STATE.openEpubPath;
|
||||
APP_STATE.openEpubPath = "";
|
||||
APP_STATE.lastSleepImage = 0;
|
||||
APP_STATE.saveToFile();
|
||||
onGoToReader(path);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user