Cut release 0.5.1

README.md

@@ -59,6 +59,10 @@ back to the other partition using the "Swap boot partition" button here https://
 
 See [Development](#development) below.
 
+## Usage
+
+See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint.
+
 ## Development
 
 ### Prerequisites

USER_GUIDE.md

@@ -0,0 +1,78 @@
+# CrossPoint User Guide
+
+Welcome to the **CrossPoint** firmware. This guide outlines the hardware controls, navigation, and reading features of 
+the device.
+
+## 1. Hardware Overview
+
+The device utilises the standard buttons on the Xtink X4 in the same layout:
+
+### Button Layout
+| Location        | Buttons                                    |
+|-----------------|--------------------------------------------|
+| **Bottom Edge** | **Back**, **Confirm**, **Left**, **Right** |
+| **Right Side**  | **Power**, **Volume Up**, **Volume Down**  |
+
+---
+
+## 2. Power & Startup
+
+### Power On / Off
+
+To turn the device on or off, **press and hold the Power button for 1 full second**.
+
+### First Launch
+
+Upon turning the device on for the first time, you will be placed on the **Book Selection Screen** (File Browser).
+
+> **Note:** On subsequent restarts, the firmware will automatically reopen the last book you were reading.
+
+---
+
+## 3. Book Selection
+
+The Home Screen acts as a folder and file browser.
+
+* **Navigate List:** Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to move the selection cursor up 
+  and down through folders and books.
+* **Open Selection:** Press **Confirm** to open a folder or read a selected book.
+
+---
+
+## 4. Reading Mode
+
+Once you have opened a book, the button layout changes to facilitate reading.
+
+### Page Turning
+| Action            | Buttons                              |
+|-------------------|--------------------------------------|
+| **Previous Page** | Press **Left** _or_ **Volume Up**    |
+| **Next Page**     | Press **Right** _or_ **Volume Down** |
+
+### Chapter Navigation
+* **Next Chapter:** Press and **hold** the **Right** (or **Volume Down**) button briefly, then release.
+* **Previous Chapter:** Press and **hold** the **Left** (or **Volume Up**) button briefly, then release.
+
+### System Navigation
+* **Return to Home:** Press **Back** to close the book and return to the Book Selection screen.
+* **Chapter Menu:** Press **Confirm** to open the Table of Contents/Chapter Selection screen.
+
+---
+
+## 5. Chapter Selection Screen
+
+Accessible by pressing **Confirm** while inside a book.
+
+1.  Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to highlight the desired chapter.
+2.  Press **Confirm** to jump to that chapter.
+3.  *Alternatively, press **Back** to cancel and return to your current page.*
+
+---
+
+## 6. Current Limitations & Roadmap
+
+Please note that this firmware is currently in active development. The following features are **not yet supported** but
+are planned for future updates:
+
+* **Images:** Embedded images in e-books will not render.
+* **Text Formatting:** There are currently no settings to adjust font type, size, line spacing, or margins.

lib/Epub/Epub.cpp

@@ -7,247 +7,148 @@
 #include <map>
 
 #include "Epub/FsHelpers.h"
+#include "Epub/parsers/ContainerParser.h"
+#include "Epub/parsers/ContentOpfParser.h"
+#include "Epub/parsers/TocNcxParser.h"
 
-bool Epub::findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile) {
-  // open up the meta data to find where the content.opf file lives
-  size_t s;
-  const auto metaInfo = reinterpret_cast<char*>(zip.readFileToMemory("META-INF/container.xml", &s, true));
-  if (!metaInfo) {
-    Serial.printf("[%lu] [EBP] Could not find META-INF/container.xml\n", millis());
+bool Epub::findContentOpfFile(std::string* contentOpfFile) const {
+  const auto containerPath = "META-INF/container.xml";
+  size_t containerSize;
+
+  // Get file size without loading it all into heap
+  if (!getItemSize(containerPath, &containerSize)) {
+    Serial.printf("[%lu] [EBP] Could not find or size META-INF/container.xml\n", millis());
     return false;
   }
 
-  // parse the meta data
-  tinyxml2::XMLDocument metaDataDoc;
-  const auto result = metaDataDoc.Parse(metaInfo);
-  free(metaInfo);
+  ContainerParser containerParser(containerSize);
 
-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Could not parse META-INF/container.xml. Error: %d\n", millis(), result);
+  if (!containerParser.setup()) {
     return false;
   }
 
-  const auto container = metaDataDoc.FirstChildElement("container");
-  if (!container) {
-    Serial.printf("[%lu] [EBP] Could not find container element in META-INF/container.xml\n", millis());
+  // Stream read (reusing your existing stream logic)
+  if (!readItemContentsToStream(containerPath, containerParser, 512)) {
+    Serial.printf("[%lu] [EBP] Could not read META-INF/container.xml\n", millis());
+    containerParser.teardown();
     return false;
   }
 
-  const auto rootfiles = container->FirstChildElement("rootfiles");
-  if (!rootfiles) {
-    Serial.printf("[%lu] [EBP] Could not find rootfiles element in META-INF/container.xml\n", millis());
+  // Extract the result
+  if (containerParser.fullPath.empty()) {
+    Serial.printf("[%lu] [EBP] Could not find valid rootfile in container.xml\n", millis());
+    containerParser.teardown();
     return false;
   }
 
-  // find the root file that has the media-type="application/oebps-package+xml"
-  auto rootfile = rootfiles->FirstChildElement("rootfile");
-  while (rootfile) {
-    const char* mediaType = rootfile->Attribute("media-type");
-    if (mediaType && strcmp(mediaType, "application/oebps-package+xml") == 0) {
-      const char* full_path = rootfile->Attribute("full-path");
-      if (full_path) {
-        contentOpfFile = full_path;
-        return true;
-      }
-    }
-    rootfile = rootfile->NextSiblingElement("rootfile");
-  }
+  *contentOpfFile = std::move(containerParser.fullPath);
 
-  Serial.printf("[%lu] [EBP] Could not get path to content.opf file\n", millis());
-  return false;
-}
-
-bool Epub::parseContentOpf(ZipFile& zip, std::string& content_opf_file) {
-  // read in the content.opf file and parse it
-  auto contents = reinterpret_cast<char*>(zip.readFileToMemory(content_opf_file.c_str(), nullptr, true));
-
-  // parse the contents
-  tinyxml2::XMLDocument doc;
-  auto result = doc.Parse(contents);
-  free(contents);
-
-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Error parsing content.opf - %s\n", millis(),
-                  tinyxml2::XMLDocument::ErrorIDToName(result));
-    return false;
-  }
-
-  auto package = doc.FirstChildElement("package");
-  if (!package) package = doc.FirstChildElement("opf:package");
-
-  if (!package) {
-    Serial.printf("[%lu] [EBP] Could not find package element in content.opf\n", millis());
-    return false;
-  }
-
-  // get the metadata - title and cover image
-  auto metadata = package->FirstChildElement("metadata");
-  if (!metadata) metadata = package->FirstChildElement("opf:metadata");
-  if (!metadata) {
-    Serial.printf("[%lu] [EBP] Missing metadata\n", millis());
-    return false;
-  }
-
-  auto titleEl = metadata->FirstChildElement("dc:title");
-  if (!titleEl) {
-    Serial.printf("[%lu] [EBP] Missing title\n", millis());
-    return false;
-  }
-  this->title = titleEl->GetText();
-
-  auto cover = metadata->FirstChildElement("meta");
-  if (!cover) cover = metadata->FirstChildElement("opf:meta");
-  while (cover && cover->Attribute("name") && strcmp(cover->Attribute("name"), "cover") != 0) {
-    cover = cover->NextSiblingElement("meta");
-  }
-  if (!cover) {
-    Serial.printf("[%lu] [EBP] Missing cover\n", millis());
-  }
-  auto coverItem = cover ? cover->Attribute("content") : nullptr;
-
-  // read the manifest and spine
-  // the manifest gives us the names of the files
-  // the spine gives us the order of the files
-  // we can then read the files in the order they are in the spine
-  auto manifest = package->FirstChildElement("manifest");
-  if (!manifest) manifest = package->FirstChildElement("opf:manifest");
-  if (!manifest) {
-    Serial.printf("[%lu] [EBP] Missing manifest\n", millis());
-    return false;
-  }
-
-  // create a mapping from id to file name
-  auto item = manifest->FirstChildElement("item");
-  if (!item) item = manifest->FirstChildElement("opf:item");
-  std::map<std::string, std::string> items;
-
-  while (item) {
-    std::string itemId = item->Attribute("id");
-    std::string href = contentBasePath + item->Attribute("href");
-
-    // grab the cover image
-    if (coverItem && itemId == coverItem) {
-      coverImageItem = href;
-    }
-
-    // grab the ncx file
-    if (itemId == "ncx" || itemId == "ncxtoc") {
-      tocNcxItem = href;
-    }
-
-    items[itemId] = href;
-    auto nextItem = item->NextSiblingElement("item");
-    if (!nextItem) nextItem = item->NextSiblingElement("opf:item");
-    item = nextItem;
-  }
-
-  // find the spine
-  auto spineEl = package->FirstChildElement("spine");
-  if (!spineEl) spineEl = package->FirstChildElement("opf:spine");
-  if (!spineEl) {
-    Serial.printf("[%lu] [EBP] Missing spine\n", millis());
-    return false;
-  }
-
-  // read the spine
-  auto itemref = spineEl->FirstChildElement("itemref");
-  if (!itemref) itemref = spineEl->FirstChildElement("opf:itemref");
-  while (itemref) {
-    auto id = itemref->Attribute("idref");
-    if (items.find(id) != items.end()) {
-      spine.emplace_back(id, items[id]);
-    }
-    auto nextItemRef = itemref->NextSiblingElement("itemref");
-    if (!nextItemRef) nextItemRef = itemref->NextSiblingElement("opf:itemref");
-    itemref = nextItemRef;
-  }
+  containerParser.teardown();
   return true;
 }
 
-bool Epub::parseTocNcxFile(const ZipFile& zip) {
+bool Epub::parseContentOpf(const std::string& contentOpfFilePath) {
+  size_t contentOpfSize;
+  if (!getItemSize(contentOpfFilePath, &contentOpfSize)) {
+    Serial.printf("[%lu] [EBP] Could not get size of content.opf\n", millis());
+    return false;
+  }
+
+  ContentOpfParser opfParser(getBasePath(), contentOpfSize);
+
+  if (!opfParser.setup()) {
+    Serial.printf("[%lu] [EBP] Could not setup content.opf parser\n", millis());
+    return false;
+  }
+
+  if (!readItemContentsToStream(contentOpfFilePath, opfParser, 1024)) {
+    Serial.printf("[%lu] [EBP] Could not read content.opf\n", millis());
+    opfParser.teardown();
+    return false;
+  }
+
+  // Grab data from opfParser into epub
+  title = opfParser.title;
+
+  if (opfParser.items.count("ncx")) {
+    tocNcxItem = opfParser.items.at("ncx");
+  } else if (opfParser.items.count("ncxtoc")) {
+    tocNcxItem = opfParser.items.at("ncxtoc");
+  }
+
+  for (auto& spineRef : opfParser.spineRefs) {
+    if (opfParser.items.count(spineRef)) {
+      spine.emplace_back(spineRef, opfParser.items.at(spineRef));
+    }
+  }
+
+  Serial.printf("[%lu] [EBP] Successfully parsed content.opf\n", millis());
+
+  opfParser.teardown();
+  return true;
+}
+
+bool Epub::parseTocNcxFile() {
   // the ncx file should have been specified in the content.opf file
   if (tocNcxItem.empty()) {
     Serial.printf("[%lu] [EBP] No ncx file specified\n", millis());
     return false;
   }
 
-  const auto ncxData = reinterpret_cast<char*>(zip.readFileToMemory(tocNcxItem.c_str(), nullptr, true));
-  if (!ncxData) {
-    Serial.printf("[%lu] [EBP] Could not find %s\n", millis(), tocNcxItem.c_str());
+  size_t tocSize;
+  if (!getItemSize(tocNcxItem, &tocSize)) {
+    Serial.printf("[%lu] [EBP] Could not get size of toc ncx\n", millis());
     return false;
   }
 
-  // Parse the Toc contents
-  tinyxml2::XMLDocument doc;
-  const auto result = doc.Parse(ncxData);
-  free(ncxData);
+  TocNcxParser ncxParser(contentBasePath, tocSize);
 
-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Error parsing toc %s\n", millis(), tinyxml2::XMLDocument::ErrorIDToName(result));
+  if (!ncxParser.setup()) {
+    Serial.printf("[%lu] [EBP] Could not setup toc ncx parser\n", millis());
     return false;
   }
 
-  const auto ncx = doc.FirstChildElement("ncx");
-  if (!ncx) {
-    Serial.printf("[%lu] [EBP] Could not find first child ncx in toc\n", millis());
+  if (!readItemContentsToStream(tocNcxItem, ncxParser, 1024)) {
+    Serial.printf("[%lu] [EBP] Could not read toc ncx stream\n", millis());
+    ncxParser.teardown();
     return false;
   }
 
-  const auto navMap = ncx->FirstChildElement("navMap");
-  if (!navMap) {
-    Serial.printf("[%lu] [EBP] Could not find navMap child in ncx\n", millis());
-    return false;
-  }
+  this->toc = std::move(ncxParser.toc);
 
-  recursivelyParseNavMap(navMap->FirstChildElement("navPoint"));
+  Serial.printf("[%lu] [EBP] Parsed %d TOC items\n", millis(), this->toc.size());
+
+  ncxParser.teardown();
   return true;
 }
 
-void Epub::recursivelyParseNavMap(tinyxml2::XMLElement* element) {
-  // Fills toc map
-  while (element) {
-    std::string navTitle = element->FirstChildElement("navLabel")->FirstChildElement("text")->FirstChild()->Value();
-    const auto content = element->FirstChildElement("content");
-    std::string href = contentBasePath + content->Attribute("src");
-    // split the href on the # to get the href and the anchor
-    const size_t pos = href.find('#');
-    std::string anchor;
-
-    if (pos != std::string::npos) {
-      anchor = href.substr(pos + 1);
-      href = href.substr(0, pos);
-    }
-
-    toc.emplace_back(navTitle, href, anchor, 0);
-
-    tinyxml2::XMLElement* nestedNavPoint = element->FirstChildElement("navPoint");
-    if (nestedNavPoint) {
-      recursivelyParseNavMap(nestedNavPoint);
-    }
-    element = element->NextSiblingElement("navPoint");
-  }
-}
-
 // load in the meta data for the epub file
 bool Epub::load() {
+  Serial.printf("[%lu] [EBP] Loading ePub: %s\n", millis(), filepath.c_str());
   ZipFile zip("/sd" + filepath);
 
-  std::string contentOpfFile;
-  if (!findContentOpfFile(zip, contentOpfFile)) {
-    Serial.printf("[%lu] [EBP] Could not open ePub\n", millis());
+  std::string contentOpfFilePath;
+  if (!findContentOpfFile(&contentOpfFilePath)) {
+    Serial.printf("[%lu] [EBP] Could not find content.opf in zip\n", millis());
     return false;
   }
 
-  contentBasePath = contentOpfFile.substr(0, contentOpfFile.find_last_of('/') + 1);
+  Serial.printf("[%lu] [EBP] Found content.opf at: %s\n", millis(), contentOpfFilePath.c_str());
 
-  if (!parseContentOpf(zip, contentOpfFile)) {
+  contentBasePath = contentOpfFilePath.substr(0, contentOpfFilePath.find_last_of('/') + 1);
+
+  if (!parseContentOpf(contentOpfFilePath)) {
+    Serial.printf("[%lu] [EBP] Could not parse content.opf\n", millis());
     return false;
   }
 
-  if (!parseTocNcxFile(zip)) {
+  if (!parseTocNcxFile()) {
+    Serial.printf("[%lu] [EBP] Could not parse toc\n", millis());
     return false;
   }
 
+  Serial.printf("[%lu] [EBP] Loaded ePub: %s\n", millis(), filepath.c_str());
+
   return true;
 }
 
@@ -344,6 +245,13 @@ bool Epub::readItemContentsToStream(const std::string& itemHref, Print& out, con
   return zip.readFileToStream(path.c_str(), out, chunkSize);
 }
 
+bool Epub::getItemSize(const std::string& itemHref, size_t* size) const {
+  const ZipFile zip("/sd" + filepath);
+  const std::string path = normalisePath(itemHref);
+
+  return zip.getInflatedFileSize(path.c_str(), size);
+}
+
 int Epub::getSpineItemsCount() const { return spine.size(); }
 
 std::string& Epub::getSpineItem(const int spineIndex) {
@@ -391,6 +299,5 @@ int Epub::getTocIndexForSpineIndex(const int spineIndex) const {
   }
 
   Serial.printf("[%lu] [EBP] TOC item not found\n", millis());
-  // not found - default to first item
-  return 0;
+  return -1;
 }

lib/Epub/Epub.h

@@ -1,22 +1,13 @@
 #pragma once
 #include <Print.h>
-#include <tinyxml2.h>
 
 #include <string>
 #include <unordered_map>
 #include <vector>
 
-class ZipFile;
+#include "Epub/EpubTocEntry.h"
 
-class EpubTocEntry {
- public:
-  std::string title;
-  std::string href;
-  std::string anchor;
-  int level;
-  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
-      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
-};
+class ZipFile;
 
 class Epub {
   // the title read from the EPUB meta data
@@ -36,11 +27,9 @@ class Epub {
   // Uniq cache key based on filepath
   std::string cachePath;
 
-  // find the path for the content.opf file
-  static bool findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile);
-  bool parseContentOpf(ZipFile& zip, std::string& content_opf_file);
-  bool parseTocNcxFile(const ZipFile& zip);
-  void recursivelyParseNavMap(tinyxml2::XMLElement* element);
+  bool findContentOpfFile(std::string* contentOpfFile) const;
+  bool parseContentOpf(const std::string& contentOpfFilePath);
+  bool parseTocNcxFile();
 
  public:
   explicit Epub(std::string filepath, const std::string& cacheDir) : filepath(std::move(filepath)) {
@@ -59,6 +48,7 @@ class Epub {
   uint8_t* readItemContentsToBytes(const std::string& itemHref, size_t* size = nullptr,
                                    bool trailingNullByte = false) const;
   bool readItemContentsToStream(const std::string& itemHref, Print& out, size_t chunkSize) const;
+  bool getItemSize(const std::string& itemHref, size_t* size) const;
   std::string& getSpineItem(int spineIndex);
   int getSpineItemsCount() const;
   EpubTocEntry& getTocItem(int tocTndex);

lib/Epub/Epub/EpubTocEntry.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+
+class EpubTocEntry {
+ public:
+  std::string title;
+  std::string href;
+  std::string anchor;
+  int level;
+  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
+      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
+};

lib/Epub/Epub/ParsedText.cpp

@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <functional>
 #include <limits>
 #include <vector>
 
@@ -17,10 +18,10 @@ void ParsedText::addWord(std::string word, const EpdFontStyle fontStyle) {
 }
 
 // Consumes data to minimize memory usage
-std::list<std::shared_ptr<TextBlock>> ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fontId,
-                                                                        const int horizontalMargin) {
+void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fontId, const int horizontalMargin,
+                                       const std::function<void(std::shared_ptr<TextBlock>)>& processLine) {
   if (words.empty()) {
-    return {};
+    return;
   }
 
   const size_t totalWordCount = words.size();
@@ -99,8 +100,6 @@ std::list<std::shared_ptr<TextBlock>> ParsedText::layoutAndExtractLines(const Gf
     currentWordIndex = nextBreakIndex;
   }
 
-  std::list<std::shared_ptr<TextBlock>> lines;
-
   // Initialize iterators for consumption
   auto wordStartIt = words.begin();
   auto wordStyleStartIt = wordStyles.begin();
@@ -153,7 +152,7 @@ std::list<std::shared_ptr<TextBlock>> ParsedText::layoutAndExtractLines(const Gf
     std::list<EpdFontStyle> lineWordStyles;
     lineWordStyles.splice(lineWordStyles.begin(), wordStyles, wordStyleStartIt, wordStyleEndIt);
 
-    lines.push_back(
+    processLine(
         std::make_shared<TextBlock>(std::move(lineWords), std::move(lineXPos), std::move(lineWordStyles), style));
 
     // Update pointers/indices for the next line
@@ -162,6 +161,4 @@ std::list<std::shared_ptr<TextBlock>> ParsedText::layoutAndExtractLines(const Gf
     wordWidthIndex += lineWordCount;
     lastBreakAt = lineBreak;
   }
-
-  return lines;
 }

lib/Epub/Epub/ParsedText.h

@@ -3,6 +3,7 @@
 #include <EpdFontFamily.h>
 
 #include <cstdint>
+#include <functional>
 #include <list>
 #include <memory>
 #include <string>
@@ -24,6 +25,6 @@ class ParsedText {
   void setStyle(const TextBlock::BLOCK_STYLE style) { this->style = style; }
   TextBlock::BLOCK_STYLE getStyle() const { return style; }
   bool isEmpty() const { return words.empty(); }
-  std::list<std::shared_ptr<TextBlock>> layoutAndExtractLines(const GfxRenderer& renderer, int fontId,
-                                                              int horizontalMargin);
+  void layoutAndExtractLines(const GfxRenderer& renderer, int fontId, int horizontalMargin,
+                             const std::function<void(std::shared_ptr<TextBlock>)>& processLine);
 };

lib/Epub/Epub/Section.cpp

@@ -5,9 +5,9 @@
 
 #include <fstream>
 
-#include "EpubHtmlParserSlim.h"
 #include "FsHelpers.h"
 #include "Page.h"
+#include "parsers/ChapterHtmlSlimParser.h"
 
 constexpr uint8_t SECTION_FILE_VERSION = 4;
 
@@ -127,9 +127,9 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,
 
   const auto sdTmpHtmlPath = "/sd" + tmpHtmlPath;
 
-  EpubHtmlParserSlim visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
-                             marginBottom, marginLeft,
-                             [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
+  ChapterHtmlSlimParser visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
+                                marginBottom, marginLeft,
+                                [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
   success = visitor.parseAndBuildPages();
 
   SD.remove(tmpHtmlPath.c_str());

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp

@@ -1,11 +1,11 @@
-#include "EpubHtmlParserSlim.h"
+#include "ChapterHtmlSlimParser.h"
 
 #include <GfxRenderer.h>
 #include <HardwareSerial.h>
 #include <expat.h>
 
-#include "Page.h"
-#include "htmlEntities.h"
+#include "../Page.h"
+#include "../htmlEntities.h"
 
 const char* HEADER_TAGS[] = {"h1", "h2", "h3", "h4", "h5", "h6"};
 constexpr int NUM_HEADER_TAGS = sizeof(HEADER_TAGS) / sizeof(HEADER_TAGS[0]);
@@ -38,7 +38,7 @@ bool matches(const char* tag_name, const char* possible_tags[], const int possib
 }
 
 // start a new text block if needed
-void EpubHtmlParserSlim::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
+void ChapterHtmlSlimParser::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
   if (currentTextBlock) {
     // already have a text block running and it is empty - just reuse it
     if (currentTextBlock->isEmpty()) {
@@ -51,8 +51,8 @@ void EpubHtmlParserSlim::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
   currentTextBlock.reset(new ParsedText(style));
 }
 
-void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
   (void)atts;
 
   // Middle of skip
@@ -62,23 +62,7 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
   }
 
   if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
-    // const char* src = element.Attribute("src");
-    // if (src) {
-    //   // don't leave an empty text block in the list
-    //   // const BLOCK_STYLE style = currentTextBlock->get_style();
-    //   if (currentTextBlock->isEmpty()) {
-    //     delete currentTextBlock;
-    //     currentTextBlock = nullptr;
-    //   }
-    //   // TODO: Fix this
-    //   // blocks.push_back(new ImageBlock(m_base_path + src));
-    //   // start a new text block - with the same style as before
-    //   // startNewTextBlock(style);
-    // } else {
-    //   // ESP_LOGE(TAG, "Could not find src attribute");
-    // }
-
-    // start skip
+    // TODO: Start processing image tags
     self->skipUntilDepth = self->depth;
     self->depth += 1;
     return;
@@ -109,8 +93,8 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
   self->depth += 1;
 }
 
-void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s, const int len) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
 
   // Middle of skip
   if (self->skipUntilDepth < self->depth) {
@@ -149,8 +133,8 @@ void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s
   }
 }
 
-void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
   (void)name;
 
   if (self->partWordBufferIndex > 0) {
@@ -196,7 +180,7 @@ void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name
   }
 }
 
-bool EpubHtmlParserSlim::parseAndBuildPages() {
+bool ChapterHtmlSlimParser::parseAndBuildPages() {
   startNewTextBlock(TextBlock::JUSTIFIED);
 
   const XML_Parser parser = XML_ParserCreate(nullptr);
@@ -261,7 +245,21 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
   return true;
 }
 
-void EpubHtmlParserSlim::makePages() {
+void ChapterHtmlSlimParser::addLineToPage(std::shared_ptr<TextBlock> line) {
+  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
+  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
+
+  if (currentPageNextY + lineHeight > pageHeight) {
+    completePageFn(std::move(currentPage));
+    currentPage.reset(new Page());
+    currentPageNextY = marginTop;
+  }
+
+  currentPage->elements.push_back(std::make_shared<PageLine>(line, marginLeft, currentPageNextY));
+  currentPageNextY += lineHeight;
+}
+
+void ChapterHtmlSlimParser::makePages() {
   if (!currentTextBlock) {
     Serial.printf("[%lu] [EHP] !! No text block to make pages for !!\n", millis());
     return;
@@ -273,23 +271,9 @@ void EpubHtmlParserSlim::makePages() {
   }
 
   const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
-  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
-
-  // Long running task, make sure to let other things happen
-  vTaskDelay(1);
-
-  const auto lines = currentTextBlock->layoutAndExtractLines(renderer, fontId, marginLeft + marginRight);
-
-  for (auto&& line : lines) {
-    if (currentPageNextY + lineHeight > pageHeight) {
-      completePageFn(std::move(currentPage));
-      currentPage.reset(new Page());
-      currentPageNextY = marginTop;
-    }
-
-    currentPage->elements.push_back(std::make_shared<PageLine>(line, marginLeft, currentPageNextY));
-    currentPageNextY += lineHeight;
-  }
-  // add some extra line between blocks
+  currentTextBlock->layoutAndExtractLines(
+      renderer, fontId, marginLeft + marginRight,
+      [this](const std::shared_ptr<TextBlock>& textBlock) { addLineToPage(textBlock); });
+  // Extra paragrpah spacing
   currentPageNextY += lineHeight / 2;
 }

lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h

@@ -6,15 +6,15 @@
 #include <functional>
 #include <memory>
 
-#include "ParsedText.h"
-#include "blocks/TextBlock.h"
+#include "../ParsedText.h"
+#include "../blocks/TextBlock.h"
 
 class Page;
 class GfxRenderer;
 
 #define MAX_WORD_SIZE 200
 
-class EpubHtmlParserSlim {
+class ChapterHtmlSlimParser {
   const char* filepath;
   GfxRenderer& renderer;
   std::function<void(std::unique_ptr<Page>)> completePageFn;
@@ -44,10 +44,10 @@ class EpubHtmlParserSlim {
   static void XMLCALL endElement(void* userData, const XML_Char* name);
 
  public:
-  explicit EpubHtmlParserSlim(const char* filepath, GfxRenderer& renderer, const int fontId,
-                              const float lineCompression, const int marginTop, const int marginRight,
-                              const int marginBottom, const int marginLeft,
-                              const std::function<void(std::unique_ptr<Page>)>& completePageFn)
+  explicit ChapterHtmlSlimParser(const char* filepath, GfxRenderer& renderer, const int fontId,
+                                 const float lineCompression, const int marginTop, const int marginRight,
+                                 const int marginBottom, const int marginLeft,
+                                 const std::function<void(std::unique_ptr<Page>)>& completePageFn)
       : filepath(filepath),
         renderer(renderer),
         fontId(fontId),
@@ -57,6 +57,7 @@ class EpubHtmlParserSlim {
         marginBottom(marginBottom),
         marginLeft(marginLeft),
         completePageFn(completePageFn) {}
-  ~EpubHtmlParserSlim() = default;
+  ~ChapterHtmlSlimParser() = default;
   bool parseAndBuildPages();
+  void addLineToPage(std::shared_ptr<TextBlock> line);
 };

lib/Epub/Epub/parsers/ContainerParser.cpp

@@ -0,0 +1,96 @@
+#include "ContainerParser.h"
+
+#include <HardwareSerial.h>
+
+bool ContainerParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [CTR] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  return true;
+}
+
+bool ContainerParser::teardown() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+  return true;
+}
+
+size_t ContainerParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t ContainerParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+    if (!buf) {
+      Serial.printf("[%lu] [CTR] Couldn't allocate buffer\n", millis());
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [CTR] Parse error: %s\n", millis(), XML_ErrorString(XML_GetErrorCode(parser)));
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+  return size;
+}
+
+void XMLCALL ContainerParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ContainerParser*>(userData);
+
+  // Simple state tracking to ensure we are looking at the valid schema structure
+  if (self->state == START && strcmp(name, "container") == 0) {
+    self->state = IN_CONTAINER;
+    return;
+  }
+
+  if (self->state == IN_CONTAINER && strcmp(name, "rootfiles") == 0) {
+    self->state = IN_ROOTFILES;
+    return;
+  }
+
+  if (self->state == IN_ROOTFILES && strcmp(name, "rootfile") == 0) {
+    const char* mediaType = nullptr;
+    const char* path = nullptr;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "media-type") == 0) {
+        mediaType = atts[i + 1];
+      } else if (strcmp(atts[i], "full-path") == 0) {
+        path = atts[i + 1];
+      }
+    }
+
+    // Check if this is the standard OEBPS package
+    if (mediaType && path && strcmp(mediaType, "application/oebps-package+xml") == 0) {
+      self->fullPath = path;
+    }
+  }
+}
+
+void XMLCALL ContainerParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ContainerParser*>(userData);
+
+  if (self->state == IN_ROOTFILES && strcmp(name, "rootfiles") == 0) {
+    self->state = IN_CONTAINER;
+  } else if (self->state == IN_CONTAINER && strcmp(name, "container") == 0) {
+    self->state = START;
+  }
+}

lib/Epub/Epub/parsers/ContainerParser.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <Print.h>
+
+#include <string>
+
+#include "expat.h"
+
+class ContainerParser final : public Print {
+  enum ParserState {
+    START,
+    IN_CONTAINER,
+    IN_ROOTFILES,
+  };
+
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::string fullPath;
+
+  explicit ContainerParser(const size_t xmlSize) : remainingSize(xmlSize) {}
+
+  bool setup();
+  bool teardown();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};

lib/Epub/Epub/parsers/ContentOpfParser.cpp

@@ -0,0 +1,161 @@
+#include "ContentOpfParser.h"
+
+#include <HardwareSerial.h>
+#include <ZipFile.h>
+
+bool ContentOpfParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [COF] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  XML_SetCharacterDataHandler(parser, characterData);
+  return true;
+}
+
+bool ContentOpfParser::teardown() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+  return true;
+}
+
+size_t ContentOpfParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t ContentOpfParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+
+    if (!buf) {
+      Serial.printf("[%lu] [COF] Couldn't allocate memory for buffer\n", millis());
+      XML_ParserFree(parser);
+      parser = nullptr;
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [COF] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
+                    XML_ErrorString(XML_GetErrorCode(parser)));
+      XML_ParserFree(parser);
+      parser = nullptr;
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+
+  return size;
+}
+
+void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ContentOpfParser*>(userData);
+  (void)atts;
+
+  if (self->state == START && (strcmp(name, "package") == 0 || strcmp(name, "opf:package") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "metadata") == 0 || strcmp(name, "opf:metadata") == 0)) {
+    self->state = IN_METADATA;
+    return;
+  }
+
+  if (self->state == IN_METADATA && strcmp(name, "dc:title") == 0) {
+    self->state = IN_BOOK_TITLE;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "manifest") == 0 || strcmp(name, "opf:manifest") == 0)) {
+    self->state = IN_MANIFEST;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "spine") == 0 || strcmp(name, "opf:spine") == 0)) {
+    self->state = IN_SPINE;
+    return;
+  }
+
+  // TODO: Support book cover
+  // if (self->state == IN_METADATA && (strcmp(name, "meta") == 0 || strcmp(name, "opf:meta") == 0)) {
+  // }
+
+  if (self->state == IN_MANIFEST && (strcmp(name, "item") == 0 || strcmp(name, "opf:item") == 0)) {
+    std::string itemId;
+    std::string href;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "id") == 0) {
+        itemId = atts[i + 1];
+      } else if (strcmp(atts[i], "href") == 0) {
+        href = self->baseContentPath + atts[i + 1];
+      }
+    }
+
+    self->items[itemId] = href;
+    return;
+  }
+
+  if (self->state == IN_SPINE && (strcmp(name, "itemref") == 0 || strcmp(name, "opf:itemref") == 0)) {
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "idref") == 0) {
+        self->spineRefs.emplace_back(atts[i + 1]);
+        break;
+      }
+    }
+    return;
+  }
+}
+
+void XMLCALL ContentOpfParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<ContentOpfParser*>(userData);
+
+  if (self->state == IN_BOOK_TITLE) {
+    self->title.append(s, len);
+    return;
+  }
+}
+
+void XMLCALL ContentOpfParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ContentOpfParser*>(userData);
+  (void)name;
+
+  if (self->state == IN_SPINE && (strcmp(name, "spine") == 0 || strcmp(name, "opf:spine") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_MANIFEST && (strcmp(name, "manifest") == 0 || strcmp(name, "opf:manifest") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_BOOK_TITLE && strcmp(name, "dc:title") == 0) {
+    self->state = IN_METADATA;
+    return;
+  }
+
+  if (self->state == IN_METADATA && (strcmp(name, "metadata") == 0 || strcmp(name, "opf:metadata") == 0)) {
+    self->state = IN_PACKAGE;
+    return;
+  }
+
+  if (self->state == IN_PACKAGE && (strcmp(name, "package") == 0 || strcmp(name, "opf:package") == 0)) {
+    self->state = START;
+    return;
+  }
+}

lib/Epub/Epub/parsers/ContentOpfParser.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <Print.h>
+
+#include <map>
+
+#include "Epub.h"
+#include "expat.h"
+
+class ContentOpfParser final : public Print {
+  enum ParserState {
+    START,
+    IN_PACKAGE,
+    IN_METADATA,
+    IN_BOOK_TITLE,
+    IN_MANIFEST,
+    IN_SPINE,
+  };
+
+  const std::string& baseContentPath;
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void characterData(void* userData, const XML_Char* s, int len);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::string title;
+  std::string tocNcxPath;
+  std::map<std::string, std::string> items;
+  std::vector<std::string> spineRefs;
+
+  explicit ContentOpfParser(const std::string& baseContentPath, const size_t xmlSize)
+      : baseContentPath(baseContentPath), remainingSize(xmlSize) {}
+
+  bool setup();
+  bool teardown();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};

lib/Epub/Epub/parsers/TocNcxParser.cpp

@@ -0,0 +1,165 @@
+#include "TocNcxParser.h"
+
+#include <HardwareSerial.h>
+
+bool TocNcxParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [TOC] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  XML_SetCharacterDataHandler(parser, characterData);
+  return true;
+}
+
+bool TocNcxParser::teardown() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+  return true;
+}
+
+size_t TocNcxParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t TocNcxParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+    if (!buf) {
+      Serial.printf("[%lu] [TOC] Couldn't allocate memory for buffer\n", millis());
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [TOC] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
+                    XML_ErrorString(XML_GetErrorCode(parser)));
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+  return size;
+}
+
+void XMLCALL TocNcxParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  // NOTE: We rely on navPoint label and content coming before any nested navPoints, this will be fine:
+  // <navPoint>
+  //   <navLabel><text>Chapter 1</text></navLabel>
+  //   <content src="ch1.html"/>
+  //   <navPoint> ...nested... </navPoint>
+  // </navPoint>
+  //
+  // This will NOT:
+  // <navPoint>
+  //   <navPoint> ...nested... </navPoint>
+  //   <navLabel><text>Chapter 1</text></navLabel>
+  //   <content src="ch1.html"/>
+  // </navPoint>
+
+  auto* self = static_cast<TocNcxParser*>(userData);
+
+  if (self->state == START && strcmp(name, "ncx") == 0) {
+    self->state = IN_NCX;
+    return;
+  }
+
+  if (self->state == IN_NCX && strcmp(name, "navMap") == 0) {
+    self->state = IN_NAV_MAP;
+    return;
+  }
+
+  // Handles both top-level and nested navPoints
+  if ((self->state == IN_NAV_MAP || self->state == IN_NAV_POINT) && strcmp(name, "navPoint") == 0) {
+    self->state = IN_NAV_POINT;
+    self->currentDepth++;
+
+    self->currentLabel.clear();
+    self->currentSrc.clear();
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "navLabel") == 0) {
+    self->state = IN_NAV_LABEL;
+    return;
+  }
+
+  if (self->state == IN_NAV_LABEL && strcmp(name, "text") == 0) {
+    self->state = IN_NAV_LABEL_TEXT;
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "content") == 0) {
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "src") == 0) {
+        self->currentSrc = atts[i + 1];
+        break;
+      }
+    }
+    return;
+  }
+}
+
+void XMLCALL TocNcxParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<TocNcxParser*>(userData);
+  if (self->state == IN_NAV_LABEL_TEXT) {
+    self->currentLabel.append(s, len);
+  }
+}
+
+void XMLCALL TocNcxParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<TocNcxParser*>(userData);
+
+  if (self->state == IN_NAV_LABEL_TEXT && strcmp(name, "text") == 0) {
+    self->state = IN_NAV_LABEL;
+    return;
+  }
+
+  if (self->state == IN_NAV_LABEL && strcmp(name, "navLabel") == 0) {
+    self->state = IN_NAV_POINT;
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "navPoint") == 0) {
+    self->currentDepth--;
+    if (self->currentDepth == 0) {
+      self->state = IN_NAV_MAP;
+    }
+    return;
+  }
+
+  if (self->state == IN_NAV_POINT && strcmp(name, "content") == 0) {
+    // At this point (end of content tag), we likely have both Label (from previous tags) and Src.
+    // This is the safest place to push the data, assuming <navLabel> always comes before <content>.
+    // NCX spec says navLabel comes before content.
+    if (!self->currentLabel.empty() && !self->currentSrc.empty()) {
+      std::string href = self->baseContentPath + self->currentSrc;
+      std::string anchor;
+
+      const size_t pos = href.find('#');
+      if (pos != std::string::npos) {
+        anchor = href.substr(pos + 1);
+        href = href.substr(0, pos);
+      }
+
+      // Push to vector
+      self->toc.emplace_back(self->currentLabel, href, anchor, self->currentDepth);
+
+      // Clear them so we don't re-add them if there are weird XML structures
+      self->currentLabel.clear();
+      self->currentSrc.clear();
+    }
+  }
+}

