arch(sdl) migrated to use new backend architecture (#2840)

* migrated to use new backend architecture

* formatted code

* with direct_mode blend coordinates are working now

* added draw_img_core to backend

* moving from gpu/sdl to draw/sdl

* updated format

* updated format

* fixed include path

* fixing build issue

src/draw/lv_draw.h

@@ -50,6 +50,9 @@ typedef struct _lv_draw_backend_t {
                      const lv_draw_img_dsc_t * draw_dsc,
                      bool chroma_key, bool alpha_byte);
 
+    lv_res_t (*draw_img_core)(const lv_area_t * coords, const lv_area_t * clip_area, const void * src,
+                              const lv_draw_img_dsc_t * draw_dsc);
+
     void (*draw_letter)(const lv_point_t * pos_p, const lv_area_t * clip_area,
                         const lv_font_t * font_p, uint32_t letter,
                         lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);

src/draw/lv_draw_img.c

@@ -70,8 +70,15 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
 
     if(dsc->opa <= LV_OPA_MIN) return;
 
+    const lv_draw_backend_t * backend = lv_draw_backend_get();
+
     lv_res_t res;
+    if(backend->draw_img_core) {
+        res = backend->draw_img_core(coords, mask, src, dsc);
+    }
+    else {
         res = lv_img_draw_core(coords, mask, src, dsc);
+    }
 
     if(res == LV_RES_INV) {
         LV_LOG_WARN("Image draw error");

src/draw/sdl/README.md

@@ -18,11 +18,11 @@ such as OpenGL.
 
 ## Notices for files
 
-### `lv_gpu_sdl_stack_blur.c`
+### `lv_draw_sdl_stack_blur.c`
 
 Contains modified code from [android-stackblur](https://github.com/kikoso/android-stackblur) project.
 Apache License 2.0
 
-### `lv_gpu_sdl_lru.c`/`lv_gpu_sdl_lru.h`
+### `lv_draw_sdl_lru.c`/`lv_draw_sdl_lru.h`
 
 Contains modified code from [C-LRU-Cache](https://github.com/willcannings/C-LRU-Cache) project. No license defined.

src/draw/sdl/lv_draw_sdl.mk

@@ -0,0 +1,14 @@
+CSRCS += lv_draw_sdl_draw_blend.c
+CSRCS += lv_draw_sdl_draw_img.c
+CSRCS += lv_draw_sdl_draw_label.c
+CSRCS += lv_draw_sdl_draw_rect.c
+CSRCS += lv_draw_sdl_lru.c
+CSRCS += lv_draw_sdl_mask.c
+CSRCS += lv_draw_sdl_stack_blur.c
+CSRCS += lv_draw_sdl_texture_cache.c
+CSRCS += lv_draw_sdl_utils.c
+
+DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
+VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
+
+CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl"

src/draw/sdl/lv_draw_sdl_blend.c

@@ -0,0 +1,147 @@
+/**
+ * @file lv_draw_sdl_draw_blend.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../draw/lv_draw_blend.h"
+#include "lv_draw_sdl_texture_cache.h"
+#include "lv_draw_sdl_utils.h"
+#include "lv_draw_sdl_mask.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_sdl_draw_blend_fill(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * fill_area,
+                                 lv_color_t color, lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode)
+{
+    LV_UNUSED(dest_buf);
+    /*Do not draw transparent things*/
+    if(opa < LV_OPA_MIN) return;
+
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
+    SDL_Renderer * renderer = ctx->renderer;
+
+    /*Get clipped fill area which is the real draw area.
+     *It is always the same or inside `fill_area`*/
+    lv_area_t draw_area = *fill_area;
+    //    if(!_lv_area_intersect(&draw_area, clip_area, fill_area)) return;
+
+    SDL_Rect draw_area_rect;
+    lv_area_to_sdl_rect(&draw_area, &draw_area_rect);
+
+    if(mask) {
+        SDL_Surface * mask_surface = lv_sdl_create_mask_surface(mask, lv_area_get_width(&draw_area),
+                                                                lv_area_get_height(&draw_area),
+                                                                lv_area_get_width(&draw_area));
+        SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, mask_surface);
+        SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+        SDL_SetTextureAlphaMod(texture, opa);
+        SDL_SetTextureColorMod(texture, color.ch.red, color.ch.green, color.ch.blue);
+        SDL_RenderSetClipRect(renderer, &draw_area_rect);
+        SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
+        SDL_DestroyTexture(texture);
+        SDL_FreeSurface(mask_surface);
+    }
+    else {
+        SDL_SetRenderDrawColor(renderer, color.ch.red, color.ch.green, color.ch.blue, opa);
+        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+        SDL_RenderSetClipRect(renderer, &draw_area_rect);
+        SDL_RenderFillRect(renderer, &draw_area_rect);
+    }
+}
+
+void lv_draw_sdl_draw_blend_map(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * clip_area,
+                                const lv_color_t * src_buf, const lv_area_t * src_area,
+                                lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode)
+{
+    LV_UNUSED(dest_buf);
+    /*Do not draw transparent things*/
+    if(opa < LV_OPA_MIN) return;
+
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
+    SDL_Renderer * renderer = ctx->renderer;
+
+    SDL_Rect draw_area_rect;
+    lv_area_to_sdl_rect(clip_area, &draw_area_rect);
+
+    Uint32 rmask = 0x00FF0000;
+    Uint32 gmask = 0x0000FF00;
+    Uint32 bmask = 0x000000FF;
+    Uint32 amask = 0x00000000;
+    SDL_Surface * surface = SDL_CreateRGBSurfaceFrom((void *) src_buf, lv_area_get_width(src_area),
+                                                     lv_area_get_height(src_area), LV_COLOR_DEPTH,
+                                                     lv_area_get_width(src_area) * LV_COLOR_DEPTH / 8,
+                                                     rmask, gmask, bmask, amask);
+    if(mask) {
+        SDL_Texture * masked = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET,
+                                                 lv_area_get_width(src_area), lv_area_get_height(src_area));
+        SDL_Texture * mask_texture = lv_sdl_create_mask_texture(renderer, mask, lv_area_get_width(src_area),
+                                                                lv_area_get_height(src_area),
+                                                                lv_area_get_width(src_area));
+        SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
+        SDL_SetRenderTarget(renderer, masked);
+
+        SDL_RenderSetClipRect(renderer, NULL);
+        SDL_SetTextureAlphaMod(mask_texture, opa);
+        SDL_SetTextureBlendMode(mask_texture, SDL_BLENDMODE_NONE);
+        SDL_RenderCopy(renderer, mask_texture, NULL, NULL);
+        SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_MOD);
+        SDL_RenderCopy(renderer, texture, NULL, NULL);
+
+        SDL_SetRenderTarget(renderer, ctx->texture);
+        SDL_RenderSetClipRect(renderer, &draw_area_rect);
+        SDL_SetTextureBlendMode(masked, SDL_BLENDMODE_BLEND);
+        SDL_SetTextureAlphaMod(masked, 0xFF);
+        SDL_SetTextureColorMod(masked, 0xFF, 0xFF, 0xFF);
+        SDL_RenderCopy(renderer, masked, NULL, &draw_area_rect);
+        SDL_DestroyTexture(texture);
+        SDL_DestroyTexture(mask_texture);
+        SDL_DestroyTexture(masked);
+    }
+    else {
+        SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
+        SDL_SetTextureAlphaMod(texture, opa);
+        SDL_SetRenderTarget(renderer, ctx->texture);
+        SDL_RenderSetClipRect(renderer, &draw_area_rect);
+        SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
+        SDL_DestroyTexture(texture);
+    }
+    SDL_FreeSurface(surface);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/

src/draw/sdl/lv_draw_sdl_img.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_draw_img.c
+ * @file lv_draw_sdl_draw_img.c
  *
  */
 
@@ -11,10 +11,13 @@
 
 #if LV_USE_GPU_SDL
 
-#include "../../core/lv_refr.h"
+#include "../../draw/lv_draw_img.h"
-#include "lv_gpu_sdl_utils.h"
+#include "../../draw/lv_img_cache.h"
-#include "lv_gpu_sdl_lru.h"
+#include "../../draw/lv_draw_mask.h"
-#include "lv_gpu_sdl_texture_cache.h"
+
+#include "lv_draw_sdl_utils.h"
+#include "lv_draw_sdl_lru.h"
+#include "lv_draw_sdl_texture_cache.h"
 
 /*********************
  *      DEFINES
@@ -45,26 +48,24 @@ static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src,
+lv_res_t lv_draw_sdl_img_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
                               const lv_draw_img_dsc_t * draw_dsc)
 {
-    if(draw_dsc->opa <= LV_OPA_MIN) return;
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-
+    SDL_Renderer * renderer = ctx->renderer;
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
 
     size_t key_size;
-    lv_gpu_sdl_cache_key_head_img_t * key = lv_gpu_sdl_img_cache_key_create(src, draw_dsc->frame_id, &key_size);
+    lv_draw_sdl_cache_key_head_img_t * key = lv_draw_sdl_img_cache_key_create(src, draw_dsc->frame_id, &key_size);
     bool texture_found = false;
     SDL_Texture * texture = lv_gpu_draw_cache_get(key, key_size, &texture_found);
     if(!texture_found) {
         _lv_img_cache_entry_t * cdsc = _lv_img_cache_open(src, draw_dsc->recolor, draw_dsc->frame_id);
-        lv_gpu_sdl_cache_flag_t tex_flags = 0;
+        lv_draw_sdl_cache_flag_t tex_flags = 0;
         if(cdsc) {
             lv_img_decoder_dsc_t * dsc = &cdsc->dec_dsc;
-            if(dsc->user_data && SDL_memcmp(dsc->user_data, LV_GPU_SDL_DEC_DSC_TEXTURE_HEAD, 8) == 0) {
+            if(dsc->user_data && SDL_memcmp(dsc->user_data, LV_DRAW_SDL_DEC_DSC_TEXTURE_HEAD, 8) == 0) {
-                texture = ((lv_gpu_sdl_dec_dsc_userdata_t *) dsc->user_data)->texture;
+                texture = ((lv_draw_sdl_dec_dsc_userdata_t *) dsc->user_data)->texture;
-                tex_flags |= LV_GPU_SDL_CACHE_FLAG_MANAGED;
+                tex_flags |= LV_DRAW_SDL_CACHE_FLAG_MANAGED;
             }
             else {
                 texture = upload_img_texture(renderer, dsc);
@@ -76,15 +77,15 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
         if(texture && cdsc) {
             lv_img_header_t * header = SDL_malloc(sizeof(lv_img_header_t));
             SDL_memcpy(header, &cdsc->dec_dsc.header, sizeof(lv_img_header_t));
-            lv_gpu_draw_cache_put_advanced(key, key_size, texture, header, SDL_free, tex_flags);
+            lv_draw_sdl_draw_cache_put_advanced(key, key_size, texture, header, SDL_free, tex_flags);
         }
         else {
-            lv_gpu_draw_cache_put(key, key_size, NULL);
+            lv_draw_sdl_draw_cache_put(key, key_size, NULL);
         }
     }
     SDL_free(key);
     if(!texture) {
-        return;
+        return LV_RES_INV;
     }
 
     SDL_Rect mask_rect, coords_rect;
@@ -116,6 +117,7 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
         SDL_SetTextureAlphaMod(texture, draw_dsc->recolor_opa);
         SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
     }
+    return LV_RES_OK;
 }
 
 /**********************

src/draw/sdl/lv_draw_sdl_label.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_draw_label.c
+ * @file lv_draw_sdl_draw_label.c
  *
  */
 
@@ -12,15 +12,14 @@
 #if LV_USE_GPU_SDL
 
 #include "../../draw/lv_draw_label.h"
-#include "../../font/lv_font_fmt_txt.h"
+#include "../../draw/lv_draw_mask.h"
-#include "../../core/lv_refr.h"
 #include "../../misc/lv_utils.h"
 
 #include LV_GPU_SDL_INCLUDE_PATH
 
-#include "lv_gpu_sdl_utils.h"
+#include "lv_draw_sdl_utils.h"
-#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_draw_sdl_texture_cache.h"
-#include "lv_gpu_sdl_mask.h"
+#include "lv_draw_sdl_mask.h"
 
 /*********************
  *      DEFINES
@@ -58,7 +57,7 @@ static lv_font_glyph_key_t font_key_glyph_create(const lv_font_t * font_p, uint3
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
+void lv_draw_sdl_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
                              const lv_font_t * font_p, uint32_t letter, lv_color_t color, lv_opa_t opa,
                              lv_blend_mode_t blend_mode)
 {
@@ -97,8 +96,8 @@ void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
         return;
     }
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+    SDL_Renderer * renderer = ctx->renderer;
 
     lv_font_glyph_key_t glyph_key = font_key_glyph_create(font_p, letter);
     bool glyph_found = false;
@@ -114,7 +113,7 @@ void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
         texture = SDL_CreateTextureFromSurface(renderer, mask);
         SDL_FreeSurface(mask);
         lv_mem_free(buf);
-        lv_gpu_draw_cache_put(&glyph_key, sizeof(glyph_key), texture);
+        lv_draw_sdl_draw_cache_put(&glyph_key, sizeof(glyph_key), texture);
     }
     if(!texture) {
         return;

src/draw/sdl/lv_draw_sdl_lru.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_lru.c
+ * @file lv_draw_sdl_lru.c
  *
  */
 
@@ -11,7 +11,7 @@
 
 #if LV_USE_GPU_SDL
 #include "../../misc/lv_log.h"
-#include "lv_gpu_sdl_lru.h"
+#include "lv_draw_sdl_lru.h"
 
 #include <stdlib.h>
 #include <string.h>

src/draw/sdl/lv_draw_sdl_lru.h

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_lru.h
+ * @file lv_draw_sdl_lru.h
  *
  */
 

src/draw/sdl/lv_draw_sdl_mask.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_mask.c
+ * @file lv_draw_sdl_mask.c
  *
  */
 
@@ -12,9 +12,8 @@
 #if LV_USE_GPU_SDL
 
 #include "../../draw/lv_draw_mask.h"
-#include "../../misc/lv_mem.h"
+#include "lv_draw_sdl_mask.h"
-#include "lv_gpu_sdl_mask.h"
+#include "lv_draw_sdl_utils.h"
-#include "lv_gpu_sdl_utils.h"
 
 /*********************
  *      DEFINES

src/draw/sdl/lv_draw_sdl_mask.h

@@ -1,10 +1,10 @@
 /**
- * @file lv_gpu_sdl_mask.h
+ * @file lv_draw_sdl_mask.h
  *
  */
 
-#ifndef LV_GPU_SDL_MASK_H
+#ifndef LV_DRAW_SDL_MASK_H
-#define LV_GPU_SDL_MASK_H
+#define LV_DRAW_SDL_MASK_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -54,4 +54,4 @@ lv_sdl_gen_mask_texture(SDL_Renderer * renderer, const lv_area_t * coords, const
 } /*extern "C"*/
 #endif
 
