Merge branch 'STM32F4LCD' into HEAD - with speed improvements for vertical blur and ability to set width

Author: gfwilliams

libs/pipboy/jswrap_pipboy.c

@@ -1973,12 +1973,14 @@ are for previous pixels
 * `options.ydiff` (default 1) is the y difference used when averaging rows above and below
 * `options.y1` (default 0) is the min row to start updating
 * `options.y2` (default 319) is the max row to start updating
+* `options.x` (default 0) is the start column to update
+* `options.w` (default 480) is number of columns to update
 */
 
 void jswrap_pb_blitScreen(JsVar *image, JsVar *options) {
   uint32_t filter = 0x00010123;
   int yoffset = 0, ydiff = 1;
-  int y1 = 0, y2 = 319;
+  int xoffset = 0, y1 = 0, y2 = 319, w = 0;
   if (jsvIsObject(options)) {
     uint32_t v = (uint32_t)jsvGetIntegerAndUnLock(jsvObjectGetChildIfExists(options, "filter"));
     if (v) filter = v;
@@ -1990,21 +1992,25 @@ void jswrap_pb_blitScreen(JsVar *image, JsVar *options) {
     y1 = jsvGetIntegerAndUnLock(jsvObjectGetChildIfExists(options, "y1"));
     v = jsvGetIntegerAndUnLock(jsvObjectGetChildIfExists(options, "y2"));
     if (v) y2=v;
+    xoffset = jsvGetIntegerAndUnLock(jsvObjectGetChildIfExists(options, "x"));
+    w = jsvGetIntegerAndUnLock(jsvObjectGetChildIfExists(options, "w"));
   }
   if (y1<0) y1=0;
   if (y1>=319) y1=319;
   if (y2>=319) y2=319;
   if (y2<y1) y2=y1;
+  if (w<=0) w=480;
+  if (w&3) return jsExceptionHere(JSET_ERROR, "Width must be multiple of 4");
   scanlinePos = ((long long)(jshGetMillisecondsFromTime(jshGetSystemTime())*(480/4000.0)) % 640LL) - 110;
 
   JsGraphics *gfx = &graphicsInternal;
   GfxDrawImageInfo img;
   if (!_jswrap_graphics_parseImage(gfx, image, 0, &img))
     return;
 
-  if (img.width!=480 || img.height!=320 || img.bpp!=2) {
+  if (img.width!=w || img.height!=320 || img.bpp!=2) {
     _jswrap_graphics_freeImageInfo(&img);
-    return jsExceptionHere(JSET_ERROR, "Image must be 480x320x2bpp");
+    return jsExceptionHere(JSET_ERROR, "Image must be %dx320x2bpp", w);
   }
   JSV_GET_AS_CHAR_ARRAY_NO_ERROR( imgPtr, imgLen, img.buffer );
   if (!imgPtr) {
@@ -2023,48 +2029,49 @@ void jswrap_pb_blitScreen(JsVar *image, JsVar *options) {
   }
 
   uint16_t palette[16];
+  int w4 = w>>2; // 480 pixels, 2bpp = 120 bytes per row
   const uint8_t *row1 = &imgPtr[0], *row2, *row3;
   yoffset += 320; // to avoid negative values
-  lcdFSMC_blitStart(gfx, 0,y1, 480,y2+1-y1);
+  lcdFSMC_blitStart(gfx, xoffset,y1, w,y2+1-y1);
   for (int y=y1;y<=y2;y++) {
     uint16_t *rowBuf = (y & 1) ? blitRowB : blitRowA; // double buffer selection
 
     // work out row pointers
-    row1 = &imgPtr[((y+yoffset-ydiff)%320)*120]; // 480 pixels, 2bpp = 120 bytes per row
-    row2 = &imgPtr[((y+yoffset)%320)*120]; // 480 pixels, 2bpp = 120 bytes per row
-    row3 = &imgPtr[((y+yoffset+ydiff)%320)*120]; // 480 pixels, 2bpp = 120 bytes per row
+    row1 = &imgPtr[((y+yoffset-ydiff)%320)*w4];
+    row2 = &imgPtr[((y+yoffset)%320)*w4];
+    row3 = &imgPtr[((y+yoffset+ydiff)%320)*w4];
     getPaletteForLine4bpp(y, palette);
 
     uint32_t pixels = 0;
-    uint8_t pixelUp, pixelDn;
     int p = 0; // index into DMA row buffer
-    #define BLITPIXEL \
-      filterResult32 = (pixels&mulx1) + ((pixels&mulx2)<<1); /* Apply 8x 2bit filter */ \
-      filterResult32 = (filterResult32&0x0F0F0F0F) + ((filterResult32>>4)&0x0F0F0F0F) ; /* Merge each nibble, now we have 8 bits to play with */ \
-      filterResult32 = filterResult32 + (filterResult32>>8); \
-      filterResult32 = (filterResult32 + (filterResult32>>16)) & 255; \
-      filterResult32 = ((((pixelUp+pixelDn)<<1) + filterResult32)*3)>>3; /* blur upper and lower lines */ \
-      if (filterResult32>15) filterResult32=15; \
-      rowBuf[p++] = palette[filterResult32];
-    for (int x=0;x<120;x++) {
-      uint8_t p4up = *(row1++);
-      uint8_t p4 = *(row2++);
-      uint8_t p4dn = *(row3++);
+    for (int x=0;x<w4;x++) {
+      uint16_t p4up = *(row1++); // line above for blurring
+      uint8_t p4 = *(row2++); // actual line
+      uint16_t p4dn = *(row3++); // line below for blurring
+      // Adding upper and lower lines. Spread 2bpp out so we can do 4 adds in one go.
+      p4up = (p4up | (p4up << 6)) & 0x3333; // 0bAABBCCDD -> 0b00AA00CC 00BB00DD
+      p4dn = (p4dn | (p4dn << 6)) & 0x3333;
+      uint16_t p4sum = p4up + p4dn; // Now 0b0AAA0CCC 0BBB0DDD
       uint32_t filterResult32;
-      pixelUp = (p4up>>5);
-      pixelDn = (p4dn>>5);
+      uint8_t pixelSum;
+      #define BLITPIXEL \
+        filterResult32 = (pixels&mulx1) + ((pixels&mulx2)<<1); /* Apply 8x 2bit filter */ \
+        filterResult32 = (filterResult32&0x0F0F0F0F) + ((filterResult32>>4)&0x0F0F0F0F) ; /* Merge each nibble, now we have 8 bits to play with */ \
+        filterResult32 = filterResult32 + (filterResult32>>8); \
+        filterResult32 = (filterResult32 + (filterResult32>>16)) & 255; \
+        filterResult32 = ((pixelSum + filterResult32)*3)>>3; /* blur upper and lower lines */ \
+        if (filterResult32>15) filterResult32=15; \
+        rowBuf[p++] = palette[filterResult32];
+      pixelSum = (p4sum>>11)&14;
       pixels = (pixels<<4) | (p4>>6);
       BLITPIXEL
-      pixelUp = (p4up>>3)&6;
-      pixelDn = (p4dn>>3)&6;
+      pixelSum = (p4sum>>3)&14;
       pixels = (pixels<<4) | ((p4>>4)&3);
       BLITPIXEL
-      pixelUp = (p4up>>1)&6;
-      pixelDn = (p4dn>>1)&6;
+      pixelSum = (p4sum>>7)&14;
       pixels = (pixels<<4) | ((p4>>2)&3);
       BLITPIXEL
-      pixelUp = (p4up&3)<<1;
-      pixelDn = (p4dn&3)<<1;
+      pixelSum = (p4sum<<1)&14;
       pixels = (pixels<<4) | (p4&3);
       BLITPIXEL
       #undef BLITPIXEL
@@ -2423,12 +2430,12 @@ void jswrap_pb_init() {
 #endif
   bool hasBootCode = jsfFindFile(jsfNameFromString(".bootcde"), NULL) ;
   if (
-#ifndef LINUX 
-  upgradeInProgress || 
+#ifndef LINUX
+  upgradeInProgress ||
 #endif
   res || !hasBootCode) {
     JsVar *msg;
-#ifndef LINUX 
+#ifndef LINUX
     if (upgradeInProgress) msg = jsvNewFromString("UPGRADE IN PROGRESS");
     else
 #endif