Add biglut 1bpp row decoding for m4

3 files changed, 159 insertions, 237 deletions

diff --git a/src/main.c b/src/main.c
index 29e420d..fa4457a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -11,7 +11,7 @@ WITH REGARD TO THIS SOFTWARE.
 
 #include "gba/gba.h"
 
-#include "renderer_m0.c"
+#include "renderer_m4.c"
 
 //
 // Config parameters.
@@ -143,8 +143,8 @@ int main(void) {
         //draw_line(239, 81, 0, 129, 3);
         ////// right -> left && bot -> top
         //draw_line(239, 129, 0, 40, 5);
-            txt_render();
-            txt_clear();
+            // txt_render();
+            // txt_clear();
 
         // draw_line(239, 149, 0, 10, 3);
 
@@ -159,10 +159,10 @@ int main(void) {
         // txt_render();
         // txt_clear();
         PROF(test_lines(), test_lines_cycles);
-        // PROF(test_rect(), test_rect_cycles);
-        // PROF(test_fill_rect(), test_fill_rect_cycles);
-        // PROF(test_chr(), test_chr_cycles);
-        // PROF(test_icn(), test_icn_cycles);
+        PROF(test_rect(), test_rect_cycles);
+        PROF(test_fill_rect(), test_fill_rect_cycles);
+        PROF(test_chr(), test_chr_cycles);
+        PROF(test_icn(), test_icn_cycles);
         draw_filled_rect(0, 0, 140, 60, 0);
         PROF_SHOW();
         PROF(flip_buffer(), flip_cycles);
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index ece7dbb..7dd5b22 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -178,193 +178,6 @@ 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 1
-
-        // Fixed Precision constants.
-        const int fp_bit = 6;
-        const int fp_one = FP_NUM(1, fp_bit);
-        const int fp_half = fp_one >> 1;
-
-        int dx = x0 > x1 ? x0 - x1 : x1 - x0;
-        int dy = y0 > y1 ? y0 - y1 : y1 - y0;
-        int dxf = (dx << fp_bit);
-        int dyf = (dy << fp_bit);
-
-        if ((dx >= dy && x0 > x1) || (dx < dy && y0 > y1)) {
-            SWAP(x0, x1);
-            SWAP(y0, y1);
-        }
-
-        int frac_x = x0 > x1 ? FP_NUM(x0 - x1, fp_bit) : FP_NUM(x1 - x0, fp_bit);
-        int frac_y = y0 > y1 ? FP_NUM(y0 - y1, fp_bit) : FP_NUM(y1 - y0, fp_bit);
-        int x_step = x0 > x1 ? -1 : 1;
-        int y_step = y0 > y1 ? -1 : 1;
-        int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
-
-        //
-        // DEBUG: reference
-        // for (int i = 0; i <= dx; i++) {
-        //     if (distance >= 0) {
-        //         distance -= 2 * dxf;
-        //         y0 += y_step;
-        //     }
-        //     draw_pixel(x0, y0, clr);
-        //     distance += 2 * dyf;
-        //     x0 += x_step;
-        // }
-        //
-
-        size_t tile_x = x0 / 8;
-        size_t tile_y = y0 / 8;
-        size_t start_col = x0 % 8;
-        size_t start_row = y0 % 8;
-        u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
-
-        // Update backbuffer.
-        if (dx >= dy) {
-            int step = dxf / dyf;
-            int remaining = dx;
-
-            //
-            // NOTE: Reference with pointers.
-            // for (int i = 0; i <= dx; i++) {
-            //     start_col = x0 % 8;
-            //     start_row = y0 % 8;
-            //     size_t shift = start_col * sizeof(u32);
-            //     u32 mask = 0xF << shift;
-            //     u32 row = clr << shift;
-            //     if (distance >= 0) {
-            //         distance -= 2 * dxf;
-            //         y0 += y_step;
-            //         if (((int)start_row + y_step) >=  8 || ((int)start_row + y_step) < 0) {
-            //             dst += 8 * 31 * y_step;
-            //         }
-            //         dst += y_step;
-            //     }
-            //     *dst = (*dst & ~mask) | row;
-            //     distance += 2 * dyf;
-            //     if ((int)(start_col + x_step) >= 8 ||(int)(start_col + x_step) < 0) {
-            //         dst += 8;
-            //     }
-            //     x0 += x_step;
-            // }
-            //
-
-            while (remaining > (step - 1)) {
-                distance += step * 2 * dyf;
-                size_t start_row = y0 % 8;
-                u32 a = x0;
-                size_t start_col = a % 8;
-                size_t tile_x0 = a / 8;
-                size_t shift_left = start_col * 4;
-                if (distance >= 0) {
-                    u32 b = x0 + step - 1;
-                    size_t tile_x1 = b / 8;
-                    size_t end_col = b % 8;
-                    size_t shift_right = (7 - end_col) * 4;
-                    size_t dtx = tile_x1 - tile_x0;
-                    if (dtx < 1) {
-                        u32 mask = (0xFFFFFFFF >> shift_right) & (0xFFFFFFFF << shift_left);
-                        u32 row = (0x11111111 * clr) & mask;
-                        *dst = (*dst & ~mask) | row;
-                        if ((start_col + x_step) >= 8 || end_col == 7) {
-                            dst += 8 * x_step;
-                        }
-                    } else {
-                        u32 mask = 0xFFFFFFFF;
-                        u32 row = 0x11111111 * clr;
-                        *dst = (*dst & ~(mask << shift_left)) | (row << shift_left);
-                        dst += 8 * x_step;
-                        for (size_t i = 1; i < dtx; i++) {
-                            *dst = row;
-                            dst += 8 * x_step;
-                        }
-                        *dst = (*dst & ~(mask >> shift_right)) | (row >> shift_right);
-                        if (end_col == 7) {
-                            dst += 8 * x_step;
-                        }
-                    }
-                    // draw_hline(a, b, y0, clr);
-                    x0 += step;
-                    remaining -= step;
-                } else {
-                    if (remaining < step) {
-                        break;
-                    }
-                    u32 b = x0 + step;
-                    size_t tile_x1 = b / 8;
-                    size_t end_col = b % 8;
-                    size_t dtx = tile_x1 - tile_x0;
-                    size_t shift_right = (7 - end_col) * 4;
-                    if (dtx < 1) {
-                        u32 mask = (0xFFFFFFFF >> shift_right) & (0xFFFFFFFF << shift_left);
-                        u32 row = (0x11111111 * clr) & mask;
-                        *dst = (*dst & ~mask) | row;
-                        if ((start_col + x_step) >= 8 || end_col == 7) {
-                            dst += 8 * x_step;
-                        }
-                    } else {
-                        u32 mask = 0xFFFFFFFF;
-                        u32 row = 0x11111111 * clr;
-                        *dst = (*dst & ~(mask << shift_left)) | (row << shift_left);
-                        dst += 8 * x_step;
-                        for (size_t i = 1; i < dtx; i++) {
-                            *dst = row;
-                            dst += 8 * x_step;
-                        }
-                        *dst = (*dst & ~(mask >> shift_right)) | (row >> shift_right);
-                        if (end_col == 7) {
-                            dst += 8 * x_step;
-                        }
-                    }
-                    // draw_hline(a, b, y0, clr);
-                    distance += 2 * dyf;
-                    x0 += (step + 1);
-                    remaining -= step + 1;
-                }
-                if (((int)start_row + y_step) >=  8 || ((int)start_row + y_step) < 0) {
-                    dst += 8 * 31 * y_step;
-                }
-                dst += y_step;
-                distance -= 2 * dxf;
-                y0 += y_step;
-            }
-            if (remaining >= 0) {
-                draw_hline(x0, x0 + remaining, y0, clr);
-            }
-
-        // for (int i = 0; i <= dx; i++) {
-        //     if (distance >= 0) {
-        //         distance -= 2 * dxf;
-        //         y0 += y_step;
-        //     }
-        //     draw_pixel(x0, y0, clr);
-        //     distance += 2 * dyf;
-        //     x0 += x_step;
-        // }
-        } else {
-            // int step = dyf / dxf;
-            // int remaining = dy;
-            // while (remaining > (step - 1)) {
-            //         distance += step * 2 * dxf;
-            //         if (distance >= 0) {
-            //             draw_vline(x0, y0, y0 + step - 1, clr);
-            //             y0 += y_step * step;
-            //             remaining -= step;
-            //         } else {
-            //             draw_vline(x0, y0, y0 + step, clr);
-            //             distance += 2 * dxf;
-            //             y0 += y_step * (step + 1);
-            //             remaining -= step + 1;
-            //         }
-            //         distance -= 2 * dyf;
-            //         x0 += x_step;
-            // }
-            // if (remaining >= 0) {
-            //     draw_vline(x0, y0, y0 + remaining, clr);
-            // }
-        }
-#else
         // Fixed Precision constants.
         const int fp_bit = 6;
         const int fp_one = FP_NUM(1, fp_bit);
@@ -431,7 +244,6 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 draw_vline(x0, y0, y0 + remaining, clr);
             }
         }