-#endif /*LV_GPU_SDL_MASK_H*/
+#endif /*LV_DRAW_SDL_MASK_H*/

src/draw/sdl/lv_draw_sdl_rect.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_draw_rect.c
+ * @file lv_draw_sdl_draw_rect.c
  *
  */
 
@@ -12,13 +12,13 @@
 #if LV_USE_GPU_SDL
 
 #include "../../draw/lv_draw_rect.h"
-#include "../../hal/lv_hal_disp.h"
+#include "../../draw/lv_draw_img.h"
-#include "../../core/lv_refr.h"
+#include "../../draw/lv_draw_label.h"
-#include "lv_gpu_sdl_utils.h"
+#include "../../draw/lv_draw_mask.h"
-#include "lv_gpu_sdl_lru.h"
+#include "lv_draw_sdl_utils.h"
-#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_draw_sdl_texture_cache.h"
-#include "lv_gpu_sdl_mask.h"
+#include "lv_draw_sdl_mask.h"
-#include "lv_gpu_sdl_stack_blur.h"
+#include "lv_draw_sdl_stack_blur.h"
 
 /*********************
  *      DEFINES
@@ -107,7 +107,7 @@ static lv_draw_rect_border_key_t rect_border_key_create(lv_coord_t rout, lv_coor
  *   GLOBAL FUNCTIONS
  **********************/
 
