Add XTC/XTCH ebook format support (#135)

## Summary

* **What is the goal of this PR?**

Add support for XTC (XTeink X4 native) ebook format, which contains
pre-rendered 480x800 1-bit bitmap pages optimized for e-ink displays.

* **What changes are included?**

- New `lib/Xtc/` library with XtcParser for reading XTC files
- XtcReaderActivity for displaying XTC pages on e-ink display
- XTC file detection in FileSelectionActivity
- Cover BMP generation from first XTC page
- Correct XTG page header structure (22 bytes) and bit polarity handling

## Additional Context

- XTC files contain pre-rendered bitmap pages with embedded status bar
(page numbers, progress %)
- XTG page header: 22 bytes (magic + dimensions + reserved fields +
bitmap size)
- Bit polarity: 0 = black, 1 = white
- No runtime text rendering needed - pages display directly on e-ink
- Faster page display compared to EPUB since no parsing/rendering
required
- Memory efficient: loads one page at a time (48KB per page)
- Tested with XTC files generated from https://x4converter.rho.sh/
- Verified correct page alignment and color rendering
- Please report any issues if you test with XTC files from other
sources.

---------

Co-authored-by: Dave Allie <dave@daveallie.com>

lib/GfxRenderer/GfxRenderer.cpp

@@ -341,12 +341,13 @@ void GfxRenderer::freeBwBufferChunks() {
  * This should be called before grayscale buffers are populated.
  * A `restoreBwBuffer` call should always follow the grayscale render if this method was called.
  * Uses chunked allocation to avoid needing 48KB of contiguous memory.
+ * Returns true if buffer was stored successfully, false if allocation failed.
  */
-void GfxRenderer::storeBwBuffer() {
+bool GfxRenderer::storeBwBuffer() {
   const uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
   if (!frameBuffer) {
     Serial.printf("[%lu] [GFX] !! No framebuffer in storeBwBuffer\n", millis());
-    return;
+    return false;
   }
 
   // Allocate and copy each chunk
@@ -367,7 +368,7 @@ void GfxRenderer::storeBwBuffer() {
                     BW_BUFFER_CHUNK_SIZE);
       // Free previously allocated chunks
       freeBwBufferChunks();
-      return;
+      return false;
     }
 
     memcpy(bwBufferChunks[i], frameBuffer + offset, BW_BUFFER_CHUNK_SIZE);
@@ -375,6 +376,7 @@ void GfxRenderer::storeBwBuffer() {
 
   Serial.printf("[%lu] [GFX] Stored BW buffer in %zu chunks (%zu bytes each)\n", millis(), BW_BUFFER_NUM_CHUNKS,
                 BW_BUFFER_CHUNK_SIZE);
+  return true;
 }
 
 /**
@@ -422,6 +424,17 @@ void GfxRenderer::restoreBwBuffer() {
   Serial.printf("[%lu] [GFX] Restored and freed BW buffer chunks\n", millis());
 }
 
+/**
+ * Cleanup grayscale buffers using the current frame buffer.
+ * Use this when BW buffer was re-rendered instead of stored/restored.
+ */
+void GfxRenderer::cleanupGrayscaleWithFrameBuffer() const {
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  if (frameBuffer) {
+    einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
+  }
+}
+
 void GfxRenderer::renderChar(const EpdFontFamily& fontFamily, const uint32_t cp, int* x, const int* y,
                              const bool pixelState, const EpdFontStyle style) const {
   const EpdGlyph* glyph = fontFamily.getGlyph(cp, style);

lib/GfxRenderer/GfxRenderer.h

@@ -85,8 +85,9 @@ class GfxRenderer {
   void copyGrayscaleLsbBuffers() const;
   void copyGrayscaleMsbBuffers() const;
   void displayGrayBuffer() const;
-  void storeBwBuffer();
+  bool storeBwBuffer();  // Returns true if buffer was stored successfully
   void restoreBwBuffer();
+  void cleanupGrayscaleWithFrameBuffer() const;
 
   // Low level functions
   uint8_t* getFrameBuffer() const;

lib/Xtc/README

@@ -0,0 +1,40 @@
+# XTC/XTCH Library
+
+XTC ebook format support for CrossPoint Reader.
+
+## Supported Formats
+
+| Format | Extension | Description                                  |
+|--------|-----------|----------------------------------------------|
+| XTC    | `.xtc`    | Container with XTG pages (1-bit monochrome)  |
+| XTCH   | `.xtch`   | Container with XTH pages (2-bit grayscale)   |
+
+## Format Overview
+
+XTC/XTCH are container formats designed for ESP32 e-paper displays. They store pre-rendered bitmap pages optimized for the XTeink X4 e-reader (480x800 resolution).
+
+### Container Structure (XTC/XTCH)
+
+- 56-byte header with metadata offsets
+- Optional metadata (title, author, etc.)
+- Page index table (16 bytes per page)
+- Page data (XTG or XTH format)
+
+### Page Formats
+
+#### XTG (1-bit monochrome)
+
+- Row-major storage, 8 pixels per byte
+- MSB first (bit 7 = leftmost pixel)
+- 0 = Black, 1 = White
+
+#### XTH (2-bit grayscale)
+
+- Two bit planes stored sequentially
+- Column-major order (right to left)
+- 8 vertical pixels per byte
+- Grayscale: 0=White, 1=Dark Grey, 2=Light Grey, 3=Black
+
+## Reference
+
+Original format info: <https://gist.github.com/CrazyCoder/b125f26d6987c0620058249f59f1327d>

lib/Xtc/Xtc.cpp

@@ -0,0 +1,337 @@
+/**
+ * Xtc.cpp
+ *
+ * Main XTC ebook class implementation
+ * XTC ebook support for CrossPoint Reader
+ */
+
+#include "Xtc.h"
+
+#include <FsHelpers.h>
+#include <HardwareSerial.h>
+#include <SD.h>
+
+bool Xtc::load() {
+  Serial.printf("[%lu] [XTC] Loading XTC: %s\n", millis(), filepath.c_str());
+
+  // Initialize parser
+  parser.reset(new xtc::XtcParser());
+
+  // Open XTC file
+  xtc::XtcError err = parser->open(filepath.c_str());
+  if (err != xtc::XtcError::OK) {
+    Serial.printf("[%lu] [XTC] Failed to load: %s\n", millis(), xtc::errorToString(err));
+    parser.reset();
+    return false;
+  }
+
+  loaded = true;
+  Serial.printf("[%lu] [XTC] Loaded XTC: %s (%lu pages)\n", millis(), filepath.c_str(), parser->getPageCount());
+  return true;
+}
+
+bool Xtc::clearCache() const {
+  if (!SD.exists(cachePath.c_str())) {
+    Serial.printf("[%lu] [XTC] Cache does not exist, no action needed\n", millis());
+    return true;
+  }
+
+  if (!FsHelpers::removeDir(cachePath.c_str())) {
+    Serial.printf("[%lu] [XTC] Failed to clear cache\n", millis());
+    return false;
+  }
+
+  Serial.printf("[%lu] [XTC] Cache cleared successfully\n", millis());
+  return true;
+}
+
+void Xtc::setupCacheDir() const {
+  if (SD.exists(cachePath.c_str())) {
+    return;
+  }
+
+  // Create directories recursively
+  for (size_t i = 1; i < cachePath.length(); i++) {
+    if (cachePath[i] == '/') {
+      SD.mkdir(cachePath.substr(0, i).c_str());
+    }
+  }
+  SD.mkdir(cachePath.c_str());
+}
+
+std::string Xtc::getTitle() const {
+  if (!loaded || !parser) {
+    return "";
+  }
+
+  // Try to get title from XTC metadata first
+  std::string title = parser->getTitle();
+  if (!title.empty()) {
+    return title;
+  }
+
+  // Fallback: extract filename from path as title
+  size_t lastSlash = filepath.find_last_of('/');
+  size_t lastDot = filepath.find_last_of('.');
+
+  if (lastSlash == std::string::npos) {
+    lastSlash = 0;
+  } else {
+    lastSlash++;
+  }
+
+  if (lastDot == std::string::npos || lastDot <= lastSlash) {
+    return filepath.substr(lastSlash);
+  }
+
+  return filepath.substr(lastSlash, lastDot - lastSlash);
+}
+
+std::string Xtc::getCoverBmpPath() const { return cachePath + "/cover.bmp"; }
+
+bool Xtc::generateCoverBmp() const {
+  // Already generated
+  if (SD.exists(getCoverBmpPath().c_str())) {
+    return true;
+  }
+
+  if (!loaded || !parser) {
+    Serial.printf("[%lu] [XTC] Cannot generate cover BMP, file not loaded\n", millis());
+    return false;
+  }
+
+  if (parser->getPageCount() == 0) {
+    Serial.printf("[%lu] [XTC] No pages in XTC file\n", millis());
+    return false;
+  }
+
+  // Setup cache directory
+  setupCacheDir();
+
+  // Get first page info for cover
+  xtc::PageInfo pageInfo;
+  if (!parser->getPageInfo(0, pageInfo)) {
+    Serial.printf("[%lu] [XTC] Failed to get first page info\n", millis());
+    return false;
+  }
+
+  // Get bit depth
+  const uint8_t bitDepth = parser->getBitDepth();
+
+  // Allocate buffer for page data
+  // XTG (1-bit): Row-major, ((width+7)/8) * height bytes
+  // XTH (2-bit): Two bit planes, column-major, ((width * height + 7) / 8) * 2 bytes
+  size_t bitmapSize;
+  if (bitDepth == 2) {
+    bitmapSize = ((static_cast<size_t>(pageInfo.width) * pageInfo.height + 7) / 8) * 2;
+  } else {
+    bitmapSize = ((pageInfo.width + 7) / 8) * pageInfo.height;
+  }
+  uint8_t* pageBuffer = static_cast<uint8_t*>(malloc(bitmapSize));
+  if (!pageBuffer) {
+    Serial.printf("[%lu] [XTC] Failed to allocate page buffer (%lu bytes)\n", millis(), bitmapSize);
+    return false;
+  }
+
+  // Load first page (cover)
+  size_t bytesRead = const_cast<xtc::XtcParser*>(parser.get())->loadPage(0, pageBuffer, bitmapSize);
+  if (bytesRead == 0) {
+    Serial.printf("[%lu] [XTC] Failed to load cover page\n", millis());
+    free(pageBuffer);
+    return false;
+  }
+
+  // Create BMP file
+  File coverBmp;
+  if (!FsHelpers::openFileForWrite("XTC", getCoverBmpPath(), coverBmp)) {
+    Serial.printf("[%lu] [XTC] Failed to create cover BMP file\n", millis());
+    free(pageBuffer);
+    return false;
+  }
+
+  // Write BMP header
+  // BMP file header (14 bytes)
+  const uint32_t rowSize = ((pageInfo.width + 31) / 32) * 4;  // Row size aligned to 4 bytes
+  const uint32_t imageSize = rowSize * pageInfo.height;
+  const uint32_t fileSize = 14 + 40 + 8 + imageSize;  // Header + DIB + palette + data
+
+  // File header
+  coverBmp.write('B');
+  coverBmp.write('M');
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&fileSize), 4);
+  uint32_t reserved = 0;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&reserved), 4);
+  uint32_t dataOffset = 14 + 40 + 8;  // 1-bit palette has 2 colors (8 bytes)
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&dataOffset), 4);
+
+  // DIB header (BITMAPINFOHEADER - 40 bytes)
+  uint32_t dibHeaderSize = 40;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&dibHeaderSize), 4);
+  int32_t width = pageInfo.width;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&width), 4);
+  int32_t height = -static_cast<int32_t>(pageInfo.height);  // Negative for top-down
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&height), 4);
+  uint16_t planes = 1;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&planes), 2);
+  uint16_t bitsPerPixel = 1;  // 1-bit monochrome
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&bitsPerPixel), 2);
+  uint32_t compression = 0;  // BI_RGB (no compression)
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&compression), 4);
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&imageSize), 4);
+  int32_t ppmX = 2835;  // 72 DPI
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&ppmX), 4);
+  int32_t ppmY = 2835;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&ppmY), 4);
+  uint32_t colorsUsed = 2;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&colorsUsed), 4);
+  uint32_t colorsImportant = 2;
+  coverBmp.write(reinterpret_cast<const uint8_t*>(&colorsImportant), 4);
+
+  // Color palette (2 colors for 1-bit)
+  // XTC uses inverted polarity: 0 = black, 1 = white
+  // Color 0: Black (text/foreground in XTC)
+  uint8_t black[4] = {0x00, 0x00, 0x00, 0x00};
+  coverBmp.write(black, 4);
+  // Color 1: White (background in XTC)
+  uint8_t white[4] = {0xFF, 0xFF, 0xFF, 0x00};
+  coverBmp.write(white, 4);
+
+  // Write bitmap data
+  // BMP requires 4-byte row alignment
+  const size_t dstRowSize = (pageInfo.width + 7) / 8;  // 1-bit destination row size
+
+  if (bitDepth == 2) {
+    // XTH 2-bit mode: Two bit planes, column-major order
+    // - Columns scanned right to left (x = width-1 down to 0)
+    // - 8 vertical pixels per byte (MSB = topmost pixel in group)
+    // - First plane: Bit1, Second plane: Bit2
+    // - Pixel value = (bit1 << 1) | bit2
+    const size_t planeSize = (static_cast<size_t>(pageInfo.width) * pageInfo.height + 7) / 8;
+    const uint8_t* plane1 = pageBuffer;                 // Bit1 plane
+    const uint8_t* plane2 = pageBuffer + planeSize;     // Bit2 plane
+    const size_t colBytes = (pageInfo.height + 7) / 8;  // Bytes per column
+
+    // Allocate a row buffer for 1-bit output
+    uint8_t* rowBuffer = static_cast<uint8_t*>(malloc(dstRowSize));
+    if (!rowBuffer) {
+      free(pageBuffer);
+      coverBmp.close();
+      return false;
+    }
+
+    for (uint16_t y = 0; y < pageInfo.height; y++) {
+      memset(rowBuffer, 0xFF, dstRowSize);  // Start with all white
+
+      for (uint16_t x = 0; x < pageInfo.width; x++) {
+        // Column-major, right to left: column index = (width - 1 - x)
+        const size_t colIndex = pageInfo.width - 1 - x;
+        const size_t byteInCol = y / 8;
+        const size_t bitInByte = 7 - (y % 8);  // MSB = topmost pixel
+
+        const size_t byteOffset = colIndex * colBytes + byteInCol;
+        const uint8_t bit1 = (plane1[byteOffset] >> bitInByte) & 1;
+        const uint8_t bit2 = (plane2[byteOffset] >> bitInByte) & 1;
+        const uint8_t pixelValue = (bit1 << 1) | bit2;
+
+        // Threshold: 0=white (1); 1,2,3=black (0)
+        if (pixelValue >= 1) {
+          // Set bit to 0 (black) in BMP format
+          const size_t dstByte = x / 8;
+          const size_t dstBit = 7 - (x % 8);
+          rowBuffer[dstByte] &= ~(1 << dstBit);
+        }
+      }
+
+      // Write converted row
+      coverBmp.write(rowBuffer, dstRowSize);
+
+      // Pad to 4-byte boundary
+      uint8_t padding[4] = {0, 0, 0, 0};
+      size_t paddingSize = rowSize - dstRowSize;
+      if (paddingSize > 0) {
+        coverBmp.write(padding, paddingSize);
+      }
+    }
+
+    free(rowBuffer);
+  } else {
+    // 1-bit source: write directly with proper padding
+    const size_t srcRowSize = (pageInfo.width + 7) / 8;
+
+    for (uint16_t y = 0; y < pageInfo.height; y++) {
+      // Write source row
+      coverBmp.write(pageBuffer + y * srcRowSize, srcRowSize);
+
+      // Pad to 4-byte boundary
+      uint8_t padding[4] = {0, 0, 0, 0};
+      size_t paddingSize = rowSize - srcRowSize;
+      if (paddingSize > 0) {
+        coverBmp.write(padding, paddingSize);
+      }
+    }
+  }
+
+  coverBmp.close();
+  free(pageBuffer);
+
+  Serial.printf("[%lu] [XTC] Generated cover BMP: %s\n", millis(), getCoverBmpPath().c_str());
+  return true;
+}
+
+uint32_t Xtc::getPageCount() const {
+  if (!loaded || !parser) {
+    return 0;
+  }
+  return parser->getPageCount();
+}
+
+uint16_t Xtc::getPageWidth() const {
+  if (!loaded || !parser) {
+    return 0;
+  }
+  return parser->getWidth();
+}
+
+uint16_t Xtc::getPageHeight() const {
+  if (!loaded || !parser) {
+    return 0;
+  }
+  return parser->getHeight();
+}
+
+uint8_t Xtc::getBitDepth() const {
+  if (!loaded || !parser) {
+    return 1;  // Default to 1-bit
+  }
+  return parser->getBitDepth();
+}
+
+size_t Xtc::loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize) const {
+  if (!loaded || !parser) {
+    return 0;
+  }
+  return const_cast<xtc::XtcParser*>(parser.get())->loadPage(pageIndex, buffer, bufferSize);
+}
+
+xtc::XtcError Xtc::loadPageStreaming(uint32_t pageIndex,
+                                     std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
+                                     size_t chunkSize) const {
+  if (!loaded || !parser) {
+    return xtc::XtcError::FILE_NOT_FOUND;
+  }
+  return const_cast<xtc::XtcParser*>(parser.get())->loadPageStreaming(pageIndex, callback, chunkSize);
+}
+
+uint8_t Xtc::calculateProgress(uint32_t currentPage) const {
+  if (!loaded || !parser || parser->getPageCount() == 0) {
+    return 0;
+  }
+  return static_cast<uint8_t>((currentPage + 1) * 100 / parser->getPageCount());
+}
+
+xtc::XtcError Xtc::getLastError() const {
+  if (!parser) {
+    return xtc::XtcError::FILE_NOT_FOUND;
+  }
+  return parser->getLastError();
+}

