github-code/lvgl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

img_decoder is working (not fully tested yet)

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi
2019-05-14 15:45:03 +02:00
parent d58c8663d4
commit f706de5517
10 changed files with 423 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/lv_core/lv_obj.c
View File

@@ -16,6 +16,7 @@
#include "../lv_misc/lv_anim.h" #include "../lv_misc/lv_anim.h"
#include "../lv_misc/lv_task.h" #include "../lv_misc/lv_task.h"
#include "../lv_misc/lv_fs.h" #include "../lv_misc/lv_fs.h"
#include "../lv_misc/lv_img_decoder.h"
#include "../lv_hal/lv_hal.h" #include "../lv_hal/lv_hal.h"
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
@@ -109,6 +110,8 @@ void lv_init(void)
/*Init the input device handling*/ /*Init the input device handling*/
lv_indev_init(); lv_indev_init();
lv_img_decoder_init();
lv_initialized = true; lv_initialized = true;
LV_LOG_INFO("lv_init ready"); LV_LOG_INFO("lv_init ready");
} }

8
src/lv_core/lv_obj.h
View File

@@ -22,6 +22,7 @@ extern "C" {
#include <stddef.h> #include <stddef.h>
#include <stdbool.h> #include <stdbool.h>
#include "lv_style.h" #include "lv_style.h"
#include "../lv_misc/lv_types.h"
#include "../lv_misc/lv_area.h" #include "../lv_misc/lv_area.h"
#include "../lv_misc/lv_mem.h" #include "../lv_misc/lv_mem.h"
#include "../lv_misc/lv_ll.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, typedef bool (*lv_design_cb_t)(struct _lv_obj_t * obj, const lv_area_t * mask_p,
lv_design_mode_t mode); 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 { enum {
LV_EVENT_PRESSED, /*The object has been pressed*/ LV_EVENT_PRESSED, /*The object has been pressed*/
LV_EVENT_PRESSING, /*The object is being pressed (called continuously while pressing)*/ LV_EVENT_PRESSING, /*The object is being pressed (called continuously while pressing)*/

16
src/lv_draw/lv_draw.h
View File

@@ -21,30 +21,16 @@ extern "C" {
#include "../lv_core/lv_style.h" #include "../lv_core/lv_style.h"
#include "../lv_misc/lv_txt.h" #include "../lv_misc/lv_txt.h"
#include "../lv_misc/lv_img_decoder.h"
/********************* /*********************
* DEFINES * 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 * 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 * GLOBAL PROTOTYPES

14
src/lv_draw/lv_draw_img.c
View File

@@ -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_img_header_t header;
lv_res_t header_res; 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) { if(header_res != LV_RES_OK) {
LV_LOG_WARN("Image draw can't get image info"); LV_LOG_WARN("Image draw can't get image info");
lv_img_decoder_close();
return LV_RES_INV; return LV_RES_INV;
} }
bool chroma_keyed = lv_img_color_format_is_chroma_keyed(header.cf); bool chroma_keyed = lv_img_color_format_is_chroma_keyed(header.cf);
bool alpha_byte = lv_img_color_format_has_alpha(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) { if(img_data == LV_IMG_DECODER_OPEN_FAIL) {
LV_LOG_WARN("Image draw cannot open the image resource"); LV_LOG_WARN("Image draw cannot open the image resource");
lv_img_decoder_close(); lv_img_decoder_close(&dsc);
return LV_RES_INV; 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_coord_t row;
lv_res_t read_res; lv_res_t read_res;
for(row = mask_com.y1; row <= mask_com.y2; row++) { 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) { 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"); LV_LOG_WARN("Image draw can't read the line");
return LV_RES_INV; 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; return LV_RES_OK;
} }

8
src/lv_draw/lv_draw_img.h
View File

@@ -40,14 +40,6 @@ extern "C" {
void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, 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); 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 * Get the type of an image source
* @param src pointer to an image source: * @param src pointer to an image source:

563
src/lv_misc/lv_img_decoder.c
View File

@@ -7,7 +7,10 @@
* INCLUDES * INCLUDES
*********************/ *********************/
#include "lv_img_decoder.h" #include "lv_img_decoder.h"
#include "../lv_draw/lv_draw_img.h"
#include "lv_ll.h" #include "lv_ll.h"
#include "lv_color.h"
#include "lv_gc.h"
#if defined(LV_GC_INCLUDE) #if defined(LV_GC_INCLUDE)
#include LV_GC_INCLUDE #include LV_GC_INCLUDE
@@ -20,11 +23,29 @@
/********************** /**********************
* TYPEDEFS * TYPEDEFS
**********************/ **********************/
typedef struct {
lv_fs_file_t * f;
lv_color_t * palette;
}lv_img_decoder_built_in_data_t;
/********************** /**********************
* STATIC PROTOTYPES * 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 * STATIC VARIABLES
**********************/ **********************/
@@ -36,6 +57,7 @@
/********************** /**********************
* GLOBAL FUNCTIONS * GLOBAL FUNCTIONS
**********************/ **********************/
/** /**
* Initialize the image decoder module * 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_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*/ /*Create a decoder for the built in color format*/
decoder = lv_img_decoder_craete(); decoder = lv_img_decoder_create();
if(decoder) return; if(decoder == NULL) {
LV_LOG_WARN("lv_img_decoder_init: out of memory");
/*Create a decoder for Alpha indexed images*/ lv_mem_assert(decoder);
decoder = lv_img_decoder_craete(); return;
if(decoder) return; }
/*Create a decoder for color indexed images*/
decoder = lv_img_decoder_craete();
if(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; lv_img_decoder_t * decoder;
decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll)); decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
lv_mem_assert(decoder); lv_mem_assert(decoder);
if(decoder == NULL) return NULL;
memset(decoder, 0, sizeof(lv_img_decoder_t));
return decoder; 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) 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) 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)); 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; 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; return &decoder->user_data;
} }
lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header) lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
{ {
header->always_zero = 0; 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; return res;
} }
const uint8_t * lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style) 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->style = style;
dsc->src = src; dsc->src = src;
dsc->src_type = lv_img_src_get_type(src); dsc->src_type = lv_img_src_get_type(src);
dsc->user_data = NULL;
lv_res_t header_res; lv_res_t header_res;
header_res = lv_img_decoder_get_info(src, &dsc->header); 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; 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; 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); lv_img_src_t src_type = lv_img_src_get_type(src);
if(src_type == LV_IMG_SRC_VARIABLE) { if(src_type == LV_IMG_SRC_VARIABLE) {
header->w = ((lv_img_dsc_t *)src)->header.w; header->w = ((lv_img_dsc_t *)src)->header.w;
header->h = ((lv_img_dsc_t *)src)->header.h; header->h = ((lv_img_dsc_t *)src)->header.h;
header->cf = ((lv_img_dsc_t *)src)->header.cf; 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*/ /*Create a dummy header on fs error*/
if(res != LV_FS_RES_OK || rn != sizeof(lv_img_header_t)) { if(res != LV_FS_RES_OK || rn != sizeof(lv_img_header_t)) {
header->w = LV_DPI; header->w = LV_DPI;
header->h = LV_DPI; header->h = LV_DPI;
header->cf = LV_IMG_CF_UNKNOWN; 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");
return LV_RES_INV; 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*/ /*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 #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) { if(res != LV_FS_RES_OK) {
LV_LOG_WARN("Built-in image decoder can't open the file"); LV_LOG_WARN("Built-in image decoder can't open the file");
return LV_IMG_DECODER_OPEN_FAIL; 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 #else
LV_LOG_WARN("Image built-in decoder can read file because LV_USE_FILESYSTEM = 0"); LV_LOG_WARN("Image built-in decoder can read file because LV_USE_FILESYSTEM = 0");
return LV_IMG_DECODER_OPEN_FAIL; return LV_IMG_DECODER_OPEN_FAIL;
#endif #endif
} }
/*Process the different color formats*/ lv_img_cf_t cf = dsc->header.cf;
lv_img_cf_t cf = decoder_header.cf; /*Process true color formats*/
if(cf == LV_IMG_CF_TRUE_COLOR || cf == LV_IMG_CF_TRUE_COLOR_ALPHA || if(cf == LV_IMG_CF_TRUE_COLOR || cf == LV_IMG_CF_TRUE_COLOR_ALPHA ||
cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) { cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
if(decoder_src_type == LV_IMG_SRC_VARIABLE) { if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
/*In case of uncompressed formats if the image stored in the ROM/RAM simply give it's /* In case of uncompressed formats the image stored in the ROM/RAM.
* pointer*/ * So simply give its pointer*/
return ((lv_img_dsc_t *)decoder_src)->data; return ((lv_img_dsc_t *)dsc->src)->data;
} else { } 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; 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_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); uint8_t px_size = lv_img_color_format_get_px_size(cf);
uint32_t palette_size = 1 << px_size; 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*/ /*Read the palette from file*/
#if LV_USE_FILESYSTEM #if LV_USE_FILESYSTEM
lv_fs_seek(&decoder_file, 4); /*Skip the header*/ lv_fs_seek(user_data->f, 4); /*Skip the header*/
lv_fs_read(&decoder_file, palette_file, palette_size * sizeof(lv_color32_t), NULL); lv_fs_read(user_data->f, palette_tmp, palette_size * sizeof(lv_color_t), NULL);
palette_p = palette_file; palette_p = palette_tmp;
#else #else
LV_LOG_WARN( 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; return LV_IMG_DECODER_OPEN_FAIL;
#endif #endif
} else { } else {
/*The palette begins in the beginning of the image data. Just point to it.*/ /*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; uint32_t i;
for(i = 0; i < palette_size; i++) { for(i = 0; i < palette_size; i++) {
decoder_index_map[i] = user_data->palette[i] = lv_color_make(palette_p[i].ch.red, palette_p[i].ch.green, palette_p[i].ch.blue);
lv_color_make(palette_p[i].ch.red, palette_p[i].ch.green, palette_p[i].ch.blue);
} }
return NULL; return NULL;
#else #else
LV_LOG_WARN("Indexed (palette) images are not enabled in lv_conf.h. See LV_IMG_CF_INDEXED"); LV_LOG_WARN("Indexed (palette) images are not enabled in lv_conf.h. See LV_IMG_CF_INDEXED");
return LV_IMG_DECODER_OPEN_FAIL; return LV_IMG_DECODER_OPEN_FAIL;
#endif #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 #if LV_IMG_CF_ALPHA
return NULL; /*Nothing to process*/ return NULL; /*Nothing to process*/
#else #else
LV_LOG_WARN("Alpha indexed images are not enabled in lv_conf.h. See LV_IMG_CF_ALPHA"); LV_LOG_WARN("Alpha indexed images are not enabled in lv_conf.h. See LV_IMG_CF_ALPHA");
return LV_IMG_DECODER_OPEN_FAIL; return LV_IMG_DECODER_OPEN_FAIL;
#endif #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") LV_LOG_WARN("Image decoder open: unknown color format")
return LV_IMG_DECODER_OPEN_FAIL; 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(dsc->src_type == LV_IMG_SRC_FILE) {
#if LV_USE_FILESYSTEM if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR ||
uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf); 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 || return res;
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;
} }
static void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc) 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*/ lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
if(decoder_src) { if(user_data) {
#if LV_USE_FILESYSTEM if(user_data->f) lv_mem_free(user_data->f);
if(decoder_src_type == LV_IMG_SRC_FILE) { if(user_data->palette) lv_mem_free(user_data->palette);
lv_fs_close(&decoder_file);
} lv_mem_free(user_data);
#endif
decoder_src_type = LV_IMG_SRC_UNKNOWN; dsc->user_data = NULL;
decoder_src = 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, static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * dsc,
uint8_t * buf) 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 #if LV_IMG_CF_ALPHA
const lv_opa_t alpha1_opa_table[2] = { 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 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*/ const lv_opa_t alpha4_opa_table[16] = {0, 17, 34, 51, /*Opacity mapping with bpp = 4*/
68, 85, 102, 119, 136, 153, 68, 85, 102, 119, 136, 153,
170, 187, 204, 221, 238, 255}; 170, 187, 204, 221, 238, 255};
/*Simply fill the buffer with the color. Later only the alpha value will be modified.*/ /*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; lv_coord_t i;
for(i = 0; i < len; i++) { for(i = 0; i < len; i++) {
#if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1 #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; 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*/ uint16_t mask = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
lv_coord_t w = 0; lv_coord_t w = 0;
uint32_t ofs = 0; uint32_t ofs = 0;
int8_t pos = 0; int8_t pos = 0;
switch(decoder_header.cf) { switch(dsc->header.cf) {
case LV_IMG_CF_ALPHA_1BIT: case LV_IMG_CF_ALPHA_1BIT:
w = (decoder_header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/ w = (dsc->header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/
if(decoder_header.w & 0x7) w++; if(dsc->header.w & 0x7) w++;
ofs += w * y + (x >> 3); /*First pixel*/ ofs += w * y + (x >> 3); /*First pixel*/
pos = 7 - (x & 0x7); pos = 7 - (x & 0x7);
opa_table = alpha1_opa_table; opa_table = alpha1_opa_table;
break; break;
case LV_IMG_CF_ALPHA_2BIT: case LV_IMG_CF_ALPHA_2BIT:
w = (decoder_header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/ w = (dsc->header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/
if(decoder_header.w & 0x3) w++; if(dsc->header.w & 0x3) w++;
ofs += w * y + (x >> 2); /*First pixel*/ ofs += w * y + (x >> 2); /*First pixel*/
pos = 6 - ((x & 0x3) * 2); pos = 6 - ((x & 0x3) * 2);
opa_table = alpha2_opa_table; opa_table = alpha2_opa_table;
break; break;
case LV_IMG_CF_ALPHA_4BIT: case LV_IMG_CF_ALPHA_4BIT:
w = (decoder_header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/ w = (dsc->header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/
if(decoder_header.w & 0x1) w++; if(dsc->header.w & 0x1) w++;
ofs += w * y + (x >> 1); /*First pixel*/ ofs += w * y + (x >> 1); /*First pixel*/
pos = 4 - ((x & 0x1) * 4); pos = 4 - ((x & 0x1) * 4);
opa_table = alpha4_opa_table; opa_table = alpha4_opa_table;
break; break;
case LV_IMG_CF_ALPHA_8BIT: case LV_IMG_CF_ALPHA_8BIT:
w = decoder_header.w; /*E.g. x = 7 -> w = 7 (bytes)*/ w = dsc->header.w; /*E.g. x = 7 -> w = 7 (bytes)*/
ofs += w * y + x; /*First pixel*/ ofs += w * y + x; /*First pixel*/
pos = 0; pos = 0;
break; break;
} }
#if LV_USE_FILESYSTEM #if LV_USE_FILESYSTEM
lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
#if LV_COMPILER_VLA_SUPPORTED #if LV_COMPILER_VLA_SUPPORTED
uint8_t fs_buf[w]; uint8_t fs_buf[w];
#else #else
@@ -451,17 +512,17 @@ static lv_res_t lv_img_built_in_decoder_line_alpha(lv_img_decoder_t * decoder, l
#endif #endif
#endif #endif
const uint8_t * data_tmp = NULL; const uint8_t * data_tmp = NULL;
if(decoder_src_type == LV_IMG_SRC_VARIABLE) { if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
const lv_img_dsc_t * img_dsc = decoder_src; const lv_img_dsc_t * img_dsc = dsc->src;
data_tmp = img_dsc->data + ofs; data_tmp = img_dsc->data + ofs;
} else { } else {
#if LV_USE_FILESYSTEM #if LV_USE_FILESYSTEM
lv_fs_seek(&decoder_file, ofs + 4); /*+4 to skip the header*/ lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/
lv_fs_read(&decoder_file, fs_buf, w, NULL); lv_fs_read(user_data->f, fs_buf, w, NULL);
data_tmp = fs_buf; data_tmp = fs_buf;
#else #else
LV_LOG_WARN( LV_LOG_WARN( "Image built-in alpha line reader can't read file because LV_USE_FILESYSTEM = 0");
"Image built-in alpha line reader can't read file because LV_USE_FILESYSTEM = 0");
data_tmp = NULL; /*To avoid warnings*/ data_tmp = NULL; /*To avoid warnings*/
return LV_RES_INV; return LV_RES_INV;
#endif #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; val_act = (data_tmp[byte_act] & (mask << pos)) >> pos;
buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE + LV_IMG_PX_SIZE_ALPHA_BYTE - 1] = 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; pos -= px_size;
if(pos < 0) { 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 #else
LV_LOG_WARN( 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; return LV_RES_INV;
#endif #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, 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) uint8_t * buf)
{ {
#if LV_IMG_CF_INDEXED #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*/ uint16_t mask = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
lv_coord_t w = 0; lv_coord_t w = 0;
int8_t pos = 0; int8_t pos = 0;
uint32_t ofs = 0; uint32_t ofs = 0;
switch(decoder_header.cf) { switch(dsc->header.cf) {
case LV_IMG_CF_INDEXED_1BIT: case LV_IMG_CF_INDEXED_1BIT:
w = (decoder_header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/ w = (dsc->header.w >> 3); /*E.g. w = 20 -> w = 2 + 1*/
if(decoder_header.w & 0x7) w++; if(dsc->header.w & 0x7) w++;
ofs += w * y + (x >> 3); /*First pixel*/ ofs += w * y + (x >> 3); /*First pixel*/
ofs += 8; /*Skip the palette*/ ofs += 8; /*Skip the palette*/
pos = 7 - (x & 0x7); pos = 7 - (x & 0x7);
break; break;
case LV_IMG_CF_INDEXED_2BIT: case LV_IMG_CF_INDEXED_2BIT:
w = (decoder_header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/ w = (dsc->header.w >> 2); /*E.g. w = 13 -> w = 3 + 1 (bytes)*/
if(decoder_header.w & 0x3) w++; if(dsc->header.w & 0x3) w++;
ofs += w * y + (x >> 2); /*First pixel*/ ofs += w * y + (x >> 2); /*First pixel*/
ofs += 16; /*Skip the palette*/ ofs += 16; /*Skip the palette*/
pos = 6 - ((x & 0x3) * 2); pos = 6 - ((x & 0x3) * 2);
break; break;
case LV_IMG_CF_INDEXED_4BIT: case LV_IMG_CF_INDEXED_4BIT:
w = (decoder_header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/ w = (dsc->header.w >> 1); /*E.g. w = 13 -> w = 6 + 1 (bytes)*/
if(decoder_header.w & 0x1) w++; if(dsc->header.w & 0x1) w++;
ofs += w * y + (x >> 1); /*First pixel*/ ofs += w * y + (x >> 1); /*First pixel*/
ofs += 64; /*Skip the palette*/ ofs += 64; /*Skip the palette*/
pos = 4 - ((x & 0x1) * 4); pos = 4 - ((x & 0x1) * 4);
break; break;
case LV_IMG_CF_INDEXED_8BIT: case LV_IMG_CF_INDEXED_8BIT:
w = decoder_header.w; /*E.g. x = 7 -> w = 7 (bytes)*/ w = dsc->header.w; /*E.g. x = 7 -> w = 7 (bytes)*/
ofs += w * y + x; /*First pixel*/ ofs += w * y + x; /*First pixel*/
ofs += 1024; /*Skip the palette*/ ofs += 1024; /*Skip the palette*/
pos = 0; pos = 0;
break; break;
} }
lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
#if LV_USE_FILESYSTEM #if LV_USE_FILESYSTEM
#if LV_COMPILER_VLA_SUPPORTED #if LV_COMPILER_VLA_SUPPORTED
uint8_t fs_buf[w]; 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
#endif #endif
const uint8_t * data_tmp = NULL; const uint8_t * data_tmp = NULL;
if(decoder_src_type == LV_IMG_SRC_VARIABLE) { if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
const lv_img_dsc_t * img_dsc = decoder_src; const lv_img_dsc_t * img_dsc = dsc->src;
data_tmp = img_dsc->data + ofs; data_tmp = img_dsc->data + ofs;
} else { } else {
#if LV_USE_FILESYSTEM #if LV_USE_FILESYSTEM
lv_fs_seek(&decoder_file, ofs + 4); /*+4 to skip the header*/ lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/
lv_fs_read(&decoder_file, fs_buf, w, NULL); lv_fs_read(user_data->f, fs_buf, w, NULL);
data_tmp = fs_buf; data_tmp = fs_buf;
#else #else
LV_LOG_WARN( 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*/ data_tmp = NULL; /*To avoid warnings*/
return LV_RES_INV; return LV_RES_INV;
#endif #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; lv_color_t * cbuf = (lv_color_t *)buf;
for(i = 0; i < len; i++) { for(i = 0; i < len; i++) {
val_act = (data_tmp[byte_act] & (mask << pos)) >> pos; 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; pos -= px_size;
if(pos < 0) { 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; return LV_RES_OK;
#else #else
LV_LOG_WARN( 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; return LV_RES_INV;
#endif #endif
} }
/**********************
* STATIC FUNCTIONS
**********************/

56
src/lv_misc/lv_img_decoder.h
View File

@@ -21,15 +21,38 @@ extern "C" {
#include <stdint.h> #include <stdint.h>
#include "lv_fs.h" #include "lv_fs.h"
#include "lv_types.h"
#include "lv_area.h"
#include "../lv_core/lv_style.h"
/********************* /*********************
* DEFINES * 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 * 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 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 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_info_f_t info_cb;
lv_img_decoder_open_f_t open_cb; lv_img_decoder_open_f_t open_cb;
lv_img_decoder_read_line_f_t read_line_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; }lv_img_decoder_t;
typedef struct { typedef struct _lv_img_decoder_dsc {
lv_img_decoder_t * decoder; lv_img_decoder_t * decoder;
const lv_style_t * style; const lv_style_t * style;
const void * src; const void * src;
@@ -154,6 +177,33 @@ typedef struct {
* GLOBAL PROTOTYPES * 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 * MACROS
**********************/ **********************/

44
src/lv_misc/lv_types.h Normal file
View File

@@ -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*/

3
src/lv_objx/lv_img.c
View File

@@ -15,6 +15,7 @@
#endif #endif
#include "../lv_themes/lv_theme.h" #include "../lv_themes/lv_theme.h"
#include "../lv_misc/lv_img_decoder.h"
#include "../lv_misc/lv_fs.h" #include "../lv_misc/lv_fs.h"
#include "../lv_misc/lv_txt.h" #include "../lv_misc/lv_txt.h"
#include "../lv_misc/lv_log.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_header_t header;
lv_img_dsc_get_info(src_img, &header); lv_img_decoder_get_info(src_img, &header);
/*Save the source*/ /*Save the source*/
if(src_type == LV_IMG_SRC_VARIABLE) { if(src_type == LV_IMG_SRC_VARIABLE) {

2
src/lv_objx/lv_imgbtn.c
View File

@@ -375,7 +375,7 @@ static void refr_img(lv_obj_t * imgbtn)
#endif #endif
lv_res_t info_res; 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) { if(info_res == LV_RES_OK) {
ext->act_cf = header.cf; ext->act_cf = header.cf;
#if LV_IMGBTN_TILED == 0 #if LV_IMGBTN_TILED == 0