osakanataro · osakanataro · Sep 28, 2026 · Sep 28, 2026 · Sep 28, 2026 · Sep 28, 2026
diff --git a/lib/EpdFont/EpdFontFamily.h b/lib/EpdFont/EpdFontFamily.h
@@ -17,6 +17,11 @@ class EpdFontFamily {
     SUP = 16,            // superscript: glyph scaled 50%, raised ~40% of ascender
     SUB = 32,            // subscript: glyph scaled 50%, lowered ~25% of ascender
     RUBY_CONTINUE = 64,  // Group ruby follower marker (used internally by Epub layout)
+    // Vertical layout only: the token is set the opposite way from what its text implies
+    // (an ASCII letter upright, a fullwidth ！ turned, a Latin run in one tate-chu-yoko
+    // cell). Carries CSS text-orientation / text-combine-upright through the page cache
+    // without a per-word behaviour array; TextBlock::renderVertical reads it, nothing else.
+    VERTICAL_FLIP = 128,
   };
   static constexpr uint8_t TEXT_DECORATION_MASK = static_cast<uint8_t>(UNDERLINE | STRIKETHROUGH);
 

diff --git a/lib/EpdFont/SdCardFont.cpp b/lib/EpdFont/SdCardFont.cpp
diff --git a/lib/EpdFont/SdCardFont.h b/lib/EpdFont/SdCardFont.h
@@ -1,12 +1,15 @@
 #pragma once
 
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "EpdFont.h"
 #include "EpdFontData.h"
 
+class HalFile;
+
 // On-disk binary format version for .cpfont files. Defined as a preprocessor
 // macro (rather than a constexpr) so it can be stringified into the SD-fonts
 // release URL — see FONT_MANIFEST_URL in FontDownloadActivity.h. No integer