lib/Xtc/Xtc.h

@@ -0,0 +1,97 @@
+/**
+ * Xtc.h
+ *
+ * Main XTC ebook class for CrossPoint Reader
+ * Provides EPUB-like interface for XTC file handling
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "Xtc/XtcParser.h"
+#include "Xtc/XtcTypes.h"
+
+/**
+ * XTC Ebook Handler
+ *
+ * Handles XTC file loading, page access, and cover image generation.
+ * Interface is designed to be similar to Epub class for easy integration.
+ */
+class Xtc {
+  std::string filepath;
+  std::string cachePath;
+  std::unique_ptr<xtc::XtcParser> parser;
+  bool loaded;
+
+ public:
+  explicit Xtc(std::string filepath, const std::string& cacheDir) : filepath(std::move(filepath)), loaded(false) {
+    // Create cache key based on filepath (same as Epub)
+    cachePath = cacheDir + "/xtc_" + std::to_string(std::hash<std::string>{}(this->filepath));
+  }
+  ~Xtc() = default;
+
+  /**
+   * Load XTC file
+   * @return true on success
+   */
+  bool load();
+
+  /**
+   * Clear cached data
+   * @return true on success
+   */
+  bool clearCache() const;
+
+  /**
+   * Setup cache directory
+   */
+  void setupCacheDir() const;
+
+  // Path accessors
+  const std::string& getCachePath() const { return cachePath; }
+  const std::string& getPath() const { return filepath; }
+
+  // Metadata
+  std::string getTitle() const;
+
+  // Cover image support (for sleep screen)
+  std::string getCoverBmpPath() const;
+  bool generateCoverBmp() const;
+
+  // Page access
+  uint32_t getPageCount() const;
+  uint16_t getPageWidth() const;
+  uint16_t getPageHeight() const;
+  uint8_t getBitDepth() const;  // 1 = XTC (1-bit), 2 = XTCH (2-bit)
+
+  /**
+   * Load page bitmap data
+   * @param pageIndex Page index (0-based)
+   * @param buffer Output buffer
+   * @param bufferSize Buffer size
+   * @return Number of bytes read
+   */
+  size_t loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize) const;
+
+  /**
+   * Load page with streaming callback
+   * @param pageIndex Page index
+   * @param callback Callback for each chunk
+   * @param chunkSize Chunk size
+   * @return Error code
+   */
+  xtc::XtcError loadPageStreaming(uint32_t pageIndex,
+                                  std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
+                                  size_t chunkSize = 1024) const;
+
+  // Progress calculation
+  uint8_t calculateProgress(uint32_t currentPage) const;
+
+  // Check if file is loaded
+  bool isLoaded() const { return loaded; }
+
+  // Error information
+  xtc::XtcError getLastError() const;
+};