lib/Epub/Epub/parsers/TocNcxParser.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <Print.h>
+
+#include <string>
+#include <vector>
+
+#include "Epub/EpubTocEntry.h"
+#include "expat.h"
+
+class TocNcxParser final : public Print {
+  enum ParserState { START, IN_NCX, IN_NAV_MAP, IN_NAV_POINT, IN_NAV_LABEL, IN_NAV_LABEL_TEXT, IN_CONTENT };
+
+  const std::string& baseContentPath;
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  std::string currentLabel;
+  std::string currentSrc;
+  size_t currentDepth = 0;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void characterData(void* userData, const XML_Char* s, int len);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::vector<EpubTocEntry> toc;
+
+  explicit TocNcxParser(const std::string& baseContentPath, const size_t xmlSize)
+      : baseContentPath(baseContentPath), remainingSize(xmlSize) {}
+
+  bool setup();
+  bool teardown();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};

lib/GfxRenderer/GfxRenderer.cpp

@@ -162,9 +162,7 @@ int GfxRenderer::getLineHeight(const int fontId) const {
   return fontMap.at(fontId).getData(REGULAR)->advanceY;
 }
 
-uint8_t *GfxRenderer::getFrameBuffer() const {
-  return einkDisplay.getFrameBuffer();
-}
+uint8_t* GfxRenderer::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
 
 void GfxRenderer::swapBuffers() const { einkDisplay.swapBuffers(); }
 

