Initial commit

include/liblvgl/draw/arm2d/lv_gpu_arm2d.h

@@ -0,0 +1,51 @@
+/**
+ * @file lv_gpu_arm2d.h
+ *
+ */
+
+#ifndef LV_GPU_ARM2D_H
+#define LV_GPU_ARM2D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/hal/lv_hal_disp.h"
+#include "liblvgl/draw/sw/lv_draw_sw.h"
+
+#if LV_USE_GPU_ARM2D
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef lv_draw_sw_ctx_t lv_draw_arm2d_ctx_t;
+
+struct _lv_disp_drv_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_arm2d_ctx_init(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_arm2d_ctx_deinit(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_GPU_ARM2D*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_ARM2D_H*/

include/liblvgl/draw/lv_draw.h

@@ -0,0 +1,218 @@
+/**
+ * @file lv_draw.h
+ *
+ */
+
+#ifndef LV_DRAW_H
+#define LV_DRAW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#include "liblvgl/misc/lv_style.h"
+#include "liblvgl/misc/lv_txt.h"
+#include "lv_img_decoder.h"
+#include "lv_img_cache.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"
+#include "lv_draw_mask.h"
+#include "lv_draw_transform.h"
+#include "lv_draw_layer.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    void * user_data;
+} lv_draw_mask_t;
+
+typedef struct _lv_draw_layer_ctx_t {
+    lv_area_t area_full;
+    lv_area_t area_act;
+    lv_coord_t max_row_with_alpha;
+    lv_coord_t max_row_with_no_alpha;
+    void * buf;
+    struct {
+        const lv_area_t * clip_area;
+        lv_area_t * buf_area;
+        void * buf;
+        bool screen_transp;
+    } original;
+} lv_draw_layer_ctx_t;
+
+typedef struct _lv_draw_ctx_t  {
+    /**
+     *  Pointer to a buffer to draw into
+     */
+    void * buf;
+
+    /**
+     * The position and size of `buf` (absolute coordinates)
+     */
+    lv_area_t * buf_area;
+
+    /**
+     * The current clip area with absolute coordinates, always the same or smaller than `buf_area`
+     */
+    const lv_area_t * clip_area;
+
+
+    void (*draw_rect)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords);
+
+    void (*draw_arc)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * dsc, const lv_point_t * center,
+                     uint16_t radius,  uint16_t start_angle, uint16_t end_angle);
+
+    void (*draw_img_decoded)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_img_dsc_t * dsc,
+                             const lv_area_t * coords, const uint8_t * map_p, lv_img_cf_t color_format);
+
+    lv_res_t (*draw_img)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_img_dsc_t * draw_dsc,
+                         const lv_area_t * coords, const void * src);
+
+    void (*draw_letter)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc,  const lv_point_t * pos_p,
+                        uint32_t letter);
+
+
+    void (*draw_line)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_line_dsc_t * dsc, const lv_point_t * point1,
+                      const lv_point_t * point2);
+
+
+    void (*draw_polygon)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * draw_dsc,
+                         const lv_point_t * points, uint16_t point_cnt);
+
+
+    /**
+     * Get an area of a transformed image (zoomed and/or rotated)
+     * @param draw_ctx      pointer to a draw context
+     * @param dest_area     get this area of the result image. It assumes that the original image is placed to the 0;0 position.
+     * @param src_buf       the source image
+     * @param src_w         width of the source image in [px]
+     * @param src_h         height of the source image in [px]
+     * @param src_stride    the stride in [px].
+     * @param draw_dsc      an `lv_draw_img_dsc_t` descriptor containing the transformation parameters
+     * @param cf            the color format of `src_buf`
+     * @param cbuf          place the colors of the pixels on `dest_area` here in RGB format
+     * @param abuf          place the opacity of the pixels on `dest_area` here
+     */
+    void (*draw_transform)(struct _lv_draw_ctx_t * draw_ctx, const lv_area_t * dest_area, const void * src_buf,
+                           lv_coord_t src_w, lv_coord_t src_h, lv_coord_t src_stride,
+                           const lv_draw_img_dsc_t * draw_dsc, lv_img_cf_t cf, lv_color_t * cbuf, lv_opa_t * abuf);
+
+    /**
+     * Replace the buffer with a rect without decoration like radius or borders
+     */
+    void (*draw_bg)(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * draw_dsc, const lv_area_t * coords);
+
+    /**
+     * Wait until all background operations are finished. (E.g. GPU operations)
+     */
+    void (*wait_for_finish)(struct _lv_draw_ctx_t * draw_ctx);
+
+    /**
+     * Copy an area from buffer to an other
+     * @param draw_ctx      pointer to a draw context
+     * @param dest_buf      copy the buffer into this buffer
+     * @param dest_stride   the width of the dest_buf in pixels
+     * @param dest_area     the destination area
+     * @param src_buf       copy from this buffer
+     * @param src_stride    the width of src_buf in pixels
+     * @param src_area      the source area.
+     *
+     * @note dest_area and src_area must have the same width and height
+     *       but can have different x and y position.
+     * @note dest_area and src_area must be clipped to the real dimensions of the buffers
+     */
+    void (*buffer_copy)(struct _lv_draw_ctx_t * draw_ctx, void * dest_buf, lv_coord_t dest_stride,
+                        const lv_area_t * dest_area,
+                        void * src_buf, lv_coord_t src_stride, const lv_area_t * src_area);
+
+    /**
+     * Initialize a new layer context.
+     * The original buffer and area data are already saved from `draw_ctx` to `layer_ctx`
+     * @param draw_ctx      pointer to the current draw context
+     * @param layer_area    the coordinates of the layer
+     * @param flags         OR-ed flags from @lv_draw_layer_flags_t
+     * @return              pointer to the layer context, or NULL on error
+     */
+    struct _lv_draw_layer_ctx_t * (*layer_init)(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                                                lv_draw_layer_flags_t flags);
+
+    /**
+     * Adjust the layer_ctx and/or draw_ctx based on the `layer_ctx->area_act`.
+     * It's called only if flags has `LV_DRAW_LAYER_FLAG_CAN_SUBDIVIDE`
+     * @param draw_ctx      pointer to the current draw context
+     * @param layer_ctx     pointer to a layer context
+     * @param flags         OR-ed flags from @lv_draw_layer_flags_t
+     */
+    void (*layer_adjust)(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                         lv_draw_layer_flags_t flags);
+
+    /**
+     * Blend a rendered layer to `layer_ctx->area_act`
+     * @param draw_ctx      pointer to the current draw context
+     * @param layer_ctx     pointer to a layer context
+     * @param draw_dsc      pointer to an image draw descriptor
+     */
+    void (*layer_blend)(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                        const lv_draw_img_dsc_t * draw_dsc);
+
+    /**
+     * Destroy a layer context. The original buffer and area data of the `draw_ctx` will be restored
+     * and the `layer_ctx` itself will be freed automatically.
+     * @param draw_ctx      pointer to the current draw context
+     * @param layer_ctx     pointer to a layer context
+     */
+    void (*layer_destroy)(struct _lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * layer_ctx);
+
+    /**
+     * Size of a layer context in bytes.
+     */
+    size_t layer_instance_size;
+
+#if LV_USE_USER_DATA
+    void * user_data;
+#endif
+
+} lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_init(void);
+
+
+void lv_draw_wait_for_finish(lv_draw_ctx_t * draw_ctx);
+
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   POST INCLUDES
+ *********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_H*/

include/liblvgl/draw/lv_draw_arc.h

@@ -0,0 +1,83 @@
+/**
+ * @file lv_draw_arc.h
+ *
+ */
+
+#ifndef LV_DRAW_ARC_H
+#define LV_DRAW_ARC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    lv_color_t color;
+    lv_coord_t width;
+    uint16_t start_angle;
+    uint16_t end_angle;
+    const void * img_src;
+    lv_opa_t opa;
+    lv_blend_mode_t blend_mode  : 2;
+    uint8_t rounded : 1;
+} lv_draw_arc_dsc_t;
+
+struct _lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc);
+
+/**
+ * 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 clip_area     the arc will be drawn only in this area
+ * @param dsc           pointer to an initialized `lv_draw_line_dsc_t` variable
+ */
+void lv_draw_arc(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * dsc, const lv_point_t * center,
+                 uint16_t radius,  uint16_t start_angle, uint16_t end_angle);
+
+/**
+ * Get an area the should be invalidated when the arcs angle changed between start_angle and end_ange
+ * @param x             the x coordinate of the center of the arc
+ * @param y             the y coordinate of the center of the arc
+ * @param radius        the radius of the arc
+ * @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 w             width of the arc
+ * @param rounded       true: the arc is rounded
+ * @param area          store the area to invalidate here
+ */
+void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle,
+                          lv_coord_t w, bool rounded, lv_area_t * area);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_ARC_H*/

include/liblvgl/draw/lv_draw_img.h

@@ -0,0 +1,104 @@
+/**
+ * @file lv_draw_img.h
+ *
+ */
+
+#ifndef LV_DRAW_IMG_H
+#define LV_DRAW_IMG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_img_decoder.h"
+#include "lv_img_buf.h"
+#include "liblvgl/misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+
+    int16_t angle;
+    uint16_t zoom;
+    lv_point_t pivot;
+
+    lv_color_t recolor;
+    lv_opa_t recolor_opa;
+
+    lv_opa_t opa;
+    lv_blend_mode_t blend_mode : 4;
+
+    int32_t frame_id;
+    uint8_t antialias       : 1;
+} lv_draw_img_dsc_t;
+
+struct _lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc);
+/**
+ * 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 dsc pointer to an initialized `lv_draw_img_dsc_t` variable
+ */
+void lv_draw_img(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_img_dsc_t * dsc, const lv_area_t * coords,
+                 const void * src);
+
+
+void lv_draw_img_decoded(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_img_dsc_t * dsc,
+                         const lv_area_t * coords, const uint8_t * map_p, lv_img_cf_t color_format);
+
+/**
+ * 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 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_cf_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_cf_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_cf_has_alpha(lv_img_cf_t cf);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_IMG_H*/

include/liblvgl/draw/lv_draw_label.h