lib/Xtc/Xtc/XtcParser.cpp

@@ -0,0 +1,316 @@
+/**
+ * XtcParser.cpp
+ *
+ * XTC file parsing implementation
+ * XTC ebook support for CrossPoint Reader
+ */
+
+#include "XtcParser.h"
+
+#include <FsHelpers.h>
+#include <HardwareSerial.h>
+
+#include <cstring>
+
+namespace xtc {
+
+XtcParser::XtcParser()
+    : m_isOpen(false),
+      m_defaultWidth(DISPLAY_WIDTH),
+      m_defaultHeight(DISPLAY_HEIGHT),
+      m_bitDepth(1),
+      m_lastError(XtcError::OK) {
+  memset(&m_header, 0, sizeof(m_header));
+}
+
+XtcParser::~XtcParser() { close(); }
+
+XtcError XtcParser::open(const char* filepath) {
+  // Close if already open
+  if (m_isOpen) {
+    close();
+  }
+
+  // Open file
+  if (!FsHelpers::openFileForRead("XTC", filepath, m_file)) {
+    m_lastError = XtcError::FILE_NOT_FOUND;
+    return m_lastError;
+  }
+
+  // Read header
+  m_lastError = readHeader();
+  if (m_lastError != XtcError::OK) {
+    Serial.printf("[%lu] [XTC] Failed to read header: %s\n", millis(), errorToString(m_lastError));
+    m_file.close();
+    return m_lastError;
+  }
+
+  // Read title if available
+  readTitle();
+
+  // Read page table
+  m_lastError = readPageTable();
+  if (m_lastError != XtcError::OK) {
+    Serial.printf("[%lu] [XTC] Failed to read page table: %s\n", millis(), errorToString(m_lastError));
+    m_file.close();
+    return m_lastError;
+  }
+
+  m_isOpen = true;
+  Serial.printf("[%lu] [XTC] Opened file: %s (%u pages, %dx%d)\n", millis(), filepath, m_header.pageCount,
+                m_defaultWidth, m_defaultHeight);
+  return XtcError::OK;
+}
+
+void XtcParser::close() {
+  if (m_isOpen) {
+    m_file.close();
+    m_isOpen = false;
+  }
+  m_pageTable.clear();
+  m_title.clear();
+  memset(&m_header, 0, sizeof(m_header));
+}
+
+XtcError XtcParser::readHeader() {
+  // Read first 56 bytes of header
+  size_t bytesRead = m_file.read(reinterpret_cast<uint8_t*>(&m_header), sizeof(XtcHeader));
+  if (bytesRead != sizeof(XtcHeader)) {
+    return XtcError::READ_ERROR;
+  }
+
+  // Verify magic number (accept both XTC and XTCH)
+  if (m_header.magic != XTC_MAGIC && m_header.magic != XTCH_MAGIC) {
+    Serial.printf("[%lu] [XTC] Invalid magic: 0x%08X (expected 0x%08X or 0x%08X)\n", millis(), m_header.magic,
+                  XTC_MAGIC, XTCH_MAGIC);
+    return XtcError::INVALID_MAGIC;
+  }
+
+  // Determine bit depth from file magic
+  m_bitDepth = (m_header.magic == XTCH_MAGIC) ? 2 : 1;
+
+  // Check version
+  if (m_header.version > 1) {
+    Serial.printf("[%lu] [XTC] Unsupported version: %d\n", millis(), m_header.version);
+    return XtcError::INVALID_VERSION;
+  }
+
+  // Basic validation
+  if (m_header.pageCount == 0) {
+    return XtcError::CORRUPTED_HEADER;
+  }
+
+  Serial.printf("[%lu] [XTC] Header: magic=0x%08X (%s), ver=%u, pages=%u, bitDepth=%u\n", millis(), m_header.magic,
+                (m_header.magic == XTCH_MAGIC) ? "XTCH" : "XTC", m_header.version, m_header.pageCount, m_bitDepth);
+
+  return XtcError::OK;
+}
+
+XtcError XtcParser::readTitle() {
+  // Title is usually at offset 0x38 (56) for 88-byte headers
+  // Read title as null-terminated UTF-8 string
+  if (m_header.titleOffset == 0) {
+    m_header.titleOffset = 0x38;  // Default offset
+  }
+
+  if (!m_file.seek(m_header.titleOffset)) {
+    return XtcError::READ_ERROR;
+  }
+
+  char titleBuf[128] = {0};
+  m_file.read(reinterpret_cast<uint8_t*>(titleBuf), sizeof(titleBuf) - 1);
+  m_title = titleBuf;
+
+  Serial.printf("[%lu] [XTC] Title: %s\n", millis(), m_title.c_str());
+  return XtcError::OK;
+}
+
+XtcError XtcParser::readPageTable() {
+  if (m_header.pageTableOffset == 0) {
+    Serial.printf("[%lu] [XTC] Page table offset is 0, cannot read\n", millis());
+    return XtcError::CORRUPTED_HEADER;
+  }
+
+  // Seek to page table
+  if (!m_file.seek(m_header.pageTableOffset)) {
+    Serial.printf("[%lu] [XTC] Failed to seek to page table at %llu\n", millis(), m_header.pageTableOffset);
+    return XtcError::READ_ERROR;
+  }
+
+  m_pageTable.resize(m_header.pageCount);
+
+  // Read page table entries
+  for (uint16_t i = 0; i < m_header.pageCount; i++) {
+    PageTableEntry entry;
+    size_t bytesRead = m_file.read(reinterpret_cast<uint8_t*>(&entry), sizeof(PageTableEntry));
+    if (bytesRead != sizeof(PageTableEntry)) {
+      Serial.printf("[%lu] [XTC] Failed to read page table entry %u\n", millis(), i);
+      return XtcError::READ_ERROR;
+    }
+
+    m_pageTable[i].offset = static_cast<uint32_t>(entry.dataOffset);
+    m_pageTable[i].size = entry.dataSize;
+    m_pageTable[i].width = entry.width;
+    m_pageTable[i].height = entry.height;
+    m_pageTable[i].bitDepth = m_bitDepth;
+
+    // Update default dimensions from first page
+    if (i == 0) {
+      m_defaultWidth = entry.width;
+      m_defaultHeight = entry.height;
+    }
+  }
+
+  Serial.printf("[%lu] [XTC] Read %u page table entries\n", millis(), m_header.pageCount);
+  return XtcError::OK;
+}
+
+bool XtcParser::getPageInfo(uint32_t pageIndex, PageInfo& info) const {
+  if (pageIndex >= m_pageTable.size()) {
+    return false;
+  }
+  info = m_pageTable[pageIndex];
+  return true;
+}
+
+size_t XtcParser::loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize) {
+  if (!m_isOpen) {
+    m_lastError = XtcError::FILE_NOT_FOUND;
+    return 0;
+  }
+
+  if (pageIndex >= m_header.pageCount) {
+    m_lastError = XtcError::PAGE_OUT_OF_RANGE;
+    return 0;
+  }
+
+  const PageInfo& page = m_pageTable[pageIndex];
+
+  // Seek to page data
+  if (!m_file.seek(page.offset)) {
+    Serial.printf("[%lu] [XTC] Failed to seek to page %u at offset %lu\n", millis(), pageIndex, page.offset);
+    m_lastError = XtcError::READ_ERROR;
+    return 0;
+  }
+
+  // Read page header (XTG for 1-bit, XTH for 2-bit - same structure)
+  XtgPageHeader pageHeader;
+  size_t headerRead = m_file.read(reinterpret_cast<uint8_t*>(&pageHeader), sizeof(XtgPageHeader));
+  if (headerRead != sizeof(XtgPageHeader)) {
+    Serial.printf("[%lu] [XTC] Failed to read page header for page %u\n", millis(), pageIndex);
+    m_lastError = XtcError::READ_ERROR;
+    return 0;
+  }
+
+  // Verify page magic (XTG for 1-bit, XTH for 2-bit)
+  const uint32_t expectedMagic = (m_bitDepth == 2) ? XTH_MAGIC : XTG_MAGIC;
+  if (pageHeader.magic != expectedMagic) {
+    Serial.printf("[%lu] [XTC] Invalid page magic for page %u: 0x%08X (expected 0x%08X)\n", millis(), pageIndex,
+                  pageHeader.magic, expectedMagic);
+    m_lastError = XtcError::INVALID_MAGIC;
+    return 0;
+  }
+
+  // Calculate bitmap size based on bit depth
+  // XTG (1-bit): Row-major, ((width+7)/8) * height bytes
+  // XTH (2-bit): Two bit planes, column-major, ((width * height + 7) / 8) * 2 bytes
+  size_t bitmapSize;
+  if (m_bitDepth == 2) {
+    // XTH: two bit planes, each containing (width * height) bits rounded up to bytes
+    bitmapSize = ((static_cast<size_t>(pageHeader.width) * pageHeader.height + 7) / 8) * 2;
+  } else {
+    bitmapSize = ((pageHeader.width + 7) / 8) * pageHeader.height;
+  }
+
+  // Check buffer size
+  if (bufferSize < bitmapSize) {
+    Serial.printf("[%lu] [XTC] Buffer too small: need %u, have %u\n", millis(), bitmapSize, bufferSize);
+    m_lastError = XtcError::MEMORY_ERROR;
+    return 0;
+  }
+
+  // Read bitmap data
+  size_t bytesRead = m_file.read(buffer, bitmapSize);
+  if (bytesRead != bitmapSize) {
+    Serial.printf("[%lu] [XTC] Page read error: expected %u, got %u\n", millis(), bitmapSize, bytesRead);
+    m_lastError = XtcError::READ_ERROR;
+    return 0;
+  }
+
+  m_lastError = XtcError::OK;
+  return bytesRead;
+}
+
+XtcError XtcParser::loadPageStreaming(uint32_t pageIndex,
+                                      std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
+                                      size_t chunkSize) {
+  if (!m_isOpen) {
+    return XtcError::FILE_NOT_FOUND;
+  }
+
+  if (pageIndex >= m_header.pageCount) {
+    return XtcError::PAGE_OUT_OF_RANGE;
+  }
+
+  const PageInfo& page = m_pageTable[pageIndex];
+
+  // Seek to page data
+  if (!m_file.seek(page.offset)) {
+    return XtcError::READ_ERROR;
+  }
+
+  // Read and skip page header (XTG for 1-bit, XTH for 2-bit)
+  XtgPageHeader pageHeader;
+  size_t headerRead = m_file.read(reinterpret_cast<uint8_t*>(&pageHeader), sizeof(XtgPageHeader));
+  const uint32_t expectedMagic = (m_bitDepth == 2) ? XTH_MAGIC : XTG_MAGIC;
+  if (headerRead != sizeof(XtgPageHeader) || pageHeader.magic != expectedMagic) {
+    return XtcError::READ_ERROR;
+  }
+
+  // Calculate bitmap size based on bit depth
+  // XTG (1-bit): Row-major, ((width+7)/8) * height bytes
+  // XTH (2-bit): Two bit planes, ((width * height + 7) / 8) * 2 bytes
+  size_t bitmapSize;
+  if (m_bitDepth == 2) {
+    bitmapSize = ((static_cast<size_t>(pageHeader.width) * pageHeader.height + 7) / 8) * 2;
+  } else {
+    bitmapSize = ((pageHeader.width + 7) / 8) * pageHeader.height;
+  }
+
+  // Read in chunks
+  std::vector<uint8_t> chunk(chunkSize);
+  size_t totalRead = 0;
+
+  while (totalRead < bitmapSize) {
+    size_t toRead = std::min(chunkSize, bitmapSize - totalRead);
+    size_t bytesRead = m_file.read(chunk.data(), toRead);
+
+    if (bytesRead == 0) {
+      return XtcError::READ_ERROR;
+    }
+
+    callback(chunk.data(), bytesRead, totalRead);
+    totalRead += bytesRead;
+  }
+
+  return XtcError::OK;
+}
+
+bool XtcParser::isValidXtcFile(const char* filepath) {
+  File file = SD.open(filepath, FILE_READ);
+  if (!file) {
+    return false;
+  }
+
+  uint32_t magic = 0;
+  size_t bytesRead = file.read(reinterpret_cast<uint8_t*>(&magic), sizeof(magic));
+  file.close();
+
+  if (bytesRead != sizeof(magic)) {
+    return false;
+  }
+
+  return (magic == XTC_MAGIC || magic == XTCH_MAGIC);
+}
+
+}  // namespace xtc

