Mirrors_UI_SDK/lvgl
1
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2026-05-21 14:32:44 +08:00
Code Issues Actions 47 Packages Projects Releases Wiki Activity

fix(vg_lite): remove the 16px width limit for image tile drawing mode (#8661)

Browse Source 
Signed-off-by: pengyiqiang <pengyiqiang@xiaomi.com>
Co-authored-by: pengyiqiang <pengyiqiang@xiaomi.com>
This commit is contained in:
VIFEX
2025-08-12 19:33:08 +08:00
committed by GitHub
parent f78be49fba
commit 5e2a9bab34
3 changed files with 65 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/draw/vg_lite/lv_draw_vg_lite_img.c
+12 -6
View File
@@ -155,9 +155,7 @@ void lv_draw_vg_lite_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
vg_lite_matrix_t path_matrix = u->global_matrix;
/* When alignment requirements are not met, use repeated drawing to simulate tile drawing effects. */
/* vg_lite_tvg does not support VG_LITE_PATTERN_REPEAT */
if(dsc->tile && (LV_USE_VG_LITE_THORVG || (img_w % 16 != 0 && lv_vg_lite_16px_align()))) {
if(dsc->tile) {
lv_area_t tile_area;
if(lv_area_get_width(&dsc->image_area) >= 0) {
tile_area = dsc->image_area;
@@ -168,9 +166,15 @@ void lv_draw_vg_lite_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
lv_area_set_width(&tile_area, img_w);
lv_area_set_height(&tile_area, img_h);
/**
* vg_lite_tvg does not support VG_LITE_PATTERN_REPEAT,
* use looping texture for simulation.
*/
#if LV_USE_VG_LITE_THORVG
const int32_t tile_x_start = tile_area.x1;
while(tile_area.y1 <= coords->y2) {
while(tile_area.x1 <= coords->x2) {
#endif
vg_lite_matrix_t tile_matrix;
vg_lite_identity(&tile_matrix);
vg_lite_translate(tile_area.x1 - coords->x1, tile_area.y1 - coords->y1, &tile_matrix);
@@ -179,7 +183,7 @@ void lv_draw_vg_lite_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
lv_vg_lite_matrix_multiply(&pattern_matrix, &tile_matrix);
lv_area_t clipped_img_area;
if(lv_area_intersect(&clipped_img_area, &tile_area, coords)) {
if(!LV_USE_VG_LITE_THORVG || lv_area_intersect(&clipped_img_area, &tile_area, coords)) {
lv_vg_lite_draw_pattern(
&u->target_buffer,
lv_vg_lite_path_get_path(path),
@@ -188,12 +192,13 @@ void lv_draw_vg_lite_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
&src_buf,
&pattern_matrix,
blend,
VG_LITE_PATTERN_COLOR,
VG_LITE_PATTERN_REPEAT,
0,
color,
filter);
}
#if LV_USE_VG_LITE_THORVG
tile_area.x1 += img_w;
tile_area.x2 += img_w;
}
@@ -203,6 +208,7 @@ void lv_draw_vg_lite_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
tile_area.x1 = tile_x_start;
tile_area.x2 = tile_x_start + img_w - 1;
}
#endif
}
else {
lv_vg_lite_draw_pattern(
@@ -213,7 +219,7 @@ void lv_draw_vg_lite_img(lv_draw_task_t * t, const lv_draw_image_dsc_t * dsc,
&src_buf,
&matrix,
blend,
dsc->tile ? VG_LITE_PATTERN_REPEAT : VG_LITE_PATTERN_COLOR,
VG_LITE_PATTERN_COLOR,
0,
color,
filter);
src/draw/vg_lite/lv_vg_lite_utils.c
+53 -34
View File
@@ -700,22 +700,15 @@ void lv_vg_lite_buffer_format_bytes(
uint32_t lv_vg_lite_width_to_stride(uint32_t w, vg_lite_buffer_format_t color_format)
{
w = lv_vg_lite_width_align(w);
if(vg_lite_query_feature(gcFEATURE_BIT_VG_16PIXELS_ALIGN)) {
w = LV_VG_LITE_ALIGN(w, 16);
}
uint32_t mul, div, align;
lv_vg_lite_buffer_format_bytes(color_format, &mul, &div, &align);
return LV_VG_LITE_ALIGN(((w * mul + div - 1) / div), align);
}
uint32_t lv_vg_lite_width_align(uint32_t w)
{
if(lv_vg_lite_16px_align()) {
w = LV_VG_LITE_ALIGN(w, 16);
}
return w;
}
void lv_vg_lite_buffer_init(
vg_lite_buffer_t * buffer,
const void * ptr,
@@ -787,8 +780,6 @@ void lv_vg_lite_buffer_from_draw_buf(vg_lite_buffer_t * buffer, const lv_draw_bu
ptr += LV_VG_LITE_ALIGN(palette_size_bytes, LV_DRAW_BUF_ALIGN);
}
width = lv_vg_lite_width_align(width);
lv_vg_lite_buffer_init(buffer, ptr,
width, height, stride, format,
lv_draw_buf_has_flag(draw_buf, LV_VG_LITE_IMAGE_FLAGS_TILED));
@@ -999,11 +990,6 @@ vg_lite_blend_t lv_vg_lite_blend_mode(lv_blend_mode_t blend_mode, bool has_pre_m
bool lv_vg_lite_buffer_check(const vg_lite_buffer_t * buffer, bool is_src)
{
uint32_t mul;
uint32_t div;
uint32_t align;
int32_t stride;
if(!buffer) {
LV_LOG_ERROR("buffer is NULL");
return false;
@@ -1029,21 +1015,59 @@ bool lv_vg_lite_buffer_check(const vg_lite_buffer_t * buffer, bool is_src)
return false;
}
if(is_src && buffer->width != (vg_lite_int32_t)lv_vg_lite_width_align(buffer->width)) {
LV_LOG_ERROR("buffer width(%d) is not aligned", (int)buffer->width);
if(buffer->tiled == VG_LITE_TILED) {
if(!LV_VG_LITE_IS_ALIGNED(buffer->width, 4) || !LV_VG_LITE_IS_ALIGNED(buffer->height, 4)) {
LV_LOG_ERROR("tiled buffer width(%d) or height(%d) is not aligned to 4", (int)buffer->width, (int)buffer->height);
return false;
}
}
int memory_align = LV_DRAW_BUF_ALIGN;
if(is_src) {
switch(buffer->format) {
case VG_LITE_INDEX_1:
case VG_LITE_INDEX_2:
case VG_LITE_INDEX_4:
case VG_LITE_A4:
memory_align = 8;
break;
case VG_LITE_INDEX_8:
case VG_LITE_A8:
case VG_LITE_L8:
case VG_LITE_RGBA2222:
case VG_LITE_BGRA2222:
case VG_LITE_ABGR2222:
case VG_LITE_ARGB2222:
memory_align = 16;
break;
case VG_LITE_ABGR1555:
case VG_LITE_ARGB1555:
case VG_LITE_BGRA5551:
case VG_LITE_RGBA5551:
case VG_LITE_RGBA4444:
case VG_LITE_BGRA4444:
case VG_LITE_ABGR4444:
case VG_LITE_ARGB4444:
case VG_LITE_RGB565:
case VG_LITE_BGR565:
memory_align = 32;
break;
default:
break;
}
}
if(!LV_VG_LITE_IS_ALIGNED(buffer->memory, memory_align)) {
LV_LOG_ERROR("buffer address(%p) is not aligned to %d", buffer->memory, memory_align);
return false;
}
if(!LV_VG_LITE_IS_ALIGNED(buffer->memory, LV_DRAW_BUF_ALIGN)) {
LV_LOG_ERROR("buffer address(%p) is not aligned to %d", buffer->memory, LV_DRAW_BUF_ALIGN);
return false;
}
lv_vg_lite_buffer_format_bytes(buffer->format, &mul, &div, &align);
stride = LV_VG_LITE_ALIGN((buffer->width * mul / div), align);
if(buffer->stride != stride) {
LV_LOG_ERROR("buffer stride(%d) != %d", (int)buffer->stride, (int)stride);
const uint32_t stride = lv_vg_lite_width_to_stride(buffer->width, buffer->format);
if(buffer->stride < 0 || (uint32_t)buffer->stride != stride) {
LV_LOG_ERROR("buffer stride(%d) != expected(%d)", (int)buffer->stride, (int)stride);
return false;
}
@@ -1169,11 +1193,6 @@ bool lv_vg_lite_support_blend_normal(void)
return vg_lite_query_feature(gcFEATURE_BIT_VG_LVGL_SUPPORT);
}
bool lv_vg_lite_16px_align(void)
{
return vg_lite_query_feature(gcFEATURE_BIT_VG_16PIXELS_ALIGN);
}
void lv_vg_lite_matrix_multiply(vg_lite_matrix_t * matrix, const vg_lite_matrix_t * mult)
{
lv_matrix_t temp;
src/draw/vg_lite/lv_vg_lite_utils.h
-4
View File
@@ -114,8 +114,6 @@ void lv_vg_lite_buffer_format_bytes(
uint32_t lv_vg_lite_width_to_stride(uint32_t w, vg_lite_buffer_format_t color_format);
uint32_t lv_vg_lite_width_align(uint32_t w);
void lv_vg_lite_buffer_init(
vg_lite_buffer_t * buffer,
const void * ptr,
@@ -163,8 +161,6 @@ bool lv_vg_lite_matrix_check(const vg_lite_matrix_t * matrix);
bool lv_vg_lite_support_blend_normal(void);
bool lv_vg_lite_16px_align(void);
void lv_vg_lite_matrix_multiply(vg_lite_matrix_t * matrix, const vg_lite_matrix_t * mult);
bool lv_vg_lite_matrix_inverse(vg_lite_matrix_t * result, const vg_lite_matrix_t * matrix);