@@ -0,0 +1,100 @@
+/**
+ * @file lv_draw_label.h
+ *
+ */
+
+#ifndef LV_DRAW_LABEL_H
+#define LV_DRAW_LABEL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/misc/lv_bidi.h"
+#include "liblvgl/misc/lv_txt.h"
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_DRAW_LABEL_NO_TXT_SEL (0xFFFF)
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    const lv_font_t * font;
+    uint32_t sel_start;
+    uint32_t sel_end;
+    lv_color_t color;
+    lv_color_t sel_color;
+    lv_color_t sel_bg_color;
+    lv_coord_t line_space;
+    lv_coord_t letter_space;
+    lv_coord_t ofs_x;
+    lv_coord_t ofs_y;
+    lv_opa_t opa;
+    lv_base_dir_t bidi_dir;
+    lv_text_align_t align;
+    lv_text_flag_t flag;
+    lv_text_decor_t decor : 3;
+    lv_blend_mode_t blend_mode: 3;
+} lv_draw_label_dsc_t;
+
+/** 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 _lv_draw_label_hint_t {
+    /** 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;
+
+struct _lv_draw_ctx_t;
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+LV_ATTRIBUTE_FAST_MEM void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc);
+
+/**
+ * Write a text
+ * @param coords coordinates of the label
+ * @param mask the label will be drawn only in this area
+ * @param dsc pointer to draw descriptor
+ * @param txt `\0` terminated text to write
+ * @param hint pointer to a `lv_draw_label_hint_t` variable.
+ * It is managed by the draw to speed up the drawing of very long texts (thousands of lines).
+ */
+LV_ATTRIBUTE_FAST_MEM void lv_draw_label(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc,
+                                         const lv_area_t * coords, const char * txt, lv_draw_label_hint_t * hint);
+
+void lv_draw_letter(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc,  const lv_point_t * pos_p,
+                    uint32_t letter);
+
+/***********************
+ * GLOBAL VARIABLES
+ ***********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_LABEL_H*/

include/liblvgl/draw/lv_draw_layer.h

@@ -0,0 +1,83 @@
+/**
+ * @file lv_draw_layer.h
+ *
+ */
+
+#ifndef LV_DRAW_LAYER_H
+#define LV_DRAW_LAYER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+struct _lv_draw_ctx_t;
+struct _lv_draw_layer_ctx_t;
+
+typedef enum {
+    LV_DRAW_LAYER_FLAG_NONE,
+    LV_DRAW_LAYER_FLAG_HAS_ALPHA,
+    LV_DRAW_LAYER_FLAG_CAN_SUBDIVIDE,
+} lv_draw_layer_flags_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create a new layer context. It is used to start and independent rendering session
+ * with the current draw_ctx
+ * @param draw_ctx      pointer to the current draw context
+ * @param layer_area    the coordinates of the layer
+ * @param flags         OR-ed flags from @lv_draw_layer_flags_t
+ * @return              pointer to the layer context, or NULL on error
+ */
+struct _lv_draw_layer_ctx_t * lv_draw_layer_create(struct _lv_draw_ctx_t * draw_ctx, const lv_area_t * layer_area,
+                                                   lv_draw_layer_flags_t flags);
+
+/**
+ * Adjust the layer_ctx and/or draw_ctx based on the `layer_ctx->area_act`.
+ * It's called only if flags has `LV_DRAW_LAYER_FLAG_CAN_SUBDIVIDE`
+ * @param draw_ctx      pointer to the current draw context
+ * @param layer_ctx     pointer to a layer context
+ * @param flags         OR-ed flags from @lv_draw_layer_flags_t
+ */
+void lv_draw_layer_adjust(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                          lv_draw_layer_flags_t flags);
+
+/**
+ * Blend a rendered layer to `layer_ctx->area_act`
+ * @param draw_ctx      pointer to the current draw context
+ * @param layer_ctx     pointer to a layer context
+ * @param draw_dsc      pointer to an image draw descriptor
+ */
+void lv_draw_layer_blend(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                         lv_draw_img_dsc_t * draw_dsc);
+
+/**
+ * Destroy a layer context.
+ * @param draw_ctx      pointer to the current draw context
+ * @param layer_ctx     pointer to a layer context
+ */
+void lv_draw_layer_destroy(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_LAYER_H*/

include/liblvgl/draw/lv_draw_line.h

@@ -0,0 +1,67 @@
+/**
+ * @file lv_draw_line.h
+ *
+ */
+
+#ifndef LV_DRAW_LINE_H
+#define LV_DRAW_LINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    lv_color_t color;
+    lv_coord_t width;
+    lv_coord_t dash_width;
+    lv_coord_t dash_gap;
+    lv_opa_t opa;
+    lv_blend_mode_t blend_mode  : 2;
+    uint8_t round_start : 1;
+    uint8_t round_end   : 1;
+    uint8_t raw_end     : 1;    /*Do not bother with perpendicular line ending if it's not visible for any reason*/
+} lv_draw_line_dsc_t;
+
+struct _lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+LV_ATTRIBUTE_FAST_MEM void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc);
+
+/**
+ * Draw a line
+ * @param point1 first point of the line
+ * @param point2 second point of the line
+ * @param clip the line will be drawn only in this area
+ * @param dsc pointer to an initialized `lv_draw_line_dsc_t` variable
+ */
+void lv_draw_line(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_line_dsc_t * dsc, const lv_point_t * point1,
+                  const lv_point_t * point2);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_LINE_H*/

include/liblvgl/draw/lv_draw_mask.h