lib/Xtc/Xtc/XtcParser.h

@@ -0,0 +1,96 @@
+/**
+ * XtcParser.h
+ *
+ * XTC file parsing and page data extraction
+ * XTC ebook support for CrossPoint Reader
+ */
+
+#pragma once
+
+#include <SD.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "XtcTypes.h"
+
+namespace xtc {
+
+/**
+ * XTC File Parser
+ *
+ * Reads XTC files from SD card and extracts page data.
+ * Designed for ESP32-C3's limited RAM (~380KB) using streaming.
+ */
+class XtcParser {
+ public:
+  XtcParser();
+  ~XtcParser();
+
+  // File open/close
+  XtcError open(const char* filepath);
+  void close();
+  bool isOpen() const { return m_isOpen; }
+
+  // Header information access
+  const XtcHeader& getHeader() const { return m_header; }
+  uint16_t getPageCount() const { return m_header.pageCount; }
+  uint16_t getWidth() const { return m_defaultWidth; }
+  uint16_t getHeight() const { return m_defaultHeight; }
+  uint8_t getBitDepth() const { return m_bitDepth; }  // 1 = XTC/XTG, 2 = XTCH/XTH
+
+  // Page information
+  bool getPageInfo(uint32_t pageIndex, PageInfo& info) const;
+
+  /**
+   * Load page bitmap (raw 1-bit data, skipping XTG header)
+   *
+   * @param pageIndex Page index (0-based)
+   * @param buffer Output buffer (caller allocated)
+   * @param bufferSize Buffer size
+   * @return Number of bytes read on success, 0 on failure
+   */
+  size_t loadPage(uint32_t pageIndex, uint8_t* buffer, size_t bufferSize);
+
+  /**
+   * Streaming page load
+   * Memory-efficient method that reads page data in chunks.
+   *
+   * @param pageIndex Page index
+   * @param callback Callback function to receive data chunks
+   * @param chunkSize Chunk size (default: 1024 bytes)
+   * @return Error code
+   */
+  XtcError loadPageStreaming(uint32_t pageIndex,
+                             std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
+                             size_t chunkSize = 1024);
+
+  // Get title from metadata
+  std::string getTitle() const { return m_title; }
+
+  // Validation
+  static bool isValidXtcFile(const char* filepath);
+
+  // Error information
+  XtcError getLastError() const { return m_lastError; }
+
+ private:
+  File m_file;
+  bool m_isOpen;
+  XtcHeader m_header;
+  std::vector<PageInfo> m_pageTable;
+  std::string m_title;
+  uint16_t m_defaultWidth;
+  uint16_t m_defaultHeight;
+  uint8_t m_bitDepth;  // 1 = XTC/XTG (1-bit), 2 = XTCH/XTH (2-bit)
+  XtcError m_lastError;
+
+  // Internal helper functions
+  XtcError readHeader();
+  XtcError readPageTable();
+  XtcError readTitle();
+};
+
+}  // namespace xtc