@@ -21,11 +24,20 @@
 class SdCardFont {
  public:
   static constexpr uint16_t MAX_PAGE_GLYPHS = 512;
-  // prewarmStyle: the bitmap arena did not fit the largest free block.
-  // Distinct from a missed-glyph count so the caller can retry smaller.
-  static constexpr int PREWARM_ARENA_TOO_LARGE = -2;
   static constexpr uint8_t MAX_STYLES = 4;
 
+  // Recent frees of a style's mini arena, for INPUT_DIAG (who dropped the page's glyphs, and when).
+  struct MiniFreeEvent {
+    uint32_t caller = 0;
+    uint32_t ms = 0;
+    uint32_t freeHeap = 0;
+    uint16_t glyphs = 0;
+    uint8_t style = 0;
+    bool metadataOnly = false;
+  };
+  static constexpr uint8_t MINI_FREE_EVENTS = 4;
+  static const MiniFreeEvent* miniFreeEvents(uint32_t& total);
+
   SdCardFont() = default;
   ~SdCardFont();
   // Owns raw buffers freed in dtor — no shallow-copy semantics. Make any
@@ -38,7 +50,19 @@ class SdCardFont {
   // Load .cpfont file: reads header + intervals into RAM, records file layout offsets.
   // Supports v4 (multi-style) format.
   // Returns true on success.
-  bool load(const char* path);
+  // isReaderFont: the family's body-text size (its first load), reported by INPUT_DIAG.
+  // scaleNum/scaleDen: every glyph record (width, height, bearings, advance) and bitmap is
+  // scaled by this ratio as it enters the resident caches, and the style's line metrics at
+  // load, so the renderer sees a font of the scaled size. 1/1 = the file as it is. Only 2-bit
+  // fonts are scaled; a 1-bit font ignores the ratio. Kerning values are not scaled (the CJK
+  // fonts this is for carry none).
+  // preferFlash: read through the copy in the inactive OTA slot (SdCardFontCache) when it holds
+  // this very file; otherwise, and for any range the copy does not hold, the SD card is read.
+  bool load(const char* path, bool isReaderFont = false, uint8_t scaleNum = 1, uint8_t scaleDen = 1,
+            bool preferFlash = false);
+  // True while reads are served from the flash copy (a read failure turns it off for good).
+  bool usingFlash() const { return useFlash_; }
+  size_t flashPayloadBytes() const { return flashPayloadBytes_; }
 
   // Pre-read glyphs needed for the given UTF-8 text from SD card.
   // styleMask: bitmask of styles to prewarm (bit 0=regular, 1=bold, 2=italic, 3=bolditalic).
@@ -81,6 +105,12 @@ class SdCardFont {
   // Look up advanceX for a codepoint from the advance table.
   // Returns the 12.4 fixed-point advance, or 0 if not found.
   uint16_t getAdvance(uint32_t codepoint, uint8_t style) const;
+  // Advance of one codepoint the table does not hold, without loading its bitmap: the resident
+  // arena, then the overflow ring, then the 12-byte glyph record straight from the card. 0 when
+  // the font has no such glyph (or the read failed), so callers can fall back to a full load.
+  uint16_t readAdvanceOnly(uint32_t codepoint, uint8_t styleIdx) const;
+  // Close the file readAdvanceOnly keeps open for the duration of a measuring pass.
+  void closeMeasureFile() const;
 
   // Returns true if advance table is populated for at least one style.
   bool hasAdvanceTable() const;
@@ -126,6 +156,12 @@ class SdCardFont {
   // Returns the bitmap for an on-demand-loaded (overflow) glyph.
   const uint8_t* getOverflowBitmap(const EpdGlyph* glyph) const;
 
+  // Resolves a prewarmed mini glyph's chunked bitmap. `ctx` is the glyphMissCtx
+  // (an OverflowContext identifying the style); `dataOffset` is the glyph's
+  // virtual offset into the style's chunked arena. Returns nullptr if the chunk
+  // is absent or out of range. Called by GfxRenderer::getGlyphBitmap().
+  const uint8_t* miniGlyphBitmap(const void* ctx, uint32_t dataOffset) const;
+
   // Extract SdCardFont* from an opaque glyphMissCtx pointer.
   // Used by GfxRenderer::getGlyphBitmap() to recover the SdCardFont from EpdFontData::glyphMissCtx.
   static SdCardFont* fromMissCtx(void* ctx);
@@ -141,6 +177,30 @@ class SdCardFont {
   void resetStats();
   const Stats& getStats() const { return stats_; }
 
+  // Counters for INPUT_DIAG. Glyphs read one at a time through the overflow ring because no
+  // prewarm covered them; mini-arena rebuilds (the reads go straight into the arena, so no other
+  // figure records them) and their time; prewarms that bailed before any style was touched; and
+  // the advance-table work a section build spends its font time on.
+  uint32_t overflowLoads() const { return overflowLoads_; }
+  uint32_t miniRebuilds() const { return miniRebuilds_; }
+  uint32_t miniRebuildMs() const { return miniRebuildMs_; }
+  uint32_t prewarmEntryFails() const { return prewarmEntryFails_; }
+  uint32_t advanceFetchCalls() const { return advanceFetchCalls_; }
+  uint32_t advanceFetchMs() const { return advanceFetchMs_; }
+  uint32_t advanceFullSkips() const { return advanceFullSkips_; }
+  // readAdvanceOnly: calls, the ones that had to read the card, and the time those reads took.
+  uint32_t advanceOnlyCalls() const { return advanceOnlyCalls_; }
+  uint32_t advanceOnlySdReads() const { return advanceOnlySdReads_; }
+  uint32_t advanceOnlyMs() const { return advanceOnlyMs_; }
+  uint32_t advanceTableMax() const {
+    uint32_t largest = 0;
+    for (uint8_t i = 0; i < MAX_STYLES; i++) {
+      if (advanceTableSize_[i] > largest) largest = advanceTableSize_[i];
+    }
+    return largest;
+  }
+  static constexpr uint32_t advanceTableLimit() { return ADVANCE_CACHE_LIMIT; }
+
   // Content hash of the file header + style TOC entries (computed during load).
   // Used to generate deterministic font IDs for section cache invalidation.
   uint32_t contentHash() const { return contentHash_; }
@@ -162,6 +222,16 @@ class SdCardFont {
   };
 
   // All per-style data: file offsets, intervals, kern/lig, prewarm cache, EpdFont
+  // The per-style mini bitmap arena is stored as a list of fixed-size chunks
+  // instead of one contiguous block: a fragmented heap routinely has the bytes
+  // but not one block large enough for a page's glyphs, and a failed arena sent
+  // every glyph through the 8-slot overflow ring. Each glyph's bitmap is placed
+  // wholly within one chunk (never straddling); its EpdGlyph::dataOffset is a
+  // virtual offset that maps to (chunk index, offset-in-chunk) via miniGlyphBitmap().
+  static constexpr uint32_t MINI_BM_CHUNK_SHIFT = 12;  // 4 KB chunks
+  static constexpr uint32_t MINI_BM_CHUNK_SIZE = 1u << MINI_BM_CHUNK_SHIFT;
+  static constexpr uint32_t MINI_BM_MAX_CHUNKS = 24;  // 96 KB ceiling per style/page
+
   struct PerStyle {
     CpFontHeader header{};
 
@@ -225,18 +295,20 @@ class SdCardFont {
     EpdFontData miniData{};
     EpdUnicodeInterval* miniIntervals = nullptr;
     EpdGlyph* miniGlyphs = nullptr;
-    uint8_t* miniBitmap = nullptr;
+    // Chunked mini bitmap arena (see MINI_BM_CHUNK_* above). Chunks are allocated
+    // on demand during prewarm and kept for reuse; miniBitmapChunkCount is how many are live.
+    uint8_t* miniBitmapChunks[MINI_BM_MAX_CHUNKS] = {};
+    uint32_t miniBitmapChunkCount = 0;
     uint32_t miniIntervalCount = 0;
     uint32_t miniGlyphCount = 0;
     uint32_t miniIntervalCapacity = 0;
     uint32_t miniGlyphCapacity = 0;
+    // Bytes held by the live chunks (miniBitmapChunkCount * MINI_BM_CHUNK_SIZE).
     uint32_t miniBitmapCapacity = 0;
     // Bitmap bytes the current page actually used (set by prewarmStyle), the
     // underuse-hysteresis signal; 0 = no bitmap built this scope (metadata-only
     // prewarm), which leaves the hysteresis counter untouched.
     uint32_t miniBitmapUsed = 0;
-    // Exact bitmap bytes per glyph of the last requested set, for the arena retry.
-    uint32_t measuredBytesPerGlyph = 0;
     uint8_t miniUnderuseRuns = 0;
     // True when the resident mini was built metadata-only (no bitmaps): it can
     // serve metadata requests but a full render request must rebuild.
@@ -274,6 +346,34 @@ class SdCardFont {
   uint8_t styleCount_ = 0;
 
   char filePath_[128] = {};
+  // Flash copy state (see load()). Mutable: the const read paths flip it off on a read failure.
+  mutable bool useFlash_ = false;
+  size_t flashPayloadBytes_ = 0;
+  bool loadSelectedSource(bool isReaderFont, uint8_t scaleNum, uint8_t scaleDen);
+
+  // Glyph scale applied on the way into the resident caches (see load()).
+  uint8_t scaleNum_ = 1;
+  uint8_t scaleDen_ = 1;
+  bool isScaled() const { return scaleNum_ != scaleDen_; }
+  // Nearest for bearings, ascender/descender and advances.
+  int16_t scaledBearing(int16_t v) const;
+  uint16_t scaleAdvance(uint16_t advanceFP) const;
+  // The scaled glyph box: the source box's edges multiplied by the exact ratio and rounded
+  // outward, so the ink keeps its scaled position inside it (never clipped, never shifted).
+  struct ScaledBox {
+    int16_t left;
+    int16_t top;
+    uint16_t width;
+    uint16_t height;
+  };
+  ScaledBox scaledBox(const EpdGlyph& g) const;
+  // width/height/left/top/advanceX only; dataLength/dataOffset are the caller's.
+  void scaleGlyphMetrics(EpdGlyph& g) const;
+  static uint32_t bitmapBytes2Bit(uint32_t w, uint32_t h) { return (w * h + 3) / 4; }
+  // Bilinear resample of a packed 2-bit (4 levels) glyph bitmap `src` (box `g`, unscaled) into
+  // `dst` (box `box` = scaledBox(g)) at exactly scaleNum_/scaleDen_; dst must hold
+  // bitmapBytes2Bit(box.width, box.height) bytes and is fully written.
+  void resampleBitmap2Bit(const uint8_t* src, const EpdGlyph& g, uint8_t* dst, const ScaledBox& box) const;
 
   // Overflow context: glyphMissHandler needs to know which style it's serving
   struct OverflowContext {
@@ -313,6 +413,26 @@ class SdCardFont {
   void mergeIntoAdvanceTable(uint8_t styleIdx, const AdvanceEntry* sortedNew, uint32_t newCount);
 
   Stats stats_;
+  uint32_t overflowLoads_ = 0;
+  uint32_t miniRebuilds_ = 0;
+  uint32_t miniRebuildMs_ = 0;
+  uint32_t prewarmEntryFails_ = 0;
+  uint32_t advanceFetchCalls_ = 0;
+  uint32_t advanceFetchMs_ = 0;
+  uint32_t advanceFullSkips_ = 0;
+  mutable uint32_t advanceOnlyCalls_ = 0;
+  mutable uint32_t advanceOnlySdReads_ = 0;
+  mutable uint32_t advanceOnlyMs_ = 0;
+  // Kept open across readAdvanceOnly calls while a build measures (closed by closeMeasureFile):
+  // opening the file by its long name was nearly all of each 3.9 ms read.
+  mutable std::unique_ptr<HalFile> measureFile_;
+  // Widths readAdvanceOnly already read from the card during this measuring pass, direct-mapped
+  // by codepoint (key = codepoint | style << 22 | valid bit). A chapter repeats its characters, so
+  // most calls past the full advance table are for a character read moments before. 3 KB, freed
+  // with the file.
+  static constexpr uint32_t MEASURE_MEMO_SLOTS = 512;
+  mutable std::unique_ptr<uint32_t[]> measureMemoKeys_;
+  mutable std::unique_ptr<uint16_t[]> measureMemoAdvances_;
   uint32_t contentHash_ = 0;
   bool loaded_ = false;
 
@@ -331,6 +451,13 @@ class SdCardFont {
   void applyGlyphMissCallback(uint8_t styleIdx);
   int32_t findGlobalGlyphIndex(const PerStyle& s, uint32_t codepoint) const;
   int fetchAdvancesForCodepoints(uint32_t* codepoints, uint32_t cpCount, uint8_t styleMask);
+  // prewarmStyle's return when the chunked arena could not hold the whole set (a chunk
+  // allocation failed or MINI_BM_MAX_CHUNKS was reached). The style is left freed and
+  // arenaFitGlyphs_ holds how many of its validGlyphs_ glyphs were placed first, which
+  // prewarm() uses to size a smaller retry.
+  static constexpr int PREWARM_ARENA_TOO_LARGE = -2;
+  uint32_t arenaFitGlyphs_ = 0;
+  uint32_t arenaValidGlyphs_ = 0;
   int prewarmStyle(uint8_t styleIdx, const uint32_t* codepoints, uint32_t cpCount, bool metadataOnly, bool loadKernLig,
                    bool accumulate);