@@ -0,0 +1,394 @@
+/**
+ * @file lv_draw_mask.h
+ *
+ */
+
+#ifndef LV_DRAW_MASK_H
+#define LV_DRAW_MASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdbool.h>
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_math.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_MASK_ID_INV  (-1)
+#if LV_DRAW_COMPLEX
+# define _LV_MASK_MAX_NUM     16
+#else
+# define _LV_MASK_MAX_NUM     1
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+enum {
+    LV_DRAW_MASK_RES_TRANSP,
+    LV_DRAW_MASK_RES_FULL_COVER,
+    LV_DRAW_MASK_RES_CHANGED,
+    LV_DRAW_MASK_RES_UNKNOWN
+};
+
+typedef uint8_t lv_draw_mask_res_t;
+
+typedef struct {
+    void * param;
+    void * custom_id;
+} _lv_draw_mask_saved_t;
+
+typedef _lv_draw_mask_saved_t _lv_draw_mask_saved_arr_t[_LV_MASK_MAX_NUM];
+
+
+
+#if LV_DRAW_COMPLEX == 0
+static inline  uint8_t lv_draw_mask_get_cnt(void)
+{
+    return 0;
+}
+
+static inline bool lv_draw_mask_is_any(const lv_area_t * a)
+{
+    LV_UNUSED(a);
+    return false;
+}
+
+#endif
+
+#if LV_DRAW_COMPLEX
+
+enum {
+    LV_DRAW_MASK_TYPE_LINE,
+    LV_DRAW_MASK_TYPE_ANGLE,
+    LV_DRAW_MASK_TYPE_RADIUS,
+    LV_DRAW_MASK_TYPE_FADE,
+    LV_DRAW_MASK_TYPE_MAP,
+    LV_DRAW_MASK_TYPE_POLYGON,
+};
+
+typedef uint8_t lv_draw_mask_type_t;
+
+enum {
+    LV_DRAW_MASK_LINE_SIDE_LEFT = 0,
+    LV_DRAW_MASK_LINE_SIDE_RIGHT,
+    LV_DRAW_MASK_LINE_SIDE_TOP,
+    LV_DRAW_MASK_LINE_SIDE_BOTTOM,
+};
+
+/**
+ * A common callback type for every mask type.
+ * Used internally by the library.
+ */
+typedef lv_draw_mask_res_t (*lv_draw_mask_xcb_t)(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                 lv_coord_t len,
+                                                 void * p);
+
+typedef uint8_t lv_draw_mask_line_side_t;
+
+typedef struct {
+    lv_draw_mask_xcb_t cb;
+    lv_draw_mask_type_t type;
+} _lv_draw_mask_common_dsc_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    _lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        /*First point*/
+        lv_point_t p1;
+
+        /*Second point*/
+        lv_point_t p2;
+
+        /*Which side to keep?*/
+        lv_draw_mask_line_side_t side : 2;
+    } cfg;
+
+    /*A point of the line*/
+    lv_point_t origo;
+
+    /*X / (1024*Y) steepness (X is 0..1023 range). What is the change of X in 1024 Y?*/
+    int32_t xy_steep;
+
+    /*Y / (1024*X) steepness (Y is 0..1023 range). What is the change of Y in 1024 X?*/
+    int32_t yx_steep;
+
+    /*Helper which stores yx_steep for flat lines and xy_steep for steep (non flat) lines*/
+    int32_t steep;
+
+    /*Steepness in 1 px in 0..255 range. Used only by flat lines.*/
+    int32_t spx;
+
+    /*1: It's a flat line? (Near to horizontal)*/
+    uint8_t flat : 1;
+
+    /*Invert the mask. The default is: Keep the left part.
+     *It is used to select left/right/top/bottom*/
+    uint8_t inv: 1;
+} lv_draw_mask_line_param_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    _lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_point_t vertex_p;
+        lv_coord_t start_angle;
+        lv_coord_t end_angle;
+    } cfg;
+
+    lv_draw_mask_line_param_t start_line;
+    lv_draw_mask_line_param_t end_line;
+    uint16_t delta_deg;
+} lv_draw_mask_angle_param_t;
+
+typedef struct  {
+    uint8_t * buf;
+    lv_opa_t * cir_opa;         /*Opacity of values on the circumference of an 1/4 circle*/
+    uint16_t * x_start_on_y;        /*The x coordinate of the circle for each y value*/
+    uint16_t * opa_start_on_y;      /*The index of `cir_opa` for each y value*/
+    int32_t life;               /*How many times the entry way used*/
+    uint32_t used_cnt;          /*Like a semaphore to count the referencing masks*/
+    lv_coord_t radius;          /*The radius of the entry*/
+} _lv_draw_mask_radius_circle_dsc_t;
+
+typedef _lv_draw_mask_radius_circle_dsc_t _lv_draw_mask_radius_circle_dsc_arr_t[LV_CIRCLE_CACHE_SIZE];
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    _lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_area_t rect;
+        lv_coord_t radius;
+        /*Invert the mask. 0: Keep the pixels inside.*/
+        uint8_t outer: 1;
+    } cfg;
+
+    _lv_draw_mask_radius_circle_dsc_t * circle;
+} lv_draw_mask_radius_param_t;
+
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    _lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_area_t coords;
+        lv_coord_t y_top;
+        lv_coord_t y_bottom;
+        lv_opa_t opa_top;
+        lv_opa_t opa_bottom;
+    } cfg;
+
+} lv_draw_mask_fade_param_t;
+
+
+typedef struct _lv_draw_mask_map_param_t {
+    /*The first element must be the common descriptor*/
+    _lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_area_t coords;
+        const lv_opa_t * map;
+    } cfg;
+} lv_draw_mask_map_param_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    _lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_point_t * points;
+        uint16_t point_cnt;
+    } cfg;
+} lv_draw_mask_polygon_param_t;
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Add a draw mask. Everything drawn after it (until removing the mask) will be affected by the mask.
+ * @param param an initialized mask parameter. Only the pointer is saved.
+ * @param custom_id a custom pointer to identify the mask. Used in `lv_draw_mask_remove_custom`.
+ * @return the an integer, the ID of the mask. Can be used in `lv_draw_mask_remove_id`.
+ */
+int16_t lv_draw_mask_add(void * param, void * custom_id);
+
+//! @cond Doxygen_Suppress
+
+/**
+ * Apply the added buffers on a line. Used internally by the library's drawing routines.
+ * @param mask_buf store the result mask here. Has to be `len` byte long. Should be initialized with `0xFF`.
+ * @param abs_x absolute X coordinate where the line to calculate start
+ * @param abs_y absolute Y coordinate where the line to calculate start
+ * @param len length of the line to calculate (in pixel count)
+ * @return One of these values:
+ * - `LV_DRAW_MASK_RES_FULL_TRANSP`: the whole line is transparent. `mask_buf` is not set to zero
+ * - `LV_DRAW_MASK_RES_FULL_COVER`: the whole line is fully visible. `mask_buf` is unchanged
+ * - `LV_DRAW_MASK_RES_CHANGED`: `mask_buf` has changed, it shows the desired opacity of each pixel in the given line
+ */
+LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                            lv_coord_t len);
+
+/**
+ * Apply the specified buffers on a line. Used internally by the library's drawing routines.
+ * @param mask_buf store the result mask here. Has to be `len` byte long. Should be initialized with `0xFF`.
+ * @param abs_x absolute X coordinate where the line to calculate start
+ * @param abs_y absolute Y coordinate where the line to calculate start
+ * @param len length of the line to calculate (in pixel count)
+ * @param ids ID array of added buffers
+ * @param ids_count number of ID array
+ * @return One of these values:
+ * - `LV_DRAW_MASK_RES_FULL_TRANSP`: the whole line is transparent. `mask_buf` is not set to zero
+ * - `LV_DRAW_MASK_RES_FULL_COVER`: the whole line is fully visible. `mask_buf` is unchanged
+ * - `LV_DRAW_MASK_RES_CHANGED`: `mask_buf` has changed, it shows the desired opacity of each pixel in the given line
+ */
+LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply_ids(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                                lv_coord_t len, const int16_t * ids, int16_t ids_count);
+
+//! @endcond
+
+/**
+ * Remove a mask with a given ID
+ * @param id the ID of the mask.  Returned by `lv_draw_mask_add`
+ * @return the parameter of the removed mask.
+ * If more masks have `custom_id` ID then the last mask's parameter will be returned
+ */
+void * lv_draw_mask_remove_id(int16_t id);
+
+/**
+ * Remove all mask with a given custom ID
+ * @param custom_id a pointer used in `lv_draw_mask_add`
+ * @return return the parameter of the removed mask.
+ * If more masks have `custom_id` ID then the last mask's parameter will be returned
+ */
+void * lv_draw_mask_remove_custom(void * custom_id);
+
+/**
+ * Free the data from the parameter.
+ * It's called inside `lv_draw_mask_remove_id` and `lv_draw_mask_remove_custom`
+ * Needs to be called only in special cases when the mask is not added by `lv_draw_mask_add`
+ * and not removed by `lv_draw_mask_remove_id` or `lv_draw_mask_remove_custom`
+ * @param p pointer to a mask parameter
+ */
+void lv_draw_mask_free_param(void * p);
+
+/**
+ * Called by LVGL the rendering of a screen is ready to clean up
+ * the temporal (cache) data of the masks
+ */
+void _lv_draw_mask_cleanup(void);
+
+//! @cond Doxygen_Suppress
+
+/**
+ * Count the currently added masks
+ * @return number of active masks
+ */
+LV_ATTRIBUTE_FAST_MEM uint8_t lv_draw_mask_get_cnt(void);
+
+
+/**
+ * Check if there is any added draw mask
+ * @param a     an area to test for affecting masks.
+ * @return true: there is t least 1 draw mask; false: there are no draw masks
+ */
+bool lv_draw_mask_is_any(const lv_area_t * a);
+
+//! @endcond
+
+/**
+ *Initialize a line mask from two points.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param p1x X coordinate of the first point of the line
+ * @param p1y Y coordinate of the first point of the line
+ * @param p2x X coordinate of the second point of the line
+ * @param p2y y coordinate of the second point of the line
+ * @param side and element of `lv_draw_mask_line_side_t` to describe which side to keep.
+ * With `LV_DRAW_MASK_LINE_SIDE_LEFT/RIGHT` and horizontal line all pixels are kept
+ * With `LV_DRAW_MASK_LINE_SIDE_TOP/BOTTOM` and vertical line all pixels are kept
+ */
+void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t p1y, lv_coord_t p2x,
+                                   lv_coord_t p2y, lv_draw_mask_line_side_t side);
+
+/**
+ *Initialize a line mask from a point and an angle.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param px X coordinate of a point of the line
+ * @param py X coordinate of a point of the line
+ * @param angle right 0 deg, bottom: 90
+ * @param side and element of `lv_draw_mask_line_side_t` to describe which side to keep.
+ * With `LV_DRAW_MASK_LINE_SIDE_LEFT/RIGHT` and horizontal line all pixels are kept
+ * With `LV_DRAW_MASK_LINE_SIDE_TOP/BOTTOM` and vertical line all pixels are kept
+ */
+void lv_draw_mask_line_angle_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t py, int16_t angle,
+                                  lv_draw_mask_line_side_t side);
+
+/**
+ * Initialize an angle mask.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param vertex_x X coordinate of the angle vertex (absolute coordinates)
+ * @param vertex_y Y coordinate of the angle vertex (absolute coordinates)
+ * @param start_angle start angle in degrees. 0 deg on the right, 90 deg, on the bottom
+ * @param end_angle end angle
+ */
+void lv_draw_mask_angle_init(lv_draw_mask_angle_param_t * param, lv_coord_t vertex_x, lv_coord_t vertex_y,
+                             lv_coord_t start_angle, lv_coord_t end_angle);
+
+/**
+ * Initialize a fade mask.
+ * @param param pointer to an `lv_draw_mask_radius_param_t` to initialize
+ * @param rect coordinates of the rectangle to affect (absolute coordinates)
+ * @param radius radius of the rectangle
+ * @param inv true: keep the pixels inside the rectangle; keep the pixels outside of the rectangle
+ */
+void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area_t * rect, lv_coord_t radius, bool inv);
+
+/**
+ * Initialize a fade mask.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param coords coordinates of the area to affect (absolute coordinates)
+ * @param opa_top opacity on the top
+ * @param y_top at which coordinate start to change to opacity to `opa_bottom`
+ * @param opa_bottom opacity at the bottom
+ * @param y_bottom at which coordinate reach `opa_bottom`.
+ */
+void lv_draw_mask_fade_init(lv_draw_mask_fade_param_t * param, const lv_area_t * coords, lv_opa_t opa_top,
+                            lv_coord_t y_top,
+                            lv_opa_t opa_bottom, lv_coord_t y_bottom);
+
+/**
+ * Initialize a map mask.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param coords coordinates of the map (absolute coordinates)
+ * @param map array of bytes with the mask values
+ */
+void lv_draw_mask_map_init(lv_draw_mask_map_param_t * param, const lv_area_t * coords, const lv_opa_t * map);
+
+void lv_draw_mask_polygon_init(lv_draw_mask_polygon_param_t * param, const lv_point_t * points, uint16_t point_cnt);
+
+#endif /*LV_DRAW_COMPLEX*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_MASK_H*/

include/liblvgl/draw/lv_draw_rect.h

@@ -0,0 +1,96 @@
+/**
+ * @file lv_draw_rect.h
+ *
+ */
+
+#ifndef LV_DRAW_RECT_H
+#define LV_DRAW_RECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_style.h"
+#include "sw/lv_draw_sw_gradient.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_RADIUS_CIRCLE        0x7FFF /**< A very big radius to always draw as circle*/
+LV_EXPORT_CONST_INT(LV_RADIUS_CIRCLE);
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_coord_t radius;
+    lv_blend_mode_t blend_mode;
+
+    /*Background*/
+    lv_opa_t bg_opa;
+    lv_color_t bg_color;        /**< First element of a gradient is a color, so it maps well here*/
+    lv_grad_dsc_t bg_grad;
+
+    /*Background img*/
+    const void * bg_img_src;
+    const void * bg_img_symbol_font;
+    lv_color_t bg_img_recolor;
+    lv_opa_t bg_img_opa;
+    lv_opa_t bg_img_recolor_opa;
+    uint8_t bg_img_tiled;
+
+    /*Border*/
+    lv_color_t border_color;
+    lv_coord_t border_width;
+    lv_opa_t border_opa;
+    uint8_t border_post : 1;        /*There is a border it will be drawn later.*/
+    lv_border_side_t border_side : 5;
+
+    /*Outline*/
+    lv_color_t outline_color;
+    lv_coord_t outline_width;
+    lv_coord_t outline_pad;
+    lv_opa_t outline_opa;
+
+    /*Shadow*/
+    lv_color_t shadow_color;
+    lv_coord_t shadow_width;
+    lv_coord_t shadow_ofs_x;
+    lv_coord_t shadow_ofs_y;
+    lv_coord_t shadow_spread;
+    lv_opa_t shadow_opa;
+} lv_draw_rect_dsc_t;
+
+struct _lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc);
+
+
+/**
+ * Draw a rectangle
+ * @param coords the coordinates of the rectangle
+ * @param clip the rectangle will be drawn only in this area
+ * @param dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
+ */
+void lv_draw_rect(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_RECT_H*/

include/liblvgl/draw/lv_draw_transform.h

@@ -0,0 +1,44 @@
+/**
+ * @file lv_draw_transform.h
+ *
+ */
+
+#ifndef LV_DRAW_TRANSFORM_H
+#define LV_DRAW_TRANSFORM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+#include "liblvgl/misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+struct _lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_transform(struct _lv_draw_ctx_t * draw_ctx, const lv_area_t * dest_area, const void * src_buf,
+                       lv_coord_t src_w, lv_coord_t src_h,
+                       lv_coord_t src_stride, const lv_draw_img_dsc_t * draw_dsc, lv_img_cf_t cf, lv_color_t * cbuf, lv_opa_t * abuf);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_TRANSFORM_H*/

include/liblvgl/draw/lv_draw_triangle.h

@@ -0,0 +1,42 @@
+/**
+ * @file lv_draw_triangle.h
+ *
+ */
+
+#ifndef LV_DRAW_TRIANGLE_H
+#define LV_DRAW_TRIANGLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_rect.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_polygon(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * draw_dsc, const lv_point_t points[],
+                     uint16_t point_cnt);
+
+void lv_draw_triangle(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * draw_dsc, const lv_point_t points[]);
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_TRIANGLE_H*/

include/liblvgl/draw/lv_img_buf.h

