Merge pull request #33 from cobaltgit/display-neon

Optimise display() to use ARM NEON for blitting, benefit most noticeable when CPU is at very low clocks (much less CPU cycles taken)

Author: cobaltgit

src/common/fb.nim

@@ -20,22 +20,10 @@ const
       arr[i] = uint8((i shl 2) or (i shr 4))
     arr
 
-  EightToFive*: array[256, uint8] = block:
-    var arr: array[256, uint8]
-    for i in 0..255:
-      arr[i] = uint8(i shr 3)
-    arr
-
-  EightToSix*: array[256, uint8] = block:
-    var arr: array[256, uint8]
-    for i in 0..255:
-      arr[i] = uint8(i shr 2)
-    arr
-
-  FbXBase*: array[FbHeight, int] = block:
-    var arr: array[FbHeight, int]
+  FbXBase*: array[FbHeight, uint32] = block:
+    var arr: array[FbHeight, uint32]
     for x in 0..<FbHeight:
-      arr[x] = (FbHeight - 1 - x) * FbWidth
+      arr[x] = uint32((FbHeight - 1 - x) * FbWidth)
     arr
 
 {.push optimization:speed, checks:off, warnings:off.}

src/common/ffi/neon_blit.c

@@ -0,0 +1,141 @@
+// NEON blitter for display
+// Generated by Claude Sonnet 4.6
+
+#include <arm_neon.h>
+#include <stdint.h>
+
+/* -------------------------------------------------------------------------
+ * Cortex-A7 notes:
+ *
+ *  - 64-bit NEON unit: q-register (128-bit) ops cost 2 cycles; d-register
+ *    (64-bit) ops cost 1 cycle. The transpose uses d-registers throughout.
+ *    rgba_to_rgb565 must use q-registers for widened intermediates (8 lanes
+ *    of uint16 is 128 bits — there is no narrower option), so no savings
+ *    there, but the 16-pixel unroll saturates each 64-byte cache line.
+ *
+ *  - In-order pipeline: cache misses stall directly. __builtin_prefetch
+ *    issues a PLD instruction to run ahead of the miss.
+ *
+ *  - L1 cache line: 64 bytes = 16 RGBA pixels = 32 RGB565 pixels.
+ * ------------------------------------------------------------------------- */
+
+/* -------------------------------------------------------------------------
+ * Phase 1: RGBA -> RGB565
+ * 16 pixels per iteration = one full 64-byte cache line of RGBA input.
+ * Intermediate values are necessarily q-registers (8×uint16 = 128 bits).
+ * ------------------------------------------------------------------------- */
+void rgba_to_rgb565(const uint8_t* src, uint16_t* dst, int n)
+{
+    /* Prefetch 4 cache lines ahead. On A7 the hardware prefetcher handles
+     * sequential access well, but an explicit prefetch avoids any startup
+     * latency at the beginning of the buffer. */
+    for (; n >= 16; n -= 16, src += 64, dst += 16) {
+        __builtin_prefetch(src + 256, 0, 1);
+
+        /* vld4_u8 deinterleaves RGBA into four d-registers (8 bytes each),
+         * giving us channels for 8 pixels per call at no extra cost. */
+        uint8x8x4_t px0 = vld4_u8(src);
+        uint8x8x4_t px1 = vld4_u8(src + 32);
+
+        /* vmovl_u8: d-reg -> q-reg widen (unavoidable for 16-bit output).
+         * vshlq_n_u16 and vorrq_u16 are q-reg ops (2 cycles each on A7),
+         * but there is no d-register equivalent for this pipeline. */
+        uint16x8_t r0 = vshlq_n_u16(vmovl_u8(vshr_n_u8(px0.val[0], 3)), 11);
+        uint16x8_t g0 = vshlq_n_u16(vmovl_u8(vshr_n_u8(px0.val[1], 2)),  5);
+        uint16x8_t b0 =             vmovl_u8(vshr_n_u8(px0.val[2], 3));
+        vst1q_u16(dst,     vorrq_u16(vorrq_u16(r0, g0), b0));
+
+        uint16x8_t r1 = vshlq_n_u16(vmovl_u8(vshr_n_u8(px1.val[0], 3)), 11);
+        uint16x8_t g1 = vshlq_n_u16(vmovl_u8(vshr_n_u8(px1.val[1], 2)),  5);
+        uint16x8_t b1 =             vmovl_u8(vshr_n_u8(px1.val[2], 3));
+        vst1q_u16(dst + 8, vorrq_u16(vorrq_u16(r1, g1), b1));
+    }
+
+    /* 8-pixel tail */
+    for (; n >= 8; n -= 8, src += 32, dst += 8) {
+        uint8x8x4_t px = vld4_u8(src);
+        uint16x8_t r = vshlq_n_u16(vmovl_u8(vshr_n_u8(px.val[0], 3)), 11);
+        uint16x8_t g = vshlq_n_u16(vmovl_u8(vshr_n_u8(px.val[1], 2)),  5);
+        uint16x8_t b =             vmovl_u8(vshr_n_u8(px.val[2], 3));
+        vst1q_u16(dst, vorrq_u16(vorrq_u16(r, g), b));
+    }
+
+    /* Scalar tail */
+    for (; n > 0; n--, src += 4, dst++)
+        *dst = ((uint16_t)(src[0] >> 3) << 11)
+             | ((uint16_t)(src[1] >> 2) <<  5)
+             |  (uint16_t)(src[2] >> 3);
+}
+
+/* -------------------------------------------------------------------------
+ * Phase 2: 4×4 tiled transpose using d-registers only.
+ *
+ * vtrn_u16 and vtrn_u32 are d-register ops (1 cycle on A7).
+ * vst1_u16 is a d-register store (1 cycle on A7).
+ * The 8×8 version used vtrnq/vst1q (2 cycles each) — this is cheaper.
+ *
+ * src_width and src_height must be multiples of 4.
+ * 240 and 320 are both divisible by 4. ✓
+ * ------------------------------------------------------------------------- */
+static inline void transpose_4x4(
+    const uint16_t* src, int src_stride,
+          uint16_t* dst, int dst_stride)
+{
+    uint16x4_t r0 = vld1_u16(src + 0 * src_stride);
+    uint16x4_t r1 = vld1_u16(src + 1 * src_stride);
+    uint16x4_t r2 = vld1_u16(src + 2 * src_stride);
+    uint16x4_t r3 = vld1_u16(src + 3 * src_stride);
+
+    /* Round 1: interleave adjacent u16 pairs (d-register, 1 cycle) */
+    uint16x4x2_t q01 = vtrn_u16(r0, r1);
+    uint16x4x2_t q23 = vtrn_u16(r2, r3);
+
+    /* Round 2: interleave u32 pairs to complete the transpose */
+    uint32x2x2_t q0123e = vtrn_u32(vreinterpret_u32_u16(q01.val[0]),
+                                    vreinterpret_u32_u16(q23.val[0]));
+    uint32x2x2_t q0123o = vtrn_u32(vreinterpret_u32_u16(q01.val[1]),
+                                    vreinterpret_u32_u16(q23.val[1]));
+
+    vst1_u16(dst + 0 * dst_stride, vreinterpret_u16_u32(q0123e.val[0]));
+    vst1_u16(dst + 1 * dst_stride, vreinterpret_u16_u32(q0123o.val[0]));
+    vst1_u16(dst + 2 * dst_stride, vreinterpret_u16_u32(q0123e.val[1]));
+    vst1_u16(dst + 3 * dst_stride, vreinterpret_u16_u32(q0123o.val[1]));
+}
+
+/*
+ * blit_transposed — rotate a landscape RGB565 buffer 90° CW into a portrait
+ * framebuffer using tiled 4×4 d-register NEON transposes.
+ *
+ * Pixel mapping:
+ *   src(lx, ly)  →  dst[(src_width - 1 - lx) * src_height + ly]
+ *
+ * For 320×240 source → 240×320 framebuffer:
+ *   dst[(319 - lx) * 240 + ly]
+ */
+void blit_transposed(const uint16_t* src, uint16_t* dst,
+                     int src_width, int src_height)
+{
+    /* Source reads stride across rows by src_width elements (640 bytes),
+     * which the A7's hardware prefetcher won't detect. We prefetch one
+     * full tile-row ahead (4 rows × src_width elements). */
+    const int prefetch_dist = 4 * src_width;
+
+    for (int ty = 0; ty < src_height; ty += 4) {
+        const uint16_t* row = src + ty * src_width;
+
+        for (int tx = 0; tx < src_width; tx += 4) {
+            const uint16_t* s = row + tx;
+
+            /* Prefetch the 4 source rows of the next tile-row.
+             * Each covers 8 bytes (4×uint16), well within one cache line,
+             * so one __builtin_prefetch per row is sufficient. */
+            __builtin_prefetch(s + 0 * src_width + prefetch_dist, 0, 1);
+            __builtin_prefetch(s + 1 * src_width + prefetch_dist, 0, 1);
+            __builtin_prefetch(s + 2 * src_width + prefetch_dist, 0, 1);
+            __builtin_prefetch(s + 3 * src_width + prefetch_dist, 0, 1);
+
+            uint16_t* d = dst + (src_width - 1 - tx) * src_height + ty;
+            transpose_4x4(s, src_width, d, -src_height);
+        }
+    }
+}

