diff --git a/demos/widgets/lv_demo_widgets.c b/demos/widgets/lv_demo_widgets.c index 839b999c05..d0175f7b64 100644 --- a/demos/widgets/lv_demo_widgets.c +++ b/demos/widgets/lv_demo_widgets.c @@ -1342,7 +1342,7 @@ static void chart_event_cb(lv_event_t * e) /*Add the faded area before the lines are drawn */ else if(dsc->part == LV_PART_ITEMS) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Add a line mask that keeps the area below the line*/ if(dsc->p1 && dsc->p2) { lv_draw_mask_line_param_t line_mask_param; diff --git a/env_support/cmsis-pack/lv_conf_cmsis.h b/env_support/cmsis-pack/lv_conf_cmsis.h index cec0fc8e7b..c45cc3f6d3 100644 --- a/env_support/cmsis-pack/lv_conf_cmsis.h +++ b/env_support/cmsis-pack/lv_conf_cmsis.h @@ -38,10 +38,10 @@ MEMORY SETTINGS *=========================*/ -/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/ +/*1: use custom malloc/free, 0: use the built-in `lv_malloc()` and `lv_free()`*/ #define LV_MEM_CUSTOM 0 #if LV_MEM_CUSTOM == 0 - /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/ + /*Size of the memory available for `lv_malloc()` in bytes (>= 2kB)*/ #define LV_MEM_SIZE (64U * 1024U) /*[bytes]*/ /*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/ @@ -112,20 +112,20 @@ /*Enable complex draw engine. *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ -#define LV_DRAW_COMPLEX 1 -#if LV_DRAW_COMPLEX != 0 +#define LV_DRAW_SW_COMPLEX 1 +#if LV_DRAW_SW_COMPLEX != 0 /*Allow buffering some shadow calculation. - *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` - *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/ - #define LV_SHADOW_CACHE_SIZE 0 + *LV_DRAW_SW_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` + *Caching has LV_DRAW_SW_SHADOW_CACHE_SIZE^2 RAM cost*/ + #define LV_DRAW_SW_SHADOW_CACHE_SIZE 0 /* Set number of maximally cached circle data. * The circumference of 1/4 circle are saved for anti-aliasing * radius * 4 bytes are used per circle (the most often used radiuses are saved) * 0: to disable caching */ - #define LV_CIRCLE_CACHE_SIZE 4 -#endif /*LV_DRAW_COMPLEX*/ + #define LV_DRAW_SW_CIRCLE_CACHE_SIZE 4 +#endif /*LV_DRAW_SW_COMPLEX*/ /** * "Simple layers" are used when a widget has `style_opa < 255` to buffer the widget into a layer @@ -133,15 +133,15 @@ * Note that `bg_opa`, `text_opa` etc don't require buffering into layer) * The widget can be buffered in smaller chunks to avoid using large buffers. * - * - LV_LAYER_SIMPLE_BUF_SIZE: [bytes] the optimal target buffer size. LVGL will try to allocate it - * - LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE: [bytes] used if `LV_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated. + * - LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE: [bytes] the optimal target buffer size. LVGL will try to allocate it + * - LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE: [bytes] used if `LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated. * * Both buffer sizes are in bytes. * "Transformed layers" (where transform_angle/zoom properties are used) use larger buffers * and can't be drawn in chunks. So these settings affects only widgets with opacity. */ -#define LV_LAYER_SIMPLE_BUF_SIZE (24 * 1024) -#define LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) +#define LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE (24 * 1024) +#define LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) /*Default image cache size. Image caching keeps the images opened. *If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added) @@ -156,20 +156,20 @@ /*Default gradient buffer size. *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. - *LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes. + *LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE sets the size of this cache in bytes. *If the cache is too small the map will be allocated only while it's required for the drawing. *0 mean no caching.*/ -#define LV_GRAD_CACHE_DEF_SIZE 0 +#define LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE 0 /*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) - *LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface + *LV_DRAW_SW_GRADIENT_DITHER implies allocating one or two more lines of the object's rendering surface *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ -#define LV_DITHER_GRADIENT 0 -#if LV_DITHER_GRADIENT +#define LV_DRAW_SW_GRADIENT_DITHER 0 +#if LV_DRAW_SW_GRADIENT_DITHER /*Add support for error diffusion dithering. *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. *The increase in memory consumption is (24 bits * object's width)*/ - #define LV_DITHER_ERROR_DIFFUSION 0 + #define LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION 0 #endif /*Maximum buffer size to allocate for rotation. @@ -203,13 +203,13 @@ #endif /*Use SDL renderer API*/ -#define LV_USE_GPU_SDL 0 -#if LV_USE_GPU_SDL - #define LV_GPU_SDL_INCLUDE_PATH +#define LV_USE_DRAW_SDL 0 +#if LV_USE_DRAW_SDL + #define LV_DARW_SDL_INCLUDE_PATH /*Texture cache size, 8MB by default*/ - #define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8) + #define LV_DARW_SDL_LRU_SIZE (1024 * 1024 * 8) /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ - #define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) + #define LV_DARW_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) #endif /*------------- @@ -397,10 +397,10 @@ #define LV_USE_FONT_COMPRESSED 0 /*Enable subpixel rendering*/ -#define LV_USE_FONT_SUBPX 0 -#if LV_USE_FONT_SUBPX +#define LV_DRAW_SW_FONT_SUBPX 0 +#if LV_DRAW_SW_FONT_SUBPX /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ - #define LV_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ + #define LV_DRAW_SW_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ #endif /*Enable drawing placeholders when glyph dsc is not found*/ diff --git a/examples/widgets/chart/lv_example_chart_2.c b/examples/widgets/chart/lv_example_chart_2.c index a10f6f9e99..9e45d3d5f3 100644 --- a/examples/widgets/chart/lv_example_chart_2.c +++ b/examples/widgets/chart/lv_example_chart_2.c @@ -1,5 +1,5 @@ #include "../../lv_examples.h" -#if LV_USE_CHART && LV_DRAW_COMPLEX && LV_BUILD_EXAMPLES +#if LV_USE_CHART && LV_USE_DRAW_MASKS && LV_BUILD_EXAMPLES static lv_obj_t * chart1; static lv_chart_series_t * ser1; diff --git a/examples/widgets/chart/lv_example_chart_8.c b/examples/widgets/chart/lv_example_chart_8.c index ca2c8f8cbd..5087a69db5 100644 --- a/examples/widgets/chart/lv_example_chart_8.c +++ b/examples/widgets/chart/lv_example_chart_8.c @@ -1,5 +1,5 @@ #include "../../lv_examples.h" -#if LV_USE_CHART && LV_DRAW_COMPLEX && LV_BUILD_EXAMPLES +#if LV_USE_CHART && LV_USE_DRAW_MASKS && LV_BUILD_EXAMPLES /* A struct is used to keep track of the series list because later we need to draw to the series in the reverse order to which they were initialised. */ typedef struct { diff --git a/examples/widgets/chart/lv_example_chart_9.c b/examples/widgets/chart/lv_example_chart_9.c index c94b564fa3..e7832ce51b 100644 --- a/examples/widgets/chart/lv_example_chart_9.c +++ b/examples/widgets/chart/lv_example_chart_9.c @@ -1,5 +1,5 @@ #include "../../lv_examples.h" -#if LV_USE_CHART && LV_DRAW_COMPLEX && LV_BUILD_EXAMPLES +#if LV_USE_CHART && LV_USE_DRAW_MASKS && LV_BUILD_EXAMPLES static void add_data(lv_timer_t * t) diff --git a/examples/widgets/label/lv_example_label_4.c b/examples/widgets/label/lv_example_label_4.c index 68b456af25..c30845e699 100644 --- a/examples/widgets/label/lv_example_label_4.c +++ b/examples/widgets/label/lv_example_label_4.c @@ -1,5 +1,5 @@ #include "../../lv_examples.h" -#if LV_USE_LABEL && LV_USE_CANVAS && LV_BUILD_EXAMPLES && LV_DRAW_COMPLEX +#if LV_USE_LABEL && LV_USE_CANVAS && LV_BUILD_EXAMPLES && LV_USE_DRAW_MASKS #define MASK_WIDTH 100 #define MASK_HEIGHT 45 diff --git a/examples/widgets/roller/lv_example_roller_3.c b/examples/widgets/roller/lv_example_roller_3.c index c1e70ff8f5..c097f85782 100644 --- a/examples/widgets/roller/lv_example_roller_3.c +++ b/examples/widgets/roller/lv_example_roller_3.c @@ -1,5 +1,5 @@ #include "../../lv_examples.h" -#if LV_USE_ROLLER && LV_DRAW_COMPLEX && LV_BUILD_EXAMPLES +#if LV_USE_ROLLER && LV_USE_DRAW_MASKS && LV_BUILD_EXAMPLES static void mask_event_cb(lv_event_t * e) { @@ -28,14 +28,14 @@ static void mask_event_cb(lv_event_t * e) rect_area.y1 = roller_coords.y1; rect_area.y2 = roller_coords.y1 + (lv_obj_get_height(obj) - font_h - line_space) / 2; - lv_draw_mask_fade_param_t * fade_mask_top = lv_mem_buf_get(sizeof(lv_draw_mask_fade_param_t)); + lv_draw_mask_fade_param_t * fade_mask_top = lv_malloc(sizeof(lv_draw_mask_fade_param_t)); lv_draw_mask_fade_init(fade_mask_top, &rect_area, LV_OPA_TRANSP, rect_area.y1, LV_OPA_COVER, rect_area.y2); mask_top_id = lv_draw_mask_add(fade_mask_top, NULL); rect_area.y1 = rect_area.y2 + font_h + line_space - 1; rect_area.y2 = roller_coords.y2; - lv_draw_mask_fade_param_t * fade_mask_bottom = lv_mem_buf_get(sizeof(lv_draw_mask_fade_param_t)); + lv_draw_mask_fade_param_t * fade_mask_bottom = lv_malloc(sizeof(lv_draw_mask_fade_param_t)); lv_draw_mask_fade_init(fade_mask_bottom, &rect_area, LV_OPA_COVER, rect_area.y1, LV_OPA_TRANSP, rect_area.y2); mask_bottom_id = lv_draw_mask_add(fade_mask_bottom, NULL); @@ -45,8 +45,8 @@ static void mask_event_cb(lv_event_t * e) lv_draw_mask_fade_param_t * fade_mask_bottom = lv_draw_mask_remove_id(mask_bottom_id); lv_draw_mask_free_param(fade_mask_top); lv_draw_mask_free_param(fade_mask_bottom); - lv_mem_buf_release(fade_mask_top); - lv_mem_buf_release(fade_mask_bottom); + lv_free(fade_mask_top); + lv_free(fade_mask_bottom); mask_top_id = -1; mask_bottom_id = -1; } diff --git a/lv_conf_template.h b/lv_conf_template.h index 3392da779f..46558bac10 100644 --- a/lv_conf_template.h +++ b/lv_conf_template.h @@ -26,30 +26,17 @@ /*Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888)*/ #define LV_COLOR_DEPTH 16 -/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/ -#define LV_COLOR_16_SWAP 0 - -/*Enable features to draw on transparent background. - *It's required if opa, and transform_* style properties are used. - *Can be also used if the UI is above another layer, e.g. an OSD menu or video player.*/ -#define LV_COLOR_SCREEN_TRANSP 0 - -/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently. - * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */ -#define LV_COLOR_MIX_ROUND_OFS 0 - -/*Images pixels with this color will not be drawn if they are chroma keyed)*/ -#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) /*pure green*/ +#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) /*========================= - MEMORY SETTINGS + STDLIB WRAPPER SETTINGS *=========================*/ -/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/ -#define LV_MEM_CUSTOM 0 -#if LV_MEM_CUSTOM == 0 - /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/ - #define LV_MEM_SIZE (48U * 1024U) /*[bytes]*/ +/*Enable and configure the built-in memory manager*/ +#define LV_USE_BUILTIN_MALLOC 1 +#if LV_USE_BUILTIN_MALLOC + /*Size of the memory available for `lv_malloc()` in bytes (>= 2kB)*/ + #define LV_MEM_SIZE (128U * 1024U) /*[bytes]*/ /*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/ #define LV_MEM_ADR 0 /*0: unused*/ @@ -58,31 +45,29 @@ #undef LV_MEM_POOL_INCLUDE #undef LV_MEM_POOL_ALLOC #endif +#endif /*LV_USE_BUILTIN_MALLOC*/ -#else /*LV_MEM_CUSTOM*/ - #define LV_MEM_CUSTOM_INCLUDE /*Header for the dynamic memory function*/ - #define LV_MEM_CUSTOM_ALLOC malloc - #define LV_MEM_CUSTOM_FREE free - #define LV_MEM_CUSTOM_REALLOC realloc -#endif /*LV_MEM_CUSTOM*/ +/*Enable and configure the built-in (v)snprintf */ +#define LV_USE_BUILTIN_SNPRINTF 1 +#if LV_USE_BUILTIN_SNPRINTF + #define LV_SPRINTF_USE_FLOAT 0 +#endif /*LV_USE_BUILTIN_SNPRINTF*/ -/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms. - *You will see an error log message if there wasn't enough buffers. */ -#define LV_MEM_BUF_MAX_NUM 16 - -/*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/ -#define LV_MEMCPY_MEMSET_STD 0 +#define LV_STDLIB_INCLUDE +#define LV_MALLOC lv_malloc_builtin +#define LV_REALLOC lv_realloc_builtin +#define LV_FREE lv_free_builtin +#define LV_MEMSET lv_memset_builtin +#define LV_MEMCPY lv_memcpy_builtin +#define LV_SNPRINTF lv_snprintf_builtin +#define LV_VSNPRINTF lv_vsnprintf_builtin +#define LV_STRLEN lv_strlen_builtin +#define LV_STRNCPY lv_strncpy_builtin /*==================== HAL SETTINGS *====================*/ -/*Default display refresh period. LVG will redraw changed areas with this period time*/ -#define LV_DISP_DEF_REFR_PERIOD 30 /*[ms]*/ - -/*Input device read period in milliseconds*/ -#define LV_INDEV_DEF_READ_PERIOD 30 /*[ms]*/ - /*Use a custom tick source that tells the elapsed time in milliseconds. *It removes the need to manually update the tick with `lv_tick_inc()`)*/ #define LV_TICK_CUSTOM 0 @@ -95,83 +80,82 @@ *(Not so important, you can adjust it to modify default sizes and spaces)*/ #define LV_DPI_DEF 130 /*[px/inch]*/ -/*======================= - * FEATURE CONFIGURATION - *=======================*/ +/*======================== + * DRAW CONFIGURATION + *========================*/ -/*------------- - * Drawing - *-----------*/ +/*Enable the built in mask engine. + *Required to draw shadow, rounded corners, circles, arc, skew lines, or any other masks*/ +#define LV_USE_DRAW_MASKS 1 -/*Enable complex draw engine. - *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ -#define LV_DRAW_COMPLEX 1 -#if LV_DRAW_COMPLEX != 0 +#define LV_USE_DRAW_SW 1 +#if LV_USE_DRAW_SW + + /*Enable complex draw engine. + *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ + #define LV_DRAW_SW_COMPLEX 1 + + /* If a widget has `style_opa < 255` (not `bg_opa`, `text_opa` etc) or not NORMAL blend mode + * it is buffered into a "simple" layer before rendering. The widget can be buffered in smaller chunks. + * "Transformed layers" (if `transform_angle/zoom` are set) use larger buffers + * and can't be drawn in chunks. */ + + /*The target buffer size for simple layer chunks.*/ + #define LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE (24 * 1024) /*[bytes]*/ + + /*Used if `LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated.*/ + #define LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) /*[bytes]*/ /*Allow buffering some shadow calculation. - *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` - *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/ - #define LV_SHADOW_CACHE_SIZE 0 + *LV_DRAW_SW_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` + *Caching has LV_DRAW_SW_SHADOW_CACHE_SIZE^2 RAM cost*/ + #define LV_DRAW_SW_SHADOW_CACHE_SIZE 0 /* Set number of maximally cached circle data. * The circumference of 1/4 circle are saved for anti-aliasing * radius * 4 bytes are used per circle (the most often used radiuses are saved) * 0: to disable caching */ - #define LV_CIRCLE_CACHE_SIZE 4 -#endif /*LV_DRAW_COMPLEX*/ + #define LV_DRAW_SW_CIRCLE_CACHE_SIZE 4 -/** - * "Simple layers" are used when a widget has `style_opa < 255` to buffer the widget into a layer - * and blend it as an image with the given opacity. - * Note that `bg_opa`, `text_opa` etc don't require buffering into layer) - * The widget can be buffered in smaller chunks to avoid using large buffers. - * - * - LV_LAYER_SIMPLE_BUF_SIZE: [bytes] the optimal target buffer size. LVGL will try to allocate it - * - LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE: [bytes] used if `LV_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated. - * - * Both buffer sizes are in bytes. - * "Transformed layers" (where transform_angle/zoom properties are used) use larger buffers - * and can't be drawn in chunks. So these settings affects only widgets with opacity. - */ -#define LV_LAYER_SIMPLE_BUF_SIZE (24 * 1024) -#define LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) + /*Default gradient buffer size. + *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. + *LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE sets the size of this cache in bytes. + *If the cache is too small the map will be allocated only while it's required for the drawing. + *0 mean no caching.*/ + #define LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE 0 -/*Default image cache size. Image caching keeps the images opened. - *If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added) - *With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images. - *However the opened images might consume additional RAM. - *0: to disable caching*/ -#define LV_IMG_CACHE_DEF_SIZE 0 + /*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) + *LV_DRAW_SW_GRADIENT_DITHER implies allocating one or two more lines of the object's rendering surface + *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ + #define LV_DRAW_SW_GRADIENT_DITHER 0 + #if LV_DRAW_SW_GRADIENT_DITHER + /*Add support for error diffusion dithering. + *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. + *The increase in memory consumption is (24 bits * object's width)*/ + #define LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION 0 + #endif -/*Number of stops allowed per gradient. Increase this to allow more stops. - *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/ -#define LV_GRADIENT_MAX_STOPS 2 - -/*Default gradient buffer size. - *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. - *LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes. - *If the cache is too small the map will be allocated only while it's required for the drawing. - *0 mean no caching.*/ -#define LV_GRAD_CACHE_DEF_SIZE 0 - -/*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) - *LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface - *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ -#define LV_DITHER_GRADIENT 0 -#if LV_DITHER_GRADIENT - /*Add support for error diffusion dithering. - *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. - *The increase in memory consumption is (24 bits * object's width)*/ - #define LV_DITHER_ERROR_DIFFUSION 0 + /*Enable subpixel rendering*/ + #define LV_DRAW_SW_FONT_SUBPX 0 + #if LV_DRAW_SW_FONT_SUBPX + /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ + #define LV_DRAW_SW_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ + #endif #endif -/*Maximum buffer size to allocate for rotation. - *Only used if software rotation is enabled in the display driver.*/ -#define LV_DISP_ROT_MAX_BUF (10*1024) +/*Use SDL renderer API*/ +#define LV_USE_DRAW_SDL 0 +#if LV_USE_DRAW_SDL + #define LV_DARW_SDL_INCLUDE_PATH + /*Texture cache size, 8MB by default*/ + #define LV_DARW_SDL_LRU_SIZE (1024 * 1024 * 8) + /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ + #define LV_DARW_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) +#endif -/*------------- - * GPU - *-----------*/ +/*===================== + * GPU CONFIGURATION + *=====================*/ /*Use Arm's 2D acceleration library Arm-2D */ #define LV_USE_GPU_ARM2D 0 @@ -184,12 +168,6 @@ #define LV_GPU_DMA2D_CMSIS_INCLUDE #endif -/*Use SWM341's DMA2D GPU*/ -#define LV_USE_GPU_SWM341_DMA2D 0 -#if LV_USE_GPU_SWM341_DMA2D - #define LV_GPU_SWM341_DMA2D_INCLUDE "SWM341.h" -#endif - /*Use NXP's PXP GPU iMX RTxxx platforms*/ #define LV_USE_GPU_NXP_PXP 0 #if LV_USE_GPU_NXP_PXP @@ -204,16 +182,16 @@ /*Use NXP's VG-Lite GPU iMX RTxxx platforms*/ #define LV_USE_GPU_NXP_VG_LITE 0 -/*Use SDL renderer API*/ -#define LV_USE_GPU_SDL 0 -#if LV_USE_GPU_SDL - #define LV_GPU_SDL_INCLUDE_PATH - /*Texture cache size, 8MB by default*/ - #define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8) - /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ - #define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) +/*Use SWM341's DMA2D GPU*/ +#define LV_USE_GPU_SWM341_DMA2D 0 +#if LV_USE_GPU_SWM341_DMA2D + #define LV_GPU_SWM341_DMA2D_INCLUDE "SWM341.h" #endif +/*======================= + * FEATURE CONFIGURATION + *=======================*/ + /*------------- * Logging *-----------*/ @@ -274,7 +252,7 @@ #endif /*1: Show the used memory and the memory fragmentation - * Requires LV_MEM_CUSTOM = 0*/ + * Requires `LV_USE_BUILTIN_MALLOC = 1`*/ #define LV_USE_MEM_MONITOR 0 #if LV_USE_MEM_MONITOR #define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT @@ -283,15 +261,9 @@ /*1: Draw random colored rectangles over the redrawn areas*/ #define LV_USE_REFR_DEBUG 0 -/*Change the built in (v)snprintf functions*/ -#define LV_SPRINTF_CUSTOM 0 -#if LV_SPRINTF_CUSTOM - #define LV_SPRINTF_INCLUDE - #define lv_snprintf snprintf - #define lv_vsnprintf vsnprintf -#else /*LV_SPRINTF_CUSTOM*/ - #define LV_SPRINTF_USE_FLOAT 0 -#endif /*LV_SPRINTF_CUSTOM*/ +/*Maximum buffer size to allocate for rotation. + *Only used if software rotation is enabled in the display driver.*/ +#define LV_DISP_ROT_MAX_BUF (10*1024) #define LV_USE_USER_DATA 1 @@ -302,6 +274,22 @@ #define LV_GC_INCLUDE "gc.h" /*Include Garbage Collector related things*/ #endif /*LV_ENABLE_GC*/ +/*Default image cache size. Image caching keeps some images opened. + *If only the built-in image formats are used there is no real advantage of caching. + *With other image decoders (e.g. PNG or JPG) caching save the continuous open/decode of images. + *However the opened images consume additional RAM. + *0: to disable caching*/ +#define LV_IMG_CACHE_DEF_SIZE 0 + + +/*Number of stops allowed per gradient. Increase this to allow more stops. + *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/ +#define LV_GRADIENT_MAX_STOPS 2 + +/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently. + * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */ +#define LV_COLOR_MIX_ROUND_OFS 0 + /*===================== * COMPILER SETTINGS *====================*/ @@ -334,8 +322,6 @@ /*Place performance critical functions into a faster memory (e.g RAM)*/ #define LV_ATTRIBUTE_FAST_MEM -/*Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible*/ -#define LV_ATTRIBUTE_DMA /*Export integer constant to binding. This macro is used with constants in the form of LV_ that *should also appear on LVGL binding API such as Micropython.*/ @@ -398,13 +384,6 @@ /*Enables/disables support for compressed fonts.*/ #define LV_USE_FONT_COMPRESSED 0 -/*Enable subpixel rendering*/ -#define LV_USE_FONT_SUBPX 0 -#if LV_USE_FONT_SUBPX - /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ - #define LV_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ -#endif - /*Enable drawing placeholders when glyph dsc is not found*/ #define LV_USE_FONT_PLACEHOLDER 1 @@ -724,7 +703,7 @@ ====================*/ /*Show some widget. It might be required to increase `LV_MEM_SIZE` */ -#define LV_USE_DEMO_WIDGETS 0 +#define LV_USE_DEMO_WIDGETS 1 #if LV_USE_DEMO_WIDGETS #define LV_DEMO_WIDGETS_SLIDESHOW 0 #endif diff --git a/src/core/lv_disp.c b/src/core/lv_disp.c index a1022b56cc..f19a5b8319 100644 --- a/src/core/lv_disp.c +++ b/src/core/lv_disp.c @@ -210,6 +210,18 @@ void lv_disp_set_bg_opa(lv_disp_t * disp, lv_opa_t opa) _lv_inv_area(disp, &a); } +lv_color_t lv_disp_get_chroma_key_color(lv_disp_t * disp) +{ + + if(!disp) disp = lv_disp_get_default(); + if(!disp) { + LV_LOG_WARN("no display registered"); + return lv_color_hex(0x00ff00); + } + + return disp->driver->color_chroma_key; +} + /** * Switch screen with animation * @param scr pointer to the new screen to load diff --git a/src/core/lv_disp.h b/src/core/lv_disp.h index 7854cb7f24..1a1b4c863b 100644 --- a/src/core/lv_disp.h +++ b/src/core/lv_disp.h @@ -119,6 +119,8 @@ void lv_disp_set_bg_image(lv_disp_t * disp, const void * img_src); */ void lv_disp_set_bg_opa(lv_disp_t * disp, lv_opa_t opa); +lv_color_t lv_disp_get_chroma_key_color(lv_disp_t * disp); + /** * Switch screen with animation * @param scr pointer to the new screen to load diff --git a/src/core/lv_event.c b/src/core/lv_event.c index f53ceac1da..9fa51dae9d 100644 --- a/src/core/lv_event.c +++ b/src/core/lv_event.c @@ -166,8 +166,8 @@ struct _lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event lv_obj_allocate_spec_attr(obj); obj->spec_attr->event_dsc_cnt++; - obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, - obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); + obj->spec_attr->event_dsc = lv_realloc(obj->spec_attr->event_dsc, + obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); LV_ASSERT_MALLOC(obj->spec_attr->event_dsc); obj->spec_attr->event_dsc[obj->spec_attr->event_dsc_cnt - 1].cb = event_cb; @@ -190,8 +190,8 @@ bool lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb) obj->spec_attr->event_dsc[i] = obj->spec_attr->event_dsc[i + 1]; } obj->spec_attr->event_dsc_cnt--; - obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, - obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); + obj->spec_attr->event_dsc = lv_realloc(obj->spec_attr->event_dsc, + obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); LV_ASSERT_MALLOC(obj->spec_attr->event_dsc); return true; } @@ -215,8 +215,8 @@ bool lv_obj_remove_event_cb_with_user_data(lv_obj_t * obj, lv_event_cb_t event_c obj->spec_attr->event_dsc[i] = obj->spec_attr->event_dsc[i + 1]; } obj->spec_attr->event_dsc_cnt--; - obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, - obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); + obj->spec_attr->event_dsc = lv_realloc(obj->spec_attr->event_dsc, + obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); LV_ASSERT_MALLOC(obj->spec_attr->event_dsc); return true; } @@ -240,8 +240,8 @@ bool lv_obj_remove_event_dsc(lv_obj_t * obj, struct _lv_event_dsc_t * event_dsc) obj->spec_attr->event_dsc[i] = obj->spec_attr->event_dsc[i + 1]; } obj->spec_attr->event_dsc_cnt--; - obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, - obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); + obj->spec_attr->event_dsc = lv_realloc(obj->spec_attr->event_dsc, + obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t)); LV_ASSERT_MALLOC(obj->spec_attr->event_dsc); return true; } diff --git a/src/core/lv_group.c b/src/core/lv_group.c index 242c9d1c42..b9a8c87088 100644 --- a/src/core/lv_group.c +++ b/src/core/lv_group.c @@ -94,7 +94,7 @@ void lv_group_del(lv_group_t * group) _lv_ll_clear(&(group->obj_ll)); _lv_ll_remove(&LV_GC_ROOT(_lv_group_ll), group); - lv_mem_free(group); + lv_free(group); } void lv_group_set_default(lv_group_t * group) @@ -201,7 +201,7 @@ void lv_group_remove_obj(lv_obj_t * obj) _LV_LL_READ(&g->obj_ll, i) { if(*i == obj) { _lv_ll_remove(&g->obj_ll, i); - lv_mem_free(i); + lv_free(i); if(obj->spec_attr) obj->spec_attr->group_p = NULL; break; } diff --git a/src/core/lv_obj.c b/src/core/lv_obj.c index 7b6bfcb3bc..976728633d 100644 --- a/src/core/lv_obj.c +++ b/src/core/lv_obj.c @@ -21,6 +21,9 @@ #include "../misc/lv_gc.h" #include "../misc/lv_math.h" #include "../misc/lv_log.h" +#if LV_USE_BUILTIN_MALLOC + #include "../misc/lv_mem_builtin.h" +#endif #include "../hal/lv_hal.h" #include "../extra/lv_extra.h" #include @@ -102,8 +105,9 @@ void lv_init(void) LV_LOG_INFO("begin"); /*Initialize the misc modules*/ - lv_mem_init(); - +#if LV_USE_BUILTIN_MALLOC + lv_mem_init_builtin(); +#endif _lv_timer_core_init(); _lv_fs_init(); @@ -190,7 +194,10 @@ void lv_deinit(void) _lv_gc_clear_roots(); lv_disp_set_default(NULL); - lv_mem_deinit(); + +#if LV_USE_BUILTIN_MALLOC + lv_mem_deinit_builtin(); +#endif lv_initialized = false; LV_LOG_INFO("lv_deinit done"); @@ -348,11 +355,11 @@ void lv_obj_allocate_spec_attr(lv_obj_t * obj) if(obj->spec_attr == NULL) { static uint32_t x = 0; x++; - obj->spec_attr = lv_mem_alloc(sizeof(_lv_obj_spec_attr_t)); + obj->spec_attr = lv_malloc(sizeof(_lv_obj_spec_attr_t)); LV_ASSERT_MALLOC(obj->spec_attr); if(obj->spec_attr == NULL) return; - lv_memset_00(obj->spec_attr, sizeof(_lv_obj_spec_attr_t)); + lv_memzero(obj->spec_attr, sizeof(_lv_obj_spec_attr_t)); obj->spec_attr->scroll_dir = LV_DIR_ALL; obj->spec_attr->scrollbar_mode = LV_SCROLLBAR_MODE_AUTO; @@ -453,15 +460,15 @@ static void lv_obj_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) if(obj->spec_attr) { if(obj->spec_attr->children) { - lv_mem_free(obj->spec_attr->children); + lv_free(obj->spec_attr->children); obj->spec_attr->children = NULL; } if(obj->spec_attr->event_dsc) { - lv_mem_free(obj->spec_attr->event_dsc); + lv_free(obj->spec_attr->event_dsc); obj->spec_attr->event_dsc = NULL; } - lv_mem_free(obj->spec_attr); + lv_free(obj->spec_attr); obj->spec_attr = NULL; } } @@ -530,7 +537,7 @@ static void lv_obj_draw(lv_event_t * e) part_dsc.part = LV_PART_MAIN; lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_dsc); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*With clip corner enabled draw the bg img separately to make it clipped*/ bool clip_corner = (lv_obj_get_style_clip_corner(obj, LV_PART_MAIN) && draw_dsc.radius != 0) ? true : false; const void * bg_img_src = draw_dsc.bg_img_src; @@ -542,9 +549,9 @@ static void lv_obj_draw(lv_event_t * e) lv_draw_rect(draw_ctx, &draw_dsc, &coords); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS if(clip_corner) { - lv_draw_mask_radius_param_t * mp = lv_mem_buf_get(sizeof(lv_draw_mask_radius_param_t)); + lv_draw_mask_radius_param_t * mp = lv_malloc(sizeof(lv_draw_mask_radius_param_t)); lv_draw_mask_radius_init(mp, &obj->coords, draw_dsc.radius, false); /*Add the mask and use `obj+8` as custom id. Don't use `obj` directly because it might be used by the user*/ lv_draw_mask_add(mp, obj + 8); @@ -566,12 +573,12 @@ static void lv_obj_draw(lv_event_t * e) lv_draw_ctx_t * draw_ctx = lv_event_get_draw_ctx(e); draw_scrollbar(obj, draw_ctx); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS if(lv_obj_get_style_clip_corner(obj, LV_PART_MAIN)) { lv_draw_mask_radius_param_t * param = lv_draw_mask_remove_custom(obj + 8); if(param) { lv_draw_mask_free_param(param); - lv_mem_buf_release(param); + lv_free(param); } } #endif @@ -670,7 +677,7 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc } } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS dsc->shadow_opa = lv_obj_get_style_shadow_opa(obj, LV_PART_SCROLLBAR); if(dsc->shadow_opa > LV_OPA_MIN) { dsc->shadow_width = lv_obj_get_style_shadow_width(obj, LV_PART_SCROLLBAR); @@ -871,8 +878,8 @@ static void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state) /*If there is no difference in styles there is nothing else to do*/ if(cmp_res == _LV_STYLE_STATE_CMP_SAME) return; - _lv_obj_style_transition_dsc_t * ts = lv_mem_buf_get(sizeof(_lv_obj_style_transition_dsc_t) * STYLE_TRANSITION_MAX); - lv_memset_00(ts, sizeof(_lv_obj_style_transition_dsc_t) * STYLE_TRANSITION_MAX); + _lv_obj_style_transition_dsc_t * ts = lv_malloc(sizeof(_lv_obj_style_transition_dsc_t) * STYLE_TRANSITION_MAX); + lv_memzero(ts, sizeof(_lv_obj_style_transition_dsc_t) * STYLE_TRANSITION_MAX); uint32_t tsi = 0; uint32_t i; for(i = 0; i < obj->style_cnt && tsi < STYLE_TRANSITION_MAX; i++) { @@ -917,7 +924,7 @@ static void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state) _lv_obj_style_create_transition(obj, part_act, prev_state, new_state, &ts[i]); } - lv_mem_buf_release(ts); + lv_free(ts); if(cmp_res == _LV_STYLE_STATE_CMP_DIFF_REDRAW) { lv_obj_invalidate(obj); diff --git a/src/core/lv_obj_class.c b/src/core/lv_obj_class.c index fe2044824d..1b84651bd0 100644 --- a/src/core/lv_obj_class.c +++ b/src/core/lv_obj_class.c @@ -44,9 +44,9 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa { LV_TRACE_OBJ_CREATE("Creating object with %p class on %p parent", (void *)class_p, (void *)parent); uint32_t s = get_instance_size(class_p); - lv_obj_t * obj = lv_mem_alloc(s); + lv_obj_t * obj = lv_malloc(s); if(obj == NULL) return NULL; - lv_memset_00(obj, s); + lv_memzero(obj, s); obj->class_p = class_p; obj->parent = parent; @@ -56,18 +56,18 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa lv_disp_t * disp = lv_disp_get_default(); if(!disp) { LV_LOG_WARN("No display created yet. No place to assign the new screen"); - lv_mem_free(obj); + lv_free(obj); return NULL; } if(disp->screens == NULL) { - disp->screens = lv_mem_alloc(sizeof(lv_obj_t *)); + disp->screens = lv_malloc(sizeof(lv_obj_t *)); disp->screens[0] = obj; disp->screen_cnt = 1; } else { disp->screen_cnt++; - disp->screens = lv_mem_realloc(disp->screens, sizeof(lv_obj_t *) * disp->screen_cnt); + disp->screens = lv_realloc(disp->screens, sizeof(lv_obj_t *) * disp->screen_cnt); disp->screens[disp->screen_cnt - 1] = obj; } @@ -86,14 +86,14 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa } if(parent->spec_attr->children == NULL) { - parent->spec_attr->children = lv_mem_alloc(sizeof(lv_obj_t *)); + parent->spec_attr->children = lv_malloc(sizeof(lv_obj_t *)); parent->spec_attr->children[0] = obj; parent->spec_attr->child_cnt = 1; } else { parent->spec_attr->child_cnt++; - parent->spec_attr->children = lv_mem_realloc(parent->spec_attr->children, - sizeof(lv_obj_t *) * parent->spec_attr->child_cnt); + parent->spec_attr->children = lv_realloc(parent->spec_attr->children, + sizeof(lv_obj_t *) * parent->spec_attr->child_cnt); parent->spec_attr->children[parent->spec_attr->child_cnt - 1] = obj; } } diff --git a/src/core/lv_obj_draw.c b/src/core/lv_obj_draw.c index f2428cddf0..298c3df60e 100644 --- a/src/core/lv_obj_draw.c +++ b/src/core/lv_obj_draw.c @@ -51,8 +51,8 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t } } -#if LV_DRAW_COMPLEX if(part != LV_PART_MAIN) draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part); +#if LV_USE_DRAW_MASKS draw_dsc->radius = lv_obj_get_style_radius(obj, part); @@ -132,7 +132,7 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t } } -#else /*LV_DRAW_COMPLEX*/ +#else /*LV_USE_DRAW_MASKS*/ if(draw_dsc->bg_opa != LV_OPA_TRANSP) { draw_dsc->bg_opa = lv_obj_get_style_bg_opa(obj, part); if(draw_dsc->bg_opa > LV_OPA_MIN) { @@ -212,9 +212,7 @@ void lv_obj_init_draw_label_dsc(lv_obj_t * obj, uint32_t part, lv_draw_label_dsc draw_dsc->letter_space = lv_obj_get_style_text_letter_space(obj, part); draw_dsc->line_space = lv_obj_get_style_text_line_space(obj, part); draw_dsc->decor = lv_obj_get_style_text_decor(obj, part); -#if LV_DRAW_COMPLEX if(part != LV_PART_MAIN) draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part); -#endif draw_dsc->font = lv_obj_get_style_text_font(obj, part); @@ -250,9 +248,7 @@ void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint32_t part, lv_draw_img_dsc_t * if(draw_dsc->recolor_opa > 0) { draw_dsc->recolor = lv_obj_get_style_img_recolor_filtered(obj, part); } -#if LV_DRAW_COMPLEX if(part != LV_PART_MAIN) draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part); -#endif } void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint32_t part, lv_draw_line_dsc_t * draw_dsc) @@ -284,9 +280,7 @@ void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint32_t part, lv_draw_line_dsc_t draw_dsc->round_start = lv_obj_get_style_line_rounded(obj, part); draw_dsc->round_end = draw_dsc->round_start; -#if LV_DRAW_COMPLEX if(part != LV_PART_MAIN) draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part); -#endif } void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, uint32_t part, lv_draw_arc_dsc_t * draw_dsc) @@ -313,9 +307,7 @@ void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, uint32_t part, lv_draw_arc_dsc_t * draw_dsc->rounded = lv_obj_get_style_arc_rounded(obj, part); -#if LV_DRAW_COMPLEX if(part != LV_PART_MAIN) draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part); -#endif } lv_coord_t lv_obj_calculate_ext_draw_size(lv_obj_t * obj, uint32_t part) @@ -354,7 +346,7 @@ lv_coord_t lv_obj_calculate_ext_draw_size(lv_obj_t * obj, uint32_t part) void lv_obj_draw_dsc_init(lv_obj_draw_part_dsc_t * dsc, lv_draw_ctx_t * draw_ctx) { - lv_memset_00(dsc, sizeof(lv_obj_draw_part_dsc_t)); + lv_memzero(dsc, sizeof(lv_obj_draw_part_dsc_t)); dsc->draw_ctx = draw_ctx; } diff --git a/src/core/lv_obj_pos.c b/src/core/lv_obj_pos.c index a31c11db85..f1858895a4 100644 --- a/src/core/lv_obj_pos.c +++ b/src/core/lv_obj_pos.c @@ -323,7 +323,7 @@ void lv_obj_update_layout(const lv_obj_t * obj) uint32_t lv_layout_register(lv_layout_update_cb_t cb, void * user_data) { layout_cnt++; - LV_GC_ROOT(_lv_layout_list) = lv_mem_realloc(LV_GC_ROOT(_lv_layout_list), layout_cnt * sizeof(lv_layout_dsc_t)); + LV_GC_ROOT(_lv_layout_list) = lv_realloc(LV_GC_ROOT(_lv_layout_list), layout_cnt * sizeof(lv_layout_dsc_t)); LV_ASSERT_MALLOC(LV_GC_ROOT(_lv_layout_list)); LV_GC_ROOT(_lv_layout_list)[layout_cnt - 1].cb = cb; diff --git a/src/core/lv_obj_style.c b/src/core/lv_obj_style.c index 5007c1042f..55903af228 100644 --- a/src/core/lv_obj_style.c +++ b/src/core/lv_obj_style.c @@ -89,14 +89,15 @@ void lv_obj_add_style(lv_obj_t * obj, const lv_style_t * style, lv_style_selecto /*Allocate space for the new style and shift the rest of the style to the end*/ obj->style_cnt++; - obj->styles = lv_mem_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); + obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); + LV_ASSERT_MALLOC(obj->styles); uint32_t j; for(j = obj->style_cnt - 1; j > i ; j--) { obj->styles[j] = obj->styles[j - 1]; } - lv_memset_00(&obj->styles[i], sizeof(_lv_obj_style_t)); + lv_memzero(&obj->styles[i], sizeof(_lv_obj_style_t)); obj->styles[i].style = style; obj->styles[i].selector = selector; @@ -128,7 +129,7 @@ void lv_obj_remove_style(lv_obj_t * obj, const lv_style_t * style, lv_style_sele if(obj->styles[i].is_local || obj->styles[i].is_trans) { if(obj->styles[i].style) lv_style_reset((lv_style_t *)obj->styles[i].style); - lv_mem_free((lv_style_t *)obj->styles[i].style); + lv_free((lv_style_t *)obj->styles[i].style); obj->styles[i].style = NULL; } @@ -139,7 +140,7 @@ void lv_obj_remove_style(lv_obj_t * obj, const lv_style_t * style, lv_style_sele } obj->style_cnt--; - obj->styles = lv_mem_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); + obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); deleted = true; /*The style from the current `i` index is removed, so `i` points to the next style. @@ -513,7 +514,7 @@ static lv_style_t * get_local_style(lv_obj_t * obj, lv_style_selector_t selector } obj->style_cnt++; - obj->styles = lv_mem_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); + obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); LV_ASSERT_MALLOC(obj->styles); for(i = obj->style_cnt - 1; i > 0 ; i--) { @@ -523,9 +524,10 @@ static lv_style_t * get_local_style(lv_obj_t * obj, lv_style_selector_t selector obj->styles[i] = obj->styles[i - 1]; } - lv_memset_00(&obj->styles[i], sizeof(_lv_obj_style_t)); - obj->styles[i].style = lv_mem_alloc(sizeof(lv_style_t)); + lv_memzero(&obj->styles[i], sizeof(_lv_obj_style_t)); + obj->styles[i].style = lv_malloc(sizeof(lv_style_t)); lv_style_init((lv_style_t *)obj->styles[i].style); + obj->styles[i].is_local = 1; obj->styles[i].selector = selector; return (lv_style_t *)obj->styles[i].style; @@ -549,15 +551,17 @@ static _lv_obj_style_t * get_trans_style(lv_obj_t * obj, lv_style_selector_t se if(i != obj->style_cnt) return &obj->styles[i]; obj->style_cnt++; - obj->styles = lv_mem_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); + obj->styles = lv_realloc(obj->styles, obj->style_cnt * sizeof(_lv_obj_style_t)); for(i = obj->style_cnt - 1; i > 0 ; i--) { obj->styles[i] = obj->styles[i - 1]; } - lv_memset_00(&obj->styles[0], sizeof(_lv_obj_style_t)); - obj->styles[0].style = lv_mem_alloc(sizeof(lv_style_t)); + + lv_memzero(&obj->styles[0], sizeof(_lv_obj_style_t)); + obj->styles[0].style = lv_malloc(sizeof(lv_style_t)); lv_style_init((lv_style_t *)obj->styles[0].style); + obj->styles[0].is_trans = 1; obj->styles[0].selector = selector; return &obj->styles[0]; @@ -705,7 +709,7 @@ static bool trans_del(lv_obj_t * obj, lv_part_t part, lv_style_prop_t prop, tran /*Free the transition descriptor too*/ lv_anim_del(tr, NULL); _lv_ll_remove(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr); - lv_mem_free(tr); + lv_free(tr); removed = true; } @@ -822,7 +826,7 @@ static void trans_anim_ready_cb(lv_anim_t * a) for(i = 0; i < obj->style_cnt; i++) { if(obj->styles[i].is_trans && obj->styles[i].selector == tr->selector) { _lv_ll_remove(&LV_GC_ROOT(_lv_obj_style_trans_ll), tr); - lv_mem_free(tr); + lv_free(tr); _lv_obj_style_t * obj_style = &obj->styles[i]; lv_style_remove_prop((lv_style_t *)obj_style->style, prop); @@ -842,10 +846,7 @@ static lv_layer_type_t calculate_layer_type(lv_obj_t * obj) if(lv_obj_get_style_transform_angle(obj, 0) != 0) return LV_LAYER_TYPE_TRANSFORM; if(lv_obj_get_style_transform_zoom(obj, 0) != 256) return LV_LAYER_TYPE_TRANSFORM; if(lv_obj_get_style_opa(obj, 0) != LV_OPA_COVER) return LV_LAYER_TYPE_SIMPLE; - -#if LV_DRAW_COMPLEX if(lv_obj_get_style_blend_mode(obj, 0) != LV_BLEND_MODE_NORMAL) return LV_LAYER_TYPE_SIMPLE; -#endif return LV_LAYER_TYPE_NONE; } diff --git a/src/core/lv_obj_tree.c b/src/core/lv_obj_tree.c index d3ad16ae3e..446d0dc684 100644 --- a/src/core/lv_obj_tree.c +++ b/src/core/lv_obj_tree.c @@ -156,18 +156,18 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent) } old_parent->spec_attr->child_cnt--; if(old_parent->spec_attr->child_cnt) { - old_parent->spec_attr->children = lv_mem_realloc(old_parent->spec_attr->children, - old_parent->spec_attr->child_cnt * (sizeof(lv_obj_t *))); + old_parent->spec_attr->children = lv_realloc(old_parent->spec_attr->children, + old_parent->spec_attr->child_cnt * (sizeof(lv_obj_t *))); } else { - lv_mem_free(old_parent->spec_attr->children); + lv_free(old_parent->spec_attr->children); old_parent->spec_attr->children = NULL; } /*Add the child to the new parent as the last (newest child)*/ parent->spec_attr->child_cnt++; - parent->spec_attr->children = lv_mem_realloc(parent->spec_attr->children, - parent->spec_attr->child_cnt * (sizeof(lv_obj_t *))); + parent->spec_attr->children = lv_realloc(parent->spec_attr->children, + parent->spec_attr->child_cnt * (sizeof(lv_obj_t *))); parent->spec_attr->children[lv_obj_get_child_cnt(parent) - 1] = obj; obj->parent = parent; @@ -402,7 +402,7 @@ static void obj_del_core(lv_obj_t * obj) disp->screens[i] = disp->screens[i + 1]; } disp->screen_cnt--; - disp->screens = lv_mem_realloc(disp->screens, disp->screen_cnt * sizeof(lv_obj_t *)); + disp->screens = lv_realloc(disp->screens, disp->screen_cnt * sizeof(lv_obj_t *)); } /*Remove the object from the child list of its parent*/ else { @@ -412,12 +412,12 @@ static void obj_del_core(lv_obj_t * obj) obj->parent->spec_attr->children[i] = obj->parent->spec_attr->children[i + 1]; } obj->parent->spec_attr->child_cnt--; - obj->parent->spec_attr->children = lv_mem_realloc(obj->parent->spec_attr->children, - obj->parent->spec_attr->child_cnt * sizeof(lv_obj_t *)); + obj->parent->spec_attr->children = lv_realloc(obj->parent->spec_attr->children, + obj->parent->spec_attr->child_cnt * sizeof(lv_obj_t *)); } /*Free the object itself*/ - lv_mem_free(obj); + lv_free(obj); } diff --git a/src/core/lv_refr.c b/src/core/lv_refr.c index e6facfa2de..ffd4c98ba1 100644 --- a/src/core/lv_refr.c +++ b/src/core/lv_refr.c @@ -334,8 +334,8 @@ void _lv_disp_refr_timer(lv_timer_t * tmr) } /*Clean up*/ - lv_memset_00(disp_refr->inv_areas, sizeof(disp_refr->inv_areas)); - lv_memset_00(disp_refr->inv_area_joined, sizeof(disp_refr->inv_area_joined)); + lv_memzero(disp_refr->inv_areas, sizeof(disp_refr->inv_areas)); + lv_memzero(disp_refr->inv_area_joined, sizeof(disp_refr->inv_area_joined)); disp_refr->inv_p = 0; elaps = lv_tick_elaps(start); @@ -346,10 +346,9 @@ void _lv_disp_refr_timer(lv_timer_t * tmr) } } - lv_mem_buf_free_all(); _lv_font_clean_up_fmt_txt(); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS _lv_draw_mask_cleanup(); #endif @@ -628,16 +627,14 @@ static void refr_area_part(lv_draw_ctx_t * draw_ctx) } /*If the screen is transparent initialize it when the flushing is ready*/ -#if LV_COLOR_SCREEN_TRANSP if(disp_refr->driver->screen_transp) { if(disp_refr->driver->clear_cb) { disp_refr->driver->clear_cb(disp_refr->driver, disp_refr->driver->draw_buf->buf_act, disp_refr->driver->draw_buf->size); } else { - lv_memset_00(disp_refr->driver->draw_buf->buf_act, disp_refr->driver->draw_buf->size * LV_IMG_PX_SIZE_ALPHA_BYTE); + lv_memzero(disp_refr->driver->draw_buf->buf_act, disp_refr->driver->draw_buf->size * LV_IMG_PX_SIZE_ALPHA_BYTE); } } -#endif } lv_obj_t * top_act_scr = NULL; @@ -1142,7 +1139,7 @@ static void draw_buf_rotate(lv_area_t * area, lv_color_t * color_p) } else { /*Rotate other areas using a maximum buffer size*/ - if(rot_buf == NULL) rot_buf = lv_mem_buf_get(LV_DISP_ROT_MAX_BUF); + if(rot_buf == NULL) rot_buf = lv_malloc(LV_DISP_ROT_MAX_BUF); draw_buf_rotate_90(drv->rotated == LV_DISP_ROT_270, area_w, height, color_p, rot_buf); if(drv->rotated == LV_DISP_ROT_90) { @@ -1174,7 +1171,7 @@ static void draw_buf_rotate(lv_area_t * area, lv_color_t * color_p) row += height; } /*Free the allocated buffer at the end if necessary*/ - if(rot_buf != NULL) lv_mem_buf_release(rot_buf); + if(rot_buf != NULL) lv_free(rot_buf); } } @@ -1197,16 +1194,14 @@ static void draw_buf_flush(lv_disp_t * disp) } /*If the screen is transparent initialize it when the flushing is ready*/ -#if LV_COLOR_SCREEN_TRANSP if(disp_refr->driver->screen_transp) { if(disp_refr->driver->clear_cb) { disp_refr->driver->clear_cb(disp_refr->driver, disp_refr->driver->draw_buf->buf_act, disp_refr->driver->draw_buf->size); } else { - lv_memset_00(disp_refr->driver->draw_buf->buf_act, disp_refr->driver->draw_buf->size * LV_IMG_PX_SIZE_ALPHA_BYTE); + lv_memzero(disp_refr->driver->draw_buf->buf_act, disp_refr->driver->draw_buf->size * LV_IMG_PX_SIZE_ALPHA_BYTE); } } -#endif } draw_buf->flushing = 1; diff --git a/src/draw/arm2d/lv_gpu_arm2d.c b/src/draw/arm2d/lv_gpu_arm2d.c index 7777fe21b4..6e2a68d9f9 100644 --- a/src/draw/arm2d/lv_gpu_arm2d.c +++ b/src/draw/arm2d/lv_gpu_arm2d.c @@ -275,7 +275,7 @@ lv_color_t *rgb_tmp_buf = NULL; \ if(draw_dsc->recolor_opa > LV_OPA_MIN) { \ rgb_tmp_buf \ - = lv_mem_buf_get(src_w * src_h * sizeof(lv_color_t)); \ + = lv_malloc(src_w * src_h * sizeof(lv_color_t)); \ if (NULL == rgb_tmp_buf) { \ LV_LOG_WARN( \ "Failed to allocate memory for accelerating recolour, " \ @@ -300,7 +300,7 @@ } \ __VA_ARGS__ \ if (NULL != rgb_tmp_buf) { \ - lv_mem_buf_release(rgb_tmp_buf); \ + lv_free(rgb_tmp_buf); \ } \ } while(0); /* *INDENT-ON* */ @@ -645,7 +645,7 @@ static void lv_draw_arm2d_blend(lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend mask, mask_stride); } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS else { break; } @@ -663,7 +663,7 @@ static void lv_draw_arm2d_blend(lv_draw_ctx_t * draw_ctx, const lv_draw_sw_blend mask, mask_stride); } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS else { break; } @@ -846,7 +846,7 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, lv_area_t blend_area; lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(lv_draw_sw_blend_dsc_t)); + lv_memzero(&blend_dsc, sizeof(lv_draw_sw_blend_dsc_t)); blend_dsc.opa = draw_dsc->opa; blend_dsc.blend_mode = draw_dsc->blend_mode; blend_dsc.blend_area = &blend_area; @@ -908,8 +908,8 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, /*Create buffers and masks*/ uint32_t buf_size = buf_w * buf_h; - lv_color_t * rgb_buf = lv_mem_buf_get(buf_size * sizeof(lv_color_t)); - lv_opa_t * mask_buf = lv_mem_buf_get(buf_size); + lv_color_t * rgb_buf = lv_malloc(buf_size * sizeof(lv_color_t)); + lv_opa_t * mask_buf = lv_malloc(buf_size); blend_dsc.mask_buf = mask_buf; blend_dsc.mask_area = &blend_area; blend_dsc.mask_res = LV_DRAW_MASK_RES_CHANGED; @@ -977,14 +977,14 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, uint8_t * mask_temp_buf = NULL; if(blend_dsc.opa < LV_OPA_MAX) { - mask_temp_buf = lv_mem_buf_get(copy_size.iHeight * copy_size.iWidth); + mask_temp_buf = lv_malloc(copy_size.iHeight * copy_size.iWidth); if(NULL == mask_temp_buf) { LV_LOG_WARN( "Failed to allocate memory for alpha mask," " use normal route instead."); break; } - lv_memset_00(mask_temp_buf, copy_size.iHeight * copy_size.iWidth); + lv_memzero(mask_temp_buf, copy_size.iHeight * copy_size.iWidth); __arm_2d_impl_gray8_colour_filling_channel_mask_opacity( mask_temp_buf, @@ -1006,7 +1006,7 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, dest_stride, ©_size); - lv_mem_buf_release(mask_temp_buf); + lv_free(mask_temp_buf); } else { __arm_2d_impl_src_chn_msk_copy( @@ -1144,7 +1144,7 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, source_center.iY = draw_dsc->pivot.y; - if((LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED == cf) || + if((LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED == cf) || (LV_IMG_CF_TRUE_COLOR == cf)) { arm_2d_tile_transform_with_opacity( &source_tile, @@ -1160,7 +1160,7 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, } #if defined(__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__) \ && __ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__ - else if((LV_IMG_CF_TRUE_COLOR_ALPHA == cf) && + else if((LV_IMG_CF_TRUE_COLOR_ALPHA == cf) && (LV_COLOR_DEPTH == 32)) { arm_2d_tile_transform_with_src_mask_and_opacity( &source_tile, @@ -1208,7 +1208,7 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, (color_int)draw_dsc->recolor.full, draw_dsc->recolor_opa); } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Apply the masks if any*/ if(mask_any) { lv_coord_t y; @@ -1218,7 +1218,7 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, mask_res_line = lv_draw_mask_apply(mask_buf_tmp, blend_area.x1, y, blend_w); if(mask_res_line == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(mask_buf_tmp, blend_w); + lv_memzero(mask_buf_tmp, blend_w); blend_dsc.mask_res = LV_DRAW_MASK_RES_CHANGED; } else if(mask_res_line == LV_DRAW_MASK_RES_CHANGED) { @@ -1238,8 +1238,8 @@ static void lv_draw_arm2d_img_decoded(struct _lv_draw_ctx_t * draw_ctx, if(blend_area.y2 > y_last) blend_area.y2 = y_last; } - lv_mem_buf_release(mask_buf); - lv_mem_buf_release(rgb_buf); + lv_free(mask_buf); + lv_free(rgb_buf); } } @@ -1275,7 +1275,7 @@ static void convert_cb(const lv_area_t * dest_area, const void * src_buf, lv_coo if(cf == LV_IMG_CF_TRUE_COLOR || cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) { uint32_t px_cnt = lv_area_get_size(dest_area); - lv_memset_ff(abuf, px_cnt); + lv_memset(abuf, 0xff, px_cnt); src_tmp8 += (src_stride * dest_area->y1 * sizeof(lv_color_t)) + dest_area->x1 * sizeof(lv_color_t); uint32_t dest_w = lv_area_get_width(dest_area); diff --git a/src/draw/lv_draw_arc.c b/src/draw/lv_draw_arc.c index b806a002e3..3a7e2becd2 100644 --- a/src/draw/lv_draw_arc.c +++ b/src/draw/lv_draw_arc.c @@ -35,7 +35,7 @@ void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc) { - lv_memset_00(dsc, sizeof(lv_draw_arc_dsc_t)); + lv_memzero(dsc, sizeof(lv_draw_arc_dsc_t)); dsc->width = 1; dsc->opa = LV_OPA_COVER; dsc->color = lv_color_black(); diff --git a/src/draw/lv_draw_img.c b/src/draw/lv_draw_img.c index 41dc0f0398..61fbf1ee93 100644 --- a/src/draw/lv_draw_img.c +++ b/src/draw/lv_draw_img.c @@ -45,7 +45,7 @@ static void draw_cleanup(_lv_img_cache_entry_t * cache); void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc) { - lv_memset_00(dsc, sizeof(lv_draw_img_dsc_t)); + lv_memzero(dsc, sizeof(lv_draw_img_dsc_t)); dsc->recolor = lv_color_black(); dsc->opa = LV_OPA_COVER; dsc->zoom = LV_IMG_ZOOM_NONE; @@ -300,8 +300,8 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t decode_and_draw(lv_draw_ctx_t * draw_ctx, int32_t width = lv_area_get_width(&mask_com); - uint8_t * buf = lv_mem_buf_get(lv_area_get_width(&mask_com) * - LV_IMG_PX_SIZE_ALPHA_BYTE); /*+1 because of the possible alpha byte*/ + uint8_t * buf = lv_malloc(lv_area_get_width(&mask_com) * + LV_IMG_PX_SIZE_ALPHA_BYTE); /*+1 because of the possible alpha byte*/ const lv_area_t * clip_area_ori = draw_ctx->clip_area; lv_area_t line; @@ -320,7 +320,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t decode_and_draw(lv_draw_ctx_t * draw_ctx, if(read_res != LV_RES_OK) { lv_img_decoder_close(&cdsc->dec_dsc); LV_LOG_WARN("Image draw can't read the line"); - lv_mem_buf_release(buf); + lv_free(buf); draw_cleanup(cdsc); draw_ctx->clip_area = clip_area_ori; return LV_RES_INV; @@ -333,7 +333,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t decode_and_draw(lv_draw_ctx_t * draw_ctx, y++; } draw_ctx->clip_area = clip_area_ori; - lv_mem_buf_release(buf); + lv_free(buf); } draw_cleanup(cdsc); diff --git a/src/draw/lv_draw_label.c b/src/draw/lv_draw_label.c index 7f80df453c..0f6f67e554 100644 --- a/src/draw/lv_draw_label.c +++ b/src/draw/lv_draw_label.c @@ -54,7 +54,7 @@ static uint8_t hex_char_to_num(char hex); void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc) { - lv_memset_00(dsc, sizeof(lv_draw_label_dsc_t)); + lv_memzero(dsc, sizeof(lv_draw_label_dsc_t)); dsc->opa = LV_OPA_COVER; dsc->color = lv_color_black(); dsc->font = LV_FONT_DEFAULT; @@ -219,7 +219,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(lv_draw_ctx_t * draw_ctx, const lv_draw cmd_state = CMD_STATE_WAIT; i = 0; #if LV_USE_BIDI - char * bidi_txt = lv_mem_buf_get(line_end - line_start + 1); + char * bidi_txt = lv_malloc(line_end - line_start + 1); _lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, base_dir, NULL, 0); #else const char * bidi_txt = txt + line_start; @@ -263,7 +263,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(lv_draw_ctx_t * draw_ctx, const lv_draw /*Get the parameter*/ if(i - par_start == LABEL_RECOLOR_PAR_LENGTH + 1) { char buf[LABEL_RECOLOR_PAR_LENGTH + 1]; - lv_memcpy_small(buf, &bidi_txt[par_start], LABEL_RECOLOR_PAR_LENGTH); + lv_memcpy(buf, &bidi_txt[par_start], LABEL_RECOLOR_PAR_LENGTH); buf[LABEL_RECOLOR_PAR_LENGTH] = '\0'; int r, g, b; r = (hex_char_to_num(buf[0]) << 4) + hex_char_to_num(buf[1]); @@ -329,7 +329,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(lv_draw_ctx_t * draw_ctx, const lv_draw } #if LV_USE_BIDI - lv_mem_buf_release(bidi_txt); + lv_free(bidi_txt); bidi_txt = NULL; #endif /*Go to next line*/ diff --git a/src/draw/lv_draw_layer.c b/src/draw/lv_draw_layer.c index da35682d10..b39c842701 100644 --- a/src/draw/lv_draw_layer.c +++ b/src/draw/lv_draw_layer.c @@ -39,14 +39,14 @@ lv_draw_layer_ctx_t * lv_draw_layer_create(lv_draw_ctx_t * draw_ctx, const lv_ar { if(draw_ctx->layer_init == NULL) return NULL; - lv_draw_layer_ctx_t * layer_ctx = lv_mem_alloc(draw_ctx->layer_instance_size); + lv_draw_layer_ctx_t * layer_ctx = lv_malloc(draw_ctx->layer_instance_size); LV_ASSERT_MALLOC(layer_ctx); if(layer_ctx == NULL) { LV_LOG_WARN("Couldn't allocate a new layer context"); return NULL; } - lv_memset_00(layer_ctx, draw_ctx->layer_instance_size); + lv_memzero(layer_ctx, draw_ctx->layer_instance_size); lv_disp_t * disp_refr = _lv_refr_get_disp_refreshing(); layer_ctx->original.buf = draw_ctx->buf; @@ -57,7 +57,7 @@ lv_draw_layer_ctx_t * lv_draw_layer_create(lv_draw_ctx_t * draw_ctx, const lv_ar lv_draw_layer_ctx_t * init_layer_ctx = draw_ctx->layer_init(draw_ctx, layer_ctx, flags); if(NULL == init_layer_ctx) { - lv_mem_free(layer_ctx); + lv_free(layer_ctx); } return init_layer_ctx; } @@ -85,7 +85,7 @@ void lv_draw_layer_destroy(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * layer disp_refr->driver->screen_transp = layer_ctx->original.screen_transp; if(draw_ctx->layer_destroy) draw_ctx->layer_destroy(draw_ctx, layer_ctx); - lv_mem_free(layer_ctx); + lv_free(layer_ctx); } /********************** diff --git a/src/draw/lv_draw_line.c b/src/draw/lv_draw_line.c index b4844dbd1c..6430b21a8c 100644 --- a/src/draw/lv_draw_line.c +++ b/src/draw/lv_draw_line.c @@ -36,7 +36,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc) { - lv_memset_00(dsc, sizeof(lv_draw_line_dsc_t)); + lv_memzero(dsc, sizeof(lv_draw_line_dsc_t)); dsc->width = 1; dsc->opa = LV_OPA_COVER; dsc->color = lv_color_black(); diff --git a/src/draw/lv_draw_mask.c b/src/draw/lv_draw_mask.c index 2170da941e..e1bf47fb5f 100644 --- a/src/draw/lv_draw_mask.c +++ b/src/draw/lv_draw_mask.c @@ -7,7 +7,7 @@ * INCLUDES *********************/ #include "lv_draw.h" -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS #include "../misc/lv_math.h" #include "../misc/lv_log.h" #include "../misc/lv_assert.h" @@ -214,8 +214,8 @@ void lv_draw_mask_free_param(void * p) lv_draw_mask_radius_param_t * radius_p = (lv_draw_mask_radius_param_t *) p; if(radius_p->circle) { if(radius_p->circle->life < 0) { - lv_mem_free(radius_p->circle->cir_opa); - lv_mem_free(radius_p->circle); + lv_free(radius_p->circle->cir_opa); + lv_free(radius_p->circle); } else { radius_p->circle->used_cnt--; @@ -224,18 +224,18 @@ void lv_draw_mask_free_param(void * p) } else if(pdsc->type == LV_DRAW_MASK_TYPE_POLYGON) { lv_draw_mask_polygon_param_t * poly_p = (lv_draw_mask_polygon_param_t *) p; - lv_mem_free(poly_p->cfg.points); + lv_free(poly_p->cfg.points); } } void _lv_draw_mask_cleanup(void) { uint8_t i; - for(i = 0; i < LV_CIRCLE_CACHE_SIZE; i++) { + for(i = 0; i < LV_DRAW_SW_CIRCLE_CACHE_SIZE; i++) { if(LV_GC_ROOT(_lv_circle_cache[i]).buf) { - lv_mem_free(LV_GC_ROOT(_lv_circle_cache[i]).buf); + lv_free(LV_GC_ROOT(_lv_circle_cache[i]).buf); } - lv_memset_00(&LV_GC_ROOT(_lv_circle_cache[i]), sizeof(LV_GC_ROOT(_lv_circle_cache[i]))); + lv_memzero(&LV_GC_ROOT(_lv_circle_cache[i]), sizeof(LV_GC_ROOT(_lv_circle_cache[i]))); } } @@ -293,7 +293,7 @@ bool lv_draw_mask_is_any(const lv_area_t * a) 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) { - lv_memset_00(param, sizeof(lv_draw_mask_line_param_t)); + lv_memzero(param, sizeof(lv_draw_mask_line_param_t)); if(p1y == p2y && side == LV_DRAW_MASK_LINE_SIDE_BOTTOM) { p1y--; @@ -493,7 +493,7 @@ void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area uint32_t i; /*Try to reuse a circle cache entry*/ - for(i = 0; i < LV_CIRCLE_CACHE_SIZE; i++) { + for(i = 0; i < LV_DRAW_SW_CIRCLE_CACHE_SIZE; i++) { if(LV_GC_ROOT(_lv_circle_cache[i]).radius == radius) { LV_GC_ROOT(_lv_circle_cache[i]).used_cnt++; CIRCLE_CACHE_AGING(LV_GC_ROOT(_lv_circle_cache[i]).life, radius); @@ -504,7 +504,7 @@ void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area /*If not found find a free entry with lowest life*/ _lv_draw_mask_radius_circle_dsc_t * entry = NULL; - for(i = 0; i < LV_CIRCLE_CACHE_SIZE; i++) { + for(i = 0; i < LV_DRAW_SW_CIRCLE_CACHE_SIZE; i++) { if(LV_GC_ROOT(_lv_circle_cache[i]).used_cnt == 0) { if(!entry) entry = &LV_GC_ROOT(_lv_circle_cache[i]); else if(LV_GC_ROOT(_lv_circle_cache[i]).life < entry->life) entry = &LV_GC_ROOT(_lv_circle_cache[i]); @@ -512,9 +512,9 @@ void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area } if(!entry) { - entry = lv_mem_alloc(sizeof(_lv_draw_mask_radius_circle_dsc_t)); + entry = lv_malloc(sizeof(_lv_draw_mask_radius_circle_dsc_t)); LV_ASSERT_MALLOC(entry); - lv_memset_00(entry, sizeof(_lv_draw_mask_radius_circle_dsc_t)); + lv_memzero(entry, sizeof(_lv_draw_mask_radius_circle_dsc_t)); entry->life = -1; } else { @@ -567,7 +567,7 @@ void lv_draw_mask_map_init(lv_draw_mask_map_param_t * param, const lv_area_t * c void lv_draw_mask_polygon_init(lv_draw_mask_polygon_param_t * param, const lv_point_t * points, uint16_t point_cnt) { /*Join adjacent points if they are on the same coordinate*/ - lv_point_t * p = lv_mem_alloc(point_cnt * sizeof(lv_point_t)); + lv_point_t * p = lv_malloc(point_cnt * sizeof(lv_point_t)); if(p == NULL) return; uint16_t i; uint16_t pcnt = 0; @@ -625,7 +625,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_line(lv_opa_t * mas else { int32_t k = - abs_x; if(k < 0) return LV_DRAW_MASK_RES_TRANSP; - if(k >= 0 && k < len) lv_memset_00(&mask_buf[k], len - k); + if(k >= 0 && k < len) lv_memzero(&mask_buf[k], len - k); return LV_DRAW_MASK_RES_CHANGED; } } @@ -635,7 +635,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_line(lv_opa_t * mas int32_t k = - abs_x; if(k < 0) k = 0; if(k >= len) return LV_DRAW_MASK_RES_TRANSP; - else if(k >= 0 && k < len) lv_memset_00(&mask_buf[0], k); + else if(k >= 0 && k < len) lv_memzero(&mask_buf[0], k); return LV_DRAW_MASK_RES_CHANGED; } } @@ -753,7 +753,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_flat(lv_opa_t * mask_b return LV_DRAW_MASK_RES_TRANSP; } if(k >= 0) { - lv_memset_00(&mask_buf[0], k); + lv_memzero(&mask_buf[0], k); } } else { @@ -762,7 +762,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_flat(lv_opa_t * mask_b return LV_DRAW_MASK_RES_TRANSP; } if(k <= len) { - lv_memset_00(&mask_buf[k], len - k); + lv_memzero(&mask_buf[k], len - k); } } @@ -832,13 +832,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_ if(k >= len) { return LV_DRAW_MASK_RES_TRANSP; } - if(k >= 0) lv_memset_00(&mask_buf[0], k); + if(k >= 0) lv_memzero(&mask_buf[0], k); } else { if(k > len) k = len; if(k == 0) return LV_DRAW_MASK_RES_TRANSP; - else if(k > 0) lv_memset_00(&mask_buf[k], len - k); + else if(k > 0) lv_memzero(&mask_buf[k], len - k); } } @@ -867,12 +867,12 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_ k = xsi - abs_x - 1; if(k > len) k = len; - else if(k > 0) lv_memset_00(&mask_buf[0], k); + else if(k > 0) lv_memzero(&mask_buf[0], k); } else { if(k > len) return LV_DRAW_MASK_RES_FULL_COVER; - if(k >= 0) lv_memset_00(&mask_buf[k], len - k); + if(k >= 0) lv_memzero(&mask_buf[k], len - k); } } @@ -897,13 +897,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_ if(p->inv) { k = xsi - abs_x; if(k > len) return LV_DRAW_MASK_RES_TRANSP; - if(k >= 0) lv_memset_00(&mask_buf[0], k); + if(k >= 0) lv_memzero(&mask_buf[0], k); } else { if(k > len) k = len; if(k == 0) return LV_DRAW_MASK_RES_TRANSP; - else if(k > 0) lv_memset_00(&mask_buf[k], len - k); + else if(k > 0) lv_memzero(&mask_buf[k], len - k); } } } @@ -949,7 +949,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma if(tmp > 0) { res1 = lv_draw_mask_line(&mask_buf[0], abs_x, abs_y, tmp, &p->start_line); if(res1 == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&mask_buf[0], tmp); + lv_memzero(&mask_buf[0], tmp); } } @@ -957,7 +957,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma if(tmp < 0) tmp = 0; res2 = lv_draw_mask_line(&mask_buf[tmp], abs_x + tmp, abs_y, len - tmp, &p->end_line); if(res2 == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&mask_buf[tmp], len - tmp); + lv_memzero(&mask_buf[tmp], len - tmp); } if(res1 == res2) return res1; else return LV_DRAW_MASK_RES_CHANGED; @@ -991,7 +991,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma if(tmp > 0) { res1 = lv_draw_mask_line(&mask_buf[0], abs_x, abs_y, tmp, (lv_draw_mask_line_param_t *)&p->end_line); if(res1 == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&mask_buf[0], tmp); + lv_memzero(&mask_buf[0], tmp); } } @@ -999,7 +999,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma if(tmp < 0) tmp = 0; res2 = lv_draw_mask_line(&mask_buf[tmp], abs_x + tmp, abs_y, len - tmp, (lv_draw_mask_line_param_t *)&p->start_line); if(res2 == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&mask_buf[tmp], len - tmp); + lv_memzero(&mask_buf[tmp], len - tmp); } if(res1 == res2) return res1; else return LV_DRAW_MASK_RES_CHANGED; @@ -1077,13 +1077,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m int32_t last = rect.x1 - abs_x; if(last > len) return LV_DRAW_MASK_RES_TRANSP; if(last >= 0) { - lv_memset_00(&mask_buf[0], last); + lv_memzero(&mask_buf[0], last); } int32_t first = rect.x2 - abs_x + 1; if(first <= 0) return LV_DRAW_MASK_RES_TRANSP; else if(first < len) { - lv_memset_00(&mask_buf[first], len - first); + lv_memzero(&mask_buf[first], len - first); } if(last == 0 && first == len) return LV_DRAW_MASK_RES_FULL_COVER; else return LV_DRAW_MASK_RES_CHANGED; @@ -1095,7 +1095,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m int32_t last = rect.x2 - abs_x - first + 1; if(first + last > len) last = len - first; if(last >= 0) { - lv_memset_00(&mask_buf[first], last); + lv_memzero(&mask_buf[first], last); } } } @@ -1142,11 +1142,11 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m /*Clean the right side*/ cir_x_right = LV_CLAMP(0, cir_x_right + i, len); - lv_memset_00(&mask_buf[cir_x_right], len - cir_x_right); + lv_memzero(&mask_buf[cir_x_right], len - cir_x_right); /*Clean the left side*/ cir_x_left = LV_CLAMP(0, cir_x_left - aa_len + 1, len); - lv_memset_00(&mask_buf[0], cir_x_left); + lv_memzero(&mask_buf[0], cir_x_left); } else { for(i = 0; i < aa_len; i++) { @@ -1161,7 +1161,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m lv_coord_t clr_start = LV_CLAMP(0, cir_x_left + 1, len); lv_coord_t clr_len = LV_CLAMP(0, cir_x_right - clr_start, len - clr_start); - lv_memset_00(&mask_buf[clr_start], clr_len); + lv_memzero(&mask_buf[clr_start], clr_len); } return LV_DRAW_MASK_RES_CHANGED; @@ -1257,7 +1257,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_polygon(lv_opa_t * lv_point_t p2; } lines[2], tmp; uint16_t line_cnt = 0; - lv_memset_00(&lines, sizeof(lines)); + lv_memzero(&lines, sizeof(lines)); int psign_prev = 0; for(i = 0; i < param->cfg.point_cnt; i++) { lv_point_t p1 = param->cfg.points[i]; @@ -1367,9 +1367,9 @@ static void circ_calc_aa4(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t radi c->radius = radius; /*Allocate buffers*/ - if(c->buf) lv_mem_free(c->buf); + if(c->buf) lv_free(c->buf); - c->buf = lv_mem_alloc(radius * 6 + 6); /*Use uint16_t for opa_start_on_y and x_start_on_y*/ + c->buf = lv_malloc(radius * 6 + 6); /*Use uint16_t for opa_start_on_y and x_start_on_y*/ LV_ASSERT_MALLOC(c->buf); c->cir_opa = c->buf; c->opa_start_on_y = (uint16_t *)(c->buf + 2 * radius + 2); @@ -1384,7 +1384,7 @@ static void circ_calc_aa4(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t radi return; } - lv_coord_t * cir_x = lv_mem_buf_get((radius + 1) * 2 * 2 * sizeof(lv_coord_t)); + lv_coord_t * cir_x = lv_malloc((radius + 1) * 2 * 2 * sizeof(lv_coord_t)); lv_coord_t * cir_y = &cir_x[(radius + 1) * 2]; uint32_t y_8th_cnt = 0; @@ -1506,7 +1506,7 @@ static void circ_calc_aa4(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t radi y++; } - lv_mem_buf_release(cir_x); + lv_free(cir_x); } static lv_opa_t * get_next_line(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t y, lv_coord_t * len, @@ -1527,4 +1527,4 @@ LV_ATTRIBUTE_FAST_MEM static inline lv_opa_t mask_mix(lv_opa_t mask_act, lv_opa_ } -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ diff --git a/src/draw/lv_draw_mask.h b/src/draw/lv_draw_mask.h index b7e4e1cd20..160980a94d 100644 --- a/src/draw/lv_draw_mask.h +++ b/src/draw/lv_draw_mask.h @@ -23,7 +23,7 @@ extern "C" { * DEFINES *********************/ #define LV_MASK_ID_INV (-1) -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS # define _LV_MASK_MAX_NUM 16 #else # define _LV_MASK_MAX_NUM 1 @@ -51,7 +51,7 @@ typedef _lv_draw_mask_saved_t _lv_draw_mask_saved_arr_t[_LV_MASK_MAX_NUM]; -#if LV_DRAW_COMPLEX == 0 +#if LV_USE_DRAW_MASKS == 0 static inline uint8_t lv_draw_mask_get_cnt(void) { return 0; @@ -65,7 +65,7 @@ static inline bool lv_draw_mask_is_any(const lv_area_t * a) #endif -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS enum { LV_DRAW_MASK_TYPE_LINE, @@ -163,7 +163,7 @@ typedef struct { 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 _lv_draw_mask_radius_circle_dsc_t _lv_draw_mask_radius_circle_dsc_arr_t[LV_DRAW_SW_CIRCLE_CACHE_SIZE]; typedef struct { /*The first element must be the common descriptor*/ @@ -381,7 +381,7 @@ void lv_draw_mask_map_init(lv_draw_mask_map_param_t * param, const lv_area_t * c 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*/ +#endif /*LV_USE_DRAW_MASKS*/ /********************** * MACROS diff --git a/src/draw/lv_draw_rect.c b/src/draw/lv_draw_rect.c index f34854d9c4..42a5433d7a 100644 --- a/src/draw/lv_draw_rect.c +++ b/src/draw/lv_draw_rect.c @@ -36,7 +36,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc) { - lv_memset_00(dsc, sizeof(lv_draw_rect_dsc_t)); + lv_memzero(dsc, sizeof(lv_draw_rect_dsc_t)); dsc->bg_color = lv_color_white(); dsc->bg_grad.stops[0].color = lv_color_white(); dsc->bg_grad.stops[1].color = lv_color_black(); diff --git a/src/draw/lv_img_buf.c b/src/draw/lv_img_buf.c index 4c939dd83e..b924133ccc 100644 --- a/src/draw/lv_img_buf.c +++ b/src/draw/lv_img_buf.c @@ -57,7 +57,7 @@ lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA || dsc->header.cf == LV_IMG_CF_RGB565A8) { uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3; uint32_t px = dsc->header.w * y * px_size + x * px_size; - lv_memcpy_small(&p_color, &buf_u8[px], sizeof(lv_color_t)); + lv_memcpy(&p_color, &buf_u8[px], sizeof(lv_color_t)); #if LV_COLOR_SIZE == 32 p_color.ch.alpha = 0xFF; /*Only the color should be get so use a default alpha value*/ #endif @@ -244,12 +244,12 @@ void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_ if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) { uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3; uint32_t px = dsc->header.w * y * px_size + x * px_size; - lv_memcpy_small(&buf_u8[px], &c, px_size); + lv_memcpy(&buf_u8[px], &c, px_size); } else if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) { uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3; uint32_t px = dsc->header.w * y * px_size + x * px_size; - lv_memcpy_small(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/ + lv_memcpy(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/ } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) { buf_u8 += sizeof(lv_color32_t) * 2; /*Skip the palette*/ @@ -317,7 +317,7 @@ void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c) lv_color32_t c32; c32.full = lv_color_to32(c); uint8_t * buf = (uint8_t *)dsc->data; - lv_memcpy_small(&buf[id * sizeof(c32)], &c32, sizeof(c32)); + lv_memcpy(&buf[id * sizeof(c32)], &c32, sizeof(c32)); } /** @@ -330,26 +330,26 @@ void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c) lv_img_dsc_t * lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf) { /*Allocate image descriptor*/ - lv_img_dsc_t * dsc = lv_mem_alloc(sizeof(lv_img_dsc_t)); + lv_img_dsc_t * dsc = lv_malloc(sizeof(lv_img_dsc_t)); if(dsc == NULL) return NULL; - lv_memset_00(dsc, sizeof(lv_img_dsc_t)); + lv_memzero(dsc, sizeof(lv_img_dsc_t)); /*Get image data size*/ dsc->data_size = lv_img_buf_get_img_size(w, h, cf); if(dsc->data_size == 0) { - lv_mem_free(dsc); + lv_free(dsc); return NULL; } /*Allocate raw buffer*/ - dsc->data = lv_mem_alloc(dsc->data_size); + dsc->data = lv_malloc(dsc->data_size); if(dsc->data == NULL) { - lv_mem_free(dsc); + lv_free(dsc); return NULL; } - lv_memset_00((uint8_t *)dsc->data, dsc->data_size); + lv_memzero((uint8_t *)dsc->data, dsc->data_size); /*Fill in header*/ dsc->header.always_zero = 0; @@ -367,9 +367,9 @@ void lv_img_buf_free(lv_img_dsc_t * dsc) { if(dsc != NULL) { if(dsc->data != NULL) - lv_mem_free((void *)dsc->data); + lv_free((void *)dsc->data); - lv_mem_free(dsc); + lv_free(dsc); } } @@ -423,7 +423,7 @@ uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf) 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) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS if(angle == 0 && zoom == LV_IMG_ZOOM_NONE) { res->x1 = 0; res->y1 = 0; diff --git a/src/draw/lv_img_cache.c b/src/draw/lv_img_cache.c index 2caf512179..453a6cfc92 100644 --- a/src/draw/lv_img_cache.c +++ b/src/draw/lv_img_cache.c @@ -123,7 +123,7 @@ _lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color, i lv_res_t open_res = lv_img_decoder_open(&cached_src->dec_dsc, src, color, frame_id); if(open_res == LV_RES_INV) { LV_LOG_WARN("Image draw cannot open the image resource"); - lv_memset_00(cached_src, sizeof(_lv_img_cache_entry_t)); + lv_memzero(cached_src, sizeof(_lv_img_cache_entry_t)); cached_src->life = INT32_MIN; /*Make the empty entry very "weak" to force its us*/ return NULL; } @@ -155,11 +155,11 @@ void lv_img_cache_set_size(uint16_t new_entry_cnt) if(LV_GC_ROOT(_lv_img_cache_array) != NULL) { /*Clean the cache before free it*/ lv_img_cache_invalidate_src(NULL); - lv_mem_free(LV_GC_ROOT(_lv_img_cache_array)); + lv_free(LV_GC_ROOT(_lv_img_cache_array)); } /*Reallocate the cache*/ - LV_GC_ROOT(_lv_img_cache_array) = lv_mem_alloc(sizeof(_lv_img_cache_entry_t) * new_entry_cnt); + LV_GC_ROOT(_lv_img_cache_array) = lv_malloc(sizeof(_lv_img_cache_entry_t) * new_entry_cnt); LV_ASSERT_MALLOC(LV_GC_ROOT(_lv_img_cache_array)); if(LV_GC_ROOT(_lv_img_cache_array) == NULL) { entry_cnt = 0; @@ -168,7 +168,7 @@ void lv_img_cache_set_size(uint16_t new_entry_cnt) entry_cnt = new_entry_cnt; /*Clean the cache*/ - lv_memset_00(LV_GC_ROOT(_lv_img_cache_array), entry_cnt * sizeof(_lv_img_cache_entry_t)); + lv_memzero(LV_GC_ROOT(_lv_img_cache_array), entry_cnt * sizeof(_lv_img_cache_entry_t)); #endif } @@ -190,7 +190,7 @@ void lv_img_cache_invalidate_src(const void * src) lv_img_decoder_close(&cache[i].dec_dsc); } - lv_memset_00(&cache[i], sizeof(_lv_img_cache_entry_t)); + lv_memzero(&cache[i], sizeof(_lv_img_cache_entry_t)); } } #endif diff --git a/src/draw/lv_img_decoder.c b/src/draw/lv_img_decoder.c index 13050b8b79..b3f4249483 100644 --- a/src/draw/lv_img_decoder.c +++ b/src/draw/lv_img_decoder.c @@ -82,7 +82,7 @@ void _lv_img_decoder_init(void) */ lv_res_t lv_img_decoder_get_info(const void * src, lv_img_header_t * header) { - lv_memset_00(header, sizeof(lv_img_header_t)); + lv_memzero(header, sizeof(lv_img_header_t)); if(src == NULL) return LV_RES_INV; @@ -106,7 +106,7 @@ lv_res_t lv_img_decoder_get_info(const void * src, lv_img_header_t * header) lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_color_t color, int32_t frame_id) { - lv_memset_00(dsc, sizeof(lv_img_decoder_dsc_t)); + lv_memzero(dsc, sizeof(lv_img_decoder_dsc_t)); if(src == NULL) return LV_RES_INV; lv_img_src_t src_type = lv_img_src_get_type(src); @@ -121,7 +121,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co if(dsc->src_type == LV_IMG_SRC_FILE) { size_t fnlen = strlen(src); - dsc->src = lv_mem_alloc(fnlen + 1); + dsc->src = lv_malloc(fnlen + 1); LV_ASSERT_MALLOC(dsc->src); if(dsc->src == NULL) { LV_LOG_WARN("lv_img_decoder_open: out of memory"); @@ -150,7 +150,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co if(res == LV_RES_OK) return res; /*Prepare for the next loop*/ - lv_memset_00(&dsc->header, sizeof(lv_img_header_t)); + lv_memzero(&dsc->header, sizeof(lv_img_header_t)); dsc->error_msg = NULL; dsc->img_data = NULL; @@ -159,7 +159,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co } if(dsc->src_type == LV_IMG_SRC_FILE) - lv_mem_free((void *)dsc->src); + lv_free((void *)dsc->src); return res; } @@ -191,7 +191,7 @@ void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc) if(dsc->decoder->close_cb) dsc->decoder->close_cb(dsc->decoder, dsc); if(dsc->src_type == LV_IMG_SRC_FILE) { - lv_mem_free((void *)dsc->src); + lv_free((void *)dsc->src); dsc->src = NULL; } } @@ -208,7 +208,7 @@ lv_img_decoder_t * lv_img_decoder_create(void) LV_ASSERT_MALLOC(decoder); if(decoder == NULL) return NULL; - lv_memset_00(decoder, sizeof(lv_img_decoder_t)); + lv_memzero(decoder, sizeof(lv_img_decoder_t)); return decoder; } @@ -220,7 +220,7 @@ lv_img_decoder_t * lv_img_decoder_create(void) void lv_img_decoder_delete(lv_img_decoder_t * decoder) { _lv_ll_remove(&LV_GC_ROOT(_lv_img_decoder_ll), decoder); - lv_mem_free(decoder); + lv_free(decoder); } /** @@ -339,18 +339,18 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder /*If the file was open successfully save the file descriptor*/ if(dsc->user_data == NULL) { - dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t)); + dsc->user_data = lv_malloc(sizeof(lv_img_decoder_built_in_data_t)); LV_ASSERT_MALLOC(dsc->user_data); if(dsc->user_data == NULL) { LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); lv_fs_close(&f); return LV_RES_INV; } - lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t)); + lv_memzero(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t)); } lv_img_decoder_built_in_data_t * user_data = dsc->user_data; - lv_memcpy_small(&user_data->f, &f, sizeof(f)); + lv_memcpy(&user_data->f, &f, sizeof(f)); } else if(dsc->src_type == LV_IMG_SRC_VARIABLE) { /*The variables should have valid data*/ @@ -383,19 +383,19 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder /*Allocate the palette*/ if(dsc->user_data == NULL) { - dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t)); + dsc->user_data = lv_malloc(sizeof(lv_img_decoder_built_in_data_t)); LV_ASSERT_MALLOC(dsc->user_data); if(dsc->user_data == NULL) { LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); return LV_RES_INV; } - lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t)); + lv_memzero(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t)); } lv_img_decoder_built_in_data_t * user_data = dsc->user_data; - user_data->palette = lv_mem_alloc(palette_size * sizeof(lv_color_t)); + user_data->palette = lv_malloc(palette_size * sizeof(lv_color_t)); LV_ASSERT_MALLOC(user_data->palette); - user_data->opa = lv_mem_alloc(palette_size * sizeof(lv_opa_t)); + user_data->opa = lv_malloc(palette_size * sizeof(lv_opa_t)); LV_ASSERT_MALLOC(user_data->opa); if(user_data->palette == NULL || user_data->opa == NULL) { LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); @@ -497,10 +497,10 @@ void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_ds if(dsc->src_type == LV_IMG_SRC_FILE) { lv_fs_close(&user_data->f); } - if(user_data->palette) lv_mem_free(user_data->palette); - if(user_data->opa) lv_mem_free(user_data->opa); + if(user_data->palette) lv_free(user_data->palette); + if(user_data->opa) lv_free(user_data->opa); - lv_mem_free(user_data); + lv_free(user_data); dsc->user_data = NULL; } } @@ -594,7 +594,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l } lv_img_decoder_built_in_data_t * user_data = dsc->user_data; - uint8_t * fs_buf = lv_mem_buf_get(w); + uint8_t * fs_buf = lv_malloc(w); if(fs_buf == NULL) return LV_RES_INV; const uint8_t * data_tmp = NULL; @@ -621,7 +621,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l data_tmp++; } } - lv_mem_buf_release(fs_buf); + lv_free(fs_buf); return LV_RES_OK; } @@ -663,7 +663,7 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc, lv_img_decoder_built_in_data_t * user_data = dsc->user_data; - uint8_t * fs_buf = lv_mem_buf_get(w); + uint8_t * fs_buf = lv_malloc(w); if(fs_buf == NULL) return LV_RES_INV; const uint8_t * data_tmp = NULL; if(dsc->src_type == LV_IMG_SRC_VARIABLE) { @@ -700,6 +700,6 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc, data_tmp++; } } - lv_mem_buf_release(fs_buf); + lv_free(fs_buf); return LV_RES_OK; } diff --git a/src/draw/nxp/lv_gpu_nxp.c b/src/draw/nxp/lv_gpu_nxp.c index 46da9334a3..62d7c481df 100644 --- a/src/draw/nxp/lv_gpu_nxp.c +++ b/src/draw/nxp/lv_gpu_nxp.c @@ -317,7 +317,7 @@ static void lv_draw_nxp_rect(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t lv_draw_rect_dsc_t nxp_dsc; lv_memcpy(&nxp_dsc, dsc, sizeof(nxp_dsc)); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /* Draw only the shadow */ nxp_dsc.bg_opa = 0; nxp_dsc.bg_img_opa = 0; @@ -330,7 +330,7 @@ static void lv_draw_nxp_rect(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t nxp_dsc.shadow_opa = 0; nxp_dsc.bg_opa = dsc->bg_opa; done = (draw_nxp_bg(draw_ctx, &nxp_dsc, coords) == LV_RES_OK); -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ /* Draw the remaining parts */ nxp_dsc.shadow_opa = 0; @@ -393,7 +393,7 @@ static void lv_draw_nxp_arc(lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * { bool done = false; -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS if(dsc->opa <= LV_OPA_MIN) return; if(dsc->width == 0) @@ -409,7 +409,7 @@ static void lv_draw_nxp_arc(lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * VG_LITE_LOG_TRACE("VG-Lite draw arc failed. Fallback."); } #endif -#endif/*LV_DRAW_COMPLEX*/ +#endif/*LV_USE_DRAW_MASKS*/ if(!done) lv_draw_sw_arc(draw_ctx, dsc, center, radius, start_angle, end_angle); diff --git a/src/draw/nxp/pxp/lv_draw_pxp_blend.c b/src/draw/nxp/pxp/lv_draw_pxp_blend.c index c0a6ecafa9..adf9078915 100644 --- a/src/draw/nxp/pxp/lv_draw_pxp_blend.c +++ b/src/draw/nxp/pxp/lv_draw_pxp_blend.c @@ -386,7 +386,7 @@ static lv_res_t lv_gpu_nxp_pxp_blit_opa(lv_color_t * dest_buf, const lv_area_t * if(ROUND_UP(size, ALIGN_SIZE) >= LV_MEM_SIZE) PXP_RETURN_INV("Insufficient memory for temporary buffer. Please increase LV_MEM_SIZE."); - lv_color_t * tmp_buf = (lv_color_t *)lv_mem_buf_get(size); + lv_color_t * tmp_buf = (lv_color_t *)lv_malloc(size); if(!tmp_buf) PXP_RETURN_INV("Allocating temporary buffer failed."); @@ -401,7 +401,7 @@ static lv_res_t lv_gpu_nxp_pxp_blit_opa(lv_color_t * dest_buf, const lv_area_t * res = lv_gpu_nxp_pxp_blit_cover(tmp_buf, &tmp_area, dest_w, src_buf, src_area, dsc, cf); if(res != LV_RES_OK) { PXP_LOG_TRACE("Blit cover with full opacity failed."); - lv_mem_buf_release(tmp_buf); + lv_free(tmp_buf); return res; } @@ -410,7 +410,7 @@ static lv_res_t lv_gpu_nxp_pxp_blit_opa(lv_color_t * dest_buf, const lv_area_t * res = lv_gpu_nxp_pxp_blit_cf(dest_buf, dest_area, dest_stride, tmp_buf, &tmp_area, dsc, cf); /*Clean-up memory*/ - lv_mem_buf_release(tmp_buf); + lv_free(tmp_buf); return res; } diff --git a/src/draw/nxp/vglite/lv_draw_vglite_arc.c b/src/draw/nxp/vglite/lv_draw_vglite_arc.c index 194f03d88c..dafdb7f94b 100644 --- a/src/draw/nxp/vglite/lv_draw_vglite_arc.c +++ b/src/draw/nxp/vglite/lv_draw_vglite_arc.c @@ -120,7 +120,7 @@ lv_res_t lv_gpu_nxp_vglite_draw_arc(lv_draw_ctx_t * draw_ctx, const lv_draw_arc_ /* path: max size = 16 cubic bezier (7 words each) */ int32_t arc_path[16 * 7]; - lv_memset_00(arc_path, sizeof(arc_path)); + lv_memzero(arc_path, sizeof(arc_path)); /*** Init destination buffer ***/ if(lv_vglite_init_buf(&vgbuf, (uint32_t)dest_width, (uint32_t)dest_height, (uint32_t)dest_width * sizeof(lv_color_t), diff --git a/src/draw/nxp/vglite/lv_draw_vglite_rect.c b/src/draw/nxp/vglite/lv_draw_vglite_rect.c index bc1d55c852..c06bc68fb3 100644 --- a/src/draw/nxp/vglite/lv_draw_vglite_rect.c +++ b/src/draw/nxp/vglite/lv_draw_vglite_rect.c @@ -168,7 +168,7 @@ lv_res_t lv_gpu_nxp_vglite_draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_ #endif } - lv_memset_00(&gradient, sizeof(vg_lite_linear_gradient_t)); + lv_memzero(&gradient, sizeof(vg_lite_linear_gradient_t)); err = vg_lite_init_grad(&gradient); VG_LITE_ERR_RETURN_INV(err, "Init gradient failed"); diff --git a/src/draw/nxp/vglite/lv_gpu_nxp_vglite.c b/src/draw/nxp/vglite/lv_gpu_nxp_vglite.c index f65ec1d480..4152952b1a 100644 --- a/src/draw/nxp/vglite/lv_gpu_nxp_vglite.c +++ b/src/draw/nxp/vglite/lv_gpu_nxp_vglite.c @@ -93,7 +93,7 @@ lv_res_t lv_vglite_init_buf(vg_lite_buffer_t * vgbuf, uint32_t width, uint32_t h vgbuf->height = (int32_t)height; vgbuf->stride = (int32_t)stride; - lv_memset_00(&vgbuf->yuv, sizeof(vgbuf->yuv)); + lv_memzero(&vgbuf->yuv, sizeof(vgbuf->yuv)); vgbuf->memory = (void *)ptr; vgbuf->address = (uint32_t)vgbuf->memory; diff --git a/src/draw/sdl/lv_draw_sdl.c b/src/draw/sdl/lv_draw_sdl.c index e3cdf577a8..e0d7c1aebf 100644 --- a/src/draw/sdl/lv_draw_sdl.c +++ b/src/draw/sdl/lv_draw_sdl.c @@ -10,7 +10,7 @@ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl.h" #include "lv_draw_sdl_utils.h" @@ -62,7 +62,7 @@ void lv_draw_sdl_draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * ds void lv_draw_sdl_init_ctx(lv_disp_drv_t * disp_drv, lv_draw_ctx_t * draw_ctx) { _lv_draw_sdl_utils_init(); - lv_memset_00(draw_ctx, sizeof(lv_draw_sdl_ctx_t)); + lv_memzero(draw_ctx, sizeof(lv_draw_sdl_ctx_t)); draw_ctx->draw_rect = lv_draw_sdl_draw_rect; draw_ctx->draw_img = lv_draw_sdl_img_core; draw_ctx->draw_letter = lv_draw_sdl_draw_letter; @@ -76,8 +76,8 @@ void lv_draw_sdl_init_ctx(lv_disp_drv_t * disp_drv, lv_draw_ctx_t * draw_ctx) draw_ctx->layer_instance_size = sizeof(lv_draw_sdl_layer_ctx_t); lv_draw_sdl_ctx_t * draw_ctx_sdl = (lv_draw_sdl_ctx_t *) draw_ctx; draw_ctx_sdl->renderer = ((lv_draw_sdl_drv_param_t *) disp_drv->user_data)->renderer; - draw_ctx_sdl->internals = lv_mem_alloc(sizeof(lv_draw_sdl_context_internals_t)); - lv_memset_00(draw_ctx_sdl->internals, sizeof(lv_draw_sdl_context_internals_t)); + draw_ctx_sdl->internals = lv_malloc(sizeof(lv_draw_sdl_context_internals_t)); + lv_memzero(draw_ctx_sdl->internals, sizeof(lv_draw_sdl_context_internals_t)); lv_draw_sdl_texture_cache_init(draw_ctx_sdl); } @@ -85,7 +85,7 @@ void lv_draw_sdl_deinit_ctx(lv_disp_drv_t * disp_drv, lv_draw_ctx_t * draw_ctx) { lv_draw_sdl_ctx_t * draw_ctx_sdl = (lv_draw_sdl_ctx_t *) draw_ctx; lv_draw_sdl_texture_cache_deinit(draw_ctx_sdl); - lv_mem_free(draw_ctx_sdl->internals); + lv_free(draw_ctx_sdl->internals); _lv_draw_sdl_utils_deinit(); } @@ -100,4 +100,4 @@ SDL_Texture * lv_draw_sdl_create_screen_texture(SDL_Renderer * renderer, lv_coor * STATIC FUNCTIONS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl.h b/src/draw/sdl/lv_draw_sdl.h index 9b44a7b2f6..0fe0e93564 100644 --- a/src/draw/sdl/lv_draw_sdl.h +++ b/src/draw/sdl/lv_draw_sdl.h @@ -16,9 +16,9 @@ extern "C" { *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "../lv_draw.h" #include "../../core/lv_disp.h" @@ -87,7 +87,7 @@ SDL_Texture * lv_draw_sdl_create_screen_texture(SDL_Renderer * renderer, lv_coor * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ diff --git a/src/draw/sdl/lv_draw_sdl_arc.c b/src/draw/sdl/lv_draw_sdl_arc.c index 5786eaeb97..129f4cf147 100644 --- a/src/draw/sdl/lv_draw_sdl_arc.c +++ b/src/draw/sdl/lv_draw_sdl_arc.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl.h" #include "lv_draw_sdl_utils.h" @@ -151,17 +151,17 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords, const in int pitch; if(SDL_LockTexture(texture, &rect, (void **) &pixels, &pitch) != 0) return; - lv_opa_t * line_buf = lv_mem_buf_get(rect.w); + lv_opa_t * line_buf = lv_malloc(rect.w); for(lv_coord_t y = 0; y < rect.h; y++) { - lv_memset_ff(line_buf, rect.w); + lv_memset(line_buf, 0xff, rect.w); lv_coord_t abs_x = (lv_coord_t) coords->x1, abs_y = (lv_coord_t)(y + coords->y1), len = (lv_coord_t) rect.w; lv_draw_mask_res_t res; res = lv_draw_mask_apply_ids(line_buf, abs_x, abs_y, len, ids, ids_count); if(res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&pixels[y * pitch], 4 * rect.w); + lv_memzero(&pixels[y * pitch], 4 * rect.w); } else if(res == LV_DRAW_MASK_RES_FULL_COVER) { - lv_memset_ff(&pixels[y * pitch], 4 * rect.w); + lv_memset(&pixels[y * pitch], 0xff, 4 * rect.w); } else { for(int x = 0; x < rect.w; x++) { @@ -172,13 +172,13 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords, const in } if(caps) { for(int i = 0; i < 2; i++) { - lv_memset_ff(line_buf, rect.w); + lv_memset(line_buf, 0xff, rect.w); res = lv_draw_mask_apply_ids(line_buf, abs_x, abs_y, len, &caps[i], 1); if(res == LV_DRAW_MASK_RES_TRANSP) { /* Ignore */ } else if(res == LV_DRAW_MASK_RES_FULL_COVER) { - lv_memset_ff(&pixels[y * pitch], 4 * rect.w); + lv_memset(&pixels[y * pitch], 0xff, 4 * rect.w); } else { for(int x = 0; x < rect.w; x++) { @@ -191,7 +191,7 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords, const in } } } - lv_mem_buf_release(line_buf); + lv_free(line_buf); SDL_UnlockTexture(texture); } @@ -235,4 +235,4 @@ static void get_cap_area(int16_t angle, lv_coord_t thickness, uint16_t radius, c lv_area_move(out, center->x, center->y); } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_bg.c b/src/draw/sdl/lv_draw_sdl_bg.c index 48e0f6b190..fd4a803392 100644 --- a/src/draw/sdl/lv_draw_sdl_bg.c +++ b/src/draw/sdl/lv_draw_sdl_bg.c @@ -9,7 +9,7 @@ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../lv_draw_rect.h" #include "../lv_draw_img.h" @@ -103,4 +103,4 @@ static void draw_bg_img(lv_draw_sdl_ctx_t * ctx, const lv_area_t * coords, const lv_draw_rect((lv_draw_ctx_t *) ctx, dsc, coords); } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_composite.c b/src/draw/sdl/lv_draw_sdl_composite.c index e6007d1a52..57e0956c4d 100644 --- a/src/draw/sdl/lv_draw_sdl_composite.c +++ b/src/draw/sdl/lv_draw_sdl_composite.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../../misc/lv_gc.h" #include "../../core/lv_refr.h" @@ -79,7 +79,7 @@ bool lv_draw_sdl_composite_begin(lv_draw_sdl_ctx_t * ctx, const lv_area_t * coor if(!_lv_area_intersect(apply_area, &full_coords, clip_in)) return false; bool has_mask = lv_draw_mask_is_any(apply_area); - const bool draw_mask = has_mask && LV_GPU_SDL_CUSTOM_BLEND_MODE; + const bool draw_mask = has_mask && LV_DARW_SDL_CUSTOM_BLEND_MODE; const bool draw_blend = blend_mode != LV_BLEND_MODE_NORMAL; if(draw_mask || draw_blend) { lv_draw_sdl_context_internals_t * internals = ctx->internals; @@ -96,7 +96,7 @@ bool lv_draw_sdl_composite_begin(lv_draw_sdl_ctx_t * ctx, const lv_area_t * coor SDL_SetRenderTarget(ctx->renderer, internals->composition); SDL_SetRenderDrawColor(ctx->renderer, 255, 255, 255, 0); SDL_RenderClear(ctx->renderer); -#if LV_GPU_SDL_CUSTOM_BLEND_MODE +#if LV_DARW_SDL_CUSTOM_BLEND_MODE internals->mask = lv_draw_sdl_composite_texture_obtain(ctx, LV_DRAW_SDL_COMPOSITE_TEXTURE_ID_STREAM0, w, h); dump_masks(internals->mask, apply_area); #endif @@ -125,7 +125,7 @@ void lv_draw_sdl_composite_end(lv_draw_sdl_ctx_t * ctx, const lv_area_t * apply_ { lv_draw_sdl_context_internals_t * internals = ctx->internals; SDL_Rect src_rect = {0, 0, lv_area_get_width(apply_area), lv_area_get_height(apply_area)}; -#if LV_GPU_SDL_CUSTOM_BLEND_MODE +#if LV_DARW_SDL_CUSTOM_BLEND_MODE if(internals->mask) { SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_ZERO, @@ -148,7 +148,7 @@ void lv_draw_sdl_composite_end(lv_draw_sdl_ctx_t * ctx, const lv_area_t * apply_ case LV_BLEND_MODE_ADDITIVE: SDL_SetTextureBlendMode(internals->composition, SDL_BLENDMODE_ADD); break; -#if LV_GPU_SDL_CUSTOM_BLEND_MODE +#if LV_DARW_SDL_CUSTOM_BLEND_MODE case LV_BLEND_MODE_SUBTRACTIVE: { SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_SUBTRACT, SDL_BLENDFACTOR_ONE, @@ -193,9 +193,9 @@ SDL_Texture * lv_draw_sdl_composite_texture_obtain(lv_draw_sdl_ctx_t * ctx, lv_d access = SDL_TEXTUREACCESS_TARGET; } result = SDL_CreateTexture(ctx->renderer, LV_DRAW_SDL_TEXTURE_FORMAT, access, size, size); - tex_size = lv_mem_alloc(sizeof(lv_point_t)); + tex_size = lv_malloc(sizeof(lv_point_t)); tex_size->x = tex_size->y = size; - lv_draw_sdl_texture_cache_put_advanced(ctx, &mask_key, sizeof(composite_key_t), result, tex_size, lv_mem_free, 0); + lv_draw_sdl_texture_cache_put_advanced(ctx, &mask_key, sizeof(composite_key_t), result, tex_size, lv_free, 0); } return result; } @@ -232,17 +232,17 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords) int pitch; if(SDL_LockTexture(texture, &rect, (void **) &pixels, &pitch) != 0) return; - lv_opa_t * line_buf = lv_mem_buf_get(rect.w); + lv_opa_t * line_buf = lv_malloc(rect.w); for(lv_coord_t y = 0; y < rect.h; y++) { - lv_memset_ff(line_buf, rect.w); + lv_memset(line_buf, 0xff, rect.w); lv_coord_t abs_x = (lv_coord_t) coords->x1, abs_y = (lv_coord_t)(y + coords->y1), len = (lv_coord_t) rect.w; lv_draw_mask_res_t res; res = lv_draw_mask_apply(line_buf, abs_x, abs_y, len); if(res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&pixels[y * pitch], 4 * rect.w); + lv_memzero(&pixels[y * pitch], 4 * rect.w); } else if(res == LV_DRAW_MASK_RES_FULL_COVER) { - lv_memset_ff(&pixels[y * pitch], 4 * rect.w); + lv_memset(&pixels[y * pitch], 0xff, 4 * rect.w); } else { for(int x = 0; x < rect.w; x++) { @@ -252,8 +252,8 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords) } } } - lv_mem_buf_release(line_buf); + lv_free(line_buf); SDL_UnlockTexture(texture); } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_composite.h b/src/draw/sdl/lv_draw_sdl_composite.h index 72a2daef7c..f91c92e3b5 100644 --- a/src/draw/sdl/lv_draw_sdl_composite.h +++ b/src/draw/sdl/lv_draw_sdl_composite.h @@ -16,7 +16,7 @@ extern "C" { #include "../../lv_conf_internal.h" -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "lv_draw_sdl.h" #include "../../misc/lv_area.h" diff --git a/src/draw/sdl/lv_draw_sdl_img.c b/src/draw/sdl/lv_draw_sdl_img.c index 59a9fc00f7..a98acaefb5 100644 --- a/src/draw/sdl/lv_draw_sdl_img.c +++ b/src/draw/sdl/lv_draw_sdl_img.c @@ -9,7 +9,7 @@ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../lv_draw_img.h" #include "../lv_img_cache.h" @@ -254,7 +254,7 @@ static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img { lv_coord_t h = (lv_coord_t) dsc->header.h; lv_coord_t w = (lv_coord_t) dsc->header.w; - uint8_t * data = lv_mem_buf_get(w * h * sizeof(lv_color_t)); + uint8_t * data = lv_malloc(w * h * sizeof(lv_color_t)); for(lv_coord_t y = 0; y < h; y++) { lv_img_decoder_read_line(dsc, 0, y, w, &data[y * w * sizeof(lv_color_t)]); } @@ -267,7 +267,7 @@ static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img SDL_SetColorKey(surface, SDL_TRUE, lv_color_to32(LV_COLOR_CHROMA_KEY)); SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface); SDL_FreeSurface(surface); - lv_mem_buf_release(data); + lv_free(data); return texture; } @@ -398,7 +398,7 @@ static SDL_Texture * img_rounded_frag_obtain(lv_draw_sdl_ctx_t * ctx, SDL_Textur SDL_SetTextureAlphaMod(texture, 0xFF); SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF); -#if LV_GPU_SDL_CUSTOM_BLEND_MODE +#if LV_DARW_SDL_CUSTOM_BLEND_MODE SDL_BlendMode blend_mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_DST_ALPHA, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD); @@ -461,4 +461,4 @@ static lv_draw_img_rounded_key_t rounded_key_create(const SDL_Texture * texture, return key; } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_img.h b/src/draw/sdl/lv_draw_sdl_img.h index 0e27027721..ea169d010c 100644 --- a/src/draw/sdl/lv_draw_sdl_img.h +++ b/src/draw/sdl/lv_draw_sdl_img.h @@ -16,9 +16,9 @@ extern "C" { *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "../lv_draw.h" @@ -63,7 +63,7 @@ bool lv_draw_sdl_img_load_texture(lv_draw_sdl_ctx_t * ctx, lv_draw_sdl_cache_key * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ diff --git a/src/draw/sdl/lv_draw_sdl_label.c b/src/draw/sdl/lv_draw_sdl_label.c index b8c79ae4ab..3b450d7e7e 100644 --- a/src/draw/sdl/lv_draw_sdl_label.c +++ b/src/draw/sdl/lv_draw_sdl_label.c @@ -9,9 +9,9 @@ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "../lv_draw_label.h" #include "../../misc/lv_utils.h" @@ -122,12 +122,12 @@ void lv_draw_sdl_draw_letter(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t font_p = g.resolved_font; } const uint8_t * bmp = lv_font_get_glyph_bitmap(font_p, letter); - uint8_t * buf = lv_mem_alloc(g.box_w * g.box_h); + uint8_t * buf = lv_malloc(g.box_w * g.box_h); lv_sdl_to_8bpp(buf, bmp, g.box_w, g.box_h, g.box_w, g.bpp); SDL_Surface * mask = lv_sdl_create_opa_surface(buf, g.box_w, g.box_h, g.box_w); texture = SDL_CreateTextureFromSurface(renderer, mask); SDL_FreeSurface(mask); - lv_mem_free(buf); + lv_free(buf); lv_draw_sdl_texture_cache_put(ctx, &glyph_key, sizeof(glyph_key), texture); } if(!texture) { @@ -173,4 +173,4 @@ static lv_font_glyph_key_t font_key_glyph_create(const lv_font_t * font_p, uint3 return key; } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_layer.c b/src/draw/sdl/lv_draw_sdl_layer.c index 48bc1b8f9a..1ba083e324 100644 --- a/src/draw/sdl/lv_draw_sdl_layer.c +++ b/src/draw/sdl/lv_draw_sdl_layer.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../../core/lv_refr.h" @@ -129,4 +129,4 @@ void lv_draw_sdl_transform_areas_offset(lv_draw_sdl_ctx_t * ctx, bool has_compos * STATIC FUNCTIONS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_line.c b/src/draw/sdl/lv_draw_sdl_line.c index 8dd7b2e007..d895dcbaf7 100644 --- a/src/draw/sdl/lv_draw_sdl_line.c +++ b/src/draw/sdl/lv_draw_sdl_line.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl.h" #include "lv_draw_sdl_utils.h" @@ -110,7 +110,7 @@ void lv_draw_sdl_draw_line(lv_draw_ctx_t * draw_ctx, const lv_draw_line_dsc_t * static lv_draw_line_key_t line_key_create(const lv_draw_line_dsc_t * dsc, lv_coord_t length) { lv_draw_line_key_t key; - lv_memset_00(&key, sizeof(lv_draw_line_key_t)); + lv_memzero(&key, sizeof(lv_draw_line_key_t)); key.magic = LV_GPU_CACHE_KEY_MAGIC_LINE; key.length = length; key.width = dsc->width; @@ -151,4 +151,4 @@ static SDL_Texture * line_texture_create(lv_draw_sdl_ctx_t * sdl_ctx, const lv_d return texture; } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_mask.c b/src/draw/sdl/lv_draw_sdl_mask.c index 7bb5bbb3b4..c5231e3c43 100644 --- a/src/draw/sdl/lv_draw_sdl_mask.c +++ b/src/draw/sdl/lv_draw_sdl_mask.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../../misc/lv_gc.h" #include "lv_draw_sdl_mask.h" @@ -46,10 +46,10 @@ lv_opa_t * lv_draw_sdl_mask_dump_opa(const lv_area_t * coords, const int16_t * i SDL_assert(coords->x2 >= coords->x1); SDL_assert(coords->y2 >= coords->y1); lv_coord_t w = lv_area_get_width(coords), h = lv_area_get_height(coords); - lv_opa_t * mask_buf = lv_mem_buf_get(w * h); + lv_opa_t * mask_buf = lv_malloc(w * h); for(lv_coord_t y = 0; y < h; y++) { lv_opa_t * line_buf = &mask_buf[y * w]; - lv_memset_ff(line_buf, w); + lv_memset(line_buf, 0xff, w); lv_coord_t abs_x = (lv_coord_t) coords->x1, abs_y = (lv_coord_t)(y + coords->y1), len = (lv_coord_t) w; lv_draw_mask_res_t res; if(ids) { @@ -59,7 +59,7 @@ lv_opa_t * lv_draw_sdl_mask_dump_opa(const lv_area_t * coords, const int16_t * i res = lv_draw_mask_apply(line_buf, abs_x, abs_y, len); } if(res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(line_buf, w); + lv_memzero(line_buf, w); } } return mask_buf; @@ -71,7 +71,7 @@ SDL_Texture * lv_draw_sdl_mask_dump_texture(SDL_Renderer * renderer, const lv_ar lv_coord_t w = lv_area_get_width(coords), h = lv_area_get_height(coords); lv_opa_t * mask_buf = lv_draw_sdl_mask_dump_opa(coords, ids, ids_count); SDL_Surface * surface = lv_sdl_create_opa_surface(mask_buf, w, h, w); - lv_mem_buf_release(mask_buf); + lv_free(mask_buf); SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface); SDL_FreeSurface(surface); return texture; @@ -81,4 +81,4 @@ SDL_Texture * lv_draw_sdl_mask_dump_texture(SDL_Renderer * renderer, const lv_ar * STATIC FUNCTIONS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_mask.h b/src/draw/sdl/lv_draw_sdl_mask.h index a562d73d7d..0980c9a772 100644 --- a/src/draw/sdl/lv_draw_sdl_mask.h +++ b/src/draw/sdl/lv_draw_sdl_mask.h @@ -16,7 +16,7 @@ extern "C" { #include "../../lv_conf_internal.h" -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "lv_draw_sdl.h" #include "../../misc/lv_area.h" diff --git a/src/draw/sdl/lv_draw_sdl_polygon.c b/src/draw/sdl/lv_draw_sdl_polygon.c index c5df50cb94..28c1913f88 100644 --- a/src/draw/sdl/lv_draw_sdl_polygon.c +++ b/src/draw/sdl/lv_draw_sdl_polygon.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl.h" #include "lv_draw_sdl_utils.h" @@ -106,17 +106,17 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords) int pitch; if(SDL_LockTexture(texture, &rect, (void **) &pixels, &pitch) != 0) return; - lv_opa_t * line_buf = lv_mem_buf_get(rect.w); + lv_opa_t * line_buf = lv_malloc(rect.w); for(lv_coord_t y = 0; y < rect.h; y++) { - lv_memset_ff(line_buf, rect.w); + lv_memset(line_buf, 0xff, rect.w); lv_coord_t abs_x = (lv_coord_t) coords->x1, abs_y = (lv_coord_t)(y + coords->y1), len = (lv_coord_t) rect.w; lv_draw_mask_res_t res; res = lv_draw_mask_apply(line_buf, abs_x, abs_y, len); if(res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&pixels[y * pitch], 4 * rect.w); + lv_memzero(&pixels[y * pitch], 4 * rect.w); } else if(res == LV_DRAW_MASK_RES_FULL_COVER) { - lv_memset_ff(&pixels[y * pitch], 4 * rect.w); + lv_memset(&pixels[y * pitch], 0xff, 4 * rect.w); } else { for(int x = 0; x < rect.w; x++) { @@ -126,8 +126,8 @@ static void dump_masks(SDL_Texture * texture, const lv_area_t * coords) } } } - lv_mem_buf_release(line_buf); + lv_free(line_buf); SDL_UnlockTexture(texture); } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_priv.h b/src/draw/sdl/lv_draw_sdl_priv.h index 24a876218a..a249e8d058 100644 --- a/src/draw/sdl/lv_draw_sdl_priv.h +++ b/src/draw/sdl/lv_draw_sdl_priv.h @@ -16,9 +16,9 @@ extern "C" { *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "../lv_draw.h" #include "../../misc/lv_lru.h" @@ -63,7 +63,7 @@ typedef struct lv_draw_sdl_context_internals_t { * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ diff --git a/src/draw/sdl/lv_draw_sdl_rect.c b/src/draw/sdl/lv_draw_sdl_rect.c index a303ac7643..129e28afe9 100644 --- a/src/draw/sdl/lv_draw_sdl_rect.c +++ b/src/draw/sdl/lv_draw_sdl_rect.c @@ -9,7 +9,7 @@ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../lv_draw_rect.h" #include "../lv_draw_img.h" @@ -424,7 +424,7 @@ static void draw_shadow(lv_draw_sdl_ctx_t * ctx, const lv_area_t * coords, const sw / 2 + sw % 2); texture = lv_sdl_create_opa_texture(ctx->renderer, mask_buf, blur_frag_size, blur_frag_size, lv_area_get_width(&mask_area_blurred)); - lv_mem_buf_release(mask_buf); + lv_free(mask_buf); lv_draw_mask_remove_id(mask_id); SDL_assert(texture); lv_draw_sdl_texture_cache_put(ctx, &key, sizeof(key), texture); @@ -709,4 +709,4 @@ static lv_draw_rect_border_key_t rect_border_key_create(lv_coord_t rout, lv_coor return key; } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_rect.h b/src/draw/sdl/lv_draw_sdl_rect.h index 1e9be34459..fec6581275 100644 --- a/src/draw/sdl/lv_draw_sdl_rect.h +++ b/src/draw/sdl/lv_draw_sdl_rect.h @@ -16,9 +16,9 @@ extern "C" { *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "../lv_draw.h" @@ -66,7 +66,7 @@ void lv_draw_sdl_rect_bg_frag_draw_corners(lv_draw_sdl_ctx_t * ctx, SDL_Texture * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ diff --git a/src/draw/sdl/lv_draw_sdl_stack_blur.c b/src/draw/sdl/lv_draw_sdl_stack_blur.c index 1c411b0ee9..529e794486 100644 --- a/src/draw/sdl/lv_draw_sdl_stack_blur.c +++ b/src/draw/sdl/lv_draw_sdl_stack_blur.c @@ -8,7 +8,7 @@ *********************/ #include "lv_draw_sdl_stack_blur.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL /********************* * DEFINES *********************/ @@ -246,4 +246,4 @@ static void stack_blur_job(lv_opa_t * src, unsigned int w, unsigned int h, unsig } } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_stack_blur.h b/src/draw/sdl/lv_draw_sdl_stack_blur.h index 413b1c949f..d432edef86 100644 --- a/src/draw/sdl/lv_draw_sdl_stack_blur.h +++ b/src/draw/sdl/lv_draw_sdl_stack_blur.h @@ -15,7 +15,7 @@ extern "C" { #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "../../misc/lv_color.h" @@ -37,7 +37,7 @@ void lv_stack_blur_grayscale(lv_opa_t * buf, uint16_t w, uint16_t h, uint16_t r) * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ diff --git a/src/draw/sdl/lv_draw_sdl_texture_cache.c b/src/draw/sdl/lv_draw_sdl_texture_cache.c index 6845addf50..1375f18e07 100644 --- a/src/draw/sdl/lv_draw_sdl_texture_cache.c +++ b/src/draw/sdl/lv_draw_sdl_texture_cache.c @@ -9,7 +9,7 @@ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl_texture_cache.h" @@ -56,7 +56,7 @@ static draw_cache_value_t * draw_cache_get_entry(lv_draw_sdl_ctx_t * ctx, const void lv_draw_sdl_texture_cache_init(lv_draw_sdl_ctx_t * ctx) { - ctx->internals->texture_cache = lv_lru_create(LV_GPU_SDL_LRU_SIZE, 65536, + ctx->internals->texture_cache = lv_lru_create(LV_DARW_SDL_LRU_SIZE, 65536, (lv_lru_free_t *) draw_cache_free_value, NULL); } @@ -174,5 +174,5 @@ static draw_cache_value_t * draw_cache_get_entry(lv_draw_sdl_ctx_t * ctx, const return value; } -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_texture_cache.h b/src/draw/sdl/lv_draw_sdl_texture_cache.h index dc8b578e6a..4335a6a078 100644 --- a/src/draw/sdl/lv_draw_sdl_texture_cache.h +++ b/src/draw/sdl/lv_draw_sdl_texture_cache.h @@ -16,9 +16,9 @@ extern "C" { #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH #include "lv_draw_sdl.h" #include "lv_draw_sdl_priv.h" #include "../../draw/lv_img_decoder.h" @@ -93,7 +93,7 @@ lv_draw_sdl_cache_key_head_img_t * lv_draw_sdl_texture_img_key_create(const void /********************** * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ diff --git a/src/draw/sdl/lv_draw_sdl_utils.c b/src/draw/sdl/lv_draw_sdl_utils.c index 3ca0fad453..4bed35caae 100644 --- a/src/draw/sdl/lv_draw_sdl_utils.c +++ b/src/draw/sdl/lv_draw_sdl_utils.c @@ -8,7 +8,7 @@ *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl_utils.h" @@ -180,4 +180,4 @@ void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, * STATIC FUNCTIONS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ diff --git a/src/draw/sdl/lv_draw_sdl_utils.h b/src/draw/sdl/lv_draw_sdl_utils.h index 9afae6879a..530a461a0c 100644 --- a/src/draw/sdl/lv_draw_sdl_utils.h +++ b/src/draw/sdl/lv_draw_sdl_utils.h @@ -14,13 +14,13 @@ extern "C" { *********************/ #include "../../lv_conf_internal.h" -#if LV_USE_GPU_SDL +#if LV_USE_DRAW_SDL #include "lv_draw_sdl.h" #include "../../misc/lv_color.h" #include "../../misc/lv_area.h" -#include LV_GPU_SDL_INCLUDE_PATH +#include LV_DARW_SDL_INCLUDE_PATH /********************* * DEFINES @@ -57,7 +57,7 @@ void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, * MACROS **********************/ -#endif /*LV_USE_GPU_SDL*/ +#endif /*LV_USE_DRAW_SDL*/ #ifdef __cplusplus } /*extern "C"*/ #endif diff --git a/src/draw/sw/lv_draw_sw.c b/src/draw/sw/lv_draw_sw.c index 1c0c6d4a2a..791ef080a3 100644 --- a/src/draw/sw/lv_draw_sw.c +++ b/src/draw/sw/lv_draw_sw.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "../lv_draw.h" +#if LV_USE_DRAW_SW + #include "lv_draw_sw.h" /********************* @@ -42,7 +44,7 @@ void lv_draw_sw_init_ctx(lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx) LV_UNUSED(drv); lv_draw_sw_ctx_t * draw_sw_ctx = (lv_draw_sw_ctx_t *) draw_ctx; - lv_memset_00(draw_sw_ctx, sizeof(lv_draw_sw_ctx_t)); + lv_memzero(draw_sw_ctx, sizeof(lv_draw_sw_ctx_t)); draw_sw_ctx->base_draw.draw_arc = lv_draw_sw_arc; draw_sw_ctx->base_draw.draw_rect = lv_draw_sw_rect; @@ -51,9 +53,7 @@ void lv_draw_sw_init_ctx(lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx) draw_sw_ctx->base_draw.draw_img_decoded = lv_draw_sw_img_decoded; draw_sw_ctx->base_draw.draw_line = lv_draw_sw_line; draw_sw_ctx->base_draw.draw_polygon = lv_draw_sw_polygon; -#if LV_DRAW_COMPLEX draw_sw_ctx->base_draw.draw_transform = lv_draw_sw_transform; -#endif draw_sw_ctx->base_draw.wait_for_finish = lv_draw_sw_wait_for_finish; draw_sw_ctx->base_draw.buffer_copy = lv_draw_sw_buffer_copy; draw_sw_ctx->base_draw.layer_init = lv_draw_sw_layer_create; @@ -69,7 +69,7 @@ void lv_draw_sw_deinit_ctx(lv_disp_drv_t * drv, lv_draw_ctx_t * draw_ctx) LV_UNUSED(drv); lv_draw_sw_ctx_t * draw_sw_ctx = (lv_draw_sw_ctx_t *) draw_ctx; - lv_memset_00(draw_sw_ctx, sizeof(lv_draw_sw_ctx_t)); + lv_memzero(draw_sw_ctx, sizeof(lv_draw_sw_ctx_t)); } void lv_draw_sw_wait_for_finish(lv_draw_ctx_t * draw_ctx) @@ -106,3 +106,5 @@ void lv_draw_sw_buffer_copy(lv_draw_ctx_t * draw_ctx, /********************** * STATIC FUNCTIONS **********************/ + +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw.h b/src/draw/sw/lv_draw_sw.h index 1618649cfd..c9cf60f6fe 100644 --- a/src/draw/sw/lv_draw_sw.h +++ b/src/draw/sw/lv_draw_sw.h @@ -14,6 +14,8 @@ extern "C" { * INCLUDES *********************/ #include "lv_draw_sw_blend.h" +#if LV_USE_DRAW_SW + #include "../lv_draw.h" #include "../../misc/lv_area.h" #include "../../misc/lv_color.h" @@ -97,6 +99,8 @@ void lv_draw_sw_layer_destroy(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * la * MACROS **********************/ +#endif /*LV_USE_DRAW_SW*/ + #ifdef __cplusplus } /*extern "C"*/ #endif diff --git a/src/draw/sw/lv_draw_sw_arc.c b/src/draw/sw/lv_draw_sw_arc.c index 3ed62b6ef8..ee7994d5f2 100644 --- a/src/draw/sw/lv_draw_sw_arc.c +++ b/src/draw/sw/lv_draw_sw_arc.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_math.h" #include "../../misc/lv_log.h" #include "../../misc/lv_mem.h" @@ -37,13 +39,13 @@ typedef struct { /********************** * STATIC PROTOTYPES **********************/ -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS static void draw_quarter_0(quarter_draw_dsc_t * q); static void draw_quarter_1(quarter_draw_dsc_t * q); static void draw_quarter_2(quarter_draw_dsc_t * q); static void draw_quarter_3(quarter_draw_dsc_t * q); static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t thickness, lv_area_t * res_area); -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ /********************** * STATIC VARIABLES @@ -60,7 +62,7 @@ typedef struct { 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) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS if(dsc->opa <= LV_OPA_MIN) return; if(dsc->width == 0) return; if(start_angle == end_angle) return; @@ -212,21 +214,21 @@ void lv_draw_sw_arc(lv_draw_ctx_t * draw_ctx, const lv_draw_arc_dsc_t * dsc, con draw_ctx->clip_area = clip_area_ori; } #else - LV_LOG_WARN("Can't draw arc with LV_DRAW_COMPLEX == 0"); + LV_LOG_WARN("Can't draw arc with LV_USE_DRAW_MASKS == 0"); LV_UNUSED(center); LV_UNUSED(radius); LV_UNUSED(start_angle); LV_UNUSED(end_angle); LV_UNUSED(draw_ctx); LV_UNUSED(dsc); -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ } /********************** * STATIC FUNCTIONS **********************/ -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS static void draw_quarter_0(quarter_draw_dsc_t * q) { const lv_area_t * clip_area_ori = q->draw_ctx->clip_area; @@ -534,4 +536,5 @@ static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t thickness } } -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_blend.c b/src/draw/sw/lv_draw_sw_blend.c index 428aba62ca..10fa75f75c 100644 --- a/src/draw/sw/lv_draw_sw_blend.c +++ b/src/draw/sw/lv_draw_sw_blend.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_math.h" #include "../../hal/lv_hal_disp.h" #include "../../core/lv_refr.h" @@ -30,15 +32,11 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(lv_color_t * dest_buf, const lv_ar lv_coord_t dest_stride, lv_color_t color, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride); -#if LV_COLOR_SCREEN_TRANSP LV_ATTRIBUTE_FAST_MEM static void fill_argb(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, lv_color_t color, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride); -#endif /*LV_COLOR_SCREEN_TRANSP*/ -#if LV_DRAW_COMPLEX static void fill_blended(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, lv_color_t color, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride, lv_blend_mode_t blend_mode); -#endif /*LV_DRAW_COMPLEX*/ static void map_set_px(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, const lv_color_t * src_buf, lv_coord_t src_stride, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride); @@ -46,14 +44,10 @@ static void map_set_px(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_co LV_ATTRIBUTE_FAST_MEM static void map_normal(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, const lv_color_t * src_buf, lv_coord_t src_stride, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride); -#if LV_COLOR_SCREEN_TRANSP LV_ATTRIBUTE_FAST_MEM static void map_argb(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, const lv_color_t * src_buf, lv_coord_t src_stride, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride, lv_blend_mode_t blend_mode); -#endif /*LV_COLOR_SCREEN_TRANSP*/ - -#if LV_DRAW_COMPLEX static void map_blended(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, const lv_color_t * src_buf, lv_coord_t src_stride, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride, lv_blend_mode_t blend_mode); @@ -61,7 +55,6 @@ static void map_blended(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_c static inline lv_color_t color_blend_true_color_additive(lv_color_t fg, lv_color_t bg, lv_opa_t opa); static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_color_t bg, lv_opa_t opa); static inline lv_color_t color_blend_true_color_multiply(lv_color_t fg, lv_color_t bg, lv_opa_t opa); -#endif /*LV_DRAW_COMPLEX*/ /********************** * STATIC VARIABLES @@ -160,7 +153,6 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_blend_basic(lv_draw_ctx_t * draw_ctx, cons map_set_px(dest_buf, &blend_area, dest_stride, src_buf, src_stride, dsc->opa, mask, mask_stride); } } -#if LV_COLOR_SCREEN_TRANSP else if(disp->driver->screen_transp) { if(dsc->src_buf == NULL) { fill_argb(dest_buf, &blend_area, dest_stride, dsc->color, dsc->opa, mask, mask_stride); @@ -169,7 +161,6 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_blend_basic(lv_draw_ctx_t * draw_ctx, cons map_argb(dest_buf, &blend_area, dest_stride, src_buf, src_stride, dsc->opa, mask, mask_stride, dsc->blend_mode); } } -#endif else if(dsc->blend_mode == LV_BLEND_MODE_NORMAL) { if(dsc->src_buf == NULL) { fill_normal(dest_buf, &blend_area, dest_stride, dsc->color, dsc->opa, mask, mask_stride); @@ -179,14 +170,12 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_blend_basic(lv_draw_ctx_t * draw_ctx, cons } } else { -#if LV_DRAW_COMPLEX if(dsc->src_buf == NULL) { fill_blended(dest_buf, &blend_area, dest_stride, dsc->color, dsc->opa, mask, mask_stride, dsc->blend_mode); } else { map_blended(dest_buf, &blend_area, dest_stride, src_buf, src_stride, dsc->opa, mask, mask_stride, dsc->blend_mode); } -#endif } } @@ -362,7 +351,6 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(lv_color_t * dest_buf, const lv_ar } } -#if LV_COLOR_SCREEN_TRANSP static inline void set_px_argb(uint8_t * buf, lv_color_t color, lv_opa_t opa) { lv_color_t bg_color; @@ -515,9 +503,7 @@ LV_ATTRIBUTE_FAST_MEM static void fill_argb(lv_color_t * dest_buf, const lv_area } } } -#endif -#if LV_DRAW_COMPLEX static void fill_blended(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, lv_color_t color, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride, lv_blend_mode_t blend_mode) @@ -717,9 +703,6 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(lv_color_t * dest_buf, const lv_are } } - - -#if LV_COLOR_SCREEN_TRANSP LV_ATTRIBUTE_FAST_MEM static void map_argb(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, const lv_color_t * src_buf, lv_coord_t src_stride, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride, lv_blend_mode_t blend_mode) @@ -857,10 +840,7 @@ LV_ATTRIBUTE_FAST_MEM static void map_argb(lv_color_t * dest_buf, const lv_area_ } } } -#endif - -#if LV_DRAW_COMPLEX static void map_blended(lv_color_t * dest_buf, const lv_area_t * dest_area, lv_coord_t dest_stride, const lv_color_t * src_buf, lv_coord_t src_stride, lv_opa_t opa, const lv_opa_t * mask, lv_coord_t mask_stride, lv_blend_mode_t blend_mode) @@ -1034,6 +1014,3 @@ static inline lv_color_t color_blend_true_color_multiply(lv_color_t fg, lv_color return lv_color_mix(fg, bg, opa); } - -#endif - diff --git a/src/draw/sw/lv_draw_sw_blend.h b/src/draw/sw/lv_draw_sw_blend.h index 9a00e533a3..584317ab85 100644 --- a/src/draw/sw/lv_draw_sw_blend.h +++ b/src/draw/sw/lv_draw_sw_blend.h @@ -13,10 +13,12 @@ extern "C" { /********************* * INCLUDES *********************/ +#include "../lv_draw_mask.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_color.h" #include "../../misc/lv_area.h" #include "../../misc/lv_style.h" -#include "../lv_draw_mask.h" /********************* * DEFINES @@ -62,6 +64,8 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_blend_basic(struct _lv_draw_ctx_t * draw_c * MACROS **********************/ +#endif /*LV_USE_DRAW_SW*/ + #ifdef __cplusplus } /*extern "C"*/ #endif diff --git a/src/draw/sw/lv_draw_sw_dither.c b/src/draw/sw/lv_draw_sw_dither.c index ff9ebf3d35..aeba23f8e8 100644 --- a/src/draw/sw/lv_draw_sw_dither.c +++ b/src/draw/sw/lv_draw_sw_dither.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw_dither.h" +#if LV_USE_DRAW_SW + #include "lv_draw_sw_gradient.h" #include "../../misc/lv_color.h" @@ -98,7 +100,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_dither_ordered_ver(lv_grad_t * grad, lv_coord_t x, } -#if LV_DITHER_ERROR_DIFFUSION == 1 +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 LV_ATTRIBUTE_FAST_MEM void lv_dither_err_diff_hor(lv_grad_t * grad, lv_coord_t xs, lv_coord_t y, lv_coord_t w) { LV_UNUSED(xs); @@ -211,3 +213,4 @@ LV_ATTRIBUTE_FAST_MEM void lv_dither_err_diff_ver(lv_grad_t * grad, lv_coord_t x } #endif #endif +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_dither.h b/src/draw/sw/lv_draw_sw_dither.h index 6362c5ac42..f99fe8c325 100644 --- a/src/draw/sw/lv_draw_sw_dither.h +++ b/src/draw/sw/lv_draw_sw_dither.h @@ -15,11 +15,12 @@ extern "C" { *********************/ #include "../../core/lv_obj_pos.h" +#if LV_USE_DRAW_SW /********************* * DEFINES *********************/ -#if LV_COLOR_DEPTH < 32 && LV_DITHER_GRADIENT == 1 +#if LV_COLOR_DEPTH < 32 && LV_DRAW_SW_GRADIENT_DITHER == 1 #define _DITHER_GRADIENT 1 #else #define _DITHER_GRADIENT 0 @@ -43,7 +44,6 @@ typedef void (*lv_dither_func_t)(struct _lv_gradient_cache_t * grad, lv_coord_t /********************** * 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); @@ -52,17 +52,16 @@ LV_ATTRIBUTE_FAST_MEM void lv_dither_ordered_hor(struct _lv_gradient_cache_t * g 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 +#if LV_DRAW_SW_GRADIENT_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 /* LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION */ #endif /* _DITHER_GRADIENT */ #endif - #ifdef __cplusplus } /*extern "C"*/ #endif diff --git a/src/draw/sw/lv_draw_sw_gradient.c b/src/draw/sw/lv_draw_sw_gradient.c index 4e4663266a..61c99df706 100644 --- a/src/draw/sw/lv_draw_sw_gradient.c +++ b/src/draw/sw/lv_draw_sw_gradient.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw_gradient.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_gc.h" #include "../../misc/lv_types.h" @@ -28,8 +30,8 @@ #define ALIGN(X) (((X) + 3) & ~3) #endif -#if LV_GRAD_CACHE_DEF_SIZE != 0 && LV_GRAD_CACHE_DEF_SIZE < 256 - #error "LV_GRAD_CACHE_DEF_SIZE is too small" +#if LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE != 0 && LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE < 256 + #error "LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE is too small" #endif /********************** @@ -74,7 +76,7 @@ static size_t get_cache_item_size(lv_grad_t * c) size_t s = ALIGN(sizeof(*c)) + ALIGN(c->alloc_size * sizeof(lv_color_t)); #if _DITHER_GRADIENT s += ALIGN(c->size * sizeof(lv_color32_t)); -#if LV_DITHER_ERROR_DIFFUSION == 1 +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 s += ALIGN(c->w * sizeof(lv_scolor24_t)); #endif #endif @@ -127,13 +129,13 @@ static void free_item(lv_grad_t * c) c->map = (lv_color_t *)(((uint8_t *)c->map) - size); #if _DITHER_GRADIENT c->hmap = (lv_color32_t *)(((uint8_t *)c->hmap) - size); -#if LV_DITHER_ERROR_DIFFUSION == 1 +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 c->error_acc = (lv_scolor24_t *)(((uint8_t *)c->error_acc) - size); #endif #endif c = (lv_grad_t *)(((uint8_t *)c) + get_cache_item_size(c)); } - lv_memset_00(old + next_items_size, size); + lv_memzero(old + next_items_size, size); } } @@ -164,7 +166,7 @@ static lv_grad_t * allocate_item(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord size_t req_size = ALIGN(sizeof(lv_grad_t)) + ALIGN(map_size * sizeof(lv_color_t)); #if _DITHER_GRADIENT req_size += ALIGN(size * sizeof(lv_color32_t)); -#if LV_DITHER_ERROR_DIFFUSION == 1 +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 req_size += ALIGN(w * sizeof(lv_scolor24_t)); #endif #endif @@ -189,7 +191,7 @@ static lv_grad_t * allocate_item(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord } else { /*The cache is too small. Allocate the item manually and free it later.*/ - item = lv_mem_alloc(req_size); + item = lv_malloc(req_size); LV_ASSERT_MALLOC(item); if(item == NULL) return NULL; item->not_cached = 1; @@ -206,7 +208,7 @@ static lv_grad_t * allocate_item(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord item->map = (lv_color_t *)(p + ALIGN(sizeof(*item))); #if _DITHER_GRADIENT item->hmap = (lv_color32_t *)(p + ALIGN(sizeof(*item)) + ALIGN(map_size * sizeof(lv_color_t))); -#if LV_DITHER_ERROR_DIFFUSION == 1 +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 item->error_acc = (lv_scolor24_t *)(p + ALIGN(sizeof(*item)) + ALIGN(size * sizeof(lv_grad_color_t)) + ALIGN(map_size * sizeof(lv_color_t))); item->w = w; @@ -217,7 +219,7 @@ static lv_grad_t * allocate_item(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord item->map = (lv_color_t *)(grad_cache_end + ALIGN(sizeof(*item))); #if _DITHER_GRADIENT item->hmap = (lv_color32_t *)(grad_cache_end + ALIGN(sizeof(*item)) + ALIGN(map_size * sizeof(lv_color_t))); -#if LV_DITHER_ERROR_DIFFUSION == 1 +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 item->error_acc = (lv_scolor24_t *)(grad_cache_end + ALIGN(sizeof(*item)) + ALIGN(size * sizeof(lv_grad_color_t)) + ALIGN(map_size * sizeof(lv_color_t))); item->w = w; @@ -234,17 +236,17 @@ static lv_grad_t * allocate_item(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord **********************/ void lv_gradient_free_cache(void) { - lv_mem_free(LV_GC_ROOT(_lv_grad_cache_mem)); + lv_free(LV_GC_ROOT(_lv_grad_cache_mem)); LV_GC_ROOT(_lv_grad_cache_mem) = grad_cache_end = NULL; grad_cache_size = 0; } void lv_gradient_set_cache_size(size_t max_bytes) { - lv_mem_free(LV_GC_ROOT(_lv_grad_cache_mem)); - grad_cache_end = LV_GC_ROOT(_lv_grad_cache_mem) = lv_mem_alloc(max_bytes); + lv_free(LV_GC_ROOT(_lv_grad_cache_mem)); + grad_cache_end = LV_GC_ROOT(_lv_grad_cache_mem) = lv_malloc(max_bytes); LV_ASSERT_MALLOC(LV_GC_ROOT(_lv_grad_cache_mem)); - lv_memset_00(LV_GC_ROOT(_lv_grad_cache_mem), max_bytes); + lv_memzero(LV_GC_ROOT(_lv_grad_cache_mem), max_bytes); grad_cache_size = max_bytes; } @@ -256,7 +258,7 @@ lv_grad_t * lv_gradient_get(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord_t h) /* Step 0: Check if the cache exist (else create it) */ static bool inited = false; if(!inited) { - lv_gradient_set_cache_size(LV_GRAD_CACHE_DEF_SIZE); + lv_gradient_set_cache_size(LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE); inited = true; } @@ -281,8 +283,8 @@ lv_grad_t * lv_gradient_get(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord_t h) for(lv_coord_t i = 0; i < item->size; i++) { item->hmap[i] = lv_gradient_calculate(g, item->size, i); } -#if LV_DITHER_ERROR_DIFFUSION == 1 - lv_memset_00(item->error_acc, w * sizeof(lv_scolor24_t)); +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION == 1 + lv_memzero(item->error_acc, w * sizeof(lv_scolor24_t)); #endif #else for(lv_coord_t i = 0; i < item->size; i++) { @@ -341,6 +343,8 @@ LV_ATTRIBUTE_FAST_MEM lv_grad_color_t lv_gradient_calculate(const lv_grad_dsc_t void lv_gradient_cleanup(lv_grad_t * grad) { if(grad->not_cached) { - lv_mem_free(grad); + lv_free(grad); } } + +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_gradient.h b/src/draw/sw/lv_draw_sw_gradient.h index f5f3215ced..8692b70e7a 100644 --- a/src/draw/sw/lv_draw_sw_gradient.h +++ b/src/draw/sw/lv_draw_sw_gradient.h @@ -13,9 +13,11 @@ extern "C" { /********************* * INCLUDES *********************/ +#include "lv_draw_sw_dither.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_color.h" #include "../../misc/lv_style.h" -#include "lv_draw_sw_dither.h" /********************* * DEFINES @@ -51,7 +53,7 @@ typedef struct _lv_gradient_cache_t { #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 +#if LV_DRAW_SW_GRADIENT_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 */ @@ -90,6 +92,8 @@ lv_grad_t * lv_gradient_get(const lv_grad_dsc_t * gradient, lv_coord_t w, lv_coo */ void lv_gradient_cleanup(lv_grad_t * grad); +#endif /*LV_USE_DRAW_SW*/ + #ifdef __cplusplus } /*extern "C"*/ #endif diff --git a/src/draw/sw/lv_draw_sw_img.c b/src/draw/sw/lv_draw_sw_img.c index 9578bc7cc3..0ca963dc3f 100644 --- a/src/draw/sw/lv_draw_sw_img.c +++ b/src/draw/sw/lv_draw_sw_img.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../lv_img_cache.h" #include "../../hal/lv_hal_disp.h" #include "../../misc/lv_log.h" @@ -55,7 +57,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_c lv_area_t blend_area; lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(lv_draw_sw_blend_dsc_t)); + lv_memzero(&blend_dsc, sizeof(lv_draw_sw_blend_dsc_t)); blend_dsc.opa = draw_dsc->opa; blend_dsc.blend_mode = draw_dsc->blend_mode; blend_dsc.blend_area = &blend_area; @@ -120,8 +122,8 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_c /*Create buffers and masks*/ uint32_t buf_size = buf_w * buf_h; - lv_color_t * rgb_buf = lv_mem_buf_get(buf_size * sizeof(lv_color_t)); - lv_opa_t * mask_buf = lv_mem_buf_get(buf_size); + lv_color_t * rgb_buf = lv_malloc(buf_size * sizeof(lv_color_t)); + lv_opa_t * mask_buf = lv_malloc(buf_size); blend_dsc.mask_buf = mask_buf; blend_dsc.mask_area = &blend_area; blend_dsc.mask_res = LV_DRAW_MASK_RES_CHANGED; @@ -159,7 +161,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_c rgb_buf[i] = lv_color_mix_premult(premult_v, rgb_buf[i], recolor_opa); } } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Apply the masks if any*/ if(mask_any) { lv_coord_t y; @@ -169,7 +171,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_c mask_res_line = lv_draw_mask_apply(mask_buf_tmp, blend_area.x1, y, blend_w); if(mask_res_line == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(mask_buf_tmp, blend_w); + lv_memzero(mask_buf_tmp, blend_w); blend_dsc.mask_res = LV_DRAW_MASK_RES_CHANGED; } else if(mask_res_line == LV_DRAW_MASK_RES_CHANGED) { @@ -178,7 +180,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_c mask_buf_tmp += blend_w; } } -#endif +#endif /*LV_USE_DRAW_MASKS*/ /*Blend*/ lv_draw_sw_blend(draw_ctx, &blend_dsc); @@ -189,8 +191,8 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_img_decoded(struct _lv_draw_ctx_t * draw_c if(blend_area.y2 > y_last) blend_area.y2 = y_last; } - lv_mem_buf_release(mask_buf); - lv_mem_buf_release(rgb_buf); + lv_free(mask_buf); + lv_free(rgb_buf); } } @@ -212,7 +214,7 @@ static void convert_cb(const lv_area_t * dest_area, const void * src_buf, lv_coo if(cf == LV_IMG_CF_TRUE_COLOR || cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) { uint32_t px_cnt = lv_area_get_size(dest_area); - lv_memset_ff(abuf, px_cnt); + lv_memset(abuf, 0xff, px_cnt); src_tmp8 += (src_stride * dest_area->y1 * sizeof(lv_color_t)) + dest_area->x1 * sizeof(lv_color_t); uint32_t dest_w = lv_area_get_width(dest_area); @@ -295,3 +297,5 @@ static void convert_cb(const lv_area_t * dest_area, const void * src_buf, lv_coo } } } + +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_layer.c b/src/draw/sw/lv_draw_sw_layer.c index 644012fee3..8e55b77909 100644 --- a/src/draw/sw/lv_draw_sw_layer.c +++ b/src/draw/sw/lv_draw_sw_layer.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../hal/lv_hal_disp.h" #include "../../misc/lv_area.h" #include "../../core/lv_refr.h" @@ -43,23 +45,18 @@ 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) { - if(LV_COLOR_SCREEN_TRANSP == 0 && (flags & LV_DRAW_LAYER_FLAG_HAS_ALPHA)) { - LV_LOG_WARN("Rendering this widget needs LV_COLOR_SCREEN_TRANSP 1"); - return NULL; - } - lv_draw_sw_layer_ctx_t * layer_sw_ctx = (lv_draw_sw_layer_ctx_t *) layer_ctx; uint32_t px_size = flags & LV_DRAW_LAYER_FLAG_HAS_ALPHA ? LV_IMG_PX_SIZE_ALPHA_BYTE : sizeof(lv_color_t); if(flags & LV_DRAW_LAYER_FLAG_CAN_SUBDIVIDE) { - layer_sw_ctx->buf_size_bytes = LV_LAYER_SIMPLE_BUF_SIZE; + layer_sw_ctx->buf_size_bytes = LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE; uint32_t full_size = lv_area_get_size(&layer_sw_ctx->base_draw.area_full) * px_size; if(layer_sw_ctx->buf_size_bytes > full_size) layer_sw_ctx->buf_size_bytes = full_size; - layer_sw_ctx->base_draw.buf = lv_mem_alloc(layer_sw_ctx->buf_size_bytes); + layer_sw_ctx->base_draw.buf = lv_malloc(layer_sw_ctx->buf_size_bytes); if(layer_sw_ctx->base_draw.buf == NULL) { LV_LOG_WARN("Cannot allocate %"LV_PRIu32" bytes for layer buffer. Allocating %"LV_PRIu32" bytes instead. (Reduced performance)", - (uint32_t)layer_sw_ctx->buf_size_bytes, (uint32_t)LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE * px_size); - layer_sw_ctx->buf_size_bytes = LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE; - layer_sw_ctx->base_draw.buf = lv_mem_alloc(layer_sw_ctx->buf_size_bytes); + (uint32_t)layer_sw_ctx->buf_size_bytes, (uint32_t)LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE * px_size); + layer_sw_ctx->buf_size_bytes = LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE; + layer_sw_ctx->base_draw.buf = lv_malloc(layer_sw_ctx->buf_size_bytes); if(layer_sw_ctx->base_draw.buf == NULL) { return NULL; } @@ -73,8 +70,8 @@ struct _lv_draw_layer_ctx_t * lv_draw_sw_layer_create(struct _lv_draw_ctx_t * dr else { layer_sw_ctx->base_draw.area_act = layer_sw_ctx->base_draw.area_full; layer_sw_ctx->buf_size_bytes = lv_area_get_size(&layer_sw_ctx->base_draw.area_full) * px_size; - layer_sw_ctx->base_draw.buf = lv_mem_alloc(layer_sw_ctx->buf_size_bytes); - lv_memset_00(layer_sw_ctx->base_draw.buf, layer_sw_ctx->buf_size_bytes); + layer_sw_ctx->base_draw.buf = lv_malloc(layer_sw_ctx->buf_size_bytes); + lv_memzero(layer_sw_ctx->base_draw.buf, layer_sw_ctx->buf_size_bytes); layer_sw_ctx->has_alpha = flags & LV_DRAW_LAYER_FLAG_HAS_ALPHA ? 1 : 0; if(layer_sw_ctx->base_draw.buf == NULL) { return NULL; @@ -98,7 +95,7 @@ void lv_draw_sw_layer_adjust(struct _lv_draw_ctx_t * draw_ctx, struct _lv_draw_l lv_draw_sw_layer_ctx_t * layer_sw_ctx = (lv_draw_sw_layer_ctx_t *) layer_ctx; lv_disp_t * disp_refr = _lv_refr_get_disp_refreshing(); if(flags & LV_DRAW_LAYER_FLAG_HAS_ALPHA) { - lv_memset_00(layer_ctx->buf, layer_sw_ctx->buf_size_bytes); + lv_memzero(layer_ctx->buf, layer_sw_ctx->buf_size_bytes); layer_sw_ctx->has_alpha = 1; disp_refr->driver->screen_transp = 1; } @@ -141,10 +138,12 @@ void lv_draw_sw_layer_destroy(lv_draw_ctx_t * draw_ctx, lv_draw_layer_ctx_t * la { LV_UNUSED(draw_ctx); - lv_mem_free(layer_ctx->buf); + lv_free(layer_ctx->buf); } /********************** * STATIC FUNCTIONS **********************/ + +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_letter.c b/src/draw/sw/lv_draw_sw_letter.c index 9522888c9e..aaef85fee7 100644 --- a/src/draw/sw/lv_draw_sw_letter.c +++ b/src/draw/sw/lv_draw_sw_letter.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../hal/lv_hal_disp.h" #include "../../misc/lv_math.h" #include "../../misc/lv_assert.h" @@ -31,10 +33,10 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_draw_ctx_t * draw_ctx, c const lv_point_t * pos, lv_font_glyph_dsc_t * g, const uint8_t * map_p); -#if LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX +#if LV_DRAW_SW_FONT_SUBPX static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc, const lv_point_t * pos, lv_font_glyph_dsc_t * g, const uint8_t * map_p); -#endif /*LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX*/ +#endif /*LV_DRAW_SW_FONT_SUBPX*/ /********************** * STATIC VARIABLES @@ -147,10 +149,10 @@ void lv_draw_sw_letter(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc } if(g.resolved_font->subpx) { -#if LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX +#if LV_DRAW_SW_FONT_SUBPX draw_letter_subpx(draw_ctx, dsc, &gpos, &g, map_p); #else - LV_LOG_WARN("Can't draw sub-pixel rendered letter because LV_USE_FONT_SUBPX == 0 in lv_conf.h"); + LV_LOG_WARN("Can't draw sub-pixel rendered letter because LV_DRAW_SW_FONT_SUBPX == 0 in lv_conf.h"); #endif } else { @@ -253,14 +255,14 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_draw_ctx_t * draw_ctx, c col_bit = bit_ofs & 0x7; /*"& 0x7" equals to "% 8" just faster*/ lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); + lv_memzero(&blend_dsc, sizeof(blend_dsc)); blend_dsc.color = dsc->color; blend_dsc.opa = dsc->opa; blend_dsc.blend_mode = dsc->blend_mode; lv_coord_t hor_res = lv_disp_get_hor_res(_lv_refr_get_disp_refreshing()); uint32_t mask_buf_size = box_w * box_h > hor_res ? hor_res : box_w * box_h; - lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size); + lv_opa_t * mask_buf = lv_malloc(mask_buf_size); blend_dsc.mask_buf = mask_buf; int32_t mask_p = 0; @@ -269,7 +271,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_draw_ctx_t * draw_ctx, c fill_area.x2 = col_end + pos->x - 1; fill_area.y1 = row_start + pos->y; fill_area.y2 = fill_area.y1; -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS lv_coord_t fill_w = lv_area_get_width(&fill_area); lv_area_t mask_area; lv_area_copy(&mask_area, &fill_area); @@ -283,7 +285,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_draw_ctx_t * draw_ctx, c uint32_t col_bit_row_ofs = (box_w + col_start - col_end) * bpp; for(row = row_start ; row < row_end; row++) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS int32_t mask_p_start = mask_p; #endif bitmask = bitmask_init >> col_bit; @@ -312,13 +314,13 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_draw_ctx_t * draw_ctx, c mask_p++; } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Apply masks if any*/ if(mask_any) { blend_dsc.mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, fill_area.x1, fill_area.y2, fill_w); if(blend_dsc.mask_res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(mask_buf + mask_p_start, fill_w); + lv_memzero(mask_buf + mask_p_start, fill_w); } } #endif @@ -348,10 +350,10 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_draw_ctx_t * draw_ctx, c mask_p = 0; } - lv_mem_buf_release(mask_buf); + lv_free(mask_buf); } -#if LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX +#if LV_DRAW_SW_FONT_SUBPX static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc, const lv_point_t * pos, lv_font_glyph_dsc_t * g, const uint8_t * map_p) { @@ -415,10 +417,10 @@ static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_ lv_coord_t hor_res = lv_disp_get_hor_res(_lv_refr_get_disp_refreshing()); int32_t mask_buf_size = box_w * box_h > hor_res ? hor_res : g->box_w * g->box_h; - lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size); + lv_opa_t * mask_buf = lv_malloc(mask_buf_size); int32_t mask_p = 0; - lv_color_t * color_buf = lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t)); + lv_color_t * color_buf = lv_malloc(mask_buf_size * sizeof(lv_color_t)); int32_t dest_buf_stride = lv_area_get_width(draw_ctx->buf_area); lv_color_t * dest_buf_tmp = draw_ctx->buf; @@ -443,7 +445,7 @@ static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_ #endif lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); + lv_memzero(&blend_dsc, sizeof(blend_dsc)); blend_dsc.blend_area = &map_area; blend_dsc.mask_area = &map_area; blend_dsc.src_buf = color_buf; @@ -488,7 +490,7 @@ static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_ }; #endif -#if LV_FONT_SUBPX_BGR +#if LV_DRAW_SW_FONT_SUBPX_BGR res_color.ch.blue = (uint32_t)((uint32_t)txt_rgb[0] * font_rgb[0] + (bg_rgb[0] * (255 - font_rgb[0]))) >> 8; res_color.ch.red = (uint32_t)((uint32_t)txt_rgb[2] * font_rgb[2] + (bg_rgb[2] * (255 - font_rgb[2]))) >> 8; #else @@ -529,15 +531,16 @@ static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_ } } +#if LV_USE_DRAW_MASKS /*Apply masks if any*/ if(mask_any) { blend_dsc.mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, map_area.x1, map_area.y2, lv_area_get_width(&map_area)); if(blend_dsc.mask_res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&map_area)); + lv_memzero(mask_buf + mask_p_start, lv_area_get_width(&map_area)); } } - +#endif if((int32_t) mask_p + (col_end - col_start) < mask_buf_size) { map_area.y2 ++; } @@ -566,8 +569,9 @@ static void draw_letter_subpx(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_ lv_draw_sw_blend(draw_ctx, &blend_dsc); } - lv_mem_buf_release(mask_buf); - lv_mem_buf_release(color_buf); + lv_free(mask_buf); + lv_free(color_buf); } -#endif /*LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX*/ +#endif /*LV_DRAW_SW_FONT_SUBPX*/ +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_line.c b/src/draw/sw/lv_draw_sw_line.c index 73833c164a..f7d8d9815a 100644 --- a/src/draw/sw/lv_draw_sw_line.c +++ b/src/draw/sw/lv_draw_sw_line.c @@ -8,6 +8,8 @@ *********************/ #include #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_math.h" #include "../../core/lv_refr.h" @@ -132,7 +134,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(struct _lv_draw_ctx_t * draw_ctx else if(dashed) simple_mode = false; lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); + lv_memzero(&blend_dsc, sizeof(blend_dsc)); blend_dsc.blend_area = &blend_area; blend_dsc.color = dsc->color; blend_dsc.opa = dsc->opa; @@ -141,7 +143,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(struct _lv_draw_ctx_t * draw_ctx if(simple_mode) { lv_draw_sw_blend(draw_ctx, &blend_dsc); } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*If there other mask apply it*/ else { @@ -155,12 +157,12 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(struct _lv_draw_ctx_t * draw_ctx dash_start = (blend_area.x1) % (dsc->dash_gap + dsc->dash_width); } - lv_opa_t * mask_buf = lv_mem_buf_get(blend_area_w); + lv_opa_t * mask_buf = lv_malloc(blend_area_w); blend_dsc.mask_buf = mask_buf; blend_dsc.mask_area = &blend_area; int32_t h; for(h = blend_area.y1; h <= y2; h++) { - lv_memset_ff(mask_buf, blend_area_w); + lv_memset(mask_buf, 0xff, blend_area_w); blend_dsc.mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, h, blend_area_w); if(dashed) { @@ -190,9 +192,9 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(struct _lv_draw_ctx_t * draw_ctx blend_area.y1++; blend_area.y2++; } - lv_mem_buf_release(mask_buf); + lv_free(mask_buf); } -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ } LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_line_dsc_t * dsc, @@ -218,7 +220,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(struct _lv_draw_ctx_t * draw_ctx else if(dashed) simple_mode = false; lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); + lv_memzero(&blend_dsc, sizeof(blend_dsc)); blend_dsc.blend_area = &blend_area; blend_dsc.color = dsc->color; blend_dsc.opa = dsc->opa; @@ -228,7 +230,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(struct _lv_draw_ctx_t * draw_ctx lv_draw_sw_blend(draw_ctx, &blend_dsc); } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*If there other mask apply it*/ else { int32_t draw_area_w = lv_area_get_width(&blend_area); @@ -236,7 +238,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(struct _lv_draw_ctx_t * draw_ctx lv_coord_t y2 = blend_area.y2; blend_area.y2 = blend_area.y1; - lv_opa_t * mask_buf = lv_mem_buf_get(draw_area_w); + lv_opa_t * mask_buf = lv_malloc(draw_area_w); blend_dsc.mask_buf = mask_buf; blend_dsc.mask_area = &blend_area; @@ -249,7 +251,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(struct _lv_draw_ctx_t * draw_ctx int32_t h; for(h = blend_area.y1; h <= y2; h++) { - lv_memset_ff(mask_buf, draw_area_w); + lv_memset(mask_buf, 0xff, draw_area_w); blend_dsc.mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, h, draw_area_w); if(dashed) { @@ -270,15 +272,15 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(struct _lv_draw_ctx_t * draw_ctx blend_area.y1++; blend_area.y2++; } - lv_mem_buf_release(mask_buf); + lv_free(mask_buf); } -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ } LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(struct _lv_draw_ctx_t * draw_ctx, const lv_draw_line_dsc_t * dsc, const lv_point_t * point1, const lv_point_t * point2) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Keep the great y in p1*/ lv_point_t p1; lv_point_t p2; @@ -377,16 +379,16 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(struct _lv_draw_ctx_t * draw_ct int32_t h; uint32_t hor_res = (uint32_t)lv_disp_get_hor_res(_lv_refr_get_disp_refreshing()); size_t mask_buf_size = LV_MIN(lv_area_get_size(&blend_area), hor_res); - lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size); + lv_opa_t * mask_buf = lv_malloc(mask_buf_size); lv_coord_t y2 = blend_area.y2; blend_area.y2 = blend_area.y1; uint32_t mask_p = 0; - lv_memset_ff(mask_buf, mask_buf_size); + lv_memset(mask_buf, 0xff, mask_buf_size); lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); + lv_memzero(&blend_dsc, sizeof(blend_dsc)); blend_dsc.blend_area = &blend_area; blend_dsc.color = dsc->color; blend_dsc.opa = dsc->opa; @@ -397,7 +399,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(struct _lv_draw_ctx_t * draw_ct for(h = blend_area.y1; h <= y2; h++) { blend_dsc.mask_res = lv_draw_mask_apply(&mask_buf[mask_p], blend_area.x1, h, draw_area_w); if(blend_dsc.mask_res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(&mask_buf[mask_p], draw_area_w); + lv_memzero(&mask_buf[mask_p], draw_area_w); } mask_p += draw_area_w; @@ -411,7 +413,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(struct _lv_draw_ctx_t * draw_ct blend_area.y1 = blend_area.y2 + 1; blend_area.y2 = blend_area.y1; mask_p = 0; - lv_memset_ff(mask_buf, mask_buf_size); + lv_memset(mask_buf, 0xff, mask_buf_size); } } @@ -422,7 +424,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(struct _lv_draw_ctx_t * draw_ct lv_draw_sw_blend(draw_ctx, &blend_dsc); } - lv_mem_buf_release(mask_buf); + lv_free(mask_buf); lv_draw_mask_free_param(&mask_left_param); lv_draw_mask_free_param(&mask_right_param); @@ -437,7 +439,8 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(struct _lv_draw_ctx_t * draw_ct LV_UNUSED(point2); LV_UNUSED(draw_ctx); LV_UNUSED(dsc); - LV_LOG_WARN("Can't draw skewed line with LV_DRAW_COMPLEX == 0"); -#endif /*LV_DRAW_COMPLEX*/ + LV_LOG_WARN("Can't draw skewed line with LV_USE_DRAW_MASKS == 0"); +#endif /*LV_USE_DRAW_MASKS*/ } +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_polygon.c b/src/draw/sw/lv_draw_sw_polygon.c index a05b4713e8..fd84618596 100644 --- a/src/draw/sw/lv_draw_sw_polygon.c +++ b/src/draw/sw/lv_draw_sw_polygon.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_math.h" #include "../../misc/lv_mem.h" #include "../../misc/lv_area.h" @@ -47,12 +49,12 @@ void lv_draw_sw_polygon(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * draw_dsc, const lv_point_t * points, uint16_t point_cnt) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS if(point_cnt < 3) return; if(points == NULL) return; /*Join adjacent points if they are on the same coordinate*/ - lv_point_t * p = lv_mem_buf_get(point_cnt * sizeof(lv_point_t)); + lv_point_t * p = lv_malloc(point_cnt * sizeof(lv_point_t)); if(p == NULL) return; uint16_t i; uint16_t pcnt = 0; @@ -71,7 +73,7 @@ void lv_draw_sw_polygon(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dra point_cnt = pcnt; if(point_cnt < 3) { - lv_mem_buf_release(p); + lv_free(p); return; } @@ -88,7 +90,7 @@ void lv_draw_sw_polygon(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dra lv_area_t clip_area; is_common = _lv_area_intersect(&clip_area, &poly_coords, draw_ctx->clip_area); if(!is_common) { - lv_mem_buf_release(p); + lv_free(p); return; } @@ -106,7 +108,7 @@ void lv_draw_sw_polygon(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dra } } - lv_draw_mask_line_param_t * mp = lv_mem_buf_get(sizeof(lv_draw_mask_line_param_t) * point_cnt); + lv_draw_mask_line_param_t * mp = lv_malloc(sizeof(lv_draw_mask_line_param_t) * point_cnt); lv_draw_mask_line_param_t * mp_next = mp; int32_t i_prev_left = y_min_i; @@ -189,8 +191,8 @@ void lv_draw_sw_polygon(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dra lv_draw_mask_remove_custom(mp); - lv_mem_buf_release(mp); - lv_mem_buf_release(p); + lv_free(mp); + lv_free(p); draw_ctx->clip_area = clip_area_ori; #else @@ -198,10 +200,12 @@ void lv_draw_sw_polygon(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dra LV_UNUSED(point_cnt); LV_UNUSED(draw_ctx); LV_UNUSED(draw_dsc); - LV_LOG_WARN("Can't draw polygon with LV_DRAW_COMPLEX == 0"); -#endif /*LV_DRAW_COMPLEX*/ + LV_LOG_WARN("Can't draw polygon with LV_USE_DRAW_MASKS == 0"); +#endif /*LV_USE_DRAW_MASKS*/ } /********************** * STATIC FUNCTIONS **********************/ + +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_rect.c b/src/draw/sw/lv_draw_sw_rect.c index 2b2ea98204..e5ebf8b150 100644 --- a/src/draw/sw/lv_draw_sw_rect.c +++ b/src/draw/sw/lv_draw_sw_rect.c @@ -7,6 +7,8 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_math.h" #include "../../misc/lv_txt_ap.h" #include "../../core/lv_refr.h" @@ -34,7 +36,7 @@ static void draw_border(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc static void draw_outline(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords); LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coords, uint16_t * sh_buf, lv_coord_t s, @@ -52,8 +54,8 @@ static void draw_border_simple(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer /********************** * STATIC VARIABLES **********************/ -#if defined(LV_SHADOW_CACHE_SIZE) && LV_SHADOW_CACHE_SIZE > 0 - static uint8_t sh_cache[LV_SHADOW_CACHE_SIZE * LV_SHADOW_CACHE_SIZE]; +#if defined(LV_DRAW_SW_SHADOW_CACHE_SIZE) && LV_DRAW_SW_SHADOW_CACHE_SIZE > 0 + static uint8_t sh_cache[LV_DRAW_SW_SHADOW_CACHE_SIZE * LV_DRAW_SW_SHADOW_CACHE_SIZE]; static int32_t sh_cache_size = -1; static int32_t sh_cache_r = -1; #endif @@ -68,7 +70,7 @@ static void draw_border_simple(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer void lv_draw_sw_rect(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS draw_shadow(draw_ctx, dsc, coords); #endif @@ -84,8 +86,11 @@ void lv_draw_sw_rect(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, c void lv_draw_sw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords) { -#if LV_COLOR_SCREEN_TRANSP && LV_COLOR_DEPTH == 32 - lv_memset_00(draw_ctx->buf, lv_area_get_size(draw_ctx->buf_area) * sizeof(lv_color_t)); +#if LV_COLOR_DEPTH == 32 + lv_disp_t * d = _lv_refr_get_disp_refreshing(); + if(d->driver->screen_transp) { + lv_memzero(draw_ctx->buf, lv_area_get_size(draw_ctx->buf_area) * sizeof(lv_color_t)); + } #endif draw_bg(draw_ctx, dsc, coords); @@ -133,8 +138,8 @@ static void draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, co } /*Complex case: there is gradient, mask, or radius*/ -#if LV_DRAW_COMPLEX == 0 - LV_LOG_WARN("Can't draw complex rectangle because LV_DRAW_COMPLEX = 0"); +#if LV_USE_DRAW_MASKS == 0 + LV_LOG_WARN("Can't draw complex rectangle because LV_USE_DRAW_MASKS = 0"); #else lv_opa_t opa = dsc->bg_opa >= LV_OPA_MAX ? LV_OPA_COVER : dsc->bg_opa; @@ -150,7 +155,7 @@ static void draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, co lv_opa_t * mask_buf = NULL; lv_draw_mask_radius_param_t mask_rout_param; if(rout > 0 || mask_any) { - mask_buf = lv_mem_buf_get(clipped_w); + mask_buf = lv_malloc(clipped_w); lv_draw_mask_radius_init(&mask_rout_param, &bg_coords, rout, false); mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL); } @@ -188,7 +193,7 @@ static void draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, co grad_size = coords_bg_h; } else -#if LV_DITHER_ERROR_DIFFUSION +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION if(dither_mode == LV_DITHER_ORDERED) #endif switch(grad_dir) { @@ -202,7 +207,7 @@ static void draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, co dither_func = NULL; } -#if LV_DITHER_ERROR_DIFFUSION +#if LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION else if(dither_mode == LV_DITHER_ERR_DIFF) switch(grad_dir) { case LV_GRAD_DIR_HOR: @@ -315,7 +320,7 @@ static void draw_bg(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, co bg_clean_up: - if(mask_buf) lv_mem_buf_release(mask_buf); + if(mask_buf) lv_free(mask_buf); if(mask_rout_id != LV_MASK_ID_INV) { lv_draw_mask_remove_id(mask_rout_id); lv_draw_mask_free_param(&mask_rout_param); @@ -429,7 +434,7 @@ static void draw_border(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords) { @@ -485,15 +490,15 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv lv_opa_t * sh_buf; -#if LV_SHADOW_CACHE_SIZE +#if LV_DRAW_SW_SHADOW_CACHE_SIZE if(sh_cache_size == corner_size && sh_cache_r == r_sh) { /*Use the cache if available*/ - sh_buf = lv_mem_buf_get(corner_size * corner_size); + sh_buf = lv_malloc(corner_size * corner_size); lv_memcpy(sh_buf, sh_cache, corner_size * corner_size); } else { /*A larger buffer is required for calculation*/ - sh_buf = lv_mem_buf_get(corner_size * corner_size * sizeof(uint16_t)); + sh_buf = lv_malloc(corner_size * corner_size * sizeof(uint16_t)); shadow_draw_corner_buf(&core_area, (uint16_t *)sh_buf, dsc->shadow_width, r_sh); /*Cache the corner if it fits into the cache size*/ @@ -504,7 +509,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv } } #else - sh_buf = lv_mem_buf_get(corner_size * corner_size * sizeof(uint16_t)); + sh_buf = lv_malloc(corner_size * corner_size * sizeof(uint16_t)); shadow_draw_corner_buf(&core_area, (uint16_t *)sh_buf, dsc->shadow_width, r_sh); #endif @@ -521,7 +526,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv lv_draw_mask_radius_init(&mask_rout_param, &bg_area, r_bg, true); mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL); } - lv_opa_t * mask_buf = lv_mem_buf_get(lv_area_get_width(&shadow_area)); + lv_opa_t * mask_buf = lv_malloc(lv_area_get_width(&shadow_area)); lv_area_t blend_area; lv_area_t clip_area_sub; lv_opa_t * sh_buf_tmp; @@ -529,7 +534,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv bool simple_sub; lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); + lv_memzero(&blend_dsc, sizeof(blend_dsc)); blend_dsc.blend_area = &blend_area; blend_dsc.mask_area = &blend_area; blend_dsc.mask_buf = mask_buf; @@ -928,7 +933,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv blend_area.y1 = y; blend_area.y2 = y; - lv_memset_ff(mask_buf, w); + lv_memset(mask_buf, 0xff, w); blend_dsc.mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w); lv_draw_sw_blend(draw_ctx, &blend_dsc); } @@ -939,8 +944,8 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(lv_draw_ctx_t * draw_ctx, const lv lv_draw_mask_free_param(&mask_rout_param); lv_draw_mask_remove_id(mask_rout_id); } - lv_mem_buf_release(sh_buf); - lv_mem_buf_release(mask_buf); + lv_free(sh_buf); + lv_free(mask_buf); } /** @@ -974,13 +979,13 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord #endif int32_t y; - lv_opa_t * mask_line = lv_mem_buf_get(size); + lv_opa_t * mask_line = lv_malloc(size); uint16_t * sh_ups_tmp_buf = (uint16_t *)sh_buf; for(y = 0; y < size; y++) { - lv_memset_ff(mask_line, size); + lv_memset(mask_line, 0xff, size); lv_draw_mask_res_t mask_res = mask_param.dsc.cb(mask_line, 0, y, size, &mask_param); if(mask_res == LV_DRAW_MASK_RES_TRANSP) { - lv_memset_00(sh_ups_tmp_buf, size * sizeof(sh_ups_tmp_buf[0])); + lv_memzero(sh_ups_tmp_buf, size * sizeof(sh_ups_tmp_buf[0])); } else { int32_t i; @@ -993,7 +998,7 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord sh_ups_tmp_buf += size; } - lv_mem_buf_release(mask_line); + lv_free(mask_line); lv_draw_mask_free_param(&mask_param); @@ -1044,7 +1049,7 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t if((sw & 1) == 0) s_left--; /*Horizontal blur*/ - uint16_t * sh_ups_blur_buf = lv_mem_buf_get(size * sizeof(uint16_t)); + uint16_t * sh_ups_blur_buf = lv_malloc(size * sizeof(uint16_t)); int32_t x; int32_t y; @@ -1107,7 +1112,7 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t } } - lv_mem_buf_release(sh_ups_blur_buf); + lv_free(sh_ups_blur_buf); } #endif @@ -1164,7 +1169,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, return; } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Get clipped draw area which is the real draw area. *It is always the same or inside `coords`*/ lv_area_t draw_area; @@ -1172,8 +1177,8 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, int32_t draw_area_w = lv_area_get_width(&draw_area); lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(blend_dsc)); - blend_dsc.mask_buf = lv_mem_buf_get(draw_area_w);; + lv_memzero(&blend_dsc, sizeof(blend_dsc)); + blend_dsc.mask_buf = lv_malloc(draw_area_w);; /*Create mask for the outer area*/ @@ -1219,7 +1224,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, blend_area.y1 = h; blend_area.y2 = h; - lv_memset_ff(blend_dsc.mask_buf, draw_area_w); + lv_memset(blend_dsc.mask_buf, 0xff, draw_area_w); blend_dsc.mask_res = lv_draw_mask_apply(blend_dsc.mask_buf, draw_area.x1, h, draw_area_w); lv_draw_sw_blend(draw_ctx, &blend_dsc); } @@ -1230,7 +1235,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, lv_draw_mask_free_param(&mask_rout_param); lv_draw_mask_remove_id(mask_rout_id); } - lv_mem_buf_release(blend_dsc.mask_buf); + lv_free(blend_dsc.mask_buf); return; } @@ -1292,7 +1297,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, lv_coord_t bottom_y = outer_area->y2 - h; if(top_y < draw_area.y1 && bottom_y > draw_area.y2) continue; /*This line is clipped now*/ - lv_memset_ff(blend_dsc.mask_buf, draw_area_w); + lv_memset(blend_dsc.mask_buf, 0xff, draw_area_w); blend_dsc.mask_res = lv_draw_mask_apply(blend_dsc.mask_buf, blend_area.x1, top_y, draw_area_w); if(top_y >= draw_area.y1) { @@ -1319,7 +1324,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, blend_area.y1 = h; blend_area.y2 = h; - lv_memset_ff(blend_dsc.mask_buf, blend_w); + lv_memset(blend_dsc.mask_buf, 0xff, blend_w); blend_dsc.mask_res = lv_draw_mask_apply(blend_dsc.mask_buf, blend_area.x1, h, blend_w); lv_draw_sw_blend(draw_ctx, &blend_dsc); } @@ -1330,7 +1335,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, blend_area.y1 = h; blend_area.y2 = h; - lv_memset_ff(blend_dsc.mask_buf, blend_w); + lv_memset(blend_dsc.mask_buf, 0xff, blend_w); blend_dsc.mask_res = lv_draw_mask_apply(blend_dsc.mask_buf, blend_area.x1, h, blend_w); lv_draw_sw_blend(draw_ctx, &blend_dsc); } @@ -1348,7 +1353,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, blend_area.y1 = h; blend_area.y2 = h; - lv_memset_ff(blend_dsc.mask_buf, blend_w); + lv_memset(blend_dsc.mask_buf, 0xff, blend_w); blend_dsc.mask_res = lv_draw_mask_apply(blend_dsc.mask_buf, blend_area.x1, h, blend_w); lv_draw_sw_blend(draw_ctx, &blend_dsc); } @@ -1359,7 +1364,7 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, blend_area.y1 = h; blend_area.y2 = h; - lv_memset_ff(blend_dsc.mask_buf, blend_w); + lv_memset(blend_dsc.mask_buf, 0xff, blend_w); blend_dsc.mask_res = lv_draw_mask_apply(blend_dsc.mask_buf, blend_area.x1, h, blend_w); lv_draw_sw_blend(draw_ctx, &blend_dsc); } @@ -1371,18 +1376,18 @@ void draw_border_generic(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, lv_draw_mask_remove_id(mask_rin_id); lv_draw_mask_free_param(&mask_rout_param); lv_draw_mask_remove_id(mask_rout_id); - lv_mem_buf_release(blend_dsc.mask_buf); + lv_free(blend_dsc.mask_buf); -#else /*LV_DRAW_COMPLEX*/ +#else /*LV_USE_DRAW_MASKS*/ LV_UNUSED(blend_mode); -#endif /*LV_DRAW_COMPLEX*/ +#endif /*LV_USE_DRAW_MASKS*/ } static void draw_border_simple(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer_area, const lv_area_t * inner_area, lv_color_t color, lv_opa_t opa) { lv_area_t a; lv_draw_sw_blend_dsc_t blend_dsc; - lv_memset_00(&blend_dsc, sizeof(lv_draw_sw_blend_dsc_t)); + lv_memzero(&blend_dsc, sizeof(lv_draw_sw_blend_dsc_t)); blend_dsc.blend_area = &a; blend_dsc.color = color; blend_dsc.opa = opa; @@ -1426,3 +1431,4 @@ static void draw_border_simple(lv_draw_ctx_t * draw_ctx, const lv_area_t * outer } } +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/draw/sw/lv_draw_sw_transform.c b/src/draw/sw/lv_draw_sw_transform.c index 80b1e6dea3..12fe89effd 100644 --- a/src/draw/sw/lv_draw_sw_transform.c +++ b/src/draw/sw/lv_draw_sw_transform.c @@ -7,11 +7,12 @@ * INCLUDES *********************/ #include "lv_draw_sw.h" +#if LV_USE_DRAW_SW + #include "../../misc/lv_assert.h" #include "../../misc/lv_area.h" #include "../../core/lv_refr.h" -#if LV_DRAW_COMPLEX /********************* * DEFINES *********************/ @@ -166,7 +167,7 @@ static void rgb_no_aa(const uint8_t * src, lv_coord_t src_w, lv_coord_t src_h, l lv_disp_t * d = _lv_refr_get_disp_refreshing(); lv_color_t ck = d->driver->color_chroma_key; - lv_memset_ff(abuf, x_end); + lv_memset(abuf, 0xff, x_end); lv_coord_t x; for(x = 0; x < x_end; x++) { @@ -492,5 +493,5 @@ static void transform_point_upscaled(point_transform_dsc_t * t, int32_t xin, int } } -#endif +#endif /*LV_USE_DRAW_SW*/ diff --git a/src/extra/layouts/flex/lv_flex.c b/src/extra/layouts/flex/lv_flex.c index 405a56b7fc..2e75a74443 100644 --- a/src/extra/layouts/flex/lv_flex.c +++ b/src/extra/layouts/flex/lv_flex.c @@ -291,7 +291,7 @@ static void flex_update(lv_obj_t * cont, void * user_data) } children_repos(cont, &f, track_first_item, next_track_first_item, abs_x, abs_y, max_main_size, item_gap, &t); track_first_item = next_track_first_item; - lv_mem_buf_release(t.grow_dsc); + lv_free(t.grow_dsc); t.grow_dsc = NULL; if(rtl && !f.row) { *cross_pos -= gap + track_gap; @@ -346,13 +346,13 @@ static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id t->grow_item_cnt++; t->track_fix_main_size += item_gap; if(t->grow_dsc_calc) { - grow_dsc_t * new_dsc = lv_mem_buf_get(sizeof(grow_dsc_t) * (t->grow_item_cnt)); + grow_dsc_t * new_dsc = lv_malloc(sizeof(grow_dsc_t) * (t->grow_item_cnt)); LV_ASSERT_MALLOC(new_dsc); if(new_dsc == NULL) return item_id; if(t->grow_dsc) { lv_memcpy(new_dsc, t->grow_dsc, sizeof(grow_dsc_t) * (t->grow_item_cnt - 1)); - lv_mem_buf_release(t->grow_dsc); + lv_free(t->grow_dsc); } new_dsc[t->grow_item_cnt - 1].item = item; new_dsc[t->grow_item_cnt - 1].min_size = f->row ? lv_obj_get_style_min_width(item, diff --git a/src/extra/layouts/grid/lv_grid.c b/src/extra/layouts/grid/lv_grid.c index 74f8e95fb2..d5d222b3fc 100644 --- a/src/extra/layouts/grid/lv_grid.c +++ b/src/extra/layouts/grid/lv_grid.c @@ -354,7 +354,7 @@ static void grid_update(lv_obj_t * cont, void * user_data) calc(cont, &c); item_repos_hint_t hint; - lv_memset_00(&hint, sizeof(hint)); + lv_memzero(&hint, sizeof(hint)); /*Calculate the grids absolute x and y coordinates. *It will be used as helper during item repositioning to avoid calculating this value for every children*/ @@ -391,7 +391,7 @@ static void grid_update(lv_obj_t * cont, void * user_data) static void calc(lv_obj_t * cont, _lv_grid_calc_t * calc_out) { if(lv_obj_get_child(cont, 0) == NULL) { - lv_memset_00(calc_out, sizeof(_lv_grid_calc_t)); + lv_memzero(calc_out, sizeof(_lv_grid_calc_t)); return; } @@ -424,10 +424,10 @@ static void calc(lv_obj_t * cont, _lv_grid_calc_t * calc_out) */ static void calc_free(_lv_grid_calc_t * calc) { - lv_mem_buf_release(calc->x); - lv_mem_buf_release(calc->y); - lv_mem_buf_release(calc->w); - lv_mem_buf_release(calc->h); + lv_free(calc->x); + lv_free(calc->y); + lv_free(calc->w); + lv_free(calc->h); } static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * c) @@ -436,8 +436,8 @@ static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * c) lv_coord_t cont_w = lv_obj_get_content_width(cont); c->col_num = count_tracks(col_templ); - c->x = lv_mem_buf_get(sizeof(lv_coord_t) * c->col_num); - c->w = lv_mem_buf_get(sizeof(lv_coord_t) * c->col_num); + c->x = lv_malloc(sizeof(lv_coord_t) * c->col_num); + c->w = lv_malloc(sizeof(lv_coord_t) * c->col_num); /*Set sizes for CONTENT cells*/ uint32_t i; @@ -507,8 +507,8 @@ static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * c) uint32_t i; const lv_coord_t * row_templ = get_row_dsc(cont); c->row_num = count_tracks(row_templ); - c->y = lv_mem_buf_get(sizeof(lv_coord_t) * c->row_num); - c->h = lv_mem_buf_get(sizeof(lv_coord_t) * c->row_num); + c->y = lv_malloc(sizeof(lv_coord_t) * c->row_num); + c->h = lv_malloc(sizeof(lv_coord_t) * c->row_num); /*Set sizes for CONTENT cells*/ for(i = 0; i < c->row_num; i++) { lv_coord_t size = LV_COORD_MIN; diff --git a/src/extra/libs/bmp/lv_bmp.c b/src/extra/libs/bmp/lv_bmp.c index f89a0a8c7b..8484b6cd87 100644 --- a/src/extra/libs/bmp/lv_bmp.c +++ b/src/extra/libs/bmp/lv_bmp.c @@ -173,7 +173,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * return LV_RES_INV; } - dsc->user_data = lv_mem_alloc(sizeof(bmp_dsc_t)); + dsc->user_data = lv_malloc(sizeof(bmp_dsc_t)); LV_ASSERT_MALLOC(dsc->user_data); if(dsc->user_data == NULL) return LV_RES_INV; memcpy(dsc->user_data, &b, sizeof(b)); @@ -251,7 +251,7 @@ static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc LV_UNUSED(decoder); bmp_dsc_t * b = dsc->user_data; lv_fs_close(&b->f); - lv_mem_free(dsc->user_data); + lv_free(dsc->user_data); } diff --git a/src/extra/libs/freetype/lv_freetype.c b/src/extra/libs/freetype/lv_freetype.c index 4bf6602223..284811c8da 100644 --- a/src/extra/libs/freetype/lv_freetype.c +++ b/src/extra/libs/freetype/lv_freetype.c @@ -353,9 +353,9 @@ static const uint8_t * get_glyph_bitmap_cb_cache(const lv_font_t * font, uint32_ static bool lv_ft_font_init_cache(lv_ft_info_t * info) { size_t need_size = sizeof(lv_font_fmt_ft_dsc_t) + sizeof(lv_font_t); - lv_font_fmt_ft_dsc_t * dsc = lv_mem_alloc(need_size); + lv_font_fmt_ft_dsc_t * dsc = lv_malloc(need_size); if(dsc == NULL) return false; - lv_memset_00(dsc, need_size); + lv_memzero(dsc, need_size); dsc->font = (lv_font_t *)(((char *)dsc) + sizeof(lv_font_fmt_ft_dsc_t)); dsc->mem = info->mem; @@ -396,7 +396,7 @@ static bool lv_ft_font_init_cache(lv_ft_info_t * info) return true; Fail: - lv_mem_free(dsc); + lv_free(dsc); return false; } @@ -410,7 +410,7 @@ void lv_ft_font_destroy_cache(lv_font_t * font) if(dsc) { FTC_Manager_RemoveFaceID(cache_manager, (FTC_FaceID)dsc); name_refer_del(dsc->name); - lv_mem_free(dsc); + lv_free(dsc); } } #else/* LV_FREETYPE_CACHE_SIZE */ @@ -443,7 +443,7 @@ static void face_remove_from_list(FT_Face face) while(pface) { if(*pface == face) { _lv_ll_remove(&face_control.face_ll, pface); - lv_mem_free(pface); + lv_free(pface); break; } pface = _lv_ll_get_next(&face_control.face_ll, pface); @@ -534,9 +534,9 @@ static const uint8_t * get_glyph_bitmap_cb_nocache(const lv_font_t * font, uint3 static bool lv_ft_font_init_nocache(lv_ft_info_t * info) { size_t need_size = sizeof(lv_font_fmt_ft_dsc_t) + sizeof(lv_font_t); - lv_font_fmt_ft_dsc_t * dsc = lv_mem_alloc(need_size); + lv_font_fmt_ft_dsc_t * dsc = lv_malloc(need_size); if(dsc == NULL) return false; - lv_memset_00(dsc, need_size); + lv_memzero(dsc, need_size); dsc->font = (lv_font_t *)(((char *)dsc) + sizeof(lv_font_fmt_ft_dsc_t)); dsc->mem = info->mem; @@ -594,7 +594,7 @@ static bool lv_ft_font_init_nocache(lv_ft_info_t * info) return true; Fail: - lv_mem_free(dsc); + lv_free(dsc); return false; } @@ -610,7 +610,7 @@ static void lv_ft_font_destroy_nocache(lv_font_t * font) FT_Done_Size(dsc->size); FT_Done_Face(face); name_refer_del(dsc->name); - lv_mem_free(dsc); + lv_free(dsc); } } @@ -645,8 +645,8 @@ static void name_refer_del(const char * name) refer->cnt -= 1; if(refer->cnt <= 0) { _lv_ll_remove(&names_ll, refer); - lv_mem_free((void *)refer->name); - lv_mem_free(refer); + lv_free((void *)refer->name); + lv_free(refer); } return; } @@ -671,14 +671,14 @@ static const char * name_refer_save(const char * name) name_refer_t * refer = _lv_ll_ins_tail(&names_ll); if(refer) { uint32_t len = strlen(name) + 1; - refer->name = lv_mem_alloc(len); + refer->name = lv_malloc(len); if(refer->name) { lv_memcpy((void *)refer->name, name, len); refer->cnt = 1; return refer->name; } _lv_ll_remove(&names_ll, refer); - lv_mem_free(refer); + lv_free(refer); } LV_LOG_WARN("save_name_to_names error(not memory)."); return ""; diff --git a/src/extra/libs/fsdrv/lv_fs_fatfs.c b/src/extra/libs/fsdrv/lv_fs_fatfs.c index cc1d2e6d65..fc81f5b6c9 100644 --- a/src/extra/libs/fsdrv/lv_fs_fatfs.c +++ b/src/extra/libs/fsdrv/lv_fs_fatfs.c @@ -110,7 +110,7 @@ static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode) else if(mode == LV_FS_MODE_RD) flags = FA_READ; else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = FA_READ | FA_WRITE | FA_OPEN_ALWAYS; - FIL * f = lv_mem_alloc(sizeof(FIL)); + FIL * f = lv_malloc(sizeof(FIL)); if(f == NULL) return NULL; FRESULT res = f_open(f, path, flags); @@ -118,7 +118,7 @@ static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode) return f; } else { - lv_mem_free(f); + lv_free(f); return NULL; } } @@ -134,7 +134,7 @@ static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p) { LV_UNUSED(drv); f_close(file_p); - lv_mem_free(file_p); + lv_free(file_p); return LV_FS_RES_OK; } @@ -225,12 +225,12 @@ static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p) static void * fs_dir_open(lv_fs_drv_t * drv, const char * path) { LV_UNUSED(drv); - DIR * d = lv_mem_alloc(sizeof(DIR)); + DIR * d = lv_malloc(sizeof(DIR)); if(d == NULL) return NULL; FRESULT res = f_opendir(d, path); if(res != FR_OK) { - lv_mem_free(d); + lv_free(d); d = NULL; } return d; @@ -276,7 +276,7 @@ static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p) { LV_UNUSED(drv); f_closedir(dir_p); - lv_mem_free(dir_p); + lv_free(dir_p); return LV_FS_RES_OK; } diff --git a/src/extra/libs/fsdrv/lv_fs_stdio.c b/src/extra/libs/fsdrv/lv_fs_stdio.c index c2de6880ed..00acad1fb4 100644 --- a/src/extra/libs/fsdrv/lv_fs_stdio.c +++ b/src/extra/libs/fsdrv/lv_fs_stdio.c @@ -206,14 +206,14 @@ static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p) static void * fs_dir_open(lv_fs_drv_t * drv, const char * path) { LV_UNUSED(drv); - dir_handle_t * handle = (dir_handle_t *)lv_mem_alloc(sizeof(dir_handle_t)); + dir_handle_t * handle = (dir_handle_t *)lv_malloc(sizeof(dir_handle_t)); #ifndef WIN32 /*Make the path relative to the current directory (the projects root folder)*/ char buf[MAX_PATH_LEN]; lv_snprintf(buf, sizeof(buf), LV_FS_STDIO_PATH "%s", path); handle->dir_p = opendir(buf); if(handle->dir_p == NULL) { - lv_mem_free(handle); + lv_free(handle); return NULL; } return handle; @@ -243,7 +243,7 @@ static void * fs_dir_open(lv_fs_drv_t * drv, const char * path) } while(FindNextFileA(handle->dir_p, &fdata)); if(handle->dir_p == INVALID_HANDLE_VALUE) { - lv_mem_free(handle); + lv_free(handle); return INVALID_HANDLE_VALUE; } return handle; @@ -315,7 +315,7 @@ static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p) #else FindClose(handle->dir_p); #endif - lv_mem_free(handle); + lv_free(handle); return LV_FS_RES_OK; } diff --git a/src/extra/libs/fsdrv/lv_fs_win32.c b/src/extra/libs/fsdrv/lv_fs_win32.c index 1a59aa496d..666f07147f 100644 --- a/src/extra/libs/fsdrv/lv_fs_win32.c +++ b/src/extra/libs/fsdrv/lv_fs_win32.c @@ -359,7 +359,7 @@ static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p) static void * fs_dir_open(lv_fs_drv_t * drv, const char * path) { LV_UNUSED(drv); - dir_handle_t * handle = (dir_handle_t *)lv_mem_alloc(sizeof(dir_handle_t)); + dir_handle_t * handle = (dir_handle_t *)lv_malloc(sizeof(dir_handle_t)); handle->dir_p = INVALID_HANDLE_VALUE; handle->next_error = LV_FS_RES_OK; WIN32_FIND_DATAA fdata; @@ -390,7 +390,7 @@ static void * fs_dir_open(lv_fs_drv_t * drv, const char * path) } while(FindNextFileA(handle->dir_p, &fdata)); if(handle->dir_p == INVALID_HANDLE_VALUE) { - lv_mem_free(handle); + lv_free(handle); handle->next_error = fs_error_from_win32(GetLastError()); return INVALID_HANDLE_VALUE; } @@ -453,7 +453,7 @@ static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p) lv_fs_res_t res = FindClose(handle->dir_p) ? LV_FS_RES_OK : fs_error_from_win32(GetLastError()); - lv_mem_free(handle); + lv_free(handle); return res; } diff --git a/src/extra/libs/gif/gifdec.c b/src/extra/libs/gif/gifdec.c index 68f50057e3..963bf14c19 100644 --- a/src/extra/libs/gif/gifdec.c +++ b/src/extra/libs/gif/gifdec.c @@ -108,11 +108,11 @@ static gd_GIF * gif_open(gd_GIF * gif_base) f_gif_read(gif_base, &aspect, 1); /* Create gd_GIF Structure. */ #if LV_COLOR_DEPTH == 32 - gif = lv_mem_alloc(sizeof(gd_GIF) + 5 * width * height); + gif = lv_malloc(sizeof(gd_GIF) + 5 * width * height); #elif LV_COLOR_DEPTH == 16 - gif = lv_mem_alloc(sizeof(gd_GIF) + 4 * width * height); + gif = lv_malloc(sizeof(gd_GIF) + 4 * width * height); #elif LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1 - gif = lv_mem_alloc(sizeof(gd_GIF) + 3 * width * height); + gif = lv_malloc(sizeof(gd_GIF) + 3 * width * height); #endif if (!gif) goto fail; @@ -291,7 +291,7 @@ new_table(int key_size) { int key; int init_bulk = MAX(1 << (key_size + 1), 0x100); - Table *table = lv_mem_alloc(sizeof(*table) + sizeof(Entry) * init_bulk); + Table *table = lv_malloc(sizeof(*table) + sizeof(Entry) * init_bulk); if (table) { table->bulk = init_bulk; table->nentries = (1 << key_size) + 2; @@ -312,7 +312,7 @@ add_entry(Table **tablep, uint16_t length, uint16_t prefix, uint8_t suffix) Table *table = *tablep; if (table->nentries == table->bulk) { table->bulk *= 2; - table = lv_mem_realloc(table, sizeof(*table) + sizeof(Entry) * table->bulk); + table = lv_realloc(table, sizeof(*table) + sizeof(Entry) * table->bulk); if (!table) return -1; table->entries = (Entry *) &table[1]; *tablep = table; @@ -413,7 +413,7 @@ read_image_data(gd_GIF *gif, int interlace) } else if (!table_is_full) { ret = add_entry(&table, str_len + 1, key, entry.suffix); if (ret == -1) { - lv_mem_free(table); + lv_free(table); return -1; } if (table->nentries == 0x1000) { @@ -443,7 +443,7 @@ read_image_data(gd_GIF *gif, int interlace) if (key < table->nentries - 1 && !table_is_full) table->entries[table->nentries - 1].suffix = entry.suffix; } - lv_mem_free(table); + lv_free(table); if (key == stop) f_gif_read(gif, &sub_len, 1); /* Must be zero! */ f_gif_seek(gif, end, LV_FS_SEEK_SET); return 0; @@ -605,7 +605,7 @@ void gd_close_gif(gd_GIF *gif) { f_gif_close(gif); - lv_mem_free(gif); + lv_free(gif); } static bool f_gif_open(gd_GIF * gif, const void * path, bool is_file) diff --git a/src/extra/libs/png/lodepng.c b/src/extra/libs/png/lodepng.c index 82e18e1a09..c61b17cd60 100644 --- a/src/extra/libs/png/lodepng.c +++ b/src/extra/libs/png/lodepng.c @@ -75,7 +75,7 @@ static void* lodepng_malloc(size_t size) { #ifdef LODEPNG_MAX_ALLOC if(size > LODEPNG_MAX_ALLOC) return 0; #endif - return lv_mem_alloc(size); + return lv_malloc(size); } /* NOTE: when realloc returns NULL, it leaves the original memory untouched */ @@ -83,11 +83,11 @@ static void* lodepng_realloc(void* ptr, size_t new_size) { #ifdef LODEPNG_MAX_ALLOC if(new_size > LODEPNG_MAX_ALLOC) return 0; #endif - return lv_mem_realloc(ptr, new_size); + return lv_realloc(ptr, new_size); } static void lodepng_free(void* ptr) { - lv_mem_free(ptr); + lv_free(ptr); } #else /*LODEPNG_COMPILE_ALLOCATORS*/ /* TODO: support giving additional void* payload to the custom allocators */ diff --git a/src/extra/libs/png/lv_png.c b/src/extra/libs/png/lv_png.c index d067ef5086..7f485fea79 100644 --- a/src/extra/libs/png/lv_png.c +++ b/src/extra/libs/png/lv_png.c @@ -152,10 +152,10 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * /*Decode the loaded image in ARGB8888 */ error = lodepng_decode32(&img_data, &png_width, &png_height, png_data, png_data_size); - lv_mem_free(png_data); /*Free the loaded file*/ + lv_free(png_data); /*Free the loaded file*/ if(error) { if(img_data != NULL) { - lv_mem_free(img_data); + lv_free(img_data); } LV_LOG_WARN("error %u: %s\n", error, lodepng_error_text(error)); return LV_RES_INV; @@ -178,7 +178,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * if(error) { if(img_data != NULL) { - lv_mem_free(img_data); + lv_free(img_data); } return LV_RES_INV; } @@ -200,7 +200,7 @@ static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc { LV_UNUSED(decoder); /*Unused*/ if(dsc->img_data) { - lv_mem_free((uint8_t *)dsc->img_data); + lv_free((uint8_t *)dsc->img_data); dsc->img_data = NULL; } } diff --git a/src/extra/libs/qrcode/lv_qrcode.c b/src/extra/libs/qrcode/lv_qrcode.c index 079873e138..67747eea51 100644 --- a/src/extra/libs/qrcode/lv_qrcode.c +++ b/src/extra/libs/qrcode/lv_qrcode.c @@ -101,9 +101,9 @@ lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_le qrcodegen_VERSION_MAX : qr_version + version_extend; } - uint8_t * qr0 = lv_mem_alloc(qrcodegen_BUFFER_LEN_FOR_VERSION(qr_version)); + uint8_t * qr0 = lv_malloc(qrcodegen_BUFFER_LEN_FOR_VERSION(qr_version)); LV_ASSERT_MALLOC(qr0); - uint8_t * data_tmp = lv_mem_alloc(qrcodegen_BUFFER_LEN_FOR_VERSION(qr_version)); + uint8_t * data_tmp = lv_malloc(qrcodegen_BUFFER_LEN_FOR_VERSION(qr_version)); LV_ASSERT_MALLOC(data_tmp); lv_memcpy(data_tmp, data, data_len); @@ -113,8 +113,8 @@ lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_le qrcodegen_Mask_AUTO, true); if(!ok) { - lv_mem_free(qr0); - lv_mem_free(data_tmp); + lv_free(qr0); + lv_free(data_tmp); return LV_RES_INV; } @@ -173,8 +173,8 @@ lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_le } } - lv_mem_free(qr0); - lv_mem_free(data_tmp); + lv_free(qr0); + lv_free(data_tmp); return LV_RES_OK; } @@ -193,7 +193,7 @@ static void lv_qrcode_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj LV_UNUSED(class_p); uint32_t buf_size = LV_CANVAS_BUF_SIZE_INDEXED_1BIT(size_param, size_param); - uint8_t * buf = lv_mem_alloc(buf_size); + uint8_t * buf = lv_malloc(buf_size); LV_ASSERT_MALLOC(buf); if(buf == NULL) return; @@ -208,7 +208,7 @@ static void lv_qrcode_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) lv_img_dsc_t * img = lv_canvas_get_img(obj); lv_img_cache_invalidate_src(img); - lv_mem_free((void *)img->data); + lv_free((void *)img->data); img->data = NULL; } diff --git a/src/extra/libs/rlottie/lv_rlottie.c b/src/extra/libs/rlottie/lv_rlottie.c index a264948c32..e208fa5a2f 100644 --- a/src/extra/libs/rlottie/lv_rlottie.c +++ b/src/extra/libs/rlottie/lv_rlottie.c @@ -127,7 +127,7 @@ static void lv_rlottie_constructor(const lv_obj_class_t * class_p, lv_obj_t * ob rlottie->scanline_width = create_width * LV_ARGB32 / 8; size_t allocaled_buf_size = (create_width * create_height * LV_ARGB32 / 8); - rlottie->allocated_buf = lv_mem_alloc(allocaled_buf_size); + rlottie->allocated_buf = lv_malloc(allocaled_buf_size); if(rlottie->allocated_buf != NULL) { rlottie->allocated_buffer_size = allocaled_buf_size; memset(rlottie->allocated_buf, 0, allocaled_buf_size); @@ -174,7 +174,7 @@ static void lv_rlottie_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj lv_img_cache_invalidate_src(&rlottie->imgdsc); if(rlottie->allocated_buf) { - lv_mem_free(rlottie->allocated_buf); + lv_free(rlottie->allocated_buf); rlottie->allocated_buf = NULL; rlottie->allocated_buffer_size = 0; } diff --git a/src/extra/libs/sjpg/lv_sjpg.c b/src/extra/libs/sjpg/lv_sjpg.c index 5a12ea2516..e65cfcb38d 100644 --- a/src/extra/libs/sjpg/lv_sjpg.c +++ b/src/extra/libs/sjpg/lv_sjpg.c @@ -180,7 +180,7 @@ static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_im header->always_zero = 0; header->cf = LV_IMG_CF_RAW; - uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + uint8_t * workb_temp = lv_malloc(TJPGD_WORKBUFF_SIZE); if(!workb_temp) return LV_RES_INV; io_source_t io_source_temp; @@ -203,7 +203,7 @@ static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_im } end: - lv_mem_free(workb_temp); + lv_free(workb_temp); return ret; @@ -251,7 +251,7 @@ end: lv_fs_res_t res = lv_fs_open(&file, fn, LV_FS_MODE_RD); if(res != LV_FS_RES_OK) return 78; - uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + uint8_t * workb_temp = lv_malloc(TJPGD_WORKBUFF_SIZE); if(!workb_temp) { lv_fs_close(&file); return LV_RES_INV; @@ -265,7 +265,7 @@ end: JDEC jd_tmp; JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp); - lv_mem_free(workb_temp); + lv_free(workb_temp); lv_fs_close(&file); if(rc == JDR_OK) { @@ -351,7 +351,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * SJPEG * sjpeg = (SJPEG *) dsc->user_data; const uint32_t raw_sjpeg_data_size = ((lv_img_dsc_t *)dsc->src)->data_size; if(sjpeg == NULL) { - sjpeg = lv_mem_alloc(sizeof(SJPEG)); + sjpeg = lv_malloc(sizeof(SJPEG)); if(!sjpeg) return LV_RES_INV; memset(sjpeg, 0, sizeof(SJPEG)); @@ -378,7 +378,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * sjpeg->sjpeg_single_frame_height = *data++; sjpeg->sjpeg_single_frame_height |= *data++ << 8; - sjpeg->frame_base_array = lv_mem_alloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames); + sjpeg->frame_base_array = lv_malloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames); if(! sjpeg->frame_base_array) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -396,7 +396,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * sjpeg->frame_base_array[i] = sjpeg->frame_base_array[i - 1] + offset; } sjpeg->sjpeg_cache_frame_index = -1; - sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3/*2*/); + sjpeg->frame_cache = (void *)lv_malloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3/*2*/); if(! sjpeg->frame_cache) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -404,14 +404,14 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * } sjpeg->io.img_cache_buff = sjpeg->frame_cache; sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res; - sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + sjpeg->workb = lv_malloc(TJPGD_WORKBUFF_SIZE); if(! sjpeg->workb) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; return LV_RES_INV; } - sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC)); + sjpeg->tjpeg_jd = lv_malloc(sizeof(JDEC)); if(! sjpeg->tjpeg_jd) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -424,7 +424,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * } else if(is_jpg(sjpeg->sjpeg_data, raw_sjpeg_data_size) == true) { - uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + uint8_t * workb_temp = lv_malloc(TJPGD_WORKBUFF_SIZE); if(! workb_temp) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -438,7 +438,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * JDEC jd_tmp; JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp); - lv_mem_free(workb_temp); + lv_free(workb_temp); if(rc == JDR_OK) { @@ -447,7 +447,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * sjpeg->sjpeg_total_frames = 1; sjpeg->sjpeg_single_frame_height = jd_tmp.height; - sjpeg->frame_base_array = lv_mem_alloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames); + sjpeg->frame_base_array = lv_malloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames); if(! sjpeg->frame_base_array) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -459,7 +459,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * sjpeg->frame_base_array[0] = img_frame_base; sjpeg->sjpeg_cache_frame_index = -1; - sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3); + sjpeg->frame_cache = (void *)lv_malloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3); if(! sjpeg->frame_cache) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -468,14 +468,14 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * sjpeg->io.img_cache_buff = sjpeg->frame_cache; sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res; - sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + sjpeg->workb = lv_malloc(TJPGD_WORKBUFF_SIZE); if(! sjpeg->workb) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; return LV_RES_INV; } - sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC)); + sjpeg->tjpeg_jd = lv_malloc(sizeof(JDEC)); if(! sjpeg->tjpeg_jd) { lv_sjpg_cleanup(sjpeg); sjpeg = NULL; @@ -493,7 +493,7 @@ static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * } end: - lv_mem_free(workb_temp); + lv_free(workb_temp); return lv_ret; } @@ -527,7 +527,7 @@ end: SJPEG * sjpeg = (SJPEG *) dsc->user_data; if(sjpeg == NULL) { - sjpeg = lv_mem_alloc(sizeof(SJPEG)); + sjpeg = lv_malloc(sizeof(SJPEG)); if(! sjpeg) { lv_fs_close(&lv_file); @@ -554,8 +554,8 @@ end: sjpeg->sjpeg_single_frame_height = *data++; sjpeg->sjpeg_single_frame_height |= *data++ << 8; - sjpeg->frame_base_array = NULL;//lv_mem_alloc( sizeof(uint8_t *) * sjpeg->sjpeg_total_frames ); - sjpeg->frame_base_offset = lv_mem_alloc(sizeof(int) * sjpeg->sjpeg_total_frames); + sjpeg->frame_base_array = NULL;//lv_malloc( sizeof(uint8_t *) * sjpeg->sjpeg_total_frames ); + sjpeg->frame_base_offset = lv_malloc(sizeof(int) * sjpeg->sjpeg_total_frames); if(! sjpeg->frame_base_offset) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -578,7 +578,7 @@ end: } sjpeg->sjpeg_cache_frame_index = -1; //INVALID AT BEGINNING for a forced compare mismatch at first time. - sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3); + sjpeg->frame_cache = (void *)lv_malloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3); if(! sjpeg->frame_cache) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -586,14 +586,14 @@ end: } sjpeg->io.img_cache_buff = sjpeg->frame_cache; sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res; - sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + sjpeg->workb = lv_malloc(TJPGD_WORKBUFF_SIZE); if(! sjpeg->workb) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); return LV_RES_INV; } - sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC)); + sjpeg->tjpeg_jd = lv_malloc(sizeof(JDEC)); if(! sjpeg->tjpeg_jd) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -616,7 +616,7 @@ end: SJPEG * sjpeg = (SJPEG *) dsc->user_data; if(sjpeg == NULL) { - sjpeg = lv_mem_alloc(sizeof(SJPEG)); + sjpeg = lv_malloc(sizeof(SJPEG)); if(! sjpeg) { lv_fs_close(&lv_file); return LV_RES_INV; @@ -628,7 +628,7 @@ end: sjpeg->sjpeg_data_size = ((lv_img_dsc_t *)(dsc->src))->data_size; } - uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + uint8_t * workb_temp = lv_malloc(TJPGD_WORKBUFF_SIZE); if(! workb_temp) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -645,7 +645,7 @@ end: JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp); - lv_mem_free(workb_temp); + lv_free(workb_temp); if(rc == JDR_OK) { @@ -655,7 +655,7 @@ end: sjpeg->sjpeg_single_frame_height = jd_tmp.height; sjpeg->frame_base_array = NULL; - sjpeg->frame_base_offset = lv_mem_alloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames); + sjpeg->frame_base_offset = lv_malloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames); if(! sjpeg->frame_base_offset) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -666,7 +666,7 @@ end: sjpeg->frame_base_offset[0] = img_frame_start_offset; sjpeg->sjpeg_cache_frame_index = -1; - sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3); + sjpeg->frame_cache = (void *)lv_malloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3); if(! sjpeg->frame_cache) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -675,14 +675,14 @@ end: sjpeg->io.img_cache_buff = sjpeg->frame_cache; sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res; - sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE); + sjpeg->workb = lv_malloc(TJPGD_WORKBUFF_SIZE); if(! sjpeg->workb) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); return LV_RES_INV; } - sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC)); + sjpeg->tjpeg_jd = lv_malloc(sizeof(JDEC)); if(! sjpeg->tjpeg_jd) { lv_fs_close(&lv_file); lv_sjpg_cleanup(sjpeg); @@ -696,7 +696,7 @@ end: } else { - if(dsc->user_data) lv_mem_free(dsc->user_data); + if(dsc->user_data) lv_free(dsc->user_data); lv_fs_close(&lv_file); return LV_RES_INV; } @@ -899,11 +899,11 @@ static int is_jpg(const uint8_t * raw_data, size_t len) static void lv_sjpg_free(SJPEG * sjpeg) { - if(sjpeg->frame_cache) lv_mem_free(sjpeg->frame_cache); - if(sjpeg->frame_base_array) lv_mem_free(sjpeg->frame_base_array); - if(sjpeg->frame_base_offset) lv_mem_free(sjpeg->frame_base_offset); - if(sjpeg->tjpeg_jd) lv_mem_free(sjpeg->tjpeg_jd); - if(sjpeg->workb) lv_mem_free(sjpeg->workb); + if(sjpeg->frame_cache) lv_free(sjpeg->frame_cache); + if(sjpeg->frame_base_array) lv_free(sjpeg->frame_base_array); + if(sjpeg->frame_base_offset) lv_free(sjpeg->frame_base_offset); + if(sjpeg->tjpeg_jd) lv_free(sjpeg->tjpeg_jd); + if(sjpeg->workb) lv_free(sjpeg->workb); } static void lv_sjpg_cleanup(SJPEG * sjpeg) @@ -911,7 +911,7 @@ static void lv_sjpg_cleanup(SJPEG * sjpeg) if(! sjpeg) return; lv_sjpg_free(sjpeg); - lv_mem_free(sjpeg); + lv_free(sjpeg); } #endif /*LV_USE_SJPG*/ diff --git a/src/extra/others/fragment/lv_fragment.c b/src/extra/others/fragment/lv_fragment.c index a2cdfadc22..48f694486e 100644 --- a/src/extra/others/fragment/lv_fragment.c +++ b/src/extra/others/fragment/lv_fragment.c @@ -26,8 +26,8 @@ lv_fragment_t * lv_fragment_create(const lv_fragment_class_t * cls, void * args) LV_ASSERT_NULL(cls); LV_ASSERT_NULL(cls->create_obj_cb); LV_ASSERT(cls->instance_size > 0); - lv_fragment_t * instance = lv_mem_alloc(cls->instance_size); - lv_memset_00(instance, cls->instance_size); + lv_fragment_t * instance = lv_malloc(cls->instance_size); + lv_memzero(instance, cls->instance_size); instance->cls = cls; instance->child_manager = lv_fragment_manager_create(instance); if(cls->constructor_cb) { @@ -52,7 +52,7 @@ void lv_fragment_del(lv_fragment_t * fragment) cls->destructor_cb(fragment); } lv_fragment_manager_del(fragment->child_manager); - lv_mem_free(fragment); + lv_free(fragment); } lv_fragment_manager_t * lv_fragment_get_manager(lv_fragment_t * fragment) diff --git a/src/extra/others/fragment/lv_fragment_manager.c b/src/extra/others/fragment/lv_fragment_manager.c index e8ee84f490..5358cad2cc 100644 --- a/src/extra/others/fragment/lv_fragment_manager.c +++ b/src/extra/others/fragment/lv_fragment_manager.c @@ -64,8 +64,8 @@ static lv_fragment_managed_states_t * fragment_attach(lv_fragment_manager_t * ma lv_fragment_manager_t * lv_fragment_manager_create(lv_fragment_t * parent) { - lv_fragment_manager_t * instance = lv_mem_alloc(sizeof(lv_fragment_manager_t)); - lv_memset_00(instance, sizeof(lv_fragment_manager_t)); + lv_fragment_manager_t * instance = lv_malloc(sizeof(lv_fragment_manager_t)); + lv_memzero(instance, sizeof(lv_fragment_manager_t)); instance->parent = parent; _lv_ll_init(&instance->attached, sizeof(lv_fragment_managed_states_t)); _lv_ll_init(&instance->stack, sizeof(lv_fragment_stack_item_t)); @@ -82,7 +82,7 @@ void lv_fragment_manager_del(lv_fragment_manager_t * manager) } _lv_ll_clear(&manager->attached); _lv_ll_clear(&manager->stack); - lv_mem_free(manager); + lv_free(manager); } void lv_fragment_manager_create_obj(lv_fragment_manager_t * manager) @@ -139,13 +139,13 @@ void lv_fragment_manager_remove(lv_fragment_manager_t * manager, lv_fragment_t * } if(item) { _lv_ll_remove(&manager->stack, item); - lv_mem_free(item); + lv_free(item); } } item_del_obj(states); item_del_fragment(states); _lv_ll_remove(&manager->attached, states); - lv_mem_free(states); + lv_free(states); if(prev && was_top) { item_create_obj(prev); } @@ -161,7 +161,7 @@ void lv_fragment_manager_push(lv_fragment_manager_t * manager, lv_fragment_t * f states->in_stack = true; /*Add fragment to the top of the stack*/ lv_fragment_stack_item_t * item = _lv_ll_ins_tail(&manager->stack); - lv_memset_00(item, sizeof(lv_fragment_stack_item_t)); + lv_memzero(item, sizeof(lv_fragment_stack_item_t)); item->states = states; item_create_obj(states); } @@ -265,7 +265,7 @@ static lv_fragment_managed_states_t * fragment_attach(lv_fragment_manager_t * ma LV_ASSERT(fragment); LV_ASSERT(fragment->managed == NULL); lv_fragment_managed_states_t * states = _lv_ll_ins_tail(&manager->attached); - lv_memset_00(states, sizeof(lv_fragment_managed_states_t)); + lv_memzero(states, sizeof(lv_fragment_managed_states_t)); states->cls = fragment->cls; states->manager = manager; states->container = container; diff --git a/src/extra/others/gridnav/lv_gridnav.c b/src/extra/others/gridnav/lv_gridnav.c index 4eec637bd6..66340dd024 100644 --- a/src/extra/others/gridnav/lv_gridnav.c +++ b/src/extra/others/gridnav/lv_gridnav.c @@ -63,7 +63,7 @@ void lv_gridnav_add(lv_obj_t * obj, lv_gridnav_ctrl_t ctrl) { lv_gridnav_remove(obj); /*Be sure to not add gridnav twice*/ - lv_gridnav_dsc_t * dsc = lv_mem_alloc(sizeof(lv_gridnav_dsc_t)); + lv_gridnav_dsc_t * dsc = lv_malloc(sizeof(lv_gridnav_dsc_t)); LV_ASSERT_MALLOC(dsc); dsc->ctrl = ctrl; dsc->focused_obj = NULL; @@ -77,7 +77,7 @@ void lv_gridnav_remove(lv_obj_t * obj) lv_gridnav_dsc_t * dsc = lv_obj_get_event_user_data(obj, gridnav_event_cb); if(dsc == NULL) return; /* no gridnav on this object */ - lv_mem_free(dsc); + lv_free(dsc); lv_obj_remove_event_cb(obj, gridnav_event_cb); } diff --git a/src/extra/others/ime/lv_ime_pinyin.c b/src/extra/others/ime/lv_ime_pinyin.c index e93d35238e..8ae077c98b 100644 --- a/src/extra/others/ime/lv_ime_pinyin.c +++ b/src/extra/others/ime/lv_ime_pinyin.c @@ -558,9 +558,9 @@ static void lv_ime_pinyin_constructor(const lv_obj_class_t * class_p, lv_obj_t * pinyin_ime->py_page = 0; pinyin_ime->ta_count = 0; pinyin_ime->cand_num = 0; - lv_memset_00(pinyin_ime->input_char, sizeof(pinyin_ime->input_char)); - lv_memset_00(pinyin_ime->py_num, sizeof(pinyin_ime->py_num)); - lv_memset_00(pinyin_ime->py_pos, sizeof(pinyin_ime->py_pos)); + lv_memzero(pinyin_ime->input_char, sizeof(pinyin_ime->input_char)); + lv_memzero(pinyin_ime->py_num, sizeof(pinyin_ime->py_num)); + lv_memzero(pinyin_ime->py_pos, sizeof(pinyin_ime->py_pos)); lv_obj_set_size(obj, LV_PCT(100), LV_PCT(55)); lv_obj_align(obj, LV_ALIGN_BOTTOM_MID, 0, 0); @@ -605,7 +605,7 @@ static void lv_ime_pinyin_constructor(const lv_obj_class_t * class_p, lv_obj_t * pinyin_ime->k9_input_str_len = 0; pinyin_ime->k9_py_ll_pos = 0; pinyin_ime->k9_legal_py_count = 0; - lv_memset_00(pinyin_ime->k9_input_str, LV_IME_PINYIN_K9_MAX_INPUT); + lv_memzero(pinyin_ime->k9_input_str, LV_IME_PINYIN_K9_MAX_INPUT); pinyin_k9_init_data(obj); @@ -654,7 +654,7 @@ static void lv_ime_pinyin_kb_event(lv_event_t * e) uint16_t tmp_btn_str_len = strlen(pinyin_ime->input_char); if((btn_id >= 16) && (tmp_btn_str_len > 0) && (btn_id < (16 + LV_IME_PINYIN_K9_CAND_TEXT_NUM))) { - lv_memset_00(pinyin_ime->input_char, sizeof(pinyin_ime->input_char)); + lv_memzero(pinyin_ime->input_char, sizeof(pinyin_ime->input_char)); strcat(pinyin_ime->input_char, txt); pinyin_input_proc(obj); @@ -957,16 +957,16 @@ static void pinyin_ime_clear_data(lv_obj_t * obj) pinyin_ime->k9_input_str_len = 0; pinyin_ime->k9_py_ll_pos = 0; pinyin_ime->k9_legal_py_count = 0; - lv_memset_00(pinyin_ime->k9_input_str, LV_IME_PINYIN_K9_MAX_INPUT); - lv_memset_00(lv_pinyin_k9_cand_str, sizeof(lv_pinyin_k9_cand_str)); + lv_memzero(pinyin_ime->k9_input_str, LV_IME_PINYIN_K9_MAX_INPUT); + lv_memzero(lv_pinyin_k9_cand_str, sizeof(lv_pinyin_k9_cand_str)); strcpy(lv_pinyin_k9_cand_str[LV_IME_PINYIN_K9_CAND_TEXT_NUM], LV_SYMBOL_RIGHT"\0"); strcpy(lv_pinyin_k9_cand_str[LV_IME_PINYIN_K9_CAND_TEXT_NUM + 1], "\0"); } #endif pinyin_ime->ta_count = 0; - lv_memset_00(lv_pinyin_cand_str, (sizeof(lv_pinyin_cand_str))); - lv_memset_00(pinyin_ime->input_char, sizeof(pinyin_ime->input_char)); + lv_memzero(lv_pinyin_cand_str, (sizeof(lv_pinyin_cand_str))); + lv_memzero(pinyin_ime->input_char, sizeof(pinyin_ime->input_char)); lv_obj_add_flag(pinyin_ime->cand_panel, LV_OBJ_FLAG_HIDDEN); } @@ -1108,7 +1108,7 @@ static void pinyin_k9_fill_cand(lv_obj_t * obj) tmp_len = pinyin_ime->k9_legal_py_count; if(tmp_len != len) { - lv_memset_00(lv_pinyin_k9_cand_str, sizeof(lv_pinyin_k9_cand_str)); + lv_memzero(lv_pinyin_k9_cand_str, sizeof(lv_pinyin_k9_cand_str)); strcpy(lv_pinyin_k9_cand_str[LV_IME_PINYIN_K9_CAND_TEXT_NUM], LV_SYMBOL_RIGHT"\0"); strcpy(lv_pinyin_k9_cand_str[LV_IME_PINYIN_K9_CAND_TEXT_NUM + 1], "\0"); len = tmp_len; @@ -1157,7 +1157,7 @@ static void pinyin_k9_cand_page_proc(lv_obj_t * obj, uint16_t dir) if((NULL == ll_index) && (dir == 1)) return; - lv_memset_00(lv_pinyin_k9_cand_str, sizeof(lv_pinyin_k9_cand_str)); + lv_memzero(lv_pinyin_k9_cand_str, sizeof(lv_pinyin_k9_cand_str)); strcpy(lv_pinyin_k9_cand_str[LV_IME_PINYIN_K9_CAND_TEXT_NUM], LV_SYMBOL_RIGHT"\0"); strcpy(lv_pinyin_k9_cand_str[LV_IME_PINYIN_K9_CAND_TEXT_NUM + 1], "\0"); diff --git a/src/extra/others/imgfont/lv_imgfont.c b/src/extra/others/imgfont/lv_imgfont.c index ad4ab60236..5204f38c70 100644 --- a/src/extra/others/imgfont/lv_imgfont.c +++ b/src/extra/others/imgfont/lv_imgfont.c @@ -52,9 +52,9 @@ lv_font_t * lv_imgfont_create(uint16_t height, lv_get_imgfont_path_cb_t path_cb) "LV_IMGFONT_PATH_MAX_LEN must be greater than sizeof(lv_img_dsc_t)"); size_t size = sizeof(imgfont_dsc_t) + sizeof(lv_font_t); - imgfont_dsc_t * dsc = (imgfont_dsc_t *)lv_mem_alloc(size); + imgfont_dsc_t * dsc = (imgfont_dsc_t *)lv_malloc(size); if(dsc == NULL) return NULL; - lv_memset_00(dsc, size); + lv_memzero(dsc, size); dsc->font = (lv_font_t *)(((char *)dsc) + sizeof(imgfont_dsc_t)); dsc->path_cb = path_cb; @@ -79,7 +79,7 @@ void lv_imgfont_destroy(lv_font_t * font) } imgfont_dsc_t * dsc = (imgfont_dsc_t *)font->dsc; - lv_mem_free(dsc); + lv_free(dsc); } /********************** diff --git a/src/extra/others/monkey/lv_monkey.c b/src/extra/others/monkey/lv_monkey.c index 6ec45e22b6..cf0484fc0b 100755 --- a/src/extra/others/monkey/lv_monkey.c +++ b/src/extra/others/monkey/lv_monkey.c @@ -59,7 +59,7 @@ static void lv_monkey_timer_cb(lv_timer_t * timer); void lv_monkey_config_init(lv_monkey_config_t * config) { - lv_memset_00(config, sizeof(lv_monkey_config_t)); + lv_memzero(config, sizeof(lv_monkey_config_t)); config->type = LV_INDEV_TYPE_POINTER; config->period_range.min = MONKEY_PERIOD_RANGE_MIN_DEF; config->period_range.max = MONKEY_PERIOD_RANGE_MAX_DEF; @@ -67,10 +67,10 @@ void lv_monkey_config_init(lv_monkey_config_t * config) lv_monkey_t * lv_monkey_create(const lv_monkey_config_t * config) { - lv_monkey_t * monkey = lv_mem_alloc(sizeof(lv_monkey_t)); + lv_monkey_t * monkey = lv_malloc(sizeof(lv_monkey_t)); LV_ASSERT_MALLOC(monkey); - lv_memset_00(monkey, sizeof(lv_monkey_t)); + lv_memzero(monkey, sizeof(lv_monkey_t)); monkey->config = *config; @@ -128,7 +128,7 @@ void lv_monkey_del(lv_monkey_t * monkey) lv_timer_del(monkey->timer); lv_indev_delete(monkey->indev); - lv_mem_free(monkey); + lv_free(monkey); } /********************** diff --git a/src/extra/others/msg/lv_msg.c b/src/extra/others/msg/lv_msg.c index 8fd434d06b..88562f63c5 100644 --- a/src/extra/others/msg/lv_msg.c +++ b/src/extra/others/msg/lv_msg.c @@ -65,7 +65,7 @@ void * lv_msg_subsribe(uint32_t msg_id, lv_msg_subscribe_cb_t cb, void * user_da LV_ASSERT_MALLOC(s); if(s == NULL) return NULL; - lv_memset_00(s, sizeof(*s)); + lv_memzero(s, sizeof(*s)); s->msg_id = msg_id; s->callback = cb; @@ -91,13 +91,13 @@ void lv_msg_unsubscribe(void * s) { LV_ASSERT_NULL(s); _lv_ll_remove(&subs_ll, s); - lv_mem_free(s); + lv_free(s); } void lv_msg_send(uint32_t msg_id, const void * payload) { lv_msg_t m; - lv_memset_00(&m, sizeof(m)); + lv_memzero(&m, sizeof(m)); m.id = msg_id; m.payload = payload; notify(&m); diff --git a/src/extra/others/snapshot/lv_snapshot.c b/src/extra/others/snapshot/lv_snapshot.c index 1b22751152..db46b90462 100644 --- a/src/extra/others/snapshot/lv_snapshot.c +++ b/src/extra/others/snapshot/lv_snapshot.c @@ -114,7 +114,7 @@ lv_res_t lv_snapshot_take_to_buf(lv_obj_t * obj, lv_img_cf_t cf, lv_img_dsc_t * lv_area_increase(&snapshot_area, ext_size, ext_size); lv_memset(buf, 0x00, buff_size); - lv_memset_00(dsc, sizeof(lv_img_dsc_t)); + lv_memzero(dsc, sizeof(lv_img_dsc_t)); lv_disp_t * obj_disp = lv_obj_get_disp(obj); lv_disp_drv_t driver; @@ -125,10 +125,10 @@ lv_res_t lv_snapshot_take_to_buf(lv_obj_t * obj, lv_img_cf_t cf, lv_img_dsc_t * lv_disp_drv_use_generic_set_px_cb(&driver, cf); lv_disp_t fake_disp; - lv_memset_00(&fake_disp, sizeof(lv_disp_t)); + lv_memzero(&fake_disp, sizeof(lv_disp_t)); fake_disp.driver = &driver; - lv_draw_ctx_t * draw_ctx = lv_mem_alloc(obj_disp->driver->draw_ctx_size); + lv_draw_ctx_t * draw_ctx = lv_malloc(obj_disp->driver->draw_ctx_size); LV_ASSERT_MALLOC(draw_ctx); if(draw_ctx == NULL) return LV_RES_INV; obj_disp->driver->draw_ctx_init(fake_disp.driver, draw_ctx); @@ -145,7 +145,7 @@ lv_res_t lv_snapshot_take_to_buf(lv_obj_t * obj, lv_img_cf_t cf, lv_img_dsc_t * _lv_refr_set_disp_refreshing(refr_ori); obj_disp->driver->draw_ctx_deinit(fake_disp.driver, draw_ctx); - lv_mem_free(draw_ctx); + lv_free(draw_ctx); dsc->data = buf; dsc->header.w = w; @@ -166,22 +166,22 @@ lv_img_dsc_t * lv_snapshot_take(lv_obj_t * obj, lv_img_cf_t cf) LV_ASSERT_NULL(obj); uint32_t buff_size = lv_snapshot_buf_size_needed(obj, cf); - void * buf = lv_mem_alloc(buff_size); + void * buf = lv_malloc(buff_size); LV_ASSERT_MALLOC(buf); if(buf == NULL) { return NULL; } - lv_img_dsc_t * dsc = lv_mem_alloc(sizeof(lv_img_dsc_t)); + lv_img_dsc_t * dsc = lv_malloc(sizeof(lv_img_dsc_t)); LV_ASSERT_MALLOC(buf); if(dsc == NULL) { - lv_mem_free(buf); + lv_free(buf); return NULL; } if(lv_snapshot_take_to_buf(obj, cf, dsc, buf, buff_size) == LV_RES_INV) { - lv_mem_free(buf); - lv_mem_free(dsc); + lv_free(buf); + lv_free(dsc); return NULL; } @@ -201,9 +201,9 @@ void lv_snapshot_free(lv_img_dsc_t * dsc) return; if(dsc->data) - lv_mem_free((void *)dsc->data); + lv_free((void *)dsc->data); - lv_mem_free(dsc); + lv_free(dsc); } /********************** diff --git a/src/extra/themes/basic/lv_theme_basic.c b/src/extra/themes/basic/lv_theme_basic.c index d342455ff2..26fac36787 100644 --- a/src/extra/themes/basic/lv_theme_basic.c +++ b/src/extra/themes/basic/lv_theme_basic.c @@ -148,7 +148,7 @@ lv_theme_t * lv_theme_basic_init(lv_disp_t * disp) *In a general case styles could be in simple `static lv_style_t my_style...` variables*/ if(!lv_theme_basic_is_inited()) { inited = false; - LV_GC_ROOT(_lv_theme_basic_styles) = lv_mem_alloc(sizeof(my_theme_styles_t)); + LV_GC_ROOT(_lv_theme_basic_styles) = lv_malloc(sizeof(my_theme_styles_t)); styles = (my_theme_styles_t *)LV_GC_ROOT(_lv_theme_basic_styles); } diff --git a/src/extra/themes/default/lv_theme_default.c b/src/extra/themes/default/lv_theme_default.c index 47392b0d15..290ca1a683 100644 --- a/src/extra/themes/default/lv_theme_default.c +++ b/src/extra/themes/default/lv_theme_default.c @@ -654,7 +654,7 @@ lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, l *In a general case styles could be in simple `static lv_style_t my_style...` variables*/ if(!lv_theme_default_is_inited()) { inited = false; - LV_GC_ROOT(_lv_theme_default_styles) = lv_mem_alloc(sizeof(my_theme_styles_t)); + LV_GC_ROOT(_lv_theme_default_styles) = lv_malloc(sizeof(my_theme_styles_t)); styles = (my_theme_styles_t *)LV_GC_ROOT(_lv_theme_default_styles); } diff --git a/src/extra/themes/mono/lv_theme_mono.c b/src/extra/themes/mono/lv_theme_mono.c index b249e76d50..d8eb26b441 100644 --- a/src/extra/themes/mono/lv_theme_mono.c +++ b/src/extra/themes/mono/lv_theme_mono.c @@ -177,7 +177,7 @@ lv_theme_t * lv_theme_mono_init(lv_disp_t * disp, bool dark_bg, const lv_font_t *In a general case styles could be in simple `static lv_style_t my_style...` variables*/ if(!inited) { inited = false; - LV_GC_ROOT(_lv_theme_default_styles) = lv_mem_alloc(sizeof(my_theme_styles_t)); + LV_GC_ROOT(_lv_theme_default_styles) = lv_malloc(sizeof(my_theme_styles_t)); styles = (my_theme_styles_t *)LV_GC_ROOT(_lv_theme_default_styles); } diff --git a/src/extra/widgets/calendar/lv_calendar.c b/src/extra/widgets/calendar/lv_calendar.c index b806d25294..d62204488c 100644 --- a/src/extra/widgets/calendar/lv_calendar.c +++ b/src/extra/widgets/calendar/lv_calendar.c @@ -254,7 +254,7 @@ static void lv_calendar_constructor(const lv_obj_class_t * class_p, lv_obj_t * o calendar->highlighted_dates = NULL; calendar->highlighted_dates_num = 0; - lv_memset_00(calendar->nums, sizeof(calendar->nums)); + lv_memzero(calendar->nums, sizeof(calendar->nums)); uint8_t i; uint8_t j = 0; for(i = 0; i < 8 * 7; i++) { diff --git a/src/extra/widgets/chart/lv_chart.c b/src/extra/widgets/chart/lv_chart.c index 5bdc474885..5c04d377d3 100644 --- a/src/extra/widgets/chart/lv_chart.c +++ b/src/extra/widgets/chart/lv_chart.c @@ -82,7 +82,7 @@ void lv_chart_set_type(lv_obj_t * obj, lv_chart_type_t type) if(chart->type == LV_CHART_TYPE_SCATTER) { lv_chart_series_t * ser; _LV_LL_READ_BACK(&chart->series_ll, ser) { - lv_mem_free(ser->x_points); + lv_free(ser->x_points); ser->x_points = NULL; } } @@ -90,7 +90,7 @@ void lv_chart_set_type(lv_obj_t * obj, lv_chart_type_t type) if(type == LV_CHART_TYPE_SCATTER) { lv_chart_series_t * ser; _LV_LL_READ_BACK(&chart->series_ll, ser) { - ser->x_points = lv_mem_alloc(sizeof(lv_point_t) * chart->point_cnt); + ser->x_points = lv_malloc(sizeof(lv_point_t) * chart->point_cnt); LV_ASSERT_MALLOC(ser->x_points); if(ser->x_points == NULL) return; } @@ -352,16 +352,16 @@ lv_chart_series_t * lv_chart_add_series(lv_obj_t * obj, lv_color_t color, lv_cha lv_coord_t def = LV_CHART_POINT_NONE; ser->color = color; - ser->y_points = lv_mem_alloc(sizeof(lv_coord_t) * chart->point_cnt); + ser->y_points = lv_malloc(sizeof(lv_coord_t) * chart->point_cnt); LV_ASSERT_MALLOC(ser->y_points); if(chart->type == LV_CHART_TYPE_SCATTER) { - ser->x_points = lv_mem_alloc(sizeof(lv_coord_t) * chart->point_cnt); + ser->x_points = lv_malloc(sizeof(lv_coord_t) * chart->point_cnt); LV_ASSERT_MALLOC(ser->x_points); } if(ser->y_points == NULL) { _lv_ll_remove(&chart->series_ll, ser); - lv_mem_free(ser); + lv_free(ser); return NULL; } @@ -387,10 +387,10 @@ void lv_chart_remove_series(lv_obj_t * obj, lv_chart_series_t * series) LV_ASSERT_NULL(series); lv_chart_t * chart = (lv_chart_t *)obj; - if(!series->y_ext_buf_assigned && series->y_points) lv_mem_free(series->y_points); + if(!series->y_ext_buf_assigned && series->y_points) lv_free(series->y_points); _lv_ll_remove(&chart->series_ll, series); - lv_mem_free(series); + lv_free(series); return; } @@ -598,7 +598,7 @@ void lv_chart_set_ext_y_array(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_ LV_ASSERT_OBJ(obj, MY_CLASS); LV_ASSERT_NULL(ser); - if(!ser->y_ext_buf_assigned && ser->y_points) lv_mem_free(ser->y_points); + if(!ser->y_ext_buf_assigned && ser->y_points) lv_free(ser->y_points); ser->y_ext_buf_assigned = true; ser->y_points = array; lv_obj_invalidate(obj); @@ -609,7 +609,7 @@ void lv_chart_set_ext_x_array(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_ LV_ASSERT_OBJ(obj, MY_CLASS); LV_ASSERT_NULL(ser); - if(!ser->x_ext_buf_assigned && ser->x_points) lv_mem_free(ser->x_points); + if(!ser->x_ext_buf_assigned && ser->x_points) lv_free(ser->x_points); ser->x_ext_buf_assigned = true; ser->x_points = array; lv_obj_invalidate(obj); @@ -682,10 +682,10 @@ static void lv_chart_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) while(chart->series_ll.head) { ser = _lv_ll_get_head(&chart->series_ll); - if(!ser->y_ext_buf_assigned) lv_mem_free(ser->y_points); + if(!ser->y_ext_buf_assigned) lv_free(ser->y_points); _lv_ll_remove(&chart->series_ll, ser); - lv_mem_free(ser); + lv_free(ser); } _lv_ll_clear(&chart->series_ll); @@ -693,7 +693,7 @@ static void lv_chart_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) while(chart->cursor_ll.head) { cur = _lv_ll_get_head(&chart->cursor_ll); _lv_ll_remove(&chart->cursor_ll, cur); - lv_mem_free(cur); + lv_free(cur); } _lv_ll_clear(&chart->cursor_ll); @@ -1749,7 +1749,7 @@ static void new_points_alloc(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t c uint32_t i; if(ser->start_point != 0) { - lv_coord_t * new_points = lv_mem_alloc(sizeof(lv_coord_t) * cnt); + lv_coord_t * new_points = lv_malloc(sizeof(lv_coord_t) * cnt); LV_ASSERT_MALLOC(new_points); if(new_points == NULL) return; @@ -1770,11 +1770,11 @@ static void new_points_alloc(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t c } /*Switch over pointer from old to new*/ - lv_mem_free((*a)); + lv_free((*a)); (*a) = new_points; } else { - (*a) = lv_mem_realloc((*a), sizeof(lv_coord_t) * cnt); + (*a) = lv_realloc((*a), sizeof(lv_coord_t) * cnt); LV_ASSERT_MALLOC((*a)); if((*a) == NULL) return; /*Initialize the new points*/ diff --git a/src/extra/widgets/colorwheel/lv_colorwheel.c b/src/extra/widgets/colorwheel/lv_colorwheel.c index 3fb7128cfb..4eb420d855 100644 --- a/src/extra/widgets/colorwheel/lv_colorwheel.c +++ b/src/extra/widgets/colorwheel/lv_colorwheel.c @@ -259,7 +259,7 @@ static void draw_disc_grad(lv_event_t * e) uint32_t a = 0; lv_coord_t cir_w = lv_obj_get_style_arc_width(obj, LV_PART_MAIN); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Mask outer and inner ring of widget to tidy up ragged edges of lines while drawing outer ring*/ lv_draw_mask_radius_param_t mask_out_param; lv_draw_mask_radius_init(&mask_out_param, &obj->coords, LV_RADIUS_CIRCLE, false); @@ -295,7 +295,7 @@ static void draw_disc_grad(lv_event_t * e) lv_draw_line(draw_ctx, &line_dsc, &p[0], &p[1]); } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS lv_draw_mask_free_param(&mask_out_param); lv_draw_mask_free_param(&mask_in_param); lv_draw_mask_remove_id(mask_out_id); diff --git a/src/extra/widgets/imgbtn/lv_imgbtn.c b/src/extra/widgets/imgbtn/lv_imgbtn.c index 00c3011caa..db3bdc1613 100644 --- a/src/extra/widgets/imgbtn/lv_imgbtn.c +++ b/src/extra/widgets/imgbtn/lv_imgbtn.c @@ -166,9 +166,9 @@ static void lv_imgbtn_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj LV_UNUSED(class_p); lv_imgbtn_t * imgbtn = (lv_imgbtn_t *)obj; /*Initialize the allocated 'ext'*/ - lv_memset_00((void *)imgbtn->img_src_mid, sizeof(imgbtn->img_src_mid)); - lv_memset_00(imgbtn->img_src_left, sizeof(imgbtn->img_src_left)); - lv_memset_00(imgbtn->img_src_right, sizeof(imgbtn->img_src_right)); + lv_memzero((void *)imgbtn->img_src_mid, sizeof(imgbtn->img_src_mid)); + lv_memzero(imgbtn->img_src_left, sizeof(imgbtn->img_src_left)); + lv_memzero(imgbtn->img_src_right, sizeof(imgbtn->img_src_right)); imgbtn->act_cf = LV_IMG_CF_UNKNOWN; } diff --git a/src/extra/widgets/keyboard/lv_keyboard.c b/src/extra/widgets/keyboard/lv_keyboard.c index 8e052e33a1..a8af00431a 100644 --- a/src/extra/widgets/keyboard/lv_keyboard.c +++ b/src/extra/widgets/keyboard/lv_keyboard.c @@ -413,7 +413,7 @@ static void lv_keyboard_update_ctrl_map(lv_obj_t * obj) else { /*Make a copy of the current control map*/ lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj; - lv_btnmatrix_ctrl_t * ctrl_map = lv_mem_alloc(btnm->btn_cnt * sizeof(lv_btnmatrix_ctrl_t)); + lv_btnmatrix_ctrl_t * ctrl_map = lv_malloc(btnm->btn_cnt * sizeof(lv_btnmatrix_ctrl_t)); lv_memcpy(ctrl_map, kb_ctrl[keyboard->mode], sizeof(lv_btnmatrix_ctrl_t) * btnm->btn_cnt); /*Remove all LV_BTNMATRIX_CTRL_POPOVER flags*/ @@ -423,7 +423,7 @@ static void lv_keyboard_update_ctrl_map(lv_obj_t * obj) /*Apply new control map and clean up*/ lv_btnmatrix_set_ctrl_map(obj, ctrl_map); - lv_mem_free(ctrl_map); + lv_free(ctrl_map); } } diff --git a/src/extra/widgets/menu/lv_menu.c b/src/extra/widgets/menu/lv_menu.c index 78577e7709..398a2c69d0 100644 --- a/src/extra/widgets/menu/lv_menu.c +++ b/src/extra/widgets/menu/lv_menu.c @@ -125,7 +125,7 @@ lv_obj_t * lv_menu_page_create(lv_obj_t * parent, char * title) lv_menu_page_t * page = (lv_menu_page_t *)obj; if(title) { - page->title = lv_mem_alloc(strlen(title) + 1); + page->title = lv_malloc(strlen(title) + 1); LV_ASSERT_MALLOC(page->title); if(page->title == NULL) return NULL; strcpy(page->title, title); @@ -177,7 +177,7 @@ void lv_menu_refr(lv_obj_t * obj) page = act_hist->page; /* Delete the current item from the history */ _lv_ll_remove(history_ll, act_hist); - lv_mem_free(act_hist); + lv_free(act_hist); menu->cur_depth--; } @@ -371,7 +371,7 @@ void lv_menu_set_load_page_event(lv_obj_t * menu, lv_obj_t * obj, lv_obj_t * pag lv_obj_remove_event_cb(obj, lv_menu_obj_del_event_cb); } - lv_menu_load_page_event_data_t * event_data = lv_mem_alloc(sizeof(lv_menu_load_page_event_data_t)); + lv_menu_load_page_event_data_t * event_data = lv_malloc(sizeof(lv_menu_load_page_event_data_t)); event_data->menu = menu; event_data->page = page; @@ -560,7 +560,7 @@ static void lv_menu_page_destructor(const lv_obj_class_t * class_p, lv_obj_t * o lv_menu_page_t * page = (lv_menu_page_t *)obj; if(page->title != NULL) { - lv_mem_free(page->title); + lv_free(page->title); page->title = NULL; } } @@ -695,7 +695,7 @@ static void lv_menu_load_page_event_cb(lv_event_t * e) static void lv_menu_obj_del_event_cb(lv_event_t * e) { lv_menu_load_page_event_data_t * event_data = lv_event_get_user_data(e); - lv_mem_free(event_data); + lv_free(event_data); } static void lv_menu_back_event_cb(lv_event_t * e) @@ -724,7 +724,7 @@ static void lv_menu_back_event_cb(lv_event_t * e) /* Previous menu exists */ /* Delete the current item from the history */ _lv_ll_remove(history_ll, act_hist); - lv_mem_free(act_hist); + lv_free(act_hist); menu->cur_depth--; /* Create the previous menu. * Remove it from the history because `lv_menu_set_page` will add it again */ @@ -732,7 +732,7 @@ static void lv_menu_back_event_cb(lv_event_t * e) menu->cur_depth--; lv_menu_set_page(&(menu->obj), prev_hist->page); - lv_mem_free(prev_hist); + lv_free(prev_hist); } } } diff --git a/src/extra/widgets/meter/lv_meter.c b/src/extra/widgets/meter/lv_meter.c index 668ab97e99..db474686ec 100644 --- a/src/extra/widgets/meter/lv_meter.c +++ b/src/extra/widgets/meter/lv_meter.c @@ -70,7 +70,7 @@ lv_meter_scale_t * lv_meter_add_scale(lv_obj_t * obj) lv_meter_scale_t * scale = _lv_ll_ins_head(&meter->scale_ll); LV_ASSERT_MALLOC(scale); - lv_memset_00(scale, sizeof(lv_meter_scale_t)); + lv_memzero(scale, sizeof(lv_meter_scale_t)); scale->angle_range = 270; scale->rotation = 90 + (360 - scale->angle_range) / 2; @@ -126,7 +126,7 @@ lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t lv_meter_t * meter = (lv_meter_t *)obj; lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll); LV_ASSERT_MALLOC(indic); - lv_memset_00(indic, sizeof(lv_meter_indicator_t)); + lv_memzero(indic, sizeof(lv_meter_indicator_t)); indic->scale = scale; indic->opa = LV_OPA_COVER; @@ -146,7 +146,7 @@ lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t lv_meter_t * meter = (lv_meter_t *)obj; lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll); LV_ASSERT_MALLOC(indic); - lv_memset_00(indic, sizeof(lv_meter_indicator_t)); + lv_memzero(indic, sizeof(lv_meter_indicator_t)); indic->scale = scale; indic->opa = LV_OPA_COVER; @@ -166,7 +166,7 @@ lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale lv_meter_t * meter = (lv_meter_t *)obj; lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll); LV_ASSERT_MALLOC(indic); - lv_memset_00(indic, sizeof(lv_meter_indicator_t)); + lv_memzero(indic, sizeof(lv_meter_indicator_t)); indic->scale = scale; indic->opa = LV_OPA_COVER; @@ -186,7 +186,7 @@ lv_meter_indicator_t * lv_meter_add_scale_lines(lv_obj_t * obj, lv_meter_scale_t lv_meter_t * meter = (lv_meter_t *)obj; lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll); LV_ASSERT_MALLOC(indic); - lv_memset_00(indic, sizeof(lv_meter_indicator_t)); + lv_memzero(indic, sizeof(lv_meter_indicator_t)); indic->scale = scale; indic->opa = LV_OPA_COVER; diff --git a/src/extra/widgets/meter/lv_meter.h b/src/extra/widgets/meter/lv_meter.h index 24c1dae0f0..fdf2ae6444 100644 --- a/src/extra/widgets/meter/lv_meter.h +++ b/src/extra/widgets/meter/lv_meter.h @@ -18,8 +18,8 @@ extern "C" { #if LV_USE_METER != 0 /*Testing of dependencies*/ -#if LV_DRAW_COMPLEX == 0 -#error "lv_meter: Complex drawing is required. Enable it in lv_conf.h (LV_DRAW_COMPLEX 1)" +#if LV_USE_DRAW_MASKS == 0 +#error "lv_meter: Complex drawing is required. Enable it in lv_conf.h (LV_USE_DRAW_MASKS 1)" #endif /********************* diff --git a/src/extra/widgets/span/lv_span.c b/src/extra/widgets/span/lv_span.c index 96f044760d..918be46740 100644 --- a/src/extra/widgets/span/lv_span.c +++ b/src/extra/widgets/span/lv_span.c @@ -127,10 +127,10 @@ void lv_spangroup_del_span(lv_obj_t * obj, lv_span_t * span) if(cur_span == span) { _lv_ll_remove(&spans->child_ll, cur_span); if(cur_span->txt && cur_span->static_flag == 0) { - lv_mem_free(cur_span->txt); + lv_free(cur_span->txt); } lv_style_reset(&cur_span->style); - lv_mem_free(cur_span); + lv_free(cur_span); break; } } @@ -149,10 +149,10 @@ void lv_span_set_text(lv_span_t * span, const char * text) } if(span->txt == NULL || span->static_flag == 1) { - span->txt = lv_mem_alloc(strlen(text) + 1); + span->txt = lv_malloc(strlen(text) + 1); } else { - span->txt = lv_mem_realloc(span->txt, strlen(text) + 1); + span->txt = lv_realloc(span->txt, strlen(text) + 1); } span->static_flag = 0; strcpy(span->txt, text); @@ -167,7 +167,7 @@ void lv_span_set_text_static(lv_span_t * span, const char * text) } if(span->txt && span->static_flag == 0) { - lv_mem_free(span->txt); + lv_free(span->txt); } span->static_flag = 1; span->txt = (char *)text; @@ -520,10 +520,10 @@ static void lv_spangroup_destructor(const lv_obj_class_t * class_p, lv_obj_t * o while(cur_span) { _lv_ll_remove(&spans->child_ll, cur_span); if(cur_span->txt && cur_span->static_flag == 0) { - lv_mem_free(cur_span->txt); + lv_free(cur_span->txt); } lv_style_reset(&cur_span->style); - lv_mem_free(cur_span); + lv_free(cur_span); cur_span = _lv_ll_get_head(&spans->child_ll); } } @@ -791,7 +791,7 @@ static void lv_draw_span(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx) span_text_check(&cur_txt); uint32_t cur_txt_ofs = 0; lv_snippet_t snippet; /* use to save cur_span info and push it to stack */ - lv_memset_00(&snippet, sizeof(snippet)); + lv_memzero(&snippet, sizeof(snippet)); lv_draw_label_dsc_t label_draw_dsc; lv_draw_label_dsc_init(&label_draw_dsc); diff --git a/src/extra/widgets/spinbox/lv_spinbox.c b/src/extra/widgets/spinbox/lv_spinbox.c index 34691053ee..a438521da5 100644 --- a/src/extra/widgets/spinbox/lv_spinbox.c +++ b/src/extra/widgets/spinbox/lv_spinbox.c @@ -445,7 +445,7 @@ static void lv_spinbox_updatevalue(lv_obj_t * obj) lv_spinbox_t * spinbox = (lv_spinbox_t *)obj; char buf[LV_SPINBOX_MAX_DIGIT_COUNT + 8]; - lv_memset_00(buf, sizeof(buf)); + lv_memzero(buf, sizeof(buf)); char * buf_p = buf; uint8_t cur_shift_left = 0; diff --git a/src/extra/widgets/tabview/lv_tabview.c b/src/extra/widgets/tabview/lv_tabview.c index 81addc6633..85e5b63e63 100755 --- a/src/extra/widgets/tabview/lv_tabview.c +++ b/src/extra/widgets/tabview/lv_tabview.c @@ -82,31 +82,31 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name) /*top or bottom dir*/ if(tabview->tab_pos & LV_DIR_VER) { - new_map = lv_mem_alloc((tab_id + 1) * sizeof(const char *)); - lv_memcpy_small(new_map, old_map, sizeof(const char *) * (tab_id - 1)); - new_map[tab_id - 1] = lv_mem_alloc(strlen(name) + 1); + new_map = lv_malloc((tab_id + 1) * sizeof(const char *)); + lv_memcpy(new_map, old_map, sizeof(const char *) * (tab_id - 1)); + new_map[tab_id - 1] = lv_malloc(strlen(name) + 1); strcpy((char *)new_map[tab_id - 1], name); new_map[tab_id] = ""; } /*left or right dir*/ else { - new_map = lv_mem_alloc((tab_id * 2) * sizeof(const char *)); - lv_memcpy_small(new_map, old_map, sizeof(const char *) * (tab_id - 1) * 2); + new_map = lv_malloc((tab_id * 2) * sizeof(const char *)); + lv_memcpy(new_map, old_map, sizeof(const char *) * (tab_id - 1) * 2); if(tabview->tab_cnt == 0) { - new_map[0] = lv_mem_alloc(strlen(name) + 1); + new_map[0] = lv_malloc(strlen(name) + 1); strcpy((char *)new_map[0], name); new_map[1] = ""; } else { new_map[tab_id * 2 - 3] = "\n"; - new_map[tab_id * 2 - 2] = lv_mem_alloc(strlen(name) + 1); + new_map[tab_id * 2 - 2] = lv_malloc(strlen(name) + 1); new_map[tab_id * 2 - 1] = ""; strcpy((char *)new_map[(tab_id * 2) - 2], name); } } tabview->map = new_map; lv_btnmatrix_set_map(btns, (const char **)new_map); - lv_mem_free(old_map); + lv_free(old_map); lv_btnmatrix_set_btn_ctrl_all(btns, LV_BTNMATRIX_CTRL_CHECKABLE | LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT); @@ -129,8 +129,8 @@ void lv_tabview_rename_tab(lv_obj_t * obj, uint32_t id, const char * new_name) if(id >= tabview->tab_cnt) return; if(tabview->tab_pos & LV_DIR_HOR) id *= 2; - lv_mem_free(tabview->map[id]); - tabview->map[id] = lv_mem_alloc(strlen(new_name) + 1); + lv_free(tabview->map[id]); + tabview->map[id] = lv_malloc(strlen(new_name) + 1); strcpy(tabview->map[id], new_name); lv_obj_invalidate(obj); } @@ -224,7 +224,7 @@ static void lv_tabview_constructor(const lv_obj_class_t * class_p, lv_obj_t * ob cont = lv_obj_create(obj); lv_btnmatrix_set_one_checked(btnm, true); - tabview->map = lv_mem_alloc(sizeof(const char *)); + tabview->map = lv_malloc(sizeof(const char *)); tabview->map[0] = ""; lv_btnmatrix_set_map(btnm, (const char **)tabview->map); lv_obj_add_event_cb(btnm, btns_value_changed_event_cb, LV_EVENT_VALUE_CHANGED, NULL); @@ -271,19 +271,19 @@ static void lv_tabview_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj uint32_t i; if(tabview->tab_pos & LV_DIR_VER) { for(i = 0; i < tabview->tab_cnt; i++) { - lv_mem_free(tabview->map[i]); + lv_free(tabview->map[i]); tabview->map[i] = NULL; } } if(tabview->tab_pos & LV_DIR_HOR) { for(i = 0; i < tabview->tab_cnt; i++) { - lv_mem_free(tabview->map[i * 2]); + lv_free(tabview->map[i * 2]); tabview->map[i * 2] = NULL; } } - lv_mem_free(tabview->map); + lv_free(tabview->map); tabview->map = NULL; } diff --git a/src/font/lv_font_fmt_txt.c b/src/font/lv_font_fmt_txt.c index 7a36f01b8a..846fb9385f 100644 --- a/src/font/lv_font_fmt_txt.c +++ b/src/font/lv_font_fmt_txt.c @@ -116,7 +116,7 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic } if(last_buf_size < buf_size) { - uint8_t * tmp = lv_mem_realloc(LV_GC_ROOT(_lv_font_decompr_buf), buf_size); + uint8_t * tmp = lv_realloc(LV_GC_ROOT(_lv_font_decompr_buf), buf_size); LV_ASSERT_MALLOC(tmp); if(tmp == NULL) return NULL; LV_GC_ROOT(_lv_font_decompr_buf) = tmp; @@ -196,7 +196,7 @@ void _lv_font_clean_up_fmt_txt(void) { #if LV_USE_FONT_COMPRESSED if(LV_GC_ROOT(_lv_font_decompr_buf)) { - lv_mem_free(LV_GC_ROOT(_lv_font_decompr_buf)); + lv_free(LV_GC_ROOT(_lv_font_decompr_buf)); LV_GC_ROOT(_lv_font_decompr_buf) = NULL; } #endif @@ -361,12 +361,12 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord rle_init(in, bpp); - uint8_t * line_buf1 = lv_mem_buf_get(w); + uint8_t * line_buf1 = lv_malloc(w); uint8_t * line_buf2 = NULL; if(prefilter) { - line_buf2 = lv_mem_buf_get(w); + line_buf2 = lv_malloc(w); } decompress_line(line_buf1, w); @@ -399,8 +399,8 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord } } - lv_mem_buf_release(line_buf1); - lv_mem_buf_release(line_buf2); + lv_free(line_buf1); + lv_free(line_buf2); } /** diff --git a/src/font/lv_font_loader.c b/src/font/lv_font_loader.c index f7c061bbed..a99e43b181 100644 --- a/src/font/lv_font_loader.c +++ b/src/font/lv_font_loader.c @@ -90,7 +90,7 @@ lv_font_t * lv_font_load(const char * font_name) if(res != LV_FS_RES_OK) return NULL; - lv_font_t * font = lv_mem_alloc(sizeof(lv_font_t)); + lv_font_t * font = lv_malloc(sizeof(lv_font_t)); if(font) { memset(font, 0, sizeof(lv_font_t)); if(!lvgl_load_font(&file, font)) { @@ -127,12 +127,12 @@ void lv_font_free(lv_font_t * font) if(NULL != kern_dsc) { if(kern_dsc->glyph_ids) - lv_mem_free((void *)kern_dsc->glyph_ids); + lv_free((void *)kern_dsc->glyph_ids); if(kern_dsc->values) - lv_mem_free((void *)kern_dsc->values); + lv_free((void *)kern_dsc->values); - lv_mem_free((void *)kern_dsc); + lv_free((void *)kern_dsc); } } else { @@ -141,15 +141,15 @@ void lv_font_free(lv_font_t * font) if(NULL != kern_dsc) { if(kern_dsc->class_pair_values) - lv_mem_free((void *)kern_dsc->class_pair_values); + lv_free((void *)kern_dsc->class_pair_values); if(kern_dsc->left_class_mapping) - lv_mem_free((void *)kern_dsc->left_class_mapping); + lv_free((void *)kern_dsc->left_class_mapping); if(kern_dsc->right_class_mapping) - lv_mem_free((void *)kern_dsc->right_class_mapping); + lv_free((void *)kern_dsc->right_class_mapping); - lv_mem_free((void *)kern_dsc); + lv_free((void *)kern_dsc); } } @@ -159,22 +159,22 @@ void lv_font_free(lv_font_t * font) if(NULL != cmaps) { for(int i = 0; i < dsc->cmap_num; ++i) { if(NULL != cmaps[i].glyph_id_ofs_list) - lv_mem_free((void *)cmaps[i].glyph_id_ofs_list); + lv_free((void *)cmaps[i].glyph_id_ofs_list); if(NULL != cmaps[i].unicode_list) - lv_mem_free((void *)cmaps[i].unicode_list); + lv_free((void *)cmaps[i].unicode_list); } - lv_mem_free(cmaps); + lv_free(cmaps); } if(NULL != dsc->glyph_bitmap) { - lv_mem_free((void *)dsc->glyph_bitmap); + lv_free((void *)dsc->glyph_bitmap); } if(NULL != dsc->glyph_dsc) { - lv_mem_free((void *)dsc->glyph_dsc); + lv_free((void *)dsc->glyph_dsc); } - lv_mem_free(dsc); + lv_free(dsc); } - lv_mem_free(font); + lv_free(font); } } @@ -262,7 +262,7 @@ static bool load_cmaps_tables(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_ds switch(cmap_table[i].format_type) { case LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL: { uint8_t ids_size = sizeof(uint8_t) * cmap_table[i].data_entries_count; - uint8_t * glyph_id_ofs_list = lv_mem_alloc(ids_size); + uint8_t * glyph_id_ofs_list = lv_malloc(ids_size); cmap->glyph_id_ofs_list = glyph_id_ofs_list; @@ -278,7 +278,7 @@ static bool load_cmaps_tables(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_ds case LV_FONT_FMT_TXT_CMAP_SPARSE_FULL: case LV_FONT_FMT_TXT_CMAP_SPARSE_TINY: { uint32_t list_size = sizeof(uint16_t) * cmap_table[i].data_entries_count; - uint16_t * unicode_list = (uint16_t *)lv_mem_alloc(list_size); + uint16_t * unicode_list = (uint16_t *)lv_malloc(list_size); cmap->unicode_list = unicode_list; cmap->list_length = cmap_table[i].data_entries_count; @@ -288,7 +288,7 @@ static bool load_cmaps_tables(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_ds } if(cmap_table[i].format_type == LV_FONT_FMT_TXT_CMAP_SPARSE_FULL) { - uint16_t * buf = lv_mem_alloc(sizeof(uint16_t) * cmap->list_length); + uint16_t * buf = lv_malloc(sizeof(uint16_t) * cmap->list_length); cmap->glyph_id_ofs_list = buf; @@ -319,18 +319,18 @@ static int32_t load_cmaps(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, u } lv_font_fmt_txt_cmap_t * cmaps = - lv_mem_alloc(cmaps_subtables_count * sizeof(lv_font_fmt_txt_cmap_t)); + lv_malloc(cmaps_subtables_count * sizeof(lv_font_fmt_txt_cmap_t)); memset(cmaps, 0, cmaps_subtables_count * sizeof(lv_font_fmt_txt_cmap_t)); font_dsc->cmaps = cmaps; font_dsc->cmap_num = cmaps_subtables_count; - cmap_table_bin_t * cmaps_tables = lv_mem_alloc(sizeof(cmap_table_bin_t) * font_dsc->cmap_num); + cmap_table_bin_t * cmaps_tables = lv_malloc(sizeof(cmap_table_bin_t) * font_dsc->cmap_num); bool success = load_cmaps_tables(fp, font_dsc, cmaps_start, cmaps_tables); - lv_mem_free(cmaps_tables); + lv_free(cmaps_tables); return success ? cmaps_length : -1; } @@ -344,7 +344,7 @@ static int32_t load_glyph(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, } lv_font_fmt_txt_glyph_dsc_t * glyph_dsc = (lv_font_fmt_txt_glyph_dsc_t *) - lv_mem_alloc(loca_count * sizeof(lv_font_fmt_txt_glyph_dsc_t)); + lv_malloc(loca_count * sizeof(lv_font_fmt_txt_glyph_dsc_t)); memset(glyph_dsc, 0, loca_count * sizeof(lv_font_fmt_txt_glyph_dsc_t)); @@ -414,7 +414,7 @@ static int32_t load_glyph(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, } } - uint8_t * glyph_bmp = (uint8_t *)lv_mem_alloc(sizeof(uint8_t) * cur_bmp_size); + uint8_t * glyph_bmp = (uint8_t *)lv_malloc(sizeof(uint8_t) * cur_bmp_size); font_dsc->glyph_bitmap = glyph_bmp; @@ -483,7 +483,7 @@ static int32_t load_glyph(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font) { lv_font_fmt_txt_dsc_t * font_dsc = (lv_font_fmt_txt_dsc_t *) - lv_mem_alloc(sizeof(lv_font_fmt_txt_dsc_t)); + lv_malloc(sizeof(lv_font_fmt_txt_dsc_t)); memset(font_dsc, 0, sizeof(lv_font_fmt_txt_dsc_t)); @@ -532,7 +532,7 @@ static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font) } bool failed = false; - uint32_t * glyph_offset = lv_mem_alloc(sizeof(uint32_t) * (loca_count + 1)); + uint32_t * glyph_offset = lv_malloc(sizeof(uint32_t) * (loca_count + 1)); if(font_header.index_to_loc_format == 0) { for(unsigned int i = 0; i < loca_count; ++i) { @@ -555,7 +555,7 @@ static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font) } if(failed) { - lv_mem_free(glyph_offset); + lv_free(glyph_offset); return false; } @@ -564,7 +564,7 @@ static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font) int32_t glyph_length = load_glyph( fp, font_dsc, glyph_start, glyph_offset, loca_count, &font_header); - lv_mem_free(glyph_offset); + lv_free(glyph_offset); if(glyph_length < 0) { return false; @@ -599,7 +599,7 @@ int32_t load_kern(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint8_t f } if(0 == kern_format_type) { /*sorted pairs*/ - lv_font_fmt_txt_kern_pair_t * kern_pair = lv_mem_alloc(sizeof(lv_font_fmt_txt_kern_pair_t)); + lv_font_fmt_txt_kern_pair_t * kern_pair = lv_malloc(sizeof(lv_font_fmt_txt_kern_pair_t)); memset(kern_pair, 0, sizeof(lv_font_fmt_txt_kern_pair_t)); @@ -619,8 +619,8 @@ int32_t load_kern(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint8_t f ids_size = sizeof(int16_t) * 2 * glyph_entries; } - uint8_t * glyph_ids = lv_mem_alloc(ids_size); - int8_t * values = lv_mem_alloc(glyph_entries); + uint8_t * glyph_ids = lv_malloc(ids_size); + int8_t * values = lv_malloc(glyph_entries); kern_pair->glyph_ids_size = format; kern_pair->pair_cnt = glyph_entries; @@ -637,7 +637,7 @@ int32_t load_kern(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint8_t f } else if(3 == kern_format_type) { /*array M*N of classes*/ - lv_font_fmt_txt_kern_classes_t * kern_classes = lv_mem_alloc(sizeof(lv_font_fmt_txt_kern_classes_t)); + lv_font_fmt_txt_kern_classes_t * kern_classes = lv_malloc(sizeof(lv_font_fmt_txt_kern_classes_t)); memset(kern_classes, 0, sizeof(lv_font_fmt_txt_kern_classes_t)); @@ -656,9 +656,9 @@ int32_t load_kern(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint8_t f int kern_values_length = sizeof(int8_t) * kern_table_rows * kern_table_cols; - uint8_t * kern_left = lv_mem_alloc(kern_class_mapping_length); - uint8_t * kern_right = lv_mem_alloc(kern_class_mapping_length); - int8_t * kern_values = lv_mem_alloc(kern_values_length); + uint8_t * kern_left = lv_malloc(kern_class_mapping_length); + uint8_t * kern_right = lv_malloc(kern_class_mapping_length); + int8_t * kern_values = lv_malloc(kern_values_length); kern_classes->left_class_mapping = kern_left; kern_classes->right_class_mapping = kern_right; diff --git a/src/hal/lv_hal_disp.c b/src/hal/lv_hal_disp.c index 0dd8f6b303..02f2a121ca 100644 --- a/src/hal/lv_hal_disp.c +++ b/src/hal/lv_hal_disp.c @@ -83,7 +83,7 @@ static lv_disp_t * disp_def; */ void lv_disp_drv_init(lv_disp_drv_t * driver) { - lv_memset_00(driver, sizeof(lv_disp_drv_t)); + lv_memzero(driver, sizeof(lv_disp_drv_t)); driver->hor_res = 320; driver->ver_res = 240; @@ -109,7 +109,7 @@ void lv_disp_drv_init(lv_disp_drv_t * driver) driver->draw_ctx_init = lv_draw_nxp_ctx_init; driver->draw_ctx_deinit = lv_draw_nxp_ctx_deinit; driver->draw_ctx_size = sizeof(lv_draw_nxp_ctx_t); -#elif LV_USE_GPU_SDL +#elif LV_USE_DRAW_SDL driver->draw_ctx_init = lv_draw_sdl_init_ctx; driver->draw_ctx_deinit = lv_draw_sdl_deinit_ctx; driver->draw_ctx_size = sizeof(lv_draw_sdl_ctx_t); @@ -142,7 +142,7 @@ void lv_disp_drv_init(lv_disp_drv_t * driver) */ void lv_disp_draw_buf_init(lv_disp_draw_buf_t * draw_buf, void * buf1, void * buf2, uint32_t size_in_px_cnt) { - lv_memset_00(draw_buf, sizeof(lv_disp_draw_buf_t)); + lv_memzero(draw_buf, sizeof(lv_disp_draw_buf_t)); draw_buf->buf1 = buf1; draw_buf->buf2 = buf2; @@ -166,14 +166,14 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver) /*Create a draw context if not created yet*/ if(driver->draw_ctx == NULL) { - lv_draw_ctx_t * draw_ctx = lv_mem_alloc(driver->draw_ctx_size); + lv_draw_ctx_t * draw_ctx = lv_malloc(driver->draw_ctx_size); LV_ASSERT_MALLOC(draw_ctx); if(draw_ctx == NULL) return NULL; driver->draw_ctx_init(driver, draw_ctx); driver->draw_ctx = draw_ctx; } - lv_memset_00(disp, sizeof(lv_disp_t)); + lv_memzero(disp, sizeof(lv_disp_t)); disp->driver = driver; @@ -183,10 +183,10 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver) disp_def = disp; /*Temporarily change the default screen to create the default screens on the new display*/ /*Create a refresh timer*/ - disp->refr_timer = lv_timer_create(_lv_disp_refr_timer, LV_DISP_DEF_REFR_PERIOD, disp); + disp->refr_timer = lv_timer_create(_lv_disp_refr_timer, LV_DEF_REFR_PERIOD, disp); LV_ASSERT_MALLOC(disp->refr_timer); if(disp->refr_timer == NULL) { - lv_mem_free(disp); + lv_free(disp); return NULL; } @@ -196,11 +196,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver) } disp->bg_color = lv_color_white(); -#if LV_COLOR_SCREEN_TRANSP - disp->bg_opa = LV_OPA_TRANSP; -#else disp->bg_opa = LV_OPA_COVER; -#endif #if LV_USE_THEME_DEFAULT if(lv_theme_default_is_inited() == false) { @@ -265,8 +261,8 @@ void lv_disp_drv_update(lv_disp_t * disp, lv_disp_drv_t * new_drv) * The object invalidated its previous area. That area is now out of the screen area * so we reset all invalidated areas and invalidate the active screen's new area only. */ - lv_memset_00(disp->inv_areas, sizeof(disp->inv_areas)); - lv_memset_00(disp->inv_area_joined, sizeof(disp->inv_area_joined)); + lv_memzero(disp->inv_areas, sizeof(disp->inv_areas)); + lv_memzero(disp->inv_area_joined, sizeof(disp->inv_area_joined)); disp->inv_p = 0; if(disp->act_scr != NULL) lv_obj_invalidate(disp->act_scr); @@ -310,7 +306,7 @@ void lv_disp_remove(lv_disp_t * disp) _lv_ll_remove(&LV_GC_ROOT(_lv_disp_ll), disp); if(disp->refr_timer) lv_timer_del(disp->refr_timer); - lv_mem_free(disp); + lv_free(disp); if(was_default) lv_disp_set_default(_lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll))); } diff --git a/src/hal/lv_hal_disp.h b/src/hal/lv_hal_disp.h index d3425fe4e1..598a963975 100644 --- a/src/hal/lv_hal_disp.h +++ b/src/hal/lv_hal_disp.h @@ -35,6 +35,9 @@ extern "C" { #define LV_ATTRIBUTE_FLUSH_READY #endif +/*Default display refresh, input device read and animation step period.*/ +#define LV_DEF_REFR_PERIOD 33 /*[ms]*/ + /********************** * TYPEDEFS **********************/ diff --git a/src/hal/lv_hal_indev.c b/src/hal/lv_hal_indev.c index c3661e4224..cac408a478 100644 --- a/src/hal/lv_hal_indev.c +++ b/src/hal/lv_hal_indev.c @@ -56,7 +56,7 @@ */ void lv_indev_drv_init(lv_indev_drv_t * driver) { - lv_memset_00(driver, sizeof(lv_indev_drv_t)); + lv_memzero(driver, sizeof(lv_indev_drv_t)); driver->type = LV_INDEV_TYPE_NONE; driver->scroll_limit = LV_INDEV_DEF_SCROLL_LIMIT; @@ -89,11 +89,11 @@ lv_indev_t * lv_indev_drv_register(lv_indev_drv_t * driver) return NULL; } - lv_memset_00(indev, sizeof(lv_indev_t)); + lv_memzero(indev, sizeof(lv_indev_t)); indev->driver = driver; indev->proc.reset_query = 1; - indev->driver->read_timer = lv_timer_create(lv_indev_read_timer_cb, LV_INDEV_DEF_READ_PERIOD, indev); + indev->driver->read_timer = lv_timer_create(lv_indev_read_timer_cb, LV_DEF_REFR_PERIOD, indev); return indev; } @@ -122,7 +122,7 @@ void lv_indev_drv_update(lv_indev_t * indev, lv_indev_drv_t * new_drv) } indev->driver = new_drv; - indev->driver->read_timer = lv_timer_create(lv_indev_read_timer_cb, LV_INDEV_DEF_READ_PERIOD, indev); + indev->driver->read_timer = lv_timer_create(lv_indev_read_timer_cb, LV_DEF_REFR_PERIOD, indev); indev->proc.reset_query = 1; } @@ -140,7 +140,7 @@ void lv_indev_delete(lv_indev_t * indev) /*Remove the input device from the list*/ _lv_ll_remove(&LV_GC_ROOT(_lv_indev_ll), indev); /*Free the memory of the input device*/ - lv_mem_free(indev); + lv_free(indev); } /** @@ -164,7 +164,7 @@ lv_indev_t * lv_indev_get_next(lv_indev_t * indev) */ void _lv_indev_read(lv_indev_t * indev, lv_indev_data_t * data) { - lv_memset_00(data, sizeof(lv_indev_data_t)); + lv_memzero(data, sizeof(lv_indev_data_t)); /* For touchpad sometimes users don't set the last pressed coordinate on release. * So be sure a coordinates are initialized to the last point */ diff --git a/src/lv_conf_internal.h b/src/lv_conf_internal.h index 110bb63190..a3e18f09b4 100644 --- a/src/lv_conf_internal.h +++ b/src/lv_conf_internal.h @@ -70,64 +70,37 @@ #endif #endif -/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/ -#ifndef LV_COLOR_16_SWAP - #ifdef CONFIG_LV_COLOR_16_SWAP - #define LV_COLOR_16_SWAP CONFIG_LV_COLOR_16_SWAP - #else - #define LV_COLOR_16_SWAP 0 - #endif -#endif - -/*Enable features to draw on transparent background. - *It's required if opa, and transform_* style properties are used. - *Can be also used if the UI is above another layer, e.g. an OSD menu or video player.*/ -#ifndef LV_COLOR_SCREEN_TRANSP - #ifdef CONFIG_LV_COLOR_SCREEN_TRANSP - #define LV_COLOR_SCREEN_TRANSP CONFIG_LV_COLOR_SCREEN_TRANSP - #else - #define LV_COLOR_SCREEN_TRANSP 0 - #endif -#endif - -/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently. - * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */ -#ifndef LV_COLOR_MIX_ROUND_OFS - #ifdef CONFIG_LV_COLOR_MIX_ROUND_OFS - #define LV_COLOR_MIX_ROUND_OFS CONFIG_LV_COLOR_MIX_ROUND_OFS - #else - #define LV_COLOR_MIX_ROUND_OFS 0 - #endif -#endif - -/*Images pixels with this color will not be drawn if they are chroma keyed)*/ #ifndef LV_COLOR_CHROMA_KEY #ifdef CONFIG_LV_COLOR_CHROMA_KEY #define LV_COLOR_CHROMA_KEY CONFIG_LV_COLOR_CHROMA_KEY #else - #define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) /*pure green*/ + #define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) #endif #endif /*========================= - MEMORY SETTINGS + STDLIB WRAPPER SETTINGS *=========================*/ -/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/ -#ifndef LV_MEM_CUSTOM - #ifdef CONFIG_LV_MEM_CUSTOM - #define LV_MEM_CUSTOM CONFIG_LV_MEM_CUSTOM +/*Enable and configure the built-in memory manager*/ +#ifndef LV_USE_BUILTIN_MALLOC + #ifdef _LV_KCONFIG_PRESENT + #ifdef CONFIG_LV_USE_BUILTIN_MALLOC + #define LV_USE_BUILTIN_MALLOC CONFIG_LV_USE_BUILTIN_MALLOC + #else + #define LV_USE_BUILTIN_MALLOC 0 + #endif #else - #define LV_MEM_CUSTOM 0 + #define LV_USE_BUILTIN_MALLOC 1 #endif #endif -#if LV_MEM_CUSTOM == 0 - /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/ +#if LV_USE_BUILTIN_MALLOC + /*Size of the memory available for `lv_malloc()` in bytes (>= 2kB)*/ #ifndef LV_MEM_SIZE #ifdef CONFIG_LV_MEM_SIZE #define LV_MEM_SIZE CONFIG_LV_MEM_SIZE #else - #define LV_MEM_SIZE (48U * 1024U) /*[bytes]*/ + #define LV_MEM_SIZE (128U * 1024U) /*[bytes]*/ #endif #endif @@ -156,54 +129,98 @@ #endif #endif #endif +#endif /*LV_USE_BUILTIN_MALLOC*/ -#else /*LV_MEM_CUSTOM*/ - #ifndef LV_MEM_CUSTOM_INCLUDE - #ifdef CONFIG_LV_MEM_CUSTOM_INCLUDE - #define LV_MEM_CUSTOM_INCLUDE CONFIG_LV_MEM_CUSTOM_INCLUDE +/*Enable and configure the built-in (v)snprintf */ +#ifndef LV_USE_BUILTIN_SNPRINTF + #ifdef _LV_KCONFIG_PRESENT + #ifdef CONFIG_LV_USE_BUILTIN_SNPRINTF + #define LV_USE_BUILTIN_SNPRINTF CONFIG_LV_USE_BUILTIN_SNPRINTF #else - #define LV_MEM_CUSTOM_INCLUDE /*Header for the dynamic memory function*/ + #define LV_USE_BUILTIN_SNPRINTF 0 #endif - #endif - #ifndef LV_MEM_CUSTOM_ALLOC - #ifdef CONFIG_LV_MEM_CUSTOM_ALLOC - #define LV_MEM_CUSTOM_ALLOC CONFIG_LV_MEM_CUSTOM_ALLOC - #else - #define LV_MEM_CUSTOM_ALLOC malloc - #endif - #endif - #ifndef LV_MEM_CUSTOM_FREE - #ifdef CONFIG_LV_MEM_CUSTOM_FREE - #define LV_MEM_CUSTOM_FREE CONFIG_LV_MEM_CUSTOM_FREE - #else - #define LV_MEM_CUSTOM_FREE free - #endif - #endif - #ifndef LV_MEM_CUSTOM_REALLOC - #ifdef CONFIG_LV_MEM_CUSTOM_REALLOC - #define LV_MEM_CUSTOM_REALLOC CONFIG_LV_MEM_CUSTOM_REALLOC - #else - #define LV_MEM_CUSTOM_REALLOC realloc - #endif - #endif -#endif /*LV_MEM_CUSTOM*/ - -/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms. - *You will see an error log message if there wasn't enough buffers. */ -#ifndef LV_MEM_BUF_MAX_NUM - #ifdef CONFIG_LV_MEM_BUF_MAX_NUM - #define LV_MEM_BUF_MAX_NUM CONFIG_LV_MEM_BUF_MAX_NUM #else - #define LV_MEM_BUF_MAX_NUM 16 + #define LV_USE_BUILTIN_SNPRINTF 1 #endif #endif +#if LV_USE_BUILTIN_SNPRINTF + #ifndef LV_SPRINTF_USE_FLOAT + #ifdef CONFIG_LV_SPRINTF_USE_FLOAT + #define LV_SPRINTF_USE_FLOAT CONFIG_LV_SPRINTF_USE_FLOAT + #else + #define LV_SPRINTF_USE_FLOAT 0 + #endif + #endif +#endif /*LV_USE_BUILTIN_SNPRINTF*/ -/*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/ -#ifndef LV_MEMCPY_MEMSET_STD - #ifdef CONFIG_LV_MEMCPY_MEMSET_STD - #define LV_MEMCPY_MEMSET_STD CONFIG_LV_MEMCPY_MEMSET_STD +#ifndef LV_STDLIB_INCLUDE + #ifdef CONFIG_LV_STDLIB_INCLUDE + #define LV_STDLIB_INCLUDE CONFIG_LV_STDLIB_INCLUDE #else - #define LV_MEMCPY_MEMSET_STD 0 + #define LV_STDLIB_INCLUDE + #endif +#endif +#ifndef LV_MALLOC + #ifdef CONFIG_LV_MALLOC + #define LV_MALLOC CONFIG_LV_MALLOC + #else + #define LV_MALLOC lv_malloc_builtin + #endif +#endif +#ifndef LV_REALLOC + #ifdef CONFIG_LV_REALLOC + #define LV_REALLOC CONFIG_LV_REALLOC + #else + #define LV_REALLOC lv_realloc_builtin + #endif +#endif +#ifndef LV_FREE + #ifdef CONFIG_LV_FREE + #define LV_FREE CONFIG_LV_FREE + #else + #define LV_FREE lv_free_builtin + #endif +#endif +#ifndef LV_MEMSET + #ifdef CONFIG_LV_MEMSET + #define LV_MEMSET CONFIG_LV_MEMSET + #else + #define LV_MEMSET lv_memset_builtin + #endif +#endif +#ifndef LV_MEMCPY + #ifdef CONFIG_LV_MEMCPY + #define LV_MEMCPY CONFIG_LV_MEMCPY + #else + #define LV_MEMCPY lv_memcpy_builtin + #endif +#endif +#ifndef LV_SNPRINTF + #ifdef CONFIG_LV_SNPRINTF + #define LV_SNPRINTF CONFIG_LV_SNPRINTF + #else + #define LV_SNPRINTF lv_snprintf_builtin + #endif +#endif +#ifndef LV_VSNPRINTF + #ifdef CONFIG_LV_VSNPRINTF + #define LV_VSNPRINTF CONFIG_LV_VSNPRINTF + #else + #define LV_VSNPRINTF lv_vsnprintf_builtin + #endif +#endif +#ifndef LV_STRLEN + #ifdef CONFIG_LV_STRLEN + #define LV_STRLEN CONFIG_LV_STRLEN + #else + #define LV_STRLEN lv_strlen_builtin + #endif +#endif +#ifndef LV_STRNCPY + #ifdef CONFIG_LV_STRNCPY + #define LV_STRNCPY CONFIG_LV_STRNCPY + #else + #define LV_STRNCPY lv_strncpy_builtin #endif #endif @@ -211,24 +228,6 @@ HAL SETTINGS *====================*/ -/*Default display refresh period. LVG will redraw changed areas with this period time*/ -#ifndef LV_DISP_DEF_REFR_PERIOD - #ifdef CONFIG_LV_DISP_DEF_REFR_PERIOD - #define LV_DISP_DEF_REFR_PERIOD CONFIG_LV_DISP_DEF_REFR_PERIOD - #else - #define LV_DISP_DEF_REFR_PERIOD 30 /*[ms]*/ - #endif -#endif - -/*Input device read period in milliseconds*/ -#ifndef LV_INDEV_DEF_READ_PERIOD - #ifdef CONFIG_LV_INDEV_DEF_READ_PERIOD - #define LV_INDEV_DEF_READ_PERIOD CONFIG_LV_INDEV_DEF_READ_PERIOD - #else - #define LV_INDEV_DEF_READ_PERIOD 30 /*[ms]*/ - #endif -#endif - /*Use a custom tick source that tells the elapsed time in milliseconds. *It removes the need to manually update the tick with `lv_tick_inc()`)*/ #ifndef LV_TICK_CUSTOM @@ -265,37 +264,82 @@ #endif #endif -/*======================= - * FEATURE CONFIGURATION - *=======================*/ +/*======================== + * DRAW CONFIGURATION + *========================*/ -/*------------- - * Drawing - *-----------*/ - -/*Enable complex draw engine. - *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ -#ifndef LV_DRAW_COMPLEX +/*Enable the built in mask engine. + *Required to draw shadow, rounded corners, circles, arc, skew lines, or any other masks*/ +#ifndef LV_USE_DRAW_MASKS #ifdef _LV_KCONFIG_PRESENT - #ifdef CONFIG_LV_DRAW_COMPLEX - #define LV_DRAW_COMPLEX CONFIG_LV_DRAW_COMPLEX + #ifdef CONFIG_LV_USE_DRAW_MASKS + #define LV_USE_DRAW_MASKS CONFIG_LV_USE_DRAW_MASKS #else - #define LV_DRAW_COMPLEX 0 + #define LV_USE_DRAW_MASKS 0 #endif #else - #define LV_DRAW_COMPLEX 1 + #define LV_USE_DRAW_MASKS 1 #endif #endif -#if LV_DRAW_COMPLEX != 0 + +#ifndef LV_USE_DRAW_SW + #ifdef _LV_KCONFIG_PRESENT + #ifdef CONFIG_LV_USE_DRAW_SW + #define LV_USE_DRAW_SW CONFIG_LV_USE_DRAW_SW + #else + #define LV_USE_DRAW_SW 0 + #endif + #else + #define LV_USE_DRAW_SW 1 + #endif +#endif +#if LV_USE_DRAW_SW + + /*Enable complex draw engine. + *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ + #ifndef LV_DRAW_SW_COMPLEX + #ifdef _LV_KCONFIG_PRESENT + #ifdef CONFIG_LV_DRAW_SW_COMPLEX + #define LV_DRAW_SW_COMPLEX CONFIG_LV_DRAW_SW_COMPLEX + #else + #define LV_DRAW_SW_COMPLEX 0 + #endif + #else + #define LV_DRAW_SW_COMPLEX 1 + #endif + #endif + + /* If a widget has `style_opa < 255` (not `bg_opa`, `text_opa` etc) or not NORMAL blend mode + * it is buffered into a "simple" layer before rendering. The widget can be buffered in smaller chunks. + * "Transformed layers" (if `transform_angle/zoom` are set) use larger buffers + * and can't be drawn in chunks. */ + + /*The target buffer size for simple layer chunks.*/ + #ifndef LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE + #ifdef CONFIG_LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE + #define LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE CONFIG_LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE + #else + #define LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE (24 * 1024) /*[bytes]*/ + #endif + #endif + + /*Used if `LV_DRAW_SW_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated.*/ + #ifndef LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE + #ifdef CONFIG_LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE + #define LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE CONFIG_LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE + #else + #define LV_DRAW_SW_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) /*[bytes]*/ + #endif + #endif /*Allow buffering some shadow calculation. - *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` - *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/ - #ifndef LV_SHADOW_CACHE_SIZE - #ifdef CONFIG_LV_SHADOW_CACHE_SIZE - #define LV_SHADOW_CACHE_SIZE CONFIG_LV_SHADOW_CACHE_SIZE + *LV_DRAW_SW_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` + *Caching has LV_DRAW_SW_SHADOW_CACHE_SIZE^2 RAM cost*/ + #ifndef LV_DRAW_SW_SHADOW_CACHE_SIZE + #ifdef CONFIG_LV_DRAW_SW_SHADOW_CACHE_SIZE + #define LV_DRAW_SW_SHADOW_CACHE_SIZE CONFIG_LV_DRAW_SW_SHADOW_CACHE_SIZE #else - #define LV_SHADOW_CACHE_SIZE 0 + #define LV_DRAW_SW_SHADOW_CACHE_SIZE 0 #endif #endif @@ -303,115 +347,107 @@ * The circumference of 1/4 circle are saved for anti-aliasing * radius * 4 bytes are used per circle (the most often used radiuses are saved) * 0: to disable caching */ - #ifndef LV_CIRCLE_CACHE_SIZE - #ifdef CONFIG_LV_CIRCLE_CACHE_SIZE - #define LV_CIRCLE_CACHE_SIZE CONFIG_LV_CIRCLE_CACHE_SIZE + #ifndef LV_DRAW_SW_CIRCLE_CACHE_SIZE + #ifdef CONFIG_LV_DRAW_SW_CIRCLE_CACHE_SIZE + #define LV_DRAW_SW_CIRCLE_CACHE_SIZE CONFIG_LV_DRAW_SW_CIRCLE_CACHE_SIZE #else - #define LV_CIRCLE_CACHE_SIZE 4 + #define LV_DRAW_SW_CIRCLE_CACHE_SIZE 4 #endif #endif -#endif /*LV_DRAW_COMPLEX*/ -/** - * "Simple layers" are used when a widget has `style_opa < 255` to buffer the widget into a layer - * and blend it as an image with the given opacity. - * Note that `bg_opa`, `text_opa` etc don't require buffering into layer) - * The widget can be buffered in smaller chunks to avoid using large buffers. - * - * - LV_LAYER_SIMPLE_BUF_SIZE: [bytes] the optimal target buffer size. LVGL will try to allocate it - * - LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE: [bytes] used if `LV_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated. - * - * Both buffer sizes are in bytes. - * "Transformed layers" (where transform_angle/zoom properties are used) use larger buffers - * and can't be drawn in chunks. So these settings affects only widgets with opacity. - */ -#ifndef LV_LAYER_SIMPLE_BUF_SIZE - #ifdef CONFIG_LV_LAYER_SIMPLE_BUF_SIZE - #define LV_LAYER_SIMPLE_BUF_SIZE CONFIG_LV_LAYER_SIMPLE_BUF_SIZE - #else - #define LV_LAYER_SIMPLE_BUF_SIZE (24 * 1024) - #endif -#endif -#ifndef LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE - #ifdef CONFIG_LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE - #define LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE CONFIG_LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE - #else - #define LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024) - #endif -#endif - -/*Default image cache size. Image caching keeps the images opened. - *If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added) - *With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images. - *However the opened images might consume additional RAM. - *0: to disable caching*/ -#ifndef LV_IMG_CACHE_DEF_SIZE - #ifdef CONFIG_LV_IMG_CACHE_DEF_SIZE - #define LV_IMG_CACHE_DEF_SIZE CONFIG_LV_IMG_CACHE_DEF_SIZE - #else - #define LV_IMG_CACHE_DEF_SIZE 0 - #endif -#endif - -/*Number of stops allowed per gradient. Increase this to allow more stops. - *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/ -#ifndef LV_GRADIENT_MAX_STOPS - #ifdef CONFIG_LV_GRADIENT_MAX_STOPS - #define LV_GRADIENT_MAX_STOPS CONFIG_LV_GRADIENT_MAX_STOPS - #else - #define LV_GRADIENT_MAX_STOPS 2 - #endif -#endif - -/*Default gradient buffer size. - *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. - *LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes. - *If the cache is too small the map will be allocated only while it's required for the drawing. - *0 mean no caching.*/ -#ifndef LV_GRAD_CACHE_DEF_SIZE - #ifdef CONFIG_LV_GRAD_CACHE_DEF_SIZE - #define LV_GRAD_CACHE_DEF_SIZE CONFIG_LV_GRAD_CACHE_DEF_SIZE - #else - #define LV_GRAD_CACHE_DEF_SIZE 0 - #endif -#endif - -/*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) - *LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface - *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ -#ifndef LV_DITHER_GRADIENT - #ifdef CONFIG_LV_DITHER_GRADIENT - #define LV_DITHER_GRADIENT CONFIG_LV_DITHER_GRADIENT - #else - #define LV_DITHER_GRADIENT 0 - #endif -#endif -#if LV_DITHER_GRADIENT - /*Add support for error diffusion dithering. - *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. - *The increase in memory consumption is (24 bits * object's width)*/ - #ifndef LV_DITHER_ERROR_DIFFUSION - #ifdef CONFIG_LV_DITHER_ERROR_DIFFUSION - #define LV_DITHER_ERROR_DIFFUSION CONFIG_LV_DITHER_ERROR_DIFFUSION + /*Default gradient buffer size. + *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. + *LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE sets the size of this cache in bytes. + *If the cache is too small the map will be allocated only while it's required for the drawing. + *0 mean no caching.*/ + #ifndef LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE + #ifdef CONFIG_LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE + #define LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE CONFIG_LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE #else - #define LV_DITHER_ERROR_DIFFUSION 0 + #define LV_DRAW_SW_GRADIENT_CACHE_DEF_SIZE 0 + #endif + #endif + + /*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) + *LV_DRAW_SW_GRADIENT_DITHER implies allocating one or two more lines of the object's rendering surface + *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ + #ifndef LV_DRAW_SW_GRADIENT_DITHER + #ifdef CONFIG_LV_DRAW_SW_GRADIENT_DITHER + #define LV_DRAW_SW_GRADIENT_DITHER CONFIG_LV_DRAW_SW_GRADIENT_DITHER + #else + #define LV_DRAW_SW_GRADIENT_DITHER 0 + #endif + #endif + #if LV_DRAW_SW_GRADIENT_DITHER + /*Add support for error diffusion dithering. + *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. + *The increase in memory consumption is (24 bits * object's width)*/ + #ifndef LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION + #ifdef CONFIG_LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION + #define LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION CONFIG_LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION + #else + #define LV_DRAW_SW_GRADIENT_DITHER_ERROR_DIFFUSION 0 + #endif + #endif + #endif + + /*Enable subpixel rendering*/ + #ifndef LV_DRAW_SW_FONT_SUBPX + #ifdef CONFIG_LV_DRAW_SW_FONT_SUBPX + #define LV_DRAW_SW_FONT_SUBPX CONFIG_LV_DRAW_SW_FONT_SUBPX + #else + #define LV_DRAW_SW_FONT_SUBPX 0 + #endif + #endif + #if LV_DRAW_SW_FONT_SUBPX + /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ + #ifndef LV_DRAW_SW_FONT_SUBPX_BGR + #ifdef CONFIG_LV_DRAW_SW_FONT_SUBPX_BGR + #define LV_DRAW_SW_FONT_SUBPX_BGR CONFIG_LV_DRAW_SW_FONT_SUBPX_BGR + #else + #define LV_DRAW_SW_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ + #endif #endif #endif #endif -/*Maximum buffer size to allocate for rotation. - *Only used if software rotation is enabled in the display driver.*/ -#ifndef LV_DISP_ROT_MAX_BUF - #ifdef CONFIG_LV_DISP_ROT_MAX_BUF - #define LV_DISP_ROT_MAX_BUF CONFIG_LV_DISP_ROT_MAX_BUF +/*Use SDL renderer API*/ +#ifndef LV_USE_DRAW_SDL + #ifdef CONFIG_LV_USE_DRAW_SDL + #define LV_USE_DRAW_SDL CONFIG_LV_USE_DRAW_SDL #else - #define LV_DISP_ROT_MAX_BUF (10*1024) + #define LV_USE_DRAW_SDL 0 + #endif +#endif +#if LV_USE_DRAW_SDL + #ifndef LV_DARW_SDL_INCLUDE_PATH + #ifdef CONFIG_LV_DARW_SDL_INCLUDE_PATH + #define LV_DARW_SDL_INCLUDE_PATH CONFIG_LV_DARW_SDL_INCLUDE_PATH + #else + #define LV_DARW_SDL_INCLUDE_PATH + #endif + #endif + /*Texture cache size, 8MB by default*/ + #ifndef LV_DARW_SDL_LRU_SIZE + #ifdef CONFIG_LV_DARW_SDL_LRU_SIZE + #define LV_DARW_SDL_LRU_SIZE CONFIG_LV_DARW_SDL_LRU_SIZE + #else + #define LV_DARW_SDL_LRU_SIZE (1024 * 1024 * 8) + #endif + #endif + /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ + #ifndef LV_DARW_SDL_CUSTOM_BLEND_MODE + #ifdef CONFIG_LV_DARW_SDL_CUSTOM_BLEND_MODE + #define LV_DARW_SDL_CUSTOM_BLEND_MODE CONFIG_LV_DARW_SDL_CUSTOM_BLEND_MODE + #else + #define LV_DARW_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) + #endif #endif #endif -/*------------- - * GPU - *-----------*/ +/*===================== + * GPU CONFIGURATION + *=====================*/ /*Use Arm's 2D acceleration library Arm-2D */ #ifndef LV_USE_GPU_ARM2D @@ -442,24 +478,6 @@ #endif #endif -/*Use SWM341's DMA2D GPU*/ -#ifndef LV_USE_GPU_SWM341_DMA2D - #ifdef CONFIG_LV_USE_GPU_SWM341_DMA2D - #define LV_USE_GPU_SWM341_DMA2D CONFIG_LV_USE_GPU_SWM341_DMA2D - #else - #define LV_USE_GPU_SWM341_DMA2D 0 - #endif -#endif -#if LV_USE_GPU_SWM341_DMA2D - #ifndef LV_GPU_SWM341_DMA2D_INCLUDE - #ifdef CONFIG_LV_GPU_SWM341_DMA2D_INCLUDE - #define LV_GPU_SWM341_DMA2D_INCLUDE CONFIG_LV_GPU_SWM341_DMA2D_INCLUDE - #else - #define LV_GPU_SWM341_DMA2D_INCLUDE "SWM341.h" - #endif - #endif -#endif - /*Use NXP's PXP GPU iMX RTxxx platforms*/ #ifndef LV_USE_GPU_NXP_PXP #ifdef CONFIG_LV_USE_GPU_NXP_PXP @@ -492,40 +510,28 @@ #endif #endif -/*Use SDL renderer API*/ -#ifndef LV_USE_GPU_SDL - #ifdef CONFIG_LV_USE_GPU_SDL - #define LV_USE_GPU_SDL CONFIG_LV_USE_GPU_SDL +/*Use SWM341's DMA2D GPU*/ +#ifndef LV_USE_GPU_SWM341_DMA2D + #ifdef CONFIG_LV_USE_GPU_SWM341_DMA2D + #define LV_USE_GPU_SWM341_DMA2D CONFIG_LV_USE_GPU_SWM341_DMA2D #else - #define LV_USE_GPU_SDL 0 + #define LV_USE_GPU_SWM341_DMA2D 0 #endif #endif -#if LV_USE_GPU_SDL - #ifndef LV_GPU_SDL_INCLUDE_PATH - #ifdef CONFIG_LV_GPU_SDL_INCLUDE_PATH - #define LV_GPU_SDL_INCLUDE_PATH CONFIG_LV_GPU_SDL_INCLUDE_PATH +#if LV_USE_GPU_SWM341_DMA2D + #ifndef LV_GPU_SWM341_DMA2D_INCLUDE + #ifdef CONFIG_LV_GPU_SWM341_DMA2D_INCLUDE + #define LV_GPU_SWM341_DMA2D_INCLUDE CONFIG_LV_GPU_SWM341_DMA2D_INCLUDE #else - #define LV_GPU_SDL_INCLUDE_PATH - #endif - #endif - /*Texture cache size, 8MB by default*/ - #ifndef LV_GPU_SDL_LRU_SIZE - #ifdef CONFIG_LV_GPU_SDL_LRU_SIZE - #define LV_GPU_SDL_LRU_SIZE CONFIG_LV_GPU_SDL_LRU_SIZE - #else - #define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8) - #endif - #endif - /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ - #ifndef LV_GPU_SDL_CUSTOM_BLEND_MODE - #ifdef CONFIG_LV_GPU_SDL_CUSTOM_BLEND_MODE - #define LV_GPU_SDL_CUSTOM_BLEND_MODE CONFIG_LV_GPU_SDL_CUSTOM_BLEND_MODE - #else - #define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) + #define LV_GPU_SWM341_DMA2D_INCLUDE "SWM341.h" #endif #endif #endif +/*======================= + * FEATURE CONFIGURATION + *=======================*/ + /*------------- * Logging *-----------*/ @@ -746,7 +752,7 @@ #endif /*1: Show the used memory and the memory fragmentation - * Requires LV_MEM_CUSTOM = 0*/ + * Requires `LV_USE_BUILTIN_MALLOC = 1`*/ #ifndef LV_USE_MEM_MONITOR #ifdef CONFIG_LV_USE_MEM_MONITOR #define LV_USE_MEM_MONITOR CONFIG_LV_USE_MEM_MONITOR @@ -773,45 +779,15 @@ #endif #endif -/*Change the built in (v)snprintf functions*/ -#ifndef LV_SPRINTF_CUSTOM - #ifdef CONFIG_LV_SPRINTF_CUSTOM - #define LV_SPRINTF_CUSTOM CONFIG_LV_SPRINTF_CUSTOM +/*Maximum buffer size to allocate for rotation. + *Only used if software rotation is enabled in the display driver.*/ +#ifndef LV_DISP_ROT_MAX_BUF + #ifdef CONFIG_LV_DISP_ROT_MAX_BUF + #define LV_DISP_ROT_MAX_BUF CONFIG_LV_DISP_ROT_MAX_BUF #else - #define LV_SPRINTF_CUSTOM 0 + #define LV_DISP_ROT_MAX_BUF (10*1024) #endif #endif -#if LV_SPRINTF_CUSTOM - #ifndef LV_SPRINTF_INCLUDE - #ifdef CONFIG_LV_SPRINTF_INCLUDE - #define LV_SPRINTF_INCLUDE CONFIG_LV_SPRINTF_INCLUDE - #else - #define LV_SPRINTF_INCLUDE - #endif - #endif - #ifndef lv_snprintf - #ifdef CONFIG_LV_SNPRINTF - #define lv_snprintf CONFIG_LV_SNPRINTF - #else - #define lv_snprintf snprintf - #endif - #endif - #ifndef lv_vsnprintf - #ifdef CONFIG_LV_VSNPRINTF - #define lv_vsnprintf CONFIG_LV_VSNPRINTF - #else - #define lv_vsnprintf vsnprintf - #endif - #endif -#else /*LV_SPRINTF_CUSTOM*/ - #ifndef LV_SPRINTF_USE_FLOAT - #ifdef CONFIG_LV_SPRINTF_USE_FLOAT - #define LV_SPRINTF_USE_FLOAT CONFIG_LV_SPRINTF_USE_FLOAT - #else - #define LV_SPRINTF_USE_FLOAT 0 - #endif - #endif -#endif /*LV_SPRINTF_CUSTOM*/ #ifndef LV_USE_USER_DATA #ifdef _LV_KCONFIG_PRESENT @@ -844,6 +820,40 @@ #endif #endif /*LV_ENABLE_GC*/ +/*Default image cache size. Image caching keeps some images opened. + *If only the built-in image formats are used there is no real advantage of caching. + *With other image decoders (e.g. PNG or JPG) caching save the continuous open/decode of images. + *However the opened images consume additional RAM. + *0: to disable caching*/ +#ifndef LV_IMG_CACHE_DEF_SIZE + #ifdef CONFIG_LV_IMG_CACHE_DEF_SIZE + #define LV_IMG_CACHE_DEF_SIZE CONFIG_LV_IMG_CACHE_DEF_SIZE + #else + #define LV_IMG_CACHE_DEF_SIZE 0 + #endif +#endif + + +/*Number of stops allowed per gradient. Increase this to allow more stops. + *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/ +#ifndef LV_GRADIENT_MAX_STOPS + #ifdef CONFIG_LV_GRADIENT_MAX_STOPS + #define LV_GRADIENT_MAX_STOPS CONFIG_LV_GRADIENT_MAX_STOPS + #else + #define LV_GRADIENT_MAX_STOPS 2 + #endif +#endif + +/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently. + * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */ +#ifndef LV_COLOR_MIX_ROUND_OFS + #ifdef CONFIG_LV_COLOR_MIX_ROUND_OFS + #define LV_COLOR_MIX_ROUND_OFS CONFIG_LV_COLOR_MIX_ROUND_OFS + #else + #define LV_COLOR_MIX_ROUND_OFS 0 + #endif +#endif + /*===================== * COMPILER SETTINGS *====================*/ @@ -934,14 +944,6 @@ #endif #endif -/*Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible*/ -#ifndef LV_ATTRIBUTE_DMA - #ifdef CONFIG_LV_ATTRIBUTE_DMA - #define LV_ATTRIBUTE_DMA CONFIG_LV_ATTRIBUTE_DMA - #else - #define LV_ATTRIBUTE_DMA - #endif -#endif /*Export integer constant to binding. This macro is used with constants in the form of LV_ that *should also appear on LVGL binding API such as Micropython.*/ @@ -1206,25 +1208,6 @@ #endif #endif -/*Enable subpixel rendering*/ -#ifndef LV_USE_FONT_SUBPX - #ifdef CONFIG_LV_USE_FONT_SUBPX - #define LV_USE_FONT_SUBPX CONFIG_LV_USE_FONT_SUBPX - #else - #define LV_USE_FONT_SUBPX 0 - #endif -#endif -#if LV_USE_FONT_SUBPX - /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ - #ifndef LV_FONT_SUBPX_BGR - #ifdef CONFIG_LV_FONT_SUBPX_BGR - #define LV_FONT_SUBPX_BGR CONFIG_LV_FONT_SUBPX_BGR - #else - #define LV_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ - #endif - #endif -#endif - /*Enable drawing placeholders when glyph dsc is not found*/ #ifndef LV_USE_FONT_PLACEHOLDER #ifdef _LV_KCONFIG_PRESENT @@ -2335,10 +2318,14 @@ /*Show some widget. It might be required to increase `LV_MEM_SIZE` */ #ifndef LV_USE_DEMO_WIDGETS - #ifdef CONFIG_LV_USE_DEMO_WIDGETS - #define LV_USE_DEMO_WIDGETS CONFIG_LV_USE_DEMO_WIDGETS + #ifdef _LV_KCONFIG_PRESENT + #ifdef CONFIG_LV_USE_DEMO_WIDGETS + #define LV_USE_DEMO_WIDGETS CONFIG_LV_USE_DEMO_WIDGETS + #else + #define LV_USE_DEMO_WIDGETS 0 + #endif #else - #define LV_USE_DEMO_WIDGETS 0 + #define LV_USE_DEMO_WIDGETS 1 #endif #endif #if LV_USE_DEMO_WIDGETS diff --git a/src/misc/lv_anim.c b/src/misc/lv_anim.c index 4e4253a6ec..f98ad13cc2 100644 --- a/src/misc/lv_anim.c +++ b/src/misc/lv_anim.c @@ -9,6 +9,7 @@ #include "lv_anim.h" #include "../hal/lv_hal_tick.h" +#include "../hal/lv_hal_disp.h" #include "lv_assert.h" #include "lv_timer.h" #include "lv_math.h" @@ -57,14 +58,14 @@ static lv_timer_t * _lv_anim_tmr; void _lv_anim_core_init(void) { _lv_ll_init(&LV_GC_ROOT(_lv_anim_ll), sizeof(lv_anim_t)); - _lv_anim_tmr = lv_timer_create(anim_timer, LV_DISP_DEF_REFR_PERIOD, NULL); + _lv_anim_tmr = lv_timer_create(anim_timer, LV_DEF_REFR_PERIOD, NULL); anim_mark_list_change(); /*Turn off the animation timer*/ anim_list_changed = false; } void lv_anim_init(lv_anim_t * a) { - lv_memset_00(a, sizeof(lv_anim_t)); + lv_memzero(a, sizeof(lv_anim_t)); a->time = 500; a->start_value = 0; a->end_value = 100; @@ -148,7 +149,7 @@ bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb) if((a->var == var || var == NULL) && (a->exec_cb == exec_cb || exec_cb == NULL)) { _lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a); if(a->deleted_cb != NULL) a->deleted_cb(a); - lv_mem_free(a); + lv_free(a); anim_mark_list_change(); /*Read by `anim_timer`. It need to know if a delete occurred in the linked list*/ del = true; @@ -436,7 +437,7 @@ static void anim_ready_handler(lv_anim_t * a) /*Call the callback function at the end*/ if(a->ready_cb != NULL) a->ready_cb(a); if(a->deleted_cb != NULL) a->deleted_cb(a); - lv_mem_free(a); + lv_free(a); } /*If the animation is not deleted then restart it*/ else { diff --git a/src/misc/lv_anim_timeline.c b/src/misc/lv_anim_timeline.c index 08d5321fb4..9de575e825 100644 --- a/src/misc/lv_anim_timeline.c +++ b/src/misc/lv_anim_timeline.c @@ -50,11 +50,11 @@ static void lv_anim_timeline_virtual_exec_cb(void * var, int32_t v); lv_anim_timeline_t * lv_anim_timeline_create(void) { - lv_anim_timeline_t * at = (lv_anim_timeline_t *)lv_mem_alloc(sizeof(lv_anim_timeline_t)); + lv_anim_timeline_t * at = (lv_anim_timeline_t *)lv_malloc(sizeof(lv_anim_timeline_t)); LV_ASSERT_MALLOC(at); - if(at) lv_memset_00(at, sizeof(lv_anim_timeline_t)); + if(at) lv_memzero(at, sizeof(lv_anim_timeline_t)); return at; } @@ -65,8 +65,8 @@ void lv_anim_timeline_del(lv_anim_timeline_t * at) lv_anim_timeline_stop(at); - lv_mem_free(at->anim_dsc); - lv_mem_free(at); + lv_free(at->anim_dsc); + lv_free(at); } void lv_anim_timeline_add(lv_anim_timeline_t * at, uint32_t start_time, lv_anim_t * a) @@ -74,7 +74,7 @@ void lv_anim_timeline_add(lv_anim_timeline_t * at, uint32_t start_time, lv_anim_ LV_ASSERT_NULL(at); at->anim_dsc_cnt++; - at->anim_dsc = lv_mem_realloc(at->anim_dsc, at->anim_dsc_cnt * sizeof(lv_anim_timeline_dsc_t)); + at->anim_dsc = lv_realloc(at->anim_dsc, at->anim_dsc_cnt * sizeof(lv_anim_timeline_dsc_t)); LV_ASSERT_MALLOC(at->anim_dsc); diff --git a/src/misc/lv_async.c b/src/misc/lv_async.c index c4941e8117..01c183c934 100644 --- a/src/misc/lv_async.c +++ b/src/misc/lv_async.c @@ -45,7 +45,7 @@ static void lv_async_timer_cb(lv_timer_t * timer); lv_res_t lv_async_call(lv_async_cb_t async_xcb, void * user_data) { /*Allocate an info structure*/ - lv_async_info_t * info = lv_mem_alloc(sizeof(lv_async_info_t)); + lv_async_info_t * info = lv_malloc(sizeof(lv_async_info_t)); if(info == NULL) return LV_RES_INV; @@ -54,7 +54,7 @@ lv_res_t lv_async_call(lv_async_cb_t async_xcb, void * user_data) lv_timer_t * timer = lv_timer_create(lv_async_timer_cb, 0, info); if(timer == NULL) { - lv_mem_free(info); + lv_free(info); return LV_RES_INV; } @@ -81,7 +81,7 @@ lv_res_t lv_async_call_cancel(lv_async_cb_t async_xcb, void * user_data) /*Match user function callback and user data*/ if(info->cb == async_xcb && info->user_data == user_data) { lv_timer_del(timer); - lv_mem_free(info); + lv_free(info); res = LV_RES_OK; } } @@ -101,5 +101,5 @@ static void lv_async_timer_cb(lv_timer_t * timer) lv_async_info_t * info = (lv_async_info_t *)timer->user_data; info->cb(info->user_data); - lv_mem_free(info); + lv_free(info); } diff --git a/src/misc/lv_bidi.c b/src/misc/lv_bidi.c index 3dc3ce7f14..bcb76bd844 100644 --- a/src/misc/lv_bidi.c +++ b/src/misc/lv_bidi.c @@ -126,7 +126,7 @@ lv_base_dir_t _lv_bidi_detect_base_dir(const char * txt) * Get the logical position of a character in a line * @param str_in the input string. Can be only one line. * @param bidi_txt internally the text is bidi processed which buffer can be get here. - * If not required anymore has to freed with `lv_mem_free()` + * If not required anymore has to freed with `lv_free()` * Can be `NULL` is unused * @param len length of the line in character count * @param base_dir base direction of the text: `LV_BASE_DIR_LTR` or `LV_BASE_DIR_RTL` @@ -138,12 +138,12 @@ uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_ uint32_t visual_pos, bool * is_rtl) { uint32_t pos_conv_len = get_txt_len(str_in, len); - char * buf = lv_mem_buf_get(len + 1); + char * buf = lv_malloc(len + 1); if(buf == NULL) return (uint16_t) -1; - uint16_t * pos_conv_buf = lv_mem_buf_get(pos_conv_len * sizeof(uint16_t)); + uint16_t * pos_conv_buf = lv_malloc(pos_conv_len * sizeof(uint16_t)); if(pos_conv_buf == NULL) { - lv_mem_buf_release(buf); + lv_free(buf); return (uint16_t) -1; } @@ -153,9 +153,9 @@ uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_ if(is_rtl) *is_rtl = IS_RTL_POS(pos_conv_buf[visual_pos]); - if(bidi_txt == NULL) lv_mem_buf_release(buf); + if(bidi_txt == NULL) lv_free(buf); uint16_t res = GET_POS(pos_conv_buf[visual_pos]); - lv_mem_buf_release(pos_conv_buf); + lv_free(pos_conv_buf); return res; } @@ -163,7 +163,7 @@ uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_ * Get the visual position of a character in a line * @param str_in the input string. Can be only one line. * @param bidi_txt internally the text is bidi processed which buffer can be get here. - * If not required anymore has to freed with `lv_mem_free()` + * If not required anymore has to freed with `lv_free()` * Can be `NULL` is unused * @param len length of the line in character count * @param base_dir base direction of the text: `LV_BASE_DIR_LTR` or `LV_BASE_DIR_RTL` @@ -175,12 +175,12 @@ uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t uint32_t logical_pos, bool * is_rtl) { uint32_t pos_conv_len = get_txt_len(str_in, len); - char * buf = lv_mem_buf_get(len + 1); + char * buf = lv_malloc(len + 1); if(buf == NULL) return (uint16_t) -1; - uint16_t * pos_conv_buf = lv_mem_buf_get(pos_conv_len * sizeof(uint16_t)); + uint16_t * pos_conv_buf = lv_malloc(pos_conv_len * sizeof(uint16_t)); if(pos_conv_buf == NULL) { - lv_mem_buf_release(buf); + lv_free(buf); return (uint16_t) -1; } @@ -192,14 +192,14 @@ uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t if(GET_POS(pos_conv_buf[i]) == logical_pos) { if(is_rtl) *is_rtl = IS_RTL_POS(pos_conv_buf[i]); - lv_mem_buf_release(pos_conv_buf); + lv_free(pos_conv_buf); - if(bidi_txt == NULL) lv_mem_buf_release(buf); + if(bidi_txt == NULL) lv_free(buf); return i; } } - lv_mem_buf_release(pos_conv_buf); - if(bidi_txt == NULL) lv_mem_buf_release(buf); + lv_free(pos_conv_buf); + if(bidi_txt == NULL) lv_free(buf); return (uint16_t) -1; } diff --git a/src/misc/lv_bidi.h b/src/misc/lv_bidi.h index a27b58086c..c6042f59e8 100644 --- a/src/misc/lv_bidi.h +++ b/src/misc/lv_bidi.h @@ -66,7 +66,7 @@ lv_base_dir_t _lv_bidi_detect_base_dir(const char * txt); * Get the logical position of a character in a line * @param str_in the input string. Can be only one line. * @param bidi_txt internally the text is bidi processed which buffer can be get here. - * If not required anymore has to freed with `lv_mem_free()` + * If not required anymore has to freed with `lv_free()` * Can be `NULL` is unused * @param len length of the line in character count * @param base_dir base direction of the text: `LV_BASE_DIR_LTR` or `LV_BASE_DIR_RTL` @@ -81,7 +81,7 @@ uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_ * Get the visual position of a character in a line * @param str_in the input string. Can be only one line. * @param bidi_txt internally the text is bidi processed which buffer can be get here. - * If not required anymore has to freed with `lv_mem_free()` + * If not required anymore has to freed with `lv_free()` * Can be `NULL` is unused * @param len length of the line in character count * @param base_dir base direction of the text: `LV_BASE_DIR_LTR` or `LV_BASE_DIR_RTL` diff --git a/src/misc/lv_fs.c b/src/misc/lv_fs.c index 52f3ce07de..1ffa65a6a7 100644 --- a/src/misc/lv_fs.c +++ b/src/misc/lv_fs.c @@ -92,9 +92,9 @@ lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mo file_p->file_d = file_d; if(drv->cache_size) { - file_p->cache = lv_mem_alloc(sizeof(lv_fs_file_cache_t)); + file_p->cache = lv_malloc(sizeof(lv_fs_file_cache_t)); LV_ASSERT_MALLOC(file_p->cache); - lv_memset_00(file_p->cache, sizeof(lv_fs_file_cache_t)); + lv_memzero(file_p->cache, sizeof(lv_fs_file_cache_t)); file_p->cache->start = UINT32_MAX; /*Set an invalid range by default*/ file_p->cache->end = UINT32_MAX - 1; } @@ -116,10 +116,10 @@ lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p) if(file_p->drv->cache_size && file_p->cache) { if(file_p->cache->buffer) { - lv_mem_free(file_p->cache->buffer); + lv_free(file_p->cache->buffer); } - lv_mem_free(file_p->cache); + lv_free(file_p->cache); } file_p->file_d = NULL; @@ -179,7 +179,7 @@ static lv_fs_res_t lv_fs_read_cached(lv_fs_file_t * file_p, char * buf, uint32_t else { /*If small data is requested, then read from FS into cache buffer*/ if(buffer == NULL) { - file_p->cache->buffer = lv_mem_alloc(buffer_size); + file_p->cache->buffer = lv_malloc(buffer_size); LV_ASSERT_MALLOC(file_p->cache->buffer); buffer = file_p->cache->buffer; } @@ -392,7 +392,7 @@ lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p) void lv_fs_drv_init(lv_fs_drv_t * drv) { - lv_memset_00(drv, sizeof(lv_fs_drv_t)); + lv_memzero(drv, sizeof(lv_fs_drv_t)); } void lv_fs_drv_register(lv_fs_drv_t * drv_p) diff --git a/src/misc/lv_gc.c b/src/misc/lv_gc.c index 95bb5499a2..ba34e9b967 100644 --- a/src/misc/lv_gc.c +++ b/src/misc/lv_gc.c @@ -38,7 +38,7 @@ void _lv_gc_clear_roots(void) { -#define LV_CLEAR_ROOT(root_type, root_name) lv_memset_00(&LV_GC_ROOT(root_name), sizeof(LV_GC_ROOT(root_name))); +#define LV_CLEAR_ROOT(root_type, root_name) lv_memzero(&LV_GC_ROOT(root_name), sizeof(LV_GC_ROOT(root_name))); LV_ITERATE_ROOTS(LV_CLEAR_ROOT) } diff --git a/src/misc/lv_gc.h b/src/misc/lv_gc.h index 9d7d1bb92d..98c9781500 100644 --- a/src/misc/lv_gc.h +++ b/src/misc/lv_gc.h @@ -53,9 +53,8 @@ extern "C" { LV_DISPATCH_COND(f, _lv_img_cache_entry_t*, _lv_img_cache_array, LV_IMG_CACHE_DEF, 1) \ LV_DISPATCH_COND(f, _lv_img_cache_entry_t, _lv_img_cache_single, LV_IMG_CACHE_DEF, 0) \ LV_DISPATCH(f, lv_timer_t*, _lv_timer_act) \ - LV_DISPATCH(f, lv_mem_buf_arr_t , lv_mem_buf) \ - LV_DISPATCH_COND(f, _lv_draw_mask_radius_circle_dsc_arr_t , _lv_circle_cache, LV_DRAW_COMPLEX, 1) \ - LV_DISPATCH_COND(f, _lv_draw_mask_saved_arr_t , _lv_draw_mask_list, LV_DRAW_COMPLEX, 1) \ + LV_DISPATCH_COND(f, _lv_draw_mask_radius_circle_dsc_arr_t , _lv_circle_cache, LV_USE_DRAW_MASKS, 1) \ + LV_DISPATCH_COND(f, _lv_draw_mask_saved_arr_t , _lv_draw_mask_list, LV_USE_DRAW_MASKS, 1) \ LV_DISPATCH(f, void * , _lv_theme_default_styles) \ LV_DISPATCH(f, void * , _lv_theme_basic_styles) \ LV_DISPATCH_COND(f, uint8_t *, _lv_font_decompr_buf, LV_USE_FONT_COMPRESSED, 1) \ diff --git a/src/misc/lv_ll.c b/src/misc/lv_ll.c index e7582316bb..cc9027931f 100644 --- a/src/misc/lv_ll.c +++ b/src/misc/lv_ll.c @@ -68,7 +68,7 @@ void * _lv_ll_ins_head(lv_ll_t * ll_p) { lv_ll_node_t * n_new; - n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE); + n_new = lv_malloc(ll_p->n_size + LL_NODE_META_SIZE); if(n_new != NULL) { node_set_prev(ll_p, n_new, NULL); /*No prev. before the new head*/ @@ -104,7 +104,7 @@ void * _lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act) if(n_new == NULL) return NULL; } else { - n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE); + n_new = lv_malloc(ll_p->n_size + LL_NODE_META_SIZE); if(n_new == NULL) return NULL; lv_ll_node_t * n_prev; @@ -127,7 +127,7 @@ void * _lv_ll_ins_tail(lv_ll_t * ll_p) { lv_ll_node_t * n_new; - n_new = lv_mem_alloc(ll_p->n_size + LL_NODE_META_SIZE); + n_new = lv_malloc(ll_p->n_size + LL_NODE_META_SIZE); if(n_new != NULL) { node_set_next(ll_p, n_new, NULL); /*No next after the new tail*/ @@ -200,7 +200,7 @@ void _lv_ll_clear(lv_ll_t * ll_p) i_next = _lv_ll_get_next(ll_p, i); _lv_ll_remove(ll_p, i); - lv_mem_free(i); + lv_free(i); i = i_next; } diff --git a/src/misc/lv_lru.c b/src/misc/lv_lru.c index 6ff83903e3..85816a9164 100644 --- a/src/misc/lv_lru.c +++ b/src/misc/lv_lru.c @@ -74,8 +74,8 @@ lv_lru_t * lv_lru_create(size_t cache_size, size_t average_length, lv_lru_free_t lv_lru_free_t * key_free) { // create the cache - lv_lru_t * cache = (lv_lru_t *) lv_mem_alloc(sizeof(lv_lru_t)); - lv_memset_00(cache, sizeof(lv_lru_t)); + lv_lru_t * cache = (lv_lru_t *) lv_malloc(sizeof(lv_lru_t)); + lv_memzero(cache, sizeof(lv_lru_t)); if(!cache) { LV_LOG_WARN("LRU Cache unable to create cache object"); return NULL; @@ -85,15 +85,15 @@ lv_lru_t * lv_lru_create(size_t cache_size, size_t average_length, lv_lru_free_t cache->free_memory = cache_size; cache->total_memory = cache_size; cache->seed = lv_rand(1, UINT32_MAX); - cache->value_free = value_free ? value_free : lv_mem_free; - cache->key_free = key_free ? key_free : lv_mem_free; + cache->value_free = value_free ? value_free : lv_free; + cache->key_free = key_free ? key_free : lv_free; // size the hash table to a guestimate of the number of slots required (assuming a perfect hash) - cache->items = (lv_lru_item_t **) lv_mem_alloc(sizeof(lv_lru_item_t *) * cache->hash_table_size); - lv_memset_00(cache->items, sizeof(lv_lru_item_t *) * cache->hash_table_size); + cache->items = (lv_lru_item_t **) lv_malloc(sizeof(lv_lru_item_t *) * cache->hash_table_size); + lv_memzero(cache->items, sizeof(lv_lru_item_t *) * cache->hash_table_size); if(!cache->items) { LV_LOG_WARN("LRU Cache unable to create cache hash table"); - lv_mem_free(cache); + lv_free(cache); return NULL; } return cache; @@ -115,24 +115,24 @@ void lv_lru_del(lv_lru_t * cache) cache->value_free(item->value); cache->key_free(item->key); cache->free_memory += item->value_length; - lv_mem_free(item); + lv_free(item); item = next; } } - lv_mem_free(cache->items); + lv_free(cache->items); } if(cache->free_items) { item = cache->free_items; while(item) { next = (lv_lru_item_t *) item->next; - lv_mem_free(item); + lv_free(item); item = next; } } // free the cache - lv_mem_free(cache); + lv_free(cache); } @@ -166,7 +166,7 @@ lv_lru_res_t lv_lru_set(lv_lru_t * cache, const void * key, size_t key_length, v // insert a new item item = lv_lru_pop_or_create_item(cache); item->value = value; - item->key = lv_mem_alloc(key_length); + item->key = lv_malloc(key_length); memcpy(item->key, key, key_length); item->value_length = value_length; item->key_length = key_length; @@ -326,7 +326,7 @@ static void lv_lru_remove_item(lv_lru_t * cache, lv_lru_item_t * prev, lv_lru_it cache->key_free(item->key); // push the item to the free items queue - lv_memset_00(item, sizeof(lv_lru_item_t)); + lv_memzero(item, sizeof(lv_lru_item_t)); item->next = cache->free_items; cache->free_items = item; } @@ -338,11 +338,11 @@ static lv_lru_item_t * lv_lru_pop_or_create_item(lv_lru_t * cache) if(cache->free_items) { item = cache->free_items; cache->free_items = item->next; - lv_memset_00(item, sizeof(lv_lru_item_t)); + lv_memzero(item, sizeof(lv_lru_item_t)); } else { - item = (lv_lru_item_t *) lv_mem_alloc(sizeof(lv_lru_item_t)); - lv_memset_00(item, sizeof(lv_lru_item_t)); + item = (lv_lru_item_t *) lv_malloc(sizeof(lv_lru_item_t)); + lv_memzero(item, sizeof(lv_lru_item_t)); } return item; diff --git a/src/misc/lv_mem.c b/src/misc/lv_mem.c index b7c602f7a4..f165848a0c 100644 --- a/src/misc/lv_mem.c +++ b/src/misc/lv_mem.c @@ -9,16 +9,11 @@ *********************/ #include "lv_mem.h" #include "lv_tlsf.h" -#include "lv_gc.h" #include "lv_assert.h" #include "lv_log.h" - -#if LV_MEM_CUSTOM != 0 - #include LV_MEM_CUSTOM_INCLUDE -#endif - -#ifdef LV_MEM_POOL_INCLUDE - #include LV_MEM_POOL_INCLUDE +#include LV_STDLIB_INCLUDE +#if LV_USE_BUILTIN_MALLOC + #include "lv_mem_builtin.h" #endif /********************* @@ -29,14 +24,6 @@ #define LV_MEM_ADD_JUNK 0 #endif -#ifdef LV_ARCH_64 - #define MEM_UNIT uint64_t - #define ALIGN_MASK 0x7 -#else - #define MEM_UNIT uint32_t - #define ALIGN_MASK 0x3 -#endif - #define ZERO_MEM_SENTINEL 0xa1b2c3d4 /********************** @@ -46,19 +33,10 @@ /********************** * STATIC PROTOTYPES **********************/ -#if LV_MEM_CUSTOM == 0 - static void lv_mem_walker(void * ptr, size_t size, int used, void * user); -#endif /********************** * STATIC VARIABLES **********************/ -#if LV_MEM_CUSTOM == 0 - static lv_tlsf_t tlsf; - static uint32_t cur_used; - static uint32_t max_used; -#endif - static uint32_t zero_mem = ZERO_MEM_SENTINEL; /*Give the address of this variable if 0 byte should be allocated*/ /********************** @@ -70,59 +48,15 @@ static uint32_t zero_mem = ZERO_MEM_SENTINEL; /*Give the address of this variabl #define MEM_TRACE(...) #endif -#define COPY32 *d32 = *s32; d32++; s32++; -#define COPY8 *d8 = *s8; d8++; s8++; -#define SET32(x) *d32 = x; d32++; -#define SET8(x) *d8 = x; d8++; -#define REPEAT8(expr) expr expr expr expr expr expr expr expr - /********************** * GLOBAL FUNCTIONS **********************/ - -/** - * Initialize the dyn_mem module (work memory and other variables) - */ -void lv_mem_init(void) -{ -#if LV_MEM_CUSTOM == 0 - -#if LV_MEM_ADR == 0 -#ifdef LV_MEM_POOL_ALLOC - tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_POOL_ALLOC(LV_MEM_SIZE), LV_MEM_SIZE); -#else - /*Allocate a large array to store the dynamically allocated data*/ - static LV_ATTRIBUTE_LARGE_RAM_ARRAY MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)]; - tlsf = lv_tlsf_create_with_pool((void *)work_mem_int, LV_MEM_SIZE); -#endif -#else - tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_ADR, LV_MEM_SIZE); -#endif -#endif - -#if LV_MEM_ADD_JUNK - LV_LOG_WARN("LV_MEM_ADD_JUNK is enabled which makes LVGL much slower"); -#endif -} - -/** - * Clean up the memory buffer which frees all the allocated memories. - * @note It work only if `LV_MEM_CUSTOM == 0` - */ -void lv_mem_deinit(void) -{ -#if LV_MEM_CUSTOM == 0 - lv_tlsf_destroy(tlsf); - lv_mem_init(); -#endif -} - /** * Allocate a memory dynamically * @param size size of the memory to allocate in bytes * @return pointer to the allocated memory */ -void * lv_mem_alloc(size_t size) +void * lv_malloc(size_t size) { MEM_TRACE("allocating %lu bytes", (unsigned long)size); if(size == 0) { @@ -130,11 +64,7 @@ void * lv_mem_alloc(size_t size) return &zero_mem; } -#if LV_MEM_CUSTOM == 0 - void * alloc = lv_tlsf_malloc(tlsf, size); -#else - void * alloc = LV_MEM_CUSTOM_ALLOC(size); -#endif + void * alloc = LV_MALLOC(size); if(alloc == NULL) { LV_LOG_INFO("couldn't allocate memory (%lu bytes)", (unsigned long)size); @@ -144,21 +74,16 @@ void * lv_mem_alloc(size_t size) LV_LOG_INFO("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d", (int)(mon.total_size - mon.free_size), mon.used_pct, mon.frag_pct, (int)mon.free_biggest_size); + return NULL; #endif } + #if LV_MEM_ADD_JUNK - else { - lv_memset(alloc, 0xaa, size); - } + lv_memset(alloc, 0xaa, size); #endif - if(alloc) { -#if LV_MEM_CUSTOM == 0 - cur_used += size; - max_used = LV_MAX(cur_used, max_used); -#endif - MEM_TRACE("allocated at %p", alloc); - } + MEM_TRACE("allocated at %p", alloc); + return alloc; } @@ -166,22 +91,13 @@ void * lv_mem_alloc(size_t size) * Free an allocated data * @param data pointer to an allocated memory */ -void lv_mem_free(void * data) +void lv_free(void * data) { MEM_TRACE("freeing %p", data); if(data == &zero_mem) return; if(data == NULL) return; -#if LV_MEM_CUSTOM == 0 -# if LV_MEM_ADD_JUNK - lv_memset(data, 0xbb, lv_tlsf_block_size(data)); -# endif - size_t size = lv_tlsf_free(tlsf, data); - if(cur_used > size) cur_used -= size; - else cur_used = 0; -#else - LV_MEM_CUSTOM_FREE(data); -#endif + LV_FREE(data); } /** @@ -191,31 +107,47 @@ void lv_mem_free(void * data) * @param new_size the desired new size in byte * @return pointer to the new memory */ -void * lv_mem_realloc(void * data_p, size_t new_size) +void * lv_realloc(void * data_p, size_t new_size) { MEM_TRACE("reallocating %p with %lu size", data_p, (unsigned long)new_size); if(new_size == 0) { MEM_TRACE("using zero_mem"); - lv_mem_free(data_p); + lv_free(data_p); return &zero_mem; } - if(data_p == &zero_mem) return lv_mem_alloc(new_size); + if(data_p == &zero_mem) return lv_malloc(new_size); -#if LV_MEM_CUSTOM == 0 - void * new_p = lv_tlsf_realloc(tlsf, data_p, new_size); -#else - void * new_p = LV_MEM_CUSTOM_REALLOC(data_p, new_size); -#endif + void * new_p = LV_REALLOC(data_p, new_size); if(new_p == NULL) { - LV_LOG_ERROR("couldn't allocate memory"); + LV_LOG_ERROR("couldn't reallocate memory"); return NULL; } - MEM_TRACE("allocated at %p", new_p); + MEM_TRACE("reallocated at %p", new_p); return new_p; } +void * lv_memcpy(void * dst, const void * src, size_t len) +{ + return LV_MEMCPY(dst, src, len); +} + +void lv_memset(void * dst, uint8_t v, size_t len) +{ + return LV_MEMSET(dst, v, len); +} + +size_t lv_strlen(const char * str) +{ + return LV_STRLEN(str); +} + +size_t lv_strncpy(char * dst, size_t dest_size, const char * src) +{ + return LV_STRNCPY(dst, dest_size, src); +} + lv_res_t lv_mem_test(void) { if(zero_mem != ZERO_MEM_SENTINEL) { @@ -223,344 +155,22 @@ lv_res_t lv_mem_test(void) return LV_RES_INV; } -#if LV_MEM_CUSTOM == 0 - if(lv_tlsf_check(tlsf)) { - LV_LOG_WARN("failed"); - return LV_RES_INV; - } - - if(lv_tlsf_check_pool(lv_tlsf_get_pool(tlsf))) { - LV_LOG_WARN("pool failed"); - return LV_RES_INV; - } -#endif - MEM_TRACE("passed"); +#if LV_USE_BUILTIN_MALLOC + return lv_mem_test_builtin(); +#else return LV_RES_OK; +#endif } -/** - * Give information about the work memory of dynamic allocation - * @param mon_p pointer to a lv_mem_monitor_t variable, - * the result of the analysis will be stored here - */ void lv_mem_monitor(lv_mem_monitor_t * mon_p) { /*Init the data*/ lv_memset(mon_p, 0, sizeof(lv_mem_monitor_t)); -#if LV_MEM_CUSTOM == 0 - MEM_TRACE("begin"); - - lv_tlsf_walk_pool(lv_tlsf_get_pool(tlsf), lv_mem_walker, mon_p); - - mon_p->total_size = LV_MEM_SIZE; - mon_p->used_pct = 100 - (100U * mon_p->free_size) / mon_p->total_size; - if(mon_p->free_size > 0) { - mon_p->frag_pct = mon_p->free_biggest_size * 100U / mon_p->free_size; - mon_p->frag_pct = 100 - mon_p->frag_pct; - } - else { - mon_p->frag_pct = 0; /*no fragmentation if all the RAM is used*/ - } - - mon_p->max_used = max_used; - - MEM_TRACE("finished"); +#if LV_USE_BUILTIN_MALLOC + lv_mem_monitor_builtin(mon_p); #endif } - -/** - * Get a temporal buffer with the given size. - * @param size the required size - */ -void * lv_mem_buf_get(uint32_t size) -{ - if(size == 0) return NULL; - - MEM_TRACE("begin, getting %d bytes", size); - - /*Try to find a free buffer with suitable size*/ - int8_t i_guess = -1; - for(uint8_t i = 0; i < LV_MEM_BUF_MAX_NUM; i++) { - if(LV_GC_ROOT(lv_mem_buf[i]).used == 0 && LV_GC_ROOT(lv_mem_buf[i]).size >= size) { - if(LV_GC_ROOT(lv_mem_buf[i]).size == size) { - LV_GC_ROOT(lv_mem_buf[i]).used = 1; - return LV_GC_ROOT(lv_mem_buf[i]).p; - } - else if(i_guess < 0) { - i_guess = i; - } - /*If size of `i` is closer to `size` prefer it*/ - else if(LV_GC_ROOT(lv_mem_buf[i]).size < LV_GC_ROOT(lv_mem_buf[i_guess]).size) { - i_guess = i; - } - } - } - - if(i_guess >= 0) { - LV_GC_ROOT(lv_mem_buf[i_guess]).used = 1; - MEM_TRACE("returning already allocated buffer (buffer id: %d, address: %p)", i_guess, - LV_GC_ROOT(lv_mem_buf[i_guess]).p); - return LV_GC_ROOT(lv_mem_buf[i_guess]).p; - } - - /*Reallocate a free buffer*/ - for(uint8_t i = 0; i < LV_MEM_BUF_MAX_NUM; i++) { - if(LV_GC_ROOT(lv_mem_buf[i]).used == 0) { - /*if this fails you probably need to increase your LV_MEM_SIZE/heap size*/ - void * buf = lv_mem_realloc(LV_GC_ROOT(lv_mem_buf[i]).p, size); - LV_ASSERT_MSG(buf != NULL, "Out of memory, can't allocate a new buffer (increase your LV_MEM_SIZE/heap size)"); - if(buf == NULL) return NULL; - - LV_GC_ROOT(lv_mem_buf[i]).used = 1; - LV_GC_ROOT(lv_mem_buf[i]).size = size; - LV_GC_ROOT(lv_mem_buf[i]).p = buf; - MEM_TRACE("allocated (buffer id: %d, address: %p)", i, LV_GC_ROOT(lv_mem_buf[i]).p); - return LV_GC_ROOT(lv_mem_buf[i]).p; - } - } - - LV_LOG_ERROR("no more buffers. (increase LV_MEM_BUF_MAX_NUM)"); - LV_ASSERT_MSG(false, "No more buffers. Increase LV_MEM_BUF_MAX_NUM."); - return NULL; -} - -/** - * Release a memory buffer - * @param p buffer to release - */ -void lv_mem_buf_release(void * p) -{ - MEM_TRACE("begin (address: %p)", p); - - for(uint8_t i = 0; i < LV_MEM_BUF_MAX_NUM; i++) { - if(LV_GC_ROOT(lv_mem_buf[i]).p == p) { - LV_GC_ROOT(lv_mem_buf[i]).used = 0; - return; - } - } - - LV_LOG_ERROR("p is not a known buffer"); -} - -/** - * Free all memory buffers - */ -void lv_mem_buf_free_all(void) -{ - for(uint8_t i = 0; i < LV_MEM_BUF_MAX_NUM; i++) { - if(LV_GC_ROOT(lv_mem_buf[i]).p) { - lv_mem_free(LV_GC_ROOT(lv_mem_buf[i]).p); - LV_GC_ROOT(lv_mem_buf[i]).p = NULL; - LV_GC_ROOT(lv_mem_buf[i]).used = 0; - LV_GC_ROOT(lv_mem_buf[i]).size = 0; - } - } -} - -#if LV_MEMCPY_MEMSET_STD == 0 -/** - * Same as `memcpy` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param src pointer to the source buffer - * @param len number of byte to copy - */ -LV_ATTRIBUTE_FAST_MEM void * lv_memcpy(void * dst, const void * src, size_t len) -{ - uint8_t * d8 = dst; - const uint8_t * s8 = src; - - lv_uintptr_t d_align = (lv_uintptr_t)d8 & ALIGN_MASK; - lv_uintptr_t s_align = (lv_uintptr_t)s8 & ALIGN_MASK; - - /*Byte copy for unaligned memories*/ - if(s_align != d_align) { - while(len > 32) { - REPEAT8(COPY8); - REPEAT8(COPY8); - REPEAT8(COPY8); - REPEAT8(COPY8); - len -= 32; - } - while(len) { - COPY8 - len--; - } - return dst; - } - - /*Make the memories aligned*/ - if(d_align) { - d_align = ALIGN_MASK + 1 - d_align; - while(d_align && len) { - COPY8; - d_align--; - len--; - } - } - - uint32_t * d32 = (uint32_t *)d8; - const uint32_t * s32 = (uint32_t *)s8; - while(len > 32) { - REPEAT8(COPY32) - len -= 32; - } - - while(len > 4) { - COPY32; - len -= 4; - } - - d8 = (uint8_t *)d32; - s8 = (const uint8_t *)s32; - while(len) { - COPY8 - len--; - } - - return dst; -} - -/** - * Same as `memset` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param v value to set [0..255] - * @param len number of byte to set - */ -LV_ATTRIBUTE_FAST_MEM void lv_memset(void * dst, uint8_t v, size_t len) -{ - - uint8_t * d8 = (uint8_t *)dst; - - uintptr_t d_align = (lv_uintptr_t) d8 & ALIGN_MASK; - - /*Make the address aligned*/ - if(d_align) { - d_align = ALIGN_MASK + 1 - d_align; - while(d_align && len) { - SET8(v); - len--; - d_align--; - } - } - - uint32_t v32 = (uint32_t)v + ((uint32_t)v << 8) + ((uint32_t)v << 16) + ((uint32_t)v << 24); - - uint32_t * d32 = (uint32_t *)d8; - - while(len > 32) { - REPEAT8(SET32(v32)); - len -= 32; - } - - while(len > 4) { - SET32(v32); - len -= 4; - } - - d8 = (uint8_t *)d32; - while(len) { - SET8(v); - len--; - } -} - -/** - * Same as `memset(dst, 0x00, len)` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param len number of byte to set - */ -LV_ATTRIBUTE_FAST_MEM void lv_memset_00(void * dst, size_t len) -{ - uint8_t * d8 = (uint8_t *)dst; - uintptr_t d_align = (lv_uintptr_t) d8 & ALIGN_MASK; - - /*Make the address aligned*/ - if(d_align) { - d_align = ALIGN_MASK + 1 - d_align; - while(d_align && len) { - SET8(0); - len--; - d_align--; - } - } - - uint32_t * d32 = (uint32_t *)d8; - while(len > 32) { - REPEAT8(SET32(0)); - len -= 32; - } - - while(len > 4) { - SET32(0); - len -= 4; - } - - d8 = (uint8_t *)d32; - while(len) { - SET8(0); - len--; - } -} - -/** - * Same as `memset(dst, 0xFF, len)` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param len number of byte to set - */ -LV_ATTRIBUTE_FAST_MEM void lv_memset_ff(void * dst, size_t len) -{ - uint8_t * d8 = (uint8_t *)dst; - uintptr_t d_align = (lv_uintptr_t) d8 & ALIGN_MASK; - - /*Make the address aligned*/ - if(d_align) { - d_align = ALIGN_MASK + 1 - d_align; - while(d_align && len) { - SET8(0xFF); - len--; - d_align--; - } - } - - uint32_t * d32 = (uint32_t *)d8; - while(len > 32) { - REPEAT8(SET32(0xFFFFFFFF)); - len -= 32; - } - - while(len > 4) { - SET32(0xFFFFFFFF); - len -= 4; - } - - d8 = (uint8_t *)d32; - while(len) { - SET8(0xFF); - len--; - } -} - -#endif /*LV_MEMCPY_MEMSET_STD*/ - /********************** * STATIC FUNCTIONS **********************/ - -#if LV_MEM_CUSTOM == 0 -static void lv_mem_walker(void * ptr, size_t size, int used, void * user) -{ - LV_UNUSED(ptr); - - lv_mem_monitor_t * mon_p = user; - if(used) { - mon_p->used_cnt++; - } - else { - mon_p->free_cnt++; - mon_p->free_size += size; - if(size > mon_p->free_biggest_size) - mon_p->free_biggest_size = size; - } -} -#endif diff --git a/src/misc/lv_mem.h b/src/misc/lv_mem.h index 7a83b3d5df..84230001c6 100644 --- a/src/misc/lv_mem.h +++ b/src/misc/lv_mem.h @@ -43,41 +43,22 @@ typedef struct { uint8_t frag_pct; /**< Amount of fragmentation*/ } lv_mem_monitor_t; -typedef struct { - void * p; - uint16_t size; - uint8_t used : 1; -} lv_mem_buf_t; - -typedef lv_mem_buf_t lv_mem_buf_arr_t[LV_MEM_BUF_MAX_NUM]; - /********************** * GLOBAL PROTOTYPES **********************/ -/** - * Initialize the dyn_mem module (work memory and other variables) - */ -void lv_mem_init(void); - -/** - * Clean up the memory buffer which frees all the allocated memories. - * @note It work only if `LV_MEM_CUSTOM == 0` - */ -void lv_mem_deinit(void); - /** * Allocate a memory dynamically * @param size size of the memory to allocate in bytes * @return pointer to the allocated memory */ -void * lv_mem_alloc(size_t size); +void * lv_malloc(size_t size); /** * Free an allocated data * @param data pointer to an allocated memory */ -void lv_mem_free(void * data); +void lv_free(void * data); /** * Reallocate a memory with a new size. The old content will be kept. @@ -86,7 +67,28 @@ void lv_mem_free(void * data); * @param new_size the desired new size in byte * @return pointer to the new memory, NULL on failure */ -void * lv_mem_realloc(void * data_p, size_t new_size); +void * lv_realloc(void * data_p, size_t new_size); + + +void * lv_memcpy(void * dst, const void * src, size_t len); + +void lv_memset(void * dst, uint8_t v, size_t len); + +/** + * Same as `memset(dst, 0x00, len)`. + * @param dst pointer to the destination buffer + * @param len number of byte to set + */ +static inline void lv_memzero(void * dst, size_t len) +{ + lv_memset(dst, 0x00, len); +} + +size_t lv_strlenn(const char * str); + +size_t lv_strncpy(char * dst, size_t dest_size, const char * src); + + /** * @@ -101,137 +103,6 @@ lv_res_t lv_mem_test(void); */ void lv_mem_monitor(lv_mem_monitor_t * mon_p); - -/** - * Get a temporal buffer with the given size. - * @param size the required size - */ -void * lv_mem_buf_get(uint32_t size); - -/** - * Release a memory buffer - * @param p buffer to release - */ -void lv_mem_buf_release(void * p); - -/** - * Free all memory buffers - */ -void lv_mem_buf_free_all(void); - -//! @cond Doxygen_Suppress - -#if LV_MEMCPY_MEMSET_STD - -/** - * Wrapper for the standard memcpy - * @param dst pointer to the destination buffer - * @param src pointer to the source buffer - * @param len number of byte to copy - */ -static inline void * lv_memcpy(void * dst, const void * src, size_t len) -{ - return memcpy(dst, src, len); -} - -/** - * Wrapper for the standard memcpy - * @param dst pointer to the destination buffer - * @param src pointer to the source buffer - * @param len number of byte to copy - */ -static inline void * lv_memcpy_small(void * dst, const void * src, size_t len) -{ - return memcpy(dst, src, len); -} - -/** - * Wrapper for the standard memset - * @param dst pointer to the destination buffer - * @param v value to set [0..255] - * @param len number of byte to set - */ -static inline void lv_memset(void * dst, uint8_t v, size_t len) -{ - memset(dst, v, len); -} - -/** - * Wrapper for the standard memset with fixed 0x00 value - * @param dst pointer to the destination buffer - * @param len number of byte to set - */ -static inline void lv_memset_00(void * dst, size_t len) -{ - memset(dst, 0x00, len); -} - -/** - * Wrapper for the standard memset with fixed 0xFF value - * @param dst pointer to the destination buffer - * @param len number of byte to set - */ -static inline void lv_memset_ff(void * dst, size_t len) -{ - memset(dst, 0xFF, len); -} - -#else -/** - * Same as `memcpy` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param src pointer to the source buffer - * @param len number of byte to copy - */ -LV_ATTRIBUTE_FAST_MEM void * lv_memcpy(void * dst, const void * src, size_t len); - -/** - * Same as `memcpy` but optimized to copy only a few bytes. - * @param dst pointer to the destination buffer - * @param src pointer to the source buffer - * @param len number of byte to copy - */ -LV_ATTRIBUTE_FAST_MEM static inline void * lv_memcpy_small(void * dst, const void * src, size_t len) -{ - uint8_t * d8 = (uint8_t *)dst; - const uint8_t * s8 = (const uint8_t *)src; - - while(len) { - *d8 = *s8; - d8++; - s8++; - len--; - } - - return dst; -} - -/** - * Same as `memset` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param v value to set [0..255] - * @param len number of byte to set - */ -LV_ATTRIBUTE_FAST_MEM void lv_memset(void * dst, uint8_t v, size_t len); - -/** - * Same as `memset(dst, 0x00, len)` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param len number of byte to set - */ -LV_ATTRIBUTE_FAST_MEM void lv_memset_00(void * dst, size_t len); - -/** - * Same as `memset(dst, 0xFF, len)` but optimized for 4 byte operation. - * @param dst pointer to the destination buffer - * @param len number of byte to set - */ -LV_ATTRIBUTE_FAST_MEM void lv_memset_ff(void * dst, size_t len); - -//! @endcond - -#endif - /********************** * MACROS **********************/ diff --git a/src/misc/lv_mem_builtin.c b/src/misc/lv_mem_builtin.c new file mode 100644 index 0000000000..c438b52112 --- /dev/null +++ b/src/misc/lv_mem_builtin.c @@ -0,0 +1,298 @@ +/** + * @file lv_mem_builtin.c + */ + +/********************* + * INCLUDES + *********************/ +#include "lv_mem.h" +#if LV_USE_BUILTIN_MALLOC +#include "lv_tlsf.h" +#include "lv_assert.h" +#include "lv_log.h" +#include "lv_math.h" + +#ifdef LV_MEM_POOL_INCLUDE + #include LV_MEM_POOL_INCLUDE +#endif + +/********************* + * DEFINES + *********************/ +/*memset the allocated memories to 0xaa and freed memories to 0xbb (just for testing purposes)*/ +#ifndef LV_MEM_ADD_JUNK + #define LV_MEM_ADD_JUNK 0 +#endif + +#ifdef LV_ARCH_64 + #define MEM_UNIT uint64_t + #define ALIGN_MASK 0x7 +#else + #define MEM_UNIT uint32_t + #define ALIGN_MASK 0x3 +#endif + +/********************** + * TYPEDEFS + **********************/ + +/********************** + * STATIC PROTOTYPES + **********************/ +static void lv_mem_walker(void * ptr, size_t size, int used, void * user); + +/********************** + * STATIC VARIABLES + **********************/ +static lv_tlsf_t tlsf; +static uint32_t cur_used; +static uint32_t max_used; + +/********************** + * MACROS + **********************/ +#if LV_LOG_TRACE_MEM + #define MEM_TRACE(...) LV_LOG_TRACE(__VA_ARGS__) +#else + #define MEM_TRACE(...) +#endif + +#define _COPY(d, s) *d = *s; d++; s++; +#define _SET(d, v) *d = v; d++; +#define _REPEAT8(expr) expr expr expr expr expr expr expr expr + +/********************** + * GLOBAL FUNCTIONS + **********************/ + +/** + * Initialize the dyn_mem module (work memory and other variables) + */ +void lv_mem_init_builtin(void) +{ +#if LV_MEM_ADR == 0 +#ifdef LV_MEM_POOL_ALLOC + tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_POOL_ALLOC(LV_MEM_SIZE), LV_MEM_SIZE); +#else + /*Allocate a large array to store the dynamically allocated data*/ + static LV_ATTRIBUTE_LARGE_RAM_ARRAY MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)]; + tlsf = lv_tlsf_create_with_pool((void *)work_mem_int, LV_MEM_SIZE); +#endif +#else + tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_ADR, LV_MEM_SIZE); +#endif + +#if LV_MEM_ADD_JUNK + LV_LOG_WARN("LV_MEM_ADD_JUNK is enabled which makes LVGL much slower"); +#endif +} + +void lv_mem_deinit_builtin(void) +{ + lv_tlsf_destroy(tlsf); + lv_mem_init_builtin(); +} + +void lv_mem_monitor_builtin(lv_mem_monitor_t * mon_p) +{ + /*Init the data*/ + lv_memset(mon_p, 0, sizeof(lv_mem_monitor_t)); + MEM_TRACE("begin"); + + lv_tlsf_walk_pool(lv_tlsf_get_pool(tlsf), lv_mem_walker, mon_p); + + mon_p->total_size = LV_MEM_SIZE; + mon_p->used_pct = 100 - (100U * mon_p->free_size) / mon_p->total_size; + if(mon_p->free_size > 0) { + mon_p->frag_pct = mon_p->free_biggest_size * 100U / mon_p->free_size; + mon_p->frag_pct = 100 - mon_p->frag_pct; + } + else { + mon_p->frag_pct = 0; /*no fragmentation if all the RAM is used*/ + } + + mon_p->max_used = max_used; + + MEM_TRACE("finished"); +} + +void * lv_malloc_builtin(size_t size) +{ + cur_used += size; + max_used = LV_MAX(cur_used, max_used); + return lv_tlsf_malloc(tlsf, size); +} + +void * lv_realloc_builtin(void * p, size_t new_size) +{ + return lv_tlsf_realloc(tlsf, p, new_size); +} + +void lv_free_builtin(void * p) +{ +#if LV_MEM_ADD_JUNK + lv_memset(p, 0xbb, lv_tlsf_block_size(data)); +#endif + size_t size = lv_tlsf_free(tlsf, p); + if(cur_used > size) cur_used -= size; + else cur_used = 0; +} + +/** + * Same as `memcpy` but optimized for 4 byte operation. + * @param dst pointer to the destination buffer + * @param src pointer to the source buffer + * @param len number of byte to copy + */ +LV_ATTRIBUTE_FAST_MEM void * lv_memcpy_builtin(void * dst, const void * src, size_t len) +{ + uint8_t * d8 = dst; + const uint8_t * s8 = src; + + /*Simplify for small memories*/ + if(len < 16) { + while(len) { + *d8 = *s8; + d8++; + s8++; + len--; + } + return dst; + } + + lv_uintptr_t d_align = (lv_uintptr_t)d8 & ALIGN_MASK; + lv_uintptr_t s_align = (lv_uintptr_t)s8 & ALIGN_MASK; + + /*Byte copy for unaligned memories*/ + if(s_align != d_align) { + while(len > 32) { + _REPEAT8(_COPY(d8, s8)); + _REPEAT8(_COPY(d8, s8)); + _REPEAT8(_COPY(d8, s8)); + _REPEAT8(_COPY(d8, s8)); + len -= 32; + } + while(len) { + _COPY(d8, s8) + len--; + } + return dst; + } + + /*Make the memories aligned*/ + if(d_align) { + d_align = ALIGN_MASK + 1 - d_align; + while(d_align && len) { + _COPY(d8, s8); + d_align--; + len--; + } + } + + uint32_t * d32 = (uint32_t *)d8; + const uint32_t * s32 = (uint32_t *)s8; + while(len > 32) { + _REPEAT8(_COPY(d32, s32)) + len -= 32; + } + + d8 = (uint8_t *)d32; + s8 = (const uint8_t *)s32; + while(len) { + _COPY(d8, s8) + len--; + } + + return dst; +} + +/** + * Same as `memset` but optimized for 4 byte operation. + * @param dst pointer to the destination buffer + * @param v value to set [0..255] + * @param len number of byte to set + */ +LV_ATTRIBUTE_FAST_MEM void lv_memset_builtin(void * dst, uint8_t v, size_t len) +{ + uint8_t * d8 = (uint8_t *)dst; + uintptr_t d_align = (lv_uintptr_t) d8 & ALIGN_MASK; + + /*Make the address aligned*/ + if(d_align) { + d_align = ALIGN_MASK + 1 - d_align; + while(d_align && len) { + _SET(d8, v); + len--; + d_align--; + } + } + + uint32_t v32 = (uint32_t)v + ((uint32_t)v << 8) + ((uint32_t)v << 16) + ((uint32_t)v << 24); + uint32_t * d32 = (uint32_t *)d8; + + while(len > 32) { + _REPEAT8(_SET(d32, v32)); + len -= 32; + } + + d8 = (uint8_t *)d32; + while(len) { + _SET(d8, v); + len--; + } +} + +size_t lv_strlen_builtin(const char * str) +{ + size_t i = 0; + while(str[i]) i++; + + return i + 1; +} + +size_t lv_strncpy_builtin(char * dst, size_t dest_size, const char * src) +{ + size_t i; + for(i = 0; i < dest_size - 1 && *src; i++) { + dst[i] = src[i]; + } + dst[i] = '\0'; + return i; +} + +lv_res_t lv_mem_test_builtin(void) +{ + if(lv_tlsf_check(tlsf)) { + LV_LOG_WARN("failed"); + return LV_RES_INV; + } + + if(lv_tlsf_check_pool(lv_tlsf_get_pool(tlsf))) { + LV_LOG_WARN("pool failed"); + return LV_RES_INV; + } + + MEM_TRACE("passed"); + return LV_RES_OK; +} + +/********************** + * STATIC FUNCTIONS + **********************/ + +static void lv_mem_walker(void * ptr, size_t size, int used, void * user) +{ + LV_UNUSED(ptr); + + lv_mem_monitor_t * mon_p = user; + if(used) { + mon_p->used_cnt++; + } + else { + mon_p->free_cnt++; + mon_p->free_size += size; + if(size > mon_p->free_biggest_size) + mon_p->free_biggest_size = size; + } +} +#endif /*LV_USE_BUILTIN_MALLOC*/ diff --git a/src/misc/lv_mem_builtin.h b/src/misc/lv_mem_builtin.h new file mode 100644 index 0000000000..5f6a0c36c2 --- /dev/null +++ b/src/misc/lv_mem_builtin.h @@ -0,0 +1,86 @@ +/** + * @file lv_mem_builtin.h + * + */ + +#ifndef LV_MEM_BUILTIN_H +#define LV_MEM_BUILTIN_H + +#ifdef __cplusplus +extern "C" { +#endif + +/********************* + * INCLUDES + *********************/ +#include "../lv_conf_internal.h" +#include "lv_mem.h" + +/********************* + * DEFINES + *********************/ + +/********************** + * TYPEDEFS + **********************/ + +/********************** + * GLOBAL PROTOTYPES + **********************/ + +/** + * Initialize the dyn_mem module (work memory and other variables) + */ +void lv_mem_init_builtin(void); + +/** + * Clean up the memory buffer which frees all the allocated memories. + */ +void lv_mem_deinit_builtin(void); + +void * lv_malloc_builtin(size_t size); +void * lv_realloc_builtin(void * p, size_t new_size); +void lv_free_builtin(void * p); + +/** + * Same as `memcpy` but optimized for 4 byte operation. + * @param dst pointer to the destination buffer + * @param src pointer to the source buffer + * @param len number of byte to copy + */ +LV_ATTRIBUTE_FAST_MEM void * lv_memcpy_builtin(void * dst, const void * src, size_t len); + +/** + * Same as `memset` but optimized for 4 byte operation. + * @param dst pointer to the destination buffer + * @param v value to set [0..255] + * @param len number of byte to set + */ +LV_ATTRIBUTE_FAST_MEM void lv_memset_builtin(void * dst, uint8_t v, size_t len); + +size_t lv_strlen_builtin(const char * str); + +size_t lv_strncpy_builtin(char * dst, size_t dest_size, const char * src);; + +/** + * + * @return + */ +lv_res_t lv_mem_test_builtin(void); + +/** + * Give information about the work memory of dynamic allocation + * @param mon_p pointer to a lv_mem_monitor_t variable, + * the result of the analysis will be stored here + */ +void lv_mem_monitor_builtin(lv_mem_monitor_t * mon_p); + +/********************** + * MACROS + **********************/ + +#ifdef __cplusplus +} /*extern "C"*/ +#endif + +#endif /*LV_MEM_BUILTIN_H*/ diff --git a/src/misc/lv_misc.mk b/src/misc/lv_misc.mk index 1dfd4eec9a..1675ecb8ca 100644 --- a/src/misc/lv_misc.mk +++ b/src/misc/lv_misc.mk @@ -11,6 +11,7 @@ CSRCS += lv_log.c CSRCS += lv_lru.c CSRCS += lv_math.c CSRCS += lv_mem.c +CSRCS += lv_mem_builtin.c CSRCS += lv_printf.c CSRCS += lv_style.c CSRCS += lv_style_gen.c diff --git a/src/misc/lv_style.c b/src/misc/lv_style.c index 419c29e48f..c9b4812a07 100644 --- a/src/misc/lv_style.c +++ b/src/misc/lv_style.c @@ -155,7 +155,7 @@ void lv_style_init(lv_style_t * style) } #endif - lv_memset_00(style, sizeof(lv_style_t)); + lv_memzero(style, sizeof(lv_style_t)); #if LV_USE_ASSERT_STYLE style->sentinel = LV_STYLE_SENTINEL_VALUE; #endif @@ -170,8 +170,8 @@ void lv_style_reset(lv_style_t * style) return; } - if(style->prop_cnt > 1) lv_mem_free(style->v_p.values_and_props); - lv_memset_00(style, sizeof(lv_style_t)); + if(style->prop_cnt > 1) lv_free(style->v_p.values_and_props); + lv_memzero(style, sizeof(lv_style_t)); #if LV_USE_ASSERT_STYLE style->sentinel = LV_STYLE_SENTINEL_VALUE; #endif @@ -198,7 +198,7 @@ lv_style_prop_t lv_style_register_prop(uint8_t flag) required_size = (required_size + 31) & ~31; LV_ASSERT_MSG(required_size > 0, "required size has become 0?"); uint8_t * old_p = LV_GC_ROOT(_lv_style_custom_prop_flag_lookup_table); - uint8_t * new_p = lv_mem_realloc(old_p, required_size * sizeof(uint8_t)); + uint8_t * new_p = lv_realloc(old_p, required_size * sizeof(uint8_t)); if(new_p == NULL) { LV_LOG_ERROR("Unable to allocate space for custom property lookup table"); return LV_STYLE_PROP_INV; @@ -252,7 +252,7 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_prop_t prop) } else { size_t size = (style->prop_cnt - 1) * (sizeof(lv_style_value_t) + sizeof(uint16_t)); - uint8_t * new_values_and_props = lv_mem_alloc(size); + uint8_t * new_values_and_props = lv_malloc(size); if(new_values_and_props == NULL) return false; style->v_p.values_and_props = new_values_and_props; style->prop_cnt--; @@ -271,7 +271,7 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_prop_t prop) } } - lv_mem_free(old_values); + lv_free(old_values); return true; } } @@ -297,7 +297,7 @@ lv_style_res_t lv_style_get_prop(const lv_style_t * style, lv_style_prop_t prop, void lv_style_transition_dsc_init(lv_style_transition_dsc_t * tr, const lv_style_prop_t props[], lv_anim_path_cb_t path_cb, uint32_t time, uint32_t delay, void * user_data) { - lv_memset_00(tr, sizeof(lv_style_transition_dsc_t)); + lv_memzero(tr, sizeof(lv_style_transition_dsc_t)); tr->props = props; tr->path_xcb = path_cb == NULL ? lv_anim_path_linear : path_cb; tr->time = time; @@ -435,7 +435,7 @@ static void lv_style_set_prop_internal(lv_style_t * style, lv_style_prop_t prop_ } size_t size = (style->prop_cnt + 1) * (sizeof(lv_style_value_t) + sizeof(uint16_t)); - uint8_t * values_and_props = lv_mem_realloc(style->v_p.values_and_props, size); + uint8_t * values_and_props = lv_realloc(style->v_p.values_and_props, size); if(values_and_props == NULL) return; style->v_p.values_and_props = values_and_props; @@ -461,7 +461,7 @@ static void lv_style_set_prop_internal(lv_style_t * style, lv_style_prop_t prop_ return; } size_t size = (style->prop_cnt + 1) * (sizeof(lv_style_value_t) + sizeof(uint16_t)); - uint8_t * values_and_props = lv_mem_alloc(size); + uint8_t * values_and_props = lv_malloc(size); if(values_and_props == NULL) return; lv_style_value_t value_tmp = style->v_p.value1; style->v_p.values_and_props = values_and_props; diff --git a/src/misc/lv_style.h b/src/misc/lv_style.h index 5b959e4aee..a3f9415c39 100644 --- a/src/misc/lv_style.h +++ b/src/misc/lv_style.h @@ -55,11 +55,6 @@ LV_EXPORT_CONST_INT(LV_IMG_ZOOM_NONE); #define LV_STYLE_CONST_INIT(var_name, prop_array) const lv_style_t var_name = { .v_p = { .const_props = prop_array }, .has_group = 0xFF, .prop1 = _LV_STYLE_PROP_CONST } #endif -/** On simple system, don't waste resources on gradients */ -#if !defined(LV_DRAW_COMPLEX) || !defined(LV_GRADIENT_MAX_STOPS) -#define LV_GRADIENT_MAX_STOPS 2 -#endif - #define LV_STYLE_PROP_META_INHERIT 0x8000 #define LV_STYLE_PROP_META_INITIAL 0x4000 #define LV_STYLE_PROP_META_MASK (LV_STYLE_PROP_META_INHERIT | LV_STYLE_PROP_META_INITIAL) @@ -123,7 +118,7 @@ typedef uint8_t lv_grad_dir_t; /** * The dithering algorithm for the gradient - * Depends on LV_DITHER_GRADIENT + * Depends on LV_DRAW_SW_GRADIENT_DITHER */ enum { LV_DITHER_NONE, /**< No dithering, colors are just quantized to the output resolution*/ diff --git a/src/misc/lv_timer.c b/src/misc/lv_timer.c index d8dd55b7a2..9a8626d7f6 100644 --- a/src/misc/lv_timer.c +++ b/src/misc/lv_timer.c @@ -203,7 +203,7 @@ void lv_timer_del(lv_timer_t * timer) _lv_ll_remove(&LV_GC_ROOT(_lv_timer_ll), timer); timer_deleted = true; - lv_mem_free(timer); + lv_free(timer); } /** diff --git a/src/misc/lv_txt.c b/src/misc/lv_txt.c index da7eca0bba..7543d52469 100644 --- a/src/misc/lv_txt.c +++ b/src/misc/lv_txt.c @@ -428,7 +428,7 @@ void _lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt) } /*Copy the text into the new space*/ - lv_memcpy_small(txt_buf + pos, ins_txt, ins_len); + lv_memcpy(txt_buf + pos, ins_txt, ins_len); } void _lv_txt_cut(char * txt, uint32_t pos, uint32_t len) @@ -458,7 +458,7 @@ char * _lv_txt_set_text_vfmt(const char * fmt, va_list ap) char * text = 0; #if LV_USE_ARABIC_PERSIAN_CHARS /*Put together the text according to the format string*/ - char * raw_txt = lv_mem_buf_get(len + 1); + char * raw_txt = lv_malloc(len + 1); LV_ASSERT_MALLOC(raw_txt); if(raw_txt == NULL) { return NULL; @@ -468,16 +468,16 @@ char * _lv_txt_set_text_vfmt(const char * fmt, va_list ap) /*Get the size of the Arabic text and process it*/ size_t len_ap = _lv_txt_ap_calc_bytes_cnt(raw_txt); - text = lv_mem_alloc(len_ap + 1); + text = lv_malloc(len_ap + 1); LV_ASSERT_MALLOC(text); if(text == NULL) { return NULL; } _lv_txt_ap_proc(raw_txt, text); - lv_mem_buf_release(raw_txt); + lv_free(raw_txt); #else - text = lv_mem_alloc(len + 1); + text = lv_malloc(len + 1); LV_ASSERT_MALLOC(text); if(text == NULL) { return NULL; @@ -567,7 +567,7 @@ static uint32_t lv_txt_utf8_conv_wc(uint32_t c) if((c & 0x80) != 0) { uint32_t swapped; uint8_t c8[4]; - lv_memcpy_small(c8, &c, 4); + lv_memcpy(c8, &c, 4); swapped = (c8[0] << 24) + (c8[1] << 16) + (c8[2] << 8) + (c8[3]); uint8_t i; for(i = 0; i < 4; i++) { diff --git a/src/misc/lv_txt_ap.c b/src/misc/lv_txt_ap.c index 54faf8b4fb..fab498ac3d 100644 --- a/src/misc/lv_txt_ap.c +++ b/src/misc/lv_txt_ap.c @@ -150,8 +150,8 @@ void _lv_txt_ap_proc(const char * txt, char * txt_out) txt_length = _lv_txt_get_encoded_length(txt); - ch_enc = (uint32_t *)lv_mem_alloc(sizeof(uint32_t) * (txt_length + 1)); - ch_fin = (uint32_t *)lv_mem_alloc(sizeof(uint32_t) * (txt_length + 1)); + ch_enc = (uint32_t *)lv_malloc(sizeof(uint32_t) * (txt_length + 1)); + ch_fin = (uint32_t *)lv_malloc(sizeof(uint32_t) * (txt_length + 1)); i = 0; j = 0; @@ -219,7 +219,7 @@ void _lv_txt_ap_proc(const char * txt, char * txt_out) ch_enc[i] = 0; for(i = 0; i < j; i++) ch_enc[i] = ch_fin[i]; - lv_mem_free(ch_fin); + lv_free(ch_fin); txt_out_temp = txt_out; i = 0; @@ -247,7 +247,7 @@ void _lv_txt_ap_proc(const char * txt, char * txt_out) i++; } *(txt_out_temp) = '\0'; - lv_mem_free(ch_enc); + lv_free(ch_enc); } /********************** * STATIC FUNCTIONS diff --git a/src/widgets/lv_bar.c b/src/widgets/lv_bar.c index e7033ef057..f70760c81d 100644 --- a/src/widgets/lv_bar.c +++ b/src/widgets/lv_bar.c @@ -455,7 +455,7 @@ static void draw_indic(lv_event_t * e) draw_rect_dsc.border_opa = border_opa; } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS lv_draw_mask_radius_param_t mask_bg_param; lv_area_t bg_mask_area; bg_mask_area.x1 = obj->coords.x1 + bg_left; @@ -489,7 +489,7 @@ static void draw_indic(lv_event_t * e) mask_indic_max_area.x2 = mask_indic_max_area.x1 + LV_BAR_SIZE_MIN; } -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS /*Create a mask to the current indicator area to see only this part from the whole gradient.*/ lv_draw_mask_radius_param_t mask_indic_param; lv_draw_mask_radius_init(&mask_indic_param, &bar->indic_area, draw_rect_dsc.radius, false); @@ -506,7 +506,7 @@ static void draw_indic(lv_event_t * e) draw_rect_dsc.shadow_opa = LV_OPA_TRANSP; lv_draw_rect(draw_ctx, &draw_rect_dsc, &bar->indic_area); -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS lv_draw_mask_free_param(&mask_indic_param); lv_draw_mask_free_param(&mask_bg_param); lv_draw_mask_remove_id(mask_indic_id); diff --git a/src/widgets/lv_btnmatrix.c b/src/widgets/lv_btnmatrix.c index 193290d3df..6a1d4fe1b6 100644 --- a/src/widgets/lv_btnmatrix.c +++ b/src/widgets/lv_btnmatrix.c @@ -376,8 +376,8 @@ static void lv_btnmatrix_destructor(const lv_obj_class_t * class_p, lv_obj_t * o LV_TRACE_OBJ_CREATE("begin"); LV_UNUSED(class_p); lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj; - lv_mem_free(btnm->button_areas); - lv_mem_free(btnm->ctrl_bits); + lv_free(btnm->button_areas); + lv_free(btnm->ctrl_bits); btnm->button_areas = NULL; btnm->ctrl_bits = NULL; LV_TRACE_OBJ_CREATE("finished"); @@ -684,7 +684,7 @@ static void draw_main(lv_event_t * e) #if LV_USE_ARABIC_PERSIAN_CHARS const size_t txt_ap_size = 256 ; - char * txt_ap = lv_mem_buf_get(txt_ap_size); + char * txt_ap = lv_malloc(txt_ap_size); #endif lv_obj_draw_part_dsc_t part_draw_dsc; @@ -805,7 +805,7 @@ static void draw_main(lv_event_t * e) obj->skip_trans = 0; #if LV_USE_ARABIC_PERSIAN_CHARS - lv_mem_buf_release(txt_ap); + lv_free(txt_ap); #endif } /** @@ -834,21 +834,21 @@ static void allocate_btn_areas_and_controls(const lv_obj_t * obj, const char ** if(btn_cnt == btnm->btn_cnt) return; if(btnm->button_areas != NULL) { - lv_mem_free(btnm->button_areas); + lv_free(btnm->button_areas); btnm->button_areas = NULL; } if(btnm->ctrl_bits != NULL) { - lv_mem_free(btnm->ctrl_bits); + lv_free(btnm->ctrl_bits); btnm->ctrl_bits = NULL; } - btnm->button_areas = lv_mem_alloc(sizeof(lv_area_t) * btn_cnt); + btnm->button_areas = lv_malloc(sizeof(lv_area_t) * btn_cnt); LV_ASSERT_MALLOC(btnm->button_areas); - btnm->ctrl_bits = lv_mem_alloc(sizeof(lv_btnmatrix_ctrl_t) * btn_cnt); + btnm->ctrl_bits = lv_malloc(sizeof(lv_btnmatrix_ctrl_t) * btn_cnt); LV_ASSERT_MALLOC(btnm->ctrl_bits); if(btnm->button_areas == NULL || btnm->ctrl_bits == NULL) btn_cnt = 0; - lv_memset_00(btnm->ctrl_bits, sizeof(lv_btnmatrix_ctrl_t) * btn_cnt); + lv_memzero(btnm->ctrl_bits, sizeof(lv_btnmatrix_ctrl_t) * btn_cnt); btnm->btn_cnt = btn_cnt; } diff --git a/src/widgets/lv_canvas.c b/src/widgets/lv_canvas.c index 6b37069abe..afa905f0ec 100644 --- a/src/widgets/lv_canvas.c +++ b/src/widgets/lv_canvas.c @@ -7,13 +7,12 @@ * INCLUDES *********************/ #include "lv_canvas.h" +#if LV_USE_CANVAS != 0 #include "../misc/lv_assert.h" #include "../misc/lv_math.h" #include "../draw/lv_draw.h" #include "../core/lv_refr.h" - -#if LV_USE_CANVAS != 0 - +#include "../core/lv_disp.h" #include "../draw/sw/lv_draw_sw.h" /********************* @@ -162,7 +161,7 @@ void lv_canvas_transform(lv_obj_t * obj, lv_img_dsc_t * src_img, int16_t angle, lv_coord_t offset_y, int32_t pivot_x, int32_t pivot_y, bool antialias) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS LV_ASSERT_OBJ(obj, MY_CLASS); LV_ASSERT_NULL(src_img); @@ -186,8 +185,8 @@ void lv_canvas_transform(lv_obj_t * obj, lv_img_dsc_t * src_img, int16_t angle, dest_area.y1 = 0; dest_area.y2 = 0; - lv_color_t * cbuf = lv_mem_alloc(dest_img->header.w * sizeof(lv_color_t)); - lv_opa_t * abuf = lv_mem_alloc(dest_img->header.w * sizeof(lv_opa_t)); + lv_color_t * cbuf = lv_malloc(dest_img->header.w * sizeof(lv_color_t)); + lv_opa_t * abuf = lv_malloc(dest_img->header.w * sizeof(lv_opa_t)); for(y = 0; y < dest_img->header.h; y++) { if(y + offset_y >= 0) { lv_draw_sw_transform(NULL, &dest_area, src_img->data, src_img->header.w, src_img->header.h, src_img->header.w, @@ -207,8 +206,8 @@ void lv_canvas_transform(lv_obj_t * obj, lv_img_dsc_t * src_img, int16_t angle, dest_area.y2++; } } - lv_mem_free(cbuf); - lv_mem_free(abuf); + lv_free(cbuf); + lv_free(abuf); lv_obj_invalidate(obj); @@ -222,7 +221,7 @@ void lv_canvas_transform(lv_obj_t * obj, lv_img_dsc_t * src_img, int16_t angle, LV_UNUSED(pivot_x); LV_UNUSED(pivot_y); LV_UNUSED(antialias); - LV_LOG_WARN("Can't transform canvas with LV_DRAW_COMPLEX == 0"); + LV_LOG_WARN("Can't transform canvas with LV_USE_DRAW_MASKS == 0"); #endif } @@ -259,7 +258,7 @@ void lv_canvas_blur_hor(lv_obj_t * obj, const lv_area_t * area, uint16_t r) bool has_alpha = lv_img_cf_has_alpha(canvas->dsc.header.cf); lv_coord_t line_w = lv_img_buf_get_img_size(canvas->dsc.header.w, 1, canvas->dsc.header.cf); - uint8_t * line_buf = lv_mem_buf_get(line_w); + uint8_t * line_buf = lv_malloc(line_w); lv_img_dsc_t line_img; line_img.data = line_buf; @@ -351,7 +350,7 @@ void lv_canvas_blur_hor(lv_obj_t * obj, const lv_area_t * area, uint16_t r) } lv_obj_invalidate(obj); - lv_mem_buf_release(line_buf); + lv_free(line_buf); } void lv_canvas_blur_ver(lv_obj_t * obj, const lv_area_t * area, uint16_t r) @@ -386,7 +385,7 @@ void lv_canvas_blur_ver(lv_obj_t * obj, const lv_area_t * area, uint16_t r) bool has_alpha = lv_img_cf_has_alpha(canvas->dsc.header.cf); lv_coord_t col_w = lv_img_buf_get_img_size(1, canvas->dsc.header.h, canvas->dsc.header.cf); - uint8_t * col_buf = lv_mem_buf_get(col_w); + uint8_t * col_buf = lv_malloc(col_w); lv_img_dsc_t line_img; line_img.data = col_buf; @@ -484,7 +483,7 @@ void lv_canvas_blur_ver(lv_obj_t * obj, const lv_area_t * area, uint16_t r) lv_obj_invalidate(obj); - lv_mem_buf_release(col_buf); + lv_free(col_buf); } void lv_canvas_fill_bg(lv_obj_t * canvas, lv_color_t color, lv_opa_t opa) @@ -539,7 +538,7 @@ void lv_canvas_draw_rect(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord _lv_refr_set_disp_refreshing(&fake_disp); /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/ - lv_color_t ctransp = LV_COLOR_CHROMA_KEY; + lv_color_t ctransp = lv_disp_get_chroma_key_color(refr_ori); if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED && draw_dsc->bg_color.full == ctransp.full) { fake_disp.driver->antialiasing = 0; @@ -663,7 +662,7 @@ void lv_canvas_draw_line(lv_obj_t * canvas, const lv_point_t points[], uint32_t /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/ - lv_color_t ctransp = LV_COLOR_CHROMA_KEY; + lv_color_t ctransp = lv_disp_get_chroma_key_color(refr_ori); if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED && draw_dsc->color.full == ctransp.full) { fake_disp.driver->antialiasing = 0; @@ -704,7 +703,7 @@ void lv_canvas_draw_polygon(lv_obj_t * canvas, const lv_point_t points[], uint32 _lv_refr_set_disp_refreshing(&fake_disp); /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/ - lv_color_t ctransp = LV_COLOR_CHROMA_KEY; + lv_color_t ctransp = lv_disp_get_chroma_key_color(refr_ori); if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED && draw_dsc->bg_color.full == ctransp.full) { fake_disp.driver->antialiasing = 0; @@ -722,7 +721,7 @@ void lv_canvas_draw_polygon(lv_obj_t * canvas, const lv_point_t points[], uint32 void lv_canvas_draw_arc(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord_t r, int32_t start_angle, int32_t end_angle, const lv_draw_arc_dsc_t * draw_dsc) { -#if LV_DRAW_COMPLEX +#if LV_USE_DRAW_MASKS LV_ASSERT_OBJ(canvas, MY_CLASS); lv_img_dsc_t * dsc = lv_canvas_get_img(canvas); @@ -758,7 +757,7 @@ void lv_canvas_draw_arc(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord_ LV_UNUSED(start_angle); LV_UNUSED(end_angle); LV_UNUSED(draw_dsc); - LV_LOG_WARN("Can't draw arc with LV_DRAW_COMPLEX == 0"); + LV_LOG_WARN("Can't draw arc with LV_USE_DRAW_MASKS == 0"); #endif } @@ -805,14 +804,14 @@ static void init_fake_disp(lv_obj_t * canvas, lv_disp_t * disp, lv_disp_drv_t * clip_area->y2 = dsc->header.h - 1; /*Allocate the fake driver on the stack as the entire display doesn't outlive this function*/ - lv_memset_00(disp, sizeof(lv_disp_t)); + lv_memzero(disp, sizeof(lv_disp_t)); disp->driver = drv; lv_disp_drv_init(disp->driver); disp->driver->hor_res = dsc->header.w; disp->driver->ver_res = dsc->header.h; - lv_draw_ctx_t * draw_ctx = lv_mem_alloc(sizeof(lv_draw_sw_ctx_t)); + lv_draw_ctx_t * draw_ctx = lv_malloc(sizeof(lv_draw_sw_ctx_t)); LV_ASSERT_MALLOC(draw_ctx); if(draw_ctx == NULL) return; lv_draw_sw_init_ctx(drv, draw_ctx); @@ -822,16 +821,15 @@ static void init_fake_disp(lv_obj_t * canvas, lv_disp_t * disp, lv_disp_drv_t * draw_ctx->buf = (void *)dsc->data; lv_disp_drv_use_generic_set_px_cb(disp->driver, dsc->header.cf); - if(LV_COLOR_SCREEN_TRANSP && dsc->header.cf != LV_IMG_CF_TRUE_COLOR_ALPHA) { - drv->screen_transp = 0; - } + if(dsc->header.cf != LV_IMG_CF_TRUE_COLOR_ALPHA) drv->screen_transp = 0; + else drv->screen_transp = 1; } static void deinit_fake_disp(lv_obj_t * canvas, lv_disp_t * disp) { LV_UNUSED(canvas); lv_draw_sw_deinit_ctx(disp->driver, disp->driver->draw_ctx); - lv_mem_free(disp->driver->draw_ctx); + lv_free(disp->driver->draw_ctx); } diff --git a/src/widgets/lv_canvas.h b/src/widgets/lv_canvas.h index 71f051614b..5ec3be35c9 100644 --- a/src/widgets/lv_canvas.h +++ b/src/widgets/lv_canvas.h @@ -55,7 +55,7 @@ lv_obj_t * lv_canvas_create(lv_obj_t * parent); * Set a buffer for the canvas. * @param buf a buffer where the content of the canvas will be. * The required size is (lv_img_color_format_get_px_size(cf) * w) / 8 * h) - * It can be allocated with `lv_mem_alloc()` or + * It can be allocated with `lv_malloc()` or * it can be statically allocated array (e.g. static lv_color_t buf[100*50]) or * it can be an address in RAM or external SRAM * @param canvas pointer to a canvas object diff --git a/src/widgets/lv_checkbox.c b/src/widgets/lv_checkbox.c index dd3b3d1574..d334b5a6b8 100644 --- a/src/widgets/lv_checkbox.c +++ b/src/widgets/lv_checkbox.c @@ -74,8 +74,8 @@ void lv_checkbox_set_text(lv_obj_t * obj, const char * txt) size_t len = strlen(txt); #endif - if(!cb->static_txt) cb->txt = lv_mem_realloc(cb->txt, len + 1); - else cb->txt = lv_mem_alloc(len + 1); + if(!cb->static_txt) cb->txt = lv_realloc(cb->txt, len + 1); + else cb->txt = lv_malloc(len + 1); #if LV_USE_ARABIC_PERSIAN_CHARS _lv_txt_ap_proc(txt, cb->txt); #else @@ -92,7 +92,7 @@ void lv_checkbox_set_text_static(lv_obj_t * obj, const char * txt) { lv_checkbox_t * cb = (lv_checkbox_t *)obj; - if(!cb->static_txt) lv_mem_free(cb->txt); + if(!cb->static_txt) lv_free(cb->txt); cb->txt = (char *)txt; cb->static_txt = 1; @@ -138,7 +138,7 @@ static void lv_checkbox_destructor(const lv_obj_class_t * class_p, lv_obj_t * ob lv_checkbox_t * cb = (lv_checkbox_t *)obj; if(!cb->static_txt) { - lv_mem_free(cb->txt); + lv_free(cb->txt); cb->txt = NULL; } LV_TRACE_OBJ_CREATE("finished"); diff --git a/src/widgets/lv_dropdown.c b/src/widgets/lv_dropdown.c index 241d177768..47704cbdd7 100644 --- a/src/widgets/lv_dropdown.c +++ b/src/widgets/lv_dropdown.c @@ -136,11 +136,11 @@ void lv_dropdown_set_options(lv_obj_t * obj, const char * options) #endif if(dropdown->options != NULL && dropdown->static_txt == 0) { - lv_mem_free(dropdown->options); + lv_free(dropdown->options); dropdown->options = NULL; } - dropdown->options = lv_mem_alloc(len); + dropdown->options = lv_malloc(len); LV_ASSERT_MALLOC(dropdown->options); if(dropdown->options == NULL) return; @@ -176,7 +176,7 @@ void lv_dropdown_set_options_static(lv_obj_t * obj, const char * options) dropdown->sel_opt_id_orig = 0; if(dropdown->static_txt == 0 && dropdown->options != NULL) { - lv_mem_free(dropdown->options); + lv_free(dropdown->options); dropdown->options = NULL; } @@ -199,7 +199,7 @@ void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos) char * static_options = dropdown->options; size_t len = strlen(static_options) + 1; - dropdown->options = lv_mem_alloc(len); + dropdown->options = lv_malloc(len); LV_ASSERT_MALLOC(dropdown->options); if(dropdown->options == NULL) return; @@ -216,7 +216,7 @@ void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos) #endif size_t new_len = ins_len + old_len + 2; /*+2 for terminating NULL and possible \n*/ - dropdown->options = lv_mem_realloc(dropdown->options, new_len + 1); + dropdown->options = lv_realloc(dropdown->options, new_len + 1); LV_ASSERT_MALLOC(dropdown->options); if(dropdown->options == NULL) return; @@ -239,7 +239,7 @@ void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos) _lv_txt_ins(dropdown->options, _lv_txt_encoded_get_char_id(dropdown->options, insert_pos++), "\n"); /*Insert the new option, adding \n if necessary*/ - char * ins_buf = lv_mem_buf_get(ins_len + 2); /*+ 2 for terminating NULL and possible \n*/ + char * ins_buf = lv_malloc(ins_len + 2); /*+ 2 for terminating NULL and possible \n*/ LV_ASSERT_MALLOC(ins_buf); if(ins_buf == NULL) return; #if LV_USE_ARABIC_PERSIAN_CHARS == 0 @@ -250,7 +250,7 @@ void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos) if(pos < dropdown->option_cnt) strcat(ins_buf, "\n"); _lv_txt_ins(dropdown->options, _lv_txt_encoded_get_char_id(dropdown->options, insert_pos), ins_buf); - lv_mem_buf_release(ins_buf); + lv_free(ins_buf); dropdown->option_cnt++; @@ -265,7 +265,7 @@ void lv_dropdown_clear_options(lv_obj_t * obj) if(dropdown->options == NULL) return; if(dropdown->static_txt == 0) - lv_mem_free(dropdown->options); + lv_free(dropdown->options); dropdown->options = NULL; dropdown->static_txt = 0; @@ -615,7 +615,7 @@ static void lv_dropdown_destructor(const lv_obj_class_t * class_p, lv_obj_t * ob } if(!dropdown->static_txt) { - lv_mem_free(dropdown->options); + lv_free(dropdown->options); dropdown->options = NULL; } } @@ -789,7 +789,7 @@ static void draw_main(lv_event_t * e) const char * opt_txt; if(dropdown->text) opt_txt = dropdown->text; else { - char * buf = lv_mem_buf_get(128); + char * buf = lv_malloc(128); lv_dropdown_get_selected_str(obj, buf, 128); opt_txt = buf; } @@ -880,7 +880,7 @@ static void draw_main(lv_event_t * e) lv_draw_label(draw_ctx, &label_dsc, &txt_area, opt_txt, NULL); if(dropdown->text == NULL) { - lv_mem_buf_release((char *)opt_txt); + lv_free((char *)opt_txt); } } diff --git a/src/widgets/lv_img.c b/src/widgets/lv_img.c index f47a789e77..598ac6ed39 100644 --- a/src/widgets/lv_img.c +++ b/src/widgets/lv_img.c @@ -96,7 +96,7 @@ void lv_img_set_src(lv_obj_t * obj, const void * src) if(src_type == LV_IMG_SRC_UNKNOWN) { LV_LOG_WARN("lv_img_set_src: unknown image type"); if(img->src_type == LV_IMG_SRC_SYMBOL || img->src_type == LV_IMG_SRC_FILE) { - lv_mem_free((void *)img->src); + lv_free((void *)img->src); } img->src = NULL; img->src_type = LV_IMG_SRC_UNKNOWN; @@ -110,7 +110,7 @@ void lv_img_set_src(lv_obj_t * obj, const void * src) if(src_type == LV_IMG_SRC_VARIABLE) { /*If memory was allocated because of the previous `src_type` then free it*/ if(img->src_type == LV_IMG_SRC_FILE || img->src_type == LV_IMG_SRC_SYMBOL) { - lv_mem_free((void *)img->src); + lv_free((void *)img->src); } img->src = src; } @@ -124,13 +124,13 @@ void lv_img_set_src(lv_obj_t * obj, const void * src) if(img->src_type == LV_IMG_SRC_FILE || img->src_type == LV_IMG_SRC_SYMBOL) { old_src = img->src; } - char * new_str = lv_mem_alloc(strlen(src) + 1); + char * new_str = lv_malloc(strlen(src) + 1); LV_ASSERT_MALLOC(new_str); if(new_str == NULL) return; strcpy(new_str, src); img->src = new_str; - if(old_src) lv_mem_free((void *)old_src); + if(old_src) lv_free((void *)old_src); } } @@ -417,7 +417,7 @@ static void lv_img_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) LV_UNUSED(class_p); lv_img_t * img = (lv_img_t *)obj; if(img->src_type == LV_IMG_SRC_FILE || img->src_type == LV_IMG_SRC_SYMBOL) { - lv_mem_free((void *)img->src); + lv_free((void *)img->src); img->src = NULL; img->src_type = LV_IMG_SRC_UNKNOWN; } diff --git a/src/widgets/lv_label.c b/src/widgets/lv_label.c index f4fbe01a5a..ce2e77c484 100644 --- a/src/widgets/lv_label.c +++ b/src/widgets/lv_label.c @@ -98,13 +98,13 @@ void lv_label_set_text(lv_obj_t * obj, const char * text) /*Get the size of the text and process it*/ size_t len = _lv_txt_ap_calc_bytes_cnt(text); - label->text = lv_mem_realloc(label->text, len); + label->text = lv_realloc(label->text, len); LV_ASSERT_MALLOC(label->text); if(label->text == NULL) return; _lv_txt_ap_proc(label->text, label->text); #else - label->text = lv_mem_realloc(label->text, strlen(label->text) + 1); + label->text = lv_realloc(label->text, strlen(label->text) + 1); #endif LV_ASSERT_MALLOC(label->text); @@ -113,7 +113,7 @@ void lv_label_set_text(lv_obj_t * obj, const char * text) else { /*Free the old text*/ if(label->text != NULL && label->static_txt == 0) { - lv_mem_free(label->text); + lv_free(label->text); label->text = NULL; } @@ -121,7 +121,7 @@ void lv_label_set_text(lv_obj_t * obj, const char * text) /*Get the size of the text and process it*/ size_t len = _lv_txt_ap_calc_bytes_cnt(text); - label->text = lv_mem_alloc(len); + label->text = lv_malloc(len); LV_ASSERT_MALLOC(label->text); if(label->text == NULL) return; @@ -131,7 +131,7 @@ void lv_label_set_text(lv_obj_t * obj, const char * text) size_t len = strlen(text) + 1; /*Allocate space for the new text*/ - label->text = lv_mem_alloc(len); + label->text = lv_malloc(len); LV_ASSERT_MALLOC(label->text); if(label->text == NULL) return; strcpy(label->text, text); @@ -159,7 +159,7 @@ void lv_label_set_text_fmt(lv_obj_t * obj, const char * fmt, ...) } if(label->text != NULL && label->static_txt == 0) { - lv_mem_free(label->text); + lv_free(label->text); label->text = NULL; } @@ -178,7 +178,7 @@ void lv_label_set_text_static(lv_obj_t * obj, const char * text) lv_label_t * label = (lv_label_t *)obj; if(label->static_txt == 0 && label->text != NULL) { - lv_mem_free(label->text); + lv_free(label->text); label->text = NULL; } @@ -393,7 +393,7 @@ void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t pos->y = y; #if LV_USE_BIDI - if(mutable_bidi_txt) lv_mem_buf_release(mutable_bidi_txt); + if(mutable_bidi_txt) lv_free(mutable_bidi_txt); #endif } @@ -447,7 +447,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in) } #if LV_USE_BIDI - bidi_txt = lv_mem_buf_get(new_line_start - line_start + 1); + bidi_txt = lv_malloc(new_line_start - line_start + 1); uint32_t txt_len = new_line_start - line_start; if(new_line_start > 0 && txt[new_line_start - 1] == '\0' && txt_len > 0) txt_len--; _lv_bidi_process_paragraph(txt + line_start, bidi_txt, txt_len, lv_obj_get_style_base_dir(obj, LV_PART_MAIN), NULL, 0); @@ -513,7 +513,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in) txt_len, lv_obj_get_style_base_dir(obj, LV_PART_MAIN), cid, &is_rtl); if(is_rtl) logical_pos++; } - lv_mem_buf_release(bidi_txt); + lv_free(bidi_txt); #else logical_pos = _lv_txt_encoded_get_char_id(bidi_txt, i); #endif @@ -651,7 +651,7 @@ void lv_label_ins_text(lv_obj_t * obj, uint32_t pos, const char * txt) size_t old_len = strlen(label->text); size_t ins_len = strlen(txt); size_t new_len = ins_len + old_len; - label->text = lv_mem_realloc(label->text, new_len + 1); + label->text = lv_realloc(label->text, new_len + 1); LV_ASSERT_MALLOC(label->text); if(label->text == NULL) return; @@ -727,7 +727,7 @@ static void lv_label_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) lv_label_t * label = (lv_label_t *)obj; lv_label_dot_tmp_free(obj); - if(!label->static_txt) lv_mem_free(label->text); + if(!label->static_txt) lv_free(label->text); label->text = NULL; } @@ -1207,7 +1207,7 @@ static bool lv_label_set_dot_tmp(lv_obj_t * obj, char * data, uint32_t len) if(len > sizeof(char *)) { /*Memory needs to be allocated. Allocates an additional byte *for a NULL-terminator so it can be copied.*/ - label->dot.tmp_ptr = lv_mem_alloc(len + 1); + label->dot.tmp_ptr = lv_malloc(len + 1); if(label->dot.tmp_ptr == NULL) { LV_LOG_ERROR("Failed to allocate memory for dot_tmp_ptr"); return false; @@ -1249,7 +1249,7 @@ static void lv_label_dot_tmp_free(lv_obj_t * obj) { lv_label_t * label = (lv_label_t *)obj; if(label->dot_tmp_alloc && label->dot.tmp_ptr) { - lv_mem_free(label->dot.tmp_ptr); + lv_free(label->dot.tmp_ptr); } label->dot_tmp_alloc = false; label->dot.tmp_ptr = NULL; diff --git a/src/widgets/lv_roller.c b/src/widgets/lv_roller.c index fd9b3948f5..88218b9346 100644 --- a/src/widgets/lv_roller.c +++ b/src/widgets/lv_roller.c @@ -120,7 +120,7 @@ void lv_roller_set_options(lv_obj_t * obj, const char * options, lv_roller_mode_ roller->mode = LV_ROLLER_MODE_INFINITE; size_t opt_len = strlen(options) + 1; /*+1 to add '\n' after option lists*/ - char * opt_extra = lv_mem_buf_get(opt_len * LV_ROLLER_INF_PAGES); + char * opt_extra = lv_malloc(opt_len * LV_ROLLER_INF_PAGES); uint8_t i; for(i = 0; i < LV_ROLLER_INF_PAGES; i++) { strcpy(&opt_extra[opt_len * i], options); @@ -128,7 +128,7 @@ void lv_roller_set_options(lv_obj_t * obj, const char * options, lv_roller_mode_ } opt_extra[opt_len * LV_ROLLER_INF_PAGES - 1] = '\0'; lv_label_set_text(label, opt_extra); - lv_mem_buf_release(opt_extra); + lv_free(opt_extra); roller->sel_opt_id = ((LV_ROLLER_INF_PAGES / 2) + 0) * roller->option_cnt; diff --git a/src/widgets/lv_table.c b/src/widgets/lv_table.c index 1793fbd73f..27155235ce 100644 --- a/src/widgets/lv_table.c +++ b/src/widgets/lv_table.c @@ -101,7 +101,7 @@ void lv_table_set_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col, const c size_t to_allocate = get_cell_txt_len(txt); - table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], to_allocate); + table->cell_data[cell] = lv_realloc(table->cell_data[cell], to_allocate); LV_ASSERT_MALLOC(table->cell_data[cell]); if(table->cell_data[cell] == NULL) return; @@ -142,7 +142,7 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con #if LV_USE_ARABIC_PERSIAN_CHARS /*Put together the text according to the format string*/ - char * raw_txt = lv_mem_buf_get(len + 1); + char * raw_txt = lv_malloc(len + 1); LV_ASSERT_MALLOC(raw_txt); if(raw_txt == NULL) { va_end(ap2); @@ -153,7 +153,7 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con /*Get the size of the Arabic text and process it*/ size_t len_ap = _lv_txt_ap_calc_bytes_cnt(raw_txt); - table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], len_ap + 1); + table->cell_data[cell] = lv_realloc(table->cell_data[cell], len_ap + 1); LV_ASSERT_MALLOC(table->cell_data[cell]); if(table->cell_data[cell] == NULL) { va_end(ap2); @@ -161,9 +161,9 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con } _lv_txt_ap_proc(raw_txt, &table->cell_data[cell][1]); - lv_mem_buf_release(raw_txt); + lv_free(raw_txt); #else - table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], len + 2); /*+1: trailing '\0; +1: format byte*/ + table->cell_data[cell] = lv_realloc(table->cell_data[cell], len + 2); /*+1: trailing '\0; +1: format byte*/ LV_ASSERT_MALLOC(table->cell_data[cell]); if(table->cell_data[cell] == NULL) { va_end(ap2); @@ -193,7 +193,7 @@ void lv_table_set_row_cnt(lv_obj_t * obj, uint16_t row_cnt) uint16_t old_row_cnt = table->row_cnt; table->row_cnt = row_cnt; - table->row_h = lv_mem_realloc(table->row_h, table->row_cnt * sizeof(table->row_h[0])); + table->row_h = lv_realloc(table->row_h, table->row_cnt * sizeof(table->row_h[0])); LV_ASSERT_MALLOC(table->row_h); if(table->row_h == NULL) return; @@ -203,11 +203,11 @@ void lv_table_set_row_cnt(lv_obj_t * obj, uint16_t row_cnt) uint32_t new_cell_cnt = table->col_cnt * table->row_cnt; uint32_t i; for(i = new_cell_cnt; i < old_cell_cnt; i++) { - lv_mem_free(table->cell_data[i]); + lv_free(table->cell_data[i]); } } - table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *)); + table->cell_data = lv_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *)); LV_ASSERT_MALLOC(table->cell_data); if(table->cell_data == NULL) return; @@ -215,7 +215,7 @@ void lv_table_set_row_cnt(lv_obj_t * obj, uint16_t row_cnt) if(old_row_cnt < row_cnt) { uint32_t old_cell_cnt = old_row_cnt * table->col_cnt; uint32_t new_cell_cnt = table->col_cnt * table->row_cnt; - lv_memset_00(&table->cell_data[old_cell_cnt], (new_cell_cnt - old_cell_cnt) * sizeof(table->cell_data[0])); + lv_memzero(&table->cell_data[old_cell_cnt], (new_cell_cnt - old_cell_cnt) * sizeof(table->cell_data[0])); } refr_size_form_row(obj, 0); @@ -232,12 +232,12 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt) uint16_t old_col_cnt = table->col_cnt; table->col_cnt = col_cnt; - char ** new_cell_data = lv_mem_alloc(table->row_cnt * table->col_cnt * sizeof(char *)); + char ** new_cell_data = lv_malloc(table->row_cnt * table->col_cnt * sizeof(char *)); LV_ASSERT_MALLOC(new_cell_data); if(new_cell_data == NULL) return; uint32_t new_cell_cnt = table->col_cnt * table->row_cnt; - lv_memset_00(new_cell_data, new_cell_cnt * sizeof(table->cell_data[0])); + lv_memzero(new_cell_data, new_cell_cnt * sizeof(table->cell_data[0])); /*The new column(s) messes up the mapping of `cell_data`*/ uint32_t old_col_start; @@ -248,23 +248,23 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt) old_col_start = row * old_col_cnt; new_col_start = row * col_cnt; - lv_memcpy_small(&new_cell_data[new_col_start], &table->cell_data[old_col_start], - sizeof(new_cell_data[0]) * min_col_cnt); + lv_memcpy(&new_cell_data[new_col_start], &table->cell_data[old_col_start], + sizeof(new_cell_data[0]) * min_col_cnt); /*Free the old cells (only if the table becomes smaller)*/ int32_t i; for(i = 0; i < (int32_t)old_col_cnt - col_cnt; i++) { uint32_t idx = old_col_start + min_col_cnt + i; - lv_mem_free(table->cell_data[idx]); + lv_free(table->cell_data[idx]); table->cell_data[idx] = NULL; } } - lv_mem_free(table->cell_data); + lv_free(table->cell_data); table->cell_data = new_cell_data; /*Initialize the new column widths if any*/ - table->col_w = lv_mem_realloc(table->col_w, col_cnt * sizeof(table->col_w[0])); + table->col_w = lv_realloc(table->col_w, col_cnt * sizeof(table->col_w[0])); LV_ASSERT_MALLOC(table->col_w); if(table->col_w == NULL) return; @@ -303,7 +303,7 @@ void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table uint32_t cell = row * table->col_cnt + col; if(is_cell_empty(table->cell_data[cell])) { - table->cell_data[cell] = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/ + table->cell_data[cell] = lv_malloc(2); /*+1: trailing '\0; +1: format byte*/ LV_ASSERT_MALLOC(table->cell_data[cell]); if(table->cell_data[cell] == NULL) return; @@ -327,7 +327,7 @@ void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_tab uint32_t cell = row * table->col_cnt + col; if(is_cell_empty(table->cell_data[cell])) { - table->cell_data[cell] = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/ + table->cell_data[cell] = lv_malloc(2); /*+1: trailing '\0; +1: format byte*/ LV_ASSERT_MALLOC(table->cell_data[cell]); if(table->cell_data[cell] == NULL) return; @@ -423,11 +423,11 @@ static void lv_table_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj) table->col_cnt = 1; table->row_cnt = 1; - table->col_w = lv_mem_alloc(table->col_cnt * sizeof(table->col_w[0])); - table->row_h = lv_mem_alloc(table->row_cnt * sizeof(table->row_h[0])); + table->col_w = lv_malloc(table->col_cnt * sizeof(table->col_w[0])); + table->row_h = lv_malloc(table->row_cnt * sizeof(table->row_h[0])); table->col_w[0] = LV_DPI_DEF; table->row_h[0] = LV_DPI_DEF; - table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *)); + table->cell_data = lv_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *)); table->cell_data[0] = NULL; LV_TRACE_OBJ_CREATE("finished"); @@ -441,14 +441,14 @@ static void lv_table_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj) uint16_t i; for(i = 0; i < table->col_cnt * table->row_cnt; i++) { if(table->cell_data[i]) { - lv_mem_free(table->cell_data[i]); + lv_free(table->cell_data[i]); table->cell_data[i] = NULL; } } - if(table->cell_data) lv_mem_free(table->cell_data); - if(table->row_h) lv_mem_free(table->row_h); - if(table->col_w) lv_mem_free(table->col_w); + if(table->cell_data) lv_free(table->cell_data); + if(table->row_h) lv_free(table->row_h); + if(table->col_w) lv_free(table->col_w); } static void lv_table_event(const lv_obj_class_t * class_p, lv_event_t * e) diff --git a/src/widgets/lv_textarea.c b/src/widgets/lv_textarea.c index 4d497e6697..a992da45af 100644 --- a/src/widgets/lv_textarea.c +++ b/src/widgets/lv_textarea.c @@ -142,7 +142,7 @@ void lv_textarea_add_char(lv_obj_t * obj, uint32_t c) if(ta->pwd_mode) { /*+2: the new char + \0*/ size_t realloc_size = strlen(ta->pwd_tmp) + strlen(letter_buf) + 1; - ta->pwd_tmp = lv_mem_realloc(ta->pwd_tmp, realloc_size); + ta->pwd_tmp = lv_realloc(ta->pwd_tmp, realloc_size); LV_ASSERT_MALLOC(ta->pwd_tmp); if(ta->pwd_tmp == NULL) return; @@ -192,7 +192,7 @@ void lv_textarea_add_text(lv_obj_t * obj, const char * txt) if(ta->pwd_mode) { size_t realloc_size = strlen(ta->pwd_tmp) + strlen(txt) + 1; - ta->pwd_tmp = lv_mem_realloc(ta->pwd_tmp, realloc_size); + ta->pwd_tmp = lv_realloc(ta->pwd_tmp, realloc_size); LV_ASSERT_MALLOC(ta->pwd_tmp); if(ta->pwd_tmp == NULL) return; @@ -240,7 +240,7 @@ void lv_textarea_del_char(lv_obj_t * obj) if(ta->pwd_mode) { _lv_txt_cut(ta->pwd_tmp, ta->cursor.pos - 1, 1); - ta->pwd_tmp = lv_mem_realloc(ta->pwd_tmp, strlen(ta->pwd_tmp) + 1); + ta->pwd_tmp = lv_realloc(ta->pwd_tmp, strlen(ta->pwd_tmp) + 1); LV_ASSERT_MALLOC(ta->pwd_tmp); if(ta->pwd_tmp == NULL) return; } @@ -300,7 +300,7 @@ void lv_textarea_set_text(lv_obj_t * obj, const char * txt) } if(ta->pwd_mode) { - ta->pwd_tmp = lv_mem_realloc(ta->pwd_tmp, strlen(txt) + 1); + ta->pwd_tmp = lv_realloc(ta->pwd_tmp, strlen(txt) + 1); LV_ASSERT_MALLOC(ta->pwd_tmp); if(ta->pwd_tmp == NULL) return; strcpy(ta->pwd_tmp, txt); @@ -321,13 +321,13 @@ void lv_textarea_set_placeholder_text(lv_obj_t * obj, const char * txt) size_t txt_len = strlen(txt); if((txt_len == 0) && (ta->placeholder_txt)) { - lv_mem_free(ta->placeholder_txt); + lv_free(ta->placeholder_txt); ta->placeholder_txt = NULL; } else { /*Allocate memory for the placeholder_txt text*/ /*NOTE: Using special realloc behavior, malloc-like when data_p is NULL*/ - ta->placeholder_txt = lv_mem_realloc(ta->placeholder_txt, txt_len + 1); + ta->placeholder_txt = lv_realloc(ta->placeholder_txt, txt_len + 1); LV_ASSERT_MALLOC(ta->placeholder_txt); if(ta->placeholder_txt == NULL) { LV_LOG_ERROR("lv_textarea_set_placeholder_text: couldn't allocate memory for placeholder"); @@ -414,7 +414,7 @@ void lv_textarea_set_password_mode(lv_obj_t * obj, bool en) char * txt = lv_label_get_text(ta->label); size_t len = strlen(txt); - ta->pwd_tmp = lv_mem_alloc(len + 1); + ta->pwd_tmp = lv_malloc(len + 1); LV_ASSERT_MALLOC(ta->pwd_tmp); if(ta->pwd_tmp == NULL) return; @@ -428,7 +428,7 @@ void lv_textarea_set_password_mode(lv_obj_t * obj, bool en) else { lv_textarea_clear_selection(obj); lv_label_set_text(ta->label, ta->pwd_tmp); - lv_mem_free(ta->pwd_tmp); + lv_free(ta->pwd_tmp); ta->pwd_tmp = NULL; } @@ -443,7 +443,7 @@ void lv_textarea_set_password_bullet(lv_obj_t * obj, const char * bullet) lv_textarea_t * ta = (lv_textarea_t *)obj; if(!bullet && (ta->pwd_bullet)) { - lv_mem_free(ta->pwd_bullet); + lv_free(ta->pwd_bullet); ta->pwd_bullet = NULL; } else { @@ -451,7 +451,7 @@ void lv_textarea_set_password_bullet(lv_obj_t * obj, const char * bullet) /*Allocate memory for the pwd_bullet text*/ /*NOTE: Using special realloc behavior, malloc-like when data_p is NULL*/ - ta->pwd_bullet = lv_mem_realloc(ta->pwd_bullet, txt_len + 1); + ta->pwd_bullet = lv_realloc(ta->pwd_bullet, txt_len + 1); LV_ASSERT_MALLOC(ta->pwd_bullet); if(ta->pwd_bullet == NULL) { LV_LOG_ERROR("lv_textarea_set_password_bullet: couldn't allocate memory for bullet"); @@ -845,15 +845,15 @@ static void lv_textarea_destructor(const lv_obj_class_t * class_p, lv_obj_t * ob lv_textarea_t * ta = (lv_textarea_t *)obj; if(ta->pwd_tmp != NULL) { - lv_mem_free(ta->pwd_tmp); + lv_free(ta->pwd_tmp); ta->pwd_tmp = NULL; } if(ta->pwd_bullet != NULL) { - lv_mem_free(ta->pwd_bullet); + lv_free(ta->pwd_bullet); ta->pwd_bullet = NULL; } if(ta->placeholder_txt != NULL) { - lv_mem_free(ta->placeholder_txt); + lv_free(ta->placeholder_txt); ta->placeholder_txt = NULL; } } @@ -985,7 +985,7 @@ static void pwd_char_hider(lv_obj_t * obj) const char * bullet = lv_textarea_get_password_bullet(obj); const size_t bullet_len = strlen(bullet); - char * txt_tmp = lv_mem_buf_get(enc_len * bullet_len + 1); + char * txt_tmp = lv_malloc(enc_len * bullet_len + 1); uint32_t i; for(i = 0; i < enc_len; i++) { @@ -994,7 +994,7 @@ static void pwd_char_hider(lv_obj_t * obj) txt_tmp[i * bullet_len] = '\0'; lv_label_set_text(ta->label, txt_tmp); - lv_mem_buf_release(txt_tmp); + lv_free(txt_tmp); refr_cursor_area(obj); } diff --git a/tests/src/test_cases/test_mem.c b/tests/src/test_cases/test_mem.c index c97e2719fd..59d4837a85 100644 --- a/tests/src/test_cases/test_mem.c +++ b/tests/src/test_cases/test_mem.c @@ -17,8 +17,8 @@ void tearDown(void) void test_mem_buf_realloc(void) { #if LV_MEM_CUSTOM == 0 - void * buf1 = lv_mem_alloc(20); - void * buf2 = lv_mem_realloc(buf1, LV_MEM_SIZE + 16384); + void * buf1 = lv_malloc(20); + void * buf2 = lv_realloc(buf1, LV_MEM_SIZE + 16384); TEST_ASSERT_NULL(buf2); #endif }