mirror of
https://github.com/crosspoint-reader/crosspoint-reader.git
synced 2026-04-29 10:26:52 -07:00
Justin MitchellandGitHub
fedcb2f53d
Opening XTC files with a high page count (e.g. *The Magic Mountain* at 4,187 pages) causes an immediate `abort()` crash and reboot loop. The device becomes unusable until the book is removed from the SD card. **Crash log:** ``` abort() was called at 0x4214a5fb on core 0 ``` ### Root cause During `XtcParser::open()`, the parser calls `m_pageTable.resize(pageCount)` to load the entire page table into RAM. Each `PageInfo` entry is 16 bytes, so: - 4,187 pages x 16 bytes = **66,992 bytes (~65KB)** as a single contiguous heap allocation On the ESP32-C3 with ~380KB total RAM (no PSRAM), this allocation fails after firmware, fonts, and the activity system are already loaded. Because the firmware is compiled with `-fno-exceptions`, the failed `new` inside `std::vector::resize()` calls `abort()` instead of throwing. This affects any XTC file with roughly 3,000+ pages, depending on heap state at the time of loading. ## Solution Replace the bulk page table allocation with on-demand reads from the SD card. Instead of loading all page table entries into a vector at file open, we now: 1. Read only the **first** page table entry at open time (to get default page dimensions) 2. Read a **single** 16-byte entry from the SD card each time a page is loaded This reduces page table memory usage from `pageCount * 16` bytes to **zero bytes**, regardless of how many pages the file contains. ### Changes | File | What changed | |------|-------------| | `XtcParser.h` | Removed `std::vector<PageInfo> m_pageTable`. Added `readPageTableEntry()` for on-demand reads. | | `XtcParser.cpp` | Replaced `readPageTable()` with `readFirstPageInfo()`. Updated `getPageInfo()`, `loadPage()`, and `loadPageStreaming()` to seek and read individual entries from the file. | ## Trade-offs ### Performance Each page turn now requires one additional SD card seek + 16-byte read to look up the page table entry before reading the page data itself. - SD card sequential read latency: ~0.1-0.5ms for a 16-byte read - E-ink full display refresh: ~1,000-2,000ms I personally can't see any performance difference while reading and the trade off of not boot looping seems to make this well worth it. ### Memory | Metric | Before | After | |--------|--------|-------| | Page table RAM (4,187 pages) | ~65KB | 0 bytes | | Page table RAM (1,000 pages) | ~16KB | 0 bytes | | Page table RAM (max 65,535 pages) | ~1MB (impossible) | 0 bytes |
106 lines
2.7 KiB
C++
106 lines
2.7 KiB
C++
/**
|
|
* Xtc.h
|
|
*
|
|
* Main XTC ebook class for CrossPoint Reader
|
|
* Provides EPUB-like interface for XTC file handling
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "Xtc/XtcParser.h"
|
|
#include "Xtc/XtcTypes.h"
|
|
|
|
/**
|
|
* XTC Ebook Handler
|
|
*
|
|
* Handles XTC file loading, page access, and cover image generation.
|
|
* Interface is designed to be similar to Epub class for easy integration.
|
|
*/
|
|
class Xtc {
|
|
std::string filepath;
|
|
std::string cachePath;
|
|
std::unique_ptr<xtc::XtcParser> parser;
|
|
bool loaded;
|
|
|
|
public:
|
|
explicit Xtc(std::string filepath, const std::string& cacheDir) : filepath(std::move(filepath)), loaded(false) {
|
|
// Create cache key based on filepath (same as Epub)
|
|
cachePath = cacheDir + "/xtc_" + std::to_string(std::hash<std::string>{}(this->filepath));
|
|
}
|
|
~Xtc() = default;
|
|
|
|
/**
|
|
* Load XTC file
|
|
* @return true on success
|
|
*/
|
|
bool load();
|
|
|
|
/**
|
|
* Clear cached data
|
|
* @return true on success
|
|
*/
|
|
bool clearCache() const;
|
|
|
|
/**
|
|
* Setup cache directory
|
|
*/
|
|
void setupCacheDir() const;
|
|
|
|
// Path accessors
|
|
const std::string& getCachePath() const { return cachePath; }
|
|
const std::string& getPath() const { return filepath; }
|
|
|
|
// Metadata
|
|
std::string getTitle() const;
|
|
std::string getAuthor() const;
|
|
bool hasChapters() const;
|
|
const std::vector<xtc::ChapterInfo>& getChapters();
|
|
|
|
// Cover image support (for sleep screen)
|
|
std::string getCoverBmpPath() const;
|
|
bool generateCoverBmp() const;
|
|
// Thumbnail support (for Continue Reading card)
|
|
std::string getThumbBmpPath() const;
|
|
std::string getThumbBmpPath(int height) const;
|
|
bool generateThumbBmp(int height) const;
|
|
|
|
// Page access
|
|
uint32_t getPageCount() const;
|
|
uint16_t getPageWidth() const;
|
|
uint16_t getPageHeight() const;
|
|
uint8_t getBitDepth() const; // 1 = XTC (1-bit), 2 = XTCH (2-bit)
|
|
|
|
/**
|
|
* Load page bitmap data
|
|
* @param pageIndex Page index (0-based)
|
|
* @param buffer Output buffer
|
|
* @param bufferSize Buffer size
|
|
* @return Number of bytes read
|
|
*/
|
|
size_t loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize) const;
|
|
|
|
/**
|
|
* Load page with streaming callback
|
|
* @param pageIndex Page index
|
|
* @param callback Callback for each chunk
|
|
* @param chunkSize Chunk size
|
|
* @return Error code
|
|
*/
|
|
xtc::XtcError loadPageStreaming(uint32_t pageIndex,
|
|
std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
|
|
size_t chunkSize = 1024) const;
|
|
|
|
// Progress calculation
|
|
uint8_t calculateProgress(uint32_t currentPage) const;
|
|
|
|
// Check if file is loaded
|
|
bool isLoaded() const { return loaded; }
|
|
|
|
// Error information
|
|
xtc::XtcError getLastError() const;
|
|
};
|