first commit

extended-setup/components/lvgl/src/lv_draw/lv_draw.c

@@ -0,0 +1,190 @@
+/**
+ * @file lv_draw.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include <stdio.h>
+#include <stdbool.h>
+#include "lv_draw.h"
+#include "../lv_misc/lv_math.h"
+#include "../lv_misc/lv_log.h"
+#include "../lv_misc/lv_math.h"
+#include "../lv_misc/lv_mem.h"
+#include "../lv_misc/lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static uint32_t draw_buf_size = 0;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Give a buffer with the given to use during drawing.
+ * Be careful to not use the buffer while other processes are using it.
+ * @param size the required size
+ */
+void * lv_draw_get_buf(uint32_t size)
+{
+    if(size <= draw_buf_size) return LV_GC_ROOT(_lv_draw_buf);
+
+    LV_LOG_TRACE("lv_draw_get_buf: allocate");
+
+    draw_buf_size = size;
+
+    if(LV_GC_ROOT(_lv_draw_buf) == NULL) {
+        LV_GC_ROOT(_lv_draw_buf) = lv_mem_alloc(size);
+        lv_mem_assert(LV_GC_ROOT(_lv_draw_buf));
+        return LV_GC_ROOT(_lv_draw_buf);
+    }
+
+    LV_GC_ROOT(_lv_draw_buf) = lv_mem_realloc(LV_GC_ROOT(_lv_draw_buf), size);
+    lv_mem_assert(LV_GC_ROOT(_lv_draw_buf));
+    return LV_GC_ROOT(_lv_draw_buf);
+}
+
+/**
+ * Free the draw buffer
+ */
+void lv_draw_free_buf(void)
+{
+    if(LV_GC_ROOT(_lv_draw_buf)) {
+        lv_mem_free(LV_GC_ROOT(_lv_draw_buf));
+        LV_GC_ROOT(_lv_draw_buf) = NULL;
+        draw_buf_size = 0;
+    }
+}
+
+#if LV_ANTIALIAS
+
+/**
+ * Get the opacity of a pixel based it's position in a line segment
+ * @param seg segment length
+ * @param px_id position of  of a pixel which opacity should be get [0..seg-1]
+ * @param base_opa the base opacity
+ * @return the opacity of the given pixel
+ */
+lv_opa_t lv_draw_aa_get_opa(lv_coord_t seg, lv_coord_t px_id, lv_opa_t base_opa)
+{
+    /* How to calculate the opacity of pixels on the edges which makes the anti-aliasing?
+     * For example we have a line like this (y = -0.5 * x):
+     *
+     *  | _ _
+     *    * * |
+     *
+     * Anti-aliased pixels come to the '*' characters
+     * Calculate what percentage of the pixels should be covered if real line (not rasterized) would
+     * be drawn:
+     * 1. A real line should start on (0;0) and end on (2;1)
+     * 2. So the line intersection coordinates on the first pixel: (0;0) (1;0.5) -> 25% covered
+     * pixel in average
+     * 3. For the second pixel: (1;0.5) (2;1) -> 75% covered pixel in average
+     * 4. The equation: (px_id * 2 + 1) / (segment_width * 2)
+     *                   segment_width: the line segment which is being anti-aliased (was 2 in the
+     * example) px_id: pixel ID from 0 to  (segment_width - 1) result: [0..1] coverage of the pixel
+     */
+
+    /*Accelerate the common segment sizes to avoid division*/
+    static const lv_opa_t seg1[1] = {128};
+    static const lv_opa_t seg2[2] = {64, 192};
+    static const lv_opa_t seg3[3] = {42, 128, 212};
+    static const lv_opa_t seg4[4] = {32, 96, 159, 223};
+    static const lv_opa_t seg5[5] = {26, 76, 128, 178, 230};
+    static const lv_opa_t seg6[6] = {21, 64, 106, 148, 191, 234};
+    static const lv_opa_t seg7[7] = {18, 55, 91, 128, 164, 200, 237};
+    static const lv_opa_t seg8[8] = {16, 48, 80, 112, 143, 175, 207, 239};
+
+    static const lv_opa_t * seg_map[] = {seg1, seg2, seg3, seg4, seg5, seg6, seg7, seg8};
+
+    if(seg == 0)
+        return LV_OPA_TRANSP;
+    else if(seg < 8)
+        return (uint32_t)((uint32_t)seg_map[seg - 1][px_id] * base_opa) >> 8;
+    else {
+        return ((px_id * 2 + 1) * base_opa) / (2 * seg);
+    }
+}
+
+/**
+ * Add a vertical  anti-aliasing segment (pixels with decreasing opacity)
+ * @param x start point x coordinate
+ * @param y start point y coordinate
+ * @param length length of segment (negative value to start from 0 opacity)
+ * @param mask draw only in this area
+ * @param color color of pixels
+ * @param opa maximum opacity
+ */
+void lv_draw_aa_ver_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
+                        lv_opa_t opa)
+{
+    bool aa_inv = false;
+    if(length < 0) {
+        aa_inv = true;
+        length = -length;
+    }
+
+    lv_coord_t i;
+    for(i = 0; i < length; i++) {
+        lv_opa_t px_opa = lv_draw_aa_get_opa(length, i, opa);
+        if(aa_inv) px_opa = opa - px_opa;
+        lv_draw_px(x, y + i, mask, color, px_opa);
+    }
+}
+
+/**
+ * Add a horizontal anti-aliasing segment (pixels with decreasing opacity)
+ * @param x start point x coordinate
+ * @param y start point y coordinate
+ * @param length length of segment (negative value to start from 0 opacity)
+ * @param mask draw only in this area
+ * @param color color of pixels
+ * @param opa maximum opacity
+ */
+void lv_draw_aa_hor_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
+                        lv_opa_t opa)
+{
+    bool aa_inv = false;
+    if(length < 0) {
+        aa_inv = true;
+        length = -length;
+    }
+
+    lv_coord_t i;
+    for(i = 0; i < length; i++) {
+        lv_opa_t px_opa = lv_draw_aa_get_opa(length, i, opa);
+        if(aa_inv) px_opa = opa - px_opa;
+        lv_draw_px(x + i, y, mask, color, px_opa);
+    }
+}
+
+#endif
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

extended-setup/components/lvgl/src/lv_draw/lv_draw.h

@@ -0,0 +1,109 @@
+/**
+ * @file lv_draw.h
+ *
+ */
+
+#ifndef LV_DRAW_H
+#define LV_DRAW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../../lv_conf.h"
+#endif
+
+#include "../lv_core/lv_style.h"
+#include "../lv_misc/lv_txt.h"
+#include "lv_img_decoder.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Give a buffer with the given to use during drawing.
+ * Be careful to not use the buffer while other processes are using it.
+ * @param size the required size
+ */
+void * lv_draw_get_buf(uint32_t size);
+
+/**
+ * Free the draw buffer
+ */
+void lv_draw_free_buf(void);
+
+#if LV_ANTIALIAS
+
+/**
+ * Get the opacity of a pixel based it's position in a line segment
+ * @param seg segment length
+ * @param px_id position of  of a pixel which opacity should be get [0..seg-1]
+ * @param base_opa the base opacity
+ * @return the opacity of the given pixel
+ */
+lv_opa_t lv_draw_aa_get_opa(lv_coord_t seg, lv_coord_t px_id, lv_opa_t base_opa);
+
+/**
+ * Add a vertical  anti-aliasing segment (pixels with decreasing opacity)
+ * @param x start point x coordinate
+ * @param y start point y coordinate
+ * @param length length of segment (negative value to start from 0 opacity)
+ * @param mask draw only in this area
+ * @param color color of pixels
+ * @param opa maximum opacity
+ */
+void lv_draw_aa_ver_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
+                        lv_opa_t opa);
+
+/**
+ * Add a horizontal anti-aliasing segment (pixels with decreasing opacity)
+ * @param x start point x coordinate
+ * @param y start point y coordinate
+ * @param length length of segment (negative value to start from 0 opacity)
+ * @param mask draw only in this area
+ * @param color color of pixels
+ * @param opa maximum opacity
+ */
+void lv_draw_aa_hor_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
+                        lv_opa_t opa);
+#endif
+
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   POST INCLUDES
+ *********************/
+#include "lv_draw_basic.h"
+#include "lv_draw_rect.h"
+#include "lv_draw_label.h"
+#include "lv_draw_img.h"
+#include "lv_draw_line.h"
+#include "lv_draw_triangle.h"
+#include "lv_draw_arc.h"
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_H*/

extended-setup/components/lvgl/src/lv_draw/lv_draw.mk

@@ -0,0 +1,15 @@
+CSRCS += lv_draw_basic.c
+CSRCS += lv_draw.c
+CSRCS += lv_draw_rect.c
+CSRCS += lv_draw_label.c
+CSRCS += lv_draw_line.c
+CSRCS += lv_draw_img.c
+CSRCS += lv_draw_arc.c
+CSRCS += lv_draw_triangle.c
+CSRCS += lv_img_decoder.c
+CSRCS += lv_img_cache.c
+
+DEPPATH += --dep-path $(LVGL_DIR)/lvgl/src/lv_draw
+VPATH += :$(LVGL_DIR)/lvgl/src/lv_draw
+
+CFLAGS += "-I$(LVGL_DIR)lvgl/src/lv_draw"

extended-setup/components/lvgl/src/lv_draw/lv_draw_arc.c

@@ -0,0 +1,273 @@
+/**
+ * @file lv_draw_arc.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_arc.h"
+#include "../lv_misc/lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static uint16_t fast_atan2(int x, int y);
+static void ver_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color,
+                     lv_opa_t opa);
+static void hor_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color,
+                     lv_opa_t opa);
+static bool deg_test_norm(uint16_t deg, uint16_t start, uint16_t end);
+static bool deg_test_inv(uint16_t deg, uint16_t start, uint16_t end);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Draw an arc. (Can draw pie too with great thickness.)
+ * @param center_x the x coordinate of the center of the arc
+ * @param center_y the y coordinate of the center of the arc
+ * @param radius the radius of the arc
+ * @param mask the arc will be drawn only in this mask
+ * @param start_angle the start angle of the arc (0 deg on the bottom, 90 deg on the right)
+ * @param end_angle the end angle of the arc
+ * @param style style of the arc (`body.thickness`, `body.main_color`, `body.opa` is used)
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, const lv_area_t * mask,
+                 uint16_t start_angle, uint16_t end_angle, const lv_style_t * style, lv_opa_t opa_scale)
+{
+    lv_coord_t thickness = style->line.width;
+    if(thickness > radius) thickness = radius;
+
+    lv_coord_t r_out = radius;
+    lv_coord_t r_in  = r_out - thickness;
+    int16_t deg_base;
+    int16_t deg;
+    lv_coord_t x_start[4];
+    lv_coord_t x_end[4];
+
+    lv_color_t color = style->line.color;
+    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->body.opa : (uint16_t)((uint16_t)style->body.opa * opa_scale) >> 8;
+
+    bool (*deg_test)(uint16_t, uint16_t, uint16_t);
+    if(start_angle <= end_angle)
+        deg_test = deg_test_norm;
+    else
+        deg_test = deg_test_inv;
+
+    if(deg_test(270, start_angle, end_angle))
+        hor_line(center_x - r_out + 1, center_y, mask, thickness - 1, color, opa); // Left Middle
+    if(deg_test(90, start_angle, end_angle))
+        hor_line(center_x + r_in, center_y, mask, thickness - 1, color, opa); // Right Middle
+    if(deg_test(180, start_angle, end_angle))
+        ver_line(center_x, center_y - r_out + 1, mask, thickness - 1, color, opa); // Top Middle
+    if(deg_test(0, start_angle, end_angle))
+        ver_line(center_x, center_y + r_in, mask, thickness - 1, color, opa); // Bottom middle
+
+    uint32_t r_out_sqr = r_out * r_out;
+    uint32_t r_in_sqr  = r_in * r_in;
+    int16_t xi;
+    int16_t yi;
+    for(yi = -r_out; yi < 0; yi++) {
+        x_start[0] = LV_COORD_MIN;
+        x_start[1] = LV_COORD_MIN;
+        x_start[2] = LV_COORD_MIN;
+        x_start[3] = LV_COORD_MIN;
+        x_end[0]   = LV_COORD_MIN;
+        x_end[1]   = LV_COORD_MIN;
+        x_end[2]   = LV_COORD_MIN;
+        x_end[3]   = LV_COORD_MIN;
+        for(xi = -r_out; xi < 0; xi++) {
+
+            uint32_t r_act_sqr = xi * xi + yi * yi;
+            if(r_act_sqr > r_out_sqr) continue;
+
+            deg_base = fast_atan2(xi, yi) - 180;
+
+            deg = 180 + deg_base;
+            if(deg_test(deg, start_angle, end_angle)) {
+                if(x_start[0] == LV_COORD_MIN) x_start[0] = xi;
+            } else if(x_start[0] != LV_COORD_MIN && x_end[0] == LV_COORD_MIN) {
+                x_end[0] = xi - 1;
+            }
+
+            deg = 360 - deg_base;
+            if(deg_test(deg, start_angle, end_angle)) {
+                if(x_start[1] == LV_COORD_MIN) x_start[1] = xi;
+            } else if(x_start[1] != LV_COORD_MIN && x_end[1] == LV_COORD_MIN) {
+                x_end[1] = xi - 1;
+            }
+
+            deg = 180 - deg_base;
+            if(deg_test(deg, start_angle, end_angle)) {
+                if(x_start[2] == LV_COORD_MIN) x_start[2] = xi;
+            } else if(x_start[2] != LV_COORD_MIN && x_end[2] == LV_COORD_MIN) {
+                x_end[2] = xi - 1;
+            }
+
+            deg = deg_base;
+            if(deg_test(deg, start_angle, end_angle)) {
+                if(x_start[3] == LV_COORD_MIN) x_start[3] = xi;
+            } else if(x_start[3] != LV_COORD_MIN && x_end[3] == LV_COORD_MIN) {
+                x_end[3] = xi - 1;
+            }
+
+            if(r_act_sqr < r_in_sqr)
+                break; /*No need to continue the iteration in x once we found the inner edge of the
+                          arc*/
+        }
+
+        if(x_start[0] != LV_COORD_MIN) {
+            if(x_end[0] == LV_COORD_MIN) x_end[0] = xi - 1;
+            hor_line(center_x + x_start[0], center_y + yi, mask, x_end[0] - x_start[0], color, opa);
+        }
+
+        if(x_start[1] != LV_COORD_MIN) {
+            if(x_end[1] == LV_COORD_MIN) x_end[1] = xi - 1;
+            hor_line(center_x + x_start[1], center_y - yi, mask, x_end[1] - x_start[1], color, opa);
+        }
+
+        if(x_start[2] != LV_COORD_MIN) {
+            if(x_end[2] == LV_COORD_MIN) x_end[2] = xi - 1;
+            hor_line(center_x - x_end[2], center_y + yi, mask, LV_MATH_ABS(x_end[2] - x_start[2]), color, opa);
+        }
+
+        if(x_start[3] != LV_COORD_MIN) {
+            if(x_end[3] == LV_COORD_MIN) x_end[3] = xi - 1;
+            hor_line(center_x - x_end[3], center_y - yi, mask, LV_MATH_ABS(x_end[3] - x_start[3]), color, opa);
+        }
+
+#if LV_ANTIALIAS
+        /*TODO*/
+
+#endif
+    }
+}
+
+static uint16_t fast_atan2(int x, int y)
+{
+    // Fast XY vector to integer degree algorithm - Jan 2011 www.RomanBlack.com
+    // Converts any XY values including 0 to a degree value that should be
+    // within +/- 1 degree of the accurate value without needing
+    // large slow trig functions like ArcTan() or ArcCos().
+    // NOTE! at least one of the X or Y values must be non-zero!
+    // This is the full version, for all 4 quadrants and will generate
+    // the angle in integer degrees from 0-360.
+    // Any values of X and Y are usable including negative values provided
+    // they are between -1456 and 1456 so the 16bit multiply does not overflow.
+
+    unsigned char negflag;
+    unsigned char tempdegree;
+    unsigned char comp;
+    unsigned int degree; // this will hold the result
+    // signed int x;            // these hold the XY vector at the start
+    // signed int y;            // (and they will be destroyed)
+    unsigned int ux;
+    unsigned int uy;
+
+    // Save the sign flags then remove signs and get XY as unsigned ints
+    negflag = 0;
+    if(x < 0) {
+        negflag += 0x01; // x flag bit
+        x = (0 - x);     // is now +
+    }
+    ux = x; // copy to unsigned var before multiply
+    if(y < 0) {
+        negflag += 0x02; // y flag bit
+        y = (0 - y);     // is now +
+    }
+    uy = y; // copy to unsigned var before multiply
+
+    // 1. Calc the scaled "degrees"
+    if(ux > uy) {
+        degree = (uy * 45) / ux; // degree result will be 0-45 range
+        negflag += 0x10;         // octant flag bit
+    } else {
+        degree = (ux * 45) / uy; // degree result will be 0-45 range
+    }
+
+    // 2. Compensate for the 4 degree error curve
+    comp       = 0;
+    tempdegree = degree;  // use an unsigned char for speed!
+    if(tempdegree > 22) { // if top half of range
+        if(tempdegree <= 44) comp++;
+        if(tempdegree <= 41) comp++;
+        if(tempdegree <= 37) comp++;
+        if(tempdegree <= 32) comp++; // max is 4 degrees compensated
+    } else {                         // else is lower half of range
+        if(tempdegree >= 2) comp++;
+        if(tempdegree >= 6) comp++;
+        if(tempdegree >= 10) comp++;
+        if(tempdegree >= 15) comp++; // max is 4 degrees compensated
+    }
+    degree += comp; // degree is now accurate to +/- 1 degree!
+
+    // Invert degree if it was X>Y octant, makes 0-45 into 90-45
+    if(negflag & 0x10) degree = (90 - degree);
+
+    // 3. Degree is now 0-90 range for this quadrant,
+    // need to invert it for whichever quadrant it was in
+    if(negflag & 0x02) {   // if -Y
+        if(negflag & 0x01) // if -Y -X
+            degree = (180 + degree);
+        else // else is -Y +X
+            degree = (180 - degree);
+    } else {               // else is +Y
+        if(negflag & 0x01) // if +Y -X
+            degree = (360 - degree);
+    }
+    return degree;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+static void ver_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color, lv_opa_t opa)
+{
+    lv_area_t area;
+    lv_area_set(&area, x, y, x, y + len);
+
+    lv_draw_fill(&area, mask, color, opa);
+}
+
+static void hor_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color, lv_opa_t opa)
+{
+    lv_area_t area;
+    lv_area_set(&area, x, y, x + len, y);
+
+    lv_draw_fill(&area, mask, color, opa);
+}
+
+static bool deg_test_norm(uint16_t deg, uint16_t start, uint16_t end)
+{
+    if(deg >= start && deg <= end)
+        return true;
+    else
+        return false;
+}
+
+static bool deg_test_inv(uint16_t deg, uint16_t start, uint16_t end)
+{
+    if(deg >= start || deg <= end) {
+        return true;
+    } else
+        return false;
+}

extended-setup/components/lvgl/src/lv_draw/lv_draw_arc.h

@@ -0,0 +1,52 @@
+/**
+ * @file lv_draw_arc.h
+ *
+ */
+
+#ifndef LV_DRAW_ARC_H
+#define LV_DRAW_ARC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Draw an arc. (Can draw pie too with great thickness.)
+ * @param center_x the x coordinate of the center of the arc
+ * @param center_y the y coordinate of the center of the arc
+ * @param radius the radius of the arc
+ * @param mask the arc will be drawn only in this mask
+ * @param start_angle the start angle of the arc (0 deg on the bottom, 90 deg on the right)
+ * @param end_angle the end angle of the arc
+ * @param style style of the arc (`body.thickness`, `body.main_color`, `body.opa` is used)
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, const lv_area_t * mask,
+                 uint16_t start_angle, uint16_t end_angle, const lv_style_t * style, lv_opa_t opa_scale);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_ARC*/

extended-setup/components/lvgl/src/lv_draw/lv_draw_basic.c

