Mirrors_UI_SDK/lvgl
1
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2026-05-20 21:35:19 +08:00
Code Issues Actions 48 Packages Projects Releases Wiki Activity

perf(draw): support draw task dsc alloc together to reduce the malloc call times (#8070)

Browse Source 
Signed-off-by: rongyichang <rongyichang@xiaomi.com>
This commit is contained in:
terry.rong
2025-04-10 17:40:50 +08:00
committed by GitHub
parent bf6829098e
commit 84fc0ed7f5
11 changed files with 104 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/draw/lv_draw.c
+57 -5
View File
@@ -13,6 +13,8 @@
#include "../misc/lv_area_private.h"
#include "../misc/lv_assert.h"
#include "lv_draw_private.h"
#include "lv_draw_mask_private.h"
#include "lv_draw_vector_private.h"
#include "sw/lv_draw_sw.h"
#include "../display/lv_display_private.h"
#include "../core/lv_global.h"
@@ -33,6 +35,7 @@
**********************/
static bool is_independent(lv_layer_t * layer, lv_draw_task_t * t_check);
static void cleanup_task(lv_draw_task_t * t, lv_display_t * disp);
static inline size_t get_draw_dsc_size(lv_draw_task_type_t type);
static lv_draw_task_t * get_first_available_task(lv_layer_t * layer);
#if LV_LOG_LEVEL <= LV_LOG_LEVEL_INFO
@@ -92,10 +95,12 @@ void * lv_draw_create_unit(size_t size)
return new_unit;
}
lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords)
lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords, lv_draw_task_type_t type)
{
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * new_task = lv_malloc_zeroed(sizeof(lv_draw_task_t));
size_t dsc_size = get_draw_dsc_size(type);
LV_ASSERT_FORMAT_MSG(dsc_size > 0, "Draw task size is 0 for type %d", type);
lv_draw_task_t * new_task = lv_malloc_zeroed(LV_ALIGN_UP(sizeof(lv_draw_task_t), 8) + dsc_size);
LV_ASSERT_MALLOC(new_task);
new_task->area = *coords;
new_task->_real_area = *coords;
@@ -104,6 +109,8 @@ lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords)
#if LV_DRAW_TRANSFORM_USE_MATRIX
new_task->matrix = layer->matrix;
#endif
new_task->type = type;
new_task->draw_dsc = (uint8_t *)new_task + LV_ALIGN_UP(sizeof(lv_draw_task_t), 8);
new_task->state = LV_DRAW_TASK_STATE_QUEUED;
/*Find the tail*/
@@ -326,7 +333,6 @@ lv_draw_task_t * lv_draw_get_next_available_task(lv_layer_t * layer, lv_draw_tas
{
LV_PROFILER_DRAW_BEGIN;
/*If the first task is screen sized, there cannot be independent areas*/
if(layer->draw_task_head) {
int32_t hor_res = lv_display_get_horizontal_resolution(lv_refr_get_disp_refreshing());
@@ -443,7 +449,6 @@ void lv_draw_layer_init(lv_layer_t * layer, lv_layer_t * parent_layer, lv_color_
LV_PROFILER_DRAW_END;
}
void * lv_draw_layer_alloc_buf(lv_layer_t * layer)
{
LV_PROFILER_DRAW_BEGIN;
@@ -537,6 +542,54 @@ static bool is_independent(lv_layer_t * layer, lv_draw_task_t * t_check)
return true;
}
/**
* Get the size of the draw descriptor of a draw task
* @param type type of the draw task
* @return size of the draw descriptor in bytes
*/
static inline size_t get_draw_dsc_size(lv_draw_task_type_t type)
{
switch(type) {
case LV_DRAW_TASK_TYPE_NONE:
return 0;
case LV_DRAW_TASK_TYPE_FILL:
return sizeof(lv_draw_fill_dsc_t);
case LV_DRAW_TASK_TYPE_BORDER:
return sizeof(lv_draw_border_dsc_t);
case LV_DRAW_TASK_TYPE_BOX_SHADOW:
return sizeof(lv_draw_box_shadow_dsc_t);
case LV_DRAW_TASK_TYPE_LETTER:
return sizeof(lv_draw_letter_dsc_t);
case LV_DRAW_TASK_TYPE_LABEL:
return sizeof(lv_draw_label_dsc_t);
case LV_DRAW_TASK_TYPE_IMAGE:
return sizeof(lv_draw_image_dsc_t);
case LV_DRAW_TASK_TYPE_LAYER:
return sizeof(lv_draw_image_dsc_t);
case LV_DRAW_TASK_TYPE_LINE:
return sizeof(lv_draw_line_dsc_t);
case LV_DRAW_TASK_TYPE_ARC:
return sizeof(lv_draw_arc_dsc_t);
case LV_DRAW_TASK_TYPE_TRIANGLE:
return sizeof(lv_draw_triangle_dsc_t);
case LV_DRAW_TASK_TYPE_MASK_RECTANGLE:
return sizeof(lv_draw_mask_rect_dsc_t);
/* no struct match for LV_DRAW_TASK_TYPE_MASK_BITMAP, set it to zero now */
case LV_DRAW_TASK_TYPE_MASK_BITMAP:
return 0;
#if LV_USE_VECTOR_GRAPHIC
case LV_DRAW_TASK_TYPE_VECTOR:
return sizeof(lv_draw_vector_task_dsc_t);
#endif
/* Note that default is not added here because when adding new draw task type,
* if forget to add case, the compiler will automatically report a warning.
*/
}
return 0;
}
/**
* Clean-up resources allocated by a finished task
* @param t pointer to a draw task
@@ -591,7 +644,6 @@ static void cleanup_task(lv_draw_task_t * t, lv_display_t * disp)
draw_label_dsc->text = NULL;
}
lv_free(t->draw_dsc);
lv_free(t);
LV_PROFILER_DRAW_END;
}
src/draw/lv_draw.h
+3 -1
View File
@@ -57,7 +57,9 @@ typedef enum {
LV_DRAW_TASK_TYPE_TRIANGLE,
LV_DRAW_TASK_TYPE_MASK_RECTANGLE,
LV_DRAW_TASK_TYPE_MASK_BITMAP,
#if LV_USE_VECTOR_GRAPHIC
LV_DRAW_TASK_TYPE_VECTOR,
#endif
} lv_draw_task_type_t;
typedef enum {
@@ -167,7 +169,7 @@ void * lv_draw_create_unit(size_t size);
* @return the created draw task which needs to be
* further configured e.g. by added a draw descriptor
*/
lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords);
lv_draw_task_t * lv_draw_add_task(lv_layer_t * layer, const lv_area_t * coords, lv_draw_task_type_t type);
/**
* Needs to be called when a draw task is created and configured.
src/draw/lv_draw_arc.c
+1 -4
View File
@@ -62,12 +62,9 @@ void lv_draw_arc(lv_layer_t * layer, const lv_draw_arc_dsc_t * dsc)
a.y1 = dsc->center.y - dsc->radius;
a.x2 = dsc->center.x + dsc->radius - 1;
a.y2 = dsc->center.y + dsc->radius - 1;
lv_draw_task_t * t = lv_draw_add_task(layer, &a);
lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_ARC);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_ARC;
lv_draw_finalize_task_creation(layer, t);
src/draw/lv_draw_image.c
+14 -22
View File
@@ -73,13 +73,9 @@ void lv_draw_layer(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * t = lv_draw_add_task(layer, coords);
lv_draw_image_dsc_t * new_image_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(new_image_dsc);
t->draw_dsc = new_image_dsc;
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_LAYER;
lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_LAYER);
lv_draw_image_dsc_t * new_image_dsc = t->draw_dsc;
lv_memcpy(new_image_dsc, dsc, sizeof(*dsc));
t->state = LV_DRAW_TASK_STATE_WAITING;
lv_image_buf_get_transformed_area(&t->_real_area, lv_area_get_width(coords), lv_area_get_height(coords),
@@ -114,27 +110,24 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
LV_PROFILER_DRAW_BEGIN;
lv_draw_image_dsc_t * new_image_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(new_image_dsc);
lv_memcpy(new_image_dsc, dsc, sizeof(*dsc));
lv_result_t res = lv_image_decoder_get_info(new_image_dsc->src, &new_image_dsc->header);
lv_draw_image_dsc_t new_image_dsc;
lv_memcpy(&new_image_dsc, dsc, sizeof(*dsc));
lv_result_t res = lv_image_decoder_get_info(new_image_dsc.src, &new_image_dsc.header);
if(res != LV_RESULT_OK) {
LV_LOG_WARN("Couldn't get info about the image");
lv_free(new_image_dsc);
LV_PROFILER_DRAW_END;
return;
}
/*If the image_area is not set assume that it's the same as the rendering area */
if(new_image_dsc->image_area.x2 == LV_COORD_MIN) {
new_image_dsc->image_area = *image_coords;
if(new_image_dsc.image_area.x2 == LV_COORD_MIN) {
new_image_dsc.image_area = *image_coords;
}
/*Typical case, draw the image as bitmap*/
if(!(new_image_dsc->header.flags & LV_IMAGE_FLAGS_CUSTOM_DRAW)) {
lv_draw_task_t * t = lv_draw_add_task(layer, image_coords);
t->draw_dsc = new_image_dsc;
t->type = LV_DRAW_TASK_TYPE_IMAGE;
if(!(new_image_dsc.header.flags & LV_IMAGE_FLAGS_CUSTOM_DRAW)) {
lv_draw_task_t * t = lv_draw_add_task(layer, image_coords, LV_DRAW_TASK_TYPE_IMAGE);
lv_memcpy(t->draw_dsc, &new_image_dsc, sizeof(lv_draw_image_dsc_t));
lv_image_buf_get_transformed_area(&t->_real_area, lv_area_get_width(image_coords), lv_area_get_height(image_coords),
dsc->rotation, dsc->scale_x, dsc->scale_y, &dsc->pivot);
@@ -146,7 +139,7 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
else {
lv_image_decoder_dsc_t decoder_dsc;
res = lv_image_decoder_open(&decoder_dsc, new_image_dsc->src, NULL);
res = lv_image_decoder_open(&decoder_dsc, new_image_dsc.src, NULL);
if(res != LV_RESULT_OK) {
LV_LOG_ERROR("Failed to open image");
LV_PROFILER_DRAW_END;
@@ -165,7 +158,7 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
lv_area_move(&coords_area, -(image_coords->x1 - xpos), -(image_coords->y1 - ypos));
layer->_clip_area = coords_area;
decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, new_image_dsc, &coords_area);
decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, &new_image_dsc, &coords_area);
}
}
else {
@@ -181,13 +174,12 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
lv_area_move(&clip_area, image_coords->x1, image_coords->y1);
if(lv_area_intersect(&clip_area, &clip_area, &obj_area)) {
decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, new_image_dsc, &clip_area);
decoder_dsc.decoder->custom_draw_cb(layer, &decoder_dsc, &coords_area, &new_image_dsc, &clip_area);
}
}
}
}
lv_free(new_image_dsc);
}
LV_PROFILER_DRAW_END;
src/draw/lv_draw_label.c
+2 -8
View File
@@ -108,12 +108,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_label(lv_layer_t * layer, const lv_draw_label
}
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * t = lv_draw_add_task(layer, coords);
lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_LABEL);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_LABEL;
/*The text is stored in a local variable so malloc memory for it*/
if(dsc->text_local) {
@@ -191,12 +188,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_letter(lv_layer_t * layer, lv_draw_letter_dsc
dsc->pivot.x = g.adv_w / 2 ;
dsc->pivot.y = font->line_height - font->base_line;
lv_draw_task_t * t = lv_draw_add_task(layer, &a);
lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LETTER);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_LETTER;
lv_draw_finalize_task_creation(layer, t);
LV_PROFILER_DRAW_END;
src/draw/lv_draw_line.c
+1 -4
View File
@@ -63,12 +63,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_line(lv_layer_t * layer, const lv_draw_line_d
a.y1 = (int32_t)LV_MIN(dsc->p1.y, dsc->p2.y) - dsc->width;
a.y2 = (int32_t)LV_MAX(dsc->p1.y, dsc->p2.y) + dsc->width;
lv_draw_task_t * t = lv_draw_add_task(layer, &a);
lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LINE);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_LINE;
lv_draw_finalize_task_creation(layer, t);
LV_PROFILER_DRAW_END;
src/draw/lv_draw_mask.c
+1 -4
View File
@@ -55,12 +55,9 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_mask_rect(lv_layer_t * layer, const lv_draw_m
}
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * t = lv_draw_add_task(layer, &layer->buf_area);
lv_draw_task_t * t = lv_draw_add_task(layer, &layer->buf_area, LV_DRAW_TASK_TYPE_MASK_RECTANGLE);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_MASK_RECTANGLE;
lv_draw_dsc_base_t * base_dsc = t->draw_dsc;
base_dsc->layer = layer;
src/draw/lv_draw_rect.c
+21 -44
View File
@@ -63,8 +63,6 @@ void lv_draw_fill_dsc_init(lv_draw_fill_dsc_t * dsc)
dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
}
lv_draw_fill_dsc_t * lv_draw_task_get_fill_dsc(lv_draw_task_t * task)
{
return task->type == LV_DRAW_TASK_TYPE_FILL ? (lv_draw_fill_dsc_t *)task->draw_dsc : NULL;
@@ -75,12 +73,9 @@ void lv_draw_fill(lv_layer_t * layer, const lv_draw_fill_dsc_t * dsc, const lv_a
if(dsc->opa <= LV_OPA_MIN) return;
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * t = lv_draw_add_task(layer, coords);
lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_FILL);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_FILL;
lv_draw_finalize_task_creation(layer, t);
LV_PROFILER_DRAW_END;
@@ -104,12 +99,9 @@ void lv_draw_border(lv_layer_t * layer, const lv_draw_border_dsc_t * dsc, const
if(dsc->opa <= LV_OPA_MIN) return;
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * t = lv_draw_add_task(layer, coords);
lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BORDER);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_BORDER;
lv_draw_finalize_task_creation(layer, t);
LV_PROFILER_DRAW_END;
@@ -132,12 +124,9 @@ void lv_draw_box_shadow(lv_layer_t * layer, const lv_draw_box_shadow_dsc_t * dsc
if(dsc->opa <= LV_OPA_MIN) return;
LV_PROFILER_DRAW_BEGIN;
lv_draw_task_t * t = lv_draw_add_task(layer, coords);
lv_draw_task_t * t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BOX_SHADOW);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_BOX_SHADOW;
lv_draw_finalize_task_creation(layer, t);
LV_PROFILER_DRAW_END;
@@ -195,10 +184,9 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
/*Shadow*/
if(has_shadow) {
/*Check whether the shadow is visible*/
t = lv_draw_add_task(layer, coords);
lv_draw_box_shadow_dsc_t * shadow_dsc = lv_malloc(sizeof(lv_draw_box_shadow_dsc_t));
LV_ASSERT_MALLOC(shadow_dsc);
t->draw_dsc = shadow_dsc;
t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BOX_SHADOW);
lv_draw_box_shadow_dsc_t * shadow_dsc = t->draw_dsc;
lv_area_increase(&t->_real_area, dsc->shadow_spread, dsc->shadow_spread);
lv_area_increase(&t->_real_area, dsc->shadow_width, dsc->shadow_width);
lv_area_move(&t->_real_area, dsc->shadow_offset_x, dsc->shadow_offset_y);
@@ -212,7 +200,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
shadow_dsc->ofs_x = dsc->shadow_offset_x;
shadow_dsc->ofs_y = dsc->shadow_offset_y;
shadow_dsc->bg_cover = bg_cover;
t->type = LV_DRAW_TASK_TYPE_BOX_SHADOW;
lv_draw_finalize_task_creation(layer, t);
}
@@ -227,18 +214,16 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
bg_coords.y2 -= (dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? 1 : 0;
}
t = lv_draw_add_task(layer, &bg_coords);
lv_draw_fill_dsc_t * bg_dsc = lv_malloc(sizeof(lv_draw_fill_dsc_t));
LV_ASSERT_MALLOC(bg_dsc);
t = lv_draw_add_task(layer, &bg_coords, LV_DRAW_TASK_TYPE_FILL);
lv_draw_fill_dsc_t * bg_dsc = t->draw_dsc;
lv_draw_fill_dsc_init(bg_dsc);
t->draw_dsc = bg_dsc;
bg_dsc->base = dsc->base;
bg_dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
bg_dsc->radius = dsc->radius;
bg_dsc->color = dsc->bg_color;
bg_dsc->grad = dsc->bg_grad;
bg_dsc->opa = dsc->bg_opa;
t->type = LV_DRAW_TASK_TYPE_FILL;
lv_draw_finalize_task_creation(layer, t);
}
@@ -263,18 +248,17 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
if(src_type == LV_IMAGE_SRC_VARIABLE || src_type == LV_IMAGE_SRC_FILE) {
if(dsc->bg_image_tiled) {
t = lv_draw_add_task(layer, coords);
t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_IMAGE);
}
else {
lv_area_t a = {0, 0, header.w - 1, header.h - 1};
lv_area_align(coords, &a, LV_ALIGN_CENTER, 0, 0);
t = lv_draw_add_task(layer, &a);
t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_IMAGE);
}
lv_draw_image_dsc_t * bg_image_dsc = lv_malloc(sizeof(lv_draw_image_dsc_t));
LV_ASSERT_MALLOC(bg_image_dsc);
lv_draw_image_dsc_t * bg_image_dsc = t->draw_dsc;
lv_draw_image_dsc_init(bg_image_dsc);
t->draw_dsc = bg_image_dsc;
bg_image_dsc->base = dsc->base;
bg_image_dsc->base.dsc_size = sizeof(lv_draw_image_dsc_t);
bg_image_dsc->src = dsc->bg_image_src;
@@ -285,7 +269,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
bg_image_dsc->header = header;
bg_image_dsc->clip_radius = dsc->radius;
bg_image_dsc->image_area = *coords;
t->type = LV_DRAW_TASK_TYPE_IMAGE;
lv_draw_finalize_task_creation(layer, t);
}
else {
@@ -294,12 +277,11 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
lv_area_t a = {0, 0, s.x - 1, s.y - 1};
lv_area_align(coords, &a, LV_ALIGN_CENTER, 0, 0);
t = lv_draw_add_task(layer, &a);
t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_LABEL);
lv_draw_label_dsc_t * bg_label_dsc = t->draw_dsc;
lv_draw_label_dsc_t * bg_label_dsc = lv_malloc(sizeof(lv_draw_label_dsc_t));
LV_ASSERT_MALLOC(bg_label_dsc);
lv_draw_label_dsc_init(bg_label_dsc);
t->draw_dsc = bg_label_dsc;
bg_label_dsc->base = dsc->base;
bg_label_dsc->base.dsc_size = sizeof(lv_draw_label_dsc_t);
bg_label_dsc->color = dsc->bg_image_recolor;
@@ -313,10 +295,9 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
/*Border*/
if(has_border) {
t = lv_draw_add_task(layer, coords);
lv_draw_border_dsc_t * border_dsc = lv_malloc(sizeof(lv_draw_border_dsc_t));
LV_ASSERT_MALLOC(border_dsc);
t->draw_dsc = border_dsc;
t = lv_draw_add_task(layer, coords, LV_DRAW_TASK_TYPE_BORDER);
lv_draw_border_dsc_t * border_dsc = t->draw_dsc;
border_dsc->base = dsc->base;
border_dsc->base.dsc_size = sizeof(lv_draw_border_dsc_t);
border_dsc->radius = dsc->radius;
@@ -324,7 +305,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
border_dsc->opa = dsc->border_opa;
border_dsc->width = dsc->border_width;
border_dsc->side = dsc->border_side;
t->type = LV_DRAW_TASK_TYPE_BORDER;
lv_draw_finalize_task_creation(layer, t);
}
@@ -332,10 +312,8 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
if(has_outline) {
lv_area_t outline_coords = *coords;
lv_area_increase(&outline_coords, dsc->outline_width + dsc->outline_pad, dsc->outline_width + dsc->outline_pad);
t = lv_draw_add_task(layer, &outline_coords);
lv_draw_border_dsc_t * outline_dsc = lv_malloc(sizeof(lv_draw_border_dsc_t));
LV_ASSERT_MALLOC(outline_dsc);
t->draw_dsc = outline_dsc;
t = lv_draw_add_task(layer, &outline_coords, LV_DRAW_TASK_TYPE_BORDER);
lv_draw_border_dsc_t * outline_dsc = t->draw_dsc;
lv_area_increase(&t->_real_area, dsc->outline_width, dsc->outline_width);
lv_area_increase(&t->_real_area, dsc->outline_pad, dsc->outline_pad);
outline_dsc->base = dsc->base;
@@ -346,7 +324,6 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
outline_dsc->opa = dsc->outline_opa;
outline_dsc->width = dsc->outline_width;
outline_dsc->side = LV_BORDER_SIDE_FULL;
t->type = LV_DRAW_TASK_TYPE_BORDER;
lv_draw_finalize_task_creation(layer, t);
}
src/draw/lv_draw_triangle.c
+1 -4
View File
@@ -69,12 +69,9 @@ void lv_draw_triangle(lv_layer_t * layer, const lv_draw_triangle_dsc_t * dsc)
a.x2 = (int32_t)LV_MAX3(dsc->p[0].x, dsc->p[1].x, dsc->p[2].x);
a.y2 = (int32_t)LV_MAX3(dsc->p[0].y, dsc->p[1].y, dsc->p[2].y);
lv_draw_task_t * t = lv_draw_add_task(layer, &a);
lv_draw_task_t * t = lv_draw_add_task(layer, &a, LV_DRAW_TASK_TYPE_TRIANGLE);
t->draw_dsc = lv_malloc(sizeof(*dsc));
LV_ASSERT_MALLOC(t->draw_dsc);
lv_memcpy(t->draw_dsc, dsc, sizeof(*dsc));
t->type = LV_DRAW_TASK_TYPE_TRIANGLE;
lv_draw_finalize_task_creation(layer, t);
LV_PROFILER_DRAW_END;
src/draw/lv_draw_vector.c
+1 -3
View File
@@ -754,9 +754,7 @@ void lv_draw_vector(lv_vector_dsc_t * dsc)
lv_layer_t * layer = dsc->layer;
lv_draw_task_t * t = lv_draw_add_task(layer, &(layer->_clip_area));
t->type = LV_DRAW_TASK_TYPE_VECTOR;
t->draw_dsc = lv_malloc(sizeof(lv_draw_vector_task_dsc_t));
lv_draw_task_t * t = lv_draw_add_task(layer, &(layer->_clip_area), LV_DRAW_TASK_TYPE_VECTOR);
lv_memcpy(t->draw_dsc, &(dsc->tasks), sizeof(lv_draw_vector_task_dsc_t));
lv_draw_finalize_task_creation(layer, t);
dsc->tasks.task_list = NULL;
src/draw/nema_gfx/lv_draw_nema_gfx.c
+2
View File
@@ -246,7 +246,9 @@ static int32_t nema_gfx_evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * ta
case LV_DRAW_TASK_TYPE_BOX_SHADOW:
case LV_DRAW_TASK_TYPE_MASK_RECTANGLE:
case LV_DRAW_TASK_TYPE_MASK_BITMAP:
#if LV_USE_VECTOR_GRAPHIC
case LV_DRAW_TASK_TYPE_VECTOR:
#endif
default:
break;
}