-void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
+void lv_draw_sdl_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
 {
     lv_area_t draw_area;
     bool has_draw_content = _lv_area_intersect(&draw_area, coords, clip);
@@ -117,8 +117,8 @@ void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_dra
         return;
     }
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+    SDL_Renderer * renderer = ctx->renderer;
 
 
     SDL_Rect clip_rect;
@@ -162,7 +162,7 @@ static void draw_bg_color(SDL_Renderer * renderer, const lv_area_t * coords, con
             texture = lv_sdl_gen_mask_texture(renderer, &coords_frag, &mask_id, 1);
             lv_draw_mask_remove_id(mask_id);
             SDL_assert(texture);
-            lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+            lv_draw_sdl_draw_cache_put(&key, sizeof(key), texture);
         }
 
         SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
@@ -205,7 +205,7 @@ static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip, const
     else {
         lv_img_header_t header;
         size_t key_size;
-        lv_gpu_sdl_cache_key_head_img_t * key = lv_gpu_sdl_img_cache_key_create(dsc->bg_img_src, 0, &key_size);
+        lv_draw_sdl_cache_key_head_img_t * key = lv_draw_sdl_img_cache_key_create(dsc->bg_img_src, 0, &key_size);
         bool key_found;
         lv_img_header_t * cache_header = NULL;
         SDL_Texture * texture = lv_gpu_draw_cache_get_with_userdata(key, key_size, &key_found, (void **) &cache_header);
@@ -314,7 +314,7 @@ static void draw_shadow(SDL_Renderer * renderer, const lv_area_t * coords, const
         lv_mem_buf_release(mask_buf);
         lv_draw_mask_remove_id(mask_id);
         SDL_assert(texture);
-        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+        lv_draw_sdl_draw_cache_put(&key, sizeof(key), texture);
     }
 
     SDL_Color shadow_color;
@@ -429,8 +429,8 @@ static void draw_border_generic(const lv_area_t * outer_area, const lv_area_t *
         return;
     }
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+    SDL_Renderer * renderer = ctx->renderer;
 
     lv_coord_t border_width = lv_area_get_width(outer_area);
     lv_coord_t border_height = lv_area_get_height(outer_area);
@@ -465,7 +465,7 @@ static void draw_border_generic(const lv_area_t * outer_area, const lv_area_t *
         lv_draw_mask_remove_id(mask_ids[1]);
         lv_draw_mask_remove_id(mask_ids[0]);
         SDL_assert(texture);
-        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+        lv_draw_sdl_draw_cache_put(&key, sizeof(key), texture);
     }
 
     SDL_Rect outer_rect;
@@ -485,8 +485,8 @@ static void draw_border_simple(const lv_area_t * outer_area, const lv_area_t * i
                                lv_opa_t opa)
 {
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+    SDL_Renderer * renderer = ctx->renderer;
 
     SDL_Color color_sdl;
     lv_color_to_sdl_color(&color, &color_sdl);
@@ -613,8 +613,8 @@ static void draw_rect_masked(const lv_area_t * coords, const lv_area_t * clip, c
         draw_rect_masked_simple(coords, clip, dsc);
         return;
     }
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+    SDL_Renderer * renderer = ctx->renderer;
 
     SDL_Texture * screen = SDL_GetRenderTarget(renderer);
 
@@ -673,8 +673,8 @@ static void draw_rect_masked_simple(const lv_area_t * coords, const lv_area_t *
     SDL_Color bg_color;
     lv_color_to_sdl_color(&dsc->bg_color, &bg_color);
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+    SDL_Renderer * renderer = ctx->renderer;
 
     SDL_Surface * indexed = lv_sdl_apply_mask_surface(coords, NULL, 0);
     SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, indexed);

src/draw/sdl/lv_draw_sdl_stack_blur.c

@@ -1,12 +1,12 @@
 /**
- * @file lv_gpu_sdl_stack_blur.c
+ * @file lv_draw_sdl_stack_blur.c
  *
  */
 
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_gpu_sdl_stack_blur.h"
+#include "lv_draw_sdl_stack_blur.h"
 
 /*********************
  *      DEFINES

src/draw/sdl/lv_draw_sdl_stack_blur.h

@@ -1,9 +1,9 @@
 /**
- * @file lv_gpu_sdl_stack_blur.h
+ * @file lv_draw_sdl_stack_blur.h
  *
  */
-#ifndef LV_GPU_SDL_STACK_BLUR_H
+#ifndef LV_DRAW_SDL_STACK_BLUR_H
-#define LV_GPU_SDL_STACK_BLUR_H
+#define LV_DRAW_SDL_STACK_BLUR_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -39,4 +39,4 @@ void lv_stack_blur_grayscale(lv_opa_t * buf, uint16_t w, uint16_t h, uint16_t r)
 } /*extern "C"*/
 #endif
 
-#endif /*LV_GPU_SDL_STACK_BLUR_H*/
+#endif /*LV_DRAW_SDL_STACK_BLUR_H*/

src/draw/sdl/lv_draw_sdl_texture_cache.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_texture_cache.c
+ * @file lv_draw_sdl_texture_cache.c
  *
  */
 
@@ -11,7 +11,7 @@
 
 #if LV_USE_GPU_SDL
 
-#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_draw_sdl_texture_cache.h"
 
 #include "../../misc/lv_log.h"
 #include "../../draw/lv_draw_label.h"
@@ -29,7 +29,7 @@ typedef struct {
     SDL_Texture * texture;
     void * userdata;
     lv_lru_free_t * userdata_free;
-    lv_gpu_sdl_cache_flag_t flags;
+    lv_draw_sdl_cache_flag_t flags;
 } draw_cache_value_t;
 
 typedef struct {
@@ -60,13 +60,13 @@ static lv_lru_t * lv_sdl_texture_cache;
  *   GLOBAL FUNCTIONS
  **********************/
 
-void _lv_gpu_sdl_texture_cache_init()
+void _lv_draw_sdl_texture_cache_init()
 {
     lv_sdl_texture_cache = lv_lru_new(1024 * 1024 * 8, 65536, (lv_lru_free_t *) draw_cache_free_value,
                                       NULL);
 }
 
-void _lv_gpu_sdl_texture_cache_deinit()
+void _lv_draw_sdl_texture_cache_deinit()
 {
     lv_lru_free(lv_sdl_texture_cache);
 }
@@ -97,13 +97,13 @@ SDL_Texture * lv_gpu_draw_cache_get_with_userdata(const void * key, size_t key_l
     return value->texture;
 }
 
-void lv_gpu_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture)
+void lv_draw_sdl_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture)
 {
-    lv_gpu_draw_cache_put_advanced(key, key_length, texture, NULL, NULL, 0);
+    lv_draw_sdl_draw_cache_put_advanced(key, key_length, texture, NULL, NULL, 0);
 }
 