@@ -0,0 +1,707 @@
+/**
+ * @file lv_draw_basic.c
+ *
+ */
+
+#include "lv_draw_basic.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../lv_core/lv_refr.h"
+#include "../lv_hal/lv_hal.h"
+#include "../lv_font/lv_font.h"
+#include "../lv_misc/lv_area.h"
+#include "../lv_misc/lv_color.h"
+#include "../lv_misc/lv_log.h"
+
+#include <stddef.h>
+#include "lv_draw.h"
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/*Always fill < 50 px with 'sw_color_fill' because of the hw. init overhead*/
+#define VFILL_HW_ACC_SIZE_LIMIT 50
+
+#ifndef LV_ATTRIBUTE_MEM_ALIGN
+#define LV_ATTRIBUTE_MEM_ALIGN
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void sw_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
+static void sw_color_fill(lv_color_t * mem, lv_coord_t mem_width, const lv_area_t * fill_area, lv_color_t color,
+                          lv_opa_t opa);
+
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+static inline lv_color_t color_mix_2_alpha(lv_color_t bg_color, lv_opa_t bg_opa, lv_color_t fg_color, lv_opa_t fg_opa);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Put a pixel in the Virtual Display Buffer
+ * @param x pixel x coordinate
+ * @param y pixel y coordinate
+ * @param mask_p fill only on this mask (truncated to VDB area)
+ * @param color pixel color
+ * @param opa opacity of the area (0..255)
+ */
+void lv_draw_px(lv_coord_t x, lv_coord_t y, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa)
+{
+
+    if(opa < LV_OPA_MIN) return;
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    /*Pixel out of the mask*/
+    if(x < mask_p->x1 || x > mask_p->x2 || y < mask_p->y1 || y > mask_p->y2) {
+        return;
+    }
+
+    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+    uint32_t vdb_width  = lv_area_get_width(&vdb->area);
+
+    /*Make the coordinates relative to VDB*/
+    x -= vdb->area.x1;
+    y -= vdb->area.y1;
+
+    if(disp->driver.set_px_cb) {
+        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, x, y, color, opa);
+    } else {
+        bool scr_transp = false;
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+        scr_transp = disp->driver.screen_transp;
+#endif
+
+        lv_color_t * vdb_px_p = vdb->buf_act;
+        vdb_px_p += y * vdb_width + x;
+
+        if(scr_transp == false) {
+            if(opa == LV_OPA_COVER) {
+                *vdb_px_p = color;
+            } else {
+                *vdb_px_p = lv_color_mix(color, *vdb_px_p, opa);
+            }
+        } else {
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+            *vdb_px_p = color_mix_2_alpha(*vdb_px_p, (*vdb_px_p).ch.alpha, color, opa);
+#endif
+        }
+    }
+}
+
+/**
+ * Fill an area in the Virtual Display Buffer
+ * @param cords_p coordinates of the area to fill
+ * @param mask_p fill only o this mask  (truncated to VDB area)
+ * @param color fill color
+ * @param opa opacity of the area (0..255)
+ */
+void lv_draw_fill(const lv_area_t * cords_p, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa)
+{
+    if(opa < LV_OPA_MIN) return;
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    lv_area_t res_a;
+    bool union_ok;
+
+    /*Get the union of cord and mask*/
+    /* The mask is already truncated to the vdb size
+     * in 'lv_refr_area_with_vdb' function */
+    union_ok = lv_area_intersect(&res_a, cords_p, mask_p);
+
+    /*If there are common part of the three area then draw to the vdb*/
+    if(union_ok == false) {
+        return;
+    }
+
+    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+
+    lv_area_t vdb_rel_a; /*Stores relative coordinates on vdb*/
+    vdb_rel_a.x1 = res_a.x1 - vdb->area.x1;
+    vdb_rel_a.y1 = res_a.y1 - vdb->area.y1;
+    vdb_rel_a.x2 = res_a.x2 - vdb->area.x1;
+    vdb_rel_a.y2 = res_a.y2 - vdb->area.y1;
+
+    lv_color_t * vdb_buf_tmp = vdb->buf_act;
+    uint32_t vdb_width       = lv_area_get_width(&vdb->area);
+    /*Move the vdb_tmp to the first row*/
+    vdb_buf_tmp += vdb_width * vdb_rel_a.y1;
+
+#if LV_USE_GPU
+    static LV_ATTRIBUTE_MEM_ALIGN lv_color_t color_array_tmp[LV_HOR_RES_MAX]; /*Used by 'lv_disp_mem_blend'*/
+    static lv_coord_t last_width = -1;
+
+    lv_coord_t w = lv_area_get_width(&vdb_rel_a);
+    /*Don't use hw. acc. for every small fill (because of the init overhead)*/
+    if(w < VFILL_HW_ACC_SIZE_LIMIT) {
+        sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
+    }
+    /*Not opaque fill*/
+    else if(opa == LV_OPA_COVER) {
+        /*Use hw fill if present*/
+        if(disp->driver.gpu_fill_cb) {
+            disp->driver.gpu_fill_cb(&disp->driver, vdb->buf_act, vdb_width, &vdb_rel_a, color);
+        }
+        /*Use hw blend if present and the area is not too small*/
+        else if(lv_area_get_height(&vdb_rel_a) > VFILL_HW_ACC_SIZE_LIMIT && disp->driver.gpu_blend_cb) {
+            /*Fill a  one line sized buffer with a color and blend this later*/
+            if(color_array_tmp[0].full != color.full || last_width != w) {
+                uint16_t i;
+                for(i = 0; i < w; i++) {
+                    color_array_tmp[i].full = color.full;
+                }
+                last_width = w;
+            }
+
+            /*Blend the filled line to every line VDB line-by-line*/
+            lv_coord_t row;
+            for(row = vdb_rel_a.y1; row <= vdb_rel_a.y2; row++) {
+                disp->driver.gpu_blend_cb(&disp->driver, &vdb_buf_tmp[vdb_rel_a.x1], color_array_tmp, w, opa);
+                vdb_buf_tmp += vdb_width;
+            }
+
+        }
+        /*Else use sw fill if no better option*/
+        else {
+            sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
+        }
+
+    }
+    /*Fill with opacity*/
+    else {
+        /*Use hw blend if present*/
+        if(disp->driver.gpu_blend_cb) {
+            if(color_array_tmp[0].full != color.full || last_width != w) {
+                uint16_t i;
+                for(i = 0; i < w; i++) {
+                    color_array_tmp[i].full = color.full;
+                }
+
+                last_width = w;
+            }
+            lv_coord_t row;
+            for(row = vdb_rel_a.y1; row <= vdb_rel_a.y2; row++) {
+                disp->driver.gpu_blend_cb(&disp->driver, &vdb_buf_tmp[vdb_rel_a.x1], color_array_tmp, w, opa);
+                vdb_buf_tmp += vdb_width;
+            }
+
+        }
+        /*Use sw fill with opa if no better option*/
+        else {
+            sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
+        }
+    }
+#else
+    sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
+#endif
+}
+
+/**
+ * Draw a letter in the Virtual Display Buffer
+ * @param pos_p left-top coordinate of the latter
+ * @param mask_p the letter will be drawn only on this area  (truncated to VDB area)
+ * @param font_p pointer to font
+ * @param letter a letter to draw
+ * @param color color of letter
+ * @param opa opacity of letter (0..255)
+ */
+void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * mask_p, const lv_font_t * font_p, uint32_t letter,
+                    lv_color_t color, lv_opa_t opa)
+{
+    /*clang-format off*/
+    const uint8_t bpp1_opa_table[2]  = {0, 255};          /*Opacity mapping with bpp = 1 (Just for compatibility)*/
+    const uint8_t bpp2_opa_table[4]  = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
+    const uint8_t bpp4_opa_table[16] = {0,  17, 34,  51,  /*Opacity mapping with bpp = 4*/
+                                        68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
+    /*clang-format on*/
+
+    if(opa < LV_OPA_MIN) return;
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    if(font_p == NULL) {
+        LV_LOG_WARN("Font: character's bitmap not found");
+        return;
+    }
+
+    lv_font_glyph_dsc_t g;
+    bool g_ret = lv_font_get_glyph_dsc(font_p, &g, letter, '\0');
+    if(g_ret == false) return;
+
+    lv_coord_t pos_x = pos_p->x + g.ofs_x;
+    lv_coord_t pos_y = pos_p->y + (font_p->line_height - font_p->base_line) - g.box_h - g.ofs_y;
+
+    const uint8_t * bpp_opa_table;
+    uint8_t bitmask_init;
+    uint8_t bitmask;
+
+    switch(g.bpp) {
+        case 1:
+            bpp_opa_table = bpp1_opa_table;
+            bitmask_init  = 0x80;
+            break;
+        case 2:
+            bpp_opa_table = bpp2_opa_table;
+            bitmask_init  = 0xC0;
+            break;
+        case 4:
+            bpp_opa_table = bpp4_opa_table;
+            bitmask_init  = 0xF0;
+            break;
+        case 8:
+            bpp_opa_table = NULL;
+            bitmask_init  = 0xFF;
+            break;       /*No opa table, pixel value will be used directly*/
+        default: return; /*Invalid bpp. Can't render the letter*/
+    }
+
+    const uint8_t * map_p = lv_font_get_glyph_bitmap(font_p, letter);
+
+    if(map_p == NULL) return;
+
+    /*If the letter is completely out of mask don't draw it */
+    if(pos_x + g.box_w < mask_p->x1 || pos_x > mask_p->x2 || pos_y + g.box_h < mask_p->y1 || pos_y > mask_p->y2) return;
+
+    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+
+    lv_coord_t vdb_width     = lv_area_get_width(&vdb->area);
+    lv_color_t * vdb_buf_tmp = vdb->buf_act;
+    lv_coord_t col, row;
+
+    uint8_t width_byte_scr = g.box_w >> 3; /*Width in bytes (on the screen finally) (e.g. w = 11 -> 2 bytes wide)*/
+    if(g.box_w & 0x7) width_byte_scr++;
+    uint16_t width_bit = g.box_w * g.bpp; /*Letter width in bits*/
+
+    /* Calculate the col/row start/end on the map*/
+    lv_coord_t col_start = pos_x >= mask_p->x1 ? 0 : mask_p->x1 - pos_x;
+    lv_coord_t col_end   = pos_x + g.box_w <= mask_p->x2 ? g.box_w : mask_p->x2 - pos_x + 1;
+    lv_coord_t row_start = pos_y >= mask_p->y1 ? 0 : mask_p->y1 - pos_y;
+    lv_coord_t row_end   = pos_y + g.box_h <= mask_p->y2 ? g.box_h : mask_p->y2 - pos_y + 1;
+
+    /*Set a pointer on VDB to the first pixel of the letter*/
+    vdb_buf_tmp += ((pos_y - vdb->area.y1) * vdb_width) + pos_x - vdb->area.x1;
+
+    /*If the letter is partially out of mask the move there on VDB*/
+    vdb_buf_tmp += (row_start * vdb_width) + col_start;
+
+    /*Move on the map too*/
+    uint32_t bit_ofs = (row_start * width_bit) + (col_start * g.bpp);
+    map_p += bit_ofs >> 3;
+
+    uint8_t letter_px;
+    lv_opa_t px_opa;
+    uint16_t col_bit;
+    col_bit = bit_ofs & 0x7; /* "& 0x7" equals to "% 8" just faster */
+
+    bool scr_transp = false;
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+    scr_transp = disp->driver.screen_transp;
+#endif
+
+    for(row = row_start; row < row_end; row++) {
+        bitmask = bitmask_init >> col_bit;
+        for(col = col_start; col < col_end; col++) {
+            letter_px = (*map_p & bitmask) >> (8 - col_bit - g.bpp);
+            if(letter_px != 0) {
+                if(opa == LV_OPA_COVER) {
+                    px_opa = g.bpp == 8 ? letter_px : bpp_opa_table[letter_px];
+                } else {
+                    px_opa = g.bpp == 8 ? (uint16_t)((uint16_t)letter_px * opa) >> 8
+                                        : (uint16_t)((uint16_t)bpp_opa_table[letter_px] * opa) >> 8;
+                }
+
+                if(disp->driver.set_px_cb) {
+                    disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width,
+                                           (col + pos_x) - vdb->area.x1, (row + pos_y) - vdb->area.y1, color, px_opa);
+                } else if(vdb_buf_tmp->full != color.full) {
+                    if(px_opa > LV_OPA_MAX)
+                        *vdb_buf_tmp = color;
+                    else if(px_opa > LV_OPA_MIN) {
+                        if(scr_transp == false) {
+                            *vdb_buf_tmp = lv_color_mix(color, *vdb_buf_tmp, px_opa);
+                        } else {
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+                            *vdb_buf_tmp = color_mix_2_alpha(*vdb_buf_tmp, (*vdb_buf_tmp).ch.alpha, color, px_opa);
+#endif
+                        }
+                    }
+                }
+            }
+
+            vdb_buf_tmp++;
+
+            if(col_bit < 8 - g.bpp) {
+                col_bit += g.bpp;
+                bitmask = bitmask >> g.bpp;
+            } else {
+                col_bit = 0;
+                bitmask = bitmask_init;
+                map_p++;
+            }
+        }
+        col_bit += ((g.box_w - col_end) + col_start) * g.bpp;
+
+        map_p += (col_bit >> 3);
+        col_bit = col_bit & 0x7;
+        vdb_buf_tmp += vdb_width - (col_end - col_start); /*Next row in VDB*/
+    }
+}
+
+/**
+ * Draw a color map to the display (image)
+ * @param cords_p coordinates the color map
+ * @param mask_p the map will drawn only on this area  (truncated to VDB area)
+ * @param map_p pointer to a lv_color_t array
+ * @param opa opacity of the map
+ * @param chroma_keyed true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
+ * @param alpha_byte true: extra alpha byte is inserted for every pixel
+ * @param recolor mix the pixels with this color
+ * @param recolor_opa the intense of recoloring
+ */
+void lv_draw_map(const lv_area_t * cords_p, const lv_area_t * mask_p, const uint8_t * map_p, lv_opa_t opa,
+                 bool chroma_key, bool alpha_byte, lv_color_t recolor, lv_opa_t recolor_opa)
+{
+
+    if(opa < LV_OPA_MIN) return;
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    lv_area_t masked_a;
+    bool union_ok;
+
+    /*Get the union of map size and mask*/
+    /* The mask is already truncated to the vdb size
+     * in 'lv_refr_area_with_vdb' function */
+    union_ok = lv_area_intersect(&masked_a, cords_p, mask_p);
+
+    /*If there are common part of the three area then draw to the vdb*/
+    if(union_ok == false) return;
+
+    /*The pixel size in byte is different if an alpha byte is added too*/
+    uint8_t px_size_byte = alpha_byte ? LV_IMG_PX_SIZE_ALPHA_BYTE : sizeof(lv_color_t);
+
+    /*If the map starts OUT of the masked area then calc. the first pixel*/
+    lv_coord_t map_width = lv_area_get_width(cords_p);
+    if(cords_p->y1 < masked_a.y1) {
+        map_p += (uint32_t)map_width * ((masked_a.y1 - cords_p->y1)) * px_size_byte;
+    }
+    if(cords_p->x1 < masked_a.x1) {
+        map_p += (masked_a.x1 - cords_p->x1) * px_size_byte;
+    }
+
+    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+
+    /*Stores coordinates relative to the current VDB*/
+    masked_a.x1 = masked_a.x1 - vdb->area.x1;
+    masked_a.y1 = masked_a.y1 - vdb->area.y1;
+    masked_a.x2 = masked_a.x2 - vdb->area.x1;
+    masked_a.y2 = masked_a.y2 - vdb->area.y1;
+
+    lv_coord_t vdb_width     = lv_area_get_width(&vdb->area);
+    lv_color_t * vdb_buf_tmp = vdb->buf_act;
+    vdb_buf_tmp += (uint32_t)vdb_width * masked_a.y1; /*Move to the first row*/
+    vdb_buf_tmp += (uint32_t)masked_a.x1;             /*Move to the first col*/
+
+    lv_coord_t row;
+    lv_coord_t map_useful_w = lv_area_get_width(&masked_a);
+
+    bool scr_transp = false;
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+    scr_transp = disp->driver.screen_transp;
+#endif
+
+    /*The simplest case just copy the pixels into the VDB*/
+    if(chroma_key == false && alpha_byte == false && opa == LV_OPA_COVER && recolor_opa == LV_OPA_TRANSP) {
+
+        /*Use the custom VDB write function is exists*/
+        if(disp->driver.set_px_cb) {
+            lv_coord_t col;
+            for(row = masked_a.y1; row <= masked_a.y2; row++) {
+                for(col = 0; col < map_useful_w; col++) {
+                    lv_color_t px_color = *((lv_color_t *)&map_p[(uint32_t)col * px_size_byte]);
+                    disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, col + masked_a.x1, row,
+                                           px_color, opa);
+                }
+                map_p += map_width * px_size_byte; /*Next row on the map*/
+            }
+        }
+        /*Normal native VDB*/
+        else {
+            for(row = masked_a.y1; row <= masked_a.y2; row++) {
+#if LV_USE_GPU
+                if(disp->driver.gpu_blend_cb == false) {
+                    sw_mem_blend(vdb_buf_tmp, (lv_color_t *)map_p, map_useful_w, opa);
+                } else {
+                    disp->driver.gpu_blend_cb(&disp->driver, vdb_buf_tmp, (lv_color_t *)map_p, map_useful_w, opa);
+                }
+#else
+                sw_mem_blend(vdb_buf_tmp, (lv_color_t *)map_p, map_useful_w, opa);
+#endif
+                map_p += map_width * px_size_byte; /*Next row on the map*/
+                vdb_buf_tmp += vdb_width;          /*Next row on the VDB*/
+            }
+        }
+    }
+
+    /*In the other cases every pixel need to be checked one-by-one*/
+    else {
+
+        lv_coord_t col;
+        lv_color_t last_img_px  = LV_COLOR_BLACK;
+        lv_color_t recolored_px = lv_color_mix(recolor, last_img_px, recolor_opa);
+        for(row = masked_a.y1; row <= masked_a.y2; row++) {
+            for(col = 0; col < map_useful_w; col++) {
+                lv_opa_t opa_result  = opa;
+                uint8_t * px_color_p = (uint8_t *)&map_p[(uint32_t)col * px_size_byte];
+                lv_color_t px_color;
+
+                /*Calculate with the pixel level alpha*/
+                if(alpha_byte) {
+#if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
+                    px_color.full = px_color_p[0];
+#elif LV_COLOR_DEPTH == 16
+                    /*Because of Alpha byte 16 bit color can start on odd address which can cause
+                     * crash*/
+                    px_color.full = px_color_p[0] + (px_color_p[1] << 8);
+#elif LV_COLOR_DEPTH == 32
+                    px_color = *((lv_color_t *)px_color_p);
+#endif
+                    lv_opa_t px_opa = *(px_color_p + LV_IMG_PX_SIZE_ALPHA_BYTE - 1);
+                    if(px_opa == LV_OPA_TRANSP)
+                        continue;
+                    else if(px_opa != LV_OPA_COVER)
+                        opa_result = (uint32_t)((uint32_t)px_opa * opa_result) >> 8;
+                } else {
+                    px_color = *((lv_color_t *)px_color_p);
+                }
+
+                /*Handle chroma key*/
+                if(chroma_key && px_color.full == disp->driver.color_chroma_key.full) continue;
+
+                /*Re-color the pixel if required*/
+                if(recolor_opa != LV_OPA_TRANSP) {
+                    if(last_img_px.full != px_color.full) { /*Minor acceleration: calculate only for
+                                                               new colors (save the last)*/
+                        last_img_px  = px_color;
+                        recolored_px = lv_color_mix(recolor, last_img_px, recolor_opa);
+                    }
+                    /*Handle custom VDB write is present*/
+                    if(disp->driver.set_px_cb) {
+                        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, col + masked_a.x1,
+                                               row, recolored_px, opa_result);
+                    }
+                    /*Normal native VDB write*/
+                    else {
+                        if(opa_result == LV_OPA_COVER)
+                            vdb_buf_tmp[col].full = recolored_px.full;
+                        else
+                            vdb_buf_tmp[col] = lv_color_mix(recolored_px, vdb_buf_tmp[col], opa_result);
+                    }
+                } else {
+                    /*Handle custom VDB write is present*/
+                    if(disp->driver.set_px_cb) {
+                        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, col + masked_a.x1,
+                                               row, px_color, opa_result);
+                    }
+                    /*Normal native VDB write*/
+                    else {
+
+                        if(opa_result == LV_OPA_COVER)
+                            vdb_buf_tmp[col] = px_color;
+                        else {
+                            if(scr_transp == false) {
+                                vdb_buf_tmp[col] = lv_color_mix(px_color, vdb_buf_tmp[col], opa_result);
+                            } else {
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+                                vdb_buf_tmp[col] = color_mix_2_alpha(vdb_buf_tmp[col], vdb_buf_tmp[col].ch.alpha,
+                                                                     px_color, opa_result);
+#endif
+                            }
+                        }
+                    }
+                }
+            }
+
+            map_p += map_width * px_size_byte; /*Next row on the map*/
+            vdb_buf_tmp += vdb_width;          /*Next row on the VDB*/
+        }
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Blend pixels to destination memory using opacity
+ * @param dest a memory address. Copy 'src' here.
+ * @param src pointer to pixel map. Copy it to 'dest'.
+ * @param length number of pixels in 'src'
+ * @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
+ */
+static void sw_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
+{
+    if(opa == LV_OPA_COVER) {
+        memcpy(dest, src, length * sizeof(lv_color_t));
+    } else {
+        uint32_t col;
+        for(col = 0; col < length; col++) {
+            dest[col] = lv_color_mix(src[col], dest[col], opa);
+        }
+    }
+}
+
+/**
+ * Fill an area with a color
+ * @param mem a memory address. Considered to a rectangular window according to 'mem_area'
+ * @param mem_width width of the 'mem' buffer
+ * @param fill_area coordinates of an area to fill. Relative to 'mem_area'.
+ * @param color fill color
+ * @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
+ */
+static void sw_color_fill(lv_color_t * mem, lv_coord_t mem_width, const lv_area_t * fill_area, lv_color_t color,
+                          lv_opa_t opa)
+{
+    /*Set all row in vdb to the given color*/
+    lv_coord_t row;
+    lv_coord_t col;
+
+    lv_disp_t * disp = lv_refr_get_disp_refreshing();
+    if(disp->driver.set_px_cb) {
+        for(col = fill_area->x1; col <= fill_area->x2; col++) {
+            for(row = fill_area->y1; row <= fill_area->y2; row++) {
+                disp->driver.set_px_cb(&disp->driver, (uint8_t *)mem, mem_width, col, row, color, opa);
+            }
+        }
+    } else {
+        mem += fill_area->y1 * mem_width; /*Go to the first row*/
+
+        /*Run simpler function without opacity*/
+        if(opa == LV_OPA_COVER) {
+
+            /*Fill the first row with 'color'*/
+            for(col = fill_area->x1; col <= fill_area->x2; col++) {
+                mem[col] = color;
+            }
+
+            /*Copy the first row to all other rows*/
+            lv_color_t * mem_first = &mem[fill_area->x1];
+            lv_coord_t copy_size   = (fill_area->x2 - fill_area->x1 + 1) * sizeof(lv_color_t);
+            mem += mem_width;
+
+            for(row = fill_area->y1 + 1; row <= fill_area->y2; row++) {
+                memcpy(&mem[fill_area->x1], mem_first, copy_size);
+                mem += mem_width;
+            }
+        }
+        /*Calculate with alpha too*/
+        else {
+            bool scr_transp = false;
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+            scr_transp = disp->driver.screen_transp;
+#endif
+
+            lv_color_t bg_tmp  = LV_COLOR_BLACK;
+            lv_color_t opa_tmp = lv_color_mix(color, bg_tmp, opa);
+            for(row = fill_area->y1; row <= fill_area->y2; row++) {
+                for(col = fill_area->x1; col <= fill_area->x2; col++) {
+                    if(scr_transp == false) {
+                        /*If the bg color changed recalculate the result color*/
+                        if(mem[col].full != bg_tmp.full) {
+                            bg_tmp  = mem[col];
+                            opa_tmp = lv_color_mix(color, bg_tmp, opa);
+                        }
+
+                        mem[col] = opa_tmp;
+
+                    } else {
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+                        mem[col] = color_mix_2_alpha(mem[col], mem[col].ch.alpha, color, opa);
+#endif
+                    }
+                }
+                mem += mem_width;
+            }
+        }
+    }
+}
+
+#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
+/**
+ * Mix two colors. Both color can have alpha value. It requires ARGB888 colors.
+ * @param bg_color background color
+ * @param bg_opa alpha of the background color
+ * @param fg_color foreground color
+ * @param fg_opa alpha of the foreground color
+ * @return the mixed color. the alpha channel (color.alpha) contains the result alpha
+ */
+static inline lv_color_t color_mix_2_alpha(lv_color_t bg_color, lv_opa_t bg_opa, lv_color_t fg_color, lv_opa_t fg_opa)
+{
+    /* Pick the foreground if it's fully opaque or the Background is fully transparent*/
+    if(fg_opa > LV_OPA_MAX || bg_opa <= LV_OPA_MIN) {
+        fg_color.ch.alpha = fg_opa;
+        return fg_color;
+    }
+    /*Transparent foreground: use the Background*/
+    else if(fg_opa <= LV_OPA_MIN) {
+        return bg_color;
+    }
+    /*Opaque background: use simple mix*/
+    else if(bg_opa >= LV_OPA_MAX) {
+        return lv_color_mix(fg_color, bg_color, fg_opa);
+    }
+    /*Both colors have alpha. Expensive calculation need to be applied*/
+    else {
+        /*Save the parameters and the result. If they will be asked again don't compute again*/
+        static lv_opa_t fg_opa_save     = 0;
+        static lv_opa_t bg_opa_save     = 0;
+        static lv_color_t fg_color_save = {{0}};
+        static lv_color_t bg_color_save = {{0}};
+        static lv_color_t c             = {{0}};
+
+        if(fg_opa != fg_opa_save || bg_opa != bg_opa_save || fg_color.full != fg_color_save.full ||
+           bg_color.full != bg_color_save.full) {
+            fg_opa_save        = fg_opa;
+            bg_opa_save        = bg_opa;
+            fg_color_save.full = fg_color.full;
+            bg_color_save.full = bg_color.full;
+            /*Info:
+             * https://en.wikipedia.org/wiki/Alpha_compositing#Analytical_derivation_of_the_over_operator*/
+            lv_opa_t alpha_res = 255 - ((uint16_t)((uint16_t)(255 - fg_opa) * (255 - bg_opa)) >> 8);
+            if(alpha_res == 0) {
+                while(1)
+                    ;
+            }
+            lv_opa_t ratio = (uint16_t)((uint16_t)fg_opa * 255) / alpha_res;
+            c              = lv_color_mix(fg_color, bg_color, ratio);
+            c.ch.alpha     = alpha_res;
+        }
+        return c;
+    }
+}
+#endif

