feat: 1614 lut pxc

lib/Epub/Epub/blocks/ImageBlock.cpp

@@ -74,13 +74,13 @@ bool renderFromCache(GfxRenderer& renderer, const std::string& cachePath, int x,
     }
 
     const int destY = y + row;
-    pw.beginRow(destY);
+    pw.beginRow(destY, x);
     for (int col = 0; col < cachedWidth; col++) {
       const int byteIdx = col >> 2;            // col / 4
       const int bitShift = 6 - (col & 3) * 2;  // MSB first within byte
       uint8_t pixelValue = (rowBuffer[byteIdx] >> bitShift) & 0x03;
 
-      pw.writePixel(x + col, pixelValue);
+      pw.writePixel(pixelValue);
     }
   }
 

lib/Epub/Epub/converters/DirectPixelWriter.h

@@ -6,16 +6,26 @@
 
 // Direct framebuffer writer that eliminates per-pixel overhead from the image
 // rendering hot path.  Pre-computes orientation transform as linear coefficients
-// and caches render-mode state so the inner loop is: one multiply, one add,
-// one shift, and one AND per pixel — no branches, no method calls.
+// and caches render-mode state so the inner loop is: two increments, one shift,
+// one AND, and one or two bit-writes per pixel — no multiplies, no branches on
+// mode or orientation, no method calls.
 //
