[Horus] Revert to BMP bitmaps instead of PNG. It uses far less CPU

radio/src/gui/horus/bitmapbuffer.cpp

@@ -388,6 +388,194 @@ void BitmapBuffer::drawBitmapPatternPie(coord_t x0, coord_t y0, const uint8_t *
   }
 }
 
+BitmapBuffer * BitmapBuffer::load(const char * filename)
+{
+  const char * ext = getFileExtension(filename);
+  if (!strcmp(ext, ".bmp"))
+    return load_bmp(filename);
+  else
+    return load_stb(filename);
+}
+
+BitmapBuffer * BitmapBuffer::load_bmp(const char * filename)
+{
+  FIL bmpFile;
+  UINT read;
+  uint8_t palette[16];
+  uint8_t bmpBuf[LCD_W]; /* maximum with LCD_W */
+  uint8_t * buf = &bmpBuf[0];
+
+  FRESULT result = f_open(&bmpFile, filename, FA_OPEN_EXISTING | FA_READ);
+  if (result != FR_OK) {
+    return NULL;
+  }
+
+  if (f_size(&bmpFile) < 14) {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  result = f_read(&bmpFile, buf, 14, &read);
+  if (result != FR_OK || read != 14) {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  if (buf[0] != 'B' || buf[1] != 'M') {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  uint32_t fsize  = *((uint32_t *)&buf[2]);
+  uint32_t hsize  = *((uint32_t *)&buf[10]); /* header size */
+
+  uint32_t len = limit((uint32_t)4, (uint32_t)(hsize-14), (uint32_t)32);
+  result = f_read(&bmpFile, buf, len, &read);
+  if (result != FR_OK || read != len) {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  uint32_t ihsize = *((uint32_t *)&buf[0]); /* more header size */
+
+  /* invalid header size */
+  if (ihsize + 14 > hsize) {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  /* sometimes file size is set to some headers size, set a real size in that case */
+  if (fsize == 14 || fsize == ihsize + 14)
+    fsize = f_size(&bmpFile) - 2;
+
+  /* declared file size less than header size */
+  if (fsize <= hsize) {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  uint32_t w, h;
+
+  switch (ihsize){
+    case  40: // windib
+    case  56: // windib v3
+    case  64: // OS/2 v2
+    case 108: // windib v4
+    case 124: // windib v5
+      w  = *((uint32_t *)&buf[4]);
+      h = *((uint32_t *)&buf[8]);
+      buf += 12;
+      break;
+    case  12: // OS/2 v1
+      w  = *((uint16_t *)&buf[4]);
+      h = *((uint16_t *)&buf[6]);
+      buf += 8;
+      break;
+    default:
+      f_close(&bmpFile);
+      return NULL;
+  }
+
+  if (*((uint16_t *)&buf[0]) != 1) { /* planes */
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  uint16_t depth = *((uint16_t *)&buf[2]);
+
+  buf = &bmpBuf[0];
+
+  if (depth == 4) {
+    if (f_lseek(&bmpFile, hsize-64) != FR_OK || f_read(&bmpFile, buf, 64, &read) != FR_OK || read != 64) {
+      f_close(&bmpFile);
+      return NULL;
+    }
+    for (uint8_t i=0; i<16; i++) {
+      palette[i] = buf[4*i];
+    }
+  }
+  else {
+    if (f_lseek(&bmpFile, hsize) != FR_OK) {
+      f_close(&bmpFile);
+      return NULL;
+    }
+  }
+
+  BitmapBuffer * bmp = new BitmapBuffer(BMP_RGB565, w, h);
+  if (bmp == NULL) {
+    f_close(&bmpFile);
+    return NULL;
+  }
+
+  uint16_t * dest = bmp->getData();
+  uint32_t rowSize;
+  bool hasAlpha = false;
+
+  switch (depth) {
+    case 32:
+      for (int i=h-1; i>=0; i--) {
+        uint8_t * dst = ((uint8_t *)dest) + i*w*2;
+        for (unsigned int j=0; j<w; j++) {
+          uint32_t pixel;
+          result = f_read(&bmpFile, (uint8_t *)&pixel, 4, &read);
+          if (result != FR_OK || read != 4) {
+            f_close(&bmpFile);
+            delete bmp;
+            return NULL;
+          }
+          if (hasAlpha) {
+            *((uint16_t *)dst) = ARGB(pixel & 0xff, (pixel >> 24) & 0xff, (pixel >> 16) & 0xff, (pixel >> 8) & 0xff);
+          }
+          else {
+            if ((pixel & 0xff) == 0xff) {
+              *((uint16_t *)dst) = RGB(pixel >> 24, (pixel >> 16) & 0xff, (pixel >> 8) & 0xff);
+            }
+            else {
+              hasAlpha = true;
+              bmp->setFormat(BMP_ARGB4444);
+              for (uint16_t * p = dest + i*w; p<dest + h*w; p++) {
+                uint16_t tmp = *p;
+                *p = ((tmp >> 1) & 0x0f) + (((tmp >> 7) & 0x0f) << 4) + (((tmp >> 12) & 0x0f) << 8);
+              }
+              *((uint16_t *)dst) = ARGB(pixel & 0xff, (pixel >> 24) & 0xff, (pixel >> 16) & 0xff, (pixel >> 8) & 0xff);
+            }
+          }
+          dst += 2;
+        }
+      }
+      break;
+
+    case 1:
+      break;
+
+    case 4:
+      rowSize = ((4*w+31)/32)*4;
+      for (int32_t i=h-1; i>=0; i--) {
+        result = f_read(&bmpFile, buf, rowSize, &read);
+        if (result != FR_OK || read != rowSize) {
+          f_close(&bmpFile);
+          delete bmp;
+          return NULL;
+        }
+        uint8_t * dst = ((uint8_t *)dest) + i*w*2;
+        for (uint32_t j=0; j<w; j++) {
+          uint8_t index = (buf[j/2] >> ((j & 1) ? 0 : 4)) & 0x0F;
+          uint8_t val = palette[index];
+          *((uint16_t *)dst) = RGB(val, val, val);
+          dst += 2;
+        }
+      }
+      break;
+
+    default:
+      f_close(&bmpFile);
+      delete bmp;
+      return NULL;
+  }
+
+  f_close(&bmpFile);
+  return bmp;
+}
 
 #define STB_IMAGE_IMPLEMENTATION
 #define STBI_ONLY_PNG
@@ -461,7 +649,7 @@ const stbi_io_callbacks stbCallbacks = {
   stbc_eof
 };
 
-BitmapBuffer * BitmapBuffer::load(const char * filename)
+BitmapBuffer * BitmapBuffer::load_stb(const char * filename)
 {
   FIL imgFile;