extended-setup/components/lvgl/src/lv_draw/lv_draw_basic.h

@@ -0,0 +1,82 @@
+/**
+ * @file lv_draw_basic.h
+ *
+ */
+
+#ifndef LV_DRAW_BASIC_H
+#define LV_DRAW_BASIC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../../lv_conf.h"
+#endif
+
+#include "../lv_font/lv_font.h"
+#include "../lv_misc/lv_color.h"
+#include "../lv_misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_px(lv_coord_t x, lv_coord_t y, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa);
+/**
+ * Fill an area in the Virtual Display Buffer
+ * @param cords_p coordinates of the area to fill
+ * @param mask_p fill only o this mask
+ * @param color fill color
+ * @param opa opacity of the area (0..255)
+ */
+void lv_draw_fill(const lv_area_t * cords_p, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa);
+
+/**
+ * Draw a letter in the Virtual Display Buffer
+ * @param pos_p left-top coordinate of the latter
+ * @param mask_p the letter will be drawn only on this area
+ * @param font_p pointer to font
+ * @param letter a letter to draw
+ * @param color color of letter
+ * @param opa opacity of letter (0..255)
+ */
+void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * mask_p, const lv_font_t * font_p, uint32_t letter,
+                    lv_color_t color, lv_opa_t opa);
+
+/**
+ * Draw a color map to the display (image)
+ * @param cords_p coordinates the color map
+ * @param mask_p the map will drawn only on this area  (truncated to VDB area)
+ * @param map_p pointer to a lv_color_t array
+ * @param opa opacity of the map
+ * @param chroma_keyed true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
+ * @param alpha_byte true: extra alpha byte is inserted for every pixel
+ * @param recolor mix the pixels with this color
+ * @param recolor_opa the intense of recoloring
+ */
+void lv_draw_map(const lv_area_t * cords_p, const lv_area_t * mask_p, const uint8_t * map_p, lv_opa_t opa,
+                 bool chroma_key, bool alpha_byte, lv_color_t recolor, lv_opa_t recolor_opa);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_BASIC_H*/

extended-setup/components/lvgl/src/lv_draw/lv_draw_img.c

@@ -0,0 +1,494 @@
+/**
+ * @file lv_draw_img.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_img.h"
+#include "lv_img_cache.h"
+#include "../lv_misc/lv_log.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
+                                 const lv_style_t * style, lv_opa_t opa_scale);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Draw an image
+ * @param coords the coordinates of the image
+ * @param mask the image will be drawn only in this area
+ * @param src pointer to a lv_color_t array which contains the pixels of the image
+ * @param style style of the image
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_style_t * style,
+                 lv_opa_t opa_scale)
+{
+    if(src == NULL) {
+        LV_LOG_WARN("Image draw: src is NULL");
+        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
+        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, "No\ndata", LV_TXT_FLAG_NONE, NULL, -1, -1, NULL);
+        return;
+    }
+
+    lv_res_t res;
+    res = lv_img_draw_core(coords, mask, src, style, opa_scale);
+
+    if(res == LV_RES_INV) {
+        LV_LOG_WARN("Image draw error");
+        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
+        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, "No\ndata", LV_TXT_FLAG_NONE, NULL, -1, -1, NULL);
+        return;
+    }
+}
+
+/**
+ * Get the color of an image's pixel
+ * @param dsc an image descriptor
+ * @param x x coordinate of the point to get
+ * @param y x coordinate of the point to get
+ * @param style style of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` `style->image.color` shows
+ * the color. Can be `NULL` but for `ALPHA` images black will be returned. In other cases it is not
+ * used.
+ * @return color of the point
+ */
+lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, const lv_style_t * style)
+{
+    lv_color_t p_color = LV_COLOR_BLACK;
+    if(x >= dsc->header.w) {
+        x = dsc->header.w - 1;
+        LV_LOG_WARN("lv_canvas_get_px: x is too large (out of canvas)");
+    } else if(x < 0) {
+        x = 0;
+        LV_LOG_WARN("lv_canvas_get_px: x is < 0 (out of canvas)");
+    }
+
+    if(y >= dsc->header.h) {
+        y = dsc->header.h - 1;
+        LV_LOG_WARN("lv_canvas_get_px: y is too large (out of canvas)");
+    } else if(y < 0) {
+        y = 0;
+        LV_LOG_WARN("lv_canvas_get_px: y is < 0 (out of canvas)");
+    }
+
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED ||
+       dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
+        memcpy(&p_color, &buf_u8[px], sizeof(lv_color_t));
+#if LV_COLOR_SIZE == 32
+        p_color.ch.alpha = 0xFF; /*Only the color should be get so use a deafult alpha value*/
+#endif
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
+        buf_u8 += 4 * 2;
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+
+        uint32_t px  = (dsc->header.w >> 3) * y + x;
+        p_color.full = (buf_u8[px] & (1 << (7 - bit))) >> (7 - bit);
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_2BIT) {
+        buf_u8 += 4 * 4;
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        uint32_t px  = (dsc->header.w >> 2) * y + x;
+        p_color.full = (buf_u8[px] & (3 << (6 - bit))) >> (6 - bit);
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_4BIT) {
+        buf_u8 += 4 * 16;
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        uint32_t px  = (dsc->header.w >> 1) * y + x;
+        p_color.full = (buf_u8[px] & (0xF << (4 - bit))) >> (4 - bit);
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
+        buf_u8 += 4 * 256;
+        uint32_t px  = dsc->header.w * y + x;
+        p_color.full = buf_u8[px];
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || dsc->header.cf == LV_IMG_CF_ALPHA_2BIT ||
+              dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+        if(style)
+            p_color = style->image.color;
+        else
+            p_color = LV_COLOR_BLACK;
+    }
+    return p_color;
+}
+
+/**
+ * Get the alpha value of an image's pixel
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @return alpha value of the point
+ */
+lv_opa_t lv_img_buf_get_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y)
+{
+    if(x >= dsc->header.w) {
+        x = dsc->header.w - 1;
+        LV_LOG_WARN("lv_canvas_get_px: x is too large (out of canvas)");
+    } else if(x < 0) {
+        x = 0;
+        LV_LOG_WARN("lv_canvas_get_px: x is < 0 (out of canvas)");
+    }
+
+    if(y >= dsc->header.h) {
+        y = dsc->header.h - 1;
+        LV_LOG_WARN("lv_canvas_get_px: y is too large (out of canvas)");
+    } else if(y < 0) {
+        y = 0;
+        LV_LOG_WARN("lv_canvas_get_px: y is < 0 (out of canvas)");
+    }
+
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint32_t px = dsc->header.w * y * LV_IMG_PX_SIZE_ALPHA_BYTE + x * LV_IMG_PX_SIZE_ALPHA_BYTE;
+        return buf_u8[px + LV_IMG_PX_SIZE_ALPHA_BYTE - 1];
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT) {
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+
+        uint32_t px    = (dsc->header.w >> 3) * y + x;
+        uint8_t px_opa = (buf_u8[px] & (1 << (7 - bit))) >> (7 - bit);
+        return px_opa ? LV_OPA_TRANSP : LV_OPA_COVER;
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_2BIT) {
+        const uint8_t opa_table[4] = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
+
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        uint32_t px    = (dsc->header.w >> 2) * y + x;
+        uint8_t px_opa = (buf_u8[px] & (3 << (6 - bit))) >> (6 - bit);
+        return opa_table[px_opa];
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_4BIT) {
+        const uint8_t opa_table[16] = {0,  17, 34,  51, /*Opacity mapping with bpp = 4*/
+                                       68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
+
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        uint32_t px    = (dsc->header.w >> 1) * y + x;
+        uint8_t px_opa = (buf_u8[px] & (0xF << (4 - bit))) >> (4 - bit);
+        return opa_table[px_opa];
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+        uint32_t px = dsc->header.w * y + x;
+        return buf_u8[px];
+    }
+
+    return LV_OPA_COVER;
+}
+
+/**
+ * Set the color of a pixel of an image. The alpha channel won't be affected.
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param c color of the point
+ */
+void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t c)
+{
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
+        uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
+        memcpy(&buf_u8[px], &c, px_size);
+    } else if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
+        memcpy(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 2; /*Skip the palette*/
+
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+        uint32_t px = (dsc->header.w >> 3) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(1 << (7 - bit));
+        buf_u8[px]  = buf_u8[px] | ((c.full & 0x1) << (7 - bit));
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_2BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 4; /*Skip the palette*/
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        uint32_t px = (dsc->header.w >> 2) * y + x;
+
+        buf_u8[px] = buf_u8[px] & ~(3 << (6 - bit));
+        buf_u8[px] = buf_u8[px] | ((c.full & 0x3) << (6 - bit));
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_4BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 16; /*Skip the palette*/
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        uint32_t px = (dsc->header.w >> 1) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(0xF << (4 - bit));
+        buf_u8[px]  = buf_u8[px] | ((c.full & 0xF) << (4 - bit));
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 256; /*Skip the palette*/
+        uint32_t px = dsc->header.w * y + x;
+        buf_u8[px]  = c.full;
+    }
+}
+
+/**
+ * Set the alpha value of a pixel of an image. The color won't be affected
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param opa the desired opacity
+ */
+void lv_img_buf_set_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_opa_t opa)
+{
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint8_t px_size          = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px              = dsc->header.w * y * px_size + x * px_size;
+        buf_u8[px + px_size - 1] = opa;
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT) {
+        opa         = opa >> 7; /*opa -> [0,1]*/
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+        uint32_t px = (dsc->header.w >> 3) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(1 << (7 - bit));
+        buf_u8[px]  = buf_u8[px] | ((opa & 0x1) << (7 - bit));
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_2BIT) {
+        opa         = opa >> 6; /*opa -> [0,3]*/
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+        uint32_t px = (dsc->header.w >> 2) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(3 << (6 - bit));
+        buf_u8[px]  = buf_u8[px] | ((opa & 0x3) << (6 - bit));
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_4BIT) {
+        opa         = opa >> 4; /*opa -> [0,15]*/
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        uint32_t px = (dsc->header.w >> 1) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(0xF << (4 - bit));
+        buf_u8[px]  = buf_u8[px] | ((opa & 0xF) << (4 - bit));
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+        uint32_t px = dsc->header.w * y + x;
+        buf_u8[px]  = opa;
+    }
+}
+
+/**
+ * Set the palette color of an indexed image. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
+ * @param dsc pointer to an image descriptor
+ * @param id the palette color to set:
+ *   - for `LV_IMG_CF_INDEXED1`: 0..1
+ *   - for `LV_IMG_CF_INDEXED2`: 0..3
+ *   - for `LV_IMG_CF_INDEXED4`: 0..15
+ *   - for `LV_IMG_CF_INDEXED8`: 0..255
+ * @param c the color to set
+ */
+void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c)
+{
+    if((dsc->header.cf == LV_IMG_CF_ALPHA_1BIT && id > 1) || (dsc->header.cf == LV_IMG_CF_ALPHA_2BIT && id > 3) ||
+       (dsc->header.cf == LV_IMG_CF_ALPHA_4BIT && id > 15) || (dsc->header.cf == LV_IMG_CF_ALPHA_8BIT)) {
+        LV_LOG_WARN("lv_img_buf_set_px_alpha: invalid 'id'");
+        return;
+    }
+
+    lv_color32_t c32;
+    c32.full      = lv_color_to32(c);
+    uint8_t * buf = (uint8_t *)dsc->data;
+    memcpy(&buf[id * sizeof(c32)], &c32, sizeof(c32));
+}
+
+/**
+ * Get the pixel size of a color format in bits
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return the pixel size in bits
+ */
+uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf)
+{
+    uint8_t px_size = 0;
+
+    switch(cf) {
+        case LV_IMG_CF_UNKNOWN:
+        case LV_IMG_CF_RAW: px_size = 0; break;
+        case LV_IMG_CF_TRUE_COLOR:
+        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED: px_size = LV_COLOR_SIZE; break;
+        case LV_IMG_CF_TRUE_COLOR_ALPHA: px_size = LV_IMG_PX_SIZE_ALPHA_BYTE << 3; break;
+        case LV_IMG_CF_INDEXED_1BIT:
+        case LV_IMG_CF_ALPHA_1BIT: px_size = 1; break;
+        case LV_IMG_CF_INDEXED_2BIT:
+        case LV_IMG_CF_ALPHA_2BIT: px_size = 2; break;
+        case LV_IMG_CF_INDEXED_4BIT:
+        case LV_IMG_CF_ALPHA_4BIT: px_size = 4; break;
+        case LV_IMG_CF_INDEXED_8BIT:
+        case LV_IMG_CF_ALPHA_8BIT: px_size = 8; break;
+        default: px_size = 0; break;
+    }
+
+    return px_size;
+}
+
+/**
+ * Check if a color format is chroma keyed or not
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return true: chroma keyed; false: not chroma keyed
+ */
+bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf)
+{
+    bool is_chroma_keyed = false;
+
+    switch(cf) {
+        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED:
+        case LV_IMG_CF_RAW_CHROMA_KEYED:
+        case LV_IMG_CF_INDEXED_1BIT:
+        case LV_IMG_CF_INDEXED_2BIT:
+        case LV_IMG_CF_INDEXED_4BIT:
+        case LV_IMG_CF_INDEXED_8BIT: is_chroma_keyed = true; break;
+        default: is_chroma_keyed = false; break;
+    }
+
+    return is_chroma_keyed;
+}
+
+/**
+ * Check if a color format has alpha channel or not
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return true: has alpha channel; false: doesn't have alpha channel
+ */
+bool lv_img_color_format_has_alpha(lv_img_cf_t cf)
+{
+    bool has_alpha = false;
+
+    switch(cf) {
+        case LV_IMG_CF_TRUE_COLOR_ALPHA:
+        case LV_IMG_CF_RAW_ALPHA:
+        case LV_IMG_CF_ALPHA_1BIT:
+        case LV_IMG_CF_ALPHA_2BIT:
+        case LV_IMG_CF_ALPHA_4BIT:
+        case LV_IMG_CF_ALPHA_8BIT: has_alpha = true; break;
+        default: has_alpha = false; break;
+    }
+
+    return has_alpha;
+}
+
+/**
+ * Get the type of an image source
+ * @param src pointer to an image source:
+ *  - pointer to an 'lv_img_t' variable (image stored internally and compiled into the code)
+ *  - a path to a file (e.g. "S:/folder/image.bin")
+ *  - or a symbol (e.g. LV_SYMBOL_CLOSE)
+ * @return type of the image source LV_IMG_SRC_VARIABLE/FILE/SYMBOL/UNKNOWN
+ */
+lv_img_src_t lv_img_src_get_type(const void * src)
+{
+    lv_img_src_t img_src_type = LV_IMG_SRC_UNKNOWN;
+
+    if(src == NULL) return img_src_type;
+    const uint8_t * u8_p = src;
+
+    /*The first byte shows the type of the image source*/
+    if(u8_p[0] >= 0x20 && u8_p[0] <= 0x7F) {
+        img_src_type = LV_IMG_SRC_FILE; /*If it's an ASCII character then it's file name*/
+    } else if(u8_p[0] >= 0x80) {
+        img_src_type = LV_IMG_SRC_SYMBOL; /*Symbols begins after 0x7F*/
+    } else {
+        img_src_type = LV_IMG_SRC_VARIABLE; /*`lv_img_dsc_t` is design to the first byte < 0x20*/
+    }
+
+    if(LV_IMG_SRC_UNKNOWN == img_src_type) {
+        LV_LOG_WARN("lv_img_src_get_type: unknown image type");
+    }
+
+    return img_src_type;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
+                                 const lv_style_t * style, lv_opa_t opa_scale)
+{
+
+    lv_area_t mask_com; /*Common area of mask and coords*/
+    bool union_ok;
+    union_ok = lv_area_intersect(&mask_com, mask, coords);
+    if(union_ok == false) {
+        return LV_RES_OK; /*Out of mask. There is nothing to draw so the image is drawn
+                             successfully.*/
+    }
+
+    lv_opa_t opa =
+        opa_scale == LV_OPA_COVER ? style->image.opa : (uint16_t)((uint16_t)style->image.opa * opa_scale) >> 8;
+
+    lv_img_cache_entry_t * cdsc = lv_img_cache_open(src, style);
+
+    if(cdsc == NULL) return LV_RES_INV;
+
+    bool chroma_keyed = lv_img_color_format_is_chroma_keyed(cdsc->dec_dsc.header.cf);
+    bool alpha_byte   = lv_img_color_format_has_alpha(cdsc->dec_dsc.header.cf);
+
+    if(cdsc->dec_dsc.error_msg != NULL) {
+        LV_LOG_WARN("Image draw error");
+        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
+        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, cdsc->dec_dsc.error_msg, LV_TXT_FLAG_NONE, NULL, -1,
+                      -1, NULL);
+    }
+    /* The decoder open could open the image and gave the entire uncompressed image.
+     * Just draw it!*/
+    else if(cdsc->dec_dsc.img_data) {
+        lv_draw_map(coords, mask, cdsc->dec_dsc.img_data, opa, chroma_keyed, alpha_byte, style->image.color,
+                    style->image.intense);
+    }
+    /* The whole uncompressed image is not available. Try to read it line-by-line*/
+    else {
+        lv_coord_t width = lv_area_get_width(&mask_com);
+
+        uint8_t  * buf = lv_draw_get_buf(lv_area_get_width(&mask_com) * ((LV_COLOR_DEPTH >> 3) + 1));  /*+1 because of the possible alpha byte*/
+
+        lv_area_t line;
+        lv_area_copy(&line, &mask_com);
+        lv_area_set_height(&line, 1);
+        lv_coord_t x = mask_com.x1 - coords->x1;
+        lv_coord_t y = mask_com.y1 - coords->y1;
+        lv_coord_t row;
+        lv_res_t read_res;
+        for(row = mask_com.y1; row <= mask_com.y2; row++) {
+            read_res = lv_img_decoder_read_line(&cdsc->dec_dsc, x, y, width, buf);
+            if(read_res != LV_RES_OK) {
+                lv_img_decoder_close(&cdsc->dec_dsc);
+                LV_LOG_WARN("Image draw can't read the line");
+                return LV_RES_INV;
+            }
+            lv_draw_map(&line, mask, buf, opa, chroma_keyed, alpha_byte, style->image.color, style->image.intense);
+            line.y1++;
+            line.y2++;
+            y++;
+        }
+    }
+
+    return LV_RES_OK;
+}