@@ -0,0 +1,249 @@
+/**
+ * @file lv_img_buf.h
+ *
+ */
+
+#ifndef LV_IMG_BUF_H
+#define LV_IMG_BUF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdbool.h>
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_area.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
+
+#define LV_IMG_BUF_SIZE_TRUE_COLOR(w, h) ((LV_COLOR_SIZE / 8) * w * h)
+#define LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h) ((LV_COLOR_SIZE / 8) * w * h)
+#define LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h) (LV_IMG_PX_SIZE_ALPHA_BYTE * w * h)
+
+/*+ 1: to be sure no fractional row*/
+#define LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h) ((((w / 8) + 1) * h))
+#define LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h) ((((w / 4) + 1) * h))
+#define LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h) ((((w / 2) + 1) * h))
+#define LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h) ((w * h))
+
+/*4 * X: for palette*/
+#define LV_IMG_BUF_SIZE_INDEXED_1BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h) + 4 * 2)
+#define LV_IMG_BUF_SIZE_INDEXED_2BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h) + 4 * 4)
+#define LV_IMG_BUF_SIZE_INDEXED_4BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h) + 4 * 16)
+#define LV_IMG_BUF_SIZE_INDEXED_8BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h) + 4 * 256)
+
+#define _LV_ZOOM_INV_UPSCALE 5
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*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 (can't be chroma keyed)*/
+    LV_IMG_CF_INDEXED_2BIT, /**< Can have 4 different colors in a palette (can't be chroma keyed)*/
+    LV_IMG_CF_INDEXED_4BIT, /**< Can have 16 different colors in a palette (can't be chroma keyed)*/
+    LV_IMG_CF_INDEXED_8BIT, /**< Can have 256 different colors in a palette (can't be 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_RGB888,
+    LV_IMG_CF_RGBA8888,
+    LV_IMG_CF_RGBX8888,
+    LV_IMG_CF_RGB565,
+    LV_IMG_CF_RGBA5658,
+    LV_IMG_CF_RGB565A8,
+
+    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;
+
+
+/**
+ * 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
+ * On big endian systems the order is reversed so cf and always_zero must be at
+ * the end of the struct.
+ */
+#if LV_BIG_ENDIAN_SYSTEM
+typedef struct {
+
+    uint32_t h : 11; /*Height of the image map*/
+    uint32_t w : 11; /*Width of the image map*/
+    uint32_t reserved : 2; /*Reserved to be used later*/
+    uint32_t always_zero : 3; /*It the upper bits of the first byte. Always zero to look like a
+                                 non-printable character*/
+    uint32_t cf : 5;          /*Color format: See `lv_img_color_format_t`*/
+
+} lv_img_header_t;
+#else
+typedef struct {
+
+    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;
+#endif
+
+/** Image header it is compatible with
+ * the result from image converter utility*/
+typedef struct {
+    lv_img_header_t header; /**< A header describing the basics of the image*/
+    uint32_t data_size;     /**< Size of the image in bytes*/
+    const uint8_t * data;   /**< Pointer to the data of the image*/
+} lv_img_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Allocate an image buffer in RAM
+ * @param w width of image
+ * @param h height of image
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return an allocated image, or NULL on failure
+ */
+lv_img_dsc_t * lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf);
+
+/**
+ * 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 color the color of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` this color is used.
+ * Not used in other cases.
+ * @param safe true: check out of bounds
+ * @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, lv_color_t 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
+ * @param safe true: check out of bounds
+ * @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
+ * @param safe true: check out of bounds
+ */
+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
+ * @param safe true: check out of bounds
+ */
+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);
+
+/**
+ * Free an allocated image buffer
+ * @param dsc image buffer to free
+ */
+void lv_img_buf_free(lv_img_dsc_t * dsc);
+
+/**
+ * Get the memory consumption of a raw bitmap, given color format and dimensions.
+ * @param w width
+ * @param h height
+ * @param cf color format
+ * @return size in bytes
+ */
+uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf);
+
+/**
+ * Get the area of a rectangle if its rotated and scaled
+ * @param res store the coordinates here
+ * @param w width of the rectangle to transform
+ * @param h height of the rectangle to transform
+ * @param angle angle of rotation
+ * @param zoom zoom, (256 no zoom)
+ * @param pivot x,y pivot coordinates of rotation
+ */
+void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
+                                      const lv_point_t * pivot);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_IMG_BUF_H*/

include/liblvgl/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_to_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 color The color of the image with `LV_IMG_CF_ALPHA_...`
+ * @param frame_id the index of the frame. Used only with animated images, set 0 for normal images
+ * @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, lv_color_t color, int32_t frame_id);
+
+/**
+ * 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*/

include/liblvgl/draw/lv_img_decoder.h