-void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
+void lv_draw_sdl_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
-                                    lv_lru_free_t userdata_free, lv_gpu_sdl_cache_flag_t flags)
+                                         lv_lru_free_t userdata_free, lv_draw_sdl_cache_flag_t flags)
 {
     draw_cache_value_t * value = SDL_malloc(sizeof(draw_cache_value_t));
     value->texture = texture;
@@ -114,7 +114,7 @@ void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Tex
         lv_lru_set(lv_sdl_texture_cache, key, key_length, value, 1);
         return;
     }
-    if(flags & LV_GPU_SDL_CACHE_FLAG_MANAGED) {
+    if(flags & LV_DRAW_SDL_CACHE_FLAG_MANAGED) {
         /* Managed texture doesn't count into cache size */
         LV_LOG_INFO("cache texture %p, %d*%d@%dbpp", texture, width, height, SDL_BITSPERPIXEL(format));
         lv_lru_set(lv_sdl_texture_cache, key, key_length, value, 1);
@@ -143,13 +143,13 @@ SDL_Texture * lv_gpu_temp_texture_obtain(SDL_Renderer * renderer, lv_coord_t wid
     userdata = SDL_malloc(sizeof(temp_texture_userdata_t));
     userdata->width = width;
     userdata->height = height;
-    lv_gpu_draw_cache_put_advanced(&key, sizeof(key), texture, userdata, SDL_free, 0);
+    lv_draw_sdl_draw_cache_put_advanced(&key, sizeof(key), texture, userdata, SDL_free, 0);
     return texture;
 }
 
-lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size)
+lv_draw_sdl_cache_key_head_img_t * lv_draw_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size)
 {
-    lv_gpu_sdl_cache_key_head_img_t header;
+    lv_draw_sdl_cache_key_head_img_t header;
     /* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
     SDL_memset(&header, 0, sizeof(header));
     header.magic = LV_GPU_CACHE_KEY_MAGIC_IMG;
@@ -173,7 +173,7 @@ lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * s
         SDL_memcpy(key + sizeof(header), &src, sizeof(void *));
     }
     *size = key_size;
-    return (lv_gpu_sdl_cache_key_head_img_t *) key;
+    return (lv_draw_sdl_cache_key_head_img_t *) key;
 }
 
 /**********************
@@ -182,7 +182,7 @@ lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * s
 
 static void draw_cache_free_value(draw_cache_value_t * value)
 {
-    if(value->texture && !(value->flags & LV_GPU_SDL_CACHE_FLAG_MANAGED)) {
+    if(value->texture && !(value->flags & LV_DRAW_SDL_CACHE_FLAG_MANAGED)) {
         LV_LOG_INFO("destroy texture %p", value->texture);
         SDL_DestroyTexture(value->texture);
     }

src/draw/sdl/lv_draw_sdl_texture_cache.h

@@ -1,10 +1,10 @@
 /**
- * @file lv_gpu_sdl_texture_cache.h
+ * @file lv_draw_sdl_texture_cache.h
  *
  */
 
-#ifndef LV_GPU_SDL_TEXTURE_CACHE_H
+#ifndef LV_DRAW_SDL_TEXTURE_CACHE_H
-#define LV_GPU_SDL_TEXTURE_CACHE_H
+#define LV_DRAW_SDL_TEXTURE_CACHE_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -19,13 +19,13 @@ extern "C" {
 #include LV_GPU_SDL_INCLUDE_PATH
 #include "../../draw/lv_img_decoder.h"
 #include "../../misc/lv_area.h"
-#include "lv_gpu_sdl_lru.h"
+#include "lv_draw_sdl_lru.h"
 
 /*********************
  *      DEFINES
  *********************/
 
-#define LV_GPU_SDL_DEC_DSC_TEXTURE_HEAD "@LVSDLTex"
+#define LV_DRAW_SDL_DEC_DSC_TEXTURE_HEAD "@LVSDLTex"
 
 /**********************
  *      TYPEDEFS
@@ -34,7 +34,7 @@ extern "C" {
 typedef struct {
     char head[8];
     SDL_Texture * texture;
-} lv_gpu_sdl_dec_dsc_userdata_t;
+} lv_draw_sdl_dec_dsc_userdata_t;
 
 typedef enum {
     LV_GPU_CACHE_KEY_MAGIC_ARC = 0x01,
@@ -48,36 +48,36 @@ typedef enum {
 } lv_gpu_cache_key_magic_t;
 
 typedef enum {
-    LV_GPU_SDL_CACHE_FLAG_NONE = 0,
+    LV_DRAW_SDL_CACHE_FLAG_NONE = 0,
-    LV_GPU_SDL_CACHE_FLAG_MANAGED = 1,
+    LV_DRAW_SDL_CACHE_FLAG_MANAGED = 1,
-} lv_gpu_sdl_cache_flag_t;
+} lv_draw_sdl_cache_flag_t;
 
 typedef struct {
     lv_gpu_cache_key_magic_t magic;
     lv_img_src_t type;
     int32_t frame_id;
-} lv_gpu_sdl_cache_key_head_img_t;
+} lv_draw_sdl_cache_key_head_img_t;
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
-void _lv_gpu_sdl_texture_cache_init();
+void _lv_draw_sdl_texture_cache_init();
 
-void _lv_gpu_sdl_texture_cache_deinit();
+void _lv_draw_sdl_texture_cache_deinit();
 
 SDL_Texture * lv_gpu_draw_cache_get(const void * key, size_t key_length, bool * found);
 
 SDL_Texture * lv_gpu_draw_cache_get_with_userdata(const void * key, size_t key_length, bool * found, void ** userdata);
 
-void lv_gpu_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture);
+void lv_draw_sdl_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture);
 
-void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
+void lv_draw_sdl_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
-                                    lv_lru_free_t userdata_free, lv_gpu_sdl_cache_flag_t flags);
+                                         lv_lru_free_t userdata_free, lv_draw_sdl_cache_flag_t flags);
 
 SDL_Texture * lv_gpu_temp_texture_obtain(SDL_Renderer * renderer, lv_coord_t width, lv_coord_t height);
 
-lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size);
+lv_draw_sdl_cache_key_head_img_t * lv_draw_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size);
 
 /**********************
  *      MACROS
@@ -87,4 +87,4 @@ lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * s
 } /*extern "C"*/
 #endif
 
-#endif /*LV_GPU_SDL_TEXTURE_CACHE_H*/
+#endif /*LV_DRAW_SDL_TEXTURE_CACHE_H*/

src/draw/sdl/lv_draw_sdl_utils.c

@@ -1,5 +1,5 @@
 /**
- * @file lv_gpu_sdl_utils.c
+ * @file lv_draw_sdl_utils.c
  *
  */
 
@@ -10,8 +10,9 @@
 
 #if LV_USE_GPU_SDL
 
-#include "lv_gpu_sdl_utils.h"
+#include "lv_draw_sdl_utils.h"
 
+#include "../../draw/lv_draw.h"
 #include "../../draw/lv_draw_label.h"
 
 /*********************
@@ -29,6 +30,11 @@
 /**********************
  *  STATIC VARIABLES
  **********************/
+extern const uint8_t _lv_bpp1_opa_table[2];
+extern const uint8_t _lv_bpp2_opa_table[4];
+extern const uint8_t _lv_bpp3_opa_table[8];
+extern const uint8_t _lv_bpp4_opa_table[16];
+extern const uint8_t _lv_bpp8_opa_table[256];
 
 static SDL_Palette * lv_sdl_palette_grayscale1 = NULL;
 static SDL_Palette * lv_sdl_palette_grayscale2 = NULL;
@@ -44,7 +50,7 @@ static SDL_Palette * lv_sdl_palette_grayscale8 = NULL;
  *   GLOBAL FUNCTIONS
  **********************/
 
-void _lv_gpu_sdl_utils_init()
+void _lv_draw_sdl_utils_init()
 {
     lv_sdl_palette_grayscale1 = lv_sdl_alloc_palette_for_bpp(_lv_bpp1_opa_table, 1);
     lv_sdl_palette_grayscale2 = lv_sdl_alloc_palette_for_bpp(_lv_bpp2_opa_table, 2);
@@ -53,7 +59,7 @@ void _lv_gpu_sdl_utils_init()
     lv_sdl_palette_grayscale8 = lv_sdl_alloc_palette_for_bpp(_lv_bpp8_opa_table, 8);
 }
 
-void _lv_gpu_sdl_utils_deinit()
+void _lv_draw_sdl_utils_deinit()
 {
     SDL_FreePalette(lv_sdl_palette_grayscale1);
     SDL_FreePalette(lv_sdl_palette_grayscale2);
@@ -117,20 +123,29 @@ SDL_Palette * lv_sdl_alloc_palette_for_bpp(const uint8_t * mapping, uint8_t bpp)
 
 SDL_Palette * lv_sdl_get_grayscale_palette(uint8_t bpp)
 {
+    SDL_Palette * palette;
     switch(bpp) {
         case 1:
-            return lv_sdl_palette_grayscale1;
+            palette = lv_sdl_palette_grayscale1;
+            break;
         case 2:
-            return lv_sdl_palette_grayscale2;
+            palette = lv_sdl_palette_grayscale2;
+            break;
         case 3:
-            return lv_sdl_palette_grayscale3;
+            palette = lv_sdl_palette_grayscale3;
+            break;
         case 4:
-            return lv_sdl_palette_grayscale4;
+            palette = lv_sdl_palette_grayscale4;
+            break;
         case 8:
-            return lv_sdl_palette_grayscale8;
+            palette = lv_sdl_palette_grayscale8;
-    }
+            break;
+        default:
             return NULL;
     }
+    LV_ASSERT_MSG(lv_sdl_palette_grayscale8, "lv_draw_sdl was not initialized properly");
+    return palette;
+}
 
 void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp)
 {
@@ -172,6 +187,11 @@ void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height,
     }
 }
 