lib/Xtc/Xtc/XtcTypes.h

@@ -0,0 +1,147 @@
+/**
+ * XtcTypes.h
+ *
+ * XTC file format type definitions
+ * XTC ebook support for CrossPoint Reader
+ *
+ * XTC is the native binary ebook format for XTeink X4 e-reader.
+ * It stores pre-rendered bitmap images per page.
+ *
+ * Format based on EPUB2XTC converter by Rafal-P-Mazur
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace xtc {
+
+// XTC file magic numbers (little-endian)
+// "XTC\0" = 0x58, 0x54, 0x43, 0x00
+constexpr uint32_t XTC_MAGIC = 0x00435458;  // "XTC\0" in little-endian (1-bit fast mode)
+// "XTCH" = 0x58, 0x54, 0x43, 0x48
+constexpr uint32_t XTCH_MAGIC = 0x48435458;  // "XTCH" in little-endian (2-bit high quality mode)
+// "XTG\0" = 0x58, 0x54, 0x47, 0x00
+constexpr uint32_t XTG_MAGIC = 0x00475458;  // "XTG\0" for 1-bit page data
+// "XTH\0" = 0x58, 0x54, 0x48, 0x00
+constexpr uint32_t XTH_MAGIC = 0x00485458;  // "XTH\0" for 2-bit page data
+
+// XTeink X4 display resolution
+constexpr uint16_t DISPLAY_WIDTH = 480;
+constexpr uint16_t DISPLAY_HEIGHT = 800;
+
+// XTC file header (56 bytes)
+#pragma pack(push, 1)
+struct XtcHeader {
+  uint32_t magic;            // 0x00: Magic number "XTC\0" (0x00435458)
+  uint16_t version;          // 0x04: Format version (typically 1)
+  uint16_t pageCount;        // 0x06: Total page count
+  uint32_t flags;            // 0x08: Flags/reserved
+  uint32_t headerSize;       // 0x0C: Size of header section (typically 88)
+  uint32_t reserved1;        // 0x10: Reserved
+  uint32_t tocOffset;        // 0x14: TOC offset (0 if unused) - 4 bytes, not 8!
+  uint64_t pageTableOffset;  // 0x18: Page table offset
+  uint64_t dataOffset;       // 0x20: First page data offset
+  uint64_t reserved2;        // 0x28: Reserved
+  uint32_t titleOffset;      // 0x30: Title string offset
+  uint32_t padding;          // 0x34: Padding to 56 bytes
+};
+#pragma pack(pop)
+
+// Page table entry (16 bytes per page)
+#pragma pack(push, 1)
+struct PageTableEntry {
+  uint64_t dataOffset;  // 0x00: Absolute offset to page data
+  uint32_t dataSize;    // 0x08: Page data size in bytes
+  uint16_t width;       // 0x0C: Page width (480)
+  uint16_t height;      // 0x0E: Page height (800)
+};
+#pragma pack(pop)
+
+// XTG/XTH page data header (22 bytes)
+// Used for both 1-bit (XTG) and 2-bit (XTH) formats
+#pragma pack(push, 1)
+struct XtgPageHeader {
+  uint32_t magic;       // 0x00: File identifier (XTG: 0x00475458, XTH: 0x00485458)
+  uint16_t width;       // 0x04: Image width (pixels)
+  uint16_t height;      // 0x06: Image height (pixels)
+  uint8_t colorMode;    // 0x08: Color mode (0=monochrome)
+  uint8_t compression;  // 0x09: Compression (0=uncompressed)
+  uint32_t dataSize;    // 0x0A: Image data size (bytes)
+  uint64_t md5;         // 0x0E: MD5 checksum (first 8 bytes, optional)
+  // Followed by bitmap data at offset 0x16 (22)
+  //
+  // XTG (1-bit): Row-major, 8 pixels/byte, MSB first
+  //   dataSize = ((width + 7) / 8) * height
+  //
+  // XTH (2-bit): Two bit planes, column-major (right-to-left), 8 vertical pixels/byte
+  //   dataSize = ((width * height + 7) / 8) * 2
+  //   First plane: Bit1 for all pixels
+  //   Second plane: Bit2 for all pixels
+  //   pixelValue = (bit1 << 1) | bit2
+};
+#pragma pack(pop)
+
+// Page information (internal use, optimized for memory)
+struct PageInfo {
+  uint32_t offset;   // File offset to page data (max 4GB file size)
+  uint32_t size;     // Data size (bytes)
+  uint16_t width;    // Page width
+  uint16_t height;   // Page height
+  uint8_t bitDepth;  // 1 = XTG (1-bit), 2 = XTH (2-bit grayscale)
+  uint8_t padding;   // Alignment padding
+};  // 16 bytes total
+
+// Error codes
+enum class XtcError {
+  OK = 0,
+  FILE_NOT_FOUND,
+  INVALID_MAGIC,
+  INVALID_VERSION,
+  CORRUPTED_HEADER,
+  PAGE_OUT_OF_RANGE,
+  READ_ERROR,
+  WRITE_ERROR,
+  MEMORY_ERROR,
+  DECOMPRESSION_ERROR,
+};
+
+// Convert error code to string
+inline const char* errorToString(XtcError err) {
+  switch (err) {
+    case XtcError::OK:
+      return "OK";
+    case XtcError::FILE_NOT_FOUND:
+      return "File not found";
+    case XtcError::INVALID_MAGIC:
+      return "Invalid magic number";
+    case XtcError::INVALID_VERSION:
+      return "Unsupported version";
+    case XtcError::CORRUPTED_HEADER:
+      return "Corrupted header";
+    case XtcError::PAGE_OUT_OF_RANGE:
+      return "Page out of range";
+    case XtcError::READ_ERROR:
+      return "Read error";
+    case XtcError::WRITE_ERROR:
+      return "Write error";
+    case XtcError::MEMORY_ERROR:
+      return "Memory allocation error";
+    case XtcError::DECOMPRESSION_ERROR:
+      return "Decompression error";
+    default:
+      return "Unknown error";
+  }
+}
+
+/**
+ * Check if filename has XTC/XTCH extension
+ */
+inline bool isXtcExtension(const char* filename) {
+  if (!filename) return false;
+  const char* ext = strrchr(filename, '.');
+  if (!ext) return false;
+  return (strcasecmp(ext, ".xtc") == 0 || strcasecmp(ext, ".xtch") == 0);
+}
+
+}  // namespace xtc