-// Caller is responsible for ensuring (outX, outY) are within screen bounds.
-// ImageBlock::render() already validates this before entering the pixel loop,
-// and the JPEG/PNG callbacks pre-clamp destination ranges to screen bounds.
+// Usage:
+//   pw.init(renderer);
+//   for each row: pw.beginRow(logicalY);   // resets running X/Y state to col 0
+//   for each col: pw.writePixel(value);    // advances running state, writes bit
+//
+// Caller must call writePixel() for every column in order (0, 1, 2, …) because
+// the running state is advanced unconditionally on each call.  Caller is also
+// responsible for ensuring columns are within screen bounds before entering the
+// loop; no bounds checking is performed here.
 struct DirectPixelWriter {
   uint8_t* fb;
-  GfxRenderer::RenderMode mode;
-  uint16_t displayWidthBytes;  // Runtime framebuffer stride (X4: 100, X3: 99)
+  uint8_t* fb2;                // Secondary framebuffer for MSB plane (null = two-pass / not active)
+  uint8_t writeFbMask;         // Bit i set → write to fb when pixelValue==i (pre-computed from render mode)
+  uint8_t writeFb2Mask;        // Bit i set → write to fb2 when pixelValue==i
+  bool fbClearBit;             // true = clear bit (BW black); false = set bit (all gray modes)
+  uint16_t displayWidthBytes;  // Runtime framebuffer stride
 
   // Orientation is collapsed into a linear transform:
   //   phyX = phyXBase + x * phyXStepX + y * phyXStepY
@@ -24,14 +34,44 @@ struct DirectPixelWriter {
   int phyXStepX, phyYStepX;  // per logical-X step
   int phyXStepY, phyYStepY;  // per logical-Y step
 
-  // Row-precomputed: the Y-dependent portion of the physical coords
-  int rowPhyXBase, rowPhyYBase;
+  // Pre-computed once in init(): physical-Y advance per logical-X step (in byte-index units).
+  int32_t byteIdxYStep;
+
+  // Running state — reset by beginRow(), advanced by writePixel().
+  int curPhyX;
+  int32_t curByteIdx;
 
-  void init(GfxRenderer& renderer) {
+  void init(const GfxRenderer& renderer) {
     fb = renderer.getFrameBuffer();
-    mode = renderer.getRenderMode();
+    fb2 = renderer.getSecondaryFrameBuffer();
     displayWidthBytes = renderer.getDisplayWidthBytes();
 
+    // Pre-compute write masks once so the inner loop has zero mode branches.
+    writeFbMask = 0;
+    writeFb2Mask = 0;
+    fbClearBit = false;
+    switch (renderer.getRenderMode()) {
+      case GfxRenderer::BW:
+        writeFbMask = 0x3;
+        fbClearBit = true;
+        break;
+      case GfxRenderer::GRAYSCALE_MSB:
+        writeFbMask = 0x6;
+        break;
+      case GfxRenderer::GRAYSCALE_LSB:
+        writeFbMask = 0x2;
+        break;
+      case GfxRenderer::GRAY2_LSB:
+        writeFbMask = 0x5;
+        if (fb2) writeFb2Mask = 0x3;
+        break;
+      case GfxRenderer::GRAY2_MSB:
+        writeFbMask = 0x3;
+        break;
+      default:
+        break;
+    }
+
     const int phyW = renderer.getDisplayWidth();
     const int phyH = renderer.getDisplayHeight();
 
@@ -82,52 +122,47 @@ struct DirectPixelWriter {
         phyYStepY = 1;
         break;
     }
+
+    // Per-column advance in physical-Y expressed as a byte-index delta.
+    byteIdxYStep = static_cast<int32_t>(phyYStepX) * static_cast<int32_t>(displayWidthBytes);
   }
 
   // Call once per row before the column loop.
-  // Pre-computes the Y-dependent portion so writePixel() only needs the X part.
-  inline void beginRow(int logicalY) {
-    rowPhyXBase = phyXBase + logicalY * phyXStepY;
-    rowPhyYBase = phyYBase + logicalY * phyYStepY;
+  // startLogicalX is the X coordinate of the first writePixel() call for this row (default 0).
+  // Running state is initialised at startLogicalX so every subsequent writePixel() call
+  // advances to startLogicalX+1, startLogicalX+2, … with zero per-pixel multiplies.
+  inline void beginRow(int logicalY, int startLogicalX = 0) {
+    const int rowPhyXBase = phyXBase + logicalY * phyXStepY;
+    const int rowPhyYBase = phyYBase + logicalY * phyYStepY;
+    curPhyX = rowPhyXBase + startLogicalX * phyXStepX;
+    curByteIdx =
+        static_cast<int32_t>(rowPhyYBase + startLogicalX * phyYStepX) * static_cast<int32_t>(displayWidthBytes);
   }
 
-  // Write a single 2-bit dithered pixel value to the framebuffer.
-  // Must be called after beginRow() for the current row.
+  // Write a single 2-bit pixel value to the framebuffer and advance to the next column.
+  // Must be called after beginRow() for the current row, for every column in order.
   // No bounds checking — caller guarantees coordinates are valid.
-  inline void writePixel(int logicalX, uint8_t pixelValue) const {
-    // Determine whether to draw based on render mode
-    bool draw;
-    bool state;
-    switch (mode) {
-      case GfxRenderer::BW:
-        draw = (pixelValue < 3);
-        state = true;
-        break;
-      case GfxRenderer::GRAYSCALE_MSB:
-        draw = (pixelValue == 1 || pixelValue == 2);
-        state = false;
-        break;
-      case GfxRenderer::GRAYSCALE_LSB:
-        draw = (pixelValue == 1);
-        state = false;
-        break;
-      default:
-        return;
-    }
-
-    if (!draw) return;
-
-    const int phyX = rowPhyXBase + logicalX * phyXStepX;
-    const int phyY = rowPhyYBase + logicalX * phyYStepX;
-
-    const uint16_t byteIndex = phyY * displayWidthBytes + (phyX >> 3);
+  // No mode switch — write masks are pre-computed in init() and stored as members.
+  inline void writePixel(uint8_t pixelValue) {
+    const int phyX = curPhyX;
+    const int32_t byteIdx = curByteIdx;
+    curPhyX += phyXStepX;
+    curByteIdx += byteIdxYStep;
+
+    const bool doFb = (writeFbMask >> pixelValue) & 1;
+    const bool doFb2 = (writeFb2Mask >> pixelValue) & 1;
+    if (!doFb && !doFb2) return;
+
+    const uint32_t bi = static_cast<uint32_t>(byteIdx) + static_cast<uint32_t>(phyX >> 3);
     const uint8_t bitMask = 1 << (7 - (phyX & 7));
 
-    if (state) {
-      fb[byteIndex] &= ~bitMask;  // Clear bit (draw black)
-    } else {
-      fb[byteIndex] |= bitMask;  // Set bit (draw white)
+    if (doFb) {
+      if (fbClearBit)
+        fb[bi] &= ~bitMask;
+      else
+        fb[bi] |= bitMask;
     }
+    if (doFb2) fb2[bi] |= bitMask;
   }
 };
 

lib/Epub/Epub/converters/DitherUtils.h

@@ -13,15 +13,30 @@ inline const uint8_t bayer4x4[4][4] = {
 // Apply Bayer dithering and quantize to 4 levels (0-3)
 // Stateless - works correctly with any pixel processing order
 inline uint8_t applyBayerDither4Level(uint8_t gray, int x, int y) {
+  // Soft-shoulder darkening for factory LUT: EPUB image pages render on the
+  // factory LUT, where palette levels are physically lighter than on the
+  // differential LUT. Apply a -8 offset to mid-bright pixels onward to bring
+  // highlights/midtones back down without crushing deep shadow detail.
+  // Ramp the offset from 0 to 8 across gray [0, 64], flat -8 above 64.
+  int g = gray;
+  int offset = (g < 64) ? g * 8 / 64 : 8;
+  g -= offset;
+
   int bayer = bayer4x4[y & 3][x & 3];
   int dither = (bayer - 8) * 5;  // Scale to +/-40 (half of quantization step 85)
 
-  int adjusted = gray + dither;
+  int adjusted = g + dither;
   if (adjusted < 0) adjusted = 0;
   if (adjusted > 255) adjusted = 255;
 
-  if (adjusted < 64) return 0;
-  if (adjusted < 128) return 1;
-  if (adjusted < 192) return 2;
+  // T01=48: slightly above original 43, keeps shadow detail while allowing
+  // near-black pixels to lift to dark gray.
+  // T12=133: raised from 128 to push more mid-bright source pixels into the
+  // palette 1 / palette 2 dither zone for perceptual mid-gray.
+  // T23=218: raised from 192 to expand light-gray range, preserving
+  // highlight detail on the brighter factory LUT.
+  if (adjusted < 48) return 0;
+  if (adjusted < 133) return 1;
+  if (adjusted < 218) return 2;
   return 3;
 }

lib/Epub/Epub/converters/JpegToFramebufferConverter.cpp

@@ -176,7 +176,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
   if (fineScaleFPX == FP_ONE && fineScaleFPY == FP_ONE) {
     for (int dstY = dstYStart; dstY < dstYEnd; dstY++) {
       const int outY = cfgY + dstY;
-      pw.beginRow(outY);
+      pw.beginRow(outY, cfgX + dstXStart);
       if (caching) cw.beginRow(outY, ctx->config->y);
       const uint8_t* row = &pixels[(dstY - blockY) * stride];
       for (int dstX = dstXStart; dstX < dstXEnd; dstX++) {
@@ -189,7 +189,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
           dithered = gray / 85;
           if (dithered > 3) dithered = 3;
         }
-        pw.writePixel(outX, dithered);
+        pw.writePixel(dithered);
         if (caching) cw.writePixel(outX, dithered);
       }
     }
@@ -210,7 +210,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
 
     for (int dstY = dstYStart; dstY < dstYEnd; dstY++) {
       const int outY = cfgY + dstY;
-      pw.beginRow(outY);
+      pw.beginRow(outY, cfgX + dstXStart);
       if (caching) cw.beginRow(outY, ctx->config->y);
       const int32_t srcFyFP = dstY * invScaleFPY;
       const int32_t fy = srcFyFP & FP_MASK;
@@ -248,7 +248,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
           dithered = gray / 85;
           if (dithered > 3) dithered = 3;
         }
-        pw.writePixel(outX, dithered);
+        pw.writePixel(dithered);
         if (caching) cw.writePixel(outX, dithered);
       }
 
@@ -271,7 +271,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
           dithered = gray / 85;
           if (dithered > 3) dithered = 3;
         }
-        pw.writePixel(outX, dithered);
+        pw.writePixel(dithered);
         if (caching) cw.writePixel(outX, dithered);
       }
 
@@ -297,7 +297,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
           dithered = gray / 85;
           if (dithered > 3) dithered = 3;
         }
-        pw.writePixel(outX, dithered);
+        pw.writePixel(dithered);
         if (caching) cw.writePixel(outX, dithered);
       }
     }