+lv_draw_sdl_backend_context_t * lv_draw_sdl_get_context()
+{
+    return lv_draw_backend_get()->ctx;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/

src/draw/sdl/lv_draw_sdl_utils.h

@@ -1,9 +1,9 @@
 /**
- * @file lv_gpu_sdl_utils.h
+ * @file lv_draw_sdl_utils.h
  *
  */
-#ifndef LV_GPU_SDL_UTILS_H
+#ifndef LV_DRAW_SDL_UTILS_H
-#define LV_GPU_SDL_UTILS_H
+#define LV_DRAW_SDL_UTILS_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,14 +27,17 @@ extern "C" {
 /**********************
  *      TYPEDEFS
  **********************/
-
+typedef struct lv_draw_sdl_backend_context_t {
+    SDL_Renderer * renderer;
+    SDL_Texture * texture;
+} lv_draw_sdl_backend_context_t;
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
-void _lv_gpu_sdl_utils_init();
+void _lv_draw_sdl_utils_init();
 
-void _lv_gpu_sdl_utils_deinit();
+void _lv_draw_sdl_utils_deinit();
 
 void lv_area_to_sdl_rect(const lv_area_t * in, SDL_Rect * out);
 
@@ -50,6 +53,8 @@ SDL_Palette * lv_sdl_get_grayscale_palette(uint8_t bpp);
 
 void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp);
 