-#endif
     }
 }
 
@@ -780,32 +592,19 @@ draw_2bpp_row(size_t x, size_t y, u8 a, u8 b, u8 flip_x) {
     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];
+    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);
+    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);
+    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);
+    if (start_col == 0) {
         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);
-        u32 color = clr_a + (clr_b << 1);
         dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
         dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
     }
@@ -826,17 +625,13 @@ 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 + tile_y * 32) * 8];
-    dst += start_row;
+    u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
+    u32 color = decode_1bpp(a, flip_x);
+    u32 mask = (color * 0xF);
+    color *= clr;
     if (start_col == 0) {
-        u32 color = decode_1bpp(a, flip_x);
-        u32 mask = (color * 0xF);
-        color *= clr;
         dst[0] = (dst[0] & ~mask) | color;
     } else {
-        u32 color = decode_1bpp(a, flip_x);
-        u32 mask = (color * 0xF);
-        color *= clr;
         dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
         dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
     }
diff --git a/src/renderer_m4.c b/src/renderer_m4.c
index cc9da58..6da7996 100644
--- a/src/renderer_m4.c
+++ b/src/renderer_m4.c
@@ -210,6 +210,129 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
     screen_updated = true;
 }
 
+#define DEC_BIG_LUT 1
+
+#if DEC_BIG_LUT
+static u64 dec_byte_flip_x[256] = {
+    0x0000000000000000, 0x0000000000000001, 0x0000000000000100, 0x0000000000000101, 0x0000000000010000,
+    0x0000000000010001, 0x0000000000010100, 0x0000000000010101, 0x0000000001000000, 0x0000000001000001,
+    0x0000000001000100, 0x0000000001000101, 0x0000000001010000, 0x0000000001010001, 0x0000000001010100,
+    0x0000000001010101, 0x0000000100000000, 0x0000000100000001, 0x0000000100000100, 0x0000000100000101,
+    0x0000000100010000, 0x0000000100010001, 0x0000000100010100, 0x0000000100010101, 0x0000000101000000,
+    0x0000000101000001, 0x0000000101000100, 0x0000000101000101, 0x0000000101010000, 0x0000000101010001,
+    0x0000000101010100, 0x0000000101010101, 0x0000010000000000, 0x0000010000000001, 0x0000010000000100,
+    0x0000010000000101, 0x0000010000010000, 0x0000010000010001, 0x0000010000010100, 0x0000010000010101,
+    0x0000010001000000, 0x0000010001000001, 0x0000010001000100, 0x0000010001000101, 0x0000010001010000,
+    0x0000010001010001, 0x0000010001010100, 0x0000010001010101, 0x0000010100000000, 0x0000010100000001,
+    0x0000010100000100, 0x0000010100000101, 0x0000010100010000, 0x0000010100010001, 0x0000010100010100,
+    0x0000010100010101, 0x0000010101000000, 0x0000010101000001, 0x0000010101000100, 0x0000010101000101,
+    0x0000010101010000, 0x0000010101010001, 0x0000010101010100, 0x0000010101010101, 0x0001000000000000,
+    0x0001000000000001, 0x0001000000000100, 0x0001000000000101, 0x0001000000010000, 0x0001000000010001,
+    0x0001000000010100, 0x0001000000010101, 0x0001000001000000, 0x0001000001000001, 0x0001000001000100,
+    0x0001000001000101, 0x0001000001010000, 0x0001000001010001, 0x0001000001010100, 0x0001000001010101,
+    0x0001000100000000, 0x0001000100000001, 0x0001000100000100, 0x0001000100000101, 0x0001000100010000,
+    0x0001000100010001, 0x0001000100010100, 0x0001000100010101, 0x0001000101000000, 0x0001000101000001,
+    0x0001000101000100, 0x0001000101000101, 0x0001000101010000, 0x0001000101010001, 0x0001000101010100,
+    0x0001000101010101, 0x0001010000000000, 0x0001010000000001, 0x0001010000000100, 0x0001010000000101,
+    0x0001010000010000, 0x0001010000010001, 0x0001010000010100, 0x0001010000010101, 0x0001010001000000,
+    0x0001010001000001, 0x0001010001000100, 0x0001010001000101, 0x0001010001010000, 0x0001010001010001,
+    0x0001010001010100, 0x0001010001010101, 0x0001010100000000, 0x0001010100000001, 0x0001010100000100,
+    0x0001010100000101, 0x0001010100010000, 0x0001010100010001, 0x0001010100010100, 0x0001010100010101,
+    0x0001010101000000, 0x0001010101000001, 0x0001010101000100, 0x0001010101000101, 0x0001010101010000,
+    0x0001010101010001, 0x0001010101010100, 0x0001010101010101, 0x0100000000000000, 0x0100000000000001,
+    0x0100000000000100, 0x0100000000000101, 0x0100000000010000, 0x0100000000010001, 0x0100000000010100,
+    0x0100000000010101, 0x0100000001000000, 0x0100000001000001, 0x0100000001000100, 0x0100000001000101,
+    0x0100000001010000, 0x0100000001010001, 0x0100000001010100, 0x0100000001010101, 0x0100000100000000,
+    0x0100000100000001, 0x0100000100000100, 0x0100000100000101, 0x0100000100010000, 0x0100000100010001,
+    0x0100000100010100, 0x0100000100010101, 0x0100000101000000, 0x0100000101000001, 0x0100000101000100,
+    0x0100000101000101, 0x0100000101010000, 0x0100000101010001, 0x0100000101010100, 0x0100000101010101,
+    0x0100010000000000, 0x0100010000000001, 0x0100010000000100, 0x0100010000000101, 0x0100010000010000,
+    0x0100010000010001, 0x0100010000010100, 0x0100010000010101, 0x0100010001000000, 0x0100010001000001,
+    0x0100010001000100, 0x0100010001000101, 0x0100010001010000, 0x0100010001010001, 0x0100010001010100,
+    0x0100010001010101, 0x0100010100000000, 0x0100010100000001, 0x0100010100000100, 0x0100010100000101,
+    0x0100010100010000, 0x0100010100010001, 0x0100010100010100, 0x0100010100010101, 0x0100010101000000,
+    0x0100010101000001, 0x0100010101000100, 0x0100010101000101, 0x0100010101010000, 0x0100010101010001,
+    0x0100010101010100, 0x0100010101010101, 0x0101000000000000, 0x0101000000000001, 0x0101000000000100,
+    0x0101000000000101, 0x0101000000010000, 0x0101000000010001, 0x0101000000010100, 0x0101000000010101,
+    0x0101000001000000, 0x0101000001000001, 0x0101000001000100, 0x0101000001000101, 0x0101000001010000,
+    0x0101000001010001, 0x0101000001010100, 0x0101000001010101, 0x0101000100000000, 0x0101000100000001,
+    0x0101000100000100, 0x0101000100000101, 0x0101000100010000, 0x0101000100010001, 0x0101000100010100,
+    0x0101000100010101, 0x0101000101000000, 0x0101000101000001, 0x0101000101000100, 0x0101000101000101,
+    0x0101000101010000, 0x0101000101010001, 0x0101000101010100, 0x0101000101010101, 0x0101010000000000,
+    0x0101010000000001, 0x0101010000000100, 0x0101010000000101, 0x0101010000010000, 0x0101010000010001,
+    0x0101010000010100, 0x0101010000010101, 0x0101010001000000, 0x0101010001000001, 0x0101010001000100,
+    0x0101010001000101, 0x0101010001010000, 0x0101010001010001, 0x0101010001010100, 0x0101010001010101,
+    0x0101010100000000, 0x0101010100000001, 0x0101010100000100, 0x0101010100000101, 0x0101010100010000,
+    0x0101010100010001, 0x0101010100010100, 0x0101010100010101, 0x0101010101000000, 0x0101010101000001,
+    0x0101010101000100, 0x0101010101000101, 0x0101010101010000, 0x0101010101010001, 0x0101010101010100,
+    0x0101010101010101
+};
+
+static u64 dec_byte[256] = {
+    0x0000000000000000, 0x0100000000000000, 0x0001000000000000, 0x0101000000000000, 0x0000010000000000,
+    0x0100010000000000, 0x0001010000000000, 0x0101010000000000, 0x0000000100000000, 0x0100000100000000,
+    0x0001000100000000, 0x0101000100000000, 0x0000010100000000, 0x0100010100000000, 0x0001010100000000,
+    0x0101010100000000, 0x0000000001000000, 0x0100000001000000, 0x0001000001000000, 0x0101000001000000,
+    0x0000010001000000, 0x0100010001000000, 0x0001010001000000, 0x0101010001000000, 0x0000000101000000,
+    0x0100000101000000, 0x0001000101000000, 0x0101000101000000, 0x0000010101000000, 0x0100010101000000,
+    0x0001010101000000, 0x0101010101000000, 0x0000000000010000, 0x0100000000010000, 0x0001000000010000,
+    0x0101000000010000, 0x0000010000010000, 0x0100010000010000, 0x0001010000010000, 0x0101010000010000,
+    0x0000000100010000, 0x0100000100010000, 0x0001000100010000, 0x0101000100010000, 0x0000010100010000,
+    0x0100010100010000, 0x0001010100010000, 0x0101010100010000, 0x0000000001010000, 0x0100000001010000,
+    0x0001000001010000, 0x0101000001010000, 0x0000010001010000, 0x0100010001010000, 0x0001010001010000,
+    0x0101010001010000, 0x0000000101010000, 0x0100000101010000, 0x0001000101010000, 0x0101000101010000,
+    0x0000010101010000, 0x0100010101010000, 0x0001010101010000, 0x0101010101010000, 0x0000000000000100,
+    0x0100000000000100, 0x0001000000000100, 0x0101000000000100, 0x0000010000000100, 0x0100010000000100,
+    0x0001010000000100, 0x0101010000000100, 0x0000000100000100, 0x0100000100000100, 0x0001000100000100,
+    0x0101000100000100, 0x0000010100000100, 0x0100010100000100, 0x0001010100000100, 0x0101010100000100,
+    0x0000000001000100, 0x0100000001000100, 0x0001000001000100, 0x0101000001000100, 0x0000010001000100,
+    0x0100010001000100, 0x0001010001000100, 0x0101010001000100, 0x0000000101000100, 0x0100000101000100,
+    0x0001000101000100, 0x0101000101000100, 0x0000010101000100, 0x0100010101000100, 0x0001010101000100,
+    0x0101010101000100, 0x0000000000010100, 0x0100000000010100, 0x0001000000010100, 0x0101000000010100,
+    0x0000010000010100, 0x0100010000010100, 0x0001010000010100, 0x0101010000010100, 0x0000000100010100,
+    0x0100000100010100, 0x0001000100010100, 0x0101000100010100, 0x0000010100010100, 0x0100010100010100,
+    0x0001010100010100, 0x0101010100010100, 0x0000000001010100, 0x0100000001010100, 0x0001000001010100,
+    0x0101000001010100, 0x0000010001010100, 0x0100010001010100, 0x0001010001010100, 0x0101010001010100,
+    0x0000000101010100, 0x0100000101010100, 0x0001000101010100, 0x0101000101010100, 0x0000010101010100,
+    0x0100010101010100, 0x0001010101010100, 0x0101010101010100, 0x0000000000000001, 0x0100000000000001,
+    0x0001000000000001, 0x0101000000000001, 0x0000010000000001, 0x0100010000000001, 0x0001010000000001,
+    0x0101010000000001, 0x0000000100000001, 0x0100000100000001, 0x0001000100000001, 0x0101000100000001,
+    0x0000010100000001, 0x0100010100000001, 0x0001010100000001, 0x0101010100000001, 0x0000000001000001,
+    0x0100000001000001, 0x0001000001000001, 0x0101000001000001, 0x0000010001000001, 0x0100010001000001,
+    0x0001010001000001, 0x0101010001000001, 0x0000000101000001, 0x0100000101000001, 0x0001000101000001,
+    0x0101000101000001, 0x0000010101000001, 0x0100010101000001, 0x0001010101000001, 0x0101010101000001,
+    0x0000000000010001, 0x0100000000010001, 0x0001000000010001, 0x0101000000010001, 0x0000010000010001,
+    0x0100010000010001, 0x0001010000010001, 0x0101010000010001, 0x0000000100010001, 0x0100000100010001,
+    0x0001000100010001, 0x0101000100010001, 0x0000010100010001, 0x0100010100010001, 0x0001010100010001,
+    0x0101010100010001, 0x0000000001010001, 0x0100000001010001, 0x0001000001010001, 0x0101000001010001,
+    0x0000010001010001, 0x0100010001010001, 0x0001010001010001, 0x0101010001010001, 0x0000000101010001,
+    0x0100000101010001, 0x0001000101010001, 0x0101000101010001, 0x0000010101010001, 0x0100010101010001,
+    0x0001010101010001, 0x0101010101010001, 0x0000000000000101, 0x0100000000000101, 0x0001000000000101,
+    0x0101000000000101, 0x0000010000000101, 0x0100010000000101, 0x0001010000000101, 0x0101010000000101,
+    0x0000000100000101, 0x0100000100000101, 0x0001000100000101, 0x0101000100000101, 0x0000010100000101,
+    0x0100010100000101, 0x0001010100000101, 0x0101010100000101, 0x0000000001000101, 0x0100000001000101,
+    0x0001000001000101, 0x0101000001000101, 0x0000010001000101, 0x0100010001000101, 0x0001010001000101,
+    0x0101010001000101, 0x0000000101000101, 0x0100000101000101, 0x0001000101000101, 0x0101000101000101,
+    0x0000010101000101, 0x0100010101000101, 0x0001010101000101, 0x0101010101000101, 0x0000000000010101,
+    0x0100000000010101, 0x0001000000010101, 0x0101000000010101, 0x0000010000010101, 0x0100010000010101,
+    0x0001010000010101, 0x0101010000010101, 0x0000000100010101, 0x0100000100010101, 0x0001000100010101,
+    0x0101000100010101, 0x0000010100010101, 0x0100010100010101, 0x0001010100010101, 0x0101010100010101,
+    0x0000000001010101, 0x0100000001010101, 0x0001000001010101, 0x0101000001010101, 0x0000010001010101,
+    0x0100010001010101, 0x0001010001010101, 0x0101010001010101, 0x0000000101010101, 0x0100000101010101,
+    0x0001000101010101, 0x0101000101010101, 0x0000010101010101, 0x0100010101010101, 0x0001010101010101,
+    0x0101010101010101
+};
+IWRAM_CODE
+static inline
+u64
+decode_1bpp(u8 row, u8 flip_x) {
+    if (flip_x) {
+        return dec_byte_flip_x[row];
+    }
+    return dec_byte[row];
+}
+#else
+
 static u32 dec_nibble[] = {
     0x00000000, 0x01000000, 0x00010000, 0x01010000,
     0x00000100, 0x01000100, 0x00010100, 0x01010100,
@@ -235,6 +358,7 @@ decode_1bpp(u8 row, u8 flip_x) {
     u32 *lut = dec_nibble;
     return (u64)lut[(row >> 0) & 0xF] << 32 | (u64)lut[(row >> 4) & 0xF];
 }
+#endif
 
 IWRAM_CODE
 static inline
@@ -248,21 +372,24 @@ draw_2bpp_row(size_t x, size_t y, u8 a, u8 b, u8 flip_x) {
     size_t shift_right = (8 - start_col) * 8;
 
     u64 *dst = &backbuf[(y * 30 + tile_x) * 8 / 2];
+#if DEC_BIG_LUT
+    u64 *lut = dec_byte;
+    if (flip_x) {
+        lut = dec_byte_flip_x;
+    }
+    u64 clr_a = lut[a];
+    u64 clr_b = lut[b];
+#else
+    u64 clr_a = decode_1bpp(a, flip_x);
+    u64 clr_b = decode_1bpp(b, flip_x);
+#endif
+    u64 mask_a = (clr_a * 0xF);
+    u64 mask_b = (clr_b * 0xF);
+    u64 mask = (mask_a | mask_b);
+    u64 color = clr_a + (clr_b << 1);
     if (start_col == 0) {
-        u64 clr_a = decode_1bpp(a, flip_x);
-        u64 clr_b = decode_1bpp(b, flip_x);
-        u64 mask_a = (clr_a * 0xF);
-        u64 mask_b = (clr_b * 0xF);
-        u64 mask = (mask_a | mask_b);
-        u64 color = clr_a + (clr_b << 1);
         dst[0] = (dst[0] & ~mask) | color;
     } else {
-        u64 clr_a = decode_1bpp(a, flip_x);
-        u64 clr_b = decode_1bpp(b, flip_x);
-        u64 mask_a = (clr_a * 0xF);
-        u64 mask_b = (clr_b * 0xF);
-        u64 mask = (mask_a | mask_b);
-        u64 color = clr_a + (clr_b << 1);
         dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
         if ((x + 7) > (SCREEN_WIDTH)) {
             return;