@@ -307,7 +307,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
   // === Nearest-neighbor (downscale: fineScale < 1.0) ===
   for (int dstY = dstYStart; dstY < dstYEnd; dstY++) {
     const int outY = cfgY + dstY;
-    pw.beginRow(outY);
+    pw.beginRow(outY, cfgX + dstXStart);
     if (caching) cw.beginRow(outY, ctx->config->y);
     const int32_t srcFyFP = dstY * invScaleFPY;
     int ly = (srcFyFP >> FP_SHIFT) - blockY;
@@ -330,7 +330,7 @@ int jpegDrawCallback(JPEGDRAW* pDraw) {
         dithered = gray / 85;
         if (dithered > 3) dithered = 3;
       }
-      pw.writePixel(outX, dithered);
+      pw.writePixel(dithered);
       if (caching) cw.writePixel(outX, dithered);
     }
   }

lib/Epub/Epub/converters/PngToFramebufferConverter.cpp

@@ -197,7 +197,7 @@ int pngDrawCallback(PNGDRAW* pDraw) {
   // Pre-compute orientation and render-mode state once per row
   DirectPixelWriter pw;
   pw.init(*ctx->renderer);
-  pw.beginRow(outY);
+  pw.beginRow(outY, outXBase);
 
   DirectCacheWriter cw;
   if (caching) {
@@ -220,7 +220,7 @@ int pngDrawCallback(PNGDRAW* pDraw) {
         ditheredGray = gray / 85;
         if (ditheredGray > 3) ditheredGray = 3;
       }
-      pw.writePixel(outX, ditheredGray);
+      pw.writePixel(ditheredGray);
       if (caching) cw.writePixel(outX, ditheredGray);
     }
 

lib/FsHelpers/FsHelpers.cpp

@@ -119,6 +119,8 @@ bool hasPngExtension(std::string_view fileName) { return checkFileExtension(file
 
 bool hasBmpExtension(std::string_view fileName) { return checkFileExtension(fileName, ".bmp"); }
 
+bool hasPxcExtension(std::string_view fileName) { return checkFileExtension(fileName, ".pxc"); }
+
 bool hasGifExtension(std::string_view fileName) { return checkFileExtension(fileName, ".gif"); }
 
 bool hasEpubExtension(std::string_view fileName) { return checkFileExtension(fileName, ".epub"); }

lib/FsHelpers/FsHelpers.h

@@ -34,6 +34,9 @@ inline bool hasPngExtension(const String& fileName) {
 // Check for .bmp extension (case-insensitive)
 bool hasBmpExtension(std::string_view fileName);
 
+// Check for .pxc extension (case-insensitive)
+bool hasPxcExtension(std::string_view fileName);
+
 // Check for .gif extension (case-insensitive)
 bool hasGifExtension(std::string_view fileName);
 inline bool hasGifExtension(const String& fileName) {