+lv_draw_sdl_backend_context_t * lv_draw_sdl_get_context();
+
 /**********************
  *      MACROS
  **********************/
@@ -58,4 +63,4 @@ void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height,
 } /*extern "C"*/
 #endif
 
-#endif /*LV_GPU_SDL_UTILS_H*/
+#endif /*LV_DRAW_SDL_UTILS_H*/

src/draw/sw/lv_draw_sw_rect.c

@@ -26,7 +26,6 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-#if LV_USE_EXTERNAL_RENDERER == 0
 LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip_area,
                                           const lv_draw_rect_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip,
@@ -53,7 +52,6 @@ static void draw_border_simple(const lv_area_t * clip, const lv_area_t * outer_a
 #if LV_DRAW_COMPLEX
     LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
 #endif
-#endif
 
 /**********************
  *  STATIC VARIABLES

src/gpu/lv_gpu_sdl.c

@@ -13,13 +13,29 @@
 #if LV_USE_GPU_SDL
 
 #include "lv_gpu_sdl.h"
-#include "sdl/lv_gpu_sdl_utils.h"
+#include "../draw/sdl/lv_draw_sdl_utils.h"
-#include "sdl/lv_gpu_sdl_texture_cache.h"
+#include "../draw/sdl/lv_draw_sdl_texture_cache.h"
+
+#include "../draw/sw/lv_draw_sw.h"
 
 /*********************
  *      DEFINES
  *********************/
+void lv_draw_sdl_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc);
 
+lv_res_t lv_draw_sdl_img_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
+                              const lv_draw_img_dsc_t * draw_dsc);
+
+void lv_draw_sdl_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
+                             const lv_font_t * font_p, uint32_t letter, lv_color_t color, lv_opa_t opa,
+                             lv_blend_mode_t blend_mode);
+
+void lv_draw_sdl_draw_blend_fill(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * fill_area,
+                                 lv_color_t color, lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode);
+
+void lv_draw_sdl_draw_blend_map(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * clip_area,
+                                const lv_color_t * src_buf, const lv_area_t * src_area,
+                                lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode);
 /**********************
  *      TYPEDEFS
  **********************/
@@ -42,15 +58,34 @@
 
 void lv_gpu_sdl_init()
 {
-    _lv_gpu_sdl_utils_init();
+    _lv_draw_sdl_utils_init();
-    _lv_gpu_sdl_texture_cache_init();
+    _lv_draw_sdl_texture_cache_init();
 }
 
 void lv_gpu_sdl_deinit()
 {
-    _lv_gpu_sdl_texture_cache_deinit();
+    _lv_draw_sdl_texture_cache_deinit();
-    _lv_gpu_sdl_utils_deinit();
+    _lv_draw_sdl_utils_deinit();
 }
