diff --git a/.gitmodules b/.gitmodules index b0d8e240..c7b9e37c 100644 --- a/.gitmodules +++ b/.gitmodules @@ -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 diff --git a/lib/Xtc/Xtc.h b/lib/Xtc/Xtc.h index c8d9a040..558ca597 100644 --- a/lib/Xtc/Xtc.h +++ b/lib/Xtc/Xtc.h @@ -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) diff --git a/lib/Xtc/Xtc/XtcParser.cpp b/lib/Xtc/Xtc/XtcParser.cpp index 8db3dead..e9bec67d 100644 --- a/lib/Xtc/Xtc/XtcParser.cpp +++ b/lib/Xtc/Xtc/XtcParser.cpp @@ -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(&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(&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(&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(&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(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 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(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(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(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(&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(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 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(&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(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 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(&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(&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(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 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(&entry), sizeof(PageTableEntry)) != sizeof(PageTableEntry)) { + return XtcError::READ_ERROR; + } + m_pageTable[i - startPage].offset = static_cast(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 diff --git a/lib/Xtc/Xtc/XtcParser.h b/lib/Xtc/Xtc/XtcParser.h index b0033542..2d205623 100644 --- a/lib/Xtc/Xtc/XtcParser.h +++ b/lib/Xtc/Xtc/XtcParser.h @@ -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& 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 diff --git a/lib/Xtc/Xtc/XtcTypes.h b/lib/Xtc/Xtc/XtcTypes.h index 773c7ad5..cff832cb 100644 --- a/lib/Xtc/Xtc/XtcTypes.h +++ b/lib/Xtc/Xtc/XtcTypes.h @@ -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 { diff --git a/open-x4-sdk b/open-x4-sdk index bd4e6707..c39f253a 160000 --- a/open-x4-sdk +++ b/open-x4-sdk @@ -1 +1 @@ -Subproject commit bd4e6707503ab9c97d13ee0d8f8c69e9ff03cd12 +Subproject commit c39f253a7dabbc193a8d7d310fb8777dca0ab8f1 diff --git a/src/activities/reader/XtcReaderActivity.cpp b/src/activities/reader/XtcReaderActivity.cpp index f579abcd..e702105e 100644 --- a/src/activities/reader/XtcReaderActivity.cpp +++ b/src/activities/reader/XtcReaderActivity.cpp @@ -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(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(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); } } diff --git a/src/activities/reader/XtcReaderActivity.h b/src/activities/reader/XtcReaderActivity.h index 579e1777..859bdff5 100644 --- a/src/activities/reader/XtcReaderActivity.h +++ b/src/activities/reader/XtcReaderActivity.h @@ -13,6 +13,10 @@ #include #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; @@ -23,6 +27,8 @@ class XtcReaderActivity final : public ActivityWithSubactivity { bool updateRequired = false; const std::function onGoBack; const std::function 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, diff --git a/src/activities/reader/XtcReaderChapterSelectionActivity.cpp b/src/activities/reader/XtcReaderChapterSelectionActivity.cpp index b2cfecaa..f26174a1 100644 --- a/src/activities/reader/XtcReaderChapterSelectionActivity.cpp +++ b/src/activities/reader/XtcReaderChapterSelectionActivity.cpp @@ -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(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(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(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(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(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(); }