lib/ZipFile/ZipFile.cpp

@@ -40,7 +40,7 @@ bool ZipFile::loadFileStat(const char* filename, mz_zip_archive_file_stat* fileS
   // find the file
   mz_uint32 fileIndex = 0;
   if (!mz_zip_reader_locate_file_v2(&zipArchive, filename, nullptr, 0, &fileIndex)) {
-    Serial.printf("[%lu] [ZIP] Could not find file %s\n", millis, filename);
+    Serial.printf("[%lu] [ZIP] Could not find file %s\n", millis(), filename);
     mz_zip_reader_end(&zipArchive);
     return false;
   }
@@ -82,6 +82,16 @@ long ZipFile::getDataOffset(const mz_zip_archive_file_stat& fileStat) const {
   return fileOffset + localHeaderSize + filenameLength + extraOffset;
 }
 
+bool ZipFile::getInflatedFileSize(const char* filename, size_t* size) const {
+  mz_zip_archive_file_stat fileStat;
+  if (!loadFileStat(filename, &fileStat)) {
+    return false;
+  }
+
+  *size = static_cast<size_t>(fileStat.m_uncomp_size);
+  return true;
+}
+
 uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const bool trailingNullByte) const {
   mz_zip_archive_file_stat fileStat;
   if (!loadFileStat(filename, &fileStat)) {
@@ -268,7 +278,14 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
       // Write output chunk
       if (outBytes > 0) {
         processedOutputBytes += outBytes;
-        out.write(outputBuffer + outputCursor, outBytes);
+        if (out.write(outputBuffer + outputCursor, outBytes) != outBytes) {
+          Serial.printf("[%lu] [ZIP] Failed to write all output bytes to stream\n", millis());
+          fclose(file);
+          free(outputBuffer);
+          free(fileReadBuffer);
+          free(inflator);
+          return false;
+        }
         // Update output position in buffer (with wraparound)
         outputCursor = (outputCursor + outBytes) & (TINFL_LZ_DICT_SIZE - 1);
       }

lib/ZipFile/ZipFile.h

@@ -14,6 +14,7 @@ class ZipFile {
  public:
   explicit ZipFile(std::string filePath) : filePath(std::move(filePath)) {}
   ~ZipFile() = default;
+  bool getInflatedFileSize(const char* filename, size_t* size) const;
   uint8_t* readFileToMemory(const char* filename, size_t* size = nullptr, bool trailingNullByte = false) const;
   bool readFileToStream(const char* filename, Print& out, size_t chunkSize) const;
 };

platformio.ini

@@ -1,5 +1,5 @@
 [platformio]
-crosspoint_version = 0.4.0
+crosspoint_version = 0.5.1
 default_envs = default
 
 [base]
@@ -29,7 +29,6 @@ board_build.partitions = partitions.csv
 
 ; Libraries
 lib_deps =
-  https://github.com/leethomason/tinyxml2.git#11.0.0
   BatteryMonitor=symlink://open-x4-sdk/libs/hardware/BatteryMonitor
   InputManager=symlink://open-x4-sdk/libs/hardware/InputManager
   EInkDisplay=symlink://open-x4-sdk/libs/display/EInkDisplay

src/screens/EpubReaderChapterSelectionScreen.cpp

@@ -0,0 +1,107 @@
+#include "EpubReaderChapterSelectionScreen.h"
+
+#include <GfxRenderer.h>
+#include <SD.h>
+
+#include "config.h"
+
+constexpr int PAGE_ITEMS = 24;
+constexpr int SKIP_PAGE_MS = 700;
+
+void EpubReaderChapterSelectionScreen::taskTrampoline(void* param) {
+  auto* self = static_cast<EpubReaderChapterSelectionScreen*>(param);
+  self->displayTaskLoop();
+}
+
+void EpubReaderChapterSelectionScreen::onEnter() {
+  if (!epub) {
+    return;
+  }
+
+  renderingMutex = xSemaphoreCreateMutex();
+  selectorIndex = currentSpineIndex;
+
+  // Trigger first update
+  updateRequired = true;
+  xTaskCreate(&EpubReaderChapterSelectionScreen::taskTrampoline, "EpubReaderChapterSelectionScreenTask",
+              2048,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+}
+
+void EpubReaderChapterSelectionScreen::onExit() {
+  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void EpubReaderChapterSelectionScreen::handleInput() {
+  const bool prevReleased =
+      inputManager.wasReleased(InputManager::BTN_UP) || inputManager.wasReleased(InputManager::BTN_LEFT);
+  const bool nextReleased =
+      inputManager.wasReleased(InputManager::BTN_DOWN) || inputManager.wasReleased(InputManager::BTN_RIGHT);
+
+  const bool skipPage = inputManager.getHeldTime() > SKIP_PAGE_MS;
+
+  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+    onSelectSpineIndex(selectorIndex);
+  } else if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+    onGoBack();
+  } else if (prevReleased) {
+    if (skipPage) {
+      selectorIndex =
+          ((selectorIndex / PAGE_ITEMS - 1) * PAGE_ITEMS + epub->getSpineItemsCount()) % epub->getSpineItemsCount();
+    } else {
+      selectorIndex = (selectorIndex + epub->getSpineItemsCount() - 1) % epub->getSpineItemsCount();
+    }
+    updateRequired = true;
+  } else if (nextReleased) {
+    if (skipPage) {
+      selectorIndex = ((selectorIndex / PAGE_ITEMS + 1) * PAGE_ITEMS) % epub->getSpineItemsCount();
+    } else {
+      selectorIndex = (selectorIndex + 1) % epub->getSpineItemsCount();
+    }
+    updateRequired = true;
+  }
+}
+
+void EpubReaderChapterSelectionScreen::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      renderScreen();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void EpubReaderChapterSelectionScreen::renderScreen() {
+  renderer.clearScreen();
+
+  const auto pageWidth = renderer.getScreenWidth();
+  renderer.drawCenteredText(READER_FONT_ID, 10, "Select Chapter", true, BOLD);
+
+  const auto pageStartIndex = selectorIndex / PAGE_ITEMS * PAGE_ITEMS;
+  renderer.fillRect(0, 60 + (selectorIndex % PAGE_ITEMS) * 30 + 2, pageWidth - 1, 30);
+  for (int i = pageStartIndex; i < epub->getSpineItemsCount() && i < pageStartIndex + PAGE_ITEMS; i++) {
+    const int tocIndex = epub->getTocIndexForSpineIndex(i);
+    if (tocIndex == -1) {
+      renderer.drawText(UI_FONT_ID, 20, 60 + (i % PAGE_ITEMS) * 30, "Unnamed", i != selectorIndex);
+    } else {
+      auto item = epub->getTocItem(tocIndex);
+      renderer.drawText(UI_FONT_ID, 20 + (item.level - 1) * 15, 60 + (i % PAGE_ITEMS) * 30, item.title.c_str(),
+                        i != selectorIndex);
+    }
+  }
+
+  renderer.displayBuffer();
+}

src/screens/EpubReaderChapterSelectionScreen.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <Epub.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <memory>
+
+#include "Screen.h"
+
+class EpubReaderChapterSelectionScreen final : public Screen {
+  std::shared_ptr<Epub> epub;
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  int currentSpineIndex = 0;
+  int selectorIndex = 0;
+  bool updateRequired = false;
+  const std::function<void()> onGoBack;
+  const std::function<void(int newSpineIndex)> onSelectSpineIndex;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void renderScreen();
+
+ public:
+  explicit EpubReaderChapterSelectionScreen(GfxRenderer& renderer, InputManager& inputManager,
+                                            const std::shared_ptr<Epub>& epub, const int currentSpineIndex,
+                                            const std::function<void()>& onGoBack,
+                                            const std::function<void(int newSpineIndex)>& onSelectSpineIndex)
+      : Screen(renderer, inputManager),
+        epub(epub),
+        currentSpineIndex(currentSpineIndex),
+        onGoBack(onGoBack),
+        onSelectSpineIndex(onSelectSpineIndex) {}
+  void onEnter() override;
+  void onExit() override;
+  void handleInput() override;
+};

src/screens/EpubReaderScreen.cpp

@@ -5,6 +5,7 @@
 #include <SD.h>
 
 #include "Battery.h"
+#include "EpubReaderChapterSelectionScreen.h"
 #include "config.h"
 
 constexpr int PAGES_PER_REFRESH = 15;
@@ -65,6 +66,37 @@ void EpubReaderScreen::onExit() {
 }
 
 void EpubReaderScreen::handleInput() {
+  // Pass input responsibility to sub screen if exists
+  if (subScreen) {
+    subScreen->handleInput();
+    return;
+  }
+
+  // Enter chapter selection screen
+  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
+    // Don't start screen transition while rendering
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    subScreen.reset(new EpubReaderChapterSelectionScreen(
+        this->renderer, this->inputManager, epub, currentSpineIndex,
+        [this] {
+          subScreen->onExit();
+          subScreen.reset();
+          updateRequired = true;
+        },
+        [this](const int newSpineIndex) {
+          if (currentSpineIndex != newSpineIndex) {
+            currentSpineIndex = newSpineIndex;
+            nextPageNumber = 0;
+            section.reset();
+          }
+          subScreen->onExit();
+          subScreen.reset();
+          updateRequired = true;
+        }));
+    subScreen->onEnter();
+    xSemaphoreGive(renderingMutex);
+  }
+
   if (inputManager.wasPressed(InputManager::BTN_BACK)) {
     onGoHome();
     return;
@@ -79,6 +111,14 @@ void EpubReaderScreen::handleInput() {
     return;
   }
 
+  // any botton press when at end of the book goes back to the last page
+  if (currentSpineIndex > 0 && currentSpineIndex >= epub->getSpineItemsCount()) {
+    currentSpineIndex = epub->getSpineItemsCount() - 1;
+    nextPageNumber = UINT16_MAX;
+    updateRequired = true;
+    return;
+  }
+
   const bool skipChapter = inputManager.getHeldTime() > SKIP_CHAPTER_MS;
 
   if (skipChapter) {
@@ -143,9 +183,22 @@ void EpubReaderScreen::renderScreen() {
     return;
   }
 
-  if (currentSpineIndex >= epub->getSpineItemsCount() || currentSpineIndex < 0) {
+  // edge case handling for sub-zero spine index
+  if (currentSpineIndex < 0) {
     currentSpineIndex = 0;
   }
+  // based bounds of book, show end of book screen
+  if (currentSpineIndex > epub->getSpineItemsCount()) {
+    currentSpineIndex = epub->getSpineItemsCount();
+  }
+
+  // Show end of book screen
+  if (currentSpineIndex == epub->getSpineItemsCount()) {
+    renderer.clearScreen();
+    renderer.drawCenteredText(READER_FONT_ID, 300, "End of book", true, BOLD);
+    renderer.displayBuffer();
+    return;
+  }
 
   if (!section) {
     const auto filepath = epub->getSpineItem(currentSpineIndex);
@@ -163,7 +216,7 @@ void EpubReaderScreen::renderScreen() {
         const int w = textWidth + margin * 2;
         const int h = renderer.getLineHeight(READER_FONT_ID) + margin * 2;
         renderer.grayscaleRevert();
-        uint8_t *fb1 = renderer.getFrameBuffer();
+        uint8_t* fb1 = renderer.getFrameBuffer();
         renderer.swapBuffers();
         memcpy(fb1, renderer.getFrameBuffer(), EInkDisplay::BUFFER_SIZE);
         renderer.fillRect(x, y, w, h, 0);
@@ -307,12 +360,21 @@ void EpubReaderScreen::renderStatusBar() const {
   const int titleMarginLeft = 20 + percentageTextWidth + 30 + marginLeft;
   const int titleMarginRight = progressTextWidth + 30 + marginRight;
   const int availableTextWidth = GfxRenderer::getScreenWidth() - titleMarginLeft - titleMarginRight;
-  const auto tocItem = epub->getTocItem(epub->getTocIndexForSpineIndex(currentSpineIndex));
-  auto title = tocItem.title;
-  int titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
-  while (titleWidth > availableTextWidth) {
-    title = title.substr(0, title.length() - 8) + "...";
+  const int tocIndex = epub->getTocIndexForSpineIndex(currentSpineIndex);
+
+  std::string title;
+  int titleWidth;
+  if (tocIndex == -1) {
+    title = "Unnamed";
+    titleWidth = renderer.getTextWidth(SMALL_FONT_ID, "Unnamed");
+  } else {
+    const auto tocItem = epub->getTocItem(tocIndex);
+    title = tocItem.title;
     titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
+    while (titleWidth > availableTextWidth) {
+      title = title.substr(0, title.length() - 8) + "...";
+      titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
+    }
   }
 
   renderer.drawText(SMALL_FONT_ID, titleMarginLeft + (availableTextWidth - titleWidth) / 2, textY, title.c_str());

src/screens/EpubReaderScreen.h

@@ -12,6 +12,7 @@ class EpubReaderScreen final : public Screen {
   std::unique_ptr<Section> section = nullptr;
   TaskHandle_t displayTaskHandle = nullptr;
   SemaphoreHandle_t renderingMutex = nullptr;
+  std::unique_ptr<Screen> subScreen = nullptr;
   int currentSpineIndex = 0;
   int nextPageNumber = 0;
   int pagesUntilFullRefresh = 0;