@@ -0,0 +1,274 @@
+/**
+ * @file lv_img_decoder.h
+ *
+ */
+
+#ifndef LV_IMG_DECODER_H
+#define LV_IMG_DECODER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#include <stdint.h>
+#include "lv_img_buf.h"
+#include "liblvgl/misc/lv_fs.h"
+#include "liblvgl/misc/lv_types.h"
+#include "liblvgl/misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      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;
+
+/*Decoder function definitions*/
+struct _lv_img_decoder_dsc_t;
+struct _lv_img_decoder_t;
+
+/**
+ * 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_t * 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`, `color` are already initialized in it.
+ */
+typedef lv_res_t (*lv_img_decoder_open_f_t)(struct _lv_img_decoder_t * decoder, struct _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
+ */
+typedef lv_res_t (*lv_img_decoder_read_line_f_t)(struct _lv_img_decoder_t * decoder, struct _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
+ */
+typedef void (*lv_img_decoder_close_f_t)(struct _lv_img_decoder_t * decoder, struct _lv_img_decoder_dsc_t * dsc);
+
+
+typedef struct _lv_img_decoder_t {
+    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
+    void * user_data;
+#endif
+} lv_img_decoder_t;
+
+
+/**Describe an image decoding session. Stores data about the decoding*/
+typedef struct _lv_img_decoder_dsc_t {
+    /**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;
+
+    /**Color to draw the image. USed when the image has alpha channel only*/
+    lv_color_t color;
+
+    /**Frame of the image, using with animated images*/
+    int32_t frame_id;
+
+    /**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_drv_register()`)
+ *  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 void * src, lv_img_header_t * header);
+
+/**
+ * Open an image.
+ * Try the created image decoders one by one. Once one is able to open the image that decoder is saved in `dsc`
+ * @param dsc describes 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_drv_register())`)
+ *  2) Variable: Pointer to an `lv_img_dsc_t` variable
+ *  3) Symbol: E.g. `LV_SYMBOL_OK`
+ * @param color The color of the image with `LV_IMG_CF_ALPHA_...`
+ * @param frame_id the index of the frame. Used only with animated images, set 0 for normal images
+ * @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, lv_color_t color, int32_t frame_id);
+
+/**
+ * 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_IMG_DECODER_H*/

include/liblvgl/draw/nxp/lv_gpu_nxp.h

@@ -0,0 +1,71 @@
+/**
+ * @file lv_gpu_nxp.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_GPU_NXP_H
+#define LV_GPU_NXP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+#if LV_USE_GPU_NXP_PXP || LV_USE_GPU_NXP_VG_LITE
+#include "../sw/lv_draw_sw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef lv_draw_sw_ctx_t lv_draw_nxp_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_nxp_ctx_init(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_nxp_ctx_deinit(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /*LV_USE_GPU_NXP_PXP || LV_USE_GPU_NXP_VG_LITE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_NXP_H*/

include/liblvgl/draw/nxp/pxp/lv_draw_pxp_blend.h

@@ -0,0 +1,143 @@
+/**
+ * @file lv_draw_pxp_blend.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2020-2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_DRAW_PXP_BLEND_H
+#define LV_DRAW_PXP_BLEND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_PXP
+#include "lv_gpu_nxp_pxp.h"
+#include "../../sw/lv_draw_sw.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#ifndef LV_GPU_NXP_PXP_BLIT_SIZE_LIMIT
+/** Minimum area (in pixels) for image copy with 100% opacity to be handled by PXP*/
+#define LV_GPU_NXP_PXP_BLIT_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_PXP_BLIT_OPA_SIZE_LIMIT
+/** Minimum area (in pixels) for image copy with transparency to be handled by PXP*/
+#define LV_GPU_NXP_PXP_BLIT_OPA_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_PXP_BUFF_SYNC_BLIT_SIZE_LIMIT
+/** Minimum invalidated area (in pixels) to be synchronized by PXP during buffer sync */
+#define LV_GPU_NXP_PXP_BUFF_SYNC_BLIT_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_PXP_FILL_SIZE_LIMIT
+/** Minimum area (in pixels) to be filled by PXP with 100% opacity*/
+#define LV_GPU_NXP_PXP_FILL_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_PXP_FILL_OPA_SIZE_LIMIT
+/** Minimum area (in pixels) to be filled by PXP with transparency*/
+#define LV_GPU_NXP_PXP_FILL_OPA_SIZE_LIMIT 5000
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Fill area, with optional opacity.
+ *
+ * @param[in/out] dest_buf destination buffer
+ * @param[in] dest_stride width (stride) of destination buffer in pixels
+ * @param[in] fill_area area to fill
+ * @param[in] color color
+ * @param[in] opa transparency of the color
+ * @retval LV_RES_OK Fill completed
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_PXP_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_pxp_fill(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * fill_area,
+                             lv_color_t color, lv_opa_t opa);
+
+/**
+ * BLock Image Transfer - copy rectangular image from src_buf to dst_buf with effects.
+ * By default, image is copied directly, with optional opacity. This function can also
+ * rotate the display output buffer to a specified angle (90x step).
+ *
+ * @param[in/out] dest_buf destination buffer
+ * @param[in] dest_area destination area
+ * @param[in] dest_stride width (stride) of destination buffer in pixels
+ * @param[in] src_buf source buffer
+ * @param[in] src_area source area with absolute coordinates to draw on destination buffer
+ * @param[in] opa opacity of the result
+ * @param[in] angle display rotation angle (90x)
+ * @retval LV_RES_OK Fill completed
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_PXP_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_pxp_blit(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride,
+                             const lv_color_t * src_buf, const lv_area_t * src_area, lv_opa_t opa, lv_disp_rot_t angle);
+
+/**
+ * BLock Image Transfer - copy rectangular image from src_buf to dst_buf with transformation.
+ *
+ *
+ * @param[in/out] dest_buf destination buffer
+ * @param[in] dest_area destination area
+ * @param[in] dest_stride width (stride) of destination buffer in pixels
+ * @param[in] src_buf source buffer
+ * @param[in] src_area source area with absolute coordinates to draw on destination buffer
+ * @param[in] dsc image descriptor
+ * @param[in] cf color format
+ * @retval LV_RES_OK Fill completed
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_PXP_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_pxp_blit_transform(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride,
+                                       const lv_color_t * src_buf, const lv_area_t * src_area, const lv_draw_img_dsc_t * dsc, lv_img_cf_t cf);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_NXP_PXP*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_PXP_BLEND_H*/

include/liblvgl/draw/nxp/pxp/lv_gpu_nxp_pxp.h

@@ -0,0 +1,153 @@
+/**
+ * @file lv_gpu_nxp_pxp.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2020-2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_GPU_NXP_PXP_H
+#define LV_GPU_NXP_PXP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_PXP
+#include "fsl_cache.h"
+#include "fsl_pxp.h"
+
+#include "../../../misc/lv_log.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/** PXP module instance to use*/
+#define LV_GPU_NXP_PXP_ID PXP
+
+/** PXP interrupt line ID*/
+#define LV_GPU_NXP_PXP_IRQ_ID PXP_IRQn
+
+#ifndef LV_GPU_NXP_PXP_LOG_ERRORS
+/** Enable logging of PXP errors (\see LV_LOG_ERROR)*/
+#define LV_GPU_NXP_PXP_LOG_ERRORS 1
+#endif
+
+#ifndef LV_GPU_NXP_PXP_LOG_TRACES
+/** Enable logging of PXP errors (\see LV_LOG_ERROR)*/
+#define LV_GPU_NXP_PXP_LOG_TRACES 0
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * NXP PXP device configuration - call-backs used for
+ * interrupt init/wait/deinit.
+ */
+typedef struct {
+    /** Callback for PXP interrupt initialization*/
+    lv_res_t (*pxp_interrupt_init)(void);
+
+    /** Callback for PXP interrupt de-initialization*/
+    void (*pxp_interrupt_deinit)(void);
+
+    /** Callback that should start PXP and wait for operation complete*/
+    void (*pxp_run)(void);
+} lv_nxp_pxp_cfg_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Reset and initialize PXP device. This function should be called as a part
+ * of display init sequence.
+ *
+ * @retval LV_RES_OK PXP init completed
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_PXP_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_pxp_init(void);
+
+/**
+ * Disable PXP device. Should be called during display deinit sequence.
+ */
+void lv_gpu_nxp_pxp_deinit(void);
+
+/**
+ * Start PXP job and wait for completion.
+ */
+void lv_gpu_nxp_pxp_run(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define PXP_COND_STOP(cond, txt)              \
+    do {                                      \
+        if (cond) {                           \
+            LV_LOG_ERROR("%s. STOP!", txt);   \
+            for ( ; ; );                      \
+        }                                     \
+    } while(0)
+
+#if LV_GPU_NXP_PXP_LOG_ERRORS
+#define PXP_RETURN_INV(fmt, ...)              \
+    do {                                      \
+        LV_LOG_ERROR(fmt, ##__VA_ARGS__);     \
+        return LV_RES_INV;                    \
+    } while (0)
+#else
+#define PXP_RETURN_INV(fmt, ...)              \
+    do {                                      \
+        return LV_RES_INV;                    \
+    }while(0)
+#endif /*LV_GPU_NXP_PXP_LOG_ERRORS*/
+
+#if LV_GPU_NXP_PXP_LOG_TRACES
+#define PXP_LOG_TRACE(fmt, ...)               \
+    do {                                      \
+        LV_LOG_ERROR(fmt, ##__VA_ARGS__);     \
+    } while (0)
+#else
+#define PXP_LOG_TRACE(fmt, ...)               \
+    do {                                      \
+    } while (0)
+#endif /*LV_GPU_NXP_PXP_LOG_TRACES*/
+
+#endif /*LV_USE_GPU_NXP_PXP*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_NXP_PXP_H*/

include/liblvgl/draw/nxp/pxp/lv_gpu_nxp_pxp_osa.h

@@ -0,0 +1,78 @@
+/**
+ * @file lv_gpu_nxp_pxp_osa.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2020, 2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_GPU_NXP_PXP_OSA_H
+#define LV_GPU_NXP_PXP_OSA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_PXP && LV_USE_GPU_NXP_PXP_AUTO_INIT
+#include "lv_gpu_nxp_pxp.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * PXP device interrupt handler. Used to check PXP task completion status.
+ */
+void PXP_IRQHandler(void);
+
+/**
+ * Helper function to get the PXP default configuration.
+ */
+lv_nxp_pxp_cfg_t * lv_gpu_nxp_pxp_get_cfg(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_NXP_PXP && LV_USE_GPU_NXP_PXP_AUTO_INIT*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_NXP_PXP_OSA_H*/

include/liblvgl/draw/nxp/vglite/lv_draw_vglite_arc.h

@@ -0,0 +1,79 @@
+/**
+ * @file lv_draw_vglite_arc.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2021, 2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_DRAW_VGLITE_ARC_H
+#define LV_DRAW_VGLITE_ARC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_VG_LITE
+#include "lv_gpu_nxp_vglite.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/***
+ * Draw arc shape with effects
+ * @param draw_ctx drawing context
+ * @param dsc the arc description structure (width, rounded ending, opacity)
+ * @param center the coordinates of the arc center
+ * @param radius the radius of external arc
+ * @param start_angle the starting angle in degrees
+ * @param end_angle the ending angle in degrees
+ */
+lv_res_t lv_gpu_nxp_vglite_draw_arc(lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * dsc, const lv_point_t * center,
+                                    int32_t radius, int32_t start_angle, int32_t end_angle);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_NXP_VG_LITE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_VGLITE_ARC_H*/

include/liblvgl/draw/nxp/vglite/lv_draw_vglite_blend.h

@@ -0,0 +1,149 @@
+/**
+ * @file lv_draw_vglite_blend.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2020-2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_DRAW_VGLITE_BLEND_H
+#define LV_DRAW_VGLITE_BLEND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_VG_LITE
+#include "lv_gpu_nxp_vglite.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#ifndef LV_GPU_NXP_VG_LITE_FILL_SIZE_LIMIT
+/** Minimum area (in pixels) to be filled by VG-Lite with 100% opacity*/
+#define LV_GPU_NXP_VG_LITE_FILL_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_VG_LITE_FILL_OPA_SIZE_LIMIT
+/** Minimum area (in pixels) to be filled by VG-Lite with transparency*/
+#define LV_GPU_NXP_VG_LITE_FILL_OPA_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_VG_LITE_BLIT_SIZE_LIMIT
+/** Minimum area (in pixels) for image copy with 100% opacity to be handled by VG-Lite*/
+#define LV_GPU_NXP_VG_LITE_BLIT_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_VG_LITE_BUFF_SYNC_BLIT_SIZE_LIMIT
+/** Minimum invalidated area (in pixels) to be synchronized by VG-Lite during buffer sync */
+#define LV_GPU_NXP_VG_LITE_BUFF_SYNC_BLIT_SIZE_LIMIT 5000
+#endif
+
+#ifndef LV_GPU_NXP_VG_LITE_BLIT_OPA_SIZE_LIMIT
+/** Minimum area (in pixels) for image copy with transparency to be handled by VG-Lite*/
+#define LV_GPU_NXP_VG_LITE_BLIT_OPA_SIZE_LIMIT 5000
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**
+ * BLock Image Transfer descriptor structure
+ */
+typedef struct {
+
+    const lv_color_t * src;  /**< Source buffer pointer (must be aligned on 32 bytes)*/
+    lv_area_t src_area;      /**< Area to be copied from source*/
+    lv_coord_t src_width;    /**< Source buffer width*/
+    lv_coord_t src_height;   /**< Source buffer height*/
+    int32_t src_stride;      /**< Source buffer stride in bytes (must be aligned on 16 px)*/
+
+    const lv_color_t * dst;  /**< Destination buffer pointer (must be aligned on 32 bytes)*/
+    lv_area_t dst_area;      /**< Target area in destination buffer (must be the same as src_area)*/
+    lv_coord_t dst_width;    /**< Destination buffer width*/
+    lv_coord_t dst_height;   /**< Destination buffer height*/
+    int32_t dst_stride;      /**< Destination buffer stride in bytes (must be aligned on 16 px)*/
+
+    lv_opa_t opa;            /**< Opacity - alpha mix (0 = source not copied, 255 = 100% opaque)*/
+    uint32_t angle;          /**< Rotation angle (1/10 of degree)*/
+    uint32_t zoom;           /**< 256 = no zoom (1:1 scale ratio)*/
+    lv_point_t pivot;        /**< The coordinates of rotation pivot in source image buffer*/
+} lv_gpu_nxp_vglite_blit_info_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Fill area, with optional opacity.
+ *
+ * @param[in/out] dest_buf Destination buffer pointer (must be aligned on 32 bytes)
+ * @param[in] dest_width Destination buffer width in pixels (must be aligned on 16 px)
+ * @param[in] dest_height Destination buffer height in pixels
+ * @param[in] fill_area Area to be filled
+ * @param[in] color Fill color
+ * @param[in] opa Opacity (255 = full, 128 = 50% background/50% color, 0 = no fill)
+ * @retval LV_RES_OK Fill completed
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_VG_LITE_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_vglite_fill(lv_color_t * dest_buf, lv_coord_t dest_width, lv_coord_t dest_height,
+                                const lv_area_t * fill_area, lv_color_t color, lv_opa_t opa);
+
+/**
+ * BLock Image Transfer.
+ *
+ * @param[in] blit Description of the transfer
+ * @retval LV_RES_OK Transfer complete
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_VG_LITE_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_vglite_blit(lv_gpu_nxp_vglite_blit_info_t * blit);
+
+/**
+ * BLock Image Transfer with transformation.
+ *
+ * @param[in] blit Description of the transfer
+ * @retval LV_RES_OK Transfer complete
+ * @retval LV_RES_INV Error occurred (\see LV_GPU_NXP_VG_LITE_LOG_ERRORS)
+ */
+lv_res_t lv_gpu_nxp_vglite_blit_transform(lv_gpu_nxp_vglite_blit_info_t * blit);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_NXP_VG_LITE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_VGLITE_BLEND_H*/

include/liblvgl/draw/nxp/vglite/lv_draw_vglite_rect.h

@@ -0,0 +1,77 @@
+/**
+ * @file lv_draw_vglite_rect.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2021, 2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_DRAW_VGLITE_RECT_H
+#define LV_DRAW_VGLITE_RECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_VG_LITE
+#include "lv_gpu_nxp_vglite.h"
+#include "../../lv_draw_rect.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Draw rectangle shape with effects (rounded corners, gradient)
+ *
+ * @param draw_ctx drawing context
+ * @param dsc description of the rectangle
+ * @param coords the area where rectangle is clipped
+ */
+lv_res_t lv_gpu_nxp_vglite_draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_NXP_VG_LITE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_VGLITE_RECT_H*/

include/liblvgl/draw/nxp/vglite/lv_gpu_nxp_vglite.h

@@ -0,0 +1,185 @@
+/**
+ * @file lv_gpu_nxp_vglite.h
+ *
+ */
+
+/**
+ * MIT License
+ *
+ * Copyright 2020-2022 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next paragraph)
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LV_GPU_NXP_VGLITE_H
+#define LV_GPU_NXP_VGLITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_NXP_VG_LITE
+#include "vg_lite.h"
+#include "../../sw/lv_draw_sw.h"
+#include "../../../misc/lv_log.h"
+#include "fsl_debug_console.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/** Use this symbol as limit to disable feature (value has to be larger than supported resolution) */
+#define LV_GPU_NXP_VG_LITE_FEATURE_DISABLED (1920*1080+1)
+
+/** Stride in px required by VG-Lite HW. Don't change this. */
+#define LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX 16U
+
+#ifndef LV_GPU_NXP_VG_LITE_LOG_ERRORS
+/** Enable logging of VG-Lite errors (\see LV_LOG_ERROR)*/
+#define LV_GPU_NXP_VG_LITE_LOG_ERRORS 1
+#endif
+
+#ifndef LV_GPU_NXP_VG_LITE_LOG_TRACES
+/** Enable logging of VG-Lite errors (\see LV_LOG_ERROR)*/
+#define LV_GPU_NXP_VG_LITE_LOG_TRACES 0
+#endif
+
+/* Draw rectangles around BLIT tiles */
+#define BLIT_DBG_AREAS   0
+
+/* Print detailed info to SDK console (NOT to LVGL log system) */
+#define BLIT_DBG_VERBOSE 0
+
+/* Verbose debug print */
+#if BLIT_DBG_VERBOSE
+#define PRINT_BLT PRINTF
+#else
+#define PRINT_BLT(...)
+#endif
+
+/* The optimal Bezier control point offset for radial unit
+ * see: https://spencermortensen.com/articles/bezier-circle/
+ **/
+#define BEZIER_OPTIM_CIRCLE 0.551915024494f
+
+/* Draw lines for control points of Bezier curves */
+#define BEZIER_DBG_CONTROL_POINTS   0
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Fills vg_lite_buffer_t structure according given parameters.
+ *
+ * @param[in/out] vgbuf Buffer structure to be filled
+ * @param[in] width Width of buffer in pixels
+ * @param[in] height Height of buffer in pixels
+ * @param[in] stride Stride of the buffer in bytes
+ * @param[in] ptr Pointer to the buffer (must be aligned according VG-Lite requirements)
+ * @param[in] source Boolean to check if this is a source buffer
+ */
+lv_res_t lv_vglite_init_buf(vg_lite_buffer_t * vgbuf, uint32_t width, uint32_t height, uint32_t stride,
+                            const lv_color_t * ptr, bool source);
+
+#if BLIT_DBG_AREAS
+/**
+ * Draw a simple rectangle, 1 px line width.
+ *
+ * @param dest_buf Destination buffer
+ * @param dest_width Destination buffer width (must be aligned on 16px)
+ * @param dest_height Destination buffer height
+ * @param fill_area Rectangle coordinates
+ * @param color Rectangle color
+ */
+void lv_vglite_dbg_draw_rectangle(lv_color_t * dest_buf, lv_coord_t dest_width, lv_coord_t dest_height,
+                                  lv_area_t * fill_area, lv_color_t color);
+#endif
+
+/**
+ * Clean & invalidate cache.
+ */
+void lv_vglite_invalidate_cache(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#define VG_LITE_COND_STOP(cond, txt)          \
+    do {                                      \
+        if (cond) {                           \
+            LV_LOG_ERROR("%s. STOP!", txt);   \
+            for ( ; ; );                      \
+        }                                     \
+    } while(0)
+
+#if LV_GPU_NXP_VG_LITE_LOG_ERRORS
+#define VG_LITE_ERR_RETURN_INV(err, fmt, ...) \
+    do {                                      \
+        if(err != VG_LITE_SUCCESS) {          \
+            LV_LOG_ERROR(fmt, ##__VA_ARGS__); \
+            return LV_RES_INV;                \
+        }                                     \
+    } while (0)
+#else
+#define VG_LITE_ERR_RETURN_INV(err, fmt, ...) \
+    do {                                      \
+        if(err != VG_LITE_SUCCESS) {          \
+            return LV_RES_INV;                \
+        }                                     \
+    }while(0)
+#endif /*LV_GPU_NXP_VG_LITE_LOG_ERRORS*/
+
+#if LV_GPU_NXP_VG_LITE_LOG_TRACES
+#define VG_LITE_LOG_TRACE(fmt, ...)           \
+    do {                                      \
+        LV_LOG_ERROR(fmt, ##__VA_ARGS__);     \
+    } while (0)
+
+#define VG_LITE_RETURN_INV(fmt, ...)          \
+    do {                                      \
+        LV_LOG_ERROR(fmt, ##__VA_ARGS__);     \
+        return LV_RES_INV;                    \
+    } while (0)
+#else
+#define VG_LITE_LOG_TRACE(fmt, ...)           \
+    do {                                      \
+    } while (0)
+#define VG_LITE_RETURN_INV(fmt, ...)          \
+    do {                                      \
+        return LV_RES_INV;                    \
+    }while(0)
+#endif /*LV_GPU_NXP_VG_LITE_LOG_TRACES*/
+
+#endif /*LV_USE_GPU_NXP_VG_LITE*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_NXP_VGLITE_H*/

include/liblvgl/draw/sdl/lv_draw_sdl.h

@@ -0,0 +1,96 @@
+/**
+ * @file lv_draw_sdl.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_H
+#define LV_DRAW_SDL_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "../lv_draw.h"
+#include "../../core/lv_disp.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+#define LV_DRAW_SDL_TEXTURE_FORMAT SDL_PIXELFORMAT_ARGB8888
+#else
+#define LV_DRAW_SDL_TEXTURE_FORMAT SDL_PIXELFORMAT_RGBA8888
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct lv_draw_sdl_context_internals_t;
+
+typedef struct {
+    /**
+     * Render for display driver
+     */
+    SDL_Renderer * renderer;
+    void * user_data;
+} lv_draw_sdl_drv_param_t;
+
+typedef struct {
+    lv_draw_ctx_t base_draw;
+    SDL_Renderer * renderer;
+    struct lv_draw_sdl_context_internals_t * internals;
+} lv_draw_sdl_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_sdl_init_ctx(lv_disp_drv_t * disp_drv, lv_draw_ctx_t * draw_ctx);
+
+/**
+ * @brief Free caches
+ *
+ */
+void lv_draw_sdl_deinit_ctx(lv_disp_drv_t * disp_drv, lv_draw_ctx_t * draw_ctx);
+
+SDL_Texture * lv_draw_sdl_create_screen_texture(SDL_Renderer * renderer, lv_coord_t hor, lv_coord_t ver);
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_composite.h

@@ -0,0 +1,73 @@
+/**
+ * @file lv_draw_sdl_composite.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_COMPOSITE_H
+#define LV_DRAW_SDL_COMPOSITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "lv_draw_sdl.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum lv_draw_sdl_composite_texture_id_t {
+    LV_DRAW_SDL_COMPOSITE_TEXTURE_ID_STREAM0,
+    LV_DRAW_SDL_COMPOSITE_TEXTURE_ID_STREAM1,
+    LV_DRAW_SDL_COMPOSITE_TEXTURE_ID_TARGET0,
+    LV_DRAW_SDL_COMPOSITE_TEXTURE_ID_TARGET1,
+    LV_DRAW_SDL_COMPOSITE_TEXTURE_ID_TRANSFORM0,
+} lv_draw_sdl_composite_texture_id_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Begin drawing with mask. Render target will be switched to a temporary texture,
+ * and drawing coordinates may get clipped or translated
+ * @param coords_in Original coordinates
+ * @param clip_in Original clip area
+ * @param extension Useful for shadows or outlines, can be NULL
+ * @param coords_out Translated coords
+ * @param clip_out Translated clip area
+ * @param apply_area Area of actual composited texture will be drawn
+ * @return true if there are any mask needs to be drawn, false otherwise
+ */
+bool lv_draw_sdl_composite_begin(lv_draw_sdl_ctx_t * ctx, const lv_area_t * coords_in, const lv_area_t * clip_in,
+                                 const lv_area_t * extension, lv_blend_mode_t blend_mode, lv_area_t * coords_out,
+                                 lv_area_t * clip_out, lv_area_t * apply_area);
+
+void lv_draw_sdl_composite_end(lv_draw_sdl_ctx_t * ctx, const lv_area_t * apply_area, lv_blend_mode_t blend_mode);
+
+SDL_Texture * lv_draw_sdl_composite_texture_obtain(lv_draw_sdl_ctx_t * ctx, lv_draw_sdl_composite_texture_id_t id,
+                                                   lv_coord_t w, lv_coord_t h);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_COMPOSITE_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_img.h

@@ -0,0 +1,72 @@
+/**
+ * @file lv_draw_sdl_img.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_IMG_H
+#define LV_DRAW_SDL_IMG_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "../lv_draw.h"
+
+#include "lv_draw_sdl_texture_cache.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct lv_draw_sdl_img_header_t {
+    lv_img_header_t base;
+    SDL_Rect rect;
+} lv_draw_sdl_img_header_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/*=====================
+ * Other functions
+ *====================*/
+bool lv_draw_sdl_img_load_texture(lv_draw_sdl_ctx_t * ctx, lv_draw_sdl_cache_key_head_img_t * key, size_t key_size,
+                                  const void * src, int32_t frame_id, SDL_Texture ** texture,
+                                  lv_draw_sdl_img_header_t ** header);
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_IMG_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_layer.h

@@ -0,0 +1,55 @@
+/**
+ * @file lv_draw_sdl_refr.h
+ *
+ */
+
+#ifndef LV_TEMPL_H
+#define LV_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_sdl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct _lv_draw_sdl_layer_ctx_t {
+    lv_draw_layer_ctx_t base;
+
+    SDL_Texture * orig_target;
+    SDL_Texture * target;
+    SDL_Rect target_rect;
+    lv_draw_layer_flags_t flags;
+} lv_draw_sdl_layer_ctx_t;
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_draw_layer_ctx_t * lv_draw_sdl_layer_init(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * layer_ctx,
+                                             lv_draw_layer_flags_t flags);
+
+void lv_draw_sdl_layer_blend(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * transform_ctx,
+                             const lv_draw_img_dsc_t * draw_dsc);
+
+void lv_draw_sdl_layer_destroy(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * layer_ctx);
+
+void lv_draw_sdl_transform_areas_offset(lv_draw_sdl_ctx_t * ctx, bool has_composite, lv_area_t * apply_area,
+                                        lv_area_t * coords, lv_area_t * clip);
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TEMPL_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_mask.h

@@ -0,0 +1,51 @@
+/**
+ * @file lv_draw_sdl_mask.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_MASK_H
+#define LV_DRAW_SDL_MASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "lv_draw_sdl.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_opa_t * lv_draw_sdl_mask_dump_opa(const lv_area_t * coords, const int16_t * ids, int16_t ids_count);
+
+SDL_Texture * lv_draw_sdl_mask_dump_texture(SDL_Renderer * renderer, const lv_area_t * coords, const int16_t * ids,
+                                            int16_t ids_count);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_MASK_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_priv.h

@@ -0,0 +1,72 @@
+/**
+ * @file lv_draw_sdl_priv.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_PRIV_H
+#define LV_DRAW_SDL_PRIV_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "../lv_draw.h"
+#include "../../misc/lv_lru.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct lv_draw_sdl_context_internals_t {
+    lv_lru_t * texture_cache;
+    SDL_Texture * mask;
+    SDL_Texture * composition;
+    SDL_Texture * target_backup;
+    uint8_t transform_count;
+} lv_draw_sdl_context_internals_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_PRIV_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_rect.h

@@ -0,0 +1,75 @@
+/**
+ * @file lv_draw_sdl_rect.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_RECT_H
+#define LV_DRAW_SDL_RECT_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "../lv_draw.h"
+
+#include "lv_draw_sdl_texture_cache.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct lv_draw_sdl_rect_header_t {
+    lv_img_header_t base;
+    SDL_Rect rect;
+} lv_draw_sdl_rect_header_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/*=====================
+ * Other functions
+ *====================*/
+
+SDL_Texture * lv_draw_sdl_rect_bg_frag_obtain(lv_draw_sdl_ctx_t * ctx, lv_coord_t radius);
+
+void lv_draw_sdl_rect_bg_frag_draw_corners(lv_draw_sdl_ctx_t * ctx, SDL_Texture * frag, lv_coord_t frag_size,
+                                           const lv_area_t * coords, const lv_area_t * clip, bool full);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_RECT_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_stack_blur.h

@@ -0,0 +1,46 @@
+/**
+ * @file lv_draw_sdl_stack_blur.h
+ *
+ */
+#ifndef LV_DRAW_SDL_STACK_BLUR_H
+#define LV_DRAW_SDL_STACK_BLUR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../misc/lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_stack_blur_grayscale(lv_opa_t * buf, uint16_t w, uint16_t h, uint16_t r);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_STACK_BLUR_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_texture_cache.h

@@ -0,0 +1,102 @@
+/**
+ * @file lv_draw_sdl_texture_cache.h
+ *
+ */
+
+#ifndef LV_DRAW_SDL_TEXTURE_CACHE_H
+#define LV_DRAW_SDL_TEXTURE_CACHE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include LV_GPU_SDL_INCLUDE_PATH
+#include "lv_draw_sdl.h"
+#include "lv_draw_sdl_priv.h"
+#include "../../draw/lv_img_decoder.h"
+#include "../../misc/lv_area.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_DRAW_SDL_DEC_DSC_TEXTURE_HEAD "@LVSDLTex"
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    char head[8];
+    SDL_Texture * texture;
+    SDL_Rect rect;
+    bool texture_managed;
+    bool texture_referenced;
+} lv_draw_sdl_dec_dsc_userdata_t;
+
+typedef enum {
+    LV_GPU_CACHE_KEY_MAGIC_ARC = 0x01,
+    LV_GPU_CACHE_KEY_MAGIC_IMG = 0x11,
+    LV_GPU_CACHE_KEY_MAGIC_IMG_ROUNDED_CORNERS = 0x12,
+    LV_GPU_CACHE_KEY_MAGIC_LINE = 0x21,
+    LV_GPU_CACHE_KEY_MAGIC_RECT_BG = 0x31,
+    LV_GPU_CACHE_KEY_MAGIC_RECT_SHADOW = 0x32,
+    LV_GPU_CACHE_KEY_MAGIC_RECT_BORDER = 0x33,
+    LV_GPU_CACHE_KEY_MAGIC_FONT_GLYPH = 0x41,
+    LV_GPU_CACHE_KEY_MAGIC_MASK = 0x51,
+} lv_sdl_cache_key_magic_t;
+
+typedef enum {
+    LV_DRAW_SDL_CACHE_FLAG_NONE = 0,
+    LV_DRAW_SDL_CACHE_FLAG_MANAGED = 1,
+} lv_draw_sdl_cache_flag_t;
+
+typedef struct {
+    lv_sdl_cache_key_magic_t magic;
+    lv_img_src_t type;
+    int32_t frame_id;
+} lv_draw_sdl_cache_key_head_img_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_sdl_texture_cache_init(lv_draw_sdl_ctx_t * ctx);
+
+void lv_draw_sdl_texture_cache_deinit(lv_draw_sdl_ctx_t * ctx);
+
+/**
+ * Find cached texture by key. The texture can be destroyed during usage.
+ */
+SDL_Texture * lv_draw_sdl_texture_cache_get(lv_draw_sdl_ctx_t * ctx, const void * key, size_t key_length, bool * found);
+
+SDL_Texture * lv_draw_sdl_texture_cache_get_with_userdata(lv_draw_sdl_ctx_t * ctx, const void * key, size_t key_length,
+                                                          bool * found, void ** userdata);
+
+void lv_draw_sdl_texture_cache_put(lv_draw_sdl_ctx_t * ctx, const void * key, size_t key_length, SDL_Texture * texture);
+
+void lv_draw_sdl_texture_cache_put_advanced(lv_draw_sdl_ctx_t * ctx, const void * key, size_t key_length,
+                                            SDL_Texture * texture, void * userdata, void userdata_free(void *),
+                                            lv_draw_sdl_cache_flag_t flags);
+
+lv_draw_sdl_cache_key_head_img_t * lv_draw_sdl_texture_img_key_create(const void * src, int32_t frame_id,
+                                                                      size_t * size);
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_TEXTURE_CACHE_H*/

include/liblvgl/draw/sdl/lv_draw_sdl_utils.h

@@ -0,0 +1,65 @@
+/**
+ * @file lv_draw_sdl_utils.h
+ *
+ */
+#ifndef LV_DRAW_SDL_UTILS_H
+#define LV_DRAW_SDL_UTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "liblvgl/lv_conf_internal.h"
+#if LV_USE_GPU_SDL
+
+#include "lv_draw_sdl.h"
+#include "../../misc/lv_color.h"
+#include "../../misc/lv_area.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void _lv_draw_sdl_utils_init();
+
+void _lv_draw_sdl_utils_deinit();
+
+void lv_area_to_sdl_rect(const lv_area_t * in, SDL_Rect * out);
+
+void lv_color_to_sdl_color(const lv_color_t * in, SDL_Color * out);
+
+void lv_area_zoom_to_sdl_rect(const lv_area_t * in, SDL_Rect * out, uint16_t zoom, const lv_point_t * pivot);
+
+SDL_Palette * lv_sdl_alloc_palette_for_bpp(const uint8_t * mapping, uint8_t bpp);
+
+SDL_Surface * lv_sdl_create_opa_surface(lv_opa_t * opa, lv_coord_t width, lv_coord_t height, lv_coord_t stride);
+
+SDL_Texture * lv_sdl_create_opa_texture(SDL_Renderer * renderer, lv_opa_t * pixels, lv_coord_t width,
+                                        lv_coord_t height, lv_coord_t stride);
+
+void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SDL_UTILS_H*/

include/liblvgl/draw/stm32_dma2d/lv_gpu_stm32_dma2d.h

@@ -0,0 +1,70 @@
+/**
+ * @file lv_gpu_stm32_dma2d.h
+ *
+ */
+
+#ifndef LV_GPU_STM32_DMA2D_H
+#define LV_GPU_STM32_DMA2D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/hal/lv_hal_disp.h"
+#include "liblvgl/draw/sw/lv_draw_sw.h"
+
+#if LV_USE_GPU_STM32_DMA2D
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_DMA2D_ARGB8888 0
+#define LV_DMA2D_RGB888 1
+#define LV_DMA2D_RGB565 2
+#define LV_DMA2D_ARGB1555 3
+#define LV_DMA2D_ARGB4444 4
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef lv_draw_sw_ctx_t lv_draw_stm32_dma2d_ctx_t;
+
+struct _lv_disp_drv_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Turn on the peripheral and set output color mode, this only needs to be done once
+ */
+void lv_draw_stm32_dma2d_init(void);
+
+void lv_draw_stm32_dma2d_ctx_init(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_stm32_dma2d_ctx_deinit(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_stm32_dma2d_blend(lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend_dsc_t * dsc);
+
+void lv_draw_stm32_dma2d_buffer_copy(lv_draw_ctx_t * draw_ctx,
+                                     void * dest_buf, lv_coord_t dest_stride, const lv_area_t * dest_area,
+                                     void * src_buf, lv_coord_t src_stride, const lv_area_t * src_area);
+
+void lv_gpu_stm32_dma2d_wait_cb(lv_draw_ctx_t * draw_ctx);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_GPU_STM32_DMA2D*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_STM32_DMA2D_H*/

include/liblvgl/draw/sw/lv_draw_sw.h

@@ -0,0 +1,104 @@
+/**
+ * @file lv_draw_sw.h
+ *
+ */
+
+#ifndef LV_DRAW_SW_H
+#define LV_DRAW_SW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_sw_blend.h"
+#include "liblvgl/draw/lv_draw.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/hal/lv_hal_disp.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_disp_drv_t;
+
+typedef struct {
+    lv_draw_ctx_t base_draw;
+
+    /** Fill an area of the destination buffer with a color*/
+    void (*blend)(lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend_dsc_t * dsc);
+} lv_draw_sw_ctx_t;
+
+typedef struct {
+    lv_draw_layer_ctx_t base_draw;
+
+    uint32_t buf_size_bytes: 31;
+    uint32_t has_alpha : 1;
+} lv_draw_sw_layer_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_draw_sw_init_ctx(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+void lv_draw_sw_deinit_ctx(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_sw_wait_for_finish(lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_sw_arc(lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * dsc, const lv_point_t * center, uint16_t radius,
+                    uint16_t start_angle, uint16_t end_angle);
+
+void lv_draw_sw_rect(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords);
+
+void lv_draw_sw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords);
+void lv_draw_sw_letter(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc, const lv_point_t * pos_p,
+                       uint32_t letter);
+
+LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_img_dsc_t * draw_dsc,
+                                                  const lv_area_t * coords, const uint8_t * src_buf, lv_img_cf_t cf);
+
+LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_line(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_line_dsc_t * dsc,
+                                           const lv_point_t * point1, const lv_point_t * point2);
+
+void lv_draw_sw_polygon(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * draw_dsc,
+                        const lv_point_t * points, uint16_t point_cnt);
+
+void lv_draw_sw_buffer_copy(lv_draw_ctx_t * draw_ctx,
+                            void * dest_buf, lv_coord_t dest_stride, const lv_area_t * dest_area,
+                            void * src_buf, lv_coord_t src_stride, const lv_area_t * src_area);
+
+void lv_draw_sw_transform(lv_draw_ctx_t * draw_ctx, const lv_area_t * dest_area, const void * src_buf,
+                          lv_coord_t src_w, lv_coord_t src_h, lv_coord_t src_stride,
+                          const lv_draw_img_dsc_t * draw_dsc, lv_img_cf_t cf, lv_color_t * cbuf, lv_opa_t * abuf);
+
+struct _lv_draw_layer_ctx_t * lv_draw_sw_layer_create(struct _lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * layer_ctx,
+                                                      lv_draw_layer_flags_t flags);
+
+void lv_draw_sw_layer_adjust(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                             lv_draw_layer_flags_t flags);
+
+void lv_draw_sw_layer_blend(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_layer_ctx_t * layer_ctx,
+                            const lv_draw_img_dsc_t * draw_dsc);
+
+void lv_draw_sw_layer_destroy(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * layer_ctx);
+
+/***********************
+ * GLOBAL VARIABLES
+ ***********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SW_H*/

include/liblvgl/draw/sw/lv_draw_sw_blend.h

@@ -0,0 +1,69 @@
+/**
+ * @file lv_draw_sw_blend.h
+ *
+ */
+
+#ifndef LV_DRAW_SW_BLEND_H
+#define LV_DRAW_SW_BLEND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_area.h"
+#include "liblvgl/misc/lv_style.h"
+#include "liblvgl/draw/lv_draw_mask.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    const lv_area_t * blend_area;   /**< The area with absolute coordinates to draw on `draw_ctx->buf`
+                                     *   will be clipped to `draw_ctx->clip_area` */
+    const lv_color_t * src_buf;     /**< Pointer to an image to blend. If set `fill_color` is ignored */
+    lv_color_t color;               /**< Fill color*/
+    lv_opa_t * mask_buf;            /**< NULL if ignored, or an alpha mask to apply on `blend_area`*/
+    lv_draw_mask_res_t mask_res;    /**< The result of the previous mask operation */
+    const lv_area_t * mask_area;    /**< The area of `mask_buf` with absolute coordinates*/
+    lv_opa_t opa;                   /**< The overall opacity*/
+    lv_blend_mode_t blend_mode;     /**< E.g. LV_BLEND_MODE_ADDITIVE*/
+} lv_draw_sw_blend_dsc_t;
+
+struct _lv_draw_ctx_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Call the blend function of the `draw_ctx`.
+ * @param draw_ctx      pointer to a draw context
+ * @param dsc           pointer to an initialized blend descriptor
+ */
+void lv_draw_sw_blend(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend_dsc_t * dsc);
+
+/**
+ * The basic blend function used with software rendering.
+ * @param draw_ctx      pointer to a draw context
+ * @param dsc           pointer to an initialized blend descriptor
+ */
+LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_blend_basic(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend_dsc_t * dsc);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_SW_BLEND_H*/

include/liblvgl/draw/sw/lv_draw_sw_dither.h

@@ -0,0 +1,70 @@
+/**
+ * @file lv_draw_sw_dither.h
+ *
+ */
+
+#ifndef LV_DRAW_SW_DITHER_H
+#define LV_DRAW_SW_DITHER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/core/lv_obj_pos.h"
+
+
+/*********************
+ *      DEFINES
+ *********************/
+#if LV_COLOR_DEPTH < 32 && LV_DITHER_GRADIENT == 1
+#define _DITHER_GRADIENT 1
+#else
+#define _DITHER_GRADIENT 0
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+#if _DITHER_GRADIENT
+/*A signed error color component*/
+typedef struct {
+    int8_t r, g, b;
+} lv_scolor24_t;
+
+struct _lv_gradient_cache_t;
+typedef void (*lv_dither_func_t)(struct _lv_gradient_cache_t * grad, lv_coord_t x, lv_coord_t y, lv_coord_t w);
+
+#endif
+
+
+/**********************
+ *    PROTOTYPES
+ **********************/
+#if LV_DRAW_COMPLEX
+#if _DITHER_GRADIENT
+LV_ATTRIBUTE_FAST_MEM void lv_dither_none(struct _lv_gradient_cache_t * grad, lv_coord_t x, lv_coord_t y, lv_coord_t w);
+
+LV_ATTRIBUTE_FAST_MEM void lv_dither_ordered_hor(struct _lv_gradient_cache_t * grad, const lv_coord_t xs,
+                                                 const lv_coord_t y, const lv_coord_t w);
+LV_ATTRIBUTE_FAST_MEM void lv_dither_ordered_ver(struct _lv_gradient_cache_t * grad, const lv_coord_t xs,
+                                                 const lv_coord_t y, const lv_coord_t w);
+
+#if LV_DITHER_ERROR_DIFFUSION == 1
+LV_ATTRIBUTE_FAST_MEM void lv_dither_err_diff_hor(struct _lv_gradient_cache_t * grad, const lv_coord_t xs,
+                                                  const lv_coord_t y, const lv_coord_t w);
+LV_ATTRIBUTE_FAST_MEM void lv_dither_err_diff_ver(struct _lv_gradient_cache_t * grad, const lv_coord_t xs,
+                                                  const lv_coord_t y, const lv_coord_t w);
+#endif /* LV_DITHER_ERROR_DIFFUSION */
+
+#endif /* _DITHER_GRADIENT */
+#endif
+
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif

include/liblvgl/draw/sw/lv_draw_sw_gradient.h

@@ -0,0 +1,97 @@
+/**
+ * @file lv_draw_sw_gradient.h
+ *
+ */
+
+#ifndef LV_DRAW_SW_GRADIENT_H
+#define LV_DRAW_SW_GRADIENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/misc/lv_style.h"
+#include "lv_draw_sw_dither.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#if LV_GRADIENT_MAX_STOPS < 2
+#error LVGL needs at least 2 stops for gradients. Please increase the LV_GRADIENT_MAX_STOPS
+#endif
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+#if _DITHER_GRADIENT
+typedef lv_color32_t lv_grad_color_t;
+#else
+typedef lv_color_t lv_grad_color_t;
+#endif
+
+/** To avoid recomputing gradient for each draw operation,
+ *  it's possible to cache the computation in this structure instance.
+ *  Whenever possible, this structure is reused instead of recomputing the gradient map */
+typedef struct _lv_gradient_cache_t {
+    uint32_t        key;          /**< A discriminating key that's built from the drawing operation.
+                                   * If the key does not match, the cache item is not used */
+    uint32_t        life : 30;    /**< A life counter that's incremented on usage. Higher counter is
+                                   * less likely to be evicted from the cache */
+    uint32_t        filled : 1;   /**< Used to skip dithering in it if already done */
+    uint32_t        not_cached: 1; /**< The cache was too small so this item is not managed by the cache*/
+    lv_color_t   *  map;          /**< The computed gradient low bitdepth color map, points into the
+                                   * cache's buffer, no free needed */
+    lv_coord_t      alloc_size;   /**< The map allocated size in colors */
+    lv_coord_t      size;         /**< The computed gradient color map size, in colors */
+#if _DITHER_GRADIENT
+    lv_color32_t  * hmap;         /**< If dithering, we need to store the current, high bitdepth gradient
+                                   * map too, points to the cache's buffer, no free needed */
+#if LV_DITHER_ERROR_DIFFUSION == 1
+    lv_scolor24_t * error_acc;    /**< Error diffusion dithering algorithm requires storing the last error
+                                   * drawn, points to the cache's buffer, no free needed  */
+    lv_coord_t      w;            /**< The error array width in pixels */
+#endif
+#endif
+} lv_grad_t;
+
+
+/**********************
+ *      PROTOTYPES
+ **********************/
+/** Compute the color in the given gradient and fraction
+ *  Gradient are specified in a virtual [0-255] range, so this function scales the virtual range to the given range
+ * @param dsc       The gradient descriptor to use
+ * @param range     The range to use in computation.
+ * @param frac      The current part used in the range. frac is in [0; range]
+ */
+LV_ATTRIBUTE_FAST_MEM lv_grad_color_t lv_gradient_calculate(const lv_grad_dsc_t * dsc, lv_coord_t range,
+                                                            lv_coord_t frac);
+
+/**
+ * Set the gradient cache size
+ * @param max_bytes Max cahce size
+ */
+void lv_gradient_set_cache_size(size_t max_bytes);
+
+/** Free the gradient cache */
+void lv_gradient_free_cache(void);
+
+/** Get a gradient cache from the given parameters */
+lv_grad_t * lv_gradient_get(const lv_grad_dsc_t * gradient, lv_coord_t w, lv_coord_t h);
+
+/**
+ * Clean up the gradient item after it was get with `lv_grad_get_from_cache`.
+ * @param grad      pointer to a gradient
+ */
+void lv_gradient_cleanup(lv_grad_t * grad);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_DRAW_GRADIENT_H*/

include/liblvgl/draw/swm341_dma2d/lv_gpu_swm341_dma2d.h

@@ -0,0 +1,64 @@
+/**
+ * @file lv_gpu_swm341_dma2d.h
+ *
+ */
+
+#ifndef LV_GPU_SWM341_DMA2D_H
+#define LV_GPU_SWM341_DMA2D_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "liblvgl/misc/lv_color.h"
+#include "liblvgl/hal/lv_hal_disp.h"
+#include "liblvgl/draw/sw/lv_draw_sw.h"
+
+#if LV_USE_GPU_SWM341_DMA2D
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_SWM341_DMA2D_ARGB8888 0
+#define LV_SWM341_DMA2D_RGB888 1
+#define LV_SWM341_DMA2D_RGB565 2
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef lv_draw_sw_ctx_t lv_draw_swm341_dma2d_ctx_t;
+
+struct _lv_disp_drv_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Turn on the peripheral and set output color mode, this only needs to be done once
+ */
+void lv_draw_swm341_dma2d_init(void);
+
+void lv_draw_swm341_dma2d_ctx_init(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_swm341_dma2d_ctx_deinit(struct _lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx);
+
+void lv_draw_swm341_dma2d_blend(lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend_dsc_t * dsc);
+
+void lv_gpu_swm341_dma2d_wait_cb(lv_draw_ctx_t * draw_ctx);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif  /*LV_USE_GPU_SWM341_DMA2D*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_SWM341_DMA2D_H*/