Quantum Painter (#10174)

* Install dependencies before executing unit tests.

* Split out UTF-8 decoder.

* Fixup python formatting rules.

* Add documentation for QGF/QFF and the RLE format used.

* Add CLI commands for converting images and fonts.

* Add stub rules.mk for QP.

* Add stream type.

* Add base driver and comms interfaces.

* Add support for SPI, SPI+D/C comms drivers.

* Include <qp.h> when enabled.

* Add base support for SPI+D/C+RST panels, as well as concrete implementation of ST7789.

* Add support for GC9A01.

* Add support for ILI9341.

* Add support for ILI9163.

* Add support for SSD1351.

* Implement qp_setpixel, including pixdata buffer management.

* Implement qp_line.

* Implement qp_rect.

* Implement qp_circle.

* Implement qp_ellipse.

* Implement palette interpolation.

* Allow for streams to work with either flash or RAM.

* Image loading.

* Font loading.

* QGF palette loading.

* Progressive decoder of pixel data supporting Raw+RLE, 1-,2-,4-,8-bpp monochrome and palette-based images.

* Image drawing.

* Animations.

* Font rendering.

* Check against 256 colours, dump out the loaded palette if debugging enabled.

* Fix build.

* AVR is not the intended audience.

* `qmk format-c`

* Generation fix.

* First batch of docs.

* More docs and examples.

* Review comments.

* Public API documentation.

1 files changed, 294 insertions, 0 deletions

diff --git a/quantum/painter/qp_draw_core.c b/quantum/painter/qp_draw_core.c
new file mode 100644
index 0000000000..c31c734132
--- /dev/null
+++ b/quantum/painter/qp_draw_core.c
@@ -0,0 +1,294 @@
+// Copyright 2021-2022 Nick Brassel (@tzarc)
+// Copyright 2021 Paul Cotter (@gr1mr3aver)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "qp_internal.h"
+#include "qp_comms.h"
+#include "qp_draw.h"
+#include "qgf.h"
+
+_Static_assert((QUANTUM_PAINTER_PIXDATA_BUFFER_SIZE > 0) && (QUANTUM_PAINTER_PIXDATA_BUFFER_SIZE % 16) == 0, "QUANTUM_PAINTER_PIXDATA_BUFFER_SIZE needs to be a non-zero multiple of 16");
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Global variables
+//
+// NOTE: The variables in this section are intentionally outside a stack frame. They are able to be defined with larger
+//       sizes than the normal stack frames would allow, and as such need to be external.
+//
+//       **** DO NOT refactor this and decide to place the variables inside the function calling them -- you will ****
+//       **** very likely get artifacts rendered to the screen as a result.                                       ****
+//
+
+// Buffer used for transmitting native pixel data to the downstream device.
+uint8_t qp_internal_global_pixdata_buffer[QUANTUM_PAINTER_PIXDATA_BUFFER_SIZE];
+
+// Static buffer to contain a generated color palette
+static bool       generated_palette = false;
+static int16_t    generated_steps   = -1;
+static qp_pixel_t interpolated_fg_hsv888;
+static qp_pixel_t interpolated_bg_hsv888;
+#if QUANTUM_PAINTER_SUPPORTS_256_PALETTE
+qp_pixel_t qp_internal_global_pixel_lookup_table[256];
+#else
+qp_pixel_t qp_internal_global_pixel_lookup_table[16];
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Helpers
+
+uint32_t qp_internal_num_pixels_in_buffer(painter_device_t device) {
+    struct painter_driver_t *driver = (struct painter_driver_t *)device;
+    return ((QUANTUM_PAINTER_PIXDATA_BUFFER_SIZE * 8) / driver->native_bits_per_pixel);
+}
+
+// qp_setpixel internal implementation, but accepts a buffer with pre-converted native pixel. Only the first pixel is used.
+bool qp_internal_setpixel_impl(painter_device_t device, uint16_t x, uint16_t y) {
+    struct painter_driver_t *driver = (struct painter_driver_t *)device;
+    return driver->driver_vtable->viewport(device, x, y, x, y) && driver->driver_vtable->pixdata(device, qp_internal_global_pixdata_buffer, 1);
+}
+
+// Fills the global native pixel buffer with equivalent pixels matching the supplied HSV
+void qp_internal_fill_pixdata(painter_device_t device, uint32_t num_pixels, uint8_t hue, uint8_t sat, uint8_t val) {
+    struct painter_driver_t *driver            = (struct painter_driver_t *)device;
+    uint32_t                 pixels_in_pixdata = qp_internal_num_pixels_in_buffer(device);
+    num_pixels                                 = QP_MIN(pixels_in_pixdata, num_pixels);
+
+    // Convert the color to native pixel format
+    qp_pixel_t color = {.hsv888 = {.h = hue, .s = sat, .v = val}};
+    driver->driver_vtable->palette_convert(device, 1, &color);
+
+    // Append the required number of pixels
+    uint8_t palette_idx = 0;
+    for (uint32_t i = 0; i < num_pixels; ++i) {
+        driver->driver_vtable->append_pixels(device, qp_internal_global_pixdata_buffer, &color, i, 1, &palette_idx);
+    }
+}
+
+// Resets the global palette so that it can be regenerated. Only needed if the colors are identical, but a different display is used with a different internal pixel format.
+void qp_internal_invalidate_palette(void) {
+    generated_palette = false;
+    generated_steps   = -1;
+}
+
+// Interpolates between two colors to generate a palette
+bool qp_internal_interpolate_palette(qp_pixel_t fg_hsv888, qp_pixel_t bg_hsv888, int16_t steps) {
+    // Check if we need to generate a new palette -- if the input parameters match then assume the palette can stay unchanged.
+    // This may present a problem if using the same parameters but a different screen converts pixels -- use qp_internal_invalidate_palette() to reset.
+    if (generated_palette == true && generated_steps == steps && memcmp(&interpolated_fg_hsv888, &fg_hsv888, sizeof(fg_hsv888)) == 0 && memcmp(&interpolated_bg_hsv888, &bg_hsv888, sizeof(bg_hsv888)) == 0) {
+        // We already have the correct palette, no point regenerating it.
+        return false;
+    }
+
+    // Save the parameters so we know whether we can skip generation
+    generated_palette      = true;
+    generated_steps        = steps;
+    interpolated_fg_hsv888 = fg_hsv888;
+    interpolated_bg_hsv888 = bg_hsv888;
+
+    int16_t hue_fg = fg_hsv888.hsv888.h;
+    int16_t hue_bg = bg_hsv888.hsv888.h;
+
+    // Make sure we take the "shortest" route from one hue to the other
+    if ((hue_fg - hue_bg) >= 128) {
+        hue_bg += 256;
+    } else if ((hue_fg - hue_bg) <= -128) {
+        hue_bg -= 256;
+    }
+
+    // Interpolate each of the lookup table entries
+    for (int16_t i = 0; i < steps; ++i) {
+        qp_internal_global_pixel_lookup_table[i].hsv888.h = (uint8_t)((hue_fg - hue_bg) * i / (steps - 1) + hue_bg);
+        qp_internal_global_pixel_lookup_table[i].hsv888.s = (uint8_t)((fg_hsv888.hsv888.s - bg_hsv888.hsv888.s) * i / (steps - 1) + bg_hsv888.hsv888.s);
+        qp_internal_global_pixel_lookup_table[i].hsv888.v = (uint8_t)((fg_hsv888.hsv888.v - bg_hsv888.hsv888.v) * i / (steps - 1) + bg_hsv888.hsv888.v);
+
+        qp_dprintf("qp_internal_interpolate_palette: %3d of %d -- H: %3d, S: %3d, V: %3d\n", (int)(i + 1), (int)steps, (int)qp_internal_global_pixel_lookup_table[i].hsv888.h, (int)qp_internal_global_pixel_lookup_table[i].hsv888.s, (int)qp_internal_global_pixel_lookup_table[i].hsv888.v);
+    }
+
+    return true;
+}
+
+// Helper shared between image and font rendering -- sets up the global palette to match the palette block specified in the asset. Expects the stream to be positioned at the start of the block header.
+bool qp_internal_load_qgf_palette(qp_stream_t *stream, uint8_t bpp) {
+    qgf_palette_v1_t palette_descriptor;
+    if (qp_stream_read(&palette_descriptor, sizeof(qgf_palette_v1_t), 1, stream) != 1) {
+        qp_dprintf("Failed to read palette_descriptor, expected length was not %d\n", (int)sizeof(qgf_palette_v1_t));
+        return false;
+    }
+
+    // BPP determines the number of palette entries, each entry is a HSV888 triplet.
+    const uint16_t palette_entries = 1u << bpp;
+
+    // Ensure we aren't reusing any palette
+    qp_internal_invalidate_palette();
+
+    // Read the palette entries
+    for (uint16_t i = 0; i < palette_entries; ++i) {
+        // Read the palette entry
+        qgf_palette_entry_v1_t entry;
+        if (qp_stream_read(&entry, sizeof(qgf_palette_entry_v1_t), 1, stream) != 1) {
+            return false;
+        }
+
+        // Update the lookup table
+        qp_internal_global_pixel_lookup_table[i].hsv888.h = entry.h;
+        qp_internal_global_pixel_lookup_table[i].hsv888.s = entry.s;
+        qp_internal_global_pixel_lookup_table[i].hsv888.v = entry.v;
+
+        qp_dprintf("qp_internal_load_qgf_palette: %3d of %d -- H: %3d, S: %3d, V: %3d\n", (int)(i + 1), (int)palette_entries, (int)qp_internal_global_pixel_lookup_table[i].hsv888.h, (int)qp_internal_global_pixel_lookup_table[i].hsv888.s, (int)qp_internal_global_pixel_lookup_table[i].hsv888.v);
+    }
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Quantum Painter External API: qp_setpixel
+
+bool qp_setpixel(painter_device_t device, uint16_t x, uint16_t y, uint8_t hue, uint8_t sat, uint8_t val) {
+    struct painter_driver_t *driver = (struct painter_driver_t *)device;
+    if (!driver->validate_ok) {
+        qp_dprintf("qp_setpixel: fail (validation_ok == false)\n");
+        return false;
+    }
+
+    if (!qp_comms_start(device)) {
+        qp_dprintf("Failed to start comms in qp_setpixel\n");
+        return false;
+    }
+
+    qp_internal_fill_pixdata(device, 1, hue, sat, val);
+    bool ret = qp_internal_setpixel_impl(device, x, y);
+    qp_comms_stop(device);
+    qp_dprintf("qp_setpixel: %s\n", ret ? "ok" : "fail");
+    return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Quantum Painter External API: qp_line
+
+bool qp_line(painter_device_t device, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t hue, uint8_t sat, uint8_t val) {
+    if (x0 == x1 || y0 == y1) {
+        qp_dprintf("qp_line(%d, %d, %d, %d): entry (deferring to qp_rect)\n", (int)x0, (int)y0, (int)x1, (int)y1);
+        bool ret = qp_rect(device, x0, y0, x1, y1, hue, sat, val, true);
+        qp_dprintf("qp_line(%d, %d, %d, %d): %s (deferred to qp_rect)\n", (int)x0, (int)y0, (int)x1, (int)y1, ret ? "ok" : "fail");
+        return ret;
+    }
+
+    qp_dprintf("qp_line(%d, %d, %d, %d): entry\n", (int)x0, (int)y0, (int)x1, (int)y1);
+    struct painter_driver_t *driver = (struct painter_driver_t *)device;
+    if (!driver->validate_ok) {
+        qp_dprintf("qp_line: fail (validation_ok == false)\n");
+        return false;
+    }
+
+    if (!qp_comms_start(device)) {
+        qp_dprintf("Failed to start comms in qp_line\n");
+        return false;
+    }
+
+    qp_internal_fill_pixdata(device, 1, hue, sat, val);
+
+    // draw angled line using Bresenham's algo
+    int16_t x      = ((int16_t)x0);
+    int16_t y      = ((int16_t)y0);
+    int16_t slopex = ((int16_t)x0) < ((int16_t)x1) ? 1 : -1;
+    int16_t slopey = ((int16_t)y0) < ((int16_t)y1) ? 1 : -1;
+    int16_t dx     = abs(((int16_t)x1) - ((int16_t)x0));
+    int16_t dy     = -abs(((int16_t)y1) - ((int16_t)y0));
+
+    int16_t e  = dx + dy;
+    int16_t e2 = 2 * e;
+
+    bool ret = true;
+    while (x != x1 || y != y1) {
+        if (!qp_internal_setpixel_impl(device, x, y)) {
+            ret = false;
+            break;
+        }
+        e2 = 2 * e;
+        if (e2 >= dy) {
+            e += dy;
+            x += slopex;
+        }
+        if (e2 <= dx) {
+            e += dx;
+            y += slopey;
+        }
+    }
+    // draw the last pixel
+    if (!qp_internal_setpixel_impl(device, x, y)) {
+        ret = false;
+    }
+
+    qp_comms_stop(device);
+    qp_dprintf("qp_line(%d, %d, %d, %d): %s\n", (int)x0, (int)y0, (int)x1, (int)y1, ret ? "ok" : "fail");
+    return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Quantum Painter External API: qp_rect
+
+bool qp_internal_fillrect_helper_impl(painter_device_t device, uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) {
+    uint32_t                 pixels_in_pixdata = qp_internal_num_pixels_in_buffer(device);
+    struct painter_driver_t *driver            = (struct painter_driver_t *)device;
+
+    uint16_t l = QP_MIN(left, right);
+    uint16_t r = QP_MAX(left, right);
+    uint16_t t = QP_MIN(top, bottom);
+    uint16_t b = QP_MAX(top, bottom);
+    uint16_t w = r - l + 1;
+    uint16_t h = b - t + 1;
+
+    uint32_t remaining = w * h;
+    driver->driver_vtable->viewport(device, l, t, r, b);
+    while (remaining > 0) {
+        uint32_t transmit = QP_MIN(remaining, pixels_in_pixdata);
+        if (!driver->driver_vtable->pixdata(device, qp_internal_global_pixdata_buffer, transmit)) {
+            return false;
+        }
+        remaining -= transmit;
+    }
+    return true;
+}
+
+bool qp_rect(painter_device_t device, uint16_t left, uint16_t top, uint16_t right, uint16_t bottom, uint8_t hue, uint8_t sat, uint8_t val, bool filled) {
+    qp_dprintf("qp_rect(%d, %d, %d, %d): entry\n", (int)left, (int)top, (int)right, (int)bottom);
+    struct painter_driver_t *driver = (struct painter_driver_t *)device;
+    if (!driver->validate_ok) {
+        qp_dprintf("qp_rect: fail (validation_ok == false)\n");
+        return false;
+    }
+
+    // Cater for cases where people have submitted the coordinates backwards
+    uint16_t l = QP_MIN(left, right);
+    uint16_t r = QP_MAX(left, right);
+    uint16_t t = QP_MIN(top, bottom);
+    uint16_t b = QP_MAX(top, bottom);
+    uint16_t w = r - l + 1;
+    uint16_t h = b - t + 1;
+
+    bool ret = true;
+    if (!qp_comms_start(device)) {
+        qp_dprintf("Failed to start comms in qp_rect\n");
+        return false;
+    }
+
+    if (filled) {
+        // Fill up the pixdata buffer with the required number of native pixels
+        qp_internal_fill_pixdata(device, w * h, hue, sat, val);
+
+        // Perform the draw
+        ret = qp_internal_fillrect_helper_impl(device, l, t, r, b);
+    } else {
+        // Fill up the pixdata buffer with the required number of native pixels
+        qp_internal_fill_pixdata(device, QP_MAX(w, h), hue, sat, val);
+
+        // Draw 4x filled single-width rects to create an outline
+        if (!qp_internal_fillrect_helper_impl(device, l, t, r, t) || !qp_internal_fillrect_helper_impl(device, l, b, r, b) || !qp_internal_fillrect_helper_impl(device, l, t + 1, l, b - 1) || !qp_internal_fillrect_helper_impl(device, r, t + 1, r, b - 1)) {
+            ret = false;
+        }
+    }
+
+    qp_comms_stop(device);
+    qp_dprintf("qp_rect(%d, %d, %d, %d): %s\n", (int)l, (int)t, (int)r, (int)b, ret ? "ok" : "fail");
+    return ret;
+}