extended-setup/components/lvgl/src/lv_draw/lv_draw_img.h

@@ -0,0 +1,131 @@
+/**
+ * @file lv_draw_img.h
+ *
+ */
+
+#ifndef LV_DRAW_IMG_H
+#define LV_DRAW_IMG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+#include "lv_img_decoder.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Draw an image
+ * @param coords the coordinates of the image
+ * @param mask the image will be drawn only in this area
+ * @param src pointer to a lv_color_t array which contains the pixels of the image
+ * @param style style of the image
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_style_t * style,
+                 lv_opa_t opa_scale);
+
+/**
+ * Get the type of an image source
+ * @param src pointer to an image source:
+ *  - pointer to an 'lv_img_t' variable (image stored internally and compiled into the code)
+ *  - a path to a file (e.g. "S:/folder/image.bin")
+ *  - or a symbol (e.g. LV_SYMBOL_CLOSE)
+ * @return type of the image source LV_IMG_SRC_VARIABLE/FILE/SYMBOL/UNKNOWN
+ */
+lv_img_src_t lv_img_src_get_type(const void * src);
+
+/**
+ * Get the color of an image's pixel
+ * @param dsc an image descriptor
+ * @param x x coordinate of the point to get
+ * @param y x coordinate of the point to get
+ * @param style style of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` `style->image.color` shows
+ * the color. Can be `NULL` but for `ALPHA` images black will be returned. In other cases it is not
+ * used.
+ * @return color of the point
+ */
+lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, const lv_style_t * style);
+/**
+ * Get the alpha value of an image's pixel
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @return alpha value of the point
+ */
+lv_opa_t lv_img_buf_get_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y);
+
+/**
+ * Set the color of a pixel of an image. The alpha channel won't be affected.
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param c color of the point
+ */
+void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t c);
+
+/**
+ * Set the alpha value of a pixel of an image. The color won't be affected
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param opa the desired opacity
+ */
+void lv_img_buf_set_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_opa_t opa);
+
+/**
+ * Set the palette color of an indexed image. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
+ * @param dsc pointer to an image descriptor
+ * @param id the palette color to set:
+ *   - for `LV_IMG_CF_INDEXED1`: 0..1
+ *   - for `LV_IMG_CF_INDEXED2`: 0..3
+ *   - for `LV_IMG_CF_INDEXED4`: 0..15
+ *   - for `LV_IMG_CF_INDEXED8`: 0..255
+ * @param c the color to set
+ */
+void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c);
+
+/**
+ * Get the pixel size of a color format in bits
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return the pixel size in bits
+ */
+uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf);
+
+/**
+ * Check if a color format is chroma keyed or not
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return true: chroma keyed; false: not chroma keyed
+ */
+bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf);
+
+/**
+ * Check if a color format has alpha channel or not
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return true: has alpha channel; false: doesn't have alpha channel
+ */
+bool lv_img_color_format_has_alpha(lv_img_cf_t cf);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_TEMPL_H*/

extended-setup/components/lvgl/src/lv_draw/lv_draw_label.c

@@ -0,0 +1,283 @@
+/**
+ * @file lv_draw_label.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_label.h"
+#include "../lv_misc/lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LABEL_RECOLOR_PAR_LENGTH 6
+#define LV_LABEL_HINT_UPDATE_TH 1024 /*Update the "hint" if the label's y coordinates have changed more then this*/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum {
+    CMD_STATE_WAIT,
+    CMD_STATE_PAR,
+    CMD_STATE_IN,
+};
+typedef uint8_t cmd_state_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static uint8_t hex_char_to_num(char hex);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Write a text
+ * @param coords coordinates of the label
+ * @param mask the label will be drawn only in this area
+ * @param style pointer to a style
+ * @param opa_scale scale down all opacities by the factor
+ * @param txt 0 terminated text to write
+ * @param flag settings for the text from 'txt_flag_t' enum
+ * @param offset text offset in x and y direction (NULL if unused)
+ * @param sel_start start index of selected area (`LV_LABEL_TXT_SEL_OFF` if none)
+ * @param sel_end end index of selected area (`LV_LABEL_TXT_SEL_OFF` if none)
+ */
+void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale,
+                   const char * txt, lv_txt_flag_t flag, lv_point_t * offset, uint16_t sel_start, uint16_t sel_end,
+                   lv_draw_label_hint_t * hint)
+{
+    const lv_font_t * font = style->text.font;
+    lv_coord_t w;
+    if((flag & LV_TXT_FLAG_EXPAND) == 0) {
+        /*Normally use the label's width as width*/
+        w = lv_area_get_width(coords);
+    } else {
+        /*If EXAPND is enabled then not limit the text's width to the object's width*/
+        lv_point_t p;
+        lv_txt_get_size(&p, txt, style->text.font, style->text.letter_space, style->text.line_space, LV_COORD_MAX,
+                        flag);
+        w = p.x;
+    }
+
+    lv_coord_t line_height = lv_font_get_line_height(font) + style->text.line_space;
+
+    /*Init variables for the first line*/
+    lv_coord_t line_width = 0;
+    lv_point_t pos;
+    pos.x = coords->x1;
+    pos.y = coords->y1;
+
+    lv_coord_t x_ofs = 0;
+    lv_coord_t y_ofs = 0;
+    if(offset != NULL) {
+        x_ofs = offset->x;
+        y_ofs = offset->y;
+        pos.y += y_ofs;
+    }
+
+    uint32_t line_start     = 0;
+    int32_t last_line_start = -1;
+
+    /*Check the hint to use the cached info*/
+    if(hint && y_ofs == 0) {
+        /*If the label changed too much recalculate the hint.*/
+        if(LV_MATH_ABS(hint->coord_y - coords->y1) > LV_LABEL_HINT_UPDATE_TH - 2 * line_height) {
+            hint->line_start = -1;
+        }
+        last_line_start = hint->line_start;
+    }
+
+    /*Use the hint if it's valid*/
+    if(hint && last_line_start >= 0) {
+        line_start = last_line_start;
+        pos.y += hint->y;
+    }
+
+    uint32_t line_end = line_start + lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
+
+    /*Go the first visible line*/
+    while(pos.y + line_height < mask->y1) {
+        /*Go to next line*/
+        line_start = line_end;
+        line_end += lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
+        pos.y += line_height;
+
+        /*Save at the threshold coordinate*/
+        if(hint && pos.y >= -LV_LABEL_HINT_UPDATE_TH && hint->line_start < 0) {
+            hint->line_start = line_start;
+            hint->y          = pos.y - coords->y1;
+            hint->coord_y    = coords->y1;
+        }
+
+        if(txt[line_start] == '\0') return;
+    }
+
+    /*Align to middle*/
+    if(flag & LV_TXT_FLAG_CENTER) {
+        line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+
+        pos.x += (lv_area_get_width(coords) - line_width) / 2;
+
+    }
+    /*Align to the right*/
+    else if(flag & LV_TXT_FLAG_RIGHT) {
+        line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+        pos.x += lv_area_get_width(coords) - line_width;
+    }
+
+    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->text.opa : (uint16_t)((uint16_t)style->text.opa * opa_scale) >> 8;
+
+    cmd_state_t cmd_state = CMD_STATE_WAIT;
+    uint32_t i;
+    uint16_t par_start = 0;
+    lv_color_t recolor;
+    lv_coord_t letter_w;
+    lv_style_t sel_style;
+    lv_style_copy(&sel_style, &lv_style_plain_color);
+    sel_style.body.main_color = sel_style.body.grad_color = style->text.sel_color;
+
+    /*Write out all lines*/
+    while(txt[line_start] != '\0') {
+        if(offset != NULL) {
+            pos.x += x_ofs;
+        }
+        /*Write all letter of a line*/
+        cmd_state = CMD_STATE_WAIT;
+        i         = line_start;
+        uint32_t letter;
+        uint32_t letter_next;
+        while(i < line_end) {
+            letter      = lv_txt_encoded_next(txt, &i);
+            letter_next = lv_txt_encoded_next(&txt[i], NULL);
+
+            /*Handle the re-color command*/
+            if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
+                if(letter == (uint32_t)LV_TXT_COLOR_CMD[0]) {
+                    if(cmd_state == CMD_STATE_WAIT) { /*Start char*/
+                        par_start = i;
+                        cmd_state = CMD_STATE_PAR;
+                        continue;
+                    } else if(cmd_state == CMD_STATE_PAR) { /*Other start char in parameter escaped cmd. char */
+                        cmd_state = CMD_STATE_WAIT;
+                    } else if(cmd_state == CMD_STATE_IN) { /*Command end */
+                        cmd_state = CMD_STATE_WAIT;
+                        continue;
+                    }
+                }
+
+                /*Skip the color parameter and wait the space after it*/
+                if(cmd_state == CMD_STATE_PAR) {
+                    if(letter == ' ') {
+                        /*Get the parameter*/
+                        if(i - par_start == LABEL_RECOLOR_PAR_LENGTH + 1) {
+                            char buf[LABEL_RECOLOR_PAR_LENGTH + 1];
+                            memcpy(buf, &txt[par_start], LABEL_RECOLOR_PAR_LENGTH);
+                            buf[LABEL_RECOLOR_PAR_LENGTH] = '\0';
+                            int r, g, b;
+                            r       = (hex_char_to_num(buf[0]) << 4) + hex_char_to_num(buf[1]);
+                            g       = (hex_char_to_num(buf[2]) << 4) + hex_char_to_num(buf[3]);
+                            b       = (hex_char_to_num(buf[4]) << 4) + hex_char_to_num(buf[5]);
+                            recolor = lv_color_make(r, g, b);
+                        } else {
+                            recolor.full = style->text.color.full;
+                        }
+                        cmd_state = CMD_STATE_IN; /*After the parameter the text is in the command*/
+                    }
+                    continue;
+                }
+            }
+
+            lv_color_t color = style->text.color;
+
+            if(cmd_state == CMD_STATE_IN) color = recolor;
+
+            letter_w = lv_font_get_glyph_width(font, letter, letter_next);
+
+            if(sel_start != 0xFFFF && sel_end != 0xFFFF) {
+                int char_ind = lv_encoded_get_char_id(txt, i);
+                /*Do not draw the rectangle on the character at `sel_start`.*/
+                if(char_ind > sel_start && char_ind <= sel_end) {
+                    lv_area_t sel_coords;
+                    sel_coords.x1 = pos.x;
+                    sel_coords.y1 = pos.y;
+                    sel_coords.x2 = pos.x + letter_w + style->text.letter_space - 1;
+                    sel_coords.y2 = pos.y + line_height - 1;
+                    lv_draw_rect(&sel_coords, mask, &sel_style, opa);
+                }
+            }
+            lv_draw_letter(&pos, mask, font, letter, color, opa);
+
+            if(letter_w > 0) {
+                pos.x += letter_w + style->text.letter_space;
+            }
+        }
+        /*Go to next line*/
+        line_start = line_end;
+        line_end += lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
+
+        pos.x = coords->x1;
+        /*Align to middle*/
+        if(flag & LV_TXT_FLAG_CENTER) {
+            line_width =
+                lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+
+            pos.x += (lv_area_get_width(coords) - line_width) / 2;
+
+        }
+        /*Align to the right*/
+        else if(flag & LV_TXT_FLAG_RIGHT) {
+            line_width =
+                lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+            pos.x += lv_area_get_width(coords) - line_width;
+        }
+
+        /*Go the next line position*/
+        pos.y += line_height;
+
+        if(pos.y > mask->y2) return;
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Convert a hexadecimal characters to a number (0..15)
+ * @param hex Pointer to a hexadecimal character (0..9, A..F)
+ * @return the numerical value of `hex` or 0 on error
+ */
+static uint8_t hex_char_to_num(char hex)
+{
+    uint8_t result = 0;
+
+    if(hex >= '0' && hex <= '9') {
+        result = hex - '0';
+    } else {
+        if(hex >= 'a') hex -= 'a' - 'A'; /*Convert to upper case*/
+
+        switch(hex) {
+            case 'A': result = 10; break;
+            case 'B': result = 11; break;
+            case 'C': result = 12; break;
+            case 'D': result = 13; break;
+            case 'E': result = 14; break;
+            case 'F': result = 15; break;
+            default: result = 0; break;
+        }
+    }
+
+    return result;
+}

extended-setup/components/lvgl/src/lv_draw/lv_draw_label.h

@@ -0,0 +1,71 @@
+/**
+ * @file lv_draw_label.h
+ *
+ */
+
+#ifndef LV_DRAW_LABEL_H
+#define LV_DRAW_LABEL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/** Store some info to speed up drawing of very large texts
+ * It takes a lot of time to get the first visible character because
+ * all the previous characters needs to be checked to calculate the positions.
+ * This structure stores an earlier (e.g. at -1000 px) coordinate and the index of that line.
+ * Therefore the calculations can start from here.*/
+typedef struct {
+    /** Index of the line at `y` coordinate*/
+    int32_t line_start;
+
+    /** Give the `y` coordinate of the first letter at `line start` index. Relative to the label's coordinates*/
+    int32_t y;
+
+    /** The 'y1' coordinate of the label when the hint was saved.
+     * Used to invalidate the hint if the label has moved too much. */
+    int32_t coord_y;
+}lv_draw_label_hint_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Write a text
+ * @param coords coordinates of the label
+ * @param mask the label will be drawn only in this area
+ * @param style pointer to a style
+ * @param opa_scale scale down all opacities by the factor
+ * @param txt 0 terminated text to write
+ * @param flag settings for the text from 'txt_flag_t' enum
+ * @param offset text offset in x and y direction (NULL if unused)
+ * @param sel_start start index of selected area (`LV_LABEL_TXT_SEL_OFF` if none)
+ * @param sel_end end index of selected area (`LV_LABEL_TXT_SEL_OFF` if none)
+ */
+void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale,
+                   const char * txt, lv_txt_flag_t flag, lv_point_t * offset, uint16_t sel_start, uint16_t sel_end,
+                   lv_draw_label_hint_t * hint);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_LABEL_H*/

extended-setup/components/lvgl/src/lv_draw/lv_draw_line.c

