From f706de55170e876140a1436406b8d11f58599160 Mon Sep 17 00:00:00 2001 From: Gabor Kiss-Vamosi Date: Tue, 14 May 2019 15:45:03 +0200 Subject: [PATCH] img_decoder is working (not fully tested yet) --- src/lv_core/lv_obj.c | 3 + src/lv_core/lv_obj.h | 8 +- src/lv_draw/lv_draw.h | 16 +- src/lv_draw/lv_draw_img.c | 14 +- src/lv_draw/lv_draw_img.h | 8 - src/lv_misc/lv_img_decoder.c | 563 +++++++++++++++++++---------------- src/lv_misc/lv_img_decoder.h | 56 +++- src/lv_misc/lv_types.h | 44 +++ src/lv_objx/lv_img.c | 3 +- src/lv_objx/lv_imgbtn.c | 2 +- 10 files changed, 423 insertions(+), 294 deletions(-) create mode 100644 src/lv_misc/lv_types.h diff --git a/src/lv_core/lv_obj.c b/src/lv_core/lv_obj.c index 8ef301738..9ebd4964e 100644 --- a/src/lv_core/lv_obj.c +++ b/src/lv_core/lv_obj.c @@ -16,6 +16,7 @@ #include "../lv_misc/lv_anim.h" #include "../lv_misc/lv_task.h" #include "../lv_misc/lv_fs.h" +#include "../lv_misc/lv_img_decoder.h" #include "../lv_hal/lv_hal.h" #include #include @@ -109,6 +110,8 @@ void lv_init(void) /*Init the input device handling*/ lv_indev_init(); + lv_img_decoder_init(); + lv_initialized = true; LV_LOG_INFO("lv_init ready"); } diff --git a/src/lv_core/lv_obj.h b/src/lv_core/lv_obj.h index 0e8485030..19a2d9522 100644 --- a/src/lv_core/lv_obj.h +++ b/src/lv_core/lv_obj.h @@ -22,6 +22,7 @@ extern "C" { #include #include #include "lv_style.h" +#include "../lv_misc/lv_types.h" #include "../lv_misc/lv_area.h" #include "../lv_misc/lv_mem.h" #include "../lv_misc/lv_ll.h" @@ -64,13 +65,6 @@ typedef uint8_t lv_design_mode_t; typedef bool (*lv_design_cb_t)(struct _lv_obj_t * obj, const lv_area_t * mask_p, lv_design_mode_t mode); -enum { - LV_RES_INV = 0, /*Typically indicates that the object is deleted (become invalid) in the action - function or an operation was failed*/ - LV_RES_OK, /*The object is valid (no deleted) after the action*/ -}; -typedef uint8_t lv_res_t; - enum { LV_EVENT_PRESSED, /*The object has been pressed*/ LV_EVENT_PRESSING, /*The object is being pressed (called continuously while pressing)*/ diff --git a/src/lv_draw/lv_draw.h b/src/lv_draw/lv_draw.h index 0d346653a..1828e32c2 100644 --- a/src/lv_draw/lv_draw.h +++ b/src/lv_draw/lv_draw.h @@ -21,30 +21,16 @@ extern "C" { #include "../lv_core/lv_style.h" #include "../lv_misc/lv_txt.h" +#include "../lv_misc/lv_img_decoder.h" /********************* * DEFINES *********************/ -/*If image pixels contains alpha we need to know how much byte is a pixel*/ -#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8 -#define LV_IMG_PX_SIZE_ALPHA_BYTE 2 -#elif LV_COLOR_DEPTH == 16 -#define LV_IMG_PX_SIZE_ALPHA_BYTE 3 -#elif LV_COLOR_DEPTH == 32 -#define LV_IMG_PX_SIZE_ALPHA_BYTE 4 -#endif /********************** * TYPEDEFS **********************/ -enum { - LV_IMG_SRC_VARIABLE, - LV_IMG_SRC_FILE, - LV_IMG_SRC_SYMBOL, - LV_IMG_SRC_UNKNOWN, -}; -typedef uint8_t lv_img_src_t; /********************** * GLOBAL PROTOTYPES diff --git a/src/lv_draw/lv_draw_img.c b/src/lv_draw/lv_draw_img.c index ebc9b0e3e..0986f1af4 100644 --- a/src/lv_draw/lv_draw_img.c +++ b/src/lv_draw/lv_draw_img.c @@ -452,20 +452,20 @@ static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mas lv_img_header_t header; lv_res_t header_res; - header_res = lv_img_dsc_get_info(src, &header); + header_res = lv_img_decoder_get_info(src, &header); if(header_res != LV_RES_OK) { LV_LOG_WARN("Image draw can't get image info"); - lv_img_decoder_close(); return LV_RES_INV; } bool chroma_keyed = lv_img_color_format_is_chroma_keyed(header.cf); bool alpha_byte = lv_img_color_format_has_alpha(header.cf); - const uint8_t * img_data = lv_img_decoder_open(src, style); + lv_img_decoder_dsc_t dsc; + const uint8_t * img_data = lv_img_decoder_open(&dsc, src, style); if(img_data == LV_IMG_DECODER_OPEN_FAIL) { LV_LOG_WARN("Image draw cannot open the image resource"); - lv_img_decoder_close(); + lv_img_decoder_close(&dsc); return LV_RES_INV; } @@ -493,9 +493,9 @@ static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mas lv_coord_t row; lv_res_t read_res; for(row = mask_com.y1; row <= mask_com.y2; row++) { - read_res = lv_img_decoder_read_line(x, y, width, buf); + read_res = lv_img_decoder_read_line(&dsc, x, y, width, buf); if(read_res != LV_RES_OK) { - lv_img_decoder_close(); + lv_img_decoder_close(&dsc); LV_LOG_WARN("Image draw can't read the line"); return LV_RES_INV; } @@ -507,7 +507,7 @@ static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mas } } - lv_img_decoder_close(); + lv_img_decoder_close(&dsc); return LV_RES_OK; } diff --git a/src/lv_draw/lv_draw_img.h b/src/lv_draw/lv_draw_img.h index 43c1a13df..446b2c302 100644 --- a/src/lv_draw/lv_draw_img.h +++ b/src/lv_draw/lv_draw_img.h @@ -40,14 +40,6 @@ extern "C" { void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_style_t * style, lv_opa_t opa_scale); -/** - * Initialize and `lv_img_dsc_t` variable with the image's info - * @param src variable, filename or symbol - * @param header store the result here - * @return LV_RES_OK: succeeded; LV_RES_INV: failed - */ -lv_res_t lv_img_dsc_get_info(const char * src, lv_img_header_t * header); - /** * Get the type of an image source * @param src pointer to an image source: diff --git a/src/lv_misc/lv_img_decoder.c b/src/lv_misc/lv_img_decoder.c index d0a045407..a18a9a28b 100644 --- a/src/lv_misc/lv_img_decoder.c +++ b/src/lv_misc/lv_img_decoder.c @@ -7,7 +7,10 @@ * INCLUDES *********************/ #include "lv_img_decoder.h" +#include "../lv_draw/lv_draw_img.h" #include "lv_ll.h" +#include "lv_color.h" +#include "lv_gc.h" #if defined(LV_GC_INCLUDE) #include LV_GC_INCLUDE @@ -20,11 +23,29 @@ /********************** * TYPEDEFS **********************/ +typedef struct { + lv_fs_file_t * f; + lv_color_t * palette; +}lv_img_decoder_built_in_data_t; + /********************** * STATIC PROTOTYPES **********************/ +static lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header); +static const uint8_t * lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc); +static lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, + lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf); +static void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc); +static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * dsc, + lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf); +static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, + uint8_t * buf); +static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, + uint8_t * buf); + + /********************** * STATIC VARIABLES **********************/ @@ -36,6 +57,7 @@ /********************** * GLOBAL FUNCTIONS **********************/ + /** * Initialize the image decoder module * */ @@ -43,27 +65,30 @@ void lv_img_decoder_init(void) { lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t)); - lv_img_decoder_t decoder; + lv_img_decoder_t * decoder; - /*Create a decoder for true color images*/ - decoder = lv_img_decoder_craete(); - if(decoder) return; - - /*Create a decoder for Alpha indexed images*/ - decoder = lv_img_decoder_craete(); - if(decoder) return; - - /*Create a decoder for color indexed images*/ - decoder = lv_img_decoder_craete(); - if(decoder) return; + /*Create a decoder for the built in color format*/ + decoder = lv_img_decoder_create(); + if(decoder == NULL) { + LV_LOG_WARN("lv_img_decoder_init: out of memory"); + lv_mem_assert(decoder); + return; + } + lv_img_decoder_set_info_cb(decoder, lv_img_decoder_built_in_info); + lv_img_decoder_set_open_cb(decoder, lv_img_decoder_built_in_open); + lv_img_decoder_set_read_line_cb(decoder, lv_img_decoder_built_in_read_line); + lv_img_decoder_set_close_cb(decoder, lv_img_decoder_built_in_close); } -lv_img_decoder_t * lv_img_decoder_craete(void) +lv_img_decoder_t * lv_img_decoder_create(void) { lv_img_decoder_t * decoder; decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll)); lv_mem_assert(decoder); + if(decoder == NULL) return NULL; + + memset(decoder, 0, sizeof(lv_img_decoder_t)); return decoder; } @@ -91,7 +116,7 @@ void lv_img_decoder_set_read_line_cb(lv_img_decoder_t * decoder, lv_img_decoder_ void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_close_f_t close_cb) { - decoder->read_line_cb = close_cb; + decoder->close_cb = close_cb; } void lv_img_decoder_set_user_data(lv_img_decoder_t * decoder, lv_img_decoder_t user_data) @@ -99,17 +124,16 @@ void lv_img_decoder_set_user_data(lv_img_decoder_t * decoder, lv_img_decoder_t u memcpy(&decoder->user_data, &user_data, sizeof(user_data)); } -lv_img_decoder_t lv_img_decoder_get_user_data(lv_img_decoder_t * decoder) +lv_img_decoder_user_data_t lv_img_decoder_get_user_data(lv_img_decoder_t * decoder) { return decoder->user_data; } -lv_img_decoder_t * lv_img_decoder_get_user_data_ptr(lv_img_decoder_t * decoder) +lv_img_decoder_user_data_t * lv_img_decoder_get_user_data_ptr(lv_img_decoder_t * decoder) { return &decoder->user_data; } - lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header) { header->always_zero = 0; @@ -127,12 +151,12 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header) return res; } - const uint8_t * lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style) { dsc->style = style; dsc->src = src; dsc->src_type = lv_img_src_get_type(src); + dsc->user_data = NULL; lv_res_t header_res; header_res = lv_img_decoder_get_info(src, &dsc->header); @@ -147,251 +171,287 @@ const uint8_t * lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src if(res != LV_IMG_DECODER_OPEN_FAIL) break; } -} - -static lv_res_t lv_img_decoder_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf) -{ - lv_res_t res = LV_RES_INV; - if(decoder->read_line_cb)res = decoder->read_line_cb(decoder, dsc, x, y, len, buf); return res; } -static void lv_img_decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc) +lv_res_t lv_img_decoder_read_line(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf) { - if(decoder->close_cb) decoder->close_cb(decoder, dsc); + lv_res_t res = LV_RES_INV; + if(dsc->decoder->read_line_cb)res = dsc->decoder->read_line_cb(dsc->decoder, dsc, x, y, len, buf); + + return res; +} + +void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc) +{ + if(dsc->decoder->close_cb) dsc->decoder->close_cb(dsc->decoder, dsc); } -static lv_res_t img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header) +/********************** + * STATIC FUNCTIONS + **********************/ + + +static lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header) { lv_img_src_t src_type = lv_img_src_get_type(src); - if(src_type == LV_IMG_SRC_VARIABLE) { - header->w = ((lv_img_dsc_t *)src)->header.w; - header->h = ((lv_img_dsc_t *)src)->header.h; - header->cf = ((lv_img_dsc_t *)src)->header.cf; + if(src_type == LV_IMG_SRC_VARIABLE) { + header->w = ((lv_img_dsc_t *)src)->header.w; + header->h = ((lv_img_dsc_t *)src)->header.h; + header->cf = ((lv_img_dsc_t *)src)->header.cf; + } +#if LV_USE_FILESYSTEM + else if(src_type == LV_IMG_SRC_FILE) { + lv_fs_file_t file; + lv_fs_res_t res; + uint32_t rn; + res = lv_fs_open(&file, src, LV_FS_MODE_RD); + if(res == LV_FS_RES_OK) { + res = lv_fs_read(&file, header, sizeof(lv_img_header_t), &rn); + lv_fs_close(&file); } - #if LV_USE_FILESYSTEM - else if(src_type == LV_IMG_SRC_FILE) { - lv_fs_file_t file; - lv_fs_res_t res; - uint32_t rn; - res = lv_fs_open(&file, src, LV_FS_MODE_RD); - if(res == LV_FS_RES_OK) { - res = lv_fs_read(&file, header, sizeof(lv_img_header_t), &rn); - lv_fs_close(&file); - } - /*Create a dummy header on fs error*/ - if(res != LV_FS_RES_OK || rn != sizeof(lv_img_header_t)) { - header->w = LV_DPI; - header->h = LV_DPI; - header->cf = LV_IMG_CF_UNKNOWN; - return LV_RES_INV; - } - } - #endif - else if(src_type == LV_IMG_SRC_SYMBOL) { - /*The size depend on the font but it is unknown here. It should be handled outside of the - * function*/ - header->w = 1; - header->h = 1; - /* Symbols always have transparent parts. Important because of cover check in the design - * function. The actual value doesn't matter because lv_draw_label will draw it*/ - header->cf = LV_IMG_CF_ALPHA_1BIT; - } else { - LV_LOG_WARN("Image get info found unknown src type"); + /*Create a dummy header on fs error*/ + if(res != LV_FS_RES_OK || rn != sizeof(lv_img_header_t)) { + header->w = LV_DPI; + header->h = LV_DPI; + header->cf = LV_IMG_CF_UNKNOWN; return LV_RES_INV; } - return LV_RES_OK; + } +#endif + else if(src_type == LV_IMG_SRC_SYMBOL) { + /*The size depend on the font but it is unknown here. It should be handled outside of the + * function*/ + header->w = 1; + header->h = 1; + /* Symbols always have transparent parts. Important because of cover check in the design + * function. The actual value doesn't matter because lv_draw_label will draw it*/ + header->cf = LV_IMG_CF_ALPHA_1BIT; + } else { + LV_LOG_WARN("Image get info found unknown src type"); + return LV_RES_INV; + } + return LV_RES_OK; } -static uint8_t * img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc,) +static const uint8_t * lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc) { - if(header_res == LV_RES_INV) { - decoder_src = NULL; - decoder_src_type = LV_IMG_SRC_UNKNOWN; - LV_LOG_WARN("Built-in image decoder can't get the header info"); - return LV_IMG_DECODER_OPEN_FAIL; - } - /*Open the file if it's a file*/ - if(decoder_src_type == LV_IMG_SRC_FILE) { + if(dsc->src_type == LV_IMG_SRC_FILE) { #if LV_USE_FILESYSTEM - lv_fs_res_t res = lv_fs_open(&decoder_file, src, LV_FS_MODE_RD); + lv_fs_file_t f; + lv_fs_res_t res = lv_fs_open(&f, dsc->src, LV_FS_MODE_RD); if(res != LV_FS_RES_OK) { LV_LOG_WARN("Built-in image decoder can't open the file"); return LV_IMG_DECODER_OPEN_FAIL; } + + /*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)); + if(dsc->user_data == NULL) { + LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); + lv_mem_assert(dsc->user_data); + } + memset(dsc->user_data, 0, sizeof(lv_img_decoder_built_in_data_t)); + } + + lv_img_decoder_built_in_data_t * user_data = dsc->user_data; + user_data->f = lv_mem_alloc(sizeof(f)); + if(user_data->f == NULL) { + LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); + lv_mem_assert(user_data->f); + } + + memcpy(user_data->f, &f, sizeof(f)); + #else LV_LOG_WARN("Image built-in decoder can read file because LV_USE_FILESYSTEM = 0"); return LV_IMG_DECODER_OPEN_FAIL; #endif } - /*Process the different color formats*/ - lv_img_cf_t cf = decoder_header.cf; + lv_img_cf_t cf = dsc->header.cf; + /*Process true color formats*/ if(cf == LV_IMG_CF_TRUE_COLOR || cf == LV_IMG_CF_TRUE_COLOR_ALPHA || - cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) { - if(decoder_src_type == LV_IMG_SRC_VARIABLE) { - /*In case of uncompressed formats if the image stored in the ROM/RAM simply give it's - * pointer*/ - return ((lv_img_dsc_t *)decoder_src)->data; + cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) { + if(dsc->src_type == LV_IMG_SRC_VARIABLE) { + /* In case of uncompressed formats the image stored in the ROM/RAM. + * So simply give its pointer*/ + return ((lv_img_dsc_t *)dsc->src)->data; } else { - /*If it's file it need to be read line by line later*/ + /*If it's a file it need to be read line by line later*/ return NULL; } - } else if(cf == LV_IMG_CF_INDEXED_1BIT || cf == LV_IMG_CF_INDEXED_2BIT || - cf == LV_IMG_CF_INDEXED_4BIT || cf == LV_IMG_CF_INDEXED_8BIT) { + } + /*Process indexed images. Build a palette*/ + else if(cf == LV_IMG_CF_INDEXED_1BIT || cf == LV_IMG_CF_INDEXED_2BIT || + cf == LV_IMG_CF_INDEXED_4BIT || cf == LV_IMG_CF_INDEXED_8BIT) { #if LV_IMG_CF_INDEXED -#if LV_USE_FILESYSTEM - lv_color32_t palette_file[256]; -#endif - - lv_color32_t * palette_p = NULL; uint8_t px_size = lv_img_color_format_get_px_size(cf); uint32_t palette_size = 1 << px_size; - if(decoder_src_type == LV_IMG_SRC_FILE) { + /*Allocate the palette*/ + if(dsc->user_data == NULL) { + dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t)); + if(dsc->user_data == NULL) { + LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); + lv_mem_assert(dsc->user_data); + } + memset(dsc->user_data, 0, 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(sizeof(palette_size * sizeof(lv_color_t))); + if(user_data->palette == NULL) { + LV_LOG_ERROR("img_decoder_built_in_open: out of memory"); + lv_mem_assert(user_data->f); + } +#if LV_USE_FILESYSTEM + lv_color32_t palette_tmp[256]; +#endif + lv_color32_t * palette_p; + + if(dsc->src_type == LV_IMG_SRC_FILE) { /*Read the palette from file*/ #if LV_USE_FILESYSTEM - lv_fs_seek(&decoder_file, 4); /*Skip the header*/ - lv_fs_read(&decoder_file, palette_file, palette_size * sizeof(lv_color32_t), NULL); - palette_p = palette_file; + lv_fs_seek(user_data->f, 4); /*Skip the header*/ + lv_fs_read(user_data->f, palette_tmp, palette_size * sizeof(lv_color_t), NULL); + palette_p = palette_tmp; #else LV_LOG_WARN( - "Image built-in decoder can read the palette because LV_USE_FILESYSTEM = 0"); + "Image built-in decoder can read the palette because LV_USE_FILESYSTEM = 0"); return LV_IMG_DECODER_OPEN_FAIL; #endif } else { /*The palette begins in the beginning of the image data. Just point to it.*/ - palette_p = (lv_color32_t *)((lv_img_dsc_t *)decoder_src)->data; + palette_p = (lv_color32_t *)((lv_img_dsc_t *)dsc->src)->data; } uint32_t i; for(i = 0; i < palette_size; i++) { - decoder_index_map[i] = - lv_color_make(palette_p[i].ch.red, palette_p[i].ch.green, palette_p[i].ch.blue); + user_data->palette[i] = lv_color_make(palette_p[i].ch.red, palette_p[i].ch.green, palette_p[i].ch.blue); } return NULL; #else LV_LOG_WARN("Indexed (palette) images are not enabled in lv_conf.h. See LV_IMG_CF_INDEXED"); return LV_IMG_DECODER_OPEN_FAIL; #endif - } else if(cf == LV_IMG_CF_ALPHA_1BIT || cf == LV_IMG_CF_ALPHA_2BIT || - cf == LV_IMG_CF_ALPHA_4BIT || cf == LV_IMG_CF_ALPHA_8BIT) { + } + /*Alpha indexed images. */ + else if(cf == LV_IMG_CF_ALPHA_1BIT || cf == LV_IMG_CF_ALPHA_2BIT || + cf == LV_IMG_CF_ALPHA_4BIT || cf == LV_IMG_CF_ALPHA_8BIT) { #if LV_IMG_CF_ALPHA return NULL; /*Nothing to process*/ #else LV_LOG_WARN("Alpha indexed images are not enabled in lv_conf.h. See LV_IMG_CF_ALPHA"); return LV_IMG_DECODER_OPEN_FAIL; #endif - } else { + } + /*Unknown format. Can't decode it.*/ + else { + /*Free the potentially allocated memories*/ + lv_img_decoder_built_in_close(decoder, dsc); + LV_LOG_WARN("Image decoder open: unknown color format") return LV_IMG_DECODER_OPEN_FAIL; } } -static lv_res_t lv_img_decoder_built_in_line_read(lv_img_decoder_t * decoder, lv_coord_t x, lv_coord_t y, lv_coord_t len, - uint8_t * buf) + +static lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, + lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf) { + (void)decoder; /*Unused*/ + + lv_res_t res = LV_RES_INV; + if(dsc->src_type == LV_IMG_SRC_FILE) { - #if LV_USE_FILESYSTEM - uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf); + if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || + dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA || + dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) + { + res = lv_img_decoder_built_in_line_true_color(dsc, x, y, len, buf); + } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || + dsc->header.cf == LV_IMG_CF_ALPHA_2BIT || + dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || + dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) { - lv_fs_res_t res; + res = lv_img_decoder_built_in_line_alpha(dsc, x, y, len, buf); + } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT || + dsc->header.cf == LV_IMG_CF_INDEXED_2BIT || + dsc->header.cf == LV_IMG_CF_INDEXED_4BIT || + dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) { + res = lv_img_decoder_built_in_line_indexed(dsc, x, y, len, buf); + } else { + LV_LOG_WARN("Built-in image decoder read not supports the color format"); + return false; + } + } - if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || - dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA || - dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) - { - uint32_t pos = ((y * dsc->header.w + x) * px_size) >> 3; - pos += 4; /*Skip the header*/ - res = lv_fs_seek(&decoder_file, pos); - if(res != LV_FS_RES_OK) { - LV_LOG_WARN("Built-in image decoder seek failed"); - return false; - } - uint32_t btr = len * (px_size >> 3); - uint32_t br = 0; - lv_fs_read(&decoder_file, buf, btr, &br); - if(res != LV_FS_RES_OK || btr != br) { - LV_LOG_WARN("Built-in image decoder read failed"); - return false; - } - } else if(decoder_header.cf == LV_IMG_CF_ALPHA_1BIT || - decoder_header.cf == LV_IMG_CF_ALPHA_2BIT || - decoder_header.cf == LV_IMG_CF_ALPHA_4BIT || - decoder_header.cf == LV_IMG_CF_ALPHA_8BIT) { - - lv_img_built_in_decoder_line_alpha(x, y, len, buf); - } else if(decoder_header.cf == LV_IMG_CF_INDEXED_1BIT || - decoder_header.cf == LV_IMG_CF_INDEXED_2BIT || - decoder_header.cf == LV_IMG_CF_INDEXED_4BIT || - decoder_header.cf == LV_IMG_CF_INDEXED_8BIT) { - lv_img_built_in_decoder_line_indexed(x, y, len, buf); - } else { - LV_LOG_WARN("Built-in image decoder read not supports the color format"); - return false; - } - #else - LV_LOG_WARN("Image built-in decoder can't read file because LV_USE_FILESYSTEM = 0"); - return false; - #endif - } else if(decoder_src_type == LV_IMG_SRC_VARIABLE) { - const lv_img_dsc_t * img_dsc = decoder_src; - - if(img_dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || - img_dsc->header.cf == LV_IMG_CF_ALPHA_2BIT || - img_dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || - img_dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) { - lv_img_built_in_decoder_line_alpha(x, y, len, buf); - } else if(img_dsc->header.cf == LV_IMG_CF_INDEXED_1BIT || - img_dsc->header.cf == LV_IMG_CF_INDEXED_2BIT || - img_dsc->header.cf == LV_IMG_CF_INDEXED_4BIT || - img_dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) { - lv_img_built_in_decoder_line_indexed(x, y, len, buf); - } else { - LV_LOG_WARN("Built-in image decoder not supports the color format"); - return false; - } - } - - return true; + return res; } static void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc) { + (void)decoder; /*Unused*/ - /*It was opened with built-in decoder*/ - if(decoder_src) { -#if LV_USE_FILESYSTEM - if(decoder_src_type == LV_IMG_SRC_FILE) { - lv_fs_close(&decoder_file); - } -#endif - decoder_src_type = LV_IMG_SRC_UNKNOWN; - decoder_src = NULL; + lv_img_decoder_built_in_data_t * user_data = dsc->user_data; + if(user_data) { + if(user_data->f) lv_mem_free(user_data->f); + if(user_data->palette) lv_mem_free(user_data->palette); + + lv_mem_free(user_data); + + dsc->user_data = NULL; } } -static lv_res_t lv_img_built_in_decoder_line_alpha(lv_img_decoder_t * decoder, lv_coord_t x, lv_coord_t y, lv_coord_t len, - uint8_t * buf) +static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * dsc, + lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf) +{ + lv_img_decoder_built_in_data_t * user_data = dsc->user_data; + lv_fs_res_t res; + uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf); + + uint32_t pos = ((y * dsc->header.w + x) * px_size) >> 3; + pos += 4; /*Skip the header*/ + res = lv_fs_seek(user_data->f, pos); + if(res != LV_FS_RES_OK) { + LV_LOG_WARN("Built-in image decoder seek failed"); + return LV_RES_INV; + } + uint32_t btr = len * (px_size >> 3); + uint32_t br = 0; + lv_fs_read(user_data->f, buf, btr, &br); + if(res != LV_FS_RES_OK || btr != br) { + LV_LOG_WARN("Built-in image decoder read failed"); + return LV_RES_INV; + } + + return LV_RES_OK; +} + +static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, + uint8_t * buf) { #if LV_IMG_CF_ALPHA const lv_opa_t alpha1_opa_table[2] = { - 0, 255}; /*Opacity mapping with bpp = 1 (Just for compatibility)*/ + 0, 255}; /*Opacity mapping with bpp = 1 (Just for compatibility)*/ const lv_opa_t alpha2_opa_table[4] = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/ const lv_opa_t alpha4_opa_table[16] = {0, 17, 34, 51, /*Opacity mapping with bpp = 4*/ - 68, 85, 102, 119, 136, 153, - 170, 187, 204, 221, 238, 255}; + 68, 85, 102, 119, 136, 153, + 170, 187, 204, 221, 238, 255}; /*Simply fill the buffer with the color. Later only the alpha value will be modified.*/ - lv_color_t bg_color = decoder_style->image.color; + lv_color_t bg_color = dsc->style->image.color; lv_coord_t i; for(i = 0; i < len; i++) { #if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1 @@ -408,42 +468,43 @@ static lv_res_t lv_img_built_in_decoder_line_alpha(lv_img_decoder_t * decoder, l } const lv_opa_t * opa_table = NULL; - uint8_t px_size = lv_img_color_format_get_px_size(decoder_header.cf); + uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf); uint16_t mask = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/ lv_coord_t w = 0; uint32_t ofs = 0; int8_t pos = 0; - switch(decoder_header.cf) { - case LV_IMG_CF_ALPHA_1BIT: - w = (decoder_header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/ - if(decoder_header.w & 0x7) w++; - ofs += w * y + (x >> 3); /*First pixel*/ - pos = 7 - (x & 0x7); - opa_table = alpha1_opa_table; - break; - case LV_IMG_CF_ALPHA_2BIT: - w = (decoder_header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/ - if(decoder_header.w & 0x3) w++; - ofs += w * y + (x >> 2); /*First pixel*/ - pos = 6 - ((x & 0x3) * 2); - opa_table = alpha2_opa_table; - break; - case LV_IMG_CF_ALPHA_4BIT: - w = (decoder_header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/ - if(decoder_header.w & 0x1) w++; - ofs += w * y + (x >> 1); /*First pixel*/ - pos = 4 - ((x & 0x1) * 4); - opa_table = alpha4_opa_table; - break; - case LV_IMG_CF_ALPHA_8BIT: - w = decoder_header.w; /*E.g. x = 7 -> w = 7 (bytes)*/ - ofs += w * y + x; /*First pixel*/ - pos = 0; - break; + switch(dsc->header.cf) { + case LV_IMG_CF_ALPHA_1BIT: + w = (dsc->header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/ + if(dsc->header.w & 0x7) w++; + ofs += w * y + (x >> 3); /*First pixel*/ + pos = 7 - (x & 0x7); + opa_table = alpha1_opa_table; + break; + case LV_IMG_CF_ALPHA_2BIT: + w = (dsc->header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/ + if(dsc->header.w & 0x3) w++; + ofs += w * y + (x >> 2); /*First pixel*/ + pos = 6 - ((x & 0x3) * 2); + opa_table = alpha2_opa_table; + break; + case LV_IMG_CF_ALPHA_4BIT: + w = (dsc->header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/ + if(dsc->header.w & 0x1) w++; + ofs += w * y + (x >> 1); /*First pixel*/ + pos = 4 - ((x & 0x1) * 4); + opa_table = alpha4_opa_table; + break; + case LV_IMG_CF_ALPHA_8BIT: + w = dsc->header.w; /*E.g. x = 7 -> w = 7 (bytes)*/ + ofs += w * y + x; /*First pixel*/ + pos = 0; + break; } #if LV_USE_FILESYSTEM + lv_img_decoder_built_in_data_t * user_data = dsc->user_data; #if LV_COMPILER_VLA_SUPPORTED uint8_t fs_buf[w]; #else @@ -451,17 +512,17 @@ static lv_res_t lv_img_built_in_decoder_line_alpha(lv_img_decoder_t * decoder, l #endif #endif const uint8_t * data_tmp = NULL; - if(decoder_src_type == LV_IMG_SRC_VARIABLE) { - const lv_img_dsc_t * img_dsc = decoder_src; + if(dsc->src_type == LV_IMG_SRC_VARIABLE) { + const lv_img_dsc_t * img_dsc = dsc->src; + data_tmp = img_dsc->data + ofs; } else { #if LV_USE_FILESYSTEM - lv_fs_seek(&decoder_file, ofs + 4); /*+4 to skip the header*/ - lv_fs_read(&decoder_file, fs_buf, w, NULL); + lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/ + lv_fs_read(user_data->f, fs_buf, w, NULL); data_tmp = fs_buf; #else - LV_LOG_WARN( - "Image built-in alpha line reader can't read file because LV_USE_FILESYSTEM = 0"); + LV_LOG_WARN( "Image built-in alpha line reader can't read file because LV_USE_FILESYSTEM = 0"); data_tmp = NULL; /*To avoid warnings*/ return LV_RES_INV; #endif @@ -473,7 +534,7 @@ static lv_res_t lv_img_built_in_decoder_line_alpha(lv_img_decoder_t * decoder, l val_act = (data_tmp[byte_act] & (mask << pos)) >> pos; buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE + LV_IMG_PX_SIZE_ALPHA_BYTE - 1] = - decoder_header.cf == LV_IMG_CF_ALPHA_8BIT ? val_act : opa_table[val_act]; + dsc->header.cf == LV_IMG_CF_ALPHA_8BIT ? val_act : opa_table[val_act]; pos -= px_size; if(pos < 0) { @@ -486,52 +547,54 @@ static lv_res_t lv_img_built_in_decoder_line_alpha(lv_img_decoder_t * decoder, l #else LV_LOG_WARN( - "Image built-in alpha line reader failed because LV_IMG_CF_ALPHA is 0 in lv_conf.h"); + "Image built-in alpha line reader failed because LV_IMG_CF_ALPHA is 0 in lv_conf.h"); return LV_RES_INV; #endif } -static lv_res_t lv_img_built_in_decoder_line_indexed(lv_img_decoder_t * decoder, lv_coord_t x, lv_coord_t y, lv_coord_t len, - uint8_t * buf) +static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, + uint8_t * buf) { #if LV_IMG_CF_INDEXED - uint8_t px_size = lv_img_color_format_get_px_size(decoder_header.cf); + uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf); uint16_t mask = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/ lv_coord_t w = 0; int8_t pos = 0; uint32_t ofs = 0; - switch(decoder_header.cf) { - case LV_IMG_CF_INDEXED_1BIT: - w = (decoder_header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/ - if(decoder_header.w & 0x7) w++; - ofs += w * y + (x >> 3); /*First pixel*/ - ofs += 8; /*Skip the palette*/ - pos = 7 - (x & 0x7); - break; - case LV_IMG_CF_INDEXED_2BIT: - w = (decoder_header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/ - if(decoder_header.w & 0x3) w++; - ofs += w * y + (x >> 2); /*First pixel*/ - ofs += 16; /*Skip the palette*/ - pos = 6 - ((x & 0x3) * 2); - break; - case LV_IMG_CF_INDEXED_4BIT: - w = (decoder_header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/ - if(decoder_header.w & 0x1) w++; - ofs += w * y + (x >> 1); /*First pixel*/ - ofs += 64; /*Skip the palette*/ - pos = 4 - ((x & 0x1) * 4); - break; - case LV_IMG_CF_INDEXED_8BIT: - w = decoder_header.w; /*E.g. x = 7 -> w = 7 (bytes)*/ - ofs += w * y + x; /*First pixel*/ - ofs += 1024; /*Skip the palette*/ - pos = 0; - break; + switch(dsc->header.cf) { + case LV_IMG_CF_INDEXED_1BIT: + w = (dsc->header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/ + if(dsc->header.w & 0x7) w++; + ofs += w * y + (x >> 3); /*First pixel*/ + ofs += 8; /*Skip the palette*/ + pos = 7 - (x & 0x7); + break; + case LV_IMG_CF_INDEXED_2BIT: + w = (dsc->header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/ + if(dsc->header.w & 0x3) w++; + ofs += w * y + (x >> 2); /*First pixel*/ + ofs += 16; /*Skip the palette*/ + pos = 6 - ((x & 0x3) * 2); + break; + case LV_IMG_CF_INDEXED_4BIT: + w = (dsc->header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/ + if(dsc->header.w & 0x1) w++; + ofs += w * y + (x >> 1); /*First pixel*/ + ofs += 64; /*Skip the palette*/ + pos = 4 - ((x & 0x1) * 4); + break; + case LV_IMG_CF_INDEXED_8BIT: + w = dsc->header.w; /*E.g. x = 7 -> w = 7 (bytes)*/ + ofs += w * y + x; /*First pixel*/ + ofs += 1024; /*Skip the palette*/ + pos = 0; + break; } + lv_img_decoder_built_in_data_t * user_data = dsc->user_data; + #if LV_USE_FILESYSTEM #if LV_COMPILER_VLA_SUPPORTED uint8_t fs_buf[w]; @@ -540,17 +603,17 @@ static lv_res_t lv_img_built_in_decoder_line_indexed(lv_img_decoder_t * decoder, #endif #endif const uint8_t * data_tmp = NULL; - if(decoder_src_type == LV_IMG_SRC_VARIABLE) { - const lv_img_dsc_t * img_dsc = decoder_src; + if(dsc->src_type == LV_IMG_SRC_VARIABLE) { + const lv_img_dsc_t * img_dsc = dsc->src; data_tmp = img_dsc->data + ofs; } else { #if LV_USE_FILESYSTEM - lv_fs_seek(&decoder_file, ofs + 4); /*+4 to skip the header*/ - lv_fs_read(&decoder_file, fs_buf, w, NULL); + lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/ + lv_fs_read(user_data->f, fs_buf, w, NULL); data_tmp = fs_buf; #else LV_LOG_WARN( - "Image built-in indexed line reader can't read file because LV_USE_FILESYSTEM = 0"); + "Image built-in indexed line reader can't read file because LV_USE_FILESYSTEM = 0"); data_tmp = NULL; /*To avoid warnings*/ return LV_RES_INV; #endif @@ -562,7 +625,7 @@ static lv_res_t lv_img_built_in_decoder_line_indexed(lv_img_decoder_t * decoder, lv_color_t * cbuf = (lv_color_t *)buf; for(i = 0; i < len; i++) { val_act = (data_tmp[byte_act] & (mask << pos)) >> pos; - cbuf[i] = decoder_index_map[val_act]; + cbuf[i] = user_data->palette[val_act]; pos -= px_size; if(pos < 0) { @@ -574,14 +637,10 @@ static lv_res_t lv_img_built_in_decoder_line_indexed(lv_img_decoder_t * decoder, return LV_RES_OK; #else LV_LOG_WARN( - "Image built-in indexed line reader failed because LV_IMG_CF_INDEXED is 0 in lv_conf.h"); + "Image built-in indexed line reader failed because LV_IMG_CF_INDEXED is 0 in lv_conf.h"); return LV_RES_INV; #endif } - -/********************** - * STATIC FUNCTIONS - **********************/ diff --git a/src/lv_misc/lv_img_decoder.h b/src/lv_misc/lv_img_decoder.h index 7432a4342..e431f227a 100644 --- a/src/lv_misc/lv_img_decoder.h +++ b/src/lv_misc/lv_img_decoder.h @@ -21,15 +21,38 @@ extern "C" { #include #include "lv_fs.h" +#include "lv_types.h" +#include "lv_area.h" +#include "../lv_core/lv_style.h" /********************* * DEFINES *********************/ -#define LV_IMG_DECODER_OPEN_FAIL ((void *)(-1)); +/*If image pixels contains alpha we need to know how much byte is a pixel*/ +#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8 +#define LV_IMG_PX_SIZE_ALPHA_BYTE 2 +#elif LV_COLOR_DEPTH == 16 +#define LV_IMG_PX_SIZE_ALPHA_BYTE 3 +#elif LV_COLOR_DEPTH == 32 +#define LV_IMG_PX_SIZE_ALPHA_BYTE 4 +#endif + + +#define LV_IMG_DECODER_OPEN_FAIL ((void *)(-1)) /********************** * TYPEDEFS **********************/ + +enum { + LV_IMG_SRC_VARIABLE, + LV_IMG_SRC_FILE, + LV_IMG_SRC_SYMBOL, + LV_IMG_SRC_UNKNOWN, +}; + +typedef uint8_t lv_img_src_t; + typedef struct { @@ -126,7 +149,7 @@ typedef lv_res_t (*lv_img_decoder_read_line_f_t)(struct _lv_img_decoder * decode */ typedef void (*lv_img_decoder_close_f_t)(struct _lv_img_decoder * decoder, struct _lv_img_decoder_dsc * dsc); -typedef struct _lv_img_decoder_dsc { +typedef struct _lv_img_decoder { lv_img_decoder_info_f_t info_cb; lv_img_decoder_open_f_t open_cb; lv_img_decoder_read_line_f_t read_line_cb; @@ -138,7 +161,7 @@ typedef struct _lv_img_decoder_dsc { }lv_img_decoder_t; -typedef struct { +typedef struct _lv_img_decoder_dsc { lv_img_decoder_t * decoder; const lv_style_t * style; const void * src; @@ -154,6 +177,33 @@ typedef struct { * GLOBAL PROTOTYPES **********************/ +/** + * Initialize the image decoder module + * */ +void lv_img_decoder_init(void); + +lv_img_decoder_t * lv_img_decoder_create(void); + +void lv_img_decoder_delete(lv_img_decoder_t * decoder); + +void lv_img_decoder_set_info_cb(lv_img_decoder_t * decoder, lv_img_decoder_info_f_t info_cb); + +void lv_img_decoder_set_open_cb(lv_img_decoder_t * decoder, lv_img_decoder_open_f_t open_cb); + +void lv_img_decoder_set_read_line_cb(lv_img_decoder_t * decoder, lv_img_decoder_read_line_f_t read_line_cb); + +void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_close_f_t close_cb); +void lv_img_decoder_set_user_data(lv_img_decoder_t * decoder, lv_img_decoder_t user_data); + +lv_img_decoder_user_data_t lv_img_decoder_get_user_data(lv_img_decoder_t * decoder); +lv_img_decoder_user_data_t * lv_img_decoder_get_user_data_ptr(lv_img_decoder_t * decoder); + +lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header); +const uint8_t * lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style); + +lv_res_t lv_img_decoder_read_line(lv_img_decoder_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_coord_t len, uint8_t * buf); + +void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc); /********************** * MACROS **********************/ diff --git a/src/lv_misc/lv_types.h b/src/lv_misc/lv_types.h new file mode 100644 index 000000000..bdd860f56 --- /dev/null +++ b/src/lv_misc/lv_types.h @@ -0,0 +1,44 @@ +/** + * @file lv_types.h + * + */ + +#ifndef LV_TYPES_H +#define LV_TYPES_H + +#ifdef __cplusplus +extern "C" { +#endif + +/********************* + * INCLUDES + *********************/ + +/********************* + * DEFINES + *********************/ + +/********************** + * TYPEDEFS + **********************/ + +enum { + LV_RES_INV = 0, /*Typically indicates that the object is deleted (become invalid) in the action + function or an operation was failed*/ + LV_RES_OK, /*The object is valid (no deleted) after the action*/ +}; +typedef uint8_t lv_res_t; + +/********************** + * GLOBAL PROTOTYPES + **********************/ + +/********************** + * MACROS + **********************/ + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /*LV_TYPES_H*/ diff --git a/src/lv_objx/lv_img.c b/src/lv_objx/lv_img.c index 510ad9f58..15a3299d8 100644 --- a/src/lv_objx/lv_img.c +++ b/src/lv_objx/lv_img.c @@ -15,6 +15,7 @@ #endif #include "../lv_themes/lv_theme.h" +#include "../lv_misc/lv_img_decoder.h" #include "../lv_misc/lv_fs.h" #include "../lv_misc/lv_txt.h" #include "../lv_misc/lv_log.h" @@ -148,7 +149,7 @@ void lv_img_set_src(lv_obj_t * img, const void * src_img) } lv_img_header_t header; - lv_img_dsc_get_info(src_img, &header); + lv_img_decoder_get_info(src_img, &header); /*Save the source*/ if(src_type == LV_IMG_SRC_VARIABLE) { diff --git a/src/lv_objx/lv_imgbtn.c b/src/lv_objx/lv_imgbtn.c index cf98c82b1..58a03b1c6 100644 --- a/src/lv_objx/lv_imgbtn.c +++ b/src/lv_objx/lv_imgbtn.c @@ -375,7 +375,7 @@ static void refr_img(lv_obj_t * imgbtn) #endif lv_res_t info_res; - info_res = lv_img_dsc_get_info(src, &header); + info_res = lv_img_decoder_get_info(src, &header); if(info_res == LV_RES_OK) { ext->act_cf = header.cf; #if LV_IMGBTN_TILED == 0