+
+void lv_gpu_sdl_backend_init(lv_draw_backend_t * backend, SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    lv_draw_backend_init(backend);
+    lv_draw_sdl_backend_context_t * ctx = lv_mem_alloc(sizeof(lv_draw_sdl_backend_context_t));
+    lv_memset_00(ctx, sizeof(lv_draw_sdl_backend_context_t));
+    ctx->renderer = renderer;
+    ctx->texture = texture;
+    backend->ctx = ctx;
+    backend->draw_rect = lv_draw_sdl_draw_rect;
+    backend->draw_arc = lv_draw_sw_arc;
+    backend->draw_img_core = lv_draw_sdl_img_core;
+    backend->draw_letter = lv_draw_sdl_draw_letter;
+    backend->draw_line = lv_draw_sw_line;
+    backend->draw_polygon = lv_draw_sw_polygon;
+    backend->blend_fill = lv_draw_sdl_draw_blend_fill;
+    backend->blend_map = lv_draw_sdl_draw_blend_map;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/

src/gpu/lv_gpu_sdl.h

@@ -24,6 +24,8 @@ extern "C" {
 
 #include LV_GPU_SDL_INCLUDE_PATH
 
+#include "../draw/lv_draw.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -44,6 +46,8 @@ void lv_gpu_sdl_init();
  */
 void lv_gpu_sdl_deinit();
 
+void lv_gpu_sdl_backend_init(lv_draw_backend_t * backend, SDL_Renderer * renderer, SDL_Texture * texture);
+
 /*======================
  * Add/remove functions
  *=====================*/

src/gpu/sdl/lv_gpu_sdl.mk

@@ -1,16 +0,0 @@
-CSRCS += lv_gpu_sdl_draw_arc.c
-CSRCS += lv_gpu_sdl_draw_blend.c
-CSRCS += lv_gpu_sdl_draw_img.c
-CSRCS += lv_gpu_sdl_draw_label.c
-CSRCS += lv_gpu_sdl_draw_line.c
-CSRCS += lv_gpu_sdl_draw_rect.c
-CSRCS += lv_gpu_sdl_lru.c
-CSRCS += lv_gpu_sdl_mask.c
-CSRCS += lv_gpu_sdl_stack_blur.c
-CSRCS += lv_gpu_sdl_texture_cache.c
-CSRCS += lv_gpu_sdl_utils.c
-
-DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
-VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
-
-CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl"

src/gpu/sdl/lv_gpu_sdl_draw_arc.c

@@ -1,163 +0,0 @@
-/**
- * @file lv_gpu_sdl_draw_arc.c
- *
- * This implementation does not functioning properly so it's not enabled
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "../../lv_conf_internal.h"
-
-#if LV_USE_GPU_SDL
-
-#include "../../hal/lv_hal_disp.h"
-#include "../../core/lv_refr.h"
-#include "../../draw/lv_draw_arc.h"
-#include "lv_gpu_sdl_utils.h"
-#include "lv_gpu_sdl_lru.h"
-#include "lv_gpu_sdl_texture_cache.h"
-#include "lv_gpu_sdl_mask.h"
-
-#ifndef M_PI
-    #include <math.h>
-#endif
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-typedef struct {
-    lv_gpu_cache_key_magic_t magic;
-    uint16_t radius;
-    uint16_t angle;
-    lv_coord_t width;
-    uint8_t rounded;
-} lv_draw_arc_key_t;
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-void lv_draw_arc2(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, uint16_t start_angle, uint16_t end_angle,
-                  const lv_area_t * clip_area, const lv_draw_arc_dsc_t * dsc)
-{
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    lv_disp_drv_t * driver = disp->driver;
-    SDL_Renderer * renderer = (SDL_Renderer *) driver->user_data;
-
-    lv_area_t area_out;
-    area_out.x1 = center_x - radius;
-    area_out.y1 = center_y - radius;
-    area_out.x2 = center_x + radius - 1;  /*-1 because the center already belongs to the left/bottom part*/
-    area_out.y2 = center_y + radius - 1;
-
-    lv_area_t area_in;
-    lv_area_copy(&area_in, &area_out);
-    area_in.x1 += dsc->width;
-    area_in.y1 += dsc->width;
-    area_in.x2 -= dsc->width;
-    area_in.y2 -= dsc->width;
-
-    /*Increase 1 px each side to texture, to have better rotation result*/
-    lv_area_t texture_area_out;
-    lv_area_copy(&texture_area_out, &area_out);
-    lv_area_increase(&texture_area_out, 1, 1);
-
-    SDL_Rect area_out_rect, clip_rect;
-    lv_area_to_sdl_rect(&texture_area_out, &area_out_rect);
-    lv_area_to_sdl_rect(clip_area, &clip_rect);
-
-    lv_draw_arc_key_t key = {
-        .magic = LV_GPU_CACHE_KEY_MAGIC_ARC,
-        .radius = radius,
-        .angle = ((end_angle - start_angle) % 360 + 360) % 360,
-        .width = dsc->width,
-        .rounded = dsc->rounded,
-    };
-    //    SDL_Texture *texture = lv_gpu_draw_cache_get(&key, sizeof(key));
-    SDL_Texture * texture = NULL;
-    if(texture == NULL) {
-        /*Create inner the mask*/
-        lv_draw_mask_radius_param_t mask_in_param;
-        lv_draw_mask_radius_init(&mask_in_param, &area_in, LV_RADIUS_CIRCLE, true);
-        int16_t mask_in_id = lv_draw_mask_add(&mask_in_param, NULL);
-
-        lv_draw_mask_radius_param_t mask_out_param;
-        lv_draw_mask_radius_init(&mask_out_param, &area_out, LV_RADIUS_CIRCLE, false);
-        int16_t mask_out_id = lv_draw_mask_add(&mask_out_param, NULL);
-
-        SDL_Surface * ark_mask;
-        if(key.angle < 360) {
-            while(start_angle >= 360) start_angle -= 360;
-            while(end_angle >= 360) end_angle -= 360;
-            lv_draw_mask_angle_param_t mask_angle_param;
-            lv_draw_mask_angle_init(&mask_angle_param, center_x, center_y, 0, key.angle);
-            int16_t mask_angle_id = lv_draw_mask_add(&mask_angle_param, NULL);
-            ark_mask = lv_sdl_apply_mask_surface(&texture_area_out, NULL, 0);
-            lv_draw_mask_remove_id(mask_angle_id);
-        }
-        else {
-            ark_mask = lv_sdl_apply_mask_surface(&texture_area_out, NULL, 0);
-        }
-        lv_draw_mask_remove_id(mask_out_id);
-        lv_draw_mask_remove_id(mask_in_id);
-
-        if(dsc->rounded) {
-            SDL_Renderer * mask_renderer = SDL_CreateSoftwareRenderer(ark_mask);
-            lv_area_t cap_area = {.x1 = 0, .y1 = 0};
-            lv_area_set_width(&cap_area, dsc->width);
-            lv_area_set_height(&cap_area, dsc->width);
-
-            lv_draw_mask_radius_param_t mask_rout_param;
-            lv_draw_mask_radius_init(&mask_rout_param, &cap_area, LV_RADIUS_CIRCLE, false);
-            int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-            SDL_Texture * round_texture = lv_sdl_gen_mask_texture(mask_renderer, &cap_area, &mask_rout_id, 1);
-            lv_draw_mask_remove_id(mask_rout_id);
-
-            SDL_SetTextureBlendMode(round_texture, SDL_BLENDMODE_BLEND);
-            float mid_point = radius - key.width / 2.0f;
-            SDL_Rect cap_dst;
-            cap_dst.w = lv_area_get_width(&cap_area);
-            cap_dst.h = lv_area_get_height(&cap_area);
-            cap_dst.x = mid_point + lv_sdl_round(SDL_cos(0) * mid_point);
-            cap_dst.y = mid_point + lv_sdl_round(SDL_sin(0) * mid_point);
-            SDL_RenderCopy(mask_renderer, round_texture, NULL, &cap_dst);
-            cap_dst.x = mid_point + lv_sdl_round(SDL_cos(key.angle * M_PI / 180.0f) * mid_point);
-            cap_dst.y = mid_point + lv_sdl_round(SDL_sin(key.angle * M_PI / 180.0f) * mid_point);
-            SDL_RenderCopy(mask_renderer, round_texture, NULL, &cap_dst);
-            SDL_DestroyTexture(round_texture);
-            SDL_DestroyRenderer(mask_renderer);
-        }
-        texture = SDL_CreateTextureFromSurface(renderer, ark_mask);
-        SDL_FreeSurface(ark_mask);
-
-        SDL_assert(texture);
-        //        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
-    }
-
-    SDL_Color arc_color;
-    lv_color_to_sdl_color(&dsc->color, &arc_color);
-    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
-    SDL_SetTextureAlphaMod(texture, dsc->opa);
-    SDL_SetTextureColorMod(texture, arc_color.r, arc_color.g, arc_color.b);
-    SDL_RenderSetClipRect(renderer, &clip_rect);
-    SDL_RenderCopyEx(renderer, texture, NULL, &area_out_rect, start_angle, NULL, SDL_FLIP_NONE);
-    SDL_DestroyTexture(texture);
-}
-
-#endif /*LV_USE_GPU_SDL*/

src/gpu/sdl/lv_gpu_sdl_draw_blend.c

@@ -1,102 +0,0 @@
-/**
- * @file lv_gpu_sdl_draw_blend.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "../../lv_conf_internal.h"
-
-#if LV_USE_GPU_SDL
-
-#include "../../draw/lv_draw_blend.h"
-#include "../../core/lv_refr.h"
-#include "lv_gpu_sdl_texture_cache.h"
-#include "lv_gpu_sdl_utils.h"
-#include "lv_gpu_sdl_mask.h"
-
-#include LV_GPU_SDL_INCLUDE_PATH
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-void lv_draw_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area, lv_color_t color,
-                        lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode)
-{
-    /*Do not draw transparent things*/
-    if(opa < LV_OPA_MIN) return;
-    if(mask_res == LV_DRAW_MASK_RES_TRANSP) return;
-
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
-
-    /*Get clipped fill area which is the real draw area.
-     *It is always the same or inside `fill_area`*/
-    lv_area_t draw_area;
-    if(!_lv_area_intersect(&draw_area, clip_area, fill_area)) return;
-
-    SDL_Rect draw_area_rect;
-    lv_area_to_sdl_rect(&draw_area, &draw_area_rect);
-    if(mask) {
-        SDL_Surface * mask_surface = lv_sdl_create_mask_surface(mask, lv_area_get_width(&draw_area),
-                                                                lv_area_get_height(&draw_area),
-                                                                lv_area_get_width(&draw_area));
-        SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, mask_surface);
-        SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
-        SDL_SetTextureAlphaMod(texture, opa);
-        SDL_SetTextureColorMod(texture, color.ch.red, color.ch.green, color.ch.blue);
-        SDL_RenderSetClipRect(renderer, &draw_area_rect);
-        SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
-        SDL_DestroyTexture(texture);
-        SDL_FreeSurface(mask_surface);
-    }
-    else {
-        SDL_SetRenderDrawColor(renderer, color.ch.red, color.ch.green, color.ch.blue, opa);
-        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
-        SDL_RenderSetClipRect(renderer, &draw_area_rect);
-        SDL_RenderFillRect(renderer, &draw_area_rect);
-    }
-}
-
-void lv_draw_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
-                       const lv_color_t * map_buf, lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa,
-                       lv_blend_mode_t mode)
-{
-    LV_UNUSED(clip_area);
-    LV_UNUSED(map_area);
-    LV_UNUSED(map_buf);
-    LV_UNUSED(mask);
-    LV_UNUSED(mask_res);
-    LV_UNUSED(opa);
-    LV_UNUSED(mode);
-
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#endif /*LV_USE_GPU_SDL*/

src/gpu/sdl/lv_gpu_sdl_draw_line.c

@@ -1,158 +0,0 @@
-/**
- * @file lv_gpu_sdl_draw_line.c
- *
- * This implementation does not functioning properly so it's not enabled
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "../../lv_conf_internal.h"
-
-#if LV_USE_GPU_SDL
-
-#include LV_GPU_SDL_INCLUDE_PATH
-#include "../../core/lv_refr.h"
-#include "lv_gpu_sdl_utils.h"
-#include "lv_gpu_sdl_lru.h"
-#include "lv_gpu_sdl_texture_cache.h"
-#include "lv_gpu_sdl_mask.h"
-
-#ifndef M_PI
-    #include <math.h>
-#endif
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-typedef struct {
-    lv_gpu_cache_key_magic_t magic;
-    lv_coord_t length;
-    lv_coord_t thickness;
-} lv_draw_line_key_t;
-
-static lv_draw_line_key_t line_key_create(lv_coord_t length, lv_coord_t thickness);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-void lv_draw_line2(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * clip,
-                   const lv_draw_line_dsc_t * dsc)
-{
-    if(dsc->width == 0) return;
-    if(dsc->opa <= LV_OPA_MIN) return;
-
-    if(point1->x == point2->x && point1->y == point2->y) return;
-
-    lv_area_t clip_line;
-    clip_line.x1 = LV_MIN(point1->x, point2->x) - dsc->width / 2;
-    clip_line.x2 = LV_MAX(point1->x, point2->x) + dsc->width / 2;
-    clip_line.y1 = LV_MIN(point1->y, point2->y) - dsc->width / 2;
-    clip_line.y2 = LV_MAX(point1->y, point2->y) + dsc->width / 2;
-
-    if(!_lv_area_intersect(&clip_line, &clip_line, clip)) return;
-
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
-
-    SDL_Color line_color;
-    lv_color_to_sdl_color(&dsc->color, &line_color);
-
-    int length = lv_sdl_round(SDL_sqrt(SDL_pow(point2->y - point1->y + 1, 2) + SDL_pow(point2->x - point1->x + 1, 2)));
-    lv_coord_t thickness = dsc->width;
-    lv_draw_line_key_t key = line_key_create(length, thickness);
-    lv_area_t coords = {1, 1, length, dsc->width};
-    lv_area_t tex_coords;
-    lv_area_copy(&tex_coords, &coords);
-    lv_area_increase(&tex_coords, 1, 1);
-
-    SDL_Texture * texture = lv_gpu_draw_cache_get(&key, sizeof(key), NULL);
-
-    if(texture == NULL) {
-        lv_draw_mask_radius_param_t mask_rout_param;
-        lv_draw_mask_radius_init(&mask_rout_param, &coords, 0, false);
-        int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-        texture = lv_sdl_gen_mask_texture(renderer, &tex_coords, &mask_rout_id, 1);
-        lv_draw_mask_remove_id(mask_rout_id);
-        SDL_assert(texture);
-        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
-    }
-    double angle = SDL_atan2(point2->y - point1->y, point2->x - point1->x) * 180 / M_PI;
-
-    SDL_Rect clip_rect;
-    lv_area_to_sdl_rect(&clip_line, &clip_rect);
-
-
-    SDL_Texture * screen = SDL_GetRenderTarget(renderer);
-
-    SDL_Texture * content = lv_gpu_temp_texture_obtain(renderer, clip_rect.w, clip_rect.h);
-    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_BLEND);
-    SDL_SetRenderTarget(renderer, content);
-    SDL_RenderSetClipRect(renderer, NULL);
-
-    //    /* Replace texture with clip mask */
-    SDL_Rect mask_rect = {.w = clip_rect.w, .h = clip_rect.h, .x = 0, .y = 0};
-    //    SDL_Texture *mask = lv_sdl_gen_mask_texture(renderer, &clip_line, NULL, 0);
-    //    SDL_SetTextureBlendMode(mask, SDL_BLENDMODE_NONE);
-    ////    SDL_RenderCopy(renderer, mask, NULL, &mask_rect);
-    //
-    //    SDL_SetTextureAlphaMod(texture, 0xFF);
-    //    SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF);
-    //#if SDL_VERSION_ATLEAST(2, 0, 6)
-    //    SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO,
-    //                                                    SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_ZERO,
-    //                                                    SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD);
-    //    SDL_SetTextureBlendMode(texture, mode);
-    //    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE);
-    //#else
-    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE);
-    //#endif
-
-    SDL_Rect coords_rect;
-    lv_area_to_sdl_rect(&tex_coords, &coords_rect);
-    coords_rect.x = 0 - coords_rect.h / 2;
-    coords_rect.y = 0 - coords_rect.h / 2;
-    SDL_Point center = {coords_rect.h / 2, coords_rect.h / 2};
-    SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, angle, &center, SDL_FLIP_NONE);
-    //
-    //    /* Draw composited part on screen */
-    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_NONE);
-    SDL_SetTextureAlphaMod(content, dsc->opa);
-    SDL_SetTextureColorMod(content, line_color.r, line_color.g, line_color.b);
-    //
-    SDL_SetRenderTarget(renderer, screen);
-    //    SDL_RenderSetClipRect(renderer, &clip_rect);
-    SDL_RenderSetClipRect(renderer, NULL);
-    SDL_RenderCopy(renderer, content, &mask_rect, &clip_rect);
-    //    SDL_DestroyTexture(mask);
-}
-
-static lv_draw_line_key_t line_key_create(lv_coord_t length, lv_coord_t thickness)
-{
-    lv_draw_line_key_t key;
-    /* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
-    SDL_memset(&key, 0, sizeof(key));
-    key.magic = LV_GPU_CACHE_KEY_MAGIC_LINE;
-    key.length = length;
-    key.thickness = thickness;
-    return key;
-}
-
-
-#endif /*LV_USE_GPU_SDL*/