snark13/Xteink-X4-crosspoint-reader
1
0
Fork 0
mirror of https://github.com/daveallie/crosspoint-reader.git synced 2026-02-04 14:47:37 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge b779378563 into 12c20bb09e

Browse Source
This commit is contained in:
icannotttt 2026-02-01 19:19:26 +11:00 committed by GitHub
commit 5078c490b1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 486 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitmodules vendored
View File

@ -1,3 +1,3 @@
[submodule "open-x4-sdk"]
path = open-x4-sdk
url = https://github.com/open-x4-epaper/community-sdk.git
url = git@github.com:open-x4-epaper/community-sdk.git

37
lib/Xtc/Xtc.h
View File

@ -73,6 +73,43 @@ class Xtc {
uint16_t getPageHeight() const;
uint8_t getBitDepth() const; // 1 = XTC (1-bit), 2 = XTCH (2-bit)
/**
* 动态加载下一批页码
*/
xtc::XtcError loadNextPageBatch() const {
return parser ? parser->loadNextPageBatch() : xtc::XtcError::FILE_NOT_FOUND;
}
xtc::XtcError loadPageBatchByStart(uint16_t startPage) const {
return parser ? parser->loadPageBatchByStart(startPage): xtc::XtcError::FILE_NOT_FOUND;
}
/**
* 获取当前已加载的最大页码
*/
uint16_t getLoadedMaxPage() const {
return parser ? parser->getLoadedMaxPage() : 0;
}
/**
* 获取每次加载的批次页数
*/
uint16_t getPageBatchSize() const {
return parser ? parser->getPageBatchSize() : 10;
}
xtc::XtcError readChapters_gd(uint16_t chapterStart) const {
return parser ? parser->readChapters_gd(chapterStart) : xtc::XtcError::FILE_NOT_FOUND;
}
uint32_t getChapterstartpage(int chapterIndex) {
return parser ? parser->getChapterstartpage(chapterIndex) : 0;
}
std::string getChapterTitleByIndex(int chapterIndex) {
return parser ? parser->getChapterTitleByIndex(chapterIndex) : "";
}
/**
* Load page bitmap data
* @param pageIndex Page index (0-based)

417
lib/Xtc/Xtc/XtcParser.cpp
View File

@ -21,7 +21,10 @@ XtcParser::XtcParser()
m_defaultHeight(DISPLAY_HEIGHT),
m_bitDepth(1),
m_hasChapters(false),
m_lastError(XtcError::OK) {
m_lastError(XtcError::OK),
m_loadBatchSize(500), // 500 for one load
m_loadedMaxPage(0),
m_loadedStartPage(0) { // page_start
memset(&m_header, 0, sizeof(m_header));
}
@ -47,23 +50,10 @@ XtcError XtcParser::open(const char* filepath) {
return m_lastError;
}
// Read title & author if available
if (m_header.hasMetadata) {
m_lastError = readTitle();
if (m_lastError != XtcError::OK) {
Serial.printf("[%lu] [XTC] Failed to read title: %s\n", millis(), errorToString(m_lastError));
m_file.close();
return m_lastError;
}
m_lastError = readAuthor();
if (m_lastError != XtcError::OK) {
Serial.printf("[%lu] [XTC] Failed to read author: %s\n", millis(), errorToString(m_lastError));
m_file.close();
return m_lastError;
}
}
// Read title if available
readTitle();
// Read page table
// Read page table
m_lastError = readPageTable();
if (m_lastError != XtcError::OK) {
Serial.printf("[%lu] [XTC] Failed to read page table: %s\n", millis(), errorToString(m_lastError));
@ -71,7 +61,7 @@ XtcError XtcParser::open(const char* filepath) {
return m_lastError;
}
// Read chapters if present
// Read chapters if present (to make it work, just keep the old readchapters)
m_lastError = readChapters();
if (m_lastError != XtcError::OK) {
Serial.printf("[%lu] [XTC] Failed to read chapters: %s\n", millis(), errorToString(m_lastError));
@ -80,8 +70,8 @@ XtcError XtcParser::open(const char* filepath) {
}
m_isOpen = true;
Serial.printf("[%lu] [XTC] Opened file: %s (%u pages, %dx%d)\n", millis(), filepath, m_header.pageCount,
m_defaultWidth, m_defaultHeight);
Serial.printf("[%lu] [XTC] Opened file: %s (total pages=%u, loaded pages=[0~%u], %dx%d)\n", millis(), filepath,
m_header.pageCount, m_loadedMaxPage, m_defaultWidth, m_defaultHeight);
return XtcError::OK;
}
@ -94,29 +84,24 @@ void XtcParser::close() {
m_chapters.clear();
m_title.clear();
m_hasChapters = false;
m_loadedMaxPage = 0;
memset(&m_header, 0, sizeof(m_header));
}
XtcError XtcParser::readHeader() {
// Read first 56 bytes of header
size_t bytesRead = m_file.read(reinterpret_cast<uint8_t*>(&m_header), sizeof(XtcHeader));
if (bytesRead != sizeof(XtcHeader)) {
return XtcError::READ_ERROR;
}
// Verify magic number (accept both XTC and XTCH)
if (m_header.magic != XTC_MAGIC && m_header.magic != XTCH_MAGIC) {
Serial.printf("[%lu] [XTC] Invalid magic: 0x%08X (expected 0x%08X or 0x%08X)\n", millis(), m_header.magic,
XTC_MAGIC, XTCH_MAGIC);
return XtcError::INVALID_MAGIC;
}
// Determine bit depth from file magic
m_bitDepth = (m_header.magic == XTCH_MAGIC) ? 2 : 1;
// Check version
// Currently, version 1.0 is the only valid version, however some generators are swapping the bytes around, so we
// accept both 1.0 and 0.1 for compatibility
const bool validVersion = m_header.versionMajor == 1 && m_header.versionMinor == 0 ||
m_header.versionMajor == 0 && m_header.versionMinor == 1;
if (!validVersion) {
@ -124,12 +109,11 @@ XtcError XtcParser::readHeader() {
return XtcError::INVALID_VERSION;
}
// Basic validation
if (m_header.pageCount == 0) {
return XtcError::CORRUPTED_HEADER;
}
Serial.printf("[%lu] [XTC] Header: magic=0x%08X (%s), ver=%u.%u, pages=%u, bitDepth=%u\n", millis(), m_header.magic,
Serial.printf("[%lu] [XTC] Header: magic=0x%08X (%s), ver=%u.%u, total pages=%u, bitDepth=%u\n", millis(), m_header.magic,
(m_header.magic == XTCH_MAGIC) ? "XTCH" : "XTC", m_header.versionMajor, m_header.versionMinor,
m_header.pageCount, m_bitDepth);
@ -150,37 +134,29 @@ XtcError XtcParser::readTitle() {
return XtcError::OK;
}
XtcError XtcParser::readAuthor() {
// Read author as null-terminated UTF-8 string with max length 64, directly following title
constexpr auto authorOffset = 0xB8;
if (!m_file.seek(authorOffset)) {
return XtcError::READ_ERROR;
}
char authorBuf[64] = {0};
m_file.read(authorBuf, sizeof(authorBuf) - 1);
m_author = authorBuf;
Serial.printf("[%lu] [XTC] Author: %s\n", millis(), m_author.c_str());
return XtcError::OK;
}
//load the next pagetable (for XtcReadActivity.cpp)
XtcError XtcParser::readPageTable() {
m_pageTable.clear();
m_pageTable.shrink_to_fit();
if (m_header.pageTableOffset == 0) {
Serial.printf("[%lu] [XTC] Page table offset is 0, cannot read\n", millis());
return XtcError::CORRUPTED_HEADER;
}
// Seek to page table
if (!m_file.seek(m_header.pageTableOffset)) {
Serial.printf("[%lu] [XTC] Failed to seek to page table at %llu\n", millis(), m_header.pageTableOffset);
return XtcError::READ_ERROR;
}
m_pageTable.resize(m_header.pageCount);
// for the first
uint16_t startPage = 0;
uint16_t endPage = startPage + m_loadBatchSize - 1;
if(endPage >= m_header.pageCount) endPage = m_header.pageCount - 1;
uint16_t loadCount = endPage - startPage + 1;
// Read page table entries
for (uint16_t i = 0; i < m_header.pageCount; i++) {
m_pageTable.resize(endPage + 1);
for (uint16_t i = startPage; i <= endPage; i++) {
PageTableEntry entry;
size_t bytesRead = m_file.read(reinterpret_cast<uint8_t*>(&entry), sizeof(PageTableEntry));
if (bytesRead != sizeof(PageTableEntry)) {
@ -194,17 +170,18 @@ XtcError XtcParser::readPageTable() {
m_pageTable[i].height = entry.height;
m_pageTable[i].bitDepth = m_bitDepth;
// Update default dimensions from first page
if (i == 0) {
m_defaultWidth = entry.width;
m_defaultHeight = entry.height;
}
}
Serial.printf("[%lu] [XTC] Read %u page table entries\n", millis(), m_header.pageCount);
m_loadedMaxPage = endPage;
Serial.printf("[%lu] [XTC] 初始化加载页表: 成功加载 [0~%u] 共%u页\n", millis(), m_loadedMaxPage, loadCount);
return XtcError::OK;
}
XtcError XtcParser::readChapters() {
m_hasChapters = false;
m_chapters.clear();
@ -217,129 +194,97 @@ XtcError XtcParser::readChapters() {
return XtcError::READ_ERROR;
}
if (hasChaptersFlag != 1) {
return XtcError::OK;
}
if (hasChaptersFlag != 1) {}
uint64_t chapterOffset = 0;
if (!m_file.seek(0x30)) {
return XtcError::READ_ERROR;
}
if (m_file.read(reinterpret_cast<uint8_t*>(&chapterOffset), sizeof(chapterOffset)) != sizeof(chapterOffset)) {
return XtcError::READ_ERROR;
}
if (chapterOffset == 0) {
return XtcError::OK;
}
if (!m_file.seek(0x30)) {return XtcError::READ_ERROR;}
if (m_file.read(reinterpret_cast<uint8_t*>(&chapterOffset), sizeof(chapterOffset)) != sizeof(chapterOffset)) {return XtcError::READ_ERROR;}
if (chapterOffset == 0) {}
const uint64_t fileSize = m_file.size();
if (chapterOffset < sizeof(XtcHeader) || chapterOffset >= fileSize || chapterOffset + 96 > fileSize) {
return XtcError::OK;
}
if (chapterOffset < sizeof(XtcHeader) || chapterOffset >= fileSize || chapterOffset + 96 > fileSize) {}
uint64_t maxOffset = 0;
if (m_header.pageTableOffset > chapterOffset) {
maxOffset = m_header.pageTableOffset;
} else if (m_header.dataOffset > chapterOffset) {
maxOffset = m_header.dataOffset;
} else {
maxOffset = fileSize;
}
if (maxOffset <= chapterOffset) {
return XtcError::OK;
}
if (m_header.pageTableOffset > chapterOffset) {maxOffset = m_header.pageTableOffset;}
else if (m_header.dataOffset > chapterOffset) {maxOffset = m_header.dataOffset;}
else {maxOffset = fileSize;}
if (maxOffset <= chapterOffset) {}
constexpr size_t chapterSize = 96;
const uint64_t available = maxOffset - chapterOffset;
const size_t chapterCount = static_cast<size_t>(available / chapterSize);
if (chapterCount == 0) {
return XtcError::OK;
}
if (!m_file.seek(chapterOffset)) {
return XtcError::READ_ERROR;
}
if (chapterCount == 0) {}
if (!m_file.seek(chapterOffset)) {return XtcError::READ_ERROR;}
std::vector<uint8_t> chapterBuf(chapterSize);
for (size_t i = 0; i < chapterCount; i++) {
if (m_file.read(chapterBuf.data(), chapterSize) != chapterSize) {
return XtcError::READ_ERROR;
}
char nameBuf[81];
memcpy(nameBuf, chapterBuf.data(), 80);
nameBuf[80] = '\0';
const size_t nameLen = strnlen(nameBuf, 80);
std::string name(nameBuf, nameLen);
uint16_t startPage = 0;
uint16_t endPage = 0;
memcpy(&startPage, chapterBuf.data() + 0x50, sizeof(startPage));
memcpy(&endPage, chapterBuf.data() + 0x52, sizeof(endPage));
if (name.empty() && startPage == 0 && endPage == 0) {
break;
}
if (startPage > 0) {
startPage--;
}
if (endPage > 0) {
endPage--;
}
if (startPage >= m_header.pageCount) {
continue;
}
if (endPage >= m_header.pageCount) {
endPage = m_header.pageCount - 1;
}
if (startPage > endPage) {
continue;
}
ChapterInfo chapter{std::move(name), startPage, endPage};
m_chapters.push_back(std::move(chapter));
if (m_file.read(chapterBuf.data(), chapterSize) != chapterSize) {return XtcError::READ_ERROR;}
}
std::string chapterName = m_title.empty() ? "全书" : m_title;
ChapterInfo singleChapter{std::move(chapterName), 0, m_header.pageCount - 1};
m_chapters.push_back(std::move(singleChapter));
m_hasChapters = !m_chapters.empty();
Serial.printf("[%lu] [XTC] Chapters: %u\n", millis(), static_cast<unsigned int>(m_chapters.size()));
Serial.printf("[%lu] [XTC] 解析章节 #01 : 名称=[%s] | 包含全书共%u页\n", millis(), singleChapter.name.c_str(), m_header.pageCount);
Serial.printf("[%lu] [XTC] 解析完成 ✔️ 共加载有效章节数: %u\n", millis(), static_cast<unsigned int>(m_chapters.size()));
return XtcError::OK;
}
bool XtcParser::getPageInfo(uint32_t pageIndex, PageInfo& info) const {
if (pageIndex >= m_pageTable.size()) {
return false;
// for the next pagetable
XtcError XtcParser::loadNextPageBatch() {
if(!m_isOpen) return XtcError::FILE_NOT_FOUND;
if(m_loadedMaxPage >= m_header.pageCount - 1) {
Serial.printf("[XTC] 已加载全部%u页\n", m_header.pageCount);
return XtcError::PAGE_OUT_OF_RANGE;
}
info = m_pageTable[pageIndex];
return loadPageBatchByStart(m_loadedMaxPage + 1);
}
uint16_t XtcParser::getLoadedMaxPage() const {
return m_loadedMaxPage;
}
uint16_t XtcParser::getPageBatchSize() const {
return m_loadBatchSize;
}
bool XtcParser::getPageInfo(uint32_t pageIndex, PageInfo& info) const {
if (pageIndex >= m_header.pageCount) return false;
uint16_t targetStart = (pageIndex / m_loadBatchSize) * m_loadBatchSize;
if (pageIndex < m_loadedStartPage || pageIndex > m_loadedMaxPage) {
auto* self = const_cast<XtcParser*>(this);
self->loadPageBatchByStart(targetStart);
}
uint16_t idx = pageIndex - m_loadedStartPage;
if(idx >= m_pageTable.size()) return false;
info = m_pageTable[idx];
return true;
}
//change:to get page
size_t XtcParser::loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize) {
if (!m_isOpen) {
m_lastError = XtcError::FILE_NOT_FOUND;
if (!m_isOpen || pageIndex >= m_header.pageCount) {
m_lastError = (pageIndex >= m_header.pageCount) ? XtcError::PAGE_OUT_OF_RANGE : XtcError::FILE_NOT_FOUND;
return 0;
}
if (pageIndex >= m_header.pageCount) {
m_lastError = XtcError::PAGE_OUT_OF_RANGE;
return 0;
if (pageIndex < m_loadedStartPage || pageIndex > m_loadedMaxPage) {
loadNextPageBatch();
}
const PageInfo& page = m_pageTable[pageIndex];
// Seek to page data
uint16_t idx = pageIndex - m_loadedStartPage;
const PageInfo& page = m_pageTable[idx];
if (!m_file.seek(page.offset)) {
Serial.printf("[%lu] [XTC] Failed to seek to page %u at offset %lu\n", millis(), pageIndex, page.offset);
m_lastError = XtcError::READ_ERROR;
return 0;
}
// Read page header (XTG for 1-bit, XTH for 2-bit - same structure)
XtgPageHeader pageHeader;
size_t headerRead = m_file.read(reinterpret_cast<uint8_t*>(&pageHeader), sizeof(XtgPageHeader));
if (headerRead != sizeof(XtgPageHeader)) {
@ -348,7 +293,6 @@ size_t XtcParser::loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSiz
return 0;
}
// Verify page magic (XTG for 1-bit, XTH for 2-bit)
const uint32_t expectedMagic = (m_bitDepth == 2) ? XTH_MAGIC : XTG_MAGIC;
if (pageHeader.magic != expectedMagic) {
Serial.printf("[%lu] [XTC] Invalid page magic for page %u: 0x%08X (expected 0x%08X)\n", millis(), pageIndex,
@ -357,25 +301,19 @@ size_t XtcParser::loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSiz
return 0;
}
// Calculate bitmap size based on bit depth
// XTG (1-bit): Row-major, ((width+7)/8) * height bytes
// XTH (2-bit): Two bit planes, column-major, ((width * height + 7) / 8) * 2 bytes
size_t bitmapSize;
if (m_bitDepth == 2) {
// XTH: two bit planes, each containing (width * height) bits rounded up to bytes
bitmapSize = ((static_cast<size_t>(pageHeader.width) * pageHeader.height + 7) / 8) * 2;
} else {
bitmapSize = ((pageHeader.width + 7) / 8) * pageHeader.height;
}
// Check buffer size
if (bufferSize < bitmapSize) {
Serial.printf("[%lu] [XTC] Buffer too small: need %u, have %u\n", millis(), bitmapSize, bufferSize);
m_lastError = XtcError::MEMORY_ERROR;
return 0;
}
// Read bitmap data
size_t bytesRead = m_file.read(buffer, bitmapSize);
if (bytesRead != bitmapSize) {
Serial.printf("[%lu] [XTC] Page read error: expected %u, got %u\n", millis(), bitmapSize, bytesRead);
@ -390,32 +328,18 @@ size_t XtcParser::loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSiz
XtcError XtcParser::loadPageStreaming(uint32_t pageIndex,
std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
size_t chunkSize) {
if (!m_isOpen) {
return XtcError::FILE_NOT_FOUND;
}
if (pageIndex >= m_header.pageCount) {
return XtcError::PAGE_OUT_OF_RANGE;
if (!m_isOpen || pageIndex > m_loadedMaxPage || pageIndex >= m_header.pageCount) {
return (pageIndex >= m_header.pageCount) ? XtcError::PAGE_OUT_OF_RANGE : XtcError::FILE_NOT_FOUND;
}
const PageInfo& page = m_pageTable[pageIndex];
if (!m_file.seek(page.offset)) {return XtcError::READ_ERROR;}
// Seek to page data
if (!m_file.seek(page.offset)) {
return XtcError::READ_ERROR;
}
// Read and skip page header (XTG for 1-bit, XTH for 2-bit)
XtgPageHeader pageHeader;
size_t headerRead = m_file.read(reinterpret_cast<uint8_t*>(&pageHeader), sizeof(XtgPageHeader));
const uint32_t expectedMagic = (m_bitDepth == 2) ? XTH_MAGIC : XTG_MAGIC;
if (headerRead != sizeof(XtgPageHeader) || pageHeader.magic != expectedMagic) {
return XtcError::READ_ERROR;
}
if (headerRead != sizeof(XtgPageHeader) || pageHeader.magic != expectedMagic) {return XtcError::READ_ERROR;}
// Calculate bitmap size based on bit depth
// XTG (1-bit): Row-major, ((width+7)/8) * height bytes
// XTH (2-bit): Two bit planes, ((width * height + 7) / 8) * 2 bytes
size_t bitmapSize;
if (m_bitDepth == 2) {
bitmapSize = ((static_cast<size_t>(pageHeader.width) * pageHeader.height + 7) / 8) * 2;
@ -423,40 +347,177 @@ XtcError XtcParser::loadPageStreaming(uint32_t pageIndex,
bitmapSize = ((pageHeader.width + 7) / 8) * pageHeader.height;
}
// Read in chunks
std::vector<uint8_t> chunk(chunkSize);
size_t totalRead = 0;
while (totalRead < bitmapSize) {
size_t toRead = std::min(chunkSize, bitmapSize - totalRead);
size_t bytesRead = m_file.read(chunk.data(), toRead);
if (bytesRead == 0) {
return XtcError::READ_ERROR;
}
if (bytesRead == 0) return XtcError::READ_ERROR;
callback(chunk.data(), bytesRead, totalRead);
totalRead += bytesRead;
}
return XtcError::OK;
}
bool XtcParser::isValidXtcFile(const char* filepath) {
FsFile file;
if (!SdMan.openFileForRead("XTC", filepath, file)) {
return false;
}
if (!SdMan.openFileForRead("XTC", filepath, file)) return false;
uint32_t magic = 0;
size_t bytesRead = file.read(reinterpret_cast<uint8_t*>(&magic), sizeof(magic));
file.close();
return (bytesRead == sizeof(magic)) && (magic == XTC_MAGIC || magic == XTCH_MAGIC);
}
//charge to get chapters separately
XtcError XtcParser::readChapters_gd(uint16_t chapterStart) {
chapterActualCount = 0;
memset(ChapterList, 0, sizeof(ChapterList));
Serial.printf("[Memory] memset memory \n");
uint8_t hasChaptersFlag = 0;
if (!m_file.seek(0x0B)) {
return XtcError::READ_ERROR;
}
if (m_file.read(&hasChaptersFlag, sizeof(hasChaptersFlag)) != sizeof(hasChaptersFlag)) {
return XtcError::READ_ERROR;
}
if (hasChaptersFlag != 1) {
return XtcError::OK;
}
// Serial.printf("[%lu] [XTC] 位置1");//for debug
uint64_t chapterOffset = 0;
if (!m_file.seek(0x30)) {
return XtcError::READ_ERROR;
}
if (m_file.read(reinterpret_cast<uint8_t*>(&chapterOffset), sizeof(chapterOffset)) != sizeof(chapterOffset)) {
return XtcError::READ_ERROR;
}
if (chapterOffset == 0) {
return XtcError::OK;
}
// Serial.printf("[%lu] [XTC] 位置2");//for debug
const uint64_t fileSize = m_file.size();
if (chapterOffset < sizeof(XtcHeader) || chapterOffset >= fileSize || chapterOffset + 96 > fileSize) {
return XtcError::OK;
}
uint64_t maxOffset = 0;
if (m_header.pageTableOffset > chapterOffset) {
maxOffset = m_header.pageTableOffset;
} else if (m_header.dataOffset > chapterOffset) {
maxOffset = m_header.dataOffset;
} else {
maxOffset = fileSize;
}
if (maxOffset <= chapterOffset) {
return XtcError::OK;
}
constexpr size_t chapterSize = 96;
const uint64_t available = maxOffset - chapterOffset;
const size_t chapterCount = static_cast<size_t>(available / chapterSize);
if (chapterCount == 0) {
return XtcError::OK;
}
// Serial.printf("[%lu] [XTC] 位置3"); //for debug
// find the start offset
uint64_t startReadOffset = chapterOffset + (chapterStart * chapterSize);
if (!m_file.seek(startReadOffset)) {
return XtcError::READ_ERROR;
}
Serial.printf("[%lu] [XTC] 位置4");
std::vector<uint8_t> chapterBuf(chapterSize);
int readCount = 0;
size_t currentChapterIdx = chapterStart;
// 25 chapters once
Serial.printf("[%lu] [XTC] readCount:%d,currentChapterIdx:%d, chapterCount %u\n", millis(), readCount, currentChapterIdx,chapterCount);
while (readCount < 25 && currentChapterIdx < chapterCount) {
if (m_file.read(chapterBuf.data(), chapterSize) != chapterSize) {
break;
}
//no changes
char nameBuf[81];
memcpy(nameBuf, chapterBuf.data(), 80);
nameBuf[80] = '\0';
const size_t nameLen = strnlen(nameBuf, 80);
std::string name(nameBuf, nameLen);
uint16_t startPage = 0;
uint16_t endPage = 0;
memcpy(&startPage, chapterBuf.data() + 0x50, sizeof(startPage));
memcpy(&endPage, chapterBuf.data() + 0x52, sizeof(endPage));
if (name.empty() && startPage == 0 && endPage == 0) {
currentChapterIdx++;
continue;
}
if (startPage > 0) {
startPage--;
}
if (endPage > 0) {
endPage--;
}
if (startPage >= m_header.pageCount || startPage > endPage) {
currentChapterIdx++;
continue;
}
if (endPage >= m_header.pageCount) {
endPage = m_header.pageCount - 1;
}
strncpy(ChapterList[readCount].shortTitle, name.c_str(), 63);
ChapterList[readCount].shortTitle[63] = '\0';
ChapterList[readCount].startPage = startPage;
ChapterList[readCount].chapterIndex = currentChapterIdx;
Serial.printf("[%lu] [XTC] 第%d章，名字为:%s %u\n", millis(), readCount, ChapterList[readCount].shortTitle);
readCount++; // getpages
currentChapterIdx++;
if (bytesRead != sizeof(magic)) {
return false;
}
return (magic == XTC_MAGIC || magic == XTCH_MAGIC);
m_hasChapters = readCount > 0;
Serial.printf("[%lu] [XTC] 翻页读取章节：起始=%d，有效数=%u\n", millis(), chapterStart, (unsigned int)readCount);
return XtcError::OK;
}
XtcError XtcParser::loadPageBatchByStart(uint16_t startPage) {
if(!m_isOpen) return XtcError::FILE_NOT_FOUND;
if(startPage >= m_header.pageCount) return XtcError::PAGE_OUT_OF_RANGE;
m_pageTable.clear();
m_pageTable.shrink_to_fit();
m_loadedStartPage = startPage;
uint16_t endPage = startPage + m_loadBatchSize - 1;
if(endPage >= m_header.pageCount) endPage = m_header.pageCount - 1;
uint16_t loadCount = endPage - startPage + 1;
// find the offset for new table
uint64_t seekOffset = m_header.pageTableOffset + (startPage * sizeof(PageTableEntry));
if(!m_file.seek(seekOffset)) return XtcError::READ_ERROR;
// load
m_pageTable.resize(loadCount);
for(uint16_t i = startPage; i <= endPage; i++) {
PageTableEntry entry;
if(m_file.read(reinterpret_cast<uint8_t*>(&entry), sizeof(PageTableEntry)) != sizeof(PageTableEntry)) {
return XtcError::READ_ERROR;
}
m_pageTable[i - startPage].offset = static_cast<uint32_t>(entry.dataOffset);
m_pageTable[i - startPage].size = entry.dataSize;
m_pageTable[i - startPage].width = entry.width;
m_pageTable[i - startPage].height = entry.height;
m_pageTable[i - startPage].bitDepth = m_bitDepth;
}
m_loadedMaxPage = endPage;
Serial.printf("[XTC] 强制加载批次 : 清空旧表 → 加载 [%u~%u] | 内存占用恒定\n", startPage, endPage);
return XtcError::OK;
}
} // namespace xtc

53
lib/Xtc/Xtc/XtcParser.h
View File

@ -29,6 +29,11 @@ class XtcParser {
XtcParser();
~XtcParser();
#define MAX_SAVE_CHAPTER 30
#define TITLE_KEEP_LENGTH 20
#define TITLE_BUF_SIZE 64
// File open/close
XtcError open(const char* filepath);
void close();
@ -54,6 +59,46 @@ class XtcParser {
*/
size_t loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize);
/**
* @brief
* @return XtcError Loading status: OK = success, PAGE_OUT_OF_RANGE = no more pages to load, others = loading failed.
*/
XtcError loadNextPageBatch();
/**
* @brief Get the maximum page number that has been loaded currently.
* @return uint16_t The maximum valid page number loaded currently.
*/
uint16_t getLoadedMaxPage() const;
/**
* @brief Get the number of pages loaded dynamically each time (batch size).
* @return uint16_t Page batch size, default is 10.
*/
uint16_t getPageBatchSize() const;
uint32_t getChapterstartpage(int chapterIndex) {
for(int i = 0; i < 25; i++) {
if(ChapterList[i].chapterIndex == chapterIndex) {
return ChapterList[i].startPage;
}
}
return 0; // Return 0 if the chapter does not exist.
}
std::string getChapterTitleByIndex(int chapterIndex) {
Serial.printf("[%lu] [XTC] Entered getChapterTitleByIndex，chapterActualCount=%d\n", millis(),chapterActualCount);
for(int i = 0; i < 25; i++) {
if(ChapterList[i].chapterIndex == chapterIndex) {
return std::string(ChapterList[i].shortTitle);
Serial.printf("[%lu] [XTC] In getChapterTitleByIndex, the title of chapter %d is: %s %u\n", millis(), i, ChapterList[i].shortTitle);
}
}
return ""; // Return empty string if the chapter does not exist.
}
/**
* Streaming page load
* Memory-efficient method that reads page data in chunks.
@ -74,6 +119,11 @@ class XtcParser {
bool hasChapters() const { return m_hasChapters; }
const std::vector<ChapterInfo>& getChapters() const { return m_chapters; }
XtcError readChapters_gd(uint16_t chapterStart);
ChapterData ChapterList[MAX_SAVE_CHAPTER];
int chapterActualCount = 0;
XtcError loadPageBatchByStart(uint16_t startPage);
// Validation
static bool isValidXtcFile(const char* filepath);
@ -93,6 +143,7 @@ class XtcParser {
uint8_t m_bitDepth; // 1 = XTC/XTG (1-bit), 2 = XTCH/XTH (2-bit)
bool m_hasChapters;
XtcError m_lastError;
uint16_t m_loadedStartPage = 0;
// Internal helper functions
XtcError readHeader();
@ -100,6 +151,8 @@ class XtcParser {
XtcError readTitle();
XtcError readAuthor();
XtcError readChapters();
uint16_t m_loadBatchSize = 10; // pages for once load
uint16_t m_loadedMaxPage = 0; // Record the maximum page currently loaded
};
} // namespace xtc

6
lib/Xtc/Xtc/XtcTypes.h
View File

@ -101,6 +101,12 @@ struct ChapterInfo {
uint16_t startPage;
uint16_t endPage;
};
//new struct
struct ChapterData {
int chapterIndex;
uint16_t startPage;
char shortTitle[64];
};
// Error codes
enum class XtcError {

2
open-x4-sdk

@ -1 +1 @@
Subproject commit bd4e6707503ab9c97d13ee0d8f8c69e9ff03cd12
Subproject commit c39f253a7dabbc193a8d7d310fb8777dca0ab8f1

176
src/activities/reader/XtcReaderActivity.cpp
View File

@ -21,6 +21,7 @@
namespace {
constexpr unsigned long skipPageMs = 700;
constexpr unsigned long goHomeMs = 1000;
constexpr int loadedMaxPage_per= 500;
} // namespace
void XtcReaderActivity::taskTrampoline(void* param) {
@ -92,6 +93,7 @@ void XtcReaderActivity::loop() {
},
[this](const uint32_t newPage) {
currentPage = newPage;
this->gotoPage(newPage);
exitActivity();
updateRequired = true;
}));
@ -200,48 +202,30 @@ void XtcReaderActivity::renderPage() {
pageBufferSize = ((pageWidth + 7) / 8) * pageHeight;
}
// Allocate page buffer
uint8_t* pageBuffer = static_cast<uint8_t*>(malloc(pageBufferSize));
if (!pageBuffer) {
Serial.printf("[%lu] [XTR] Failed to allocate page buffer (%lu bytes)\n", millis(), pageBufferSize);
renderer.clearScreen();
renderer.drawCenteredText(UI_12_FONT_ID, 300, "Memory error", true, EpdFontFamily::BOLD);
renderer.displayBuffer();
return;
}
// This part defines global variables to reduce memory usage, but the effect seems to be mediocre.
uint8_t* pageBuffer = s_pageBuffer;
// Load page data
// load new page
size_t bytesRead = xtc->loadPage(currentPage, pageBuffer, pageBufferSize);
if (bytesRead == 0) {
Serial.printf("[%lu] [XTR] Failed to load page %lu\n", millis(), currentPage);
free(pageBuffer);
Serial.printf("[%lu] [提示] 页码%lu加载中...\n", millis(), currentPage);
renderer.clearScreen();
renderer.drawCenteredText(UI_12_FONT_ID, 300, "Page load error", true, EpdFontFamily::BOLD);
renderer.drawCenteredText(UI_12_FONT_ID, 300, "Loading...", true, EpdFontFamily::BOLD);
renderer.displayBuffer();
updateRequired = true; // for some bugs
return;
}
// Clear screen first
// keep
renderer.clearScreen();
// Copy page bitmap using GfxRenderer's drawPixel
// XTC/XTCH pages are pre-rendered with status bar included, so render full page
const uint16_t maxSrcY = pageHeight;
if (bitDepth == 2) {
// XTH 2-bit mode: Two bit planes, column-major order
// - Columns scanned right to left (x = width-1 down to 0)
// - 8 vertical pixels per byte (MSB = topmost pixel in group)
// - First plane: Bit1, Second plane: Bit2
// - Pixel value = (bit1 << 1) | bit2
// - Grayscale: 0=White, 1=Dark Grey, 2=Light Grey, 3=Black
const size_t planeSize = (static_cast<size_t>(pageWidth) * pageHeight + 7) / 8;
const uint8_t* plane1 = pageBuffer; // Bit1 plane
const uint8_t* plane2 = pageBuffer + planeSize; // Bit2 plane
const size_t colBytes = (pageHeight + 7) / 8; // Bytes per column (100 for 800 height)
const uint8_t* plane1 = pageBuffer;
const uint8_t* plane2 = pageBuffer + planeSize;
const size_t colBytes = (pageHeight + 7) / 8;
// Lambda to get pixel value at (x, y)
auto getPixelValue = [&](uint16_t x, uint16_t y) -> uint8_t {
const size_t colIndex = pageWidth - 1 - x;
const size_t byteInCol = y / 8;
@ -252,20 +236,6 @@ void XtcReaderActivity::renderPage() {
return (bit1 << 1) | bit2;
};
// Optimized grayscale rendering without storeBwBuffer (saves 48KB peak memory)
// Flow: BW display → LSB/MSB passes → grayscale display → re-render BW for next frame
// Count pixel distribution for debugging
uint32_t pixelCounts[4] = {0, 0, 0, 0};
for (uint16_t y = 0; y < pageHeight; y++) {
for (uint16_t x = 0; x < pageWidth; x++) {
pixelCounts[getPixelValue(x, y)]++;
}
}
Serial.printf("[%lu] [XTR] Pixel distribution: White=%lu, DarkGrey=%lu, LightGrey=%lu, Black=%lu\n", millis(),
pixelCounts[0], pixelCounts[1], pixelCounts[2], pixelCounts[3]);
// Pass 1: BW buffer - draw all non-white pixels as black
for (uint16_t y = 0; y < pageHeight; y++) {
for (uint16_t x = 0; x < pageWidth; x++) {
if (getPixelValue(x, y) >= 1) {
@ -274,7 +244,6 @@ void XtcReaderActivity::renderPage() {
}
}
// Display BW with conditional refresh based on pagesUntilFullRefresh
if (pagesUntilFullRefresh <= 1) {
renderer.displayBuffer(HalDisplay::HALF_REFRESH);
pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
@ -283,35 +252,28 @@ void XtcReaderActivity::renderPage() {
pagesUntilFullRefresh--;
}
// Pass 2: LSB buffer - mark DARK gray only (XTH value 1)
// In LUT: 0 bit = apply gray effect, 1 bit = untouched
renderer.clearScreen(0x00);
for (uint16_t y = 0; y < pageHeight; y++) {
for (uint16_t x = 0; x < pageWidth; x++) {
if (getPixelValue(x, y) == 1) { // Dark grey only
if (getPixelValue(x, y) == 1) {
renderer.drawPixel(x, y, false);
}
}
}
renderer.copyGrayscaleLsbBuffers();
// Pass 3: MSB buffer - mark LIGHT AND DARK gray (XTH value 1 or 2)
// In LUT: 0 bit = apply gray effect, 1 bit = untouched
renderer.clearScreen(0x00);
for (uint16_t y = 0; y < pageHeight; y++) {
for (uint16_t x = 0; x < pageWidth; x++) {
const uint8_t pv = getPixelValue(x, y);
if (pv == 1 || pv == 2) { // Dark grey or Light grey
if (pv == 1 || pv == 2) {
renderer.drawPixel(x, y, false);
}
}
}
renderer.copyGrayscaleMsbBuffers();
// Display grayscale overlay
renderer.displayGrayBuffer();
// Pass 4: Re-render BW to framebuffer (restore for next frame, instead of restoreBwBuffer)
renderer.clearScreen();
for (uint16_t y = 0; y < pageHeight; y++) {
for (uint16_t x = 0; x < pageWidth; x++) {
@ -320,79 +282,109 @@ void XtcReaderActivity::renderPage() {
}
}
}
// Cleanup grayscale buffers with current frame buffer
renderer.cleanupGrayscaleWithFrameBuffer();
free(pageBuffer);
Serial.printf("[%lu] [XTR] Rendered page %lu/%lu (2-bit grayscale)\n", millis(), currentPage + 1,
xtc->getPageCount());
return;
} else {
// 1-bit mode: 8 pixels per byte, MSB first
const size_t srcRowBytes = (pageWidth + 7) / 8; // 60 bytes for 480 width
const size_t srcRowBytes = (pageWidth + 7) / 8;
for (uint16_t srcY = 0; srcY < maxSrcY; srcY++) {
const size_t srcRowStart = srcY * srcRowBytes;
for (uint16_t srcX = 0; srcX < pageWidth; srcX++) {
// Read source pixel (MSB first, bit 7 = leftmost pixel)
const size_t srcByte = srcRowStart + srcX / 8;
const size_t srcBit = 7 - (srcX % 8);
const bool isBlack = !((pageBuffer[srcByte] >> srcBit) & 1); // XTC: 0 = black, 1 = white
const bool isBlack = !((pageBuffer[srcByte] >> srcBit) & 1);
if (isBlack) {
renderer.drawPixel(srcX, srcY, true);
}
}
}
}
// White pixels are already cleared by clearScreen()
free(pageBuffer);
// XTC pages already have status bar pre-rendered, no need to add our own
// Display with appropriate refresh
if (pagesUntilFullRefresh <= 1) {
renderer.displayBuffer(HalDisplay::HALF_REFRESH);
pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
} else {
renderer.displayBuffer();
pagesUntilFullRefresh--;
if (pagesUntilFullRefresh <= 1) {
renderer.displayBuffer(HalDisplay::HALF_REFRESH);
pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
} else {
renderer.displayBuffer();
pagesUntilFullRefresh--;
}
}
Serial.printf("[%lu] [XTR] Rendered page %lu/%lu (%u-bit)\n", millis(), currentPage + 1, xtc->getPageCount(),
bitDepth);
Serial.printf("[%lu] [成功] 显示页码: %lu/%lu\n", millis(), currentPage+1, xtc->getPageCount());
}
void XtcReaderActivity::gotoPage(uint32_t targetPage) {
const uint32_t totalPages = xtc->getPageCount();
if (targetPage >= totalPages) targetPage = totalPages - 1;
if (targetPage < 0) targetPage = 0;
uint32_t targetBatchStart = (targetPage / loadedMaxPage_per) * loadedMaxPage_per;
xtc->loadPageBatchByStart(targetBatchStart);
m_loadedMax = targetBatchStart + loadedMaxPage_per - 1; // Activity的最大值
if(m_loadedMax >= totalPages) m_loadedMax = totalPages - 1;
currentPage = targetPage;
updateRequired = true;
Serial.printf("[跳转] 目标页%lu → 加载批次[%lu~%lu] | 内存已释放\n", targetPage, targetBatchStart, m_loadedMax);
}
void XtcReaderActivity::saveProgress() const {
FsFile f;
if (SdMan.openFileForWrite("XTR", xtc->getCachePath() + "/progress.bin", f)) {
uint8_t data[4];
uint8_t data[8]; // for 2 data:currentPage and m_loadedMax
// currentPage
data[0] = currentPage & 0xFF;
data[1] = (currentPage >> 8) & 0xFF;
data[2] = (currentPage >> 16) & 0xFF;
data[3] = (currentPage >> 24) & 0xFF;
f.write(data, 4);
// m_loadedMax
data[4] = m_loadedMax & 0xFF;
data[5] = (m_loadedMax >> 8) & 0xFF;
data[6] = (m_loadedMax >> 16) & 0xFF;
data[7] = (m_loadedMax >> 24) & 0xFF;
f.write(data, 8);
f.close();
Serial.printf("[%lu] [进度] 保存成功 → 页码: %lu | 页表上限: %lu\n", millis(), currentPage, m_loadedMax);
}
}
//2data to load
void XtcReaderActivity::loadProgress() {
FsFile f;
if (SdMan.openFileForRead("XTR", xtc->getCachePath() + "/progress.bin", f)) {
uint8_t data[4];
if (f.read(data, 4) == 4) {
uint8_t data[8];
if (f.read(data, 8) == 8) {
currentPage = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
Serial.printf("[%lu] [XTR] Loaded progress: page %lu\n", millis(), currentPage);
uint32_t savedLoadedMax = data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24);
// Validate page number
if (currentPage >= xtc->getPageCount()) {
currentPage = 0;
}
Serial.printf("[%lu] [进度] 恢复成功 → 页码: %lu | 保存的页表上限: %lu\n", millis(), currentPage, savedLoadedMax);
const uint32_t totalPages = xtc->getPageCount();
if (currentPage >= totalPages) currentPage = totalPages - 1;
if (currentPage < 0) currentPage = 0;
// Determine whether loading is required and which batch of tables to load.
uint32_t targetBatchStart = (currentPage / loadedMaxPage_per) * loadedMaxPage_per;
xtc->loadPageBatchByStart(targetBatchStart);
m_loadedMax = targetBatchStart + loadedMaxPage_per - 1;
if(m_loadedMax >= totalPages) m_loadedMax = totalPages - 1;
Serial.printf("[进度] 恢复进度后加载批次 → 页码%lu → 批次[%lu~%lu]\n", currentPage, targetBatchStart, m_loadedMax);
}
f.close();
} else {
const uint32_t totalPages = xtc->getPageCount();
currentPage = 0;
m_loadedMax = loadedMaxPage_per - 1;
if(m_loadedMax >= totalPages) m_loadedMax = totalPages - 1;
Serial.printf("[%lu] [进度] 无进度文件 → 初始化页码: 0 | 页表上限: %lu\n", millis(), m_loadedMax);
}
}

8
src/activities/reader/XtcReaderActivity.h
View File

@ -13,6 +13,10 @@
#include <freertos/task.h>
#include "activities/ActivityWithSubactivity.h"
namespace {
constexpr size_t MAX_PAGE_BUFFER_SIZE = (480 * 800 + 7) / 8 * 2;
static uint8_t s_pageBuffer[MAX_PAGE_BUFFER_SIZE] = {0};
} // namespace
class XtcReaderActivity final : public ActivityWithSubactivity {
std::shared_ptr<Xtc> xtc;
@ -23,6 +27,8 @@ class XtcReaderActivity final : public ActivityWithSubactivity {
bool updateRequired = false;
const std::function<void()> onGoBack;
const std::function<void()> onGoHome;
//pages once load
uint32_t m_loadedMax = 499;
static void taskTrampoline(void* param);
[[noreturn]] void displayTaskLoop();
@ -30,6 +36,8 @@ class XtcReaderActivity final : public ActivityWithSubactivity {
void renderPage();
void saveProgress() const;
void loadProgress();
//new
void gotoPage(uint32_t targetPage);
public:
explicit XtcReaderActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::unique_ptr<Xtc> xtc,

134
src/activities/reader/XtcReaderChapterSelectionActivity.cpp
View File

@ -4,38 +4,15 @@
#include "MappedInputManager.h"
#include "fontIds.h"
#include "Xtc.h"
namespace {
constexpr int SKIP_PAGE_MS = 700;
int page = 1;
} // namespace
int XtcReaderChapterSelectionActivity::getPageItems() const {
constexpr int startY = 60;
constexpr int lineHeight = 30;
const int screenHeight = renderer.getScreenHeight();
const int endY = screenHeight - lineHeight;
const int availableHeight = endY - startY;
int items = availableHeight / lineHeight;
if (items < 1) {
items = 1;
}
return items;
}
int XtcReaderChapterSelectionActivity::findChapterIndexForPage(uint32_t page) const {
if (!xtc) {
return 0;
}
const auto& chapters = xtc->getChapters();
for (size_t i = 0; i < chapters.size(); i++) {
if (page >= chapters[i].startPage && page <= chapters[i].endPage) {
return static_cast<int>(i);
}
}
return 0;
return 25; // 25 for one page
}
void XtcReaderChapterSelectionActivity::taskTrampoline(void* param) {
@ -44,34 +21,27 @@ void XtcReaderChapterSelectionActivity::taskTrampoline(void* param) {
}
void XtcReaderChapterSelectionActivity::onEnter() {
renderer.clearScreen();
Activity::onEnter();
if (!xtc) {
return;
}
renderingMutex = xSemaphoreCreateMutex();
selectorIndex = findChapterIndexForPage(currentPage);
updateRequired = true;
xTaskCreate(&XtcReaderChapterSelectionActivity::taskTrampoline, "XtcReaderChapterSelectionActivityTask",
4096, // Stack size
this, // Parameters
1, // Priority
&displayTaskHandle // Task handle
selectorIndex = 0;
page = 1;
xTaskCreate(&XtcReaderChapterSelectionActivity::taskTrampoline, "XtcReaderChapterSelectionTask",
4096,
this,
1,
&displayTaskHandle
);
}
void XtcReaderChapterSelectionActivity::onExit() {
Activity::onExit();
xSemaphoreTake(renderingMutex, portMAX_DELAY);
if (displayTaskHandle) {
vTaskDelete(displayTaskHandle);
displayTaskHandle = nullptr;
}
vSemaphoreDelete(renderingMutex);
renderingMutex = nullptr;
}
void XtcReaderChapterSelectionActivity::loop() {
@ -84,32 +54,34 @@ void XtcReaderChapterSelectionActivity::loop() {
const int pageItems = getPageItems();
if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
const auto& chapters = xtc->getChapters();
if (!chapters.empty() && selectorIndex >= 0 && selectorIndex < static_cast<int>(chapters.size())) {
onSelectPage(chapters[selectorIndex].startPage);
}
const int pagebegin=(page-1)*25;
xtc->readChapters_gd(pagebegin);
//to get the page for the select chapter
uint32_t chapterpage = this->xtc->getChapterstartpage(selectorIndex);
Serial.printf("[%lu] [XTC] 跳转章节：%d,跳转页数：%d\n", millis(), selectorIndex, chapterpage);
onSelectPage(chapterpage);
} else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
onGoBack();
} else if (prevReleased) {
const int total = static_cast<int>(xtc->getChapters().size());
if (total == 0) {
return;
}
if (skipPage) {
selectorIndex = ((selectorIndex / pageItems - 1) * pageItems + total) % total;
bool isUpKey = mappedInput.wasReleased(MappedInputManager::Button::Up);
if (skipPage || isUpKey) {
page -= 1;
if(page < 1) page = 1;
selectorIndex = (page-1)*25;
} else {
selectorIndex = (selectorIndex + total - 1) % total;
selectorIndex--;
if(selectorIndex < 0) selectorIndex = 0;
}
updateRequired = true;
} else if (nextReleased) {
const int total = static_cast<int>(xtc->getChapters().size());
if (total == 0) {
return;
}
if (skipPage) {
selectorIndex = ((selectorIndex / pageItems + 1) * pageItems) % total;
bool isDownKey = mappedInput.wasReleased(MappedInputManager::Button::Down);
if (skipPage || isDownKey) {
page += 1;
selectorIndex = (page-1)*25;
} else {
selectorIndex = (selectorIndex + 1) % total;
selectorIndex++;
}
updateRequired = true;
}
@ -119,9 +91,7 @@ void XtcReaderChapterSelectionActivity::displayTaskLoop() {
while (true) {
if (updateRequired) {
updateRequired = false;
xSemaphoreTake(renderingMutex, portMAX_DELAY);
renderScreen();
xSemaphoreGive(renderingMutex);
}
vTaskDelay(10 / portTICK_PERIOD_MS);
}
@ -129,28 +99,38 @@ void XtcReaderChapterSelectionActivity::displayTaskLoop() {
void XtcReaderChapterSelectionActivity::renderScreen() {
renderer.clearScreen();
const int pagebegin=(page-1)*25;
int page_chapter=25;
static int parsedPage = -1;
if (parsedPage != page) {
xtc->readChapters_gd(pagebegin);
parsedPage = page;
}
const auto pageWidth = renderer.getScreenWidth();
const int pageItems = getPageItems();
renderer.drawCenteredText(UI_12_FONT_ID, 15, "Select Chapter", true, EpdFontFamily::BOLD);
const auto& chapters = xtc->getChapters();
if (chapters.empty()) {
renderer.drawCenteredText(UI_10_FONT_ID, 120, "No chapters");
renderer.displayBuffer();
return;
}
const int FIX_LINE_HEIGHT = 29;
const int BASE_Y = 60;
const auto pageStartIndex = selectorIndex / pageItems * pageItems;
renderer.fillRect(0, 60 + (selectorIndex % pageItems) * 30 - 2, pageWidth - 1, 30);
for (int i = pageStartIndex; i < static_cast<int>(chapters.size()) && i < pageStartIndex + pageItems; i++) {
const auto& chapter = chapters[i];
const char* title = chapter.name.empty() ? "Unnamed" : chapter.name.c_str();
renderer.drawText(UI_10_FONT_ID, 20, 60 + (i % pageItems) * 30, title, i != selectorIndex);
}
const auto labels = mappedInput.mapLabels("« Back", "Select", "Up", "Down");
renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
for (int i = pagebegin; i <= pagebegin + page_chapter - 1; i++) {
int localIdx = i - pagebegin;
uint32_t currOffset = this->xtc->getChapterstartpage(i);
std::string dirTitle = this->xtc->getChapterTitleByIndex(i);
Serial.printf("[%lu] [XTC_CHAPTER] 第%d章，名字为:%s,页码为%d\n", millis(), i, dirTitle.c_str(),currOffset);
static char title[64];
strncpy(title, dirTitle.c_str(), sizeof(title)-1);
title[sizeof(title)-1] = '\0';
int drawY = BASE_Y + localIdx * FIX_LINE_HEIGHT;
Serial.printf("选中的选项是：%d\n",selectorIndex);
renderer.drawText(UI_10_FONT_ID, 20, drawY, title, i!= selectorIndex);
}
renderer.displayBuffer();
}