src/common/ffi/neon_blit.nim

@@ -0,0 +1,10 @@
+{.compile: "neon_blit.c".}
+{.passC: "-mfpu=neon-vfpv4 -mfloat-abi=hard -O3".}
+
+proc rgba_to_rgb565*(src: ptr UncheckedArray[uint8],
+                    dst: ptr UncheckedArray[uint16],
+                    n: cint) {.importc, noconv.}
+
+proc blit_transposed*(src: ptr UncheckedArray[uint16],
+                     dst: ptr UncheckedArray[uint16],
+                     width, height: cint) {.importc, noconv.}

src/display.nim

@@ -2,30 +2,39 @@ import std/[os, posix, strutils]
 import nimPNG
 
 import common/[fb, process]
-import common/ffi/stb_truetype
+import common/ffi/[stb_truetype, neon_blit]
 
 const
-  ScreenWidth = 320
+  ScreenWidth  = 320
   ScreenHeight = 240
 
   DefaultBackground* = "/mnt/SDCARD/System/res/quarkbg.png"
-  DefaultFont* = "/mnt/SDCARD/System/res/TwCenMT.ttf"
-  FontSize = 24.0
+  DefaultFont*       = "/mnt/SDCARD/System/res/TwCenMT.ttf"
+  FontSize           = 24.0
 