@@ -0,0 +1,636 @@
+/**
+ * @file lv_draw_line.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdio.h>
+#include <stdbool.h>
+#include "lv_draw.h"
+#include "../lv_core/lv_refr.h"
+#include "../lv_misc/lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct
+{
+    lv_point_t p1;
+    lv_point_t p2;
+    lv_point_t p_act;
+    lv_coord_t dx;
+    lv_coord_t sx; /*-1: x1 < x2; 1: x2 >= x1*/
+    lv_coord_t dy;
+    lv_coord_t sy; /*-1: y1 < y2; 1: y2 >= y1*/
+    lv_coord_t err;
+    lv_coord_t e2;
+    bool hor; /*Rather horizontal or vertical*/
+} line_draw_t;
+
+typedef struct
+{
+    lv_coord_t width;
+    lv_coord_t width_1;
+    lv_coord_t width_half;
+} line_width_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void line_draw_hor(line_draw_t * main_line, const lv_area_t * mask, const lv_style_t * style,
+                          lv_opa_t opa_scale);
+static void line_draw_ver(line_draw_t * main_line, const lv_area_t * mask, const lv_style_t * style,
+                          lv_opa_t opa_scale);
+static void line_draw_skew(line_draw_t * main_line, bool dir_ori, const lv_area_t * mask, const lv_style_t * style,
+                           lv_opa_t opa_scale);
+static void line_init(line_draw_t * line, const lv_point_t * p1, const lv_point_t * p2);
+static bool line_next(line_draw_t * line);
+static bool line_next_y(line_draw_t * line);
+static bool line_next_x(line_draw_t * line);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Draw a line
+ * @param point1 first point of the line
+ * @param point2 second point of the line
+ * @param mask the line will be drawn only on this area
+ * @param style pointer to a line's style
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_line(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * mask,
+                  const lv_style_t * style, lv_opa_t opa_scale)
+{
+
+    if(style->line.width == 0) return;
+    if(point1->x == point2->x && point1->y == point2->y) return;
+
+    /*Return if the points are out of the mask*/
+    if(point1->x < mask->x1 - style->line.width && point2->x < mask->x1 - style->line.width) return;
+    if(point1->x > mask->x2 + style->line.width && point2->x > mask->x2 + style->line.width) return;
+    if(point1->y < mask->y1 - style->line.width && point2->y < mask->y1 - style->line.width) return;
+    if(point1->y > mask->y2 + style->line.width && point2->y > mask->y2 + style->line.width) return;
+
+    line_draw_t main_line;
+    lv_point_t p1;
+    lv_point_t p2;
+
+    /*If the line if rather vertical then be sure y1 < y2 else x1 < x2*/
+
+    if(LV_MATH_ABS(point1->x - point2->x) > LV_MATH_ABS(point1->y - point2->y)) {
+
+        /*Steps less in y then x -> rather horizontal*/
+        if(point1->x < point2->x) {
+            p1.x = point1->x;
+            p1.y = point1->y;
+            p2.x = point2->x;
+            p2.y = point2->y;
+        } else {
+            p1.x = point2->x;
+            p1.y = point2->y;
+            p2.x = point1->x;
+            p2.y = point1->y;
+        }
+    } else {
+        /*Steps less in x then y -> rather vertical*/
+        if(point1->y < point2->y) {
+            p1.x = point1->x;
+            p1.y = point1->y;
+            p2.x = point2->x;
+            p2.y = point2->y;
+        } else {
+            p1.x = point2->x;
+            p1.y = point2->y;
+            p2.x = point1->x;
+            p2.y = point1->y;
+        }
+    }
+
+    line_init(&main_line, &p1, &p2);
+
+    /*Special case draw a horizontal line*/
+    if(main_line.p1.y == main_line.p2.y) {
+        line_draw_hor(&main_line, mask, style, opa_scale);
+    }
+    /*Special case draw a vertical line*/
+    else if(main_line.p1.x == main_line.p2.x) {
+        line_draw_ver(&main_line, mask, style, opa_scale);
+    }
+    /*Arbitrary skew line*/
+    else {
+        bool dir_ori = false;
+#if LV_ANTIALIAS
+        bool aa = lv_disp_get_antialiasing(lv_refr_get_disp_refreshing());
+        if(aa) {
+            lv_point_t p_tmp;
+
+            if(main_line.hor) {
+                if(main_line.p1.y < main_line.p2.y) {
+                    dir_ori = true;
+                    p_tmp.x = main_line.p2.x;
+                    p_tmp.y = main_line.p2.y - 1;
+                    line_init(&main_line, &p1, &p_tmp);
+                    main_line.sy = LV_MATH_ABS(main_line.sy); /*The sign can change if the line becomes horizontal*/
+                } else if(main_line.p1.y > main_line.p2.y) {
+                    dir_ori = false;
+                    p_tmp.x = main_line.p2.x;
+                    p_tmp.y = main_line.p2.y + 1;
+                    line_init(&main_line, &p1, &p_tmp);
+                    main_line.sy = -LV_MATH_ABS(main_line.sy); /*The sign can change if the line becomes horizontal*/
+                }
+            } else {
+                if(main_line.p1.x < main_line.p2.x) {
+                    dir_ori = true;
+                    p_tmp.x = main_line.p2.x - 1;
+                    p_tmp.y = main_line.p2.y;
+                    line_init(&main_line, &p1, &p_tmp);
+                    main_line.sx = LV_MATH_ABS(main_line.sx); /*The sign can change if the line becomes vertical*/
+                } else if(main_line.p1.x > main_line.p2.x) {
+                    dir_ori = false;
+                    p_tmp.x = main_line.p2.x + 1;
+                    p_tmp.y = main_line.p2.y;
+                    line_init(&main_line, &p1, &p_tmp);
+                    main_line.sx = -LV_MATH_ABS(main_line.sx); /*The sign can change if the line becomes vertical*/
+                }
+            }
+        }
+#endif
+        line_draw_skew(&main_line, dir_ori, mask, style, opa_scale);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void line_draw_hor(line_draw_t * main_line, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale)
+{
+    lv_coord_t width      = style->line.width - 1;
+    lv_coord_t width_half = width >> 1;
+    lv_coord_t width_1    = width & 0x1;
+    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->line.opa : (uint16_t)((uint16_t)style->line.opa * opa_scale) >> 8;
+
+    lv_area_t act_area;
+    act_area.x1 = main_line->p1.x;
+    act_area.x2 = main_line->p2.x;
+    act_area.y1 = main_line->p1.y - width_half - width_1;
+    act_area.y2 = main_line->p2.y + width_half;
+
+    lv_area_t draw_area;
+    draw_area.x1 = LV_MATH_MIN(act_area.x1, act_area.x2);
+    draw_area.x2 = LV_MATH_MAX(act_area.x1, act_area.x2);
+    draw_area.y1 = LV_MATH_MIN(act_area.y1, act_area.y2);
+    draw_area.y2 = LV_MATH_MAX(act_area.y1, act_area.y2);
+    lv_draw_fill(&draw_area, mask, style->line.color, opa);
+}
+
+static void line_draw_ver(line_draw_t * main_line, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale)
+{
+    lv_coord_t width      = style->line.width - 1;
+    lv_coord_t width_half = width >> 1;
+    lv_coord_t width_1    = width & 0x1;
+    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->line.opa : (uint16_t)((uint16_t)style->line.opa * opa_scale) >> 8;
+
+    lv_area_t act_area;
+    act_area.x1 = main_line->p1.x - width_half;
+    act_area.x2 = main_line->p2.x + width_half + width_1;
+    act_area.y1 = main_line->p1.y;
+    act_area.y2 = main_line->p2.y;
+
+    lv_area_t draw_area;
+    draw_area.x1 = LV_MATH_MIN(act_area.x1, act_area.x2);
+    draw_area.x2 = LV_MATH_MAX(act_area.x1, act_area.x2);
+    draw_area.y1 = LV_MATH_MIN(act_area.y1, act_area.y2);
+    draw_area.y2 = LV_MATH_MAX(act_area.y1, act_area.y2);
+    lv_draw_fill(&draw_area, mask, style->line.color, opa);
+}
+
+static void line_draw_skew(line_draw_t * main_line, bool dir_ori, const lv_area_t * mask, const lv_style_t * style,
+                           lv_opa_t opa_scale)
+{
+
+    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->line.opa : (uint16_t)((uint16_t)style->line.opa * opa_scale) >> 8;
+#if LV_ANTIALIAS
+    bool aa = lv_disp_get_antialiasing(lv_refr_get_disp_refreshing());
+#endif
+    lv_point_t vect_main, vect_norm;
+    vect_main.x = main_line->p2.x - main_line->p1.x;
+    vect_main.y = main_line->p2.y - main_line->p1.y;
+
+    if(main_line->hor) {
+        if(main_line->p1.y < main_line->p2.y + dir_ori) {
+            vect_norm.x = -vect_main.y;
+            vect_norm.y = vect_main.x;
+        } else {
+            vect_norm.x = vect_main.y;
+            vect_norm.y = -vect_main.x;
+        }
+    } else {
+        if(main_line->p1.x < main_line->p2.x + dir_ori) {
+            vect_norm.x = vect_main.y;
+            vect_norm.y = -vect_main.x;
+        } else {
+            vect_norm.x = -vect_main.y;
+            vect_norm.y = vect_main.x;
+        }
+    }
+
+    /* In case of a short but tick line the perpendicular ending is longer then the real line.
+     * it would break the calculations so make the normal vector larger*/
+    vect_norm.x = vect_norm.x << 4;
+    vect_norm.y = vect_norm.y << 4;
+
+    lv_coord_t width;
+    width = style->line.width;
+
+    /* The pattern stores the points of the line ending. It has the good direction and length.
+     * The worth case is the 45° line where pattern can have 1.41 x `width` points*/
+
+    lv_point_t * pattern = lv_draw_get_buf(width * 2 * sizeof(lv_point_t));
+    lv_coord_t i = 0;
+
+    /*Create a perpendicular pattern (a small line)*/
+    if(width != 0) {
+        line_draw_t pattern_line;
+        lv_point_t p0 = {0, 0};
+        line_init(&pattern_line, &p0, &vect_norm);
+
+        uint32_t width_sqr = width * width;
+        /* Run for a lot of times. Meanwhile the real width will be determined as well */
+        for(i = 0; i < (lv_coord_t)sizeof(pattern); i++) {
+            pattern[i].x = pattern_line.p_act.x;
+            pattern[i].y = pattern_line.p_act.y;
+
+            /*Finish the pattern line if it's length equal to the desired width (Use Pythagoras
+             * theorem)*/
+            uint32_t sqr = pattern_line.p_act.x * pattern_line.p_act.x + pattern_line.p_act.y * pattern_line.p_act.y;
+            if(sqr >= width_sqr) {
+                width = i;
+#if LV_ANTIALIAS
+                if(aa) width--;
+#endif
+                break;
+            }
+
+            line_next(&pattern_line);
+        }
+    }
+
+#if LV_ANTIALIAS
+    lv_coord_t aa_last_corner;
+    lv_coord_t width_safe = width;
+    if(aa) {
+        if(width == 0) width_safe = 1;
+
+        aa_last_corner = 0;
+    }
+#endif
+
+    lv_coord_t x_center_ofs = 0;
+    lv_coord_t y_center_ofs = 0;
+
+    if(width != 0) {
+        x_center_ofs = pattern[width - 1].x / 2;
+        y_center_ofs = pattern[width - 1].y / 2;
+    } else {
+        if(main_line->hor && main_line->p1.y >= main_line->p2.y + dir_ori) pattern[0].y--;
+        if(!main_line->hor && main_line->p1.x >= main_line->p2.x + dir_ori) pattern[0].x--;
+    }
+
+    /* Make the coordinates relative to the center */
+    for(i = 0; i < width; i++) {
+        pattern[i].x -= x_center_ofs;
+        pattern[i].y -= y_center_ofs;
+#if LV_ANTIALIAS
+        if(aa) {
+            if(i != 0) {
+                if(main_line->hor) {
+                    if(pattern[i - 1].x != pattern[i].x) {
+                        lv_coord_t seg_w = pattern[i].y - pattern[aa_last_corner].y;
+                        if(main_line->sy < 0) {
+                            lv_draw_aa_ver_seg(main_line->p1.x + pattern[aa_last_corner].x - 1,
+                                               main_line->p1.y + pattern[aa_last_corner].y + seg_w + 1, seg_w, mask,
+                                               style->line.color, opa);
+
+                            lv_draw_aa_ver_seg(main_line->p2.x + pattern[aa_last_corner].x + 1,
+                                               main_line->p2.y + pattern[aa_last_corner].y + seg_w + 1, -seg_w, mask,
+                                               style->line.color, opa);
+                        } else {
+                            lv_draw_aa_ver_seg(main_line->p1.x + pattern[aa_last_corner].x - 1,
+                                               main_line->p1.y + pattern[aa_last_corner].y, seg_w, mask,
+                                               style->line.color, opa);
+
+                            lv_draw_aa_ver_seg(main_line->p2.x + pattern[aa_last_corner].x + 1,
+                                               main_line->p2.y + pattern[aa_last_corner].y, -seg_w, mask,
+                                               style->line.color, opa);
+                        }
+                        aa_last_corner = i;
+                    }
+                } else {
+                    if(pattern[i - 1].y != pattern[i].y) {
+                        lv_coord_t seg_w = pattern[i].x - pattern[aa_last_corner].x;
+                        if(main_line->sx < 0) {
+                            lv_draw_aa_hor_seg(main_line->p1.x + pattern[aa_last_corner].x + seg_w + 1,
+                                               main_line->p1.y + pattern[aa_last_corner].y - 1, seg_w, mask,
+                                               style->line.color, opa);
+
+                            lv_draw_aa_hor_seg(main_line->p2.x + pattern[aa_last_corner].x + seg_w + 1,
+                                               main_line->p2.y + pattern[aa_last_corner].y + 1, -seg_w, mask,
+                                               style->line.color, opa);
+                        } else {
+                            lv_draw_aa_hor_seg(main_line->p1.x + pattern[aa_last_corner].x,
+                                               main_line->p1.y + pattern[aa_last_corner].y - 1, seg_w, mask,
+                                               style->line.color, opa);
+
+                            lv_draw_aa_hor_seg(main_line->p2.x + pattern[aa_last_corner].x,
+                                               main_line->p2.y + pattern[aa_last_corner].y + 1, -seg_w, mask,
+                                               style->line.color, opa);
+                        }
+                        aa_last_corner = i;
+                    }
+                }
+            }
+        }
+#endif
+    }
+
+#if LV_ANTIALIAS
+    /*Add the last part of anti-aliasing for the perpendicular ending*/
+    if(width != 0 && aa) { /*Due to rounding error with very thin lines it looks ugly*/
+        if(main_line->hor) {
+            lv_coord_t seg_w = pattern[width_safe - 1].y - pattern[aa_last_corner].y;
+            if(main_line->sy < 0) {
+                lv_draw_aa_ver_seg(main_line->p1.x + pattern[aa_last_corner].x - 1,
+                                   main_line->p1.y + pattern[aa_last_corner].y + seg_w, seg_w + main_line->sy, mask,
+                                   style->line.color, opa);
+
+                lv_draw_aa_ver_seg(main_line->p2.x + pattern[aa_last_corner].x + 1,
+                                   main_line->p2.y + pattern[aa_last_corner].y + seg_w, -(seg_w + main_line->sy), mask,
+                                   style->line.color, opa);
+
+            } else {
+                lv_draw_aa_ver_seg(main_line->p1.x + pattern[aa_last_corner].x - 1,
+                                   main_line->p1.y + pattern[aa_last_corner].y, seg_w + main_line->sy, mask,
+                                   style->line.color, opa);
+
+                lv_draw_aa_ver_seg(main_line->p2.x + pattern[aa_last_corner].x + 1,
+                                   main_line->p2.y + pattern[aa_last_corner].y, -(seg_w + main_line->sy), mask,
+                                   style->line.color, opa);
+            }
+        } else {
+            lv_coord_t seg_w = pattern[width_safe - 1].x - pattern[aa_last_corner].x;
+            if(main_line->sx < 0) {
+                lv_draw_aa_hor_seg(main_line->p1.x + pattern[aa_last_corner].x + seg_w,
+                                   main_line->p1.y + pattern[aa_last_corner].y - 1, seg_w + main_line->sx, mask,
+                                   style->line.color, opa);
+
+                lv_draw_aa_hor_seg(main_line->p2.x + pattern[aa_last_corner].x + seg_w,
+                                   main_line->p2.y + pattern[aa_last_corner].y + 1, -(seg_w + main_line->sx), mask,
+                                   style->line.color, opa);
+
+            } else {
+                lv_draw_aa_hor_seg(main_line->p1.x + pattern[aa_last_corner].x,
+                                   main_line->p1.y + pattern[aa_last_corner].y - 1, seg_w + main_line->sx, mask,
+                                   style->line.color, opa);
+
+                lv_draw_aa_hor_seg(main_line->p2.x + pattern[aa_last_corner].x,
+                                   main_line->p2.y + pattern[aa_last_corner].y + 1, -(seg_w + main_line->sx), mask,
+                                   style->line.color, opa);
+            }
+        }
+    }
+#endif
+
+#if LV_ANTIALIAS
+
+    /*Shift the anti aliasing on the edges (-1, 1 or 0 (zero only in case width == 0))*/
+    lv_coord_t aa_shift1 = 0;
+    lv_coord_t aa_shift2 = 0;
+    if(aa) {
+        if(main_line->hor == false) {
+            if(main_line->sx < 0) {
+                aa_shift1 = -1;
+                aa_shift2 = width == 0 ? 0 : aa_shift1;
+            } else {
+                aa_shift2 = 1;
+                aa_shift1 = width == 0 ? 0 : aa_shift2;
+            }
+        } else {
+            if(main_line->sy < 0) {
+                aa_shift1 = -1;
+                aa_shift2 = width == 0 ? 0 : aa_shift1;
+            } else {
+                aa_shift2 = 1;
+                aa_shift1 = width == 0 ? 0 : aa_shift2;
+            }
+        }
+    }
+#endif
+
+    volatile lv_point_t prev_p;
+    prev_p.x = main_line->p1.x;
+    prev_p.y = main_line->p1.y;
+    lv_area_t draw_area;
+    bool first_run = true;
+
+    if(main_line->hor) {
+        while(line_next_y(main_line)) {
+            for(i = 0; i < width; i++) {
+                draw_area.x1 = prev_p.x + pattern[i].x;
+                draw_area.y1 = prev_p.y + pattern[i].y;
+                draw_area.x2 = draw_area.x1 + main_line->p_act.x - prev_p.x - 1;
+                draw_area.y2 = draw_area.y1;
+                lv_draw_fill(&draw_area, mask, style->line.color, opa);
+
+                /* Fill the gaps
+                 * When stepping in y one pixel remains empty on every corner (don't do this on the
+                 * first segment ) */
+                if(i != 0 && pattern[i].x != pattern[i - 1].x && !first_run) {
+                    lv_draw_px(draw_area.x1, draw_area.y1 - main_line->sy, mask, style->line.color, opa);
+                }
+            }
+
+#if LV_ANTIALIAS
+            if(aa) {
+                lv_draw_aa_hor_seg(prev_p.x + pattern[0].x, prev_p.y + pattern[0].y - aa_shift1,
+                                   -(main_line->p_act.x - prev_p.x), mask, style->line.color, opa);
+                lv_draw_aa_hor_seg(prev_p.x + pattern[width_safe - 1].x,
+                                   prev_p.y + pattern[width_safe - 1].y + aa_shift2, main_line->p_act.x - prev_p.x,
+                                   mask, style->line.color, opa);
+            }
+#endif
+
+            first_run = false;
+
+            prev_p.x = main_line->p_act.x;
+            prev_p.y = main_line->p_act.y;
+        }
+
+        for(i = 0; i < width; i++) {
+            draw_area.x1 = prev_p.x + pattern[i].x;
+            draw_area.y1 = prev_p.y + pattern[i].y;
+            draw_area.x2 = draw_area.x1 + main_line->p_act.x - prev_p.x;
+            draw_area.y2 = draw_area.y1;
+            lv_draw_fill(&draw_area, mask, style->line.color, opa);
+
+            /* Fill the gaps
+             * When stepping in y one pixel remains empty on every corner */
+            if(i != 0 && pattern[i].x != pattern[i - 1].x && !first_run) {
+                lv_draw_px(draw_area.x1, draw_area.y1 - main_line->sy, mask, style->line.color, opa);
+            }
+        }
+
+#if LV_ANTIALIAS
+        if(aa) {
+            lv_draw_aa_hor_seg(prev_p.x + pattern[0].x, prev_p.y + pattern[0].y - aa_shift1,
+                               -(main_line->p_act.x - prev_p.x + 1), mask, style->line.color, opa);
+            lv_draw_aa_hor_seg(prev_p.x + pattern[width_safe - 1].x, prev_p.y + pattern[width_safe - 1].y + aa_shift2,
+                               main_line->p_act.x - prev_p.x + 1, mask, style->line.color, opa);
+        }
+#endif
+    }
+    /*Rather a vertical line*/
+    else {
+
+        while(line_next_x(main_line)) {
+            for(i = 0; i < width; i++) {
+                draw_area.x1 = prev_p.x + pattern[i].x;
+                draw_area.y1 = prev_p.y + pattern[i].y;
+                draw_area.x2 = draw_area.x1;
+                draw_area.y2 = draw_area.y1 + main_line->p_act.y - prev_p.y - 1;
+
+                lv_draw_fill(&draw_area, mask, style->line.color, opa);
+
+                /* Fill the gaps
+                 * When stepping in x one pixel remains empty on every corner (don't do this on the
+                 * first segment ) */
+                if(i != 0 && pattern[i].y != pattern[i - 1].y && !first_run) {
+                    lv_draw_px(draw_area.x1 - main_line->sx, draw_area.y1, mask, style->line.color, opa);
+                }
+            }
+
+#if LV_ANTIALIAS
+            if(aa) {
+                lv_draw_aa_ver_seg(prev_p.x + pattern[0].x - aa_shift1, prev_p.y + pattern[0].y,
+                                   -(main_line->p_act.y - prev_p.y), mask, style->line.color, opa);
+                lv_draw_aa_ver_seg(prev_p.x + pattern[width_safe - 1].x + aa_shift2,
+                                   prev_p.y + pattern[width_safe - 1].y, main_line->p_act.y - prev_p.y, mask,
+                                   style->line.color, opa);
+            }
+#endif
+
+            first_run = false;
+
+            prev_p.x = main_line->p_act.x;
+            prev_p.y = main_line->p_act.y;
+        }
+
+        /*Draw the last part*/
+        for(i = 0; i < width; i++) {
+            draw_area.x1 = prev_p.x + pattern[i].x;
+            draw_area.y1 = prev_p.y + pattern[i].y;
+            draw_area.x2 = draw_area.x1;
+            draw_area.y2 = draw_area.y1 + main_line->p_act.y - prev_p.y;
+
+            lv_draw_fill(&draw_area, mask, style->line.color, opa);
+
+            /* Fill the gaps
+             * When stepping in x one pixel remains empty on every corner */
+            if(i != 0 && pattern[i].y != pattern[i - 1].y && !first_run) {
+                lv_draw_px(draw_area.x1 - main_line->sx, draw_area.y1, mask, style->line.color, opa);
+            }
+        }
+
+#if LV_ANTIALIAS
+        if(aa) {
+            lv_draw_aa_ver_seg(prev_p.x + pattern[0].x - aa_shift1, prev_p.y + pattern[0].y,
+                               -(main_line->p_act.y - prev_p.y + 1), mask, style->line.color, opa);
+            lv_draw_aa_ver_seg(prev_p.x + pattern[width_safe - 1].x + aa_shift2, prev_p.y + pattern[width_safe - 1].y,
+                               main_line->p_act.y - prev_p.y + 1, mask, style->line.color, opa);
+        }
+#endif
+    }
+}
+
+static void line_init(line_draw_t * line, const lv_point_t * p1, const lv_point_t * p2)
+{
+    line->p1.x = p1->x;
+    line->p1.y = p1->y;
+    line->p2.x = p2->x;
+    line->p2.y = p2->y;
+
+    line->dx  = LV_MATH_ABS(line->p2.x - line->p1.x);
+    line->sx  = line->p1.x < line->p2.x ? 1 : -1;
+    line->dy  = LV_MATH_ABS(line->p2.y - line->p1.y);
+    line->sy  = line->p1.y < line->p2.y ? 1 : -1;
+    line->err = (line->dx > line->dy ? line->dx : -line->dy) / 2;
+    line->e2  = 0;
+    line->hor = line->dx > line->dy ? true : false; /*Rather horizontal or vertical*/
+
+    line->p_act.x = line->p1.x;
+    line->p_act.y = line->p1.y;
+}
+
+static bool line_next(line_draw_t * line)
+{
+    if(line->p_act.x == line->p2.x && line->p_act.y == line->p2.y) return false;
+    line->e2 = line->err;
+    if(line->e2 > -line->dx) {
+        line->err -= line->dy;
+        line->p_act.x += line->sx;
+    }
+    if(line->e2 < line->dy) {
+        line->err += line->dx;
+        line->p_act.y += line->sy;
+    }
+    return true;
+}
+
+/**
+ * Iterate until step one in y direction.
+ * @param line
+ * @return
+ */
+static bool line_next_y(line_draw_t * line)
+{
+    lv_coord_t last_y = line->p_act.y;
+
+    do {
+        if(!line_next(line)) return false;
+    } while(last_y == line->p_act.y);
+
+    return true;
+}
+
+/**
+ * Iterate until step one in x direction.
+ * @param line
+ * @return
+ */
+static bool line_next_x(line_draw_t * line)
+{
+    lv_coord_t last_x = line->p_act.x;
+
+    do {
+        if(!line_next(line)) return false;
+    } while(last_x == line->p_act.x);
+
+    return true;
+}

extended-setup/components/lvgl/src/lv_draw/lv_draw_line.h

@@ -0,0 +1,48 @@
+/**
+ * @file lv_draw_line.h
+ *
+ */
+
+#ifndef LV_DRAW_LINE_H
+#define LV_DRAW_LINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Draw a line
+ * @param point1 first point of the line
+ * @param point2 second point of the line
+ * @param mask the line will be drawn only on this area
+ * @param style pointer to a line's style
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_line(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * mask,
+                  const lv_style_t * style, lv_opa_t opa_scale);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_LINE_H*/

extended-setup/components/lvgl/src/lv_draw/lv_draw_rect.h

@@ -0,0 +1,47 @@
+/**
+ * @file lv_draw_rect.h
+ *
+ */
+
+#ifndef LV_DRAW_RECT_H
+#define LV_DRAW_RECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Draw a rectangle
+ * @param coords the coordinates of the rectangle
+ * @param mask the rectangle will be drawn only in this mask
+ * @param style pointer to a style
+ * @param opa_scale scale down all opacities by the factor
+ */
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_RECT_H*/

extended-setup/components/lvgl/src/lv_draw/lv_draw_triangle.c

@@ -0,0 +1,344 @@
+/**
+ * @file lv_draw_triangle.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_triangle.h"
+#include "../lv_misc/lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+void tri_draw_flat(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa);
+void tri_draw_tall(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa);
+static void point_swap(lv_point_t * p1, lv_point_t * p2);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ *
+ * @param points pointer to an array with 3 points
+ * @param mask the triangle will be drawn only in this mask
+ * @param style style for of the triangle
+ * @param opa_scale scale down all opacities by the factor (0..255)
+ */
+void lv_draw_triangle(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale)
+{
+
+    /*Return is the triangle is degenerated*/
+    if(points[0].x == points[1].x && points[0].y == points[1].y) return;
+    if(points[1].x == points[2].x && points[1].y == points[2].y) return;
+    if(points[0].x == points[2].x && points[0].y == points[2].y) return;
+
+    if(points[0].x == points[1].x && points[1].x == points[2].x) return;
+    if(points[0].y == points[1].y && points[1].y == points[2].y) return;
+
+    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->body.opa : (uint16_t)((uint16_t)style->body.opa * opa_scale) >> 8;
+
+    /*Is the triangle flat or tall?*/
+    lv_coord_t x_min = LV_MATH_MIN(LV_MATH_MIN(points[0].x, points[1].x), points[2].x);
+    lv_coord_t x_max = LV_MATH_MAX(LV_MATH_MAX(points[0].x, points[1].x), points[2].x);
+    lv_coord_t y_min = LV_MATH_MIN(LV_MATH_MIN(points[0].y, points[1].y), points[2].y);
+    lv_coord_t y_max = LV_MATH_MAX(LV_MATH_MAX(points[0].y, points[1].y), points[2].y);
+
+    /* Draw the tall rectangles from vertical lines
+     * and from the flat triangles from horizontal lines
+     * to minimize the number of lines.
+     * Some pixels are overdrawn on the common edges of the triangles
+     * so use it only if the triangle has no opacity*/
+
+    /* Draw from horizontal lines*/
+    if(x_max - x_min < y_max - y_min) {
+        tri_draw_tall(points, mask, style, opa);
+    }
+    /*Else flat so draw from vertical lines*/
+    else {
+        tri_draw_flat(points, mask, style, opa);
+    }
+}
+
+/**
+ * Draw a polygon from triangles. Only convex polygons are supported
+ * @param points an array of points
+ * @param point_cnt number of points
+ * @param mask polygon will be drawn only in this mask
+ * @param style style of the polygon
+ * @param opa_scale scale down all opacities by the factor (0..255)
+ */
+void lv_draw_polygon(const lv_point_t * points, uint32_t point_cnt, const lv_area_t * mask, const lv_style_t * style,
+                     lv_opa_t opa_scale)
+{
+    if(point_cnt < 3) return;
+    if(points == NULL) return;
+
+    uint32_t i;
+    lv_point_t tri[3];
+    tri[0].x = points[0].x;
+    tri[0].y = points[0].y;
+    for(i = 0; i < point_cnt - 1; i++) {
+        tri[1].x = points[i].x;
+        tri[1].y = points[i].y;
+        tri[2].x = points[i + 1].x;
+        tri[2].y = points[i + 1].y;
+        lv_draw_triangle(tri, mask, style, opa_scale);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+void tri_draw_flat(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa)
+{
+    /*Return if the points are out of the mask*/
+    if(points[0].x < mask->x1 && points[1].x < mask->x1 && points[2].x < mask->x1) {
+        return;
+    }
+
+    if(points[0].x > mask->x2 && points[1].x > mask->x2 && points[2].x > mask->x2) {
+        return;
+    }
+
+    if(points[0].y < mask->y1 && points[1].y < mask->y1 && points[2].y < mask->y1) {
+        return;
+    }
+
+    if(points[0].y > mask->y2 && points[1].y > mask->y2 && points[2].y > mask->y2) {
+        return;
+    }
+
+    lv_point_t tri[3];
+
+    memcpy(tri, points, sizeof(tri));
+
+    /*Sort the vertices according to their y coordinate (0: y max, 1: y mid, 2:y min)*/
+    if(tri[1].y < tri[0].y) point_swap(&tri[1], &tri[0]);
+    if(tri[2].y < tri[1].y) point_swap(&tri[2], &tri[1]);
+    if(tri[1].y < tri[0].y) point_swap(&tri[1], &tri[0]);
+
+    /*Draw the triangle*/
+    lv_point_t edge1;
+    lv_coord_t dx1  = LV_MATH_ABS(tri[0].x - tri[1].x);
+    lv_coord_t sx1  = tri[0].x < tri[1].x ? 1 : -1;
+    lv_coord_t dy1  = LV_MATH_ABS(tri[0].y - tri[1].y);
+    lv_coord_t sy1  = tri[0].y < tri[1].y ? 1 : -1;
+    lv_coord_t err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
+    lv_coord_t err_tmp1;
+
+    lv_point_t edge2;
+    lv_coord_t dx2  = LV_MATH_ABS(tri[0].x - tri[2].x);
+    lv_coord_t sx2  = tri[0].x < tri[2].x ? 1 : -1;
+    lv_coord_t dy2  = LV_MATH_ABS(tri[0].y - tri[2].y);
+    lv_coord_t sy2  = tri[0].y < tri[2].y ? 1 : -1;
+    lv_coord_t err2 = (dx1 > dy2 ? dx2 : -dy2) / 2;
+    lv_coord_t err_tmp2;
+
+    lv_coord_t y1_tmp;
+    lv_coord_t y2_tmp;
+
+    edge1.x = tri[0].x;
+    edge1.y = tri[0].y;
+    edge2.x = tri[0].x;
+    edge2.y = tri[0].y;
+    lv_area_t act_area;
+    lv_area_t draw_area;
+
+    while(1) {
+        act_area.x1 = edge1.x;
+        act_area.x2 = edge2.x;
+        act_area.y1 = edge1.y;
+        act_area.y2 = edge2.y;
+
+        /* Get the area of a line.
+         * Adjust it a little bit to perfectly match (no redrawn pixels) with the adjacent triangles*/
+        draw_area.x1 = LV_MATH_MIN(act_area.x1, act_area.x2) + 1;
+        draw_area.x2 = LV_MATH_MAX(act_area.x1, act_area.x2);
+        draw_area.y1 = LV_MATH_MIN(act_area.y1, act_area.y2) - 1;
+        draw_area.y2 = LV_MATH_MAX(act_area.y1, act_area.y2) - 1;
+
+        lv_draw_fill(&draw_area, mask, style->body.main_color, opa);
+
+        /*Calc. the next point of edge1*/
+        y1_tmp = edge1.y;
+        do {
+            if(edge1.x == tri[1].x && edge1.y == tri[1].y) {
+
+                dx1  = LV_MATH_ABS(tri[1].x - tri[2].x);
+                sx1  = tri[1].x < tri[2].x ? 1 : -1;
+                dy1  = LV_MATH_ABS(tri[1].y - tri[2].y);
+                sy1  = tri[1].y < tri[2].y ? 1 : -1;
+                err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
+            } else if(edge1.x == tri[2].x && edge1.y == tri[2].y) {
+                return;
+            }
+            err_tmp1 = err1;
+            if(err_tmp1 > -dx1) {
+                err1 -= dy1;
+                edge1.x += sx1;
+            }
+            if(err_tmp1 < dy1) {
+                err1 += dx1;
+                edge1.y += sy1;
+            }
+        } while(edge1.y == y1_tmp);
+
+        /*Calc. the next point of edge2*/
+        y2_tmp = edge2.y;
+        do {
+            if(edge2.x == tri[2].x && edge2.y == tri[2].y) return;
+            err_tmp2 = err2;
+            if(err_tmp2 > -dx2) {
+                err2 -= dy2;
+                edge2.x += sx2;
+            }
+            if(err_tmp2 < dy2) {
+                err2 += dx2;
+                edge2.y += sy2;
+            }
+        } while(edge2.y == y2_tmp);
+    }
+}
+
+void tri_draw_tall(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa)
+{
+    /*
+     * Better to draw from vertical lines
+     * |\
+     * | |
+     * | |
+     * |  \
+     * |   |
+     * |___|
+     */
+
+    lv_point_t tri[3];
+
+    memcpy(tri, points, sizeof(tri));
+
+    /*Sort the vertices according to their x coordinate (0: x max, 1: x mid, 2:x min)*/
+    if(tri[1].x < tri[0].x) point_swap(&tri[1], &tri[0]);
+    if(tri[2].x < tri[1].x) point_swap(&tri[2], &tri[1]);
+    if(tri[1].x < tri[0].x) point_swap(&tri[1], &tri[0]);
+
+    /*Draw the triangle*/
+    lv_point_t edge1;
+    lv_coord_t dx1  = LV_MATH_ABS(tri[0].x - tri[1].x);
+    lv_coord_t sx1  = tri[0].x < tri[1].x ? 1 : -1;
+    lv_coord_t dy1  = LV_MATH_ABS(tri[0].y - tri[1].y);
+    lv_coord_t sy1  = tri[0].y < tri[1].y ? 1 : -1;
+    lv_coord_t err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
+    lv_coord_t err_tmp1;
+
+    lv_point_t edge2;
+    lv_coord_t dx2  = LV_MATH_ABS(tri[0].x - tri[2].x);
+    lv_coord_t sx2  = tri[0].x < tri[2].x ? 1 : -1;
+    lv_coord_t dy2  = LV_MATH_ABS(tri[0].y - tri[2].y);
+    lv_coord_t sy2  = tri[0].y < tri[2].y ? 1 : -1;
+    lv_coord_t err2 = (dx1 > dy2 ? dx2 : -dy2) / 2;
+    lv_coord_t err_tmp2;
+
+    lv_coord_t x1_tmp;
+    lv_coord_t x2_tmp;
+
+    edge1.x = tri[0].x;
+    edge1.y = tri[0].y;
+    edge2.x = tri[0].x;
+    edge2.y = tri[0].y;
+    lv_area_t act_area;
+    lv_area_t draw_area;
+
+    while(1) {
+        act_area.x1 = edge1.x;
+        act_area.x2 = edge2.x;
+        act_area.y1 = edge1.y;
+        act_area.y2 = edge2.y;
+
+        draw_area.x1 = LV_MATH_MIN(act_area.x1, act_area.x2);
+        draw_area.x2 = LV_MATH_MAX(act_area.x1, act_area.x2);
+        draw_area.y1 = LV_MATH_MIN(act_area.y1, act_area.y2);
+        draw_area.y2 = LV_MATH_MAX(act_area.y1, act_area.y2) - 1;
+
+        lv_draw_fill(&draw_area, mask, style->body.main_color, opa);
+
+        /*Calc. the next point of edge1*/
+        x1_tmp = edge1.x;
+        do {
+            if(edge1.y == tri[1].y && edge1.x == tri[1].x) {
+
+                dx1  = LV_MATH_ABS(tri[1].x - tri[2].x);
+                sx1  = tri[1].x < tri[2].x ? 1 : -1;
+                dy1  = LV_MATH_ABS(tri[1].y - tri[2].y);
+                sy1  = tri[1].y < tri[2].y ? 1 : -1;
+                err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
+            } else if(edge1.y == tri[2].y && edge1.x == tri[2].x) {
+                return;
+            }
+            err_tmp1 = err1;
+            if(err_tmp1 > -dx1) {
+                err1 -= dy1;
+                edge1.x += sx1;
+            }
+            if(err_tmp1 < dy1) {
+                err1 += dx1;
+                edge1.y += sy1;
+            }
+        } while(edge1.x == x1_tmp);
+
+        /*Calc. the next point of edge2*/
+        x2_tmp = edge2.x;
+        do {
+            if(edge2.y == tri[2].y && edge2.x == tri[2].x) {
+                return;
+            }
+
+            err_tmp2 = err2;
+            if(err_tmp2 > -dx2) {
+                err2 -= dy2;
+                edge2.x += sx2;
+            }
+            if(err_tmp2 < dy2) {
+                err2 += dx2;
+                edge2.y += sy2;
+            }
+        } while(edge2.x == x2_tmp);
+    }
+}
+
+/**
+ * Swap two points
+ * p1 pointer to the first point
+ * p2 pointer to the second point
+ */
+static void point_swap(lv_point_t * p1, lv_point_t * p2)
+{
+    lv_point_t tmp;
+    tmp.x = p1->x;
+    tmp.y = p1->y;
+
+    p1->x = p2->x;
+    p1->y = p2->y;
+
+    p2->x = tmp.x;
+    p2->y = tmp.y;
+}

extended-setup/components/lvgl/src/lv_draw/lv_draw_triangle.h

@@ -0,0 +1,58 @@
+/**
+ * @file lv_draw_triangle.h
+ *
+ */
+
+#ifndef LV_DRAW_TRIANGLE_H
+#define LV_DRAW_TRIANGLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ *
+ * @param points pointer to an array with 3 points
+ * @param mask the triangle will be drawn only in this mask
+ * @param style style for of the triangle
+ * @param opa_scale scale down all opacities by the factor (0..255)
+ */
+void lv_draw_triangle(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale);
+
+/**
+ * Draw a polygon from triangles. Only convex polygons are supported
+ * @param points an array of points
+ * @param point_cnt number of points
+ * @param mask polygon will be drawn only in this mask
+ * @param style style of the polygon
+ * @param opa_scale scale down all opacities by the factor (0..255)
+ */
+void lv_draw_polygon(const lv_point_t * points, uint32_t point_cnt, const lv_area_t * mask, const lv_style_t * style,
+                     lv_opa_t opa_scale);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_TRIANGLE_H*/

extended-setup/components/lvgl/src/lv_draw/lv_img_cache.c

@@ -0,0 +1,195 @@
+/**
+ * @file lv_img_cache.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_img_cache.h"
+#include "../lv_hal/lv_hal_tick.h"
+#include "../lv_misc/lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+/*********************
+ *      DEFINES
+ *********************/
+/*Decrement life with this value in every open*/
+#define LV_IMG_CACHE_AGING 1
+
+/*Boost life by this factor (multiply time_to_open with this value)*/
+#define LV_IMG_CACHE_LIFE_GAIN 1
+
+/*Don't let life to be greater than this limit because it would require a lot of time to
+ * "die" from very high values */
+#define LV_IMG_CACHE_LIFE_LIMIT 1000
+
+#if LV_IMG_CACHE_DEF_SIZE < 1
+#error "LV_IMG_CACHE_DEF_SIZE must be >= 1. See lv_conf.h"
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static uint16_t entry_cnt;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Open an image using the image decoder interface and cache it.
+ * The image will be left open meaning if the image decoder open callback allocated memory then it will remain.
+ * The image is closed if a new image is opened and the new image takes its place in the cache.
+ * @param src source of the image. Path to file or pointer to an `lv_img_dsc_t` variable
+ * @param style style of the image
+ * @return pointer to the cache entry or NULL if can open the image
+ */
+lv_img_cache_entry_t * lv_img_cache_open(const void * src, const lv_style_t * style)
+{
+    if(entry_cnt == 0) {
+        LV_LOG_WARN("lv_img_cache_open: the cache size is 0");
+        return NULL;
+    }
+
+    lv_img_cache_entry_t * cache = LV_GC_ROOT(_lv_img_cache_array);
+
+    /*Decrement all lifes. Make the entries older*/
+    uint16_t i;
+    for(i = 0; i < entry_cnt; i++) {
+        if(cache[i].life > INT32_MIN + LV_IMG_CACHE_AGING) {
+            cache[i].life -= LV_IMG_CACHE_AGING;
+        }
+    }
+
+    /*Is the image cached?*/
+    lv_img_cache_entry_t * cached_src = NULL;
+    for(i = 0; i < entry_cnt; i++) {
+        if(cache[i].dec_dsc.src == src) {
+            /* If opened increment its life.
+             * Image difficult to open should live longer to keep avoid frequent their recaching.
+             * Therefore increase `life` with `time_to_open`*/
+            cached_src = &cache[i];
+            cached_src->life += cached_src->dec_dsc.time_to_open * LV_IMG_CACHE_LIFE_GAIN;
+            if(cached_src->life > LV_IMG_CACHE_LIFE_LIMIT) cached_src->life = LV_IMG_CACHE_LIFE_LIMIT;
+            LV_LOG_TRACE("image draw: image found in the cache");
+            break;
+        }
+    }
+
+    /*The image is not cached then cache it now*/
+    if(cached_src == NULL) {
+        /*Find an entry to reuse. Select the entry with the least life*/
+        cached_src = &cache[0];
+        for(i = 1; i < entry_cnt; i++) {
+            if(cache[i].life < cached_src->life) {
+                cached_src = &cache[i];
+            }
+        }
+
+        /*Close the decoder to reuse if it was opened (has a valid source)*/
+        if(cached_src->dec_dsc.src) {
+            lv_img_decoder_close(&cached_src->dec_dsc);
+            LV_LOG_INFO("image draw: cache miss, close and reuse an entry");
+        } else {
+            LV_LOG_INFO("image draw: cache miss, cached to an empty entry");
+        }
+
+        /*Open the image and measure the time to open*/
+        uint32_t t_start;
+        t_start                          = lv_tick_get();
+        cached_src->dec_dsc.time_to_open = 0;
+        lv_res_t open_res                = lv_img_decoder_open(&cached_src->dec_dsc, src, style);
+        if(open_res == LV_RES_INV) {
+            LV_LOG_WARN("Image draw cannot open the image resource");
+            lv_img_decoder_close(&cached_src->dec_dsc);
+            memset(&cached_src->dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
+            memset(cached_src, 0, sizeof(lv_img_cache_entry_t));
+            cached_src->life = INT32_MIN; /*Make the empty entry very "weak" to force its use  */
+            return NULL;
+        }
+
+        cached_src->life = 0;
+
+        /*If `time_to_open` was not set in the open function set it here*/
+        if(cached_src->dec_dsc.time_to_open == 0) {
+            cached_src->dec_dsc.time_to_open = lv_tick_elaps(t_start);
+        }
+
+        if(cached_src->dec_dsc.time_to_open == 0) cached_src->dec_dsc.time_to_open = 1;
+    }
+
+    return cached_src;
+}
+
+/**
+ * Set the number of images to be cached.
+ * More cached images mean more opened image at same time which might mean more memory usage.
+ * E.g. if 20 PNG or JPG images are open in the RAM they consume memory while opened in the cache.
+ * @param new_entry_cnt number of image to cache
+ */
+void lv_img_cache_set_size(uint16_t new_entry_cnt)
+{
+    if(LV_GC_ROOT(_lv_img_cache_array) != NULL) {
+        /*Clean the cache before free it*/
+        lv_img_cache_invalidate_src(NULL);
+        lv_mem_free(LV_GC_ROOT(_lv_img_cache_array));
+    }
+
+    /*Reallocate the cache*/
+    LV_GC_ROOT(_lv_img_cache_array) = lv_mem_alloc(sizeof(lv_img_cache_entry_t) * new_entry_cnt);
+    lv_mem_assert(LV_GC_ROOT(_lv_img_cache_array));
+    if(LV_GC_ROOT(_lv_img_cache_array) == NULL) {
+        entry_cnt = 0;
+        return;
+    }
+    entry_cnt = new_entry_cnt;
+
+    /*Clean the cache*/
+    uint16_t i;
+    for(i = 0; i < entry_cnt; i++) {
+        memset(&LV_GC_ROOT(_lv_img_cache_array)[i].dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
+        memset(&LV_GC_ROOT(_lv_img_cache_array)[i], 0, sizeof(lv_img_cache_entry_t));
+    }
+}
+
+/**
+ * Invalidate an image source in the cache.
+ * Useful if the image source is updated therefore it needs to be cached again.
+ * @param src an image source path to a file or pointer to an `lv_img_dsc_t` variable.
+ */
+void lv_img_cache_invalidate_src(const void * src)
+{
+
+    lv_img_cache_entry_t * cache = LV_GC_ROOT(_lv_img_cache_array);
+
+    uint16_t i;
+    for(i = 0; i < entry_cnt; i++) {
+        if(cache[i].dec_dsc.src == src || src == NULL) {
+            if(cache[i].dec_dsc.src != NULL) {
+                lv_img_decoder_close(&cache[i].dec_dsc);
+            }
+
+            memset(&cache[i].dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
+            memset(&cache[i], 0, sizeof(lv_img_cache_entry_t));
+        }
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/

extended-setup/components/lvgl/src/lv_draw/lv_img_cache.h

@@ -0,0 +1,78 @@
+/**
+ * @file lv_img_cache.h
+ *
+ */
+
+#ifndef LV_IMG_CACHE_H
+#define LV_IMG_CACHE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_img_decoder.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * When loading images from the network it can take a long time to download and decode the image.
+ * 
+ * To avoid repeating this heavy load images can be cached.
+ */
+typedef struct
+{
+    lv_img_decoder_dsc_t dec_dsc; /**< Image information */
+
+    /** Count the cache entries's life. Add `time_tio_open` to `life` when the entry is used.
+     * Decrement all lifes by one every in every ::lv_img_cache_open.
+     * If life == 0 the entry can be reused */
+    int32_t life;
+} lv_img_cache_entry_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Open an image using the image decoder interface and cache it.
+ * The image will be left open meaning if the image decoder open callback allocated memory then it will remain.
+ * The image is closed if a new image is opened and the new image takes its place in the cache.
+ * @param src source of the image. Path to file or pointer to an `lv_img_dsc_t` variable
+ * @param style style of the image
+ * @return pointer to the cache entry or NULL if can open the image
+ */
+lv_img_cache_entry_t * lv_img_cache_open(const void * src, const lv_style_t * style);
+
+/**
+ * Set the number of images to be cached.
+ * More cached images mean more opened image at same time which might mean more memory usage.
+ * E.g. if 20 PNG or JPG images are open in the RAM they consume memory while opened in the cache.
+ * @param new_entry_cnt number of image to cache
+ */
+void lv_img_cache_set_size(uint16_t new_slot_num);
+
+/**
+ * Invalidate an image source in the cache.
+ * Useful if the image source is updated therefore it needs to be cached again.
+ * @param src an image source path to a file or pointer to an `lv_img_dsc_t` variable.
+ */
+void lv_img_cache_invalidate_src(const void * src);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_IMG_CACHE_H*/

extended-setup/components/lvgl/src/lv_draw/lv_img_decoder.c

@@ -0,0 +1,723 @@
+/**
+ * @file lv_img_decoder.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_img_decoder.h"
+#include "../lv_draw/lv_draw_img.h"
+#include "../lv_misc/lv_ll.h"
+#include "../lv_misc/lv_color.h"
+#include "../lv_misc/lv_gc.h"
+
+#if defined(LV_GC_INCLUDE)
+#include LV_GC_INCLUDE
+#endif /* LV_ENABLE_GC */
+
+/*********************
+ *      DEFINES
+ *********************/
+#define CF_BUILT_IN_FIRST LV_IMG_CF_TRUE_COLOR
+#define CF_BUILT_IN_LAST LV_IMG_CF_ALPHA_8BIT
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct
+{
+#if LV_USE_FILESYSTEM
+    lv_fs_file_t * f;
+#endif
+    lv_color_t * palette;
+} lv_img_decoder_built_in_data_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
+                                                        lv_coord_t len, uint8_t * buf);
+static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
+                                                   lv_coord_t len, uint8_t * buf);
+static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
+                                                     lv_coord_t len, uint8_t * buf);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Initialize the image decoder module
+ * */
+void lv_img_decoder_init(void)
+{
+    lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t));
+
+    lv_img_decoder_t * decoder;
+
+    /*Create a decoder for the built in color format*/
+    decoder = lv_img_decoder_create();
+    if(decoder == NULL) {
+        LV_LOG_WARN("lv_img_decoder_init: out of memory");
+        lv_mem_assert(decoder);
+        return;
+    }
+
+    lv_img_decoder_set_info_cb(decoder, lv_img_decoder_built_in_info);
+    lv_img_decoder_set_open_cb(decoder, lv_img_decoder_built_in_open);
+    lv_img_decoder_set_read_line_cb(decoder, lv_img_decoder_built_in_read_line);
+    lv_img_decoder_set_close_cb(decoder, lv_img_decoder_built_in_close);
+}
+
+/**
+ * Get information about an image.
+ * Try the created image decoder one by one. Once one is able to get info that info will be used.
+ * @param src the image source. E.g. file name or variable.
+ * @param header the image info will be stored here
+ * @return LV_RES_OK: success; LV_RES_INV: wasn't able to get info about the image
+ */
+lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
+{
+    header->always_zero = 0;
+
+    lv_res_t res = LV_RES_INV;
+    lv_img_decoder_t * d;
+    LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d)
+    {
+        res = LV_RES_INV;
+        if(d->info_cb) {
+            res = d->info_cb(d, src, header);
+            if(res == LV_RES_OK) break;
+        }
+    }
+
+    return res;
+}
+
+/**
+ * Open an image.
+ * Try the created image decoder one by one. Once one is able to open the image that decoder is save in `dsc`
+ * @param dsc describe a decoding session. Simply a pointer to an `lv_img_decoder_dsc_t` variable.
+ * @param src the image source. Can be
+ *  1) File name: E.g. "S:folder/img1.png" (The drivers needs to registered via `lv_fs_add_drv()`)
+ *  2) Variable: Pointer to an `lv_img_dsc_t` variable
+ *  3) Symbol: E.g. `LV_SYMBOL_OK`
+ * @param style the style of the image
+ * @return LV_RES_OK: opened the image. `dsc->img_data` and `dsc->header` are set.
+ *         LV_RES_INV: none of the registered image decoders were able to open the image.
+ */
+lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style)
+{
+    dsc->style     = style;
+    dsc->src       = src;
+    dsc->src_type  = lv_img_src_get_type(src);
+    dsc->user_data = NULL;
+
+    lv_res_t res = LV_RES_INV;
+
+    lv_img_decoder_t * d;
+    LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d)
+    {
+        /*Info an Open callbacks are required*/
+        if(d->info_cb == NULL || d->open_cb == NULL) continue;
+
+        res = d->info_cb(d, src, &dsc->header);
+        if(res != LV_RES_OK) continue;
+
+        dsc->error_msg = NULL;
+        dsc->img_data  = NULL;
+        dsc->decoder   = d;
+
+        res = d->open_cb(d, dsc);
+
+        /*Opened successfully. It is a good decoder to for this image source*/
+        if(res == LV_RES_OK) break;
+    }
+
+    if(res == LV_RES_INV) {
+        memset(dsc, 0, sizeof(lv_img_decoder_dsc_t));
+    }
+
+    return res;
+}
+
+/**
+ * Read a line from an opened image
+ * @param dsc pointer to `lv_img_decoder_dsc_t` used in `lv_img_decoder_open`
+ * @param x start X coordinate (from left)
+ * @param y start Y coordinate (from top)
+ * @param len number of pixels to read
+ * @param buf store the data here
+ * @return LV_RES_OK: success; LV_RES_INV: an error occurred
+ */
+lv_res_t lv_img_decoder_read_line(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf)
+{
+    lv_res_t res = LV_RES_INV;
+    if(dsc->decoder->read_line_cb) res = dsc->decoder->read_line_cb(dsc->decoder, dsc, x, y, len, buf);
+
+    return res;
+}
+
+/**
+ * Close a decoding session
+ * @param dsc pointer to `lv_img_decoder_dsc_t` used in `lv_img_decoder_open`
+ */
+void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc)
+{
+    if(dsc->decoder) {
+        if(dsc->decoder->close_cb) dsc->decoder->close_cb(dsc->decoder, dsc);
+    }
+}
+
+/**
+ * Create a new image decoder
+ * @return pointer to the new image decoder
+ */
+lv_img_decoder_t * lv_img_decoder_create(void)
+{
+    lv_img_decoder_t * decoder;
+    decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
+    lv_mem_assert(decoder);
+    if(decoder == NULL) return NULL;
+
+    memset(decoder, 0, sizeof(lv_img_decoder_t));
+
+    return decoder;
+}
+
+/**
+ * Delete an image decoder
+ * @param decoder pointer to an image decoder
+ */
+void lv_img_decoder_delete(lv_img_decoder_t * decoder)
+{
+    lv_ll_rem(&LV_GC_ROOT(_lv_img_defoder_ll), decoder);
+    lv_mem_free(decoder);
+}
+
+/**
+ * Set a callback to get information about the image
+ * @param decoder pointer to an image decoder
+ * @param info_cb a function to collect info about an image (fill an `lv_img_header_t` struct)
+ */
+void lv_img_decoder_set_info_cb(lv_img_decoder_t * decoder, lv_img_decoder_info_f_t info_cb)
+{
+    decoder->info_cb = info_cb;
+}
+
+/**
+ * Set a callback to open an image
+ * @param decoder pointer to an image decoder
+ * @param open_cb a function to open an image
+ */
+void lv_img_decoder_set_open_cb(lv_img_decoder_t * decoder, lv_img_decoder_open_f_t open_cb)
+{
+    decoder->open_cb = open_cb;
+}
+
+/**
+ * Set a callback to a decoded line of an image
+ * @param decoder pointer to an image decoder
+ * @param read_line_cb a function to read a line of an image
+ */
+void lv_img_decoder_set_read_line_cb(lv_img_decoder_t * decoder, lv_img_decoder_read_line_f_t read_line_cb)
+{
+    decoder->read_line_cb = read_line_cb;
+}
+
+/**
+ * Set a callback to close a decoding session. E.g. close files and free other resources.
+ * @param decoder pointer to an image decoder
+ * @param close_cb a function to close a decoding session
+ */
+void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_close_f_t close_cb)
+{
+    decoder->close_cb = close_cb;
+}
+
+/**
+ * Get info about a built-in image
+ * @param decoder the decoder where this function belongs
+ * @param src the image source: pointer to an `lv_img_dsc_t` variable, a file path or a symbol
+ * @param header store the image data here
+ * @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
+ */
+lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)
+{
+    (void)decoder; /*Unused*/
+
+    lv_img_src_t src_type = lv_img_src_get_type(src);
+    if(src_type == LV_IMG_SRC_VARIABLE) {
+        lv_img_cf_t cf = ((lv_img_dsc_t *)src)->header.cf;
+        if(cf < CF_BUILT_IN_FIRST || cf > CF_BUILT_IN_LAST) return LV_RES_INV;
+
+        header->w  = ((lv_img_dsc_t *)src)->header.w;
+        header->h  = ((lv_img_dsc_t *)src)->header.h;
+        header->cf = ((lv_img_dsc_t *)src)->header.cf;
+    }
+#if LV_USE_FILESYSTEM
+    else if(src_type == LV_IMG_SRC_FILE) {
+        lv_fs_file_t file;
+        lv_fs_res_t res;
+        uint32_t rn;
+        res = lv_fs_open(&file, src, LV_FS_MODE_RD);
+        if(res == LV_FS_RES_OK) {
+            res = lv_fs_read(&file, header, sizeof(lv_img_header_t), &rn);
+            lv_fs_close(&file);
+        }
+
+        lv_img_cf_t cf = ((lv_img_dsc_t *)src)->header.cf;
+        if(cf < CF_BUILT_IN_FIRST || cf > CF_BUILT_IN_LAST) return LV_RES_INV;
+
+    }
+#endif
+    else if(src_type == LV_IMG_SRC_SYMBOL) {
+        /*The size depend on the font but it is unknown here. It should be handled outside of the
+         * function*/
+        header->w = 1;
+        header->h = 1;
+        /* Symbols always have transparent parts. Important because of cover check in the design
+         * function. The actual value doesn't matter because lv_draw_label will draw it*/
+        header->cf = LV_IMG_CF_ALPHA_1BIT;
+    } else {
+        LV_LOG_WARN("Image get info found unknown src type");
+        return LV_RES_INV;
+    }
+    return LV_RES_OK;
+}
+
+/**
+ * Open a built in image
+ * @param decoder the decoder where this function belongs
+ * @param dsc pointer to decoder descriptor. `src`, `style` are already initialized in it.
+ * @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
+ */
+lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
+{
+    /*Open the file if it's a file*/
+    if(dsc->src_type == LV_IMG_SRC_FILE) {
+#if LV_USE_FILESYSTEM
+
+        /*Support only "*.bin" files*/
+        if(strcmp(lv_fs_get_ext(dsc->src), "bin")) return LV_RES_INV;
+
+        lv_fs_file_t f;
+        lv_fs_res_t res = lv_fs_open(&f, dsc->src, LV_FS_MODE_RD);
+        if(res != LV_FS_RES_OK) {
+            LV_LOG_WARN("Built-in image decoder can't open the file");
+            return LV_RES_INV;
+        }
+
+        /*If the file was open successfully save the file descriptor*/
+        if(dsc->user_data == NULL) {
+            dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t));
+            if(dsc->user_data == NULL) {
+                LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
+                lv_mem_assert(dsc->user_data);
+            }
+            memset(dsc->user_data, 0, sizeof(lv_img_decoder_built_in_data_t));
+        }
+
+        lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
+        user_data->f                               = lv_mem_alloc(sizeof(f));
+        if(user_data->f == NULL) {
+            LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
+            lv_mem_assert(user_data->f);
+        }
+
+        memcpy(user_data->f, &f, sizeof(f));
+
+#else
+        LV_LOG_WARN("Image built-in decoder cannot read file because LV_USE_FILESYSTEM = 0");
+        return LV_RES_INV;
+#endif
+    }
+
+    lv_img_cf_t cf = dsc->header.cf;
+    /*Process true color formats*/
+    if(cf == LV_IMG_CF_TRUE_COLOR || cf == LV_IMG_CF_TRUE_COLOR_ALPHA || cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
+        if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
+            /* In case of uncompressed formats the image stored in the ROM/RAM.
+             * So simply give its pointer*/
+            dsc->img_data = ((lv_img_dsc_t *)dsc->src)->data;
+            return LV_RES_OK;
+        } else {
+            /*If it's a file it need to be read line by line later*/
+            dsc->img_data = NULL;
+            return LV_RES_OK;
+        }
+    }
+    /*Process indexed images. Build a palette*/
+    else if(cf == LV_IMG_CF_INDEXED_1BIT || cf == LV_IMG_CF_INDEXED_2BIT || cf == LV_IMG_CF_INDEXED_4BIT ||
+            cf == LV_IMG_CF_INDEXED_8BIT) {
+
+#if LV_IMG_CF_INDEXED
+        uint8_t px_size       = lv_img_color_format_get_px_size(cf);
+        uint32_t palette_size = 1 << px_size;
+
+        /*Allocate the palette*/
+        if(dsc->user_data == NULL) {
+            dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t));
+            if(dsc->user_data == NULL) {
+                LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
+                lv_mem_assert(dsc->user_data);
+            }
+            memset(dsc->user_data, 0, sizeof(lv_img_decoder_built_in_data_t));
+        }
+
+        lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
+        user_data->palette                         = lv_mem_alloc(palette_size * sizeof(lv_color_t));
+        if(user_data->palette == NULL) {
+            LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
+#if LV_USE_FILESYSTEM
+            lv_mem_assert(user_data->f);
+#endif
+        }
+
+        if(dsc->src_type == LV_IMG_SRC_FILE) {
+            /*Read the palette from file*/
+#if LV_USE_FILESYSTEM
+            lv_fs_seek(user_data->f, 4); /*Skip the header*/
+            lv_fs_read(user_data->f, user_data->palette, palette_size * sizeof(lv_color_t), NULL);
+#else
+            LV_LOG_WARN("Image built-in decoder can read the palette because LV_USE_FILESYSTEM = 0");
+            return LV_RES_INV;
+#endif
+        } else {
+            /*The palette begins in the beginning of the image data. Just point to it.*/
+            lv_color32_t * palette_p = (lv_color32_t *)((lv_img_dsc_t *)dsc->src)->data;
+
+            uint32_t i;
+            for(i = 0; i < palette_size; i++) {
+                user_data->palette[i] = lv_color_make(palette_p[i].ch.red, palette_p[i].ch.green, palette_p[i].ch.blue);
+            }
+        }
+
+        dsc->img_data = NULL;
+        return LV_RES_OK;
+#else
+        LV_LOG_WARN("Indexed (palette) images are not enabled in lv_conf.h. See LV_IMG_CF_INDEXED");
+        return LV_RES_INV;
+#endif
+    }
+    /*Alpha indexed images. */
+    else if(cf == LV_IMG_CF_ALPHA_1BIT || cf == LV_IMG_CF_ALPHA_2BIT || cf == LV_IMG_CF_ALPHA_4BIT ||
+            cf == LV_IMG_CF_ALPHA_8BIT) {
+#if LV_IMG_CF_ALPHA
+        dsc->img_data = NULL;
+        return LV_RES_OK; /*Nothing to process*/
+#else
+        LV_LOG_WARN("Alpha indexed images are not enabled in lv_conf.h. See LV_IMG_CF_ALPHA");
+        return LV_RES_INV;
+#endif
+    }
+    /*Unknown format. Can't decode it.*/
+    else {
+        /*Free the potentially allocated memories*/
+        lv_img_decoder_built_in_close(decoder, dsc);
+
+        LV_LOG_WARN("Image decoder open: unknown color format")
+        return LV_RES_INV;
+    }
+}
+
+/**
+ * Decode `len` pixels starting from the given `x`, `y` coordinates and store them in `buf`.
+ * Required only if the "open" function can't return with the whole decoded pixel array.
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor
+ * @param x start x coordinate
+ * @param y start y coordinate
+ * @param len number of pixels to decode
+ * @param buf a buffer to store the decoded pixels
+ * @return LV_RES_OK: ok; LV_RES_INV: failed
+ */
+lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, lv_coord_t x,
+                                                  lv_coord_t y, lv_coord_t len, uint8_t * buf)
+{
+    (void)decoder; /*Unused*/
+
+    lv_res_t res = LV_RES_INV;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA ||
+       dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
+        /* For TRUE_COLOR images read line required only for files.
+         * For variables the image data was returned in `open`*/
+        if(dsc->src_type == LV_IMG_SRC_FILE) {
+            res = lv_img_decoder_built_in_line_true_color(dsc, x, y, len, buf);
+        }
+    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || dsc->header.cf == LV_IMG_CF_ALPHA_2BIT ||
+              dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+
+        res = lv_img_decoder_built_in_line_alpha(dsc, x, y, len, buf);
+    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT || dsc->header.cf == LV_IMG_CF_INDEXED_2BIT ||
+              dsc->header.cf == LV_IMG_CF_INDEXED_4BIT || dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
+        res = lv_img_decoder_built_in_line_indexed(dsc, x, y, len, buf);
+    } else {
+        LV_LOG_WARN("Built-in image decoder read not supports the color format");
+        return LV_RES_INV;
+    }
+
+    return res;
+}
+
+/**
+ * Close the pending decoding. Free resources etc.
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor
+ */
+void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
+{
+    (void)decoder; /*Unused*/
+
+    lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
+    if(user_data) {
+#if LV_USE_FILESYSTEM
+        if(user_data->f) {
+            lv_fs_close(user_data->f);
+            lv_mem_free(user_data->f);
+        }
+#endif
+        if(user_data->palette) lv_mem_free(user_data->palette);
+
+        lv_mem_free(user_data);
+
+        dsc->user_data = NULL;
+    }
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
+                                                        lv_coord_t len, uint8_t * buf)
+{
+#if LV_USE_FILESYSTEM
+    lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
+    lv_fs_res_t res;
+    uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf);
+
+    uint32_t pos = ((y * dsc->header.w + x) * px_size) >> 3;
+    pos += 4; /*Skip the header*/
+    res = lv_fs_seek(user_data->f, pos);
+    if(res != LV_FS_RES_OK) {
+        LV_LOG_WARN("Built-in image decoder seek failed");
+        return LV_RES_INV;
+    }
+    uint32_t btr = len * (px_size >> 3);
+    uint32_t br  = 0;
+    lv_fs_read(user_data->f, buf, btr, &br);
+    if(res != LV_FS_RES_OK || btr != br) {
+        LV_LOG_WARN("Built-in image decoder read failed");
+        return LV_RES_INV;
+    }
+
+    return LV_RES_OK;
+#else
+    LV_LOG_WARN("Image built-in decoder cannot read file because LV_USE_FILESYSTEM = 0");
+    return LV_RES_INV;
+#endif
+}
+
+static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
+                                                   lv_coord_t len, uint8_t * buf)
+{
+
+#if LV_IMG_CF_ALPHA
+    const lv_opa_t alpha1_opa_table[2]  = {0, 255};          /*Opacity mapping with bpp = 1 (Just for compatibility)*/
+    const lv_opa_t alpha2_opa_table[4]  = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
+    const lv_opa_t alpha4_opa_table[16] = {0,  17, 34,  51,  /*Opacity mapping with bpp = 4*/
+                                           68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
+
+    /*Simply fill the buffer with the color. Later only the alpha value will be modified.*/
+    lv_color_t bg_color = dsc->style->image.color;
+    lv_coord_t i;
+    for(i = 0; i < len; i++) {
+#if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
+        buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE] = bg_color.full;
+#elif LV_COLOR_DEPTH == 16
+        /*Because of Alpha byte 16 bit color can start on odd address which can cause crash*/
+        buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE] = bg_color.full & 0xFF;
+        buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE + 1] = (bg_color.full >> 8) & 0xFF;
+#elif LV_COLOR_DEPTH == 32
+        *((uint32_t *)&buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE]) = bg_color.full;
+#else
+#error "Invalid LV_COLOR_DEPTH. Check it in lv_conf.h"
+#endif
+    }
+
+    const lv_opa_t * opa_table = NULL;
+    uint8_t px_size            = lv_img_color_format_get_px_size(dsc->header.cf);
+    uint16_t mask              = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
+
+    lv_coord_t w = 0;
+    uint32_t ofs = 0;
+    int8_t pos   = 0;
+    switch(dsc->header.cf) {
+        case LV_IMG_CF_ALPHA_1BIT:
+            w = (dsc->header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/
+            if(dsc->header.w & 0x7) w++;
+            ofs += w * y + (x >> 3); /*First pixel*/
+            pos       = 7 - (x & 0x7);
+            opa_table = alpha1_opa_table;
+            break;
+        case LV_IMG_CF_ALPHA_2BIT:
+            w = (dsc->header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/
+            if(dsc->header.w & 0x3) w++;
+            ofs += w * y + (x >> 2); /*First pixel*/
+            pos       = 6 - ((x & 0x3) * 2);
+            opa_table = alpha2_opa_table;
+            break;
+        case LV_IMG_CF_ALPHA_4BIT:
+            w = (dsc->header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/
+            if(dsc->header.w & 0x1) w++;
+            ofs += w * y + (x >> 1); /*First pixel*/
+            pos       = 4 - ((x & 0x1) * 4);
+            opa_table = alpha4_opa_table;
+            break;
+        case LV_IMG_CF_ALPHA_8BIT:
+            w = dsc->header.w; /*E.g. x = 7 -> w = 7 (bytes)*/
+            ofs += w * y + x;  /*First pixel*/
+            pos = 0;
+            break;
+    }
+
+#if LV_USE_FILESYSTEM
+    lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
+    uint8_t fs_buf[LV_HOR_RES_MAX];
+#endif
+
+    const uint8_t * data_tmp = NULL;
+    if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
+        const lv_img_dsc_t * img_dsc = dsc->src;
+
+        data_tmp = img_dsc->data + ofs;
+    } else {
+#if LV_USE_FILESYSTEM
+        lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/
+        lv_fs_read(user_data->f, fs_buf, w, NULL);
+        data_tmp = fs_buf;
+#else
+        LV_LOG_WARN("Image built-in alpha line reader can't read file because LV_USE_FILESYSTEM = 0");
+        data_tmp = NULL; /*To avoid warnings*/
+        return LV_RES_INV;
+#endif
+    }
+
+    uint8_t byte_act = 0;
+    uint8_t val_act;
+    for(i = 0; i < len; i++) {
+        val_act = (data_tmp[byte_act] & (mask << pos)) >> pos;
+
+        buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE + LV_IMG_PX_SIZE_ALPHA_BYTE - 1] =
+            dsc->header.cf == LV_IMG_CF_ALPHA_8BIT ? val_act : opa_table[val_act];
+
+        pos -= px_size;
+        if(pos < 0) {
+            pos = 8 - px_size;
+            data_tmp++;
+        }
+    }
+
+    return LV_RES_OK;
+
+#else
+    LV_LOG_WARN("Image built-in alpha line reader failed because LV_IMG_CF_ALPHA is 0 in lv_conf.h");
+    return LV_RES_INV;
+#endif
+}
+
+static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y,
+                                                     lv_coord_t len, uint8_t * buf)
+{
+
+#if LV_IMG_CF_INDEXED
+    uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf);
+    uint16_t mask   = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
+
+    lv_coord_t w = 0;
+    int8_t pos   = 0;
+    uint32_t ofs = 0;
+    switch(dsc->header.cf) {
+        case LV_IMG_CF_INDEXED_1BIT:
+            w = (dsc->header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/
+            if(dsc->header.w & 0x7) w++;
+            ofs += w * y + (x >> 3); /*First pixel*/
+            ofs += 8;                /*Skip the palette*/
+            pos = 7 - (x & 0x7);
+            break;
+        case LV_IMG_CF_INDEXED_2BIT:
+            w = (dsc->header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/
+            if(dsc->header.w & 0x3) w++;
+            ofs += w * y + (x >> 2); /*First pixel*/
+            ofs += 16;               /*Skip the palette*/
+            pos = 6 - ((x & 0x3) * 2);
+            break;
+        case LV_IMG_CF_INDEXED_4BIT:
+            w = (dsc->header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/
+            if(dsc->header.w & 0x1) w++;
+            ofs += w * y + (x >> 1); /*First pixel*/
+            ofs += 64;               /*Skip the palette*/
+            pos = 4 - ((x & 0x1) * 4);
+            break;
+        case LV_IMG_CF_INDEXED_8BIT:
+            w = dsc->header.w; /*E.g. x = 7 -> w = 7 (bytes)*/
+            ofs += w * y + x;  /*First pixel*/
+            ofs += 1024;       /*Skip the palette*/
+            pos = 0;
+            break;
+    }
+
+    lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
+
+#if LV_USE_FILESYSTEM
+    uint8_t fs_buf[LV_HOR_RES_MAX];
+#endif
+    const uint8_t * data_tmp = NULL;
+    if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
+        const lv_img_dsc_t * img_dsc = dsc->src;
+        data_tmp                     = img_dsc->data + ofs;
+    } else {
+#if LV_USE_FILESYSTEM
+        lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/
+        lv_fs_read(user_data->f, fs_buf, w, NULL);
+        data_tmp = fs_buf;
+#else
+        LV_LOG_WARN("Image built-in indexed line reader can't read file because LV_USE_FILESYSTEM = 0");
+        data_tmp = NULL; /*To avoid warnings*/
+        return LV_RES_INV;
+#endif
+    }
+
+    uint8_t byte_act = 0;
+    uint8_t val_act;
+    lv_coord_t i;
+    lv_color_t * cbuf = (lv_color_t *)buf;
+    for(i = 0; i < len; i++) {
+        val_act = (data_tmp[byte_act] & (mask << pos)) >> pos;
+        cbuf[i] = user_data->palette[val_act];
+
+        pos -= px_size;
+        if(pos < 0) {
+            pos = 8 - px_size;
+            data_tmp++;
+        }
+    }
+
+    return LV_RES_OK;
+#else
+    LV_LOG_WARN("Image built-in indexed line reader failed because LV_IMG_CF_INDEXED is 0 in lv_conf.h");
+    return LV_RES_INV;
+#endif
+}

extended-setup/components/lvgl/src/lv_draw/lv_img_decoder.h

@@ -0,0 +1,357 @@
+/**
+ * @file lv_img_decoder.h
+ *
+ */
+
+#ifndef LV_IMG_DEOCER_H
+#define LV_IMG_DEOCER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_CONF_INCLUDE_SIMPLE
+#include "lv_conf.h"
+#else
+#include "../../../lv_conf.h"
+#endif
+
+#include <stdint.h>
+#include "../lv_misc/lv_fs.h"
+#include "../lv_misc/lv_types.h"
+#include "../lv_misc/lv_area.h"
+#include "../lv_core/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+/*If image pixels contains alpha we need to know how much byte is a pixel*/
+#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8
+#define LV_IMG_PX_SIZE_ALPHA_BYTE 2
+#elif LV_COLOR_DEPTH == 16
+#define LV_IMG_PX_SIZE_ALPHA_BYTE 3
+#elif LV_COLOR_DEPTH == 32
+#define LV_IMG_PX_SIZE_ALPHA_BYTE 4
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * Source of image. */
+enum {
+    LV_IMG_SRC_VARIABLE, /** Binary/C variable */
+    LV_IMG_SRC_FILE, /** File in filesystem */
+    LV_IMG_SRC_SYMBOL, /** Symbol (@ref lv_symbol_def.h) */
+    LV_IMG_SRC_UNKNOWN, /** Unknown source */
+};
+
+typedef uint8_t lv_img_src_t;
+/**
+ * LittlevGL image header
+ */
+typedef struct
+{
+
+    /* The first 8 bit is very important to distinguish the different source types.
+     * For more info see `lv_img_get_src_type()` in lv_img.c */
+    uint32_t cf : 5;          /* Color format: See `lv_img_color_format_t`*/
+    uint32_t always_zero : 3; /*It the upper bits of the first byte. Always zero to look like a
+                                 non-printable character*/
+
+    uint32_t reserved : 2; /*Reserved to be used later*/
+
+    uint32_t w : 11; /*Width of the image map*/
+    uint32_t h : 11; /*Height of the image map*/
+} lv_img_header_t;
+
+/*Image color format*/
+enum {
+    LV_IMG_CF_UNKNOWN = 0,
+
+    LV_IMG_CF_RAW,              /**< Contains the file as it is. Needs custom decoder function*/
+    LV_IMG_CF_RAW_ALPHA,        /**< Contains the file as it is. The image has alpha. Needs custom decoder
+                                   function*/
+    LV_IMG_CF_RAW_CHROMA_KEYED, /**< Contains the file as it is. The image is chroma keyed. Needs
+                                   custom decoder function*/
+
+    LV_IMG_CF_TRUE_COLOR,              /**< Color format and depth should match with LV_COLOR settings*/
+    LV_IMG_CF_TRUE_COLOR_ALPHA,        /**< Same as `LV_IMG_CF_TRUE_COLOR` but every pixel has an alpha byte*/
+    LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED, /**< Same as `LV_IMG_CF_TRUE_COLOR` but LV_COLOR_TRANSP pixels
+                                          will be transparent*/
+
+    LV_IMG_CF_INDEXED_1BIT, /**< Can have 2 different colors in a palette (always chroma keyed)*/
+    LV_IMG_CF_INDEXED_2BIT, /**< Can have 4 different colors in a palette (always chroma keyed)*/
+    LV_IMG_CF_INDEXED_4BIT, /**< Can have 16 different colors in a palette (always chroma keyed)*/
+    LV_IMG_CF_INDEXED_8BIT, /**< Can have 256 different colors in a palette (always chroma keyed)*/
+
+    LV_IMG_CF_ALPHA_1BIT, /**< Can have one color and it can be drawn or not*/
+    LV_IMG_CF_ALPHA_2BIT, /**< Can have one color but 4 different alpha value*/
+    LV_IMG_CF_ALPHA_4BIT, /**< Can have one color but 16 different alpha value*/
+    LV_IMG_CF_ALPHA_8BIT, /**< Can have one color but 256 different alpha value*/
+
+    LV_IMG_CF_RESERVED_15,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_16,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_17,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_18,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_19,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_20,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_21,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_22,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_23,              /**< Reserved for further use. */
+
+    LV_IMG_CF_USER_ENCODED_0,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_1,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_2,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_3,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_4,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_5,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_6,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_7,          /**< User holder encoding format. */
+};
+typedef uint8_t lv_img_cf_t;
+
+/** Image header it is compatible with
+ * the result from image converter utility*/
+typedef struct
+{
+    lv_img_header_t header;
+    uint32_t data_size;
+    const uint8_t * data;
+} lv_img_dsc_t;
+
+/* Decoder function definitions */
+
+struct _lv_img_decoder;
+struct _lv_img_decoder_dsc;
+
+/**
+ * Get info from an image and store in the `header`
+ * @param src the image source. Can be a pointer to a C array or a file name (Use
+ * `lv_img_src_get_type` to determine the type)
+ * @param header store the info here
+ * @return LV_RES_OK: info written correctly; LV_RES_INV: failed
+ */
+typedef lv_res_t (*lv_img_decoder_info_f_t)(struct _lv_img_decoder * decoder, const void * src,
+                                            lv_img_header_t * header);
+
+/**
+ * Open an image for decoding. Prepare it as it is required to read it later
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor. `src`, `style` are already initialized in it.
+ */
+typedef lv_res_t (*lv_img_decoder_open_f_t)(struct _lv_img_decoder * decoder, struct _lv_img_decoder_dsc * dsc);
+
+/**
+ * Decode `len` pixels starting from the given `x`, `y` coordinates and store them in `buf`.
+ * Required only if the "open" function can't return with the whole decoded pixel array.
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor
+ * @param x start x coordinate
+ * @param y start y coordinate
+ * @param len number of pixels to decode
+ * @param buf a buffer to store the decoded pixels
+ * @return LV_RES_OK: ok; LV_RES_INV: failed
+ */
+typedef lv_res_t (*lv_img_decoder_read_line_f_t)(struct _lv_img_decoder * decoder, struct _lv_img_decoder_dsc * dsc,
+                                                 lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf);
+
+/**
+ * Close the pending decoding. Free resources etc.
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor
+ */
+typedef void (*lv_img_decoder_close_f_t)(struct _lv_img_decoder * decoder, struct _lv_img_decoder_dsc * dsc);
+
+typedef struct _lv_img_decoder
+{
+    lv_img_decoder_info_f_t info_cb;
+    lv_img_decoder_open_f_t open_cb;
+    lv_img_decoder_read_line_f_t read_line_cb;
+    lv_img_decoder_close_f_t close_cb;
+
+#if LV_USE_USER_DATA
+    lv_img_decoder_user_data_t user_data;
+#endif
+} lv_img_decoder_t;
+
+/**Describe an image decoding session. Stores data about the decoding*/
+typedef struct _lv_img_decoder_dsc
+{
+    /**The decoder which was able to open the image source*/
+    lv_img_decoder_t * decoder;
+
+    /**The image source. A file path like "S:my_img.png" or pointer to an `lv_img_dsc_t` variable*/
+    const void * src;
+
+    /**Style to draw the image.*/
+    const lv_style_t * style;
+
+    /**Type of the source: file or variable. Can be set in `open` function if required*/
+    lv_img_src_t src_type;
+
+    /**Info about the opened image: color format, size, etc. MUST be set in `open` function*/
+    lv_img_header_t header;
+
+    /** Pointer to a buffer where the image's data (pixels) are stored in a decoded, plain format.
+     *  MUST be set in `open` function*/
+    const uint8_t * img_data;
+
+    /** How much time did it take to open the image. [ms]
+     *  If not set `lv_img_cache` will measure and set the time to open*/
+    uint32_t time_to_open;
+
+    /**A text to display instead of the image when the image can't be opened.
+     * Can be set in `open` function or set NULL. */
+    const char * error_msg;
+
+    /**Store any custom data here is required*/
+    void * user_data;
+} lv_img_decoder_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the image decoder module
+ */
+void lv_img_decoder_init(void);
+
+/**
+ * Get information about an image.
+ * Try the created image decoder one by one. Once one is able to get info that info will be used.
+ * @param src the image source. Can be
+ *  1) File name: E.g. "S:folder/img1.png" (The drivers needs to registered via `lv_fs_add_drv()`)
+ *  2) Variable: Pointer to an `lv_img_dsc_t` variable
+ *  3) Symbol: E.g. `LV_SYMBOL_OK`
+ * @param header the image info will be stored here
+ * @return LV_RES_OK: success; LV_RES_INV: wasn't able to get info about the image
+ */
+lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header);
+
+/**
+ * Open an image.
+ * Try the created image decoder one by one. Once one is able to open the image that decoder is save in `dsc`
+ * @param dsc describe a decoding session. Simply a pointer to an `lv_img_decoder_dsc_t` variable.
+ * @param src the image source. Can be
+ *  1) File name: E.g. "S:folder/img1.png" (The drivers needs to registered via `lv_fs_add_drv()`)
+ *  2) Variable: Pointer to an `lv_img_dsc_t` variable
+ *  3) Symbol: E.g. `LV_SYMBOL_OK`
+ * @param style the style of the image
+ * @return LV_RES_OK: opened the image. `dsc->img_data` and `dsc->header` are set.
+ *         LV_RES_INV: none of the registered image decoders were able to open the image.
+ */
+lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style);
+
+/**
+ * Read a line from an opened image
+ * @param dsc pointer to `lv_img_decoder_dsc_t` used in `lv_img_decoder_open`
+ * @param x start X coordinate (from left)
+ * @param y start Y coordinate (from top)
+ * @param len number of pixels to read
+ * @param buf store the data here
+ * @return LV_RES_OK: success; LV_RES_INV: an error occurred
+ */
+lv_res_t lv_img_decoder_read_line(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len,
+                                  uint8_t * buf);
+
+/**
+ * Close a decoding session
+ * @param dsc pointer to `lv_img_decoder_dsc_t` used in `lv_img_decoder_open`
+ */
+void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc);
+
+/**
+ * Create a new image decoder
+ * @return pointer to the new image decoder
+ */
+lv_img_decoder_t * lv_img_decoder_create(void);
+
+/**
+ * Delete an image decoder
+ * @param decoder pointer to an image decoder
+ */
+void lv_img_decoder_delete(lv_img_decoder_t * decoder);
+
+/**
+ * Set a callback to get information about the image
+ * @param decoder pointer to an image decoder
+ * @param info_cb a function to collect info about an image (fill an `lv_img_header_t` struct)
+ */
+void lv_img_decoder_set_info_cb(lv_img_decoder_t * decoder, lv_img_decoder_info_f_t info_cb);
+
+/**
+ * Set a callback to open an image
+ * @param decoder pointer to an image decoder
+ * @param open_cb a function to open an image
+ */
+void lv_img_decoder_set_open_cb(lv_img_decoder_t * decoder, lv_img_decoder_open_f_t open_cb);
+
+/**
+ * Set a callback to a decoded line of an image
+ * @param decoder pointer to an image decoder
+ * @param read_line_cb a function to read a line of an image
+ */
+void lv_img_decoder_set_read_line_cb(lv_img_decoder_t * decoder, lv_img_decoder_read_line_f_t read_line_cb);
+
+/**
+ * Set a callback to close a decoding session. E.g. close files and free other resources.
+ * @param decoder pointer to an image decoder
+ * @param close_cb a function to close a decoding session
+ */
+void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_close_f_t close_cb);
+
+
+
+/**
+ * Get info about a built-in image
+ * @param decoder the decoder where this function belongs
+ * @param src the image source: pointer to an `lv_img_dsc_t` variable, a file path or a symbol
+ * @param header store the image data here
+ * @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
+ */
+lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header);
+
+/**
+ * Open a built in image
+ * @param decoder the decoder where this function belongs
+ * @param dsc pointer to decoder descriptor. `src`, `style` are already initialized in it.
+ * @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
+ */
+lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc);
+
+/**
+ * Decode `len` pixels starting from the given `x`, `y` coordinates and store them in `buf`.
+ * Required only if the "open" function can't return with the whole decoded pixel array.
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor
+ * @param x start x coordinate
+ * @param y start y coordinate
+ * @param len number of pixels to decode
+ * @param buf a buffer to store the decoded pixels
+ * @return LV_RES_OK: ok; LV_RES_INV: failed
+ */
+lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, lv_coord_t x,
+                                                  lv_coord_t y, lv_coord_t len, uint8_t * buf);
+
+/**
+ * Close the pending decoding. Free resources etc.
+ * @param decoder pointer to the decoder the function associated with
+ * @param dsc pointer to decoder descriptor
+ */
+void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_TEMPL_H*/