Add big lut tables for decoding 1bpp rows

While the performance increase using this tables can be high, they
consume drastically more memory than with smaller ones and per nibble
decoding. For now I'm using the big tables but allow a compile time
switch for the small ones instead.

1 files changed, 174 insertions, 22 deletions

diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index d66785a..45923e8 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -69,11 +69,13 @@ draw_pixel(size_t x, size_t y, u8 clr) {
     size_t tile_y = y / 8;
     size_t start_col = x % 8;
     size_t start_row = y % 8;
-    size_t pos = start_row + (tile_x + tile_y * 32) * 8;
+    u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
 
     // Update backbuffer.
     size_t shift = start_col * sizeof(u32);
-    backbuf[pos] = (backbuf[pos] & ~(0xF << shift)) | clr << shift;
+    u32 mask = 0xF << shift;
+    u32 row = clr << shift;
+    *dst = (*dst & ~mask) | row;
 
     // Mark tile as dirty.
     dirty_tiles[tile_y] |= 1 << tile_x;
@@ -100,11 +102,11 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
     //        partial row updates, rows in the middle can write the entire
     //        row.
     size_t dtx = tile_x1 - tile_x0;
-    u32 *dst = &backbuf[tile_x0 * 8 + tile_y * 8 * 32 + start_row];
+    u32 *dst = &backbuf[start_row + (tile_x0 + tile_y * 32) * 8];
     if (dtx < 1) {
-        u32 mask = 0xFFFFFFFF;
-        mask >>= (7 - end_col - dtx) * 4;
-        mask &= 0xFFFFFFFF << start_col * 4;
+        size_t shift_left = start_col * 4;
+        size_t shift_right = (7 - end_col) * 4;
+        u32 mask = (0xFFFFFFFF >> shift_right) & (0xFFFFFFFF << shift_left);
         u32 row = (0x11111111 * clr) & mask;
         *dst = (*dst & ~mask) | row;
     } else {
@@ -139,7 +141,7 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
 
     size_t shift_left = start_col * 4;
 
-    u32 *dst = &backbuf[tile_x * 8 + tile_y * 8 * 32 + start_row0];
+    u32 *dst = &backbuf[start_row0 + (tile_x + tile_y * 32) * 8];
     u32 mask = 0x0000000F << shift_left;
     u32 row = (0x11111111 * clr) & mask;
     u32 dty = tile_y1 - tile_y0;
@@ -176,22 +178,31 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         MAYBE_SWAP(y0, y1);
         draw_vline(x0, y0, y1, clr);
     } else {
-#if 0
-        // Diagonal line.
+#if 1
         int dx = x0 > x1 ? x0 - x1 : x1 - x0;
-        int dy = y0 > y1 ? y1 - y0 : y0 - y1;
-        int x_step = x0 < x1 ? 1 : -1;
-        int y_step = y0 < y1 ? 1 : -1;
-        int err = dx + dy;
-        while (!(x0 == x1 && y0 == y1)) {
-            draw_pixel(x0, y0, clr);
-            int diff = 2 * err;
-            if (diff >= dy) {
-                err += dy;
+        int dy = y0 > y1 ? y0 - y1 : y1 - y0;
+        int x_step = x0 > x1 ? -1 : 1;
+        int y_step = y0 > y1 ? -1 : 1;
+        if (dx >= dy) {
+            int diff = 2 * dy - dx;
+            for (int i = 0; i < dx + 1; i++) {
+                draw_pixel(x0, y0, clr);
+                if (diff >= 0) {
+                    diff -= 2 * dx;
+                    y0 += y_step;
+                }
+                diff += 2 * dy;
                 x0 += x_step;
             }
-            if (diff <= dx) {
-                err += dx;
+        } else {
+            int diff = 2 * dx - dy;
+            for (int i = 0; i < dy + 1; i++) {
+                draw_pixel(x0, y0, clr);
+                if (diff >= 0) {
+                    diff -= 2 * dy;
+                    x0 += x_step;
+                }
+                diff += 2 * dx;
                 y0 += y_step;
             }
         }
@@ -402,6 +413,130 @@ flip_buffer(void) {
     // }
 }
 
+#define DEC_BIG_LUT 1
+
+#if DEC_BIG_LUT
+static u32 dec_byte_flip_x[256] = {
+    0x00000000, 0x00000001, 0x00000010, 0x00000011, 0x00000100,
+    0x00000101, 0x00000110, 0x00000111, 0x00001000, 0x00001001,
+    0x00001010, 0x00001011, 0x00001100, 0x00001101, 0x00001110,
+    0x00001111, 0x00010000, 0x00010001, 0x00010010, 0x00010011,
+    0x00010100, 0x00010101, 0x00010110, 0x00010111, 0x00011000,
+    0x00011001, 0x00011010, 0x00011011, 0x00011100, 0x00011101,
+    0x00011110, 0x00011111, 0x00100000, 0x00100001, 0x00100010,
+    0x00100011, 0x00100100, 0x00100101, 0x00100110, 0x00100111,
+    0x00101000, 0x00101001, 0x00101010, 0x00101011, 0x00101100,
+    0x00101101, 0x00101110, 0x00101111, 0x00110000, 0x00110001,
+    0x00110010, 0x00110011, 0x00110100, 0x00110101, 0x00110110,
+    0x00110111, 0x00111000, 0x00111001, 0x00111010, 0x00111011,
+    0x00111100, 0x00111101, 0x00111110, 0x00111111, 0x01000000,
+    0x01000001, 0x01000010, 0x01000011, 0x01000100, 0x01000101,
+    0x01000110, 0x01000111, 0x01001000, 0x01001001, 0x01001010,
+    0x01001011, 0x01001100, 0x01001101, 0x01001110, 0x01001111,
+    0x01010000, 0x01010001, 0x01010010, 0x01010011, 0x01010100,
+    0x01010101, 0x01010110, 0x01010111, 0x01011000, 0x01011001,
+    0x01011010, 0x01011011, 0x01011100, 0x01011101, 0x01011110,
+    0x01011111, 0x01100000, 0x01100001, 0x01100010, 0x01100011,
+    0x01100100, 0x01100101, 0x01100110, 0x01100111, 0x01101000,
+    0x01101001, 0x01101010, 0x01101011, 0x01101100, 0x01101101,
+    0x01101110, 0x01101111, 0x01110000, 0x01110001, 0x01110010,
+    0x01110011, 0x01110100, 0x01110101, 0x01110110, 0x01110111,
+    0x01111000, 0x01111001, 0x01111010, 0x01111011, 0x01111100,
+    0x01111101, 0x01111110, 0x01111111, 0x10000000, 0x10000001,
+    0x10000010, 0x10000011, 0x10000100, 0x10000101, 0x10000110,
+    0x10000111, 0x10001000, 0x10001001, 0x10001010, 0x10001011,
+    0x10001100, 0x10001101, 0x10001110, 0x10001111, 0x10010000,
+    0x10010001, 0x10010010, 0x10010011, 0x10010100, 0x10010101,
+    0x10010110, 0x10010111, 0x10011000, 0x10011001, 0x10011010,
+    0x10011011, 0x10011100, 0x10011101, 0x10011110, 0x10011111,
+    0x10100000, 0x10100001, 0x10100010, 0x10100011, 0x10100100,
+    0x10100101, 0x10100110, 0x10100111, 0x10101000, 0x10101001,
+    0x10101010, 0x10101011, 0x10101100, 0x10101101, 0x10101110,
+    0x10101111, 0x10110000, 0x10110001, 0x10110010, 0x10110011,
+    0x10110100, 0x10110101, 0x10110110, 0x10110111, 0x10111000,
+    0x10111001, 0x10111010, 0x10111011, 0x10111100, 0x10111101,
+    0x10111110, 0x10111111, 0x11000000, 0x11000001, 0x11000010,
+    0x11000011, 0x11000100, 0x11000101, 0x11000110, 0x11000111,
+    0x11001000, 0x11001001, 0x11001010, 0x11001011, 0x11001100,
+    0x11001101, 0x11001110, 0x11001111, 0x11010000, 0x11010001,
+    0x11010010, 0x11010011, 0x11010100, 0x11010101, 0x11010110,
+    0x11010111, 0x11011000, 0x11011001, 0x11011010, 0x11011011,
+    0x11011100, 0x11011101, 0x11011110, 0x11011111, 0x11100000,
+    0x11100001, 0x11100010, 0x11100011, 0x11100100, 0x11100101,
+    0x11100110, 0x11100111, 0x11101000, 0x11101001, 0x11101010,
+    0x11101011, 0x11101100, 0x11101101, 0x11101110, 0x11101111,
+    0x11110000, 0x11110001, 0x11110010, 0x11110011, 0x11110100,
+    0x11110101, 0x11110110, 0x11110111, 0x11111000, 0x11111001,
+    0x11111010, 0x11111011, 0x11111100, 0x11111101, 0x11111110,
+    0x11111111
+};
+
+static u32 dec_byte[256] = {
+    0x00000000, 0x10000000, 0x01000000, 0x11000000, 0x00100000,
+    0x10100000, 0x01100000, 0x11100000, 0x00010000, 0x10010000,
+    0x01010000, 0x11010000, 0x00110000, 0x10110000, 0x01110000,
+    0x11110000, 0x00001000, 0x10001000, 0x01001000, 0x11001000,
+    0x00101000, 0x10101000, 0x01101000, 0x11101000, 0x00011000,
+    0x10011000, 0x01011000, 0x11011000, 0x00111000, 0x10111000,
+    0x01111000, 0x11111000, 0x00000100, 0x10000100, 0x01000100,
+    0x11000100, 0x00100100, 0x10100100, 0x01100100, 0x11100100,
+    0x00010100, 0x10010100, 0x01010100, 0x11010100, 0x00110100,
+    0x10110100, 0x01110100, 0x11110100, 0x00001100, 0x10001100,
+    0x01001100, 0x11001100, 0x00101100, 0x10101100, 0x01101100,
+    0x11101100, 0x00011100, 0x10011100, 0x01011100, 0x11011100,
+    0x00111100, 0x10111100, 0x01111100, 0x11111100, 0x00000010,
+    0x10000010, 0x01000010, 0x11000010, 0x00100010, 0x10100010,
+    0x01100010, 0x11100010, 0x00010010, 0x10010010, 0x01010010,
+    0x11010010, 0x00110010, 0x10110010, 0x01110010, 0x11110010,
+    0x00001010, 0x10001010, 0x01001010, 0x11001010, 0x00101010,
+    0x10101010, 0x01101010, 0x11101010, 0x00011010, 0x10011010,
+    0x01011010, 0x11011010, 0x00111010, 0x10111010, 0x01111010,
+    0x11111010, 0x00000110, 0x10000110, 0x01000110, 0x11000110,
+    0x00100110, 0x10100110, 0x01100110, 0x11100110, 0x00010110,
+    0x10010110, 0x01010110, 0x11010110, 0x00110110, 0x10110110,
+    0x01110110, 0x11110110, 0x00001110, 0x10001110, 0x01001110,
+    0x11001110, 0x00101110, 0x10101110, 0x01101110, 0x11101110,
+    0x00011110, 0x10011110, 0x01011110, 0x11011110, 0x00111110,
+    0x10111110, 0x01111110, 0x11111110, 0x00000001, 0x10000001,
+    0x01000001, 0x11000001, 0x00100001, 0x10100001, 0x01100001,
+    0x11100001, 0x00010001, 0x10010001, 0x01010001, 0x11010001,
+    0x00110001, 0x10110001, 0x01110001, 0x11110001, 0x00001001,
+    0x10001001, 0x01001001, 0x11001001, 0x00101001, 0x10101001,
+    0x01101001, 0x11101001, 0x00011001, 0x10011001, 0x01011001,
+    0x11011001, 0x00111001, 0x10111001, 0x01111001, 0x11111001,
+    0x00000101, 0x10000101, 0x01000101, 0x11000101, 0x00100101,
+    0x10100101, 0x01100101, 0x11100101, 0x00010101, 0x10010101,
+    0x01010101, 0x11010101, 0x00110101, 0x10110101, 0x01110101,
+    0x11110101, 0x00001101, 0x10001101, 0x01001101, 0x11001101,
+    0x00101101, 0x10101101, 0x01101101, 0x11101101, 0x00011101,
+    0x10011101, 0x01011101, 0x11011101, 0x00111101, 0x10111101,
+    0x01111101, 0x11111101, 0x00000011, 0x10000011, 0x01000011,
+    0x11000011, 0x00100011, 0x10100011, 0x01100011, 0x11100011,
+    0x00010011, 0x10010011, 0x01010011, 0x11010011, 0x00110011,
+    0x10110011, 0x01110011, 0x11110011, 0x00001011, 0x10001011,
+    0x01001011, 0x11001011, 0x00101011, 0x10101011, 0x01101011,
+    0x11101011, 0x00011011, 0x10011011, 0x01011011, 0x11011011,
+    0x00111011, 0x10111011, 0x01111011, 0x11111011, 0x00000111,
+    0x10000111, 0x01000111, 0x11000111, 0x00100111, 0x10100111,
+    0x01100111, 0x11100111, 0x00010111, 0x10010111, 0x01010111,
+    0x11010111, 0x00110111, 0x10110111, 0x01110111, 0x11110111,
+    0x00001111, 0x10001111, 0x01001111, 0x11001111, 0x00101111,
+    0x10101111, 0x01101111, 0x11101111, 0x00011111, 0x10011111,
+    0x01011111, 0x11011111, 0x00111111, 0x10111111, 0x01111111,
+    0x11111111
+};
+
+IWRAM_CODE
+static inline
+u32
+decode_1bpp(u8 row, u8 flip_x) {
+    if (flip_x) {
+        return dec_byte_flip_x[row];
+    }
+    return dec_byte[row];
+}
+
+#else
 static u16 dec_nibble[] = {
     0x0000, 0x1000, 0x0100, 0x1100,
     0x0010, 0x1010, 0x0110, 0x1110,
@@ -427,6 +562,7 @@ decode_1bpp(u8 row, u8 flip_x) {
     u16 *lut = dec_nibble;
     return (u32)lut[(row >> 0) & 0xF] << 16 | (u32)lut[(row >> 4) & 0xF];
 }
+#endif
 
 IWRAM_CODE
 static inline
@@ -441,18 +577,34 @@ draw_2bpp_row(size_t x, size_t y, u8 a, u8 b, u8 flip_x) {
     size_t shift_left = start_col * 4;
     size_t shift_right = (8 - start_col) * 4;
 
-    u32 *dst = &backbuf[tile_x * 8 + tile_y * 8 * 32 + start_row];
+    u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
+#if DEC_BIG_LUT
+    u32 *lut = dec_byte;
+    if (flip_x) {
+        lut = dec_byte_flip_x;
+    }
+#endif
     if (start_col == 0) {
+#if DEC_BIG_LUT
+        u32 clr_a = lut[a];
+        u32 clr_b = lut[b];
+#else
         u32 clr_a = decode_1bpp(a, flip_x);
         u32 clr_b = decode_1bpp(b, flip_x);
+#endif
         u32 mask_a = (clr_a * 0xF);
         u32 mask_b = (clr_b * 0xF);
         u32 mask = (mask_a | mask_b);
         u32 color = clr_a + (clr_b << 1);
         dst[0] = (dst[0] & ~mask) | color;
     } else {
+#if DEC_BIG_LUT
+        u32 clr_a = lut[a];
+        u32 clr_b = lut[b];
+#else
         u32 clr_a = decode_1bpp(a, flip_x);
         u32 clr_b = decode_1bpp(b, flip_x);
+#endif
         u32 mask_a = (clr_a * 0xF);
         u32 mask_b = (clr_b * 0xF);
         u32 mask = (mask_a | mask_b);
@@ -477,7 +629,7 @@ draw_1bpp_row(size_t x, size_t y, u8 a, u8 clr, u8 flip_x) {
     size_t shift_left = start_col * 4;
     size_t shift_right = (8 - start_col) * 4;
 
-    u32 *dst = &backbuf[tile_x * 8 + tile_y * 8 * 32];
+    u32 *dst = &backbuf[(tile_x + tile_y * 32) * 8];
     dst += start_row;
     if (start_col == 0) {
         u32 color = decode_1bpp(a, flip_x);