-{.push optimization:speed, warnings:off.}
+{.push optimization: speed, warnings: off.}
 
 var childPid: Pid = -1
 
+var blitTmp: array[FbPixels, uint16]
+
 proc toRGB565(r, g, b: uint8): uint16 {.inline.} =
-  (uint16(EightToFive[r]) shl 11) or
-  (uint16(EightToSix[g]) shl 5) or
-  uint16(EightToFive[b])
+  (uint16(r shr 3) shl 11) or
+  (uint16(g shr 2) shl 5)  or
+   uint16(b shr 3)
 
 proc fromRGB565(pixel: uint16, r, g, b: var uint8) {.inline.} =
   r = FiveToEight[(pixel shr 11) and 0x1F]
-  g = SixToEight[(pixel shr 5) and 0x3F]
+  g = SixToEight[(pixel shr  5) and 0x3F]
   b = FiveToEight[pixel and 0x1F]
 
+proc blendRGB565(fg, bg: uint16, alpha: uint32): uint16 {.inline.} =
+  let inv = 256'u32 - alpha
+  let r = (uint32(fg shr 11) * alpha + uint32(bg shr 11) * inv) shr 8
+  let g = ((uint32(fg) and 0x07E0'u32) * alpha + (uint32(bg) and 0x07E0'u32) * inv) shr 8
+  let b = (uint32(fg and 0x1F'u16) * alpha + uint32(bg and 0x1F'u16) * inv) shr 8
+  uint16((r shl 11) or (g and 0x07E0'u32) or b)
+
 proc loadFont(path: string): seq[byte] =
   let f = open(path, fmRead)
   defer: f.close()
@@ -37,21 +46,21 @@ proc measureText(font: ptr stbtt_fontinfo, text: string, scale: cfloat): int =
   var x: cint = 0
   for i, ch in text:
     var advanceWidth, leftSideBearing: cint
-    stbtt_GetCodepointHMetrics(font, cint(ch), addr advanceWidth, addr leftSideBearing)
+    stbtt_GetCodepointHMetrics(font, cint(ch), addr advanceWidth,
+                               addr leftSideBearing)
     x += advanceWidth
     if i < text.len - 1:
-      let kern = stbtt_GetCodepointKernAdvance(font, cint(ch), cint(text[i+1]))
-      x += kern
+      x += stbtt_GetCodepointKernAdvance(font, cint(ch), cint(text[i + 1]))
   result = int(cfloat(x) * scale)
 
-proc wrapText(text: string, font: ptr stbtt_fontinfo, scale: cfloat, maxWidth: int): seq[string] =
+proc wrapText(text: string, font: ptr stbtt_fontinfo, scale: cfloat,
+              maxWidth: int): seq[string] =
   result = @[]
   var currentLine = ""
   var currentWidth = 0
 
   for word in text.split(' '):
     let wordWidth = measureText(font, word & " ", scale)
-
     if currentWidth + wordWidth > maxWidth and currentLine.len > 0:
       result.add(currentLine.strip())
       currentLine = word & " "
@@ -63,19 +72,17 @@ proc wrapText(text: string, font: ptr stbtt_fontinfo, scale: cfloat, maxWidth: i
   if currentLine.len > 0:
     result.add(currentLine.strip())
 
-proc renderTextLine(fb: ptr UncheckedArray[uint16], font: ptr stbtt_fontinfo,
-                    text: string, y: int, pixelHeight: float, color: uint16) =
+proc renderTextLine(fb: ptr UncheckedArray[uint16],
+                    font: ptr stbtt_fontinfo,
+                    text: string, y: int,
+                    pixelHeight: float, color: uint16) =
   let scale = stbtt_ScaleForPixelHeight(font, cfloat(pixelHeight))
-
   var ascent, descent, lineGap: cint
   stbtt_GetFontVMetrics(font, addr ascent, addr descent, addr lineGap)
 
   let textWidth = measureText(font, text, scale)
   var x = (ScreenWidth - textWidth) div 2
-  let baseline = y + int(cfloat(ascent) * scale)
-
-  var cr, cg, cb: uint8
-  fromRGB565(color, cr, cg, cb)
+  let baseline  = y + int(cfloat(ascent) * scale)
 
   var bitmapBuf = newSeqUninit[byte](64 * 64)
 
@@ -105,31 +112,26 @@ proc renderTextLine(fb: ptr UncheckedArray[uint16], font: ptr stbtt_fontinfo,
         let fbBase = FbXBase[px]
 
         for by in 0..<h:
-          let alpha = bitmapBuf[by * w + bx]
+          let alpha = uint32(bitmapBuf[by * w + bx])
           if alpha == 0: continue
           let py = charY + by
           if py < 0 or py >= ScreenHeight: continue
 
-          if alpha == 255:
-            fb[fbBase + py] = color
+          let idx = fbBase + uint32(py)
+          if alpha >= 255:
+            fb[idx] = color
           else:
-            let bgPixel = fb[fbBase + py]
-            var bgR, bgG, bgB: uint8
-            fromRGB565(bgPixel, bgR, bgG, bgB)
-            let inv = 255'u32 - uint32(alpha)
-            let newR = uint8((uint32(cr) * uint32(alpha) + uint32(bgR) * inv) div 255)
-            let newG = uint8((uint32(cg) * uint32(alpha) + uint32(bgG) * inv) div 255)
-            let newB = uint8((uint32(cb) * uint32(alpha) + uint32(bgB) * inv) div 255)
-            fb[fbBase + py] = toRGB565(newR, newG, newB)
+            fb[idx] = blendRGB565(color, fb[idx], alpha)
       {.pop.}
 
     var advanceWidth, leftSideBearing: cint
-    stbtt_GetCodepointHMetrics(font, cint(ch), addr advanceWidth, addr leftSideBearing)
+    stbtt_GetCodepointHMetrics(font, cint(ch), addr advanceWidth,
+                               addr leftSideBearing)
     x += int(cfloat(advanceWidth) * scale)
 
     if i < text.len - 1:
-      let kern = stbtt_GetCodepointKernAdvance(font, cint(ch), cint(text[i+1]))
-      x += int(cfloat(kern) * scale)
+      x += int(cfloat(stbtt_GetCodepointKernAdvance(
+                        font, cint(ch), cint(text[i + 1]))) * scale)
 
 proc display*(text: string,
               backgroundPath: string = DefaultBackground,
@@ -156,23 +158,27 @@ proc display*(text: string,
   let fb = cast[ptr UncheckedArray[uint16]](fbMap)
 
   if not fileExists(backgroundPath):
-    raise newException(IOError, "display: background file not found: " & backgroundPath)
+    raise newException(IOError,
+      "display: background file not found: " & backgroundPath)
 
   let png = loadPNG32(backgroundPath)
 
   zeroMem(fbMap, FbSize)
 
-  var srcIdx = 0
-  for ly in 0..<min(png.height, ScreenHeight):
-    for lx in 0..<min(png.width, ScreenWidth):
-      let r = png.data[srcIdx]
-      let g = png.data[srcIdx + 1]
-      let b = png.data[srcIdx + 2]
-      srcIdx += 4
-      fb[FbXBase[lx] + ly] = toRGB565(r.uint8, g.uint8, b.uint8)
+  # commence claude's NEON fuckery
+  rgba_to_rgb565(
+    cast[ptr UncheckedArray[uint8]](unsafeAddr png.data[0]),
+    cast[ptr UncheckedArray[uint16]](addr blitTmp[0]),
+    cint(min(png.width * png.height, FbPixels)))
+
+  blit_transposed(
+    cast[ptr UncheckedArray[uint16]](addr blitTmp[0]),
+    cast[ptr UncheckedArray[uint16]](fbMap),
+    cint(ScreenWidth), cint(ScreenHeight))
 
   if not fileExists(fontPath):
-    raise newException(IOError, "display: font file not found: " & fontPath)
+    raise newException(IOError,
+      "display: font file not found: " & fontPath)
 
   let fontData = loadFont(fontPath)
   var fontInfo: stbtt_fontinfo
@@ -182,13 +188,12 @@ proc display*(text: string,
 
   let scale = stbtt_ScaleForPixelHeight(addr fontInfo, cfloat(FontSize))
   let lines = wrapText(text, addr fontInfo, scale, ScreenWidth - 40)
-
   let lineHeight = int(FontSize * 1.2)
   var startY = (ScreenHeight - lines.len * lineHeight) div 2
 
   for line in lines:
     renderTextLine(fb, addr fontInfo, line, startY, FontSize,
-                    toRGB565(255, 255, 255))
+                   toRGB565(255, 255, 255))
     startY += lineHeight
 
   if duration == 0:
@@ -216,7 +221,7 @@ proc showUsage(progName: string) =
   stderr.writeLine("  -b  Background PNG image (default: quarkbg.png)")
   stderr.writeLine("  -d  Display duration in milliseconds (default: 0 = forever)")
   stderr.writeLine("  -f  Font file path (default: TwCenMT.ttf)")
-  stderr.writeLine("  -p  Don't fork into the background (only applies if duration is 0)")
+  stderr.writeLine("  -p  Don't fork into background (only applies if duration is 0)")
 
 proc main() =
   var
@@ -256,10 +261,10 @@ proc main() =
         if i + 1 <= paramCount():
           let durationStr = paramStr(i + 1).strip()
           if durationStr.len > 0:
-            try:
-              duration = parseInt(durationStr)
+            try: duration = parseInt(durationStr)
             except ValueError:
-              stderr.writeLine("display: invalid duration value: '" & durationStr & "'"); quit(1)
+              stderr.writeLine("display: invalid duration: '" & durationStr & "'")
+              quit(1)
           inc i
         else:
           stderr.writeLine("display: -d requires a duration argument")