Support images with indexed colors

firmware/src/gfx.c

@@ -25,16 +25,15 @@ const uint16_t white_pallete[16] = {
 
 void gfx_anima_draw(const anima_t *ani, int x, int y, int frame, const uint16_t pallete[16])
 {
-    uint16_t width = ani->width;
-    uint16_t height = ani->height;
-    frame = frame % ani->frames;
-
-    rle_t rle;
-    rle_x_init(&rle, ani->data + ani->index[frame], ani->size, 0);
-
-    for (int j = 0; j < height; j++) {
-        for (int i = 0; i < width / 2; i++) {
-            uint8_t value = rle_x_get_uint8(&rle);
+    rle_decoder_t rle;
+    rle_init(&rle, 
+             &(rle_src_t){ ani->data + ani->index[frame % ani->frames], 
+                           RLE_RLE_X, ani->size, 0x00 }
+            );
+                            
+    for (int j = 0; j < ani->height; j++) {
+        for (int i = 0; i < ani->width / 2; i++) {
+            uint8_t value = rle_get_uint8(&rle);
             st7789_pixel_raw(x + i * 2, y + j, pallete[value >> 4]);
             st7789_pixel_raw(x + i * 2 + 1, y + j, pallete[value & 0x0f]);
         }
@@ -43,51 +42,44 @@ void gfx_anima_draw(const anima_t *ani, int x, int y, int frame, const uint16_t
 
 void gfx_anima_mix(const anima_t *ani, int x, int y, int frame, uint16_t color)
 {
-    uint16_t width = ani->width;
-    uint16_t height = ani->height;
-    frame = frame % ani->frames;
+    rle_decoder_t rle;
+    rle_init(&rle, 
+             &(rle_src_t){ ani->data + ani->index[frame % ani->frames], 
+                           RLE_RLE_X, ani->size, 0x00 }
+            );
 
-    rle_t rle;
-    rle_x_init(&rle, ani->data + ani->index[frame], ani->size, 0);
-    for (int j = 0; j < height; j++) {
-        for (int i = 0; i < width / 2; i++) {
-            uint8_t value = rle_x_get_uint8(&rle);
+    for (int j = 0; j < ani->height; j++) {
+        for (int i = 0; i < ani->width / 2; i++) {
+            uint8_t value = rle_get_uint8(&rle);
             st7789_pixel(x + i * 2, y + j, color, value >> 4 << 4);
             st7789_pixel(x + i * 2 + 1, y + j, color, (value & 0x0f) << 4);
         }
     }
 }
 
-static rle_t pixels_rle;
-static rle_t alpha_rle;
-static int pixels_pos;
-static int alpha_pos;
-
-#define INIT_RLE(which) \
-    if (img->which##_rle_x) { \
-        rle_x_init(&which##_rle, img->which, img->width * img->height, img->which##_x); \
-    } else if (img->which##_rle) { \
-        rle_init(&which##_rle, img->which, img->width * img->height); \
-    } else { \
-        which##_pos = 0; \
-    }
-
-#define GET_DATA(which, type) \
-    (img->which##_rle_x ? \
-        rle_x_get_##type(&which##_rle) : \
-        img->which##_rle ? \
-            rle_get_##type(&which##_rle) :\
-            img->which[which##_pos++])
-
 void gfx_img_draw(int x, int y, const image_t *img)
 {
-    INIT_RLE(pixels);
-    INIT_RLE(alpha);
+    rle_decoder_t pixels_rle;
+    rle_decoder_t alpha_rle;
+
+    rle_init(&pixels_rle, &img->pixels);
+
+    if (!img->pallete && img->alpha.input) {
+        rle_init(&alpha_rle, &img->alpha);
+    }
 
     for (int i = 0; i < img->height; i++) {
         for (int j = 0; j < img->width; j++) {
-            uint16_t pixel = GET_DATA(pixels, uint16);
-            uint8_t mix = img->alpha ? GET_DATA(alpha, uint8) : 0xff;
+            uint16_t pixel;
+            uint8_t mix;
+            if (img->pallete) {
+                uint32_t color = img->pallete[rle_get_uint8(&pixels_rle)];
+                pixel = (uint16_t)color;
+                mix = color >> 16;
+            } else {
+                pixel = rle_get_uint16(&pixels_rle);
+                mix = img->alpha.input ? rle_get_uint8(&alpha_rle) : 0xff;
+            }
             st7789_pixel(x + j, y + i, pixel, mix);
         }
     }

firmware/src/gfx.h

@@ -2,6 +2,7 @@
 #define GFX_H
 
 #include <stdint.h>
+#include "rle.h"
 
 typedef struct {
     uint16_t width;
@@ -16,15 +17,9 @@ typedef struct {
     uint16_t width;
     uint16_t height;
 
-    const uint16_t *pixels;
-    bool pixels_rle;
-    bool pixels_rle_x;
-    uint16_t pixels_x;
-
-    const uint8_t *alpha;
-    bool alpha_rle;
-    bool alpha_rle_x;
-    uint8_t alpha_x;
+    rle_src_t pixels;
+    const uint32_t *pallete; // always 256 colors, RGB565 (bits 0..15) + alpha (bits 16..23)
+    rle_src_t alpha; // ignored when pallete exists
 } image_t;
 
 extern const uint16_t white_pallete[16];

firmware/src/rle.c

@@ -7,57 +7,40 @@
 
 #include "rle.h"
 
-void rle_init(rle_t *rle, const void *input, size_t size)
+void rle_init(rle_decoder_t *rle, const rle_src_t *src)
 {
-    rle->src = input;
-    rle->size = size;
+    rle->src = *src;
     rle->pos = 0;
     rle->counter = 0;
 }
 
-void rle_x_init(rle_t *rle, const void *input, size_t size, uint32_t x)
+bool rle_eof(rle_decoder_t *rle)
 {
-    rle->x = x;
-    rle_init(rle, input, size);
+    return (!rle->counter) && (rle->pos >= rle->src.size);
 }
 
-bool rle_eof(rle_t *rle)
-{
-    return (!rle->counter) && (rle->pos >= rle->size);
-}
-
-#define RLE_GET_TEMPLATE(type, condition) \
+#define RLE_GET_TEMPLATE(type) \
+    if (rle->src.encoding == RLE_NONE) { \
+        return ((const type *)rle->src.input)[rle->pos++]; \
+    } \
     if (rle->counter) { \
         rle->counter--; \
-    } else if (rle->pos < rle->size) { \
-        rle->value = ((const type *)rle->src)[rle->pos++]; \
-        if (condition) { \
-            rle->counter = ((const type *)rle->src)[rle->pos++]; \
+    } else if (rle->pos < rle->src.size) { \
+        rle->value = ((const type *)rle->src.input)[rle->pos++]; \
+        if ((rle->src.encoding == RLE_RLE) || (rle->value == rle->src.x)) { \
+            rle->counter = ((const type *)rle->src.input)[rle->pos++]; \
         } \
     } \
     return rle->value;
 
-#define RLE_GET(type) RLE_GET_TEMPLATE(type, true)
-#define RLE_GET_X(type) RLE_GET_TEMPLATE(type, rle->value == rle->x)
-
-uint8_t rle_get_uint8(rle_t *rle)
+uint8_t rle_get_uint8(rle_decoder_t *rle)
 {
-    RLE_GET(uint8_t);
+    RLE_GET_TEMPLATE(uint8_t);
 }
 
-uint16_t rle_get_uint16(rle_t *rle)
+uint16_t rle_get_uint16(rle_decoder_t *rle)
 {
-    RLE_GET(uint16_t);
-}
-
-uint8_t rle_x_get_uint8(rle_t *rle)
-{
-    RLE_GET_X(uint8_t);
-}
-
-uint16_t rle_x_get_uint16(rle_t *rle)
-{
-    RLE_GET_X(uint16_t);
+    RLE_GET_TEMPLATE(uint16_t);
 }
 
 #define PUSH_DATA(data) \

firmware/src/rle.h

@@ -10,25 +10,32 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+typedef enum {
+    RLE_NONE,
+    RLE_RLE,
+    RLE_RLE_X
+} rle_encoding_t;
+
 typedef struct {
-    const void *src;
+    const uint8_t *input;
+    rle_encoding_t encoding;
     size_t size;
-    int pos;
     uint32_t x;
+} rle_src_t;
+
+typedef struct {
+    rle_src_t src;
+    int pos;
     uint32_t value;
     uint32_t counter;
-} rle_t;
+} rle_decoder_t;
 
-void rle_init(rle_t *rle, const void *input, size_t size);
-void rle_x_init(rle_t *rle, const void *input, size_t size, uint32_t x);
+void rle_init(rle_decoder_t *rle, const rle_src_t *src);
 
-bool rle_eof(rle_t *rle);
+bool rle_eof(rle_decoder_t *rle);
 
-uint8_t rle_get_uint8(rle_t *rle);
-uint16_t rle_get_uint16(rle_t *rle);
-
-uint8_t rle_x_get_uint8(rle_t *rle);
-uint16_t rle_x_get_uint16(rle_t *rle);
+uint8_t rle_get_uint8(rle_decoder_t *rle);
+uint16_t rle_get_uint16(rle_decoder_t *rle);
 
 /* No protection, make sure output is large enough */
 size_t rle_encode_uint8(uint8_t *output, const uint8_t *input, size_t size);