(new Section(epub, currentSpineIndex, renderer)); // Fresh section, fresh chance: a failed lazy extension start in a previous // section must not suppress watermark-triggered rebuilds for this one. partialRebuildStartFailed = false; // A finalized cache serves every page as-is. A partial cache (suspended build from a // previous session) serves its pages instantly too, but a build must still run to lay // out the rest -- it re-parses from the top in the background (HTML already cached, // pages are deterministic) and finalizes, so the partial machinery retires itself. const bool cacheLoaded = section->loadSectionFile( SETTINGS.getReaderFontId(), SETTINGS.getReaderLineCompression(), SETTINGS.extraParagraphSpacing, SETTINGS.paragraphAlignment, viewportWidth, viewportHeight, SETTINGS.hyphenationEnabled, SETTINGS.embeddedStyle, SETTINGS.imageRendering, SETTINGS.focusReadingEnabled); if (cacheLoaded) { // Matching render params means identical pagination, so the saved page number is valid // as-is: consume any pending settings-change reposition. Without this, a chapter total // saved while the section was still building (i.e. a watermark, not the real count) // would remap the resume page against the finalized count and teleport the reader. cachedChapterTotalPageCount = 0; } const bool cacheComplete = cacheLoaded && !section->isPartial(); if (!cacheComplete) { if (section->isPartial()) { LOG_DBG("ERS", "Partial cache found (%d pages), resuming build...", section->pageCount); } else { LOG_DBG("ERS", "Cache not found, building..."); } // Jumps that need the final pagination or the anchor map -- explicit page jumps, // fragment anchors, percent jumps, and cross-setting progress repositioning -- can't // resolve their landing page until the whole chapter is laid out, so they take the full // (blocking) build with the indexing popup. Everything else -- plain forward reads, resume, // and explicit page jumps -- only needs a specific page, so it builds incrementally to that // page and finishes the rest in loop(). The settings-change reposition (cachedChapterTotal*) // is NOT a full-build trigger: it's deferred to applyDeferredReposition() once the real page // count is known, so it never blocks the first page. // Only a percent jump truly needs the whole chapter up front (percent -> page needs the final // page count). Anchor jumps (TOC / chapter select / footnotes) resolve incrementally below -- // the anchor is recorded as its page is laid out, so a chapter-top anchor lands on page 0 // without indexing the whole chapter. const bool needsFullBuild = pendingPercentJump; if (needsFullBuild) { GUI.drawPopup(renderer, tr(STR_INDEXING)); // The popup's own refresh is a plain FAST, so force the page that replaces it onto the HALF // ghost-cleanup path -- otherwise the "INDEXING" text ghosts under the rendered page. pagesUntilFullRefresh = 1; // No popup redraws while the framebuffer is lent to the build below; // the panel holds the popup displayed above (e-ink is persistent). const auto popupFn = [this]() { if (renderer.hasFrameBuffer()) GUI.drawPopup(renderer, tr(STR_INDEXING)); }; // Lend the framebuffer's 48 KB to the blocking full build; restored // (white) at scope exit, and the page render below redraws everything. GfxRenderer::FrameBufferLoan loan(renderer); if (!section->createSectionFile(SETTINGS.getReaderFontId(), SETTINGS.getReaderLineCompression(), SETTINGS.extraParagraphSpacing, SETTINGS.paragraphAlignment, viewportWidth, viewportHeight, SETTINGS.hyphenationEnabled, SETTINGS.embeddedStyle, SETTINGS.imageRendering, SETTINGS.focusReadingEnabled, popupFn)) { LOG_ERR("ERS", "Failed to persist page data to SD"); section.reset(); loan.end(); // restore before anything draws showBuildError(); return; } loan.end(); } else { // Lay out just enough to show the landing page; loop() builds the rest behind it. Show the // indexing popup up front only when the build will actually be slow: a large spine (its // whole HTML must be inflated before page 1 can lay out -- the giant single-spine case), or // a deep resume/jump that must lay out many pages to reach the landing page. Tiny sections // build in a blink and stay popup-free. const int target = pendingPageJump.has_value() ? *pendingPageJump : (nextPageNumber < 0 ? 0 : nextPageNumber); const bool anchorJump = !pendingAnchor.empty(); // Landing well inside a partial: the page (or anchor, via the on-disk map) is already // servable, so don't restart the extension build now -- it re-lays out the WHOLE chapter // from page 0 (minutes of background CPU + SD writes on a giant spine), pure waste when // the reader never nears the watermark this session. loop() starts it lazily once the // reader is within PARTIAL_REBUILD_START_MARGIN pages of the watermark. if (section->isPartial() && (anchorJump ? section->getPageForAnchor(pendingAnchor).has_value() : target + PARTIAL_REBUILD_START_MARGIN < static_cast(section->pageCount))) { LOG_DBG("ERS", "Partial covers target %d of %d; deferring extension build", target, section->pageCount); } else { const size_t spineBytes = epub->getCumulativeSpineItemSize(currentSpineIndex) - (currentSpineIndex > 0 ? epub->getCumulativeSpineItemSize(currentSpineIndex - 1) : 0); // Popup only when the build will actually be slow: a big spine whose HTML still needs // inflating (the multi-second cost), or a deep page target. A reopen with cached HTML builds // fast, so no popup -- that's what made an already-indexed book look like it was reindexing. // A partial cache that already covers the target page shows it instantly: never popup. const bool willInflate = !section->hasHtmlCache(); bool showPopup; if (anchorJump) { // An anchor jump's cost is bounded by the anchor's page, not `target`. An anchor already // in the on-disk map (partial or finalized cache) lands instantly: no popup. Otherwise it // lies beyond the indexed watermark and the build may lay out the whole spine to find it, // so gate on spine size alone -- laying out a big spine takes seconds even with cached // HTML. Ordinary chapter-top TOC jumps resolve on page 0 and stay popup-free. showPopup = !section->findAnchor(pendingAnchor).has_value() && spineBytes > BUILD_POPUP_BYTE_THRESHOLD; } else { const bool targetAvailable = target < static_cast(section->pageCount); showPopup = !targetAvailable && ((spineBytes > BUILD_POPUP_BYTE_THRESHOLD && willInflate) || target > BUILD_POPUP_PAGE_THRESHOLD); } if (showPopup) { GUI.drawPopup(renderer, tr(STR_INDEXING)); // HALF-clear the popup when the page replaces it, else "INDEXING" ghosts under the page. pagesUntilFullRefresh = 1; } // Lend the framebuffer's 48 KB to the blocking pre-render burst // (startBuild inflates the whole spine HTML — the memory peak). The // background buildSomeMore chunks in loop() do NOT get the loan: they // deliberately interleave with page renders. Restored before render. GfxRenderer::FrameBufferLoan loan(renderer); if (!section->startBuild(SETTINGS.getReaderFontId(), SETTINGS.getReaderLineCompression(), SETTINGS.extraParagraphSpacing, SETTINGS.paragraphAlignment, viewportWidth, viewportHeight, SETTINGS.hyphenationEnabled, SETTINGS.embeddedStyle, SETTINGS.imageRendering, SETTINGS.focusReadingEnabled)) { LOG_ERR("ERS", "Failed to start section build"); section.reset(); loan.end(); // restore before anything draws (showBuildError renders a popup) showBuildError(); return; } while (!section->isBuildComplete() && (anchorJump ? !section->findAnchor(pendingAnchor) : static_cast(section->pageCount) <= target)) { // Anchor jump: build until the anchor's page is laid out (usually page 0), checking a // partial's on-disk anchor map too so an already-indexed anchor resolves immediately. // Otherwise: build until the target page exists. loop() builds the rest behind it. if (!section->buildSomeMore(BUILD_PAGES_PER_CHUNK)) { LOG_ERR("ERS", "Failed during incremental section build"); section.reset(); loan.end(); // restore before anything draws (showBuildError renders a popup) showBuildError(); return; } } loan.end(); } } } else { LOG_DBG("ERS", "Cache found, skipping build..."); } if (pendingPageJump.has_value()) { section->currentPage = *pendingPageJump; pendingPageJump.reset(); } else { section->currentPage = nextPageNumber; if (section->currentPage < 0) { section->currentPage = 0; } } if (!pendingAnchor.empty()) { // Resolve from the pages laid out so far and/or the on-disk map (finalized or partial). const auto page = section->findAnchor(pendingAnchor); if (page) { section->currentPage = *page; LOG_DBG("ERS", "Resolved anchor '%s' to page %d", pendingAnchor.c_str(), *page); } else { LOG_DBG("ERS", "Anchor '%s' not found in section %d", pendingAnchor.c_str(), currentSpineIndex); } pendingAnchor.clear(); } if (pendingPercentJump && section->pageCount > 0) { // Apply the pending percent jump now that we know the new section's page count. int newPage = static_cast(pendingSpineProgress * static_cast(section->pageCount)); if (newPage >= section->pageCount) { newPage = section->pageCount - 1; } section->currentPage = newPage; pendingPercentJump = false; } } // Extend the build to the requested page if needed (for partials and in-progress builds). // This runs every render, so it covers both the first page and any forward turn that gets // ahead of the background builder; pages already built do no work here. // // Crossing a partial's watermark before the extension rebuild has caught up means a // synchronous wait spanning the remaining prefix re-layout -- potentially tens of // seconds on a giant spine. Show the indexing popup so it isn't a silent freeze // (the page that replaces it takes the HALF ghost-cleanup path). Ordinary window // catch-ups on a non-partial build are a page or two and stay popup-free. if (section->isPartial() && section->currentPage >= static_cast(section->pageCount)) { GUI.drawPopup(renderer, tr(STR_INDEXING)); pagesUntilFullRefresh = 1; } while (section->isPartial() && section->currentPage >= static_cast(section->pageCount)) { // Start a build to extend a partial toward the requested page. if (!section->isBuilding() && !section->startBuild(SETTINGS.getReaderFontId(), SETTINGS.getReaderLineCompression(), SETTINGS.extraParagraphSpacing, SETTINGS.paragraphAlignment, viewportWidth, viewportHeight, SETTINGS.hyphenationEnabled, SETTINGS.embeddedStyle, SETTINGS.imageRendering, SETTINGS.focusReadingEnabled)) { LOG_ERR("ERS", "Failed to start partial extension build"); section.reset(); showBuildError(); return; } // Extend until either the target page exists or the build completes. while (!section->isBuildComplete() && section->currentPage >= static_cast(section->pageCount)) { if (!section->buildSomeMore(BUILD_PAGES_PER_CHUNK)) { LOG_ERR("ERS", "Failed during incremental section build"); section.reset(); showBuildError(); return; } } } // For an in-progress incremental build, make sure the page we're about to show has been laid out. if (section->isBuilding()) { while (!section->isBuildComplete() && section->currentPage >= static_cast(section->pageCount)) { if (!section->buildSomeMore(BUILD_PAGES_PER_CHUNK)) { LOG_ERR("ERS", "Failed during incremental section build"); section.reset(); showBuildError(); return; } } } // The requested page is now as built as it will get. If it still lands past the end, // clamp to the last real page: the UINT16_MAX "last page" sentinel from backward chapter // navigation, an explicit jump beyond a finished chapter, or a stale saved position. // Guarded on !isBuilding() because a still-building section's pageCount is only the current // watermark (not the final count) and has already been driven far enough by the loops above. if (!section->isBuilding() && section->pageCount > 0 && section->currentPage >= static_cast(section->pageCount)) { section->currentPage = section->pageCount - 1; } // Apply a deferred settings-change reposition now that the real page count is known (a no-op for // a plain resume / unchanged pagination). If still building, this defers to loop() on completion. applyDeferredReposition(); renderer.clearScreen(); if (section->pageCount == 0) { LOG_DBG("ERS", "No pages to render"); renderer.drawCenteredText(UI_12_FONT_ID, 300, tr(STR_EMPTY_CHAPTER), true, EpdFontFamily::BOLD); renderStatusBar(); renderer.displayBuffer(); automaticPageTurnActive = false; showPendingSyncSaveError(); return; } if (section->currentPage < 0 || section->currentPage >= section->pageCount) { LOG_DBG("ERS", "Page out of bounds: %d (max %d)", section->currentPage, section->pageCount); renderer.drawCenteredText(UI_12_FONT_ID, 300, tr(STR_OUT_OF_BOUNDS), true, EpdFontFamily::BOLD); renderStatusBar(); renderer.displayBuffer(); automaticPageTurnActive = false; showPendingSyncSaveError(); return; } updateBookmarkFlag(); { // Unified page read: the in-progress build's in-RAM table if it has reached the page, // otherwise the on-disk file (finalized section, or a partial from a previous session). auto p = section->loadPage(section->currentPage); if (!p) { LOG_ERR("ERS", "Failed to load page from SD - clearing section cache"); automaticPageTurnActive = false; // Retrying rebuilds a transiently corrupt section and usually recovers, but a page that keeps // failing would loop forever on a blank screen, so bound the retries before giving up. const bool giveUp = ++pageLoadRetryCount > MAX_PAGE_LOAD_RETRIES; // Abandon (not suspend) any active build BEFORE clearing: clearCache deletes the files, // and the destructor's suspend would otherwise commit tables into a deleted handle. section->abandonBuild(); section->clearCache(); section.reset(); if (giveUp) { LOG_ERR("ERS", "Page load retry limit reached, aborting"); pageLoadRetryCount = 0; // Reset so a later user-initiated navigation can try afresh renderer.clearScreen(); renderer.drawCenteredText(UI_12_FONT_ID, 300, tr(STR_PAGE_LOAD_ERROR), true, EpdFontFamily::BOLD); renderer.displayBuffer(); showPendingSyncSaveError(); return; } requestUpdate(); // Try again after clearing cache showPendingSyncSaveError(); return; } pageLoadRetryCount = 0; // Reset the retry counter once a page loads cleanly // Collect footnotes from the loaded page currentPageFootnotes = std::move(p->footnotes); const auto start = millis(); renderContents(std::move(p), orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft); LOG_DBG("ERS", "Rendered page in %dms", millis() - start); } // Only persist when the position actually changed. render() also runs on menu, // bookmark and screenshot re-renders, and writeAtomic is several FAT ops for 6 bytes. // Every real page turn changes currentPage, so progress durability is unaffected. if (currentSpineIndex != lastSavedSpineIndex || section->currentPage != lastSavedPage || section->pageCount != lastSavedPageCount) { if (saveProgress(currentSpineIndex, section->currentPage, section->estimatedTotalPages())) { lastSavedSpineIndex = currentSpineIndex; lastSavedPage = section->currentPage; lastSavedPageCount = section->estimatedTotalPages(); } } showPendingSyncSaveError(); if (pendingScreenshot) { pendingScreenshot = false; ScreenshotUtil::takeScreenshot(renderer); } if (showBookmarkMessage) { GUI.drawPopup(renderer, bookmarkRemoved ? tr(STR_BOOKMARK_REMOVED) : tr(STR_BOOKMARK_ADDED)); } if (showDictionaryMessage) { GUI.drawPopup(renderer, tr(STR_DICT_NO_DICT_SET)); } } bool EpubReaderActivity::applyDeferredReposition() { if (cachedChapterTotalPageCount == 0 || !section || section->isBuilding()) { return false; } bool changed = false; // Only remap when the chapter actually re-paginated (e.g. after a settings change). A plain // resume has identical pagination, so section->pageCount == cachedChapterTotalPageCount and // nothing moves. if (currentSpineIndex == cachedSpineIndex && section->pageCount != cachedChapterTotalPageCount) { const float progress = static_cast(section->currentPage) / static_cast(cachedChapterTotalPageCount); int newPage = static_cast(progress * static_cast(section->pageCount)); if (newPage < 0) newPage = 0; if (section->pageCount > 0 && newPage >= static_cast(section->pageCount)) { newPage = section->pageCount - 1; } if (newPage != section->currentPage) { section->currentPage = newPage; changed = true; } } cachedChapterTotalPageCount = 0; // consumed; don't read cached progress again return changed; } bool EpubReaderActivity::saveProgress(int spineIndex, int currentPage, int pageCount) { return EpubReaderUtils::saveProgress(*epub, spineIndex, currentPage, pageCount); } void EpubReaderActivity::renderContents(std::unique_ptr page, const int orientedMarginTop, const int orientedMarginRight, const int orientedMarginBottom, const int orientedMarginLeft) { const auto t0 = millis(); const int fontId = SETTINGS.getReaderFontId(); // Font prewarm: scan pass accumulates text, then prewarm, then real render auto* fcm = renderer.getFontCacheManager(); auto scope = fcm->createPrewarmScope(); page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop); // scan pass scope.endScanAndPrewarm(); const auto tPrewarm = millis(); const bool pageHasImages = page->hasImages(); const bool pageHasImagesNeedingDecode = pageHasImages && page->hasImagesNeedingDecode(); const bool needsTextGrayscale = SETTINGS.textAntiAliasing; const bool needsAnyGrayscale = needsTextGrayscale || pageHasImages; const bool tiledGrayscale = needsAnyGrayscale && renderer.supportsStripGrayscale(); // Whole-plane buffering only pays when the BW refresh genuinely runs async // underneath it; on blocking panels it would just spend ~50 KB for the // identical serial timing. const bool overlapRefresh = tiledGrayscale && renderer.supportsAsyncRefresh(); auto renderGrayscalePass = [&]() { if (needsTextGrayscale) { page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop); } else { page->renderImages(renderer, fontId, orientedMarginLeft, orientedMarginTop); } }; if (pageHasImagesNeedingDecode) { page->renderWithImagePlaceholders(renderer, fontId, orientedMarginLeft, orientedMarginTop); renderStatusBar(); renderer.displayBuffer(HalDisplay::FAST_REFRESH); renderer.clearScreen(); } page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop); renderStatusBar(); const auto tBwRender = millis(); if (pageHasImages) { // Double FAST_REFRESH with selective image blanking (pablohc's technique): // HALF_REFRESH sets particles too firmly for the grayscale LUT to adjust. // Instead, blank only the image area and do two fast refreshes. // Step 1: Display page with image area blanked (text appears, image area white) // Step 2: Re-render with images and display again (images appear clean) int16_t imgX, imgY, imgW, imgH; if (page->getImageBoundingBox(imgX, imgY, imgW, imgH)) { renderer.fillRect(imgX + orientedMarginLeft, imgY + orientedMarginTop, imgW, imgH, false); renderer.displayBuffer(HalDisplay::FAST_REFRESH); // Re-render page content to restore images into the blanked area // Status bar is not re-rendered here to avoid reading stale dynamic values (e.g. battery %) page->render(renderer, fontId, orientedMarginLeft, orientedMarginTop); renderer.displayBuffer(HalDisplay::FAST_REFRESH); } else { renderer.displayBuffer(HalDisplay::HALF_REFRESH); } // The image's own page is handled above and doesn't count toward the full // refresh cadence. But the grayscale pass below leaves gray charge in the // image region that a plain fast diff on the *next* page can't clear, so // text there ghosts gray (#2190). Force the next ordinary page onto the // HALF ghost-cleanup path, which drives every pixel to its target // regardless of residue. pagesUntilFullRefresh = 1; } else { // Deferred when a tiled grayscale pass follows: the plane rendering below // then overlaps the panel's refresh time instead of following it. ReaderUtils::displayWithRefreshCycle(renderer, pagesUntilFullRefresh, /*async=*/overlapRefresh); } const auto tDisplay = millis(); // Tiled grayscale: render each plane band-by-band, leaving the BW // framebuffer intact so no full-frame storeBwBuffer is needed; controller // RAM is re-synced from the live framebuffer afterward. The page is // re-rendered ceil(H/STRIP_ROWS) times per plane, but renderCharImpl culls // out-of-band glyphs before decode so the cost stays close to one render. // Both text (drawPixel) and images (DirectPixelWriter) honor the active // strip target. When the BW refresh above went out async, the plane // rendering below overlaps the panel's refresh time; only the controller // RAM writes wait for BUSY. if (tiledGrayscale) { constexpr int STRIP_ROWS = 80; const int gh = renderer.getDisplayHeight(); const int gwBytes = renderer.getDisplayWidthBytes(); const size_t planeBytes = static_cast(gwBytes) * gh; // Render one plane band-by-band into a whole-plane buffer without touching // the controller, so it can run while the refresh is still in flight. auto renderPlaneToBuffer = [&](const bool lsbPlane, uint8_t* buf) { renderer.setRenderMode(lsbPlane ? GfxRenderer::GRAYSCALE_LSB : GfxRenderer::GRAYSCALE_MSB); for (int y = 0; y < gh; y += STRIP_ROWS) { const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS; renderer.beginStripTarget(buf + static_cast(y) * gwBytes, y, rows); renderer.clearScreen(0x00); renderGrayscalePass(); renderer.endStripTarget(); } }; // Tiered on heap pressure: two plane buffers hide both plane renders // inside the refresh wait; one hides the LSB render (its buffer is reused // for MSB after streaming); none falls back to the strip-scratch flow with // no overlap. The MSB buffer is only attempted when it leaves ~60 KB free // so the pass never starves concurrent allocations. Blocking panels skip // the buffers entirely (nothing to overlap). auto lsbPlaneBuf = overlapRefresh ? makeUniqueNoThrow(planeBytes) : nullptr; auto msbPlaneBuf = (lsbPlaneBuf && ESP.getFreeHeap() >= planeBytes + 60000) ? makeUniqueNoThrow(planeBytes) : nullptr; if (lsbPlaneBuf) { renderPlaneToBuffer(true, lsbPlaneBuf.get()); if (msbPlaneBuf) renderPlaneToBuffer(false, msbPlaneBuf.get()); const auto tGrayRender = millis(); renderer.waitRefreshComplete(); const auto tWait = millis(); renderer.writeGrayscalePlaneStrip(true, lsbPlaneBuf.get(), 0, gh); if (msbPlaneBuf) { renderer.writeGrayscalePlaneStrip(false, msbPlaneBuf.get(), 0, gh); } else { renderPlaneToBuffer(false, lsbPlaneBuf.get()); renderer.writeGrayscalePlaneStrip(false, lsbPlaneBuf.get(), 0, gh); } const auto tGrayWrite = millis(); renderer.setRenderMode(GfxRenderer::BW); renderer.displayGrayBuffer(); const auto tGrayDisplay = millis(); // BW framebuffer is intact; re-sync controller RAM for the next // differential page turn directly from it. renderer.cleanupGrayscaleWithFrameBuffer(); const auto tEnd = millis(); LOG_DBG("ERS", "Page render (tiled async): prewarm=%lums bw_render=%lums display=%lums gray_render=%lums " "wait=%lums gray_write=%lums gray_display=%lums cleanup=%lums total=%lums (planes buffered: %d)", tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tGrayRender - tDisplay, tWait - tGrayRender, tGrayWrite - tWait, tGrayDisplay - tGrayWrite, tEnd - tGrayDisplay, tEnd - t0, msbPlaneBuf ? 2 : 1); } else { // Per-strip scratch tier: blocking panels and the OOM fallback. The // strip writes below need the panel idle, so wait out any pending async // refresh first (no-op on blocking panels). auto scratch = makeUniqueNoThrow(static_cast(gwBytes) * STRIP_ROWS); renderer.waitRefreshComplete(); if (!scratch) { LOG_ERR("ERS", "OOM: grayscale strip scratch (%d bytes); skipping AA this page", gwBytes * STRIP_ROWS); } else { // Bands may be streamed in any order: X4 windows each via setRamArea, // X3 via PTL. renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB); for (int y = 0; y < gh; y += STRIP_ROWS) { const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS; renderer.beginStripTarget(scratch.get(), y, rows); renderer.clearScreen(0x00); renderGrayscalePass(); renderer.endStripTarget(); renderer.writeGrayscalePlaneStrip(true, scratch.get(), y, rows); } const auto tGrayLsb = millis(); // MSB plane. renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB); for (int y = 0; y < gh; y += STRIP_ROWS) { const int rows = (gh - y < STRIP_ROWS) ? (gh - y) : STRIP_ROWS; renderer.beginStripTarget(scratch.get(), y, rows); renderer.clearScreen(0x00); renderGrayscalePass(); renderer.endStripTarget(); renderer.writeGrayscalePlaneStrip(false, scratch.get(), y, rows); } const auto tGrayMsb = millis(); renderer.setRenderMode(GfxRenderer::BW); renderer.displayGrayBuffer(); const auto tGrayDisplay = millis(); // BW framebuffer is intact; re-sync controller RAM for the next // differential page turn directly from it. renderer.cleanupGrayscaleWithFrameBuffer(); const auto tCleanup = millis(); const auto tEnd = millis(); LOG_DBG("ERS", "Page render (tiled): prewarm=%lums bw_render=%lums display=%lums gray_lsb=%lums " "gray_msb=%lums gray_display=%lums cleanup=%lums total=%lums", tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tGrayLsb - tDisplay, tGrayMsb - tGrayLsb, tGrayDisplay - tGrayMsb, tCleanup - tGrayDisplay, tEnd - t0); } } } else { // Fallback path for a controller without strip support. grayscale rendering // TODO: Only do this if font supports it if (needsAnyGrayscale) { // Save the BW frame before the grayscale passes overwrite it, restore // after. Only needed when grayscale actually renders. if (!renderer.storeBwBuffer()) { LOG_ERR("ERS", "Failed to store BW buffer for grayscale render; skipping grayscale this page"); const auto tEnd = millis(); LOG_DBG("ERS", "Page render: prewarm=%lums bw_render=%lums display=%lums total=%lums", tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tEnd - t0); return; } const auto tBwStore = millis(); renderer.clearScreen(0x00); renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB); renderGrayscalePass(); renderer.copyGrayscaleLsbBuffers(); const auto tGrayLsb = millis(); // Render and copy to MSB buffer renderer.clearScreen(0x00); renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB); renderGrayscalePass(); renderer.copyGrayscaleMsbBuffers(); const auto tGrayMsb = millis(); // display grayscale part renderer.displayGrayBuffer(); const auto tGrayDisplay = millis(); renderer.setRenderMode(GfxRenderer::BW); renderer.restoreBwBuffer(); const auto tBwRestore = millis(); const auto tEnd = millis(); LOG_DBG("ERS", "Page render: prewarm=%lums bw_render=%lums display=%lums bw_store=%lums " "gray_lsb=%lums gray_msb=%lums gray_display=%lums bw_restore=%lums total=%lums", tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tBwStore - tDisplay, tGrayLsb - tBwStore, tGrayMsb - tGrayLsb, tGrayDisplay - tGrayMsb, tBwRestore - tGrayDisplay, tEnd - t0); } else { // No text AA and no images: BW frame already displayed above, no grayscale // to render, so no save/restore. const auto tEnd = millis(); LOG_DBG("ERS", "Page render: prewarm=%lums bw_render=%lums display=%lums total=%lums", tPrewarm - t0, tBwRender - tPrewarm, tDisplay - tBwRender, tEnd - t0); } } } void EpubReaderActivity::renderStatusBar() const { // Calculate progress in book. Use the estimated total while a giant spine is still building so // "page X of Y" and the progress bar don't read off the small build watermark. const int currentPage = section->currentPage + 1; const float pageCount = section->estimatedTotalPages(); const float sectionChapterProg = (pageCount > 0) ? (static_cast(currentPage) / pageCount) : 0; const float bookProgress = epub->calculateProgress(currentSpineIndex, sectionChapterProg) * 100; std::string title; int textYOffset = 0; if (automaticPageTurnActive) { title = tr(STR_AUTO_TURN_ENABLED) + std::to_string(60 * 1000 / pageTurnDuration); // calculates textYOffset when rendering title in status bar const uint8_t statusBarHeight = UITheme::getInstance().getStatusBarHeight(); // offsets text if no status bar or progress bar only if (statusBarHeight == 0 || statusBarHeight == UITheme::getInstance().getProgressBarHeight()) { textYOffset += UITheme::getInstance().getMetrics().statusBarVerticalMargin; } } else if (SETTINGS.statusBarTitle == CrossPointSettings::STATUS_BAR_TITLE::CHAPTER_TITLE) { title = tr(STR_UNNAMED); const int tocIndex = epub->getTocIndexForSpineIndex(currentSpineIndex); if (tocIndex != -1) { const auto tocItem = epub->getTocItem(tocIndex); title = tocItem.title; } } else if (SETTINGS.statusBarTitle == CrossPointSettings::STATUS_BAR_TITLE::BOOK_TITLE) { title = epub->getTitle(); } GUI.drawStatusBar(renderer, bookProgress, currentPage, pageCount, title, 0, textYOffset, true, currentPageBookmarked, section->isBuilding()); } void EpubReaderActivity::navigateToHref(const std::string& hrefStr, const bool savePosition) { if (!epub) return; // Push current position onto saved stack if (savePosition && section && footnoteDepth < MAX_FOOTNOTE_DEPTH) { savedPositions[footnoteDepth] = {currentSpineIndex, section->currentPage}; footnoteDepth++; LOG_DBG("ERS", "Saved position [%d]: spine %d, page %d", footnoteDepth, currentSpineIndex, section->currentPage); } // Extract fragment anchor (e.g. "#note1" or "chapter2.xhtml#note1") std::string anchor; const auto hashPos = hrefStr.find('#'); if (hashPos != std::string::npos && hashPos + 1 < hrefStr.size()) { anchor = hrefStr.substr(hashPos + 1); } // Check for same-file anchor reference (#anchor only) bool sameFile = !hrefStr.empty() && hrefStr[0] == '#'; int targetSpineIndex; if (sameFile) { targetSpineIndex = currentSpineIndex; } else { targetSpineIndex = epub->resolveHrefToSpineIndex(hrefStr); } if (targetSpineIndex < 0) { LOG_DBG("ERS", "Could not resolve href: %s", hrefStr.c_str()); if (savePosition && footnoteDepth > 0) footnoteDepth--; // undo push return; } { RenderLock lock(*this); pendingAnchor = std::move(anchor); currentSpineIndex = targetSpineIndex; nextPageNumber = 0; section.reset(); } requestUpdate(); LOG_DBG("ERS", "Navigated to spine %d for href: %s", targetSpineIndex, hrefStr.c_str()); } void EpubReaderActivity::restoreSavedPosition() { if (footnoteDepth <= 0) return; footnoteDepth--; const auto& pos = savedPositions[footnoteDepth]; LOG_DBG("ERS", "Restoring position [%d]: spine %d, page %d", footnoteDepth, pos.spineIndex, pos.pageNumber); { RenderLock lock(*this); currentSpineIndex = pos.spineIndex; nextPageNumber = pos.pageNumber; section.reset(); } requestUpdate(); } void EpubReaderActivity::loadCachedBookmarks() { cachedBookmarks.clear(); if (cachedBookmarks.capacity() < initialBookmarkCacheCapacity) { cachedBookmarks.reserve(initialBookmarkCacheCapacity); } if (!epub) { currentPageBookmarked = false; return; } const std::string bmPath = BookmarkUtil::getBookmarkPath(epub->getPath()); if (Storage.exists(bmPath.c_str())) { String json = Storage.readFile(bmPath.c_str()); if (!json.isEmpty()) { JsonSettingsIO::loadBookmarks(cachedBookmarks, json.c_str()); } } updateBookmarkFlag(); } void EpubReaderActivity::addBookmark() { if (!section || !epub) { return; } LOG_DBG("ERS", "Toggle bookmark at spine %d, page %d", currentSpineIndex, section ? section->currentPage : -1); int currentPage; int pageCount; { RenderLock lock(*this); pageCount = section->estimatedTotalPages(); currentPage = section->currentPage; } SavedProgressPosition progress = ProgressMapper::toSavedProgress(epub, getCurrentPosition()); const ProgressRange pageRange = getPageProgressRange(epub, currentSpineIndex, currentPage, pageCount); const size_t bookmarkCountBeforeToggle = cachedBookmarks.size(); cachedBookmarks.erase(std::remove_if(cachedBookmarks.begin(), cachedBookmarks.end(), [&](const BookmarkEntry& b) { return bookmarkMatchesProgress(b, currentSpineIndex, currentPage, pageCount, pageRange); }), cachedBookmarks.end()); if (cachedBookmarks.size() != bookmarkCountBeforeToggle) { bookmarkRemoved = true; currentPageBookmarked = false; } else { std::string pageText; if (currentPage >= 0 && currentPage < pageCount) { pageText = section->getTextFromSectionFile(); } BookmarkEntry entry; entry.percentage = progress.percentage; entry.xpath = progress.xpath; entry.summary = BookmarkUtil::sanitizeBookmarkSummary(pageText); entry.computedSpineIndex = currentSpineIndex; entry.computedChapterPageCount = pageCount; entry.computedChapterProgress = currentPage; cachedBookmarks.insert(cachedBookmarks.begin(), entry); bookmarkRemoved = false; currentPageBookmarked = true; } const std::string path = BookmarkUtil::getBookmarkPath(epub->getPath()); const std::string bookmarksDir = BookmarkUtil::getBookmarksDir(); Storage.mkdir(bookmarksDir.c_str()); const bool ok = JsonSettingsIO::saveBookmarks(cachedBookmarks, path.c_str()); if (!ok) { LOG_ERR("ERS", "Failed to save bookmarks to: %s", path.c_str()); } requestUpdate(); } void EpubReaderActivity::updateBookmarkFlag() { if (!section || !epub || cachedBookmarks.empty()) { currentPageBookmarked = false; return; } const int pageCount = section->estimatedTotalPages(); const ProgressRange pageRange = getPageProgressRange(epub, currentSpineIndex, section->currentPage, pageCount); currentPageBookmarked = std::any_of(cachedBookmarks.begin(), cachedBookmarks.end(), [&](const BookmarkEntry& b) { return bookmarkMatchesProgress(b, currentSpineIndex, section->currentPage, pageCount, pageRange); }); } ScreenshotInfo EpubReaderActivity::getScreenshotInfo() const { ScreenshotInfo info; info.readerType = ScreenshotInfo::ReaderType::Epub; if (epub) { snprintf(info.title, sizeof(info.title), "%s", epub->getTitle().c_str()); info.spineIndex = currentSpineIndex; } if (section) { info.currentPage = section->currentPage + 1; info.totalPages = section->estimatedTotalPages(); if (epub && epub->getBookSize() > 0 && info.totalPages > 0) { const float chapterProgress = static_cast(section->currentPage) / static_cast(info.totalPages); int pct = static_cast(epub->calculateProgress(currentSpineIndex, chapterProgress) * 100.0f + 0.5f); if (pct < 0) pct = 0; if (pct > 100) pct = 100; info.progressPercent = pct; } } return info; } CrossPointPosition EpubReaderActivity::getCurrentPosition() const { const int currentPage = section ? section->currentPage : nextPageNumber; const int totalPages = section ? section->estimatedTotalPages() : cachedChapterTotalPageCount; std::optional paragraphIndex; if (section && currentPage >= 0 && currentPage < section->pageCount) { const uint16_t paragraphPage = currentPage > 0 ? static_cast(currentPage - 1) : static_cast(currentPage); if (const auto pIdx = section->getParagraphIndexForPage(paragraphPage)) { paragraphIndex = *pIdx; } } CrossPointPosition localPos = {currentSpineIndex, currentPage, totalPages}; if (paragraphIndex.has_value()) { localPos.paragraphIndex = *paragraphIndex; localPos.hasParagraphIndex = true; } return localPos; }