Umstrukuriert/windows-app hinzugefügt
This commit is contained in:
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* @file lv_bmp.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_BMP
|
||||
|
||||
#include <string.h>
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
typedef struct {
|
||||
lv_fs_file_t f;
|
||||
unsigned int px_offset;
|
||||
int px_width;
|
||||
int px_height;
|
||||
unsigned int bpp;
|
||||
int row_size_bytes;
|
||||
} bmp_dsc_t;
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header);
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
|
||||
|
||||
static lv_res_t 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);
|
||||
|
||||
static void decoder_close(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
void lv_bmp_init(void)
|
||||
{
|
||||
lv_img_decoder_t * dec = lv_img_decoder_create();
|
||||
lv_img_decoder_set_info_cb(dec, decoder_info);
|
||||
lv_img_decoder_set_open_cb(dec, decoder_open);
|
||||
lv_img_decoder_set_read_line_cb(dec, decoder_read_line);
|
||||
lv_img_decoder_set_close_cb(dec, decoder_close);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Get info about a PNG image
|
||||
* @param src can be file name or pointer to a C array
|
||||
* @param header store the info here
|
||||
* @return LV_RES_OK: no error; LV_RES_INV: can't get the info
|
||||
*/
|
||||
static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)
|
||||
{
|
||||
LV_UNUSED(decoder);
|
||||
|
||||
lv_img_src_t src_type = lv_img_src_get_type(src); /*Get the source type*/
|
||||
|
||||
/*If it's a BMP file...*/
|
||||
if(src_type == LV_IMG_SRC_FILE) {
|
||||
const char * fn = src;
|
||||
if(strcmp(lv_fs_get_ext(fn), "bmp") == 0) { /*Check the extension*/
|
||||
/*Save the data in the header*/
|
||||
lv_fs_file_t f;
|
||||
lv_fs_res_t res = lv_fs_open(&f, src, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) return LV_RES_INV;
|
||||
uint8_t headers[54];
|
||||
|
||||
lv_fs_read(&f, headers, 54, NULL);
|
||||
uint32_t w;
|
||||
uint32_t h;
|
||||
memcpy(&w, headers + 18, 4);
|
||||
memcpy(&h, headers + 22, 4);
|
||||
header->w = w;
|
||||
header->h = h;
|
||||
header->always_zero = 0;
|
||||
lv_fs_close(&f);
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
uint16_t bpp;
|
||||
memcpy(&bpp, headers + 28, 2);
|
||||
header->cf = bpp == 32 ? LV_IMG_CF_TRUE_COLOR_ALPHA : LV_IMG_CF_TRUE_COLOR;
|
||||
#else
|
||||
header->cf = LV_IMG_CF_TRUE_COLOR;
|
||||
#endif
|
||||
return LV_RES_OK;
|
||||
}
|
||||
}
|
||||
/* BMP file as data not supported for simplicity.
|
||||
* Convert them to LVGL compatible C arrays directly. */
|
||||
else if(src_type == LV_IMG_SRC_VARIABLE) {
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
return LV_RES_INV; /*If didn't succeeded earlier then it's an error*/
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a PNG image and return the decided image
|
||||
* @param src can be file name or pointer to a C array
|
||||
* @param style style of the image object (unused now but certain formats might use it)
|
||||
* @return pointer to the decoded image or `LV_IMG_DECODER_OPEN_FAIL` if failed
|
||||
*/
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
LV_UNUSED(decoder);
|
||||
|
||||
/*If it's a PNG file...*/
|
||||
if(dsc->src_type == LV_IMG_SRC_FILE) {
|
||||
const char * fn = dsc->src;
|
||||
|
||||
if(strcmp(lv_fs_get_ext(fn), "bmp") != 0) {
|
||||
return LV_RES_INV; /*Check the extension*/
|
||||
}
|
||||
|
||||
bmp_dsc_t b;
|
||||
memset(&b, 0x00, sizeof(b));
|
||||
|
||||
lv_fs_res_t res = lv_fs_open(&b.f, dsc->src, LV_FS_MODE_RD);
|
||||
if(res == LV_RES_OK) return LV_RES_INV;
|
||||
|
||||
uint8_t header[54];
|
||||
lv_fs_read(&b.f, header, 54, NULL);
|
||||
|
||||
if(0x42 != header[0] || 0x4d != header[1]) {
|
||||
lv_fs_close(&b.f);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
memcpy(&b.px_offset, header + 10, 4);
|
||||
memcpy(&b.px_width, header + 18, 4);
|
||||
memcpy(&b.px_height, header + 22, 4);
|
||||
memcpy(&b.bpp, header + 28, 2);
|
||||
b.row_size_bytes = ((b.bpp * b.px_width + 31) / 32) * 4;
|
||||
|
||||
bool color_depth_error = false;
|
||||
if(LV_COLOR_DEPTH == 32 && (b.bpp != 32 && b.bpp != 24)) {
|
||||
LV_LOG_WARN("LV_COLOR_DEPTH == 32 but bpp is %d (should be 32 or 24)", b.bpp);
|
||||
color_depth_error = true;
|
||||
}
|
||||
else if(LV_COLOR_DEPTH == 16 && b.bpp != 16) {
|
||||
LV_LOG_WARN("LV_COLOR_DEPTH == 16 but bpp is %d (should be 16)", b.bpp);
|
||||
color_depth_error = true;
|
||||
}
|
||||
else if(LV_COLOR_DEPTH == 8 && b.bpp != 8) {
|
||||
LV_LOG_WARN("LV_COLOR_DEPTH == 8 but bpp is %d (should be 8)", b.bpp);
|
||||
color_depth_error = true;
|
||||
}
|
||||
|
||||
if(color_depth_error) {
|
||||
dsc->error_msg = "Color depth mismatch";
|
||||
lv_fs_close(&b.f);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
dsc->user_data = lv_mem_alloc(sizeof(bmp_dsc_t));
|
||||
LV_ASSERT_MALLOC(dsc->user_data);
|
||||
if(dsc->user_data == NULL) return LV_RES_INV;
|
||||
memcpy(dsc->user_data, &b, sizeof(b));
|
||||
|
||||
dsc->img_data = NULL;
|
||||
return LV_RES_OK;
|
||||
}
|
||||
/* BMP file as data not supported for simplicity.
|
||||
* Convert them to LVGL compatible C arrays directly. */
|
||||
else if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
return LV_RES_INV; /*If not returned earlier then it failed*/
|
||||
}
|
||||
|
||||
static lv_res_t 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_UNUSED(decoder);
|
||||
|
||||
bmp_dsc_t * b = dsc->user_data;
|
||||
y = (b->px_height - 1) - y; /*BMP images are stored upside down*/
|
||||
uint32_t p = b->px_offset + b->row_size_bytes * y;
|
||||
p += x * (b->bpp / 8);
|
||||
lv_fs_seek(&b->f, p, LV_FS_SEEK_SET);
|
||||
lv_fs_read(&b->f, buf, len * (b->bpp / 8), NULL);
|
||||
|
||||
#if LV_COLOR_DEPTH == 16 && LV_COLOR_16_SWAP == 1
|
||||
for(unsigned int i = 0; i < len * (b->bpp / 8); i += 2) {
|
||||
buf[i] = buf[i] ^ buf[i + 1];
|
||||
buf[i + 1] = buf[i] ^ buf[i + 1];
|
||||
buf[i] = buf[i] ^ buf[i + 1];
|
||||
}
|
||||
|
||||
#elif LV_COLOR_DEPTH == 32
|
||||
if(b->bpp == 32) {
|
||||
lv_coord_t i;
|
||||
for(i = 0; i < len; i++) {
|
||||
uint8_t b0 = buf[i * 4];
|
||||
uint8_t b1 = buf[i * 4 + 1];
|
||||
uint8_t b2 = buf[i * 4 + 2];
|
||||
uint8_t b3 = buf[i * 4 + 3];
|
||||
lv_color32_t * c = (lv_color32_t *)&buf[i * 4];
|
||||
c->ch.red = b2;
|
||||
c->ch.green = b1;
|
||||
c->ch.blue = b0;
|
||||
c->ch.alpha = b3;
|
||||
}
|
||||
}
|
||||
if(b->bpp == 24) {
|
||||
lv_coord_t i;
|
||||
|
||||
for(i = len - 1; i >= 0; i--) {
|
||||
uint8_t * t = &buf[i * 3];
|
||||
lv_color32_t * c = (lv_color32_t *)&buf[i * 4];
|
||||
c->ch.red = t[2];
|
||||
c->ch.green = t[1];
|
||||
c->ch.blue = t[0];
|
||||
c->ch.alpha = 0xff;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return LV_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free the allocated resources
|
||||
*/
|
||||
static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
LV_UNUSED(decoder);
|
||||
bmp_dsc_t * b = dsc->user_data;
|
||||
lv_fs_close(&b->f);
|
||||
lv_mem_free(dsc->user_data);
|
||||
|
||||
}
|
||||
|
||||
#endif /*LV_USE_BMP*/
|
||||
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* @file lv_bmp.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_BMP_H
|
||||
#define LV_BMP_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lv_conf_internal.h"
|
||||
#if LV_USE_BMP
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
void lv_bmp_init(void);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_BMP*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /*LV_BMP_H*/
|
||||
@@ -0,0 +1,875 @@
|
||||
/**
|
||||
* @file lv_ffmpeg.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "lv_ffmpeg.h"
|
||||
#if LV_USE_FFMPEG != 0
|
||||
|
||||
#include <libavcodec/avcodec.h>
|
||||
#include <libavformat/avformat.h>
|
||||
#include <libavutil/imgutils.h>
|
||||
#include <libavutil/samplefmt.h>
|
||||
#include <libavutil/timestamp.h>
|
||||
#include <libswscale/swscale.h>
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8
|
||||
#define AV_PIX_FMT_TRUE_COLOR AV_PIX_FMT_RGB8
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
#if LV_COLOR_16_SWAP == 0
|
||||
#define AV_PIX_FMT_TRUE_COLOR AV_PIX_FMT_RGB565LE
|
||||
#else
|
||||
#define AV_PIX_FMT_TRUE_COLOR AV_PIX_FMT_RGB565BE
|
||||
#endif
|
||||
#elif LV_COLOR_DEPTH == 32
|
||||
#define AV_PIX_FMT_TRUE_COLOR AV_PIX_FMT_BGR0
|
||||
#else
|
||||
#error Unsupported LV_COLOR_DEPTH
|
||||
#endif
|
||||
|
||||
#define MY_CLASS &lv_ffmpeg_player_class
|
||||
|
||||
#define FRAME_DEF_REFR_PERIOD 33 /*[ms]*/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
struct ffmpeg_context_s {
|
||||
AVFormatContext * fmt_ctx;
|
||||
AVCodecContext * video_dec_ctx;
|
||||
AVStream * video_stream;
|
||||
uint8_t * video_src_data[4];
|
||||
uint8_t * video_dst_data[4];
|
||||
struct SwsContext * sws_ctx;
|
||||
AVFrame * frame;
|
||||
AVPacket pkt;
|
||||
int video_stream_idx;
|
||||
int video_src_linesize[4];
|
||||
int video_dst_linesize[4];
|
||||
enum AVPixelFormat video_dst_pix_fmt;
|
||||
bool has_alpha;
|
||||
};
|
||||
|
||||
#pragma pack(1)
|
||||
|
||||
struct lv_img_pixel_color_s {
|
||||
lv_color_t c;
|
||||
uint8_t alpha;
|
||||
};
|
||||
|
||||
#pragma pack()
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
|
||||
static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header);
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
|
||||
static void decoder_close(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
|
||||
|
||||
static struct ffmpeg_context_s * ffmpeg_open_file(const char * path);
|
||||
static void ffmpeg_close(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static void ffmpeg_close_src_ctx(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static void ffmpeg_close_dst_ctx(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static int ffmpeg_image_allocate(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static int ffmpeg_get_img_header(const char * path, lv_img_header_t * header);
|
||||
static int ffmpeg_get_frame_refr_period(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static uint8_t * ffmpeg_get_img_data(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static int ffmpeg_update_next_frame(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static int ffmpeg_output_video_frame(struct ffmpeg_context_s * ffmpeg_ctx);
|
||||
static bool ffmpeg_pix_fmt_has_alpha(enum AVPixelFormat pix_fmt);
|
||||
static bool ffmpeg_pix_fmt_is_yuv(enum AVPixelFormat pix_fmt);
|
||||
|
||||
static void lv_ffmpeg_player_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
static void lv_ffmpeg_player_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
|
||||
#if LV_COLOR_DEPTH != 32
|
||||
static void convert_color_depth(uint8_t * img, uint32_t px_cnt);
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
const lv_obj_class_t lv_ffmpeg_player_class = {
|
||||
.constructor_cb = lv_ffmpeg_player_constructor,
|
||||
.destructor_cb = lv_ffmpeg_player_destructor,
|
||||
.instance_size = sizeof(lv_ffmpeg_player_t),
|
||||
.base_class = &lv_img_class
|
||||
};
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
void lv_ffmpeg_init(void)
|
||||
{
|
||||
lv_img_decoder_t * dec = lv_img_decoder_create();
|
||||
lv_img_decoder_set_info_cb(dec, decoder_info);
|
||||
lv_img_decoder_set_open_cb(dec, decoder_open);
|
||||
lv_img_decoder_set_close_cb(dec, decoder_close);
|
||||
|
||||
#if LV_FFMPEG_AV_DUMP_FORMAT == 0
|
||||
av_log_set_level(AV_LOG_QUIET);
|
||||
#endif
|
||||
}
|
||||
|
||||
int lv_ffmpeg_get_frame_num(const char * path)
|
||||
{
|
||||
int ret = -1;
|
||||
struct ffmpeg_context_s * ffmpeg_ctx = ffmpeg_open_file(path);
|
||||
|
||||
if(ffmpeg_ctx) {
|
||||
ret = ffmpeg_ctx->video_stream->nb_frames;
|
||||
ffmpeg_close(ffmpeg_ctx);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
lv_obj_t * lv_ffmpeg_player_create(lv_obj_t * parent)
|
||||
{
|
||||
lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
|
||||
lv_obj_class_init_obj(obj);
|
||||
return obj;
|
||||
}
|
||||
|
||||
lv_res_t lv_ffmpeg_player_set_src(lv_obj_t * obj, const char * path)
|
||||
{
|
||||
LV_ASSERT_OBJ(obj, MY_CLASS);
|
||||
lv_res_t res = LV_RES_INV;
|
||||
|
||||
lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
|
||||
|
||||
if(player->ffmpeg_ctx) {
|
||||
ffmpeg_close(player->ffmpeg_ctx);
|
||||
player->ffmpeg_ctx = NULL;
|
||||
}
|
||||
|
||||
lv_timer_pause(player->timer);
|
||||
|
||||
player->ffmpeg_ctx = ffmpeg_open_file(path);
|
||||
|
||||
if(!player->ffmpeg_ctx) {
|
||||
LV_LOG_ERROR("ffmpeg file open failed: %s", path);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if(ffmpeg_image_allocate(player->ffmpeg_ctx) < 0) {
|
||||
LV_LOG_ERROR("ffmpeg image allocate failed");
|
||||
ffmpeg_close(player->ffmpeg_ctx);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
bool has_alpha = player->ffmpeg_ctx->has_alpha;
|
||||
int width = player->ffmpeg_ctx->video_dec_ctx->width;
|
||||
int height = player->ffmpeg_ctx->video_dec_ctx->height;
|
||||
uint32_t data_size = 0;
|
||||
|
||||
if(has_alpha) {
|
||||
data_size = width * height * LV_IMG_PX_SIZE_ALPHA_BYTE;
|
||||
}
|
||||
else {
|
||||
data_size = width * height * LV_COLOR_SIZE / 8;
|
||||
}
|
||||
|
||||
player->imgdsc.header.always_zero = 0;
|
||||
player->imgdsc.header.w = width;
|
||||
player->imgdsc.header.h = height;
|
||||
player->imgdsc.data_size = data_size;
|
||||
player->imgdsc.header.cf = has_alpha ? LV_IMG_CF_TRUE_COLOR_ALPHA : LV_IMG_CF_TRUE_COLOR;
|
||||
player->imgdsc.data = ffmpeg_get_img_data(player->ffmpeg_ctx);
|
||||
|
||||
lv_img_set_src(&player->img.obj, &(player->imgdsc));
|
||||
|
||||
int period = ffmpeg_get_frame_refr_period(player->ffmpeg_ctx);
|
||||
|
||||
if(period > 0) {
|
||||
LV_LOG_INFO("frame refresh period = %d ms, rate = %d fps",
|
||||
period, 1000 / period);
|
||||
lv_timer_set_period(player->timer, period);
|
||||
}
|
||||
else {
|
||||
LV_LOG_WARN("unable to get frame refresh period");
|
||||
}
|
||||
|
||||
res = LV_RES_OK;
|
||||
|
||||
failed:
|
||||
return res;
|
||||
}
|
||||
|
||||
void lv_ffmpeg_player_set_cmd(lv_obj_t * obj, lv_ffmpeg_player_cmd_t cmd)
|
||||
{
|
||||
LV_ASSERT_OBJ(obj, MY_CLASS);
|
||||
lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
|
||||
|
||||
if(!player->ffmpeg_ctx) {
|
||||
LV_LOG_ERROR("ffmpeg_ctx is NULL");
|
||||
return;
|
||||
}
|
||||
|
||||
lv_timer_t * timer = player->timer;
|
||||
|
||||
switch(cmd) {
|
||||
case LV_FFMPEG_PLAYER_CMD_START:
|
||||
av_seek_frame(player->ffmpeg_ctx->fmt_ctx,
|
||||
0, 0, AVSEEK_FLAG_BACKWARD);
|
||||
lv_timer_resume(timer);
|
||||
LV_LOG_INFO("ffmpeg player start");
|
||||
break;
|
||||
case LV_FFMPEG_PLAYER_CMD_STOP:
|
||||
av_seek_frame(player->ffmpeg_ctx->fmt_ctx,
|
||||
0, 0, AVSEEK_FLAG_BACKWARD);
|
||||
lv_timer_pause(timer);
|
||||
LV_LOG_INFO("ffmpeg player stop");
|
||||
break;
|
||||
case LV_FFMPEG_PLAYER_CMD_PAUSE:
|
||||
lv_timer_pause(timer);
|
||||
LV_LOG_INFO("ffmpeg player pause");
|
||||
break;
|
||||
case LV_FFMPEG_PLAYER_CMD_RESUME:
|
||||
lv_timer_resume(timer);
|
||||
LV_LOG_INFO("ffmpeg player resume");
|
||||
break;
|
||||
default:
|
||||
LV_LOG_ERROR("Error cmd: %d", cmd);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void lv_ffmpeg_player_set_auto_restart(lv_obj_t * obj, bool en)
|
||||
{
|
||||
LV_ASSERT_OBJ(obj, MY_CLASS);
|
||||
lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
|
||||
player->auto_restart = en;
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)
|
||||
{
|
||||
/* Get the source type */
|
||||
lv_img_src_t src_type = lv_img_src_get_type(src);
|
||||
|
||||
if(src_type == LV_IMG_SRC_FILE) {
|
||||
const char * fn = src;
|
||||
|
||||
if(ffmpeg_get_img_header(fn, header) < 0) {
|
||||
LV_LOG_ERROR("ffmpeg can't get image header");
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
return LV_RES_OK;
|
||||
}
|
||||
|
||||
/* If didn't succeeded earlier then it's an error */
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
if(dsc->src_type == LV_IMG_SRC_FILE) {
|
||||
const char * path = dsc->src;
|
||||
|
||||
struct ffmpeg_context_s * ffmpeg_ctx = ffmpeg_open_file(path);
|
||||
|
||||
if(ffmpeg_ctx == NULL) {
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
if(ffmpeg_image_allocate(ffmpeg_ctx) < 0) {
|
||||
LV_LOG_ERROR("ffmpeg image allocate failed");
|
||||
ffmpeg_close(ffmpeg_ctx);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
if(ffmpeg_update_next_frame(ffmpeg_ctx) < 0) {
|
||||
ffmpeg_close(ffmpeg_ctx);
|
||||
LV_LOG_ERROR("ffmpeg update frame failed");
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
ffmpeg_close_src_ctx(ffmpeg_ctx);
|
||||
uint8_t * img_data = ffmpeg_get_img_data(ffmpeg_ctx);
|
||||
|
||||
#if LV_COLOR_DEPTH != 32
|
||||
if(ffmpeg_ctx->has_alpha) {
|
||||
convert_color_depth(img_data, dsc->header.w * dsc->header.h);
|
||||
}
|
||||
#endif
|
||||
|
||||
dsc->user_data = ffmpeg_ctx;
|
||||
dsc->img_data = img_data;
|
||||
|
||||
/* The image is fully decoded. Return with its pointer */
|
||||
return LV_RES_OK;
|
||||
}
|
||||
|
||||
/* If not returned earlier then it failed */
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
struct ffmpeg_context_s * ffmpeg_ctx = dsc->user_data;
|
||||
ffmpeg_close(ffmpeg_ctx);
|
||||
}
|
||||
|
||||
#if LV_COLOR_DEPTH != 32
|
||||
|
||||
static void convert_color_depth(uint8_t * img, uint32_t px_cnt)
|
||||
{
|
||||
lv_color32_t * img_src_p = (lv_color32_t *)img;
|
||||
struct lv_img_pixel_color_s * img_dst_p = (struct lv_img_pixel_color_s *)img;
|
||||
|
||||
for(uint32_t i = 0; i < px_cnt; i++) {
|
||||
lv_color32_t temp = *img_src_p;
|
||||
img_dst_p->c = lv_color_hex(temp.full);
|
||||
img_dst_p->alpha = temp.ch.alpha;
|
||||
|
||||
img_src_p++;
|
||||
img_dst_p++;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static uint8_t * ffmpeg_get_img_data(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
uint8_t * img_data = ffmpeg_ctx->video_dst_data[0];
|
||||
|
||||
if(img_data == NULL) {
|
||||
LV_LOG_ERROR("ffmpeg video dst data is NULL");
|
||||
}
|
||||
|
||||
return img_data;
|
||||
}
|
||||
|
||||
static bool ffmpeg_pix_fmt_has_alpha(enum AVPixelFormat pix_fmt)
|
||||
{
|
||||
const AVPixFmtDescriptor * desc = av_pix_fmt_desc_get(pix_fmt);
|
||||
|
||||
if(desc == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if(pix_fmt == AV_PIX_FMT_PAL8) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return (desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? true : false;
|
||||
}
|
||||
|
||||
static bool ffmpeg_pix_fmt_is_yuv(enum AVPixelFormat pix_fmt)
|
||||
{
|
||||
const AVPixFmtDescriptor * desc = av_pix_fmt_desc_get(pix_fmt);
|
||||
|
||||
if(desc == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
|
||||
}
|
||||
|
||||
static int ffmpeg_output_video_frame(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
int ret = -1;
|
||||
|
||||
int width = ffmpeg_ctx->video_dec_ctx->width;
|
||||
int height = ffmpeg_ctx->video_dec_ctx->height;
|
||||
AVFrame * frame = ffmpeg_ctx->frame;
|
||||
|
||||
if(frame->width != width
|
||||
|| frame->height != height
|
||||
|| frame->format != ffmpeg_ctx->video_dec_ctx->pix_fmt) {
|
||||
|
||||
/* To handle this change, one could call av_image_alloc again and
|
||||
* decode the following frames into another rawvideo file.
|
||||
*/
|
||||
LV_LOG_ERROR("Width, height and pixel format have to be "
|
||||
"constant in a rawvideo file, but the width, height or "
|
||||
"pixel format of the input video changed:\n"
|
||||
"old: width = %d, height = %d, format = %s\n"
|
||||
"new: width = %d, height = %d, format = %s\n",
|
||||
width,
|
||||
height,
|
||||
av_get_pix_fmt_name(ffmpeg_ctx->video_dec_ctx->pix_fmt),
|
||||
frame->width, frame->height,
|
||||
av_get_pix_fmt_name(frame->format));
|
||||
goto failed;
|
||||
}
|
||||
|
||||
LV_LOG_TRACE("video_frame coded_n:%d", frame->coded_picture_number);
|
||||
|
||||
/* copy decoded frame to destination buffer:
|
||||
* this is required since rawvideo expects non aligned data
|
||||
*/
|
||||
av_image_copy(ffmpeg_ctx->video_src_data, ffmpeg_ctx->video_src_linesize,
|
||||
(const uint8_t **)(frame->data), frame->linesize,
|
||||
ffmpeg_ctx->video_dec_ctx->pix_fmt, width, height);
|
||||
|
||||
if(ffmpeg_ctx->sws_ctx == NULL) {
|
||||
int swsFlags = SWS_BILINEAR;
|
||||
|
||||
if(ffmpeg_pix_fmt_is_yuv(ffmpeg_ctx->video_dec_ctx->pix_fmt)) {
|
||||
|
||||
/* When the video width and height are not multiples of 8,
|
||||
* and there is no size change in the conversion,
|
||||
* a blurry screen will appear on the right side
|
||||
* This problem was discovered in 2012 and
|
||||
* continues to exist in version 4.1.3 in 2019
|
||||
* This problem can be avoided by increasing SWS_ACCURATE_RND
|
||||
*/
|
||||
if((width & 0x7) || (height & 0x7)) {
|
||||
LV_LOG_WARN("The width(%d) and height(%d) the image "
|
||||
"is not a multiple of 8, "
|
||||
"the decoding speed may be reduced",
|
||||
width, height);
|
||||
swsFlags |= SWS_ACCURATE_RND;
|
||||
}
|
||||
}
|
||||
|
||||
ffmpeg_ctx->sws_ctx = sws_getContext(
|
||||
width, height, ffmpeg_ctx->video_dec_ctx->pix_fmt,
|
||||
width, height, ffmpeg_ctx->video_dst_pix_fmt,
|
||||
swsFlags,
|
||||
NULL, NULL, NULL);
|
||||
}
|
||||
|
||||
if(!ffmpeg_ctx->has_alpha) {
|
||||
int lv_linesize = sizeof(lv_color_t) * width;
|
||||
int dst_linesize = ffmpeg_ctx->video_dst_linesize[0];
|
||||
if(dst_linesize != lv_linesize) {
|
||||
LV_LOG_WARN("ffmpeg linesize = %d, but lvgl image require %d",
|
||||
dst_linesize,
|
||||
lv_linesize);
|
||||
ffmpeg_ctx->video_dst_linesize[0] = lv_linesize;
|
||||
}
|
||||
}
|
||||
|
||||
ret = sws_scale(
|
||||
ffmpeg_ctx->sws_ctx,
|
||||
(const uint8_t * const *)(ffmpeg_ctx->video_src_data),
|
||||
ffmpeg_ctx->video_src_linesize,
|
||||
0,
|
||||
height,
|
||||
ffmpeg_ctx->video_dst_data,
|
||||
ffmpeg_ctx->video_dst_linesize);
|
||||
|
||||
failed:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ffmpeg_decode_packet(AVCodecContext * dec, const AVPacket * pkt,
|
||||
struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
/* submit the packet to the decoder */
|
||||
ret = avcodec_send_packet(dec, pkt);
|
||||
if(ret < 0) {
|
||||
LV_LOG_ERROR("Error submitting a packet for decoding (%s)",
|
||||
av_err2str(ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* get all the available frames from the decoder */
|
||||
while(ret >= 0) {
|
||||
ret = avcodec_receive_frame(dec, ffmpeg_ctx->frame);
|
||||
if(ret < 0) {
|
||||
|
||||
/* those two return values are special and mean there is
|
||||
* no output frame available,
|
||||
* but there were no errors during decoding
|
||||
*/
|
||||
if(ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
LV_LOG_ERROR("Error during decoding (%s)", av_err2str(ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* write the frame data to output file */
|
||||
if(dec->codec->type == AVMEDIA_TYPE_VIDEO) {
|
||||
ret = ffmpeg_output_video_frame(ffmpeg_ctx);
|
||||
}
|
||||
|
||||
av_frame_unref(ffmpeg_ctx->frame);
|
||||
if(ret < 0) {
|
||||
LV_LOG_WARN("ffmpeg_decode_packet ended %d", ret);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ffmpeg_open_codec_context(int * stream_idx,
|
||||
AVCodecContext ** dec_ctx, AVFormatContext * fmt_ctx,
|
||||
enum AVMediaType type)
|
||||
{
|
||||
int ret;
|
||||
int stream_index;
|
||||
AVStream * st;
|
||||
AVCodec * dec = NULL;
|
||||
AVDictionary * opts = NULL;
|
||||
|
||||
ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
|
||||
if(ret < 0) {
|
||||
LV_LOG_ERROR("Could not find %s stream in input file",
|
||||
av_get_media_type_string(type));
|
||||
return ret;
|
||||
}
|
||||
else {
|
||||
stream_index = ret;
|
||||
st = fmt_ctx->streams[stream_index];
|
||||
|
||||
/* find decoder for the stream */
|
||||
dec = avcodec_find_decoder(st->codecpar->codec_id);
|
||||
if(dec == NULL) {
|
||||
LV_LOG_ERROR("Failed to find %s codec",
|
||||
av_get_media_type_string(type));
|
||||
return AVERROR(EINVAL);
|
||||
}
|
||||
|
||||
/* Allocate a codec context for the decoder */
|
||||
*dec_ctx = avcodec_alloc_context3(dec);
|
||||
if(*dec_ctx == NULL) {
|
||||
LV_LOG_ERROR("Failed to allocate the %s codec context",
|
||||
av_get_media_type_string(type));
|
||||
return AVERROR(ENOMEM);
|
||||
}
|
||||
|
||||
/* Copy codec parameters from input stream to output codec context */
|
||||
if((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) < 0) {
|
||||
LV_LOG_ERROR(
|
||||
"Failed to copy %s codec parameters to decoder context",
|
||||
av_get_media_type_string(type));
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Init the decoders */
|
||||
if((ret = avcodec_open2(*dec_ctx, dec, &opts)) < 0) {
|
||||
LV_LOG_ERROR("Failed to open %s codec",
|
||||
av_get_media_type_string(type));
|
||||
return ret;
|
||||
}
|
||||
|
||||
*stream_idx = stream_index;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ffmpeg_get_img_header(const char * filepath,
|
||||
lv_img_header_t * header)
|
||||
{
|
||||
int ret = -1;
|
||||
|
||||
AVFormatContext * fmt_ctx = NULL;
|
||||
AVCodecContext * video_dec_ctx = NULL;
|
||||
int video_stream_idx;
|
||||
|
||||
/* open input file, and allocate format context */
|
||||
if(avformat_open_input(&fmt_ctx, filepath, NULL, NULL) < 0) {
|
||||
LV_LOG_ERROR("Could not open source file %s", filepath);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
/* retrieve stream information */
|
||||
if(avformat_find_stream_info(fmt_ctx, NULL) < 0) {
|
||||
LV_LOG_ERROR("Could not find stream information");
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if(ffmpeg_open_codec_context(&video_stream_idx, &video_dec_ctx,
|
||||
fmt_ctx, AVMEDIA_TYPE_VIDEO)
|
||||
>= 0) {
|
||||
bool has_alpha = ffmpeg_pix_fmt_has_alpha(video_dec_ctx->pix_fmt);
|
||||
|
||||
/* allocate image where the decoded image will be put */
|
||||
header->w = video_dec_ctx->width;
|
||||
header->h = video_dec_ctx->height;
|
||||
header->always_zero = 0;
|
||||
header->cf = (has_alpha ? LV_IMG_CF_TRUE_COLOR_ALPHA : LV_IMG_CF_TRUE_COLOR);
|
||||
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
failed:
|
||||
avcodec_free_context(&video_dec_ctx);
|
||||
avformat_close_input(&fmt_ctx);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ffmpeg_get_frame_refr_period(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
int avg_frame_rate_num = ffmpeg_ctx->video_stream->avg_frame_rate.num;
|
||||
if(avg_frame_rate_num > 0) {
|
||||
int period = 1000 * (int64_t)ffmpeg_ctx->video_stream->avg_frame_rate.den
|
||||
/ avg_frame_rate_num;
|
||||
return period;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int ffmpeg_update_next_frame(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
while(1) {
|
||||
|
||||
/* read frames from the file */
|
||||
if(av_read_frame(ffmpeg_ctx->fmt_ctx, &(ffmpeg_ctx->pkt)) >= 0) {
|
||||
bool is_image = false;
|
||||
|
||||
/* check if the packet belongs to a stream we are interested in,
|
||||
* otherwise skip it
|
||||
*/
|
||||
if(ffmpeg_ctx->pkt.stream_index == ffmpeg_ctx->video_stream_idx) {
|
||||
ret = ffmpeg_decode_packet(ffmpeg_ctx->video_dec_ctx,
|
||||
&(ffmpeg_ctx->pkt), ffmpeg_ctx);
|
||||
is_image = true;
|
||||
}
|
||||
|
||||
av_packet_unref(&(ffmpeg_ctx->pkt));
|
||||
|
||||
if(ret < 0) {
|
||||
LV_LOG_WARN("video frame is empty %d", ret);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Used to filter data that is not an image */
|
||||
if(is_image) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
else {
|
||||
ret = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct ffmpeg_context_s * ffmpeg_open_file(const char * path)
|
||||
{
|
||||
if(path == NULL || strlen(path) == 0) {
|
||||
LV_LOG_ERROR("file path is empty");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct ffmpeg_context_s * ffmpeg_ctx = calloc(1, sizeof(struct ffmpeg_context_s));
|
||||
|
||||
if(ffmpeg_ctx == NULL) {
|
||||
LV_LOG_ERROR("ffmpeg_ctx malloc failed");
|
||||
goto failed;
|
||||
}
|
||||
|
||||
/* open input file, and allocate format context */
|
||||
|
||||
if(avformat_open_input(&(ffmpeg_ctx->fmt_ctx), path, NULL, NULL) < 0) {
|
||||
LV_LOG_ERROR("Could not open source file %s", path);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
/* retrieve stream information */
|
||||
|
||||
if(avformat_find_stream_info(ffmpeg_ctx->fmt_ctx, NULL) < 0) {
|
||||
LV_LOG_ERROR("Could not find stream information");
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if(ffmpeg_open_codec_context(
|
||||
&(ffmpeg_ctx->video_stream_idx),
|
||||
&(ffmpeg_ctx->video_dec_ctx),
|
||||
ffmpeg_ctx->fmt_ctx, AVMEDIA_TYPE_VIDEO)
|
||||
>= 0) {
|
||||
ffmpeg_ctx->video_stream = ffmpeg_ctx->fmt_ctx->streams[ffmpeg_ctx->video_stream_idx];
|
||||
|
||||
ffmpeg_ctx->has_alpha = ffmpeg_pix_fmt_has_alpha(ffmpeg_ctx->video_dec_ctx->pix_fmt);
|
||||
|
||||
ffmpeg_ctx->video_dst_pix_fmt = (ffmpeg_ctx->has_alpha ? AV_PIX_FMT_BGRA : AV_PIX_FMT_TRUE_COLOR);
|
||||
}
|
||||
|
||||
#if LV_FFMPEG_AV_DUMP_FORMAT != 0
|
||||
/* dump input information to stderr */
|
||||
av_dump_format(ffmpeg_ctx->fmt_ctx, 0, path, 0);
|
||||
#endif
|
||||
|
||||
if(ffmpeg_ctx->video_stream == NULL) {
|
||||
LV_LOG_ERROR("Could not find video stream in the input, aborting");
|
||||
goto failed;
|
||||
}
|
||||
|
||||
return ffmpeg_ctx;
|
||||
|
||||
failed:
|
||||
ffmpeg_close(ffmpeg_ctx);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int ffmpeg_image_allocate(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* allocate image where the decoded image will be put */
|
||||
ret = av_image_alloc(
|
||||
ffmpeg_ctx->video_src_data,
|
||||
ffmpeg_ctx->video_src_linesize,
|
||||
ffmpeg_ctx->video_dec_ctx->width,
|
||||
ffmpeg_ctx->video_dec_ctx->height,
|
||||
ffmpeg_ctx->video_dec_ctx->pix_fmt,
|
||||
4);
|
||||
|
||||
if(ret < 0) {
|
||||
LV_LOG_ERROR("Could not allocate src raw video buffer");
|
||||
return ret;
|
||||
}
|
||||
|
||||
LV_LOG_INFO("alloc video_src_bufsize = %d", ret);
|
||||
|
||||
ret = av_image_alloc(
|
||||
ffmpeg_ctx->video_dst_data,
|
||||
ffmpeg_ctx->video_dst_linesize,
|
||||
ffmpeg_ctx->video_dec_ctx->width,
|
||||
ffmpeg_ctx->video_dec_ctx->height,
|
||||
ffmpeg_ctx->video_dst_pix_fmt,
|
||||
4);
|
||||
|
||||
if(ret < 0) {
|
||||
LV_LOG_ERROR("Could not allocate dst raw video buffer");
|
||||
return ret;
|
||||
}
|
||||
|
||||
LV_LOG_INFO("allocate video_dst_bufsize = %d", ret);
|
||||
|
||||
ffmpeg_ctx->frame = av_frame_alloc();
|
||||
|
||||
if(ffmpeg_ctx->frame == NULL) {
|
||||
LV_LOG_ERROR("Could not allocate frame");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* initialize packet, set data to NULL, let the demuxer fill it */
|
||||
av_init_packet(&ffmpeg_ctx->pkt);
|
||||
ffmpeg_ctx->pkt.data = NULL;
|
||||
ffmpeg_ctx->pkt.size = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ffmpeg_close_src_ctx(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
avcodec_free_context(&(ffmpeg_ctx->video_dec_ctx));
|
||||
avformat_close_input(&(ffmpeg_ctx->fmt_ctx));
|
||||
av_frame_free(&(ffmpeg_ctx->frame));
|
||||
if(ffmpeg_ctx->video_src_data[0] != NULL) {
|
||||
av_free(ffmpeg_ctx->video_src_data[0]);
|
||||
ffmpeg_ctx->video_src_data[0] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static void ffmpeg_close_dst_ctx(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
if(ffmpeg_ctx->video_dst_data[0] != NULL) {
|
||||
av_free(ffmpeg_ctx->video_dst_data[0]);
|
||||
ffmpeg_ctx->video_dst_data[0] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static void ffmpeg_close(struct ffmpeg_context_s * ffmpeg_ctx)
|
||||
{
|
||||
if(ffmpeg_ctx == NULL) {
|
||||
LV_LOG_WARN("ffmpeg_ctx is NULL");
|
||||
return;
|
||||
}
|
||||
|
||||
sws_freeContext(ffmpeg_ctx->sws_ctx);
|
||||
ffmpeg_close_src_ctx(ffmpeg_ctx);
|
||||
ffmpeg_close_dst_ctx(ffmpeg_ctx);
|
||||
free(ffmpeg_ctx);
|
||||
|
||||
LV_LOG_INFO("ffmpeg_ctx closed");
|
||||
}
|
||||
|
||||
static void lv_ffmpeg_player_frame_update_cb(lv_timer_t * timer)
|
||||
{
|
||||
lv_obj_t * obj = (lv_obj_t *)timer->user_data;
|
||||
lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
|
||||
|
||||
if(!player->ffmpeg_ctx) {
|
||||
return;
|
||||
}
|
||||
|
||||
int has_next = ffmpeg_update_next_frame(player->ffmpeg_ctx);
|
||||
|
||||
if(has_next < 0) {
|
||||
lv_ffmpeg_player_set_cmd(obj, player->auto_restart ? LV_FFMPEG_PLAYER_CMD_START : LV_FFMPEG_PLAYER_CMD_STOP);
|
||||
return;
|
||||
}
|
||||
|
||||
#if LV_COLOR_DEPTH != 32
|
||||
if(player->ffmpeg_ctx->has_alpha) {
|
||||
convert_color_depth((uint8_t *)(player->imgdsc.data),
|
||||
player->imgdsc.header.w * player->imgdsc.header.h);
|
||||
}
|
||||
#endif
|
||||
|
||||
lv_img_cache_invalidate_src(lv_img_get_src(obj));
|
||||
lv_obj_invalidate(obj);
|
||||
}
|
||||
|
||||
static void lv_ffmpeg_player_constructor(const lv_obj_class_t * class_p,
|
||||
lv_obj_t * obj)
|
||||
{
|
||||
LV_TRACE_OBJ_CREATE("begin");
|
||||
|
||||
lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
|
||||
|
||||
player->auto_restart = false;
|
||||
player->ffmpeg_ctx = NULL;
|
||||
player->timer = lv_timer_create(lv_ffmpeg_player_frame_update_cb,
|
||||
FRAME_DEF_REFR_PERIOD, obj);
|
||||
lv_timer_pause(player->timer);
|
||||
|
||||
LV_TRACE_OBJ_CREATE("finished");
|
||||
}
|
||||
|
||||
static void lv_ffmpeg_player_destructor(const lv_obj_class_t * class_p,
|
||||
lv_obj_t * obj)
|
||||
{
|
||||
LV_TRACE_OBJ_CREATE("begin");
|
||||
|
||||
lv_ffmpeg_player_t * player = (lv_ffmpeg_player_t *)obj;
|
||||
|
||||
if(player->timer) {
|
||||
lv_timer_del(player->timer);
|
||||
player->timer = NULL;
|
||||
}
|
||||
|
||||
lv_img_cache_invalidate_src(lv_img_get_src(obj));
|
||||
|
||||
ffmpeg_close(player->ffmpeg_ctx);
|
||||
player->ffmpeg_ctx = NULL;
|
||||
|
||||
LV_TRACE_OBJ_CREATE("finished");
|
||||
}
|
||||
|
||||
#endif /*LV_USE_FFMPEG*/
|
||||
@@ -0,0 +1,104 @@
|
||||
/**
|
||||
* @file lv_ffmpeg.h
|
||||
*
|
||||
*/
|
||||
#ifndef LV_FFMPEG_H
|
||||
#define LV_FFMPEG_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_FFMPEG != 0
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
struct ffmpeg_context_s;
|
||||
|
||||
extern const lv_obj_class_t lv_ffmpeg_player_class;
|
||||
|
||||
typedef struct {
|
||||
lv_img_t img;
|
||||
lv_timer_t * timer;
|
||||
lv_img_dsc_t imgdsc;
|
||||
bool auto_restart;
|
||||
struct ffmpeg_context_s * ffmpeg_ctx;
|
||||
} lv_ffmpeg_player_t;
|
||||
|
||||
typedef enum {
|
||||
LV_FFMPEG_PLAYER_CMD_START,
|
||||
LV_FFMPEG_PLAYER_CMD_STOP,
|
||||
LV_FFMPEG_PLAYER_CMD_PAUSE,
|
||||
LV_FFMPEG_PLAYER_CMD_RESUME,
|
||||
_LV_FFMPEG_PLAYER_CMD_LAST
|
||||
} lv_ffmpeg_player_cmd_t;
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Register FFMPEG image decoder
|
||||
*/
|
||||
void lv_ffmpeg_init(void);
|
||||
|
||||
/**
|
||||
* Get the number of frames contained in the file
|
||||
* @param path image or video file name
|
||||
* @return Number of frames, less than 0 means failed
|
||||
*/
|
||||
int lv_ffmpeg_get_frame_num(const char * path);
|
||||
|
||||
/**
|
||||
* Create ffmpeg_player object
|
||||
* @param parent pointer to an object, it will be the parent of the new player
|
||||
* @return pointer to the created ffmpeg_player
|
||||
*/
|
||||
lv_obj_t * lv_ffmpeg_player_create(lv_obj_t * parent);
|
||||
|
||||
/**
|
||||
* Set the path of the file to be played
|
||||
* @param obj pointer to a ffmpeg_player object
|
||||
* @param path video file path
|
||||
* @return LV_RES_OK: no error; LV_RES_INV: can't get the info.
|
||||
*/
|
||||
lv_res_t lv_ffmpeg_player_set_src(lv_obj_t * obj, const char * path);
|
||||
|
||||
/**
|
||||
* Set command control video player
|
||||
* @param obj pointer to a ffmpeg_player object
|
||||
* @param cmd control commands
|
||||
*/
|
||||
void lv_ffmpeg_player_set_cmd(lv_obj_t * obj, lv_ffmpeg_player_cmd_t cmd);
|
||||
|
||||
/**
|
||||
* Set the video to automatically replay
|
||||
* @param obj pointer to a ffmpeg_player object
|
||||
* @param en true: enable the auto restart
|
||||
*/
|
||||
void lv_ffmpeg_player_set_auto_restart(lv_obj_t * obj, bool en);
|
||||
|
||||
/*=====================
|
||||
* Other functions
|
||||
*====================*/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_FFMPEG*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /*extern "C"*/
|
||||
#endif
|
||||
|
||||
#endif /*LV_FFMPEG_H*/
|
||||
Binary file not shown.
@@ -0,0 +1,687 @@
|
||||
/**
|
||||
* @file lv_freetype.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "lv_freetype.h"
|
||||
#if LV_USE_FREETYPE
|
||||
|
||||
#include "ft2build.h"
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_GLYPH_H
|
||||
#include FT_CACHE_H
|
||||
#include FT_SIZES_H
|
||||
#include FT_IMAGE_H
|
||||
#include FT_OUTLINE_H
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
typedef struct {
|
||||
lv_ll_t face_ll;
|
||||
} lv_faces_control_t;
|
||||
|
||||
typedef struct name_refer_t {
|
||||
const char * name; /* point to font name string */
|
||||
int32_t cnt; /* reference count */
|
||||
} name_refer_t;
|
||||
|
||||
typedef struct {
|
||||
const void * mem;
|
||||
const char * name;
|
||||
size_t mem_size;
|
||||
#if LV_FREETYPE_CACHE_SIZE < 0
|
||||
FT_Size size;
|
||||
#endif
|
||||
lv_font_t * font;
|
||||
uint16_t style;
|
||||
uint16_t height;
|
||||
} lv_font_fmt_ft_dsc_t;
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
static FT_Error font_face_requester(FTC_FaceID face_id,
|
||||
FT_Library library_is, FT_Pointer req_data, FT_Face * aface);
|
||||
static bool lv_ft_font_init_cache(lv_ft_info_t * info);
|
||||
static void lv_ft_font_destroy_cache(lv_font_t * font);
|
||||
#else
|
||||
static FT_Face face_find_in_list(lv_ft_info_t * info);
|
||||
static void face_add_to_list(FT_Face face);
|
||||
static void face_remove_from_list(FT_Face face);
|
||||
static void face_generic_finalizer(void * object);
|
||||
static bool lv_ft_font_init_nocache(lv_ft_info_t * info);
|
||||
static void lv_ft_font_destroy_nocache(lv_font_t * font);
|
||||
#endif
|
||||
|
||||
static const char * name_refer_save(const char * name);
|
||||
static void name_refer_del(const char * name);
|
||||
static const char * name_refer_find(const char * name);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
static FT_Library library;
|
||||
static lv_ll_t names_ll;
|
||||
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
static FTC_Manager cache_manager;
|
||||
static FTC_CMapCache cmap_cache;
|
||||
static FT_Face current_face = NULL;
|
||||
|
||||
#if LV_FREETYPE_SBIT_CACHE
|
||||
static FTC_SBitCache sbit_cache;
|
||||
static FTC_SBit sbit;
|
||||
#else
|
||||
static FTC_ImageCache image_cache;
|
||||
static FT_Glyph image_glyph;
|
||||
#endif
|
||||
|
||||
#else
|
||||
static lv_faces_control_t face_control;
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
bool lv_freetype_init(uint16_t max_faces, uint16_t max_sizes, uint32_t max_bytes)
|
||||
{
|
||||
FT_Error error = FT_Init_FreeType(&library);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("init freeType error(%d)", error);
|
||||
return false;
|
||||
}
|
||||
|
||||
_lv_ll_init(&names_ll, sizeof(name_refer_t));
|
||||
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
error = FTC_Manager_New(library, max_faces, max_sizes,
|
||||
max_bytes, font_face_requester, NULL, &cache_manager);
|
||||
if(error) {
|
||||
FT_Done_FreeType(library);
|
||||
LV_LOG_ERROR("Failed to open cache manager");
|
||||
return false;
|
||||
}
|
||||
|
||||
error = FTC_CMapCache_New(cache_manager, &cmap_cache);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("Failed to open Cmap Cache");
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
#if LV_FREETYPE_SBIT_CACHE
|
||||
error = FTC_SBitCache_New(cache_manager, &sbit_cache);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("Failed to open sbit cache");
|
||||
goto Fail;
|
||||
}
|
||||
#else
|
||||
error = FTC_ImageCache_New(cache_manager, &image_cache);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("Failed to open image cache");
|
||||
goto Fail;
|
||||
}
|
||||
#endif
|
||||
|
||||
return true;
|
||||
Fail:
|
||||
FTC_Manager_Done(cache_manager);
|
||||
FT_Done_FreeType(library);
|
||||
return false;
|
||||
#else
|
||||
LV_UNUSED(max_faces);
|
||||
LV_UNUSED(max_sizes);
|
||||
LV_UNUSED(max_bytes);
|
||||
_lv_ll_init(&face_control.face_ll, sizeof(FT_Face *));
|
||||
return true;
|
||||
#endif/* LV_FREETYPE_CACHE_SIZE */
|
||||
}
|
||||
|
||||
void lv_freetype_destroy(void)
|
||||
{
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
FTC_Manager_Done(cache_manager);
|
||||
#endif
|
||||
FT_Done_FreeType(library);
|
||||
}
|
||||
|
||||
bool lv_ft_font_init(lv_ft_info_t * info)
|
||||
{
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
return lv_ft_font_init_cache(info);
|
||||
#else
|
||||
return lv_ft_font_init_nocache(info);
|
||||
#endif
|
||||
}
|
||||
|
||||
void lv_ft_font_destroy(lv_font_t * font)
|
||||
{
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
lv_ft_font_destroy_cache(font);
|
||||
#else
|
||||
lv_ft_font_destroy_nocache(font);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
#if LV_FREETYPE_CACHE_SIZE >= 0
|
||||
|
||||
static FT_Error font_face_requester(FTC_FaceID face_id,
|
||||
FT_Library library_is, FT_Pointer req_data, FT_Face * aface)
|
||||
{
|
||||
LV_UNUSED(library_is);
|
||||
LV_UNUSED(req_data);
|
||||
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)face_id;
|
||||
FT_Error error;
|
||||
if(dsc->mem) {
|
||||
error = FT_New_Memory_Face(library, dsc->mem, dsc->mem_size, 0, aface);
|
||||
}
|
||||
else {
|
||||
error = FT_New_Face(library, dsc->name, 0, aface);
|
||||
}
|
||||
if(error) {
|
||||
LV_LOG_ERROR("FT_New_Face error:%d\n", error);
|
||||
return error;
|
||||
}
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
static bool get_bold_glyph(const lv_font_t * font, FT_Face face,
|
||||
FT_UInt glyph_index, lv_font_glyph_dsc_t * dsc_out)
|
||||
{
|
||||
if(FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
if(face->glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
|
||||
if(dsc->style & FT_FONT_STYLE_BOLD) {
|
||||
int strength = 1 << 6;
|
||||
FT_Outline_Embolden(&face->glyph->outline, strength);
|
||||
}
|
||||
}
|
||||
|
||||
if(FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
dsc_out->adv_w = (face->glyph->metrics.horiAdvance >> 6);
|
||||
dsc_out->box_h = face->glyph->bitmap.rows; /*Height of the bitmap in [px]*/
|
||||
dsc_out->box_w = face->glyph->bitmap.width; /*Width of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = face->glyph->bitmap_left; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = face->glyph->bitmap_top -
|
||||
face->glyph->bitmap.rows; /*Y offset of the bitmap measured from the as line*/
|
||||
dsc_out->bpp = 8; /*Bit per pixel: 1/2/4/8*/
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool get_glyph_dsc_cb_cache(const lv_font_t * font,
|
||||
lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter, uint32_t unicode_letter_next)
|
||||
{
|
||||
LV_UNUSED(unicode_letter_next);
|
||||
if(unicode_letter < 0x20) {
|
||||
dsc_out->adv_w = 0;
|
||||
dsc_out->box_h = 0;
|
||||
dsc_out->box_w = 0;
|
||||
dsc_out->ofs_x = 0;
|
||||
dsc_out->ofs_y = 0;
|
||||
dsc_out->bpp = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
|
||||
FTC_FaceID face_id = (FTC_FaceID)dsc;
|
||||
FT_Size face_size;
|
||||
struct FTC_ScalerRec_ scaler;
|
||||
scaler.face_id = face_id;
|
||||
scaler.width = dsc->height;
|
||||
scaler.height = dsc->height;
|
||||
scaler.pixel = 1;
|
||||
if(FTC_Manager_LookupSize(cache_manager, &scaler, &face_size) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
FT_Face face = face_size->face;
|
||||
FT_UInt charmap_index = FT_Get_Charmap_Index(face->charmap);
|
||||
FT_UInt glyph_index = FTC_CMapCache_Lookup(cmap_cache, face_id, charmap_index, unicode_letter);
|
||||
dsc_out->is_placeholder = glyph_index == 0;
|
||||
|
||||
if(dsc->style & FT_FONT_STYLE_ITALIC) {
|
||||
FT_Matrix italic_matrix;
|
||||
italic_matrix.xx = 1 << 16;
|
||||
italic_matrix.xy = 0x5800;
|
||||
italic_matrix.yx = 0;
|
||||
italic_matrix.yy = 1 << 16;
|
||||
FT_Set_Transform(face, &italic_matrix, NULL);
|
||||
}
|
||||
|
||||
if(dsc->style & FT_FONT_STYLE_BOLD) {
|
||||
current_face = face;
|
||||
if(!get_bold_glyph(font, face, glyph_index, dsc_out)) {
|
||||
current_face = NULL;
|
||||
return false;
|
||||
}
|
||||
goto end;
|
||||
}
|
||||
|
||||
FTC_ImageTypeRec desc_type;
|
||||
desc_type.face_id = face_id;
|
||||
desc_type.flags = FT_LOAD_RENDER | FT_LOAD_TARGET_NORMAL;
|
||||
desc_type.height = dsc->height;
|
||||
desc_type.width = dsc->height;
|
||||
|
||||
#if LV_FREETYPE_SBIT_CACHE
|
||||
FT_Error error = FTC_SBitCache_Lookup(sbit_cache, &desc_type, glyph_index, &sbit, NULL);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("SBitCache_Lookup error");
|
||||
return false;
|
||||
}
|
||||
|
||||
dsc_out->adv_w = sbit->xadvance;
|
||||
dsc_out->box_h = sbit->height; /*Height of the bitmap in [px]*/
|
||||
dsc_out->box_w = sbit->width; /*Width of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = sbit->left; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = sbit->top - sbit->height; /*Y offset of the bitmap measured from the as line*/
|
||||
dsc_out->bpp = 8; /*Bit per pixel: 1/2/4/8*/
|
||||
#else
|
||||
FT_Error error = FTC_ImageCache_Lookup(image_cache, &desc_type, glyph_index, &image_glyph, NULL);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("ImageCache_Lookup error");
|
||||
return false;
|
||||
}
|
||||
if(image_glyph->format != FT_GLYPH_FORMAT_BITMAP) {
|
||||
LV_LOG_ERROR("Glyph_To_Bitmap error");
|
||||
return false;
|
||||
}
|
||||
|
||||
FT_BitmapGlyph glyph_bitmap = (FT_BitmapGlyph)image_glyph;
|
||||
dsc_out->adv_w = (glyph_bitmap->root.advance.x >> 16);
|
||||
dsc_out->box_h = glyph_bitmap->bitmap.rows; /*Height of the bitmap in [px]*/
|
||||
dsc_out->box_w = glyph_bitmap->bitmap.width; /*Width of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = glyph_bitmap->left; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = glyph_bitmap->top -
|
||||
glyph_bitmap->bitmap.rows; /*Y offset of the bitmap measured from the as line*/
|
||||
dsc_out->bpp = 8; /*Bit per pixel: 1/2/4/8*/
|
||||
#endif
|
||||
|
||||
end:
|
||||
if((dsc->style & FT_FONT_STYLE_ITALIC) && (unicode_letter_next == '\0')) {
|
||||
dsc_out->adv_w = dsc_out->box_w + dsc_out->ofs_x;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static const uint8_t * get_glyph_bitmap_cb_cache(const lv_font_t * font, uint32_t unicode_letter)
|
||||
{
|
||||
LV_UNUSED(unicode_letter);
|
||||
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
if(dsc->style & FT_FONT_STYLE_BOLD) {
|
||||
if(current_face && current_face->glyph->format == FT_GLYPH_FORMAT_BITMAP) {
|
||||
return (const uint8_t *)(current_face->glyph->bitmap.buffer);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#if LV_FREETYPE_SBIT_CACHE
|
||||
return (const uint8_t *)sbit->buffer;
|
||||
#else
|
||||
FT_BitmapGlyph glyph_bitmap = (FT_BitmapGlyph)image_glyph;
|
||||
return (const uint8_t *)glyph_bitmap->bitmap.buffer;
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool lv_ft_font_init_cache(lv_ft_info_t * info)
|
||||
{
|
||||
size_t need_size = sizeof(lv_font_fmt_ft_dsc_t) + sizeof(lv_font_t);
|
||||
lv_font_fmt_ft_dsc_t * dsc = lv_mem_alloc(need_size);
|
||||
if(dsc == NULL) return false;
|
||||
lv_memset_00(dsc, need_size);
|
||||
|
||||
dsc->font = (lv_font_t *)(((char *)dsc) + sizeof(lv_font_fmt_ft_dsc_t));
|
||||
dsc->mem = info->mem;
|
||||
dsc->mem_size = info->mem_size;
|
||||
dsc->name = name_refer_save(info->name);
|
||||
dsc->height = info->weight;
|
||||
dsc->style = info->style;
|
||||
|
||||
/* use to get font info */
|
||||
FT_Size face_size;
|
||||
struct FTC_ScalerRec_ scaler;
|
||||
scaler.face_id = (FTC_FaceID)dsc;
|
||||
scaler.width = info->weight;
|
||||
scaler.height = info->weight;
|
||||
scaler.pixel = 1;
|
||||
FT_Error error = FTC_Manager_LookupSize(cache_manager, &scaler, &face_size);
|
||||
if(error) {
|
||||
LV_LOG_ERROR("Failed to LookupSize");
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
lv_font_t * font = dsc->font;
|
||||
font->dsc = dsc;
|
||||
font->get_glyph_dsc = get_glyph_dsc_cb_cache;
|
||||
font->get_glyph_bitmap = get_glyph_bitmap_cb_cache;
|
||||
font->subpx = LV_FONT_SUBPX_NONE;
|
||||
font->line_height = (face_size->face->size->metrics.height >> 6);
|
||||
font->base_line = -(face_size->face->size->metrics.descender >> 6);
|
||||
|
||||
FT_Fixed scale = face_size->face->size->metrics.y_scale;
|
||||
int8_t thickness = FT_MulFix(scale, face_size->face->underline_thickness) >> 6;
|
||||
font->underline_position = FT_MulFix(scale, face_size->face->underline_position) >> 6;
|
||||
font->underline_thickness = thickness < 1 ? 1 : thickness;
|
||||
|
||||
/* return to user */
|
||||
info->font = font;
|
||||
|
||||
return true;
|
||||
|
||||
Fail:
|
||||
lv_mem_free(dsc);
|
||||
return false;
|
||||
}
|
||||
|
||||
void lv_ft_font_destroy_cache(lv_font_t * font)
|
||||
{
|
||||
if(font == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
if(dsc) {
|
||||
FTC_Manager_RemoveFaceID(cache_manager, (FTC_FaceID)dsc);
|
||||
name_refer_del(dsc->name);
|
||||
lv_mem_free(dsc);
|
||||
}
|
||||
}
|
||||
#else/* LV_FREETYPE_CACHE_SIZE */
|
||||
|
||||
static FT_Face face_find_in_list(lv_ft_info_t * info)
|
||||
{
|
||||
lv_font_fmt_ft_dsc_t * dsc;
|
||||
FT_Face * pface = _lv_ll_get_head(&face_control.face_ll);
|
||||
while(pface) {
|
||||
dsc = (lv_font_fmt_ft_dsc_t *)(*pface)->generic.data;
|
||||
if(strcmp(dsc->name, info->name) == 0) {
|
||||
return *pface;
|
||||
}
|
||||
pface = _lv_ll_get_next(&face_control.face_ll, pface);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void face_add_to_list(FT_Face face)
|
||||
{
|
||||
FT_Face * pface;
|
||||
pface = (FT_Face *)_lv_ll_ins_tail(&face_control.face_ll);
|
||||
*pface = face;
|
||||
}
|
||||
|
||||
static void face_remove_from_list(FT_Face face)
|
||||
{
|
||||
FT_Face * pface = _lv_ll_get_head(&face_control.face_ll);
|
||||
while(pface) {
|
||||
if(*pface == face) {
|
||||
_lv_ll_remove(&face_control.face_ll, pface);
|
||||
lv_mem_free(pface);
|
||||
break;
|
||||
}
|
||||
pface = _lv_ll_get_next(&face_control.face_ll, pface);
|
||||
}
|
||||
}
|
||||
|
||||
static void face_generic_finalizer(void * object)
|
||||
{
|
||||
FT_Face face = (FT_Face)object;
|
||||
face_remove_from_list(face);
|
||||
LV_LOG_INFO("face finalizer(%p)\n", face);
|
||||
}
|
||||
|
||||
static bool get_glyph_dsc_cb_nocache(const lv_font_t * font,
|
||||
lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter, uint32_t unicode_letter_next)
|
||||
{
|
||||
LV_UNUSED(unicode_letter_next);
|
||||
if(unicode_letter < 0x20) {
|
||||
dsc_out->adv_w = 0;
|
||||
dsc_out->box_h = 0;
|
||||
dsc_out->box_w = 0;
|
||||
dsc_out->ofs_x = 0;
|
||||
dsc_out->ofs_y = 0;
|
||||
dsc_out->bpp = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
FT_Error error;
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
FT_Face face = dsc->size->face;
|
||||
|
||||
FT_UInt glyph_index = FT_Get_Char_Index(face, unicode_letter);
|
||||
|
||||
if(face->size != dsc->size) {
|
||||
FT_Activate_Size(dsc->size);
|
||||
}
|
||||
dsc_out->is_placeholder = glyph_index == 0;
|
||||
|
||||
error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
|
||||
if(error) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if(face->glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
|
||||
if(dsc->style & FT_FONT_STYLE_BOLD) {
|
||||
int strength = 1 << 6;
|
||||
FT_Outline_Embolden(&face->glyph->outline, strength);
|
||||
}
|
||||
|
||||
if(dsc->style & FT_FONT_STYLE_ITALIC) {
|
||||
FT_Matrix italic_matrix;
|
||||
italic_matrix.xx = 1 << 16;
|
||||
italic_matrix.xy = 0x5800;
|
||||
italic_matrix.yx = 0;
|
||||
italic_matrix.yy = 1 << 16;
|
||||
FT_Outline_Transform(&face->glyph->outline, &italic_matrix);
|
||||
}
|
||||
}
|
||||
|
||||
error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
|
||||
if(error) {
|
||||
return false;
|
||||
}
|
||||
|
||||
dsc_out->adv_w = (face->glyph->metrics.horiAdvance >> 6);
|
||||
dsc_out->box_h = face->glyph->bitmap.rows; /*Height of the bitmap in [px]*/
|
||||
dsc_out->box_w = face->glyph->bitmap.width; /*Width of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = face->glyph->bitmap_left; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = face->glyph->bitmap_top -
|
||||
face->glyph->bitmap.rows; /*Y offset of the bitmap measured from the as line*/
|
||||
dsc_out->bpp = 8; /*Bit per pixel: 1/2/4/8*/
|
||||
|
||||
if((dsc->style & FT_FONT_STYLE_ITALIC) && (unicode_letter_next == '\0')) {
|
||||
dsc_out->adv_w = dsc_out->box_w + dsc_out->ofs_x;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static const uint8_t * get_glyph_bitmap_cb_nocache(const lv_font_t * font, uint32_t unicode_letter)
|
||||
{
|
||||
LV_UNUSED(unicode_letter);
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
FT_Face face = dsc->size->face;
|
||||
return (const uint8_t *)(face->glyph->bitmap.buffer);
|
||||
}
|
||||
|
||||
static bool lv_ft_font_init_nocache(lv_ft_info_t * info)
|
||||
{
|
||||
size_t need_size = sizeof(lv_font_fmt_ft_dsc_t) + sizeof(lv_font_t);
|
||||
lv_font_fmt_ft_dsc_t * dsc = lv_mem_alloc(need_size);
|
||||
if(dsc == NULL) return false;
|
||||
lv_memset_00(dsc, need_size);
|
||||
|
||||
dsc->font = (lv_font_t *)(((char *)dsc) + sizeof(lv_font_fmt_ft_dsc_t));
|
||||
dsc->mem = info->mem;
|
||||
dsc->mem_size = info->mem_size;
|
||||
dsc->name = name_refer_save(info->name);
|
||||
dsc->height = info->weight;
|
||||
dsc->style = info->style;
|
||||
|
||||
FT_Face face = face_find_in_list(info);
|
||||
if(face == NULL) {
|
||||
FT_Error error;
|
||||
if(dsc->mem) {
|
||||
error = FT_New_Memory_Face(library, dsc->mem, (FT_Long) dsc->mem_size, 0, &face);
|
||||
}
|
||||
else {
|
||||
error = FT_New_Face(library, dsc->name, 0, &face);
|
||||
}
|
||||
if(error) {
|
||||
LV_LOG_WARN("create face error(%d)", error);
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
/* link face and face info */
|
||||
face->generic.data = dsc;
|
||||
face->generic.finalizer = face_generic_finalizer;
|
||||
face_add_to_list(face);
|
||||
}
|
||||
else {
|
||||
FT_Size size;
|
||||
FT_Error error = FT_New_Size(face, &size);
|
||||
if(error) {
|
||||
goto Fail;
|
||||
}
|
||||
FT_Activate_Size(size);
|
||||
FT_Reference_Face(face);
|
||||
}
|
||||
|
||||
FT_Set_Pixel_Sizes(face, 0, info->weight);
|
||||
dsc->size = face->size;
|
||||
|
||||
lv_font_t * font = dsc->font;
|
||||
font->dsc = dsc;
|
||||
font->get_glyph_dsc = get_glyph_dsc_cb_nocache;
|
||||
font->get_glyph_bitmap = get_glyph_bitmap_cb_nocache;
|
||||
font->line_height = (face->size->metrics.height >> 6);
|
||||
font->base_line = -(face->size->metrics.descender >> 6);
|
||||
font->subpx = LV_FONT_SUBPX_NONE;
|
||||
|
||||
FT_Fixed scale = face->size->metrics.y_scale;
|
||||
int8_t thickness = FT_MulFix(scale, face->underline_thickness) >> 6;
|
||||
font->underline_position = FT_MulFix(scale, face->underline_position) >> 6;
|
||||
font->underline_thickness = thickness < 1 ? 1 : thickness;
|
||||
|
||||
info->font = font;
|
||||
return true;
|
||||
|
||||
Fail:
|
||||
lv_mem_free(dsc);
|
||||
return false;
|
||||
}
|
||||
|
||||
static void lv_ft_font_destroy_nocache(lv_font_t * font)
|
||||
{
|
||||
if(font == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
lv_font_fmt_ft_dsc_t * dsc = (lv_font_fmt_ft_dsc_t *)(font->dsc);
|
||||
if(dsc) {
|
||||
FT_Face face = dsc->size->face;
|
||||
FT_Done_Size(dsc->size);
|
||||
FT_Done_Face(face);
|
||||
name_refer_del(dsc->name);
|
||||
lv_mem_free(dsc);
|
||||
}
|
||||
}
|
||||
|
||||
#endif/* LV_FREETYPE_CACHE_SIZE */
|
||||
|
||||
/**
|
||||
* find name string in names list.name string cnt += 1 if find.
|
||||
* @param name name string
|
||||
* @return the string pointer of name.
|
||||
*/
|
||||
static const char * name_refer_find(const char * name)
|
||||
{
|
||||
name_refer_t * refer = _lv_ll_get_head(&names_ll);
|
||||
while(refer) {
|
||||
if(strcmp(refer->name, name) == 0) {
|
||||
refer->cnt += 1;
|
||||
return refer->name;
|
||||
}
|
||||
refer = _lv_ll_get_next(&names_ll, refer);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* del name string from list.
|
||||
*/
|
||||
static void name_refer_del(const char * name)
|
||||
{
|
||||
name_refer_t * refer = _lv_ll_get_head(&names_ll);
|
||||
while(refer) {
|
||||
if(strcmp(refer->name, name) == 0) {
|
||||
refer->cnt -= 1;
|
||||
if(refer->cnt <= 0) {
|
||||
_lv_ll_remove(&names_ll, refer);
|
||||
lv_mem_free((void *)refer->name);
|
||||
lv_mem_free(refer);
|
||||
}
|
||||
return;
|
||||
}
|
||||
refer = _lv_ll_get_next(&names_ll, refer);
|
||||
}
|
||||
|
||||
LV_LOG_WARN("name_in_names_del error(not find:%p).", name);
|
||||
}
|
||||
|
||||
/**
|
||||
* save name string to list.
|
||||
* @param name name string
|
||||
* @return Saved string pointer
|
||||
*/
|
||||
static const char * name_refer_save(const char * name)
|
||||
{
|
||||
const char * pos = name_refer_find(name);
|
||||
if(pos) {
|
||||
return pos;
|
||||
}
|
||||
|
||||
name_refer_t * refer = _lv_ll_ins_tail(&names_ll);
|
||||
if(refer) {
|
||||
uint32_t len = strlen(name) + 1;
|
||||
refer->name = lv_mem_alloc(len);
|
||||
if(refer->name) {
|
||||
lv_memcpy((void *)refer->name, name, len);
|
||||
refer->cnt = 1;
|
||||
return refer->name;
|
||||
}
|
||||
_lv_ll_remove(&names_ll, refer);
|
||||
lv_mem_free(refer);
|
||||
}
|
||||
LV_LOG_WARN("save_name_to_names error(not memory).");
|
||||
return "";
|
||||
}
|
||||
|
||||
#endif /*LV_USE_FREETYPE*/
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* @file lv_freetype.h
|
||||
*
|
||||
*/
|
||||
#ifndef LV_FREETYPE_H
|
||||
#define LV_FREETYPE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_FREETYPE
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
typedef enum {
|
||||
FT_FONT_STYLE_NORMAL = 0,
|
||||
FT_FONT_STYLE_ITALIC = 1 << 0,
|
||||
FT_FONT_STYLE_BOLD = 1 << 1
|
||||
} LV_FT_FONT_STYLE;
|
||||
|
||||
typedef struct {
|
||||
const char * name; /* The name of the font file */
|
||||
const void * mem; /* The pointer of the font file */
|
||||
size_t mem_size; /* The size of the memory */
|
||||
lv_font_t * font; /* point to lvgl font */
|
||||
uint16_t weight; /* font size */
|
||||
uint16_t style; /* font style */
|
||||
} lv_ft_info_t;
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* init freetype library
|
||||
* @param max_faces Maximum number of opened FT_Face objects managed by this cache instance. Use 0 for defaults.
|
||||
* @param max_sizes Maximum number of opened FT_Size objects managed by this cache instance. Use 0 for defaults.
|
||||
* @param max_bytes Maximum number of bytes to use for cached data nodes. Use 0 for defaults.
|
||||
* Note that this value does not account for managed FT_Face and FT_Size objects.
|
||||
* @return true on success, otherwise false.
|
||||
*/
|
||||
bool lv_freetype_init(uint16_t max_faces, uint16_t max_sizes, uint32_t max_bytes);
|
||||
|
||||
/**
|
||||
* Destroy freetype library
|
||||
*/
|
||||
void lv_freetype_destroy(void);
|
||||
|
||||
/**
|
||||
* Creates a font with info parameter specified.
|
||||
* @param info See lv_ft_info_t for details.
|
||||
* when success, lv_ft_info_t->font point to the font you created.
|
||||
* @return true on success, otherwise false.
|
||||
*/
|
||||
bool lv_ft_font_init(lv_ft_info_t * info);
|
||||
|
||||
/**
|
||||
* Destroy a font that has been created.
|
||||
* @param font pointer to font.
|
||||
*/
|
||||
void lv_ft_font_destroy(lv_font_t * font);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_FREETYPE*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* LV_FREETYPE_H */
|
||||
@@ -0,0 +1,290 @@
|
||||
/**
|
||||
* @file lv_fs_fatfs.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
|
||||
#if LV_USE_FS_FATFS
|
||||
#include "ff.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
#if LV_FS_FATFS_LETTER == '\0'
|
||||
#error "LV_FS_FATFS_LETTER must be an upper case ASCII letter"
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static void fs_init(void);
|
||||
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
void lv_fs_fatfs_init(void)
|
||||
{
|
||||
/*----------------------------------------------------
|
||||
* Initialize your storage device and File System
|
||||
* -------------------------------------------------*/
|
||||
fs_init();
|
||||
|
||||
/*---------------------------------------------------
|
||||
* Register the file system interface in LVGL
|
||||
*--------------------------------------------------*/
|
||||
|
||||
/*Add a simple drive to open images*/
|
||||
static lv_fs_drv_t fs_drv; /*A driver descriptor*/
|
||||
lv_fs_drv_init(&fs_drv);
|
||||
|
||||
/*Set up fields...*/
|
||||
fs_drv.letter = LV_FS_FATFS_LETTER;
|
||||
fs_drv.cache_size = LV_FS_FATFS_CACHE_SIZE;
|
||||
|
||||
fs_drv.open_cb = fs_open;
|
||||
fs_drv.close_cb = fs_close;
|
||||
fs_drv.read_cb = fs_read;
|
||||
fs_drv.write_cb = fs_write;
|
||||
fs_drv.seek_cb = fs_seek;
|
||||
fs_drv.tell_cb = fs_tell;
|
||||
|
||||
fs_drv.dir_close_cb = fs_dir_close;
|
||||
fs_drv.dir_open_cb = fs_dir_open;
|
||||
fs_drv.dir_read_cb = fs_dir_read;
|
||||
|
||||
lv_fs_drv_register(&fs_drv);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/*Initialize your Storage device and File system.*/
|
||||
static void fs_init(void)
|
||||
{
|
||||
/*Initialize the SD card and FatFS itself.
|
||||
*Better to do it in your code to keep this library untouched for easy updating*/
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
|
||||
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
|
||||
* @return pointer to FIL struct or NULL in case of fail
|
||||
*/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
uint8_t flags = 0;
|
||||
|
||||
if(mode == LV_FS_MODE_WR) flags = FA_WRITE | FA_OPEN_ALWAYS;
|
||||
else if(mode == LV_FS_MODE_RD) flags = FA_READ;
|
||||
else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = FA_READ | FA_WRITE | FA_OPEN_ALWAYS;
|
||||
|
||||
FIL * f = lv_mem_alloc(sizeof(FIL));
|
||||
if(f == NULL) return NULL;
|
||||
|
||||
FRESULT res = f_open(f, path, flags);
|
||||
if(res == FR_OK) {
|
||||
return f;
|
||||
}
|
||||
else {
|
||||
lv_mem_free(f);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FIL variable. (opened with fs_open)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
f_close(file_p);
|
||||
lv_mem_free(file_p);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read data from an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FIL variable.
|
||||
* @param buf pointer to a memory block where to store the read data
|
||||
* @param btr number of Bytes To Read
|
||||
* @param br the real number of read bytes (Byte Read)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
FRESULT res = f_read(file_p, buf, btr, (UINT *)br);
|
||||
if(res == FR_OK) return LV_FS_RES_OK;
|
||||
else return LV_FS_RES_UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write into a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FIL variable
|
||||
* @param buf pointer to a buffer with the bytes to write
|
||||
* @param btw Bytes To Write
|
||||
* @param bw the number of real written bytes (Bytes Written). NULL if unused.
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
FRESULT res = f_write(file_p, buf, btw, (UINT *)bw);
|
||||
if(res == FR_OK) return LV_FS_RES_OK;
|
||||
else return LV_FS_RES_UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the read write pointer. Also expand the file size if necessary.
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FIL variable. (opened with fs_open )
|
||||
* @param pos the new position of read write pointer
|
||||
* @param whence only LV_SEEK_SET is supported
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
switch(whence) {
|
||||
case LV_FS_SEEK_SET:
|
||||
f_lseek(file_p, pos);
|
||||
break;
|
||||
case LV_FS_SEEK_CUR:
|
||||
f_lseek(file_p, f_tell((FIL *)file_p) + pos);
|
||||
break;
|
||||
case LV_FS_SEEK_END:
|
||||
f_lseek(file_p, f_size((FIL *)file_p) + pos);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Give the position of the read write pointer
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FIL variable.
|
||||
* @param pos_p pointer to to store the result
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
*pos_p = f_tell((FIL *)file_p);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a 'DIR' variable for directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to a directory
|
||||
* @return pointer to an initialized 'DIR' variable
|
||||
*/
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
DIR * d = lv_mem_alloc(sizeof(DIR));
|
||||
if(d == NULL) return NULL;
|
||||
|
||||
FRESULT res = f_opendir(d, path);
|
||||
if(res != FR_OK) {
|
||||
lv_mem_free(d);
|
||||
d = NULL;
|
||||
}
|
||||
return d;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the next filename from a directory.
|
||||
* The name of the directories will begin with '/'
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' variable
|
||||
* @param fn pointer to a buffer to store the filename
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
FRESULT res;
|
||||
FILINFO fno;
|
||||
fn[0] = '\0';
|
||||
|
||||
do {
|
||||
res = f_readdir(dir_p, &fno);
|
||||
if(res != FR_OK) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
if(fno.fattrib & AM_DIR) {
|
||||
fn[0] = '/';
|
||||
strcpy(&fn[1], fno.fname);
|
||||
}
|
||||
else strcpy(fn, fno.fname);
|
||||
|
||||
} while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
|
||||
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' variable
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
f_closedir(dir_p);
|
||||
lv_mem_free(dir_p);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
#else /*LV_USE_FS_FATFS == 0*/
|
||||
|
||||
#if defined(LV_FS_FATFS_LETTER) && LV_FS_FATFS_LETTER != '\0'
|
||||
#warning "LV_USE_FS_FATFS is not enabled but LV_FS_FATFS_LETTER is set"
|
||||
#endif
|
||||
|
||||
#endif /*LV_USE_FS_POSIX*/
|
||||
|
||||
@@ -0,0 +1,332 @@
|
||||
/**
|
||||
* @file lv_fs_littlefs.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
|
||||
#if LV_USE_FS_LITTLEFS
|
||||
#include "lfs.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
#if LV_FS_LITTLEFS_LETTER == '\0'
|
||||
#error "LV_FS_LITTLEFS_LETTER must be an upper case ASCII letter"
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
|
||||
static void fs_init(void);
|
||||
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
|
||||
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
|
||||
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
|
||||
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
void lv_fs_littlefs_init(void)
|
||||
{
|
||||
/*----------------------------------------------------
|
||||
* Initialize your storage device and File System
|
||||
* -------------------------------------------------*/
|
||||
fs_init();
|
||||
|
||||
/*---------------------------------------------------
|
||||
* Register the file system interface in LVGL
|
||||
*--------------------------------------------------*/
|
||||
|
||||
/*Add a simple drive to open images*/
|
||||
static lv_fs_drv_t fs_drv; /*A driver descriptor*/
|
||||
lv_fs_drv_init(&fs_drv);
|
||||
|
||||
/*Set up fields...*/
|
||||
fs_drv.letter = LV_FS_LITTLEFS_LETTER;
|
||||
fs_drv.cache_size = LV_FS_LITTLEFS_CACHE_SIZE;
|
||||
|
||||
fs_drv.open_cb = fs_open;
|
||||
fs_drv.close_cb = fs_close;
|
||||
fs_drv.read_cb = fs_read;
|
||||
fs_drv.write_cb = fs_write;
|
||||
fs_drv.seek_cb = fs_seek;
|
||||
fs_drv.tell_cb = fs_tell;
|
||||
|
||||
fs_drv.dir_open_cb = fs_dir_open;
|
||||
fs_drv.dir_close_cb = fs_dir_close;
|
||||
fs_drv.dir_read_cb = fs_dir_read;
|
||||
|
||||
/*#if LV_USE_USER_DATA*/
|
||||
fs_drv.user_data = NULL;
|
||||
/*#endif*/
|
||||
|
||||
lv_fs_drv_register(&fs_drv);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convenience function to attach registered driver to lfs_t structure by driver-label
|
||||
* @param label the label assigned to the driver when it was registered
|
||||
* @param lfs_p the pointer to the lfs_t structure initialized by external code/library
|
||||
* @return pointer to a driver descriptor or NULL on error
|
||||
*/
|
||||
lv_fs_drv_t * lv_fs_littlefs_set_driver(char label, void * lfs_p)
|
||||
{
|
||||
lv_fs_drv_t * drv_p = lv_fs_get_drv(label);
|
||||
if(drv_p != NULL) drv_p->user_data = (lfs_t *) lfs_p;
|
||||
return drv_p;
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/*Initialize your Storage device and File system.*/
|
||||
static void fs_init(void)
|
||||
{
|
||||
/* Initialize the internal flash or SD-card and LittleFS itself.
|
||||
* Better to do it in your code to keep this library untouched for easy updating */
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
|
||||
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
|
||||
* @return pointer to a file descriptor or NULL on error
|
||||
*/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
uint32_t flags = 0;
|
||||
|
||||
flags = mode == LV_FS_MODE_RD ? LFS_O_RDONLY
|
||||
: mode == LV_FS_MODE_WR ? LFS_O_WRONLY
|
||||
: mode == (LV_FS_MODE_WR | LV_FS_MODE_RD) ? LFS_O_RDWR : 0;
|
||||
|
||||
lfs_file_t * file_p = lv_mem_alloc(sizeof(lfs_file_t));
|
||||
if(file_p == NULL) return NULL;
|
||||
|
||||
int result = lfs_file_open(lfs_p, file_p, path, flags);
|
||||
|
||||
if(result != LFS_ERR_OK) {
|
||||
lv_mem_free(file_p);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return file_p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable. (opened with fs_open)
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
int result = lfs_file_close(lfs_p, file_p);
|
||||
lv_mem_free(file_p);
|
||||
/*lv_mem_free( lfs_p );*/ /*allocated and freed by outside-code*/
|
||||
|
||||
if(result != LFS_ERR_OK) return LV_FS_RES_UNKNOWN;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read data from an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable.
|
||||
* @param buf pointer to a memory block where to store the read data
|
||||
* @param btr number of Bytes To Read
|
||||
* @param br the real number of read bytes (Byte Read)
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_ssize_t result = lfs_file_read(lfs_p, file_p, buf, btr);
|
||||
if(result < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
*br = (uint32_t) result;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write into a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable
|
||||
* @param buf pointer to a buffer with the bytes to write
|
||||
* @param btw Bytes To Write
|
||||
* @param bw the number of real written bytes (Bytes Written). NULL if unused.
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
|
||||
{
|
||||
#ifndef LFS_READONLY
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_ssize_t result = lfs_file_write(lfs_p, file_p, buf, btw);
|
||||
if(result < 0 || lfs_file_sync(lfs_p, file_p) < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
*bw = (uint32_t) result;
|
||||
return LV_FS_RES_OK;
|
||||
#else
|
||||
return LV_FS_RES_NOT_IMP;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the read write pointer. Also expand the file size if necessary.
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable. (opened with fs_open )
|
||||
* @param pos the new position of read write pointer
|
||||
* @param whence tells from where to interpret the `pos`. See @lv_fs_whence_t
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
int lfs_whence = whence == LV_FS_SEEK_SET ? LFS_SEEK_SET
|
||||
: whence == LV_FS_SEEK_CUR ? LFS_SEEK_CUR
|
||||
: whence == LV_FS_SEEK_END ? LFS_SEEK_END : 0;
|
||||
|
||||
lfs_soff_t result = lfs_file_seek(lfs_p, file_p, pos, lfs_whence);
|
||||
if(result < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
/*pos = result;*/ /*not supported by lv_fs*/
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Give the position of the read write pointer
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a file_t variable.
|
||||
* @param pos_p pointer to where to store the result
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_soff_t result = lfs_file_tell(lfs_p, file_p);
|
||||
if(result < 0) return LV_FS_RES_UNKNOWN;
|
||||
|
||||
*pos_p = (uint32_t) result;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a 'lv_fs_dir_t' variable for directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to a directory
|
||||
* @return pointer to the directory read descriptor or NULL on error
|
||||
*/
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
lfs_dir_t * dir_p = lv_mem_alloc(sizeof(lfs_dir_t));
|
||||
if(dir_p == NULL) return NULL;
|
||||
|
||||
int result = lfs_dir_open(lfs_p, dir_p, path);
|
||||
if(result != LFS_ERR_OK) {
|
||||
lv_mem_free(dir_p);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return dir_p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the next filename form a directory.
|
||||
* The name of the directories will begin with '/'
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
|
||||
* @param fn pointer to a buffer to store the filename
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * rddir_p, char * fn)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
struct lfs_info info;
|
||||
int result;
|
||||
|
||||
info.name[0] = '\0';
|
||||
|
||||
do {
|
||||
result = lfs_dir_read(lfs_p, rddir_p, &info);
|
||||
if(result > 0) {
|
||||
if(info.type == LFS_TYPE_DIR) {
|
||||
fn[0] = '/';
|
||||
strcpy(&fn[1], info.name);
|
||||
}
|
||||
else strcpy(fn, info.name);
|
||||
}
|
||||
else if(result == 0) fn[0] = '\0'; /*dir-scan ended*/
|
||||
else return LV_FS_RES_UNKNOWN;
|
||||
|
||||
} while(!strcmp(fn, "/.") || !strcmp(fn, "/.."));
|
||||
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
|
||||
* @return LV_FS_RES_OK: no error or any error from @lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * rddir_p)
|
||||
{
|
||||
lfs_t * lfs_p = drv->user_data;
|
||||
|
||||
int result = lfs_dir_close(lfs_p, rddir_p);
|
||||
lv_mem_free(rddir_p);
|
||||
|
||||
if(result != LFS_ERR_OK) return LV_FS_RES_UNKNOWN;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
#else /*LV_USE_FS_LITTLEFS == 0*/
|
||||
|
||||
#if defined(LV_FS_LITTLEFS_LETTER) && LV_FS_LITTLEFS_LETTER != '\0'
|
||||
#warning "LV_USE_FS_LITTLEFS is not enabled but LV_FS_LITTLEFS_LETTER is set"
|
||||
#endif
|
||||
|
||||
#endif /*LV_USE_FS_POSIX*/
|
||||
@@ -0,0 +1,318 @@
|
||||
/**
|
||||
* @file lv_fs_posix.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
|
||||
#if LV_USE_FS_POSIX
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#ifndef WIN32
|
||||
#include <dirent.h>
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
#if LV_FS_POSIX_LETTER == '\0'
|
||||
#error "LV_FS_POSIX_LETTER must be an upper case ASCII letter"
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Register a driver for the File system interface
|
||||
*/
|
||||
void lv_fs_posix_init(void)
|
||||
{
|
||||
/*---------------------------------------------------
|
||||
* Register the file system interface in LVGL
|
||||
*--------------------------------------------------*/
|
||||
|
||||
/*Add a simple drive to open images*/
|
||||
static lv_fs_drv_t fs_drv; /*A driver descriptor*/
|
||||
lv_fs_drv_init(&fs_drv);
|
||||
|
||||
/*Set up fields...*/
|
||||
fs_drv.letter = LV_FS_POSIX_LETTER;
|
||||
fs_drv.cache_size = LV_FS_POSIX_CACHE_SIZE;
|
||||
|
||||
fs_drv.open_cb = fs_open;
|
||||
fs_drv.close_cb = fs_close;
|
||||
fs_drv.read_cb = fs_read;
|
||||
fs_drv.write_cb = fs_write;
|
||||
fs_drv.seek_cb = fs_seek;
|
||||
fs_drv.tell_cb = fs_tell;
|
||||
|
||||
fs_drv.dir_close_cb = fs_dir_close;
|
||||
fs_drv.dir_open_cb = fs_dir_open;
|
||||
fs_drv.dir_read_cb = fs_dir_read;
|
||||
|
||||
lv_fs_drv_register(&fs_drv);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Open a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
|
||||
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
|
||||
* @return a file handle or -1 in case of fail
|
||||
*/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
uint32_t flags = 0;
|
||||
if(mode == LV_FS_MODE_WR) flags = O_WRONLY | O_CREAT;
|
||||
else if(mode == LV_FS_MODE_RD) flags = O_RDONLY;
|
||||
else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = O_RDWR | O_CREAT;
|
||||
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
char buf[256];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_POSIX_PATH "%s", path);
|
||||
|
||||
int f = open(buf, flags, 0666);
|
||||
if(f < 0) return NULL;
|
||||
|
||||
return (void *)(lv_uintptr_t)f;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p a file handle. (opened with fs_open)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
close((lv_uintptr_t)file_p);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read data from an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p a file handle variable.
|
||||
* @param buf pointer to a memory block where to store the read data
|
||||
* @param btr number of Bytes To Read
|
||||
* @param br the real number of read bytes (Byte Read)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
*br = read((lv_uintptr_t)file_p, buf, btr);
|
||||
return (int32_t)(*br) < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write into a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p a file handle variable
|
||||
* @param buf pointer to a buffer with the bytes to write
|
||||
* @param btw Bytes To Write
|
||||
* @param bw the number of real written bytes (Bytes Written). NULL if unused.
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
*bw = write((lv_uintptr_t)file_p, buf, btw);
|
||||
return (int32_t)(*bw) < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the read write pointer. Also expand the file size if necessary.
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p a file handle variable. (opened with fs_open )
|
||||
* @param pos the new position of read write pointer
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
off_t offset = lseek((lv_uintptr_t)file_p, pos, whence);
|
||||
return offset < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Give the position of the read write pointer
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p a file handle variable.
|
||||
* @param pos_p pointer to to store the result
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
off_t offset = lseek((lv_uintptr_t)file_p, 0, SEEK_CUR);
|
||||
*pos_p = offset;
|
||||
return offset < 0 ? LV_FS_RES_FS_ERR : LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
static char next_fn[256];
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Initialize a 'fs_read_dir_t' variable for directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to a directory
|
||||
* @return pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
*/
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
#ifndef WIN32
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
char buf[256];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_POSIX_PATH "%s", path);
|
||||
return opendir(buf);
|
||||
#else
|
||||
HANDLE d = INVALID_HANDLE_VALUE;
|
||||
WIN32_FIND_DATA fdata;
|
||||
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
char buf[256];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_POSIX_PATH "%s\\*", path);
|
||||
|
||||
strcpy(next_fn, "");
|
||||
d = FindFirstFile(buf, &fdata);
|
||||
do {
|
||||
if(strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
||||
sprintf(next_fn, "/%s", fdata.cFileName);
|
||||
}
|
||||
else {
|
||||
sprintf(next_fn, "%s", fdata.cFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while(FindNextFileA(d, &fdata));
|
||||
|
||||
return d;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the next filename from a directory.
|
||||
* The name of the directories will begin with '/'
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
* @param fn pointer to a buffer to store the filename
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
#ifndef WIN32
|
||||
struct dirent * entry;
|
||||
do {
|
||||
entry = readdir(dir_p);
|
||||
if(entry) {
|
||||
if(entry->d_type == DT_DIR) sprintf(fn, "/%s", entry->d_name);
|
||||
else strcpy(fn, entry->d_name);
|
||||
}
|
||||
else {
|
||||
strcpy(fn, "");
|
||||
}
|
||||
} while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
|
||||
#else
|
||||
strcpy(fn, next_fn);
|
||||
|
||||
strcpy(next_fn, "");
|
||||
WIN32_FIND_DATA fdata;
|
||||
|
||||
if(FindNextFile(dir_p, &fdata) == false) return LV_FS_RES_OK;
|
||||
do {
|
||||
if(strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
||||
sprintf(next_fn, "/%s", fdata.cFileName);
|
||||
}
|
||||
else {
|
||||
sprintf(next_fn, "%s", fdata.cFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while(FindNextFile(dir_p, &fdata));
|
||||
|
||||
#endif
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
#ifndef WIN32
|
||||
closedir(dir_p);
|
||||
#else
|
||||
FindClose(dir_p);
|
||||
#endif
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
#else /*LV_USE_FS_POSIX == 0*/
|
||||
|
||||
#if defined(LV_FS_POSIX_LETTER) && LV_FS_POSIX_LETTER != '\0'
|
||||
#warning "LV_USE_FS_POSIX is not enabled but LV_FS_POSIX_LETTER is set"
|
||||
#endif
|
||||
|
||||
#endif /*LV_USE_FS_POSIX*/
|
||||
@@ -0,0 +1,327 @@
|
||||
/**
|
||||
* @file lv_fs_stdio.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_FS_STDIO != '\0'
|
||||
|
||||
#include <stdio.h>
|
||||
#ifndef WIN32
|
||||
#include <dirent.h>
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#define MAX_PATH_LEN 256
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
typedef struct {
|
||||
#ifdef WIN32
|
||||
HANDLE dir_p;
|
||||
char next_fn[MAX_PATH_LEN];
|
||||
#else
|
||||
DIR * dir_p;
|
||||
#endif
|
||||
} dir_handle_t;
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Register a driver for the File system interface
|
||||
*/
|
||||
void lv_fs_stdio_init(void)
|
||||
{
|
||||
/*---------------------------------------------------
|
||||
* Register the file system interface in LVGL
|
||||
*--------------------------------------------------*/
|
||||
|
||||
/*Add a simple drive to open images*/
|
||||
static lv_fs_drv_t fs_drv; /*A driver descriptor*/
|
||||
lv_fs_drv_init(&fs_drv);
|
||||
|
||||
/*Set up fields...*/
|
||||
fs_drv.letter = LV_FS_STDIO_LETTER;
|
||||
fs_drv.cache_size = LV_FS_STDIO_CACHE_SIZE;
|
||||
|
||||
fs_drv.open_cb = fs_open;
|
||||
fs_drv.close_cb = fs_close;
|
||||
fs_drv.read_cb = fs_read;
|
||||
fs_drv.write_cb = fs_write;
|
||||
fs_drv.seek_cb = fs_seek;
|
||||
fs_drv.tell_cb = fs_tell;
|
||||
|
||||
fs_drv.dir_close_cb = fs_dir_close;
|
||||
fs_drv.dir_open_cb = fs_dir_open;
|
||||
fs_drv.dir_read_cb = fs_dir_read;
|
||||
|
||||
lv_fs_drv_register(&fs_drv);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Open a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
|
||||
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
|
||||
* @return pointer to FIL struct or NULL in case of fail
|
||||
*/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
const char * flags = "";
|
||||
|
||||
if(mode == LV_FS_MODE_WR) flags = "wb";
|
||||
else if(mode == LV_FS_MODE_RD) flags = "rb";
|
||||
else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = "rb+";
|
||||
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
|
||||
char buf[MAX_PATH_LEN];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_STDIO_PATH "%s", path);
|
||||
|
||||
return fopen(buf, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* Close an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable. (opened with fs_open)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
fclose(file_p);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read data from an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable.
|
||||
* @param buf pointer to a memory block where to store the read data
|
||||
* @param btr number of Bytes To Read
|
||||
* @param br the real number of read bytes (Byte Read)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
*br = fread(buf, 1, btr, file_p);
|
||||
return (int32_t)(*br) < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write into a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable
|
||||
* @param buf pointer to a buffer with the bytes to write
|
||||
* @param btw Bytes To Write
|
||||
* @param bw the number of real written bytes (Bytes Written). NULL if unused.
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
*bw = fwrite(buf, 1, btw, file_p);
|
||||
return (int32_t)(*bw) < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the read write pointer. Also expand the file size if necessary.
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable. (opened with fs_open )
|
||||
* @param pos the new position of read write pointer
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
fseek(file_p, pos, whence);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Give the position of the read write pointer
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable.
|
||||
* @param pos_p pointer to to store the result
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
*pos_p = ftell(file_p);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a 'DIR' or 'HANDLE' variable for directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to a directory
|
||||
* @return pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
*/
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
dir_handle_t * handle = (dir_handle_t *)lv_mem_alloc(sizeof(dir_handle_t));
|
||||
#ifndef WIN32
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
char buf[MAX_PATH_LEN];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_STDIO_PATH "%s", path);
|
||||
handle->dir_p = opendir(buf);
|
||||
if(handle->dir_p == NULL) {
|
||||
lv_mem_free(handle);
|
||||
return NULL;
|
||||
}
|
||||
return handle;
|
||||
#else
|
||||
handle->dir_p = INVALID_HANDLE_VALUE;
|
||||
WIN32_FIND_DATAA fdata;
|
||||
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
char buf[MAX_PATH_LEN];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_STDIO_PATH "%s\\*", path);
|
||||
|
||||
strcpy(handle->next_fn, "");
|
||||
handle->dir_p = FindFirstFileA(buf, &fdata);
|
||||
do {
|
||||
if(strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "/%s", fdata.cFileName);
|
||||
}
|
||||
else {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "%s", fdata.cFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while(FindNextFileA(handle->dir_p, &fdata));
|
||||
|
||||
if(handle->dir_p == INVALID_HANDLE_VALUE) {
|
||||
lv_mem_free(handle);
|
||||
return INVALID_HANDLE_VALUE;
|
||||
}
|
||||
return handle;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the next filename form a directory.
|
||||
* The name of the directories will begin with '/'
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
* @param fn pointer to a buffer to store the filename
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
dir_handle_t * handle = (dir_handle_t *)dir_p;
|
||||
#ifndef WIN32
|
||||
struct dirent * entry;
|
||||
do {
|
||||
entry = readdir(handle->dir_p);
|
||||
if(entry) {
|
||||
if(entry->d_type == DT_DIR) lv_snprintf(fn, MAX_PATH_LEN, "/%s", entry->d_name);
|
||||
else strcpy(fn, entry->d_name);
|
||||
}
|
||||
else {
|
||||
strcpy(fn, "");
|
||||
}
|
||||
} while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
|
||||
#else
|
||||
strcpy(fn, handle->next_fn);
|
||||
|
||||
strcpy(handle->next_fn, "");
|
||||
WIN32_FIND_DATAA fdata;
|
||||
|
||||
if(FindNextFileA(handle->dir_p, &fdata) == false) return LV_FS_RES_OK;
|
||||
do {
|
||||
if(strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "/%s", fdata.cFileName);
|
||||
}
|
||||
else {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "%s", fdata.cFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while(FindNextFileA(handle->dir_p, &fdata));
|
||||
|
||||
#endif
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
dir_handle_t * handle = (dir_handle_t *)dir_p;
|
||||
#ifndef WIN32
|
||||
closedir(handle->dir_p);
|
||||
#else
|
||||
FindClose(handle->dir_p);
|
||||
#endif
|
||||
lv_mem_free(handle);
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
|
||||
#else /*LV_USE_FS_STDIO == 0*/
|
||||
|
||||
#if defined(LV_FS_STDIO_LETTER) && LV_FS_STDIO_LETTER != '\0'
|
||||
#warning "LV_USE_FS_STDIO is not enabled but LV_FS_STDIO_LETTER is set"
|
||||
#endif
|
||||
|
||||
#endif /*LV_USE_FS_POSIX*/
|
||||
@@ -0,0 +1,465 @@
|
||||
/**
|
||||
* @file lv_fs_win32.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_FS_WIN32 != '\0'
|
||||
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#define MAX_PATH_LEN 256
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
typedef struct {
|
||||
HANDLE dir_p;
|
||||
char next_fn[MAX_PATH_LEN];
|
||||
lv_fs_res_t next_error;
|
||||
} dir_handle_t;
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
|
||||
static bool is_dots_name(const char * name);
|
||||
static lv_fs_res_t fs_error_from_win32(DWORD error);
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Register a driver for the File system interface
|
||||
*/
|
||||
void lv_fs_win32_init(void)
|
||||
{
|
||||
/*---------------------------------------------------
|
||||
* Register the file system interface in LVGL
|
||||
*--------------------------------------------------*/
|
||||
|
||||
/*Add a simple driver to open images*/
|
||||
static lv_fs_drv_t fs_drv; /*A driver descriptor*/
|
||||
lv_fs_drv_init(&fs_drv);
|
||||
|
||||
/*Set up fields...*/
|
||||
fs_drv.letter = LV_FS_WIN32_LETTER;
|
||||
fs_drv.cache_size = LV_FS_WIN32_CACHE_SIZE;
|
||||
|
||||
fs_drv.open_cb = fs_open;
|
||||
fs_drv.close_cb = fs_close;
|
||||
fs_drv.read_cb = fs_read;
|
||||
fs_drv.write_cb = fs_write;
|
||||
fs_drv.seek_cb = fs_seek;
|
||||
fs_drv.tell_cb = fs_tell;
|
||||
|
||||
fs_drv.dir_close_cb = fs_dir_close;
|
||||
fs_drv.dir_open_cb = fs_dir_open;
|
||||
fs_drv.dir_read_cb = fs_dir_read;
|
||||
|
||||
lv_fs_drv_register(&fs_drv);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Check the dots name
|
||||
* @param name file or dir name
|
||||
* @return true if the name is dots name
|
||||
*/
|
||||
static bool is_dots_name(const char * name)
|
||||
{
|
||||
return name[0] == '.' && (!name[1] || (name[1] == '.' && !name[2]));
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Win32 error code to error from lv_fs_res_t enum
|
||||
* @param error Win32 error code
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_error_from_win32(DWORD error)
|
||||
{
|
||||
lv_fs_res_t res;
|
||||
|
||||
switch(error) {
|
||||
case ERROR_SUCCESS:
|
||||
res = LV_FS_RES_OK;
|
||||
break;
|
||||
case ERROR_BAD_UNIT:
|
||||
case ERROR_NOT_READY:
|
||||
case ERROR_CRC:
|
||||
case ERROR_SEEK:
|
||||
case ERROR_NOT_DOS_DISK:
|
||||
case ERROR_WRITE_FAULT:
|
||||
case ERROR_READ_FAULT:
|
||||
case ERROR_GEN_FAILURE:
|
||||
case ERROR_WRONG_DISK:
|
||||
res = LV_FS_RES_HW_ERR;
|
||||
break;
|
||||
case ERROR_INVALID_HANDLE:
|
||||
case ERROR_INVALID_TARGET_HANDLE:
|
||||
res = LV_FS_RES_FS_ERR;
|
||||
break;
|
||||
case ERROR_FILE_NOT_FOUND:
|
||||
case ERROR_PATH_NOT_FOUND:
|
||||
case ERROR_INVALID_DRIVE:
|
||||
case ERROR_NO_MORE_FILES:
|
||||
case ERROR_SECTOR_NOT_FOUND:
|
||||
case ERROR_BAD_NETPATH:
|
||||
case ERROR_BAD_NET_NAME:
|
||||
case ERROR_BAD_PATHNAME:
|
||||
case ERROR_FILENAME_EXCED_RANGE:
|
||||
res = LV_FS_RES_NOT_EX;
|
||||
break;
|
||||
case ERROR_DISK_FULL:
|
||||
res = LV_FS_RES_FULL;
|
||||
break;
|
||||
case ERROR_SHARING_VIOLATION:
|
||||
case ERROR_LOCK_VIOLATION:
|
||||
case ERROR_DRIVE_LOCKED:
|
||||
res = LV_FS_RES_LOCKED;
|
||||
break;
|
||||
case ERROR_ACCESS_DENIED:
|
||||
case ERROR_CURRENT_DIRECTORY:
|
||||
case ERROR_WRITE_PROTECT:
|
||||
case ERROR_NETWORK_ACCESS_DENIED:
|
||||
case ERROR_CANNOT_MAKE:
|
||||
case ERROR_FAIL_I24:
|
||||
case ERROR_SEEK_ON_DEVICE:
|
||||
case ERROR_NOT_LOCKED:
|
||||
case ERROR_LOCK_FAILED:
|
||||
res = LV_FS_RES_DENIED;
|
||||
break;
|
||||
case ERROR_BUSY:
|
||||
res = LV_FS_RES_BUSY;
|
||||
break;
|
||||
case ERROR_TIMEOUT:
|
||||
res = LV_FS_RES_TOUT;
|
||||
break;
|
||||
case ERROR_NOT_SAME_DEVICE:
|
||||
case ERROR_DIRECT_ACCESS_HANDLE:
|
||||
res = LV_FS_RES_NOT_IMP;
|
||||
break;
|
||||
case ERROR_TOO_MANY_OPEN_FILES:
|
||||
case ERROR_ARENA_TRASHED:
|
||||
case ERROR_NOT_ENOUGH_MEMORY:
|
||||
case ERROR_INVALID_BLOCK:
|
||||
case ERROR_OUT_OF_PAPER:
|
||||
case ERROR_SHARING_BUFFER_EXCEEDED:
|
||||
case ERROR_NOT_ENOUGH_QUOTA:
|
||||
res = LV_FS_RES_OUT_OF_MEM;
|
||||
break;
|
||||
case ERROR_INVALID_FUNCTION:
|
||||
case ERROR_INVALID_ACCESS:
|
||||
case ERROR_INVALID_DATA:
|
||||
case ERROR_BAD_COMMAND:
|
||||
case ERROR_BAD_LENGTH:
|
||||
case ERROR_INVALID_PARAMETER:
|
||||
case ERROR_NEGATIVE_SEEK:
|
||||
res = LV_FS_RES_INV_PARAM;
|
||||
break;
|
||||
default:
|
||||
res = LV_FS_RES_UNKNOWN;
|
||||
break;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
|
||||
* @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
|
||||
* @return pointer to FIL struct or NULL in case of fail
|
||||
*/
|
||||
static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
DWORD desired_access = 0;
|
||||
|
||||
if(mode & LV_FS_MODE_RD) {
|
||||
desired_access |= GENERIC_READ;
|
||||
}
|
||||
|
||||
if(mode & LV_FS_MODE_WR) {
|
||||
desired_access |= GENERIC_WRITE;
|
||||
}
|
||||
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
|
||||
char buf[MAX_PATH];
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_WIN32_PATH "%s", path);
|
||||
|
||||
return (void *)CreateFileA(
|
||||
buf,
|
||||
desired_access,
|
||||
FILE_SHARE_READ,
|
||||
NULL,
|
||||
OPEN_EXISTING,
|
||||
FILE_ATTRIBUTE_NORMAL,
|
||||
NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Close an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable. (opened with fs_open)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
return CloseHandle((HANDLE)file_p)
|
||||
? LV_FS_RES_OK
|
||||
: fs_error_from_win32(GetLastError());
|
||||
}
|
||||
|
||||
/**
|
||||
* Read data from an opened file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable.
|
||||
* @param buf pointer to a memory block where to store the read data
|
||||
* @param btr number of Bytes To Read
|
||||
* @param br the real number of read bytes (Byte Read)
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
return ReadFile((HANDLE)file_p, buf, btr, (LPDWORD)br, NULL)
|
||||
? LV_FS_RES_OK
|
||||
: fs_error_from_win32(GetLastError());
|
||||
}
|
||||
|
||||
/**
|
||||
* Write into a file
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable
|
||||
* @param buf pointer to a buffer with the bytes to write
|
||||
* @param btw Bytes To Write
|
||||
* @param bw the number of real written bytes (Bytes Written). NULL if unused.
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
return WriteFile((HANDLE)file_p, buf, btw, (LPDWORD)bw, NULL)
|
||||
? LV_FS_RES_OK
|
||||
: fs_error_from_win32(GetLastError());
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the read write pointer. Also expand the file size if necessary.
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable. (opened with fs_open )
|
||||
* @param pos the new position of read write pointer
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
DWORD move_method = (DWORD) -1;
|
||||
if(whence == LV_FS_SEEK_SET) {
|
||||
move_method = FILE_BEGIN;
|
||||
}
|
||||
else if(whence == LV_FS_SEEK_CUR) {
|
||||
move_method = FILE_CURRENT;
|
||||
}
|
||||
else if(whence == LV_FS_SEEK_END) {
|
||||
move_method = FILE_END;
|
||||
}
|
||||
|
||||
LARGE_INTEGER distance_to_move;
|
||||
distance_to_move.QuadPart = pos;
|
||||
return SetFilePointerEx((HANDLE)file_p, distance_to_move, NULL, move_method)
|
||||
? LV_FS_RES_OK
|
||||
: fs_error_from_win32(GetLastError());
|
||||
}
|
||||
|
||||
/**
|
||||
* Give the position of the read write pointer
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param file_p pointer to a FILE variable.
|
||||
* @param pos_p pointer to to store the result
|
||||
* @return LV_FS_RES_OK: no error, the file is read
|
||||
* any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
|
||||
if(!pos_p) {
|
||||
return LV_FS_RES_INV_PARAM;
|
||||
}
|
||||
|
||||
LARGE_INTEGER file_pointer;
|
||||
file_pointer.QuadPart = 0;
|
||||
|
||||
LARGE_INTEGER distance_to_move;
|
||||
distance_to_move.QuadPart = 0;
|
||||
if(SetFilePointerEx(
|
||||
(HANDLE)file_p,
|
||||
distance_to_move,
|
||||
&file_pointer,
|
||||
FILE_CURRENT)) {
|
||||
if(file_pointer.QuadPart > LONG_MAX) {
|
||||
return LV_FS_RES_INV_PARAM;
|
||||
}
|
||||
else {
|
||||
*pos_p = file_pointer.LowPart;
|
||||
return LV_FS_RES_OK;
|
||||
}
|
||||
}
|
||||
else {
|
||||
return fs_error_from_win32(GetLastError());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a 'DIR' or 'HANDLE' variable for directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param path path to a directory
|
||||
* @return pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
*/
|
||||
static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
dir_handle_t * handle = (dir_handle_t *)lv_mem_alloc(sizeof(dir_handle_t));
|
||||
handle->dir_p = INVALID_HANDLE_VALUE;
|
||||
handle->next_error = LV_FS_RES_OK;
|
||||
WIN32_FIND_DATAA fdata;
|
||||
|
||||
/*Make the path relative to the current directory (the projects root folder)*/
|
||||
char buf[MAX_PATH_LEN];
|
||||
#ifdef LV_FS_WIN32_PATH
|
||||
lv_snprintf(buf, sizeof(buf), LV_FS_WIN32_PATH "%s\\*", path);
|
||||
#else
|
||||
lv_snprintf(buf, sizeof(buf), "%s\\*", path);
|
||||
#endif
|
||||
|
||||
strcpy(handle->next_fn, "");
|
||||
handle->dir_p = FindFirstFileA(buf, &fdata);
|
||||
do {
|
||||
if(is_dots_name(fdata.cFileName)) {
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "/%s", fdata.cFileName);
|
||||
}
|
||||
else {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "%s", fdata.cFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while(FindNextFileA(handle->dir_p, &fdata));
|
||||
|
||||
if(handle->dir_p == INVALID_HANDLE_VALUE) {
|
||||
lv_mem_free(handle);
|
||||
handle->next_error = fs_error_from_win32(GetLastError());
|
||||
return INVALID_HANDLE_VALUE;
|
||||
}
|
||||
else {
|
||||
handle->next_error = LV_FS_RES_OK;
|
||||
return handle;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the next filename from a directory.
|
||||
* The name of the directories will begin with '/'
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
* @param fn pointer to a buffer to store the filename
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
dir_handle_t * handle = (dir_handle_t *)dir_p;
|
||||
strcpy(fn, handle->next_fn);
|
||||
lv_fs_res_t current_error = handle->next_error;
|
||||
strcpy(handle->next_fn, "");
|
||||
|
||||
WIN32_FIND_DATAA fdata;
|
||||
|
||||
while(FindNextFileA(handle->dir_p, &fdata)) {
|
||||
if(is_dots_name(fdata.cFileName)) {
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
if(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "/%s", fdata.cFileName);
|
||||
}
|
||||
else {
|
||||
lv_snprintf(handle->next_fn, sizeof(handle->next_fn), "%s", fdata.cFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(handle->next_fn[0] == '\0') {
|
||||
handle->next_error = fs_error_from_win32(GetLastError());
|
||||
}
|
||||
|
||||
return current_error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the directory reading
|
||||
* @param drv pointer to a driver where this function belongs
|
||||
* @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
|
||||
* @return LV_FS_RES_OK or any error from lv_fs_res_t enum
|
||||
*/
|
||||
static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
|
||||
{
|
||||
LV_UNUSED(drv);
|
||||
dir_handle_t * handle = (dir_handle_t *)dir_p;
|
||||
lv_fs_res_t res = FindClose(handle->dir_p)
|
||||
? LV_FS_RES_OK
|
||||
: fs_error_from_win32(GetLastError());
|
||||
lv_mem_free(handle);
|
||||
return res;
|
||||
}
|
||||
|
||||
#else /*LV_USE_FS_WIN32 == 0*/
|
||||
|
||||
#if defined(LV_FS_WIN32_LETTER) && LV_FS_WIN32_LETTER != '\0'
|
||||
#warning "LV_USE_FS_WIN32 is not enabled but LV_FS_WIN32_LETTER is set"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* @file lv_fsdrv.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_FSDRV_H
|
||||
#define LV_FSDRV_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lv_conf_internal.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
#if LV_USE_FS_FATFS != '\0'
|
||||
void lv_fs_fatfs_init(void);
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_LITTLEFS != '\0'
|
||||
void lv_fs_littlefs_init(void);
|
||||
lv_fs_drv_t * lv_fs_littlefs_set_driver(char label, void * lfs_p);
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_STDIO != '\0'
|
||||
void lv_fs_stdio_init(void);
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_POSIX != '\0'
|
||||
void lv_fs_posix_init(void);
|
||||
#endif
|
||||
|
||||
#if LV_USE_FS_WIN32 != '\0'
|
||||
void lv_fs_win32_init(void);
|
||||
#endif
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /*LV_FSDRV_H*/
|
||||
|
||||
@@ -0,0 +1,677 @@
|
||||
#include "gifdec.h"
|
||||
#include "../../../misc/lv_log.h"
|
||||
#include "../../../misc/lv_mem.h"
|
||||
#include "../../../misc/lv_color.h"
|
||||
#if LV_USE_GIF
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#define MIN(A, B) ((A) < (B) ? (A) : (B))
|
||||
#define MAX(A, B) ((A) > (B) ? (A) : (B))
|
||||
|
||||
typedef struct Entry {
|
||||
uint16_t length;
|
||||
uint16_t prefix;
|
||||
uint8_t suffix;
|
||||
} Entry;
|
||||
|
||||
typedef struct Table {
|
||||
int bulk;
|
||||
int nentries;
|
||||
Entry *entries;
|
||||
} Table;
|
||||
|
||||
static gd_GIF * gif_open(gd_GIF * gif);
|
||||
static bool f_gif_open(gd_GIF * gif, const void * path, bool is_file);
|
||||
static void f_gif_read(gd_GIF * gif, void * buf, size_t len);
|
||||
static int f_gif_seek(gd_GIF * gif, size_t pos, int k);
|
||||
static void f_gif_close(gd_GIF * gif);
|
||||
|
||||
static uint16_t
|
||||
read_num(gd_GIF * gif)
|
||||
{
|
||||
uint8_t bytes[2];
|
||||
|
||||
f_gif_read(gif, bytes, 2);
|
||||
return bytes[0] + (((uint16_t) bytes[1]) << 8);
|
||||
}
|
||||
|
||||
|
||||
|
||||
gd_GIF *
|
||||
gd_open_gif_file(const char *fname)
|
||||
{
|
||||
gd_GIF gif_base;
|
||||
memset(&gif_base, 0, sizeof(gif_base));
|
||||
|
||||
bool res = f_gif_open(&gif_base, fname, true);
|
||||
if(!res) return NULL;
|
||||
|
||||
return gif_open(&gif_base);
|
||||
}
|
||||
|
||||
|
||||
gd_GIF *
|
||||
gd_open_gif_data(const void *data)
|
||||
{
|
||||
gd_GIF gif_base;
|
||||
memset(&gif_base, 0, sizeof(gif_base));
|
||||
|
||||
bool res = f_gif_open(&gif_base, data, false);
|
||||
if(!res) return NULL;
|
||||
|
||||
return gif_open(&gif_base);
|
||||
}
|
||||
|
||||
static gd_GIF * gif_open(gd_GIF * gif_base)
|
||||
{
|
||||
uint8_t sigver[3];
|
||||
uint16_t width, height, depth;
|
||||
uint8_t fdsz, bgidx, aspect;
|
||||
int i;
|
||||
uint8_t *bgcolor;
|
||||
int gct_sz;
|
||||
gd_GIF *gif = NULL;
|
||||
|
||||
/* Header */
|
||||
f_gif_read(gif_base, sigver, 3);
|
||||
if (memcmp(sigver, "GIF", 3) != 0) {
|
||||
LV_LOG_WARN("invalid signature\n");
|
||||
goto fail;
|
||||
}
|
||||
/* Version */
|
||||
f_gif_read(gif_base, sigver, 3);
|
||||
if (memcmp(sigver, "89a", 3) != 0) {
|
||||
LV_LOG_WARN("invalid version\n");
|
||||
goto fail;
|
||||
}
|
||||
/* Width x Height */
|
||||
width = read_num(gif_base);
|
||||
height = read_num(gif_base);
|
||||
/* FDSZ */
|
||||
f_gif_read(gif_base, &fdsz, 1);
|
||||
/* Presence of GCT */
|
||||
if (!(fdsz & 0x80)) {
|
||||
LV_LOG_WARN("no global color table\n");
|
||||
goto fail;
|
||||
}
|
||||
/* Color Space's Depth */
|
||||
depth = ((fdsz >> 4) & 7) + 1;
|
||||
/* Ignore Sort Flag. */
|
||||
/* GCT Size */
|
||||
gct_sz = 1 << ((fdsz & 0x07) + 1);
|
||||
/* Background Color Index */
|
||||
f_gif_read(gif_base, &bgidx, 1);
|
||||
/* Aspect Ratio */
|
||||
f_gif_read(gif_base, &aspect, 1);
|
||||
/* Create gd_GIF Structure. */
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
gif = lv_mem_alloc(sizeof(gd_GIF) + 5 * width * height);
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
gif = lv_mem_alloc(sizeof(gd_GIF) + 4 * width * height);
|
||||
#elif LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
|
||||
gif = lv_mem_alloc(sizeof(gd_GIF) + 3 * width * height);
|
||||
#endif
|
||||
|
||||
if (!gif) goto fail;
|
||||
memcpy(gif, gif_base, sizeof(gd_GIF));
|
||||
gif->width = width;
|
||||
gif->height = height;
|
||||
gif->depth = depth;
|
||||
/* Read GCT */
|
||||
gif->gct.size = gct_sz;
|
||||
f_gif_read(gif, gif->gct.colors, 3 * gif->gct.size);
|
||||
gif->palette = &gif->gct;
|
||||
gif->bgindex = bgidx;
|
||||
gif->canvas = (uint8_t *) &gif[1];
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
gif->frame = &gif->canvas[4 * width * height];
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
gif->frame = &gif->canvas[3 * width * height];
|
||||
#elif LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
|
||||
gif->frame = &gif->canvas[2 * width * height];
|
||||
#endif
|
||||
if (gif->bgindex) {
|
||||
memset(gif->frame, gif->bgindex, gif->width * gif->height);
|
||||
}
|
||||
bgcolor = &gif->palette->colors[gif->bgindex*3];
|
||||
|
||||
for (i = 0; i < gif->width * gif->height; i++) {
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
gif->canvas[i*4 + 0] = *(bgcolor + 2);
|
||||
gif->canvas[i*4 + 1] = *(bgcolor + 1);
|
||||
gif->canvas[i*4 + 2] = *(bgcolor + 0);
|
||||
gif->canvas[i*4 + 3] = 0xff;
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
|
||||
gif->canvas[i*3 + 0] = c.full & 0xff;
|
||||
gif->canvas[i*3 + 1] = (c.full >> 8) & 0xff;
|
||||
gif->canvas[i*3 + 2] = 0xff;
|
||||
#elif LV_COLOR_DEPTH == 8
|
||||
lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
|
||||
gif->canvas[i*2 + 0] = c.full;
|
||||
gif->canvas[i*2 + 1] = 0xff;
|
||||
#elif LV_COLOR_DEPTH == 1
|
||||
lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
|
||||
gif->canvas[i*2 + 0] = c.ch.red > 128 ? 1 : 0;
|
||||
gif->canvas[i*2 + 1] = 0xff;
|
||||
#endif
|
||||
}
|
||||
gif->anim_start = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
|
||||
gif->loop_count = -1;
|
||||
goto ok;
|
||||
fail:
|
||||
f_gif_close(gif_base);
|
||||
ok:
|
||||
return gif;
|
||||
}
|
||||
|
||||
static void
|
||||
discard_sub_blocks(gd_GIF *gif)
|
||||
{
|
||||
uint8_t size;
|
||||
|
||||
do {
|
||||
f_gif_read(gif, &size, 1);
|
||||
f_gif_seek(gif, size, LV_FS_SEEK_CUR);
|
||||
} while (size);
|
||||
}
|
||||
|
||||
static void
|
||||
read_plain_text_ext(gd_GIF *gif)
|
||||
{
|
||||
if (gif->plain_text) {
|
||||
uint16_t tx, ty, tw, th;
|
||||
uint8_t cw, ch, fg, bg;
|
||||
size_t sub_block;
|
||||
f_gif_seek(gif, 1, LV_FS_SEEK_CUR); /* block size = 12 */
|
||||
tx = read_num(gif);
|
||||
ty = read_num(gif);
|
||||
tw = read_num(gif);
|
||||
th = read_num(gif);
|
||||
f_gif_read(gif, &cw, 1);
|
||||
f_gif_read(gif, &ch, 1);
|
||||
f_gif_read(gif, &fg, 1);
|
||||
f_gif_read(gif, &bg, 1);
|
||||
sub_block = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
|
||||
gif->plain_text(gif, tx, ty, tw, th, cw, ch, fg, bg);
|
||||
f_gif_seek(gif, sub_block, LV_FS_SEEK_SET);
|
||||
} else {
|
||||
/* Discard plain text metadata. */
|
||||
f_gif_seek(gif, 13, LV_FS_SEEK_CUR);
|
||||
}
|
||||
/* Discard plain text sub-blocks. */
|
||||
discard_sub_blocks(gif);
|
||||
}
|
||||
|
||||
static void
|
||||
read_graphic_control_ext(gd_GIF *gif)
|
||||
{
|
||||
uint8_t rdit;
|
||||
|
||||
/* Discard block size (always 0x04). */
|
||||
f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
|
||||
f_gif_read(gif, &rdit, 1);
|
||||
gif->gce.disposal = (rdit >> 2) & 3;
|
||||
gif->gce.input = rdit & 2;
|
||||
gif->gce.transparency = rdit & 1;
|
||||
gif->gce.delay = read_num(gif);
|
||||
f_gif_read(gif, &gif->gce.tindex, 1);
|
||||
/* Skip block terminator. */
|
||||
f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
|
||||
}
|
||||
|
||||
static void
|
||||
read_comment_ext(gd_GIF *gif)
|
||||
{
|
||||
if (gif->comment) {
|
||||
size_t sub_block = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
|
||||
gif->comment(gif);
|
||||
f_gif_seek(gif, sub_block, LV_FS_SEEK_SET);
|
||||
}
|
||||
/* Discard comment sub-blocks. */
|
||||
discard_sub_blocks(gif);
|
||||
}
|
||||
|
||||
static void
|
||||
read_application_ext(gd_GIF *gif)
|
||||
{
|
||||
char app_id[8];
|
||||
char app_auth_code[3];
|
||||
uint16_t loop_count;
|
||||
|
||||
/* Discard block size (always 0x0B). */
|
||||
f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
|
||||
/* Application Identifier. */
|
||||
f_gif_read(gif, app_id, 8);
|
||||
/* Application Authentication Code. */
|
||||
f_gif_read(gif, app_auth_code, 3);
|
||||
if (!strncmp(app_id, "NETSCAPE", sizeof(app_id))) {
|
||||
/* Discard block size (0x03) and constant byte (0x01). */
|
||||
f_gif_seek(gif, 2, LV_FS_SEEK_CUR);
|
||||
loop_count = read_num(gif);
|
||||
if(gif->loop_count < 0) {
|
||||
if(loop_count == 0) {
|
||||
gif->loop_count = 0;
|
||||
}
|
||||
else{
|
||||
gif->loop_count = loop_count + 1;
|
||||
}
|
||||
}
|
||||
/* Skip block terminator. */
|
||||
f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
|
||||
} else if (gif->application) {
|
||||
size_t sub_block = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
|
||||
gif->application(gif, app_id, app_auth_code);
|
||||
f_gif_seek(gif, sub_block, LV_FS_SEEK_SET);
|
||||
discard_sub_blocks(gif);
|
||||
} else {
|
||||
discard_sub_blocks(gif);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
read_ext(gd_GIF *gif)
|
||||
{
|
||||
uint8_t label;
|
||||
|
||||
f_gif_read(gif, &label, 1);
|
||||
switch (label) {
|
||||
case 0x01:
|
||||
read_plain_text_ext(gif);
|
||||
break;
|
||||
case 0xF9:
|
||||
read_graphic_control_ext(gif);
|
||||
break;
|
||||
case 0xFE:
|
||||
read_comment_ext(gif);
|
||||
break;
|
||||
case 0xFF:
|
||||
read_application_ext(gif);
|
||||
break;
|
||||
default:
|
||||
LV_LOG_WARN("unknown extension: %02X\n", label);
|
||||
}
|
||||
}
|
||||
|
||||
static Table *
|
||||
new_table(int key_size)
|
||||
{
|
||||
int key;
|
||||
int init_bulk = MAX(1 << (key_size + 1), 0x100);
|
||||
Table *table = lv_mem_alloc(sizeof(*table) + sizeof(Entry) * init_bulk);
|
||||
if (table) {
|
||||
table->bulk = init_bulk;
|
||||
table->nentries = (1 << key_size) + 2;
|
||||
table->entries = (Entry *) &table[1];
|
||||
for (key = 0; key < (1 << key_size); key++)
|
||||
table->entries[key] = (Entry) {1, 0xFFF, key};
|
||||
}
|
||||
return table;
|
||||
}
|
||||
|
||||
/* Add table entry. Return value:
|
||||
* 0 on success
|
||||
* +1 if key size must be incremented after this addition
|
||||
* -1 if could not realloc table */
|
||||
static int
|
||||
add_entry(Table **tablep, uint16_t length, uint16_t prefix, uint8_t suffix)
|
||||
{
|
||||
Table *table = *tablep;
|
||||
if (table->nentries == table->bulk) {
|
||||
table->bulk *= 2;
|
||||
table = lv_mem_realloc(table, sizeof(*table) + sizeof(Entry) * table->bulk);
|
||||
if (!table) return -1;
|
||||
table->entries = (Entry *) &table[1];
|
||||
*tablep = table;
|
||||
}
|
||||
table->entries[table->nentries] = (Entry) {length, prefix, suffix};
|
||||
table->nentries++;
|
||||
if ((table->nentries & (table->nentries - 1)) == 0)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint16_t
|
||||
get_key(gd_GIF *gif, int key_size, uint8_t *sub_len, uint8_t *shift, uint8_t *byte)
|
||||
{
|
||||
int bits_read;
|
||||
int rpad;
|
||||
int frag_size;
|
||||
uint16_t key;
|
||||
|
||||
key = 0;
|
||||
for (bits_read = 0; bits_read < key_size; bits_read += frag_size) {
|
||||
rpad = (*shift + bits_read) % 8;
|
||||
if (rpad == 0) {
|
||||
/* Update byte. */
|
||||
if (*sub_len == 0) {
|
||||
f_gif_read(gif, sub_len, 1); /* Must be nonzero! */
|
||||
if (*sub_len == 0) return 0x1000;
|
||||
}
|
||||
f_gif_read(gif, byte, 1);
|
||||
(*sub_len)--;
|
||||
}
|
||||
frag_size = MIN(key_size - bits_read, 8 - rpad);
|
||||
key |= ((uint16_t) ((*byte) >> rpad)) << bits_read;
|
||||
}
|
||||
/* Clear extra bits to the left. */
|
||||
key &= (1 << key_size) - 1;
|
||||
*shift = (*shift + key_size) % 8;
|
||||
return key;
|
||||
}
|
||||
|
||||
/* Compute output index of y-th input line, in frame of height h. */
|
||||
static int
|
||||
interlaced_line_index(int h, int y)
|
||||
{
|
||||
int p; /* number of lines in current pass */
|
||||
|
||||
p = (h - 1) / 8 + 1;
|
||||
if (y < p) /* pass 1 */
|
||||
return y * 8;
|
||||
y -= p;
|
||||
p = (h - 5) / 8 + 1;
|
||||
if (y < p) /* pass 2 */
|
||||
return y * 8 + 4;
|
||||
y -= p;
|
||||
p = (h - 3) / 4 + 1;
|
||||
if (y < p) /* pass 3 */
|
||||
return y * 4 + 2;
|
||||
y -= p;
|
||||
/* pass 4 */
|
||||
return y * 2 + 1;
|
||||
}
|
||||
|
||||
/* Decompress image pixels.
|
||||
* Return 0 on success or -1 on out-of-memory (w.r.t. LZW code table). */
|
||||
static int
|
||||
read_image_data(gd_GIF *gif, int interlace)
|
||||
{
|
||||
uint8_t sub_len, shift, byte;
|
||||
int init_key_size, key_size, table_is_full=0;
|
||||
int frm_off, frm_size, str_len=0, i, p, x, y;
|
||||
uint16_t key, clear, stop;
|
||||
int ret;
|
||||
Table *table;
|
||||
Entry entry = {0};
|
||||
size_t start, end;
|
||||
|
||||
f_gif_read(gif, &byte, 1);
|
||||
key_size = (int) byte;
|
||||
start = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
|
||||
discard_sub_blocks(gif);
|
||||
end = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
|
||||
f_gif_seek(gif, start, LV_FS_SEEK_SET);
|
||||
clear = 1 << key_size;
|
||||
stop = clear + 1;
|
||||
table = new_table(key_size);
|
||||
key_size++;
|
||||
init_key_size = key_size;
|
||||
sub_len = shift = 0;
|
||||
key = get_key(gif, key_size, &sub_len, &shift, &byte); /* clear code */
|
||||
frm_off = 0;
|
||||
ret = 0;
|
||||
frm_size = gif->fw*gif->fh;
|
||||
while (frm_off < frm_size) {
|
||||
if (key == clear) {
|
||||
key_size = init_key_size;
|
||||
table->nentries = (1 << (key_size - 1)) + 2;
|
||||
table_is_full = 0;
|
||||
} else if (!table_is_full) {
|
||||
ret = add_entry(&table, str_len + 1, key, entry.suffix);
|
||||
if (ret == -1) {
|
||||
lv_mem_free(table);
|
||||
return -1;
|
||||
}
|
||||
if (table->nentries == 0x1000) {
|
||||
ret = 0;
|
||||
table_is_full = 1;
|
||||
}
|
||||
}
|
||||
key = get_key(gif, key_size, &sub_len, &shift, &byte);
|
||||
if (key == clear) continue;
|
||||
if (key == stop || key == 0x1000) break;
|
||||
if (ret == 1) key_size++;
|
||||
entry = table->entries[key];
|
||||
str_len = entry.length;
|
||||
for (i = 0; i < str_len; i++) {
|
||||
p = frm_off + entry.length - 1;
|
||||
x = p % gif->fw;
|
||||
y = p / gif->fw;
|
||||
if (interlace)
|
||||
y = interlaced_line_index((int) gif->fh, y);
|
||||
gif->frame[(gif->fy + y) * gif->width + gif->fx + x] = entry.suffix;
|
||||
if (entry.prefix == 0xFFF)
|
||||
break;
|
||||
else
|
||||
entry = table->entries[entry.prefix];
|
||||
}
|
||||
frm_off += str_len;
|
||||
if (key < table->nentries - 1 && !table_is_full)
|
||||
table->entries[table->nentries - 1].suffix = entry.suffix;
|
||||
}
|
||||
lv_mem_free(table);
|
||||
if (key == stop) f_gif_read(gif, &sub_len, 1); /* Must be zero! */
|
||||
f_gif_seek(gif, end, LV_FS_SEEK_SET);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Read image.
|
||||
* Return 0 on success or -1 on out-of-memory (w.r.t. LZW code table). */
|
||||
static int
|
||||
read_image(gd_GIF *gif)
|
||||
{
|
||||
uint8_t fisrz;
|
||||
int interlace;
|
||||
|
||||
/* Image Descriptor. */
|
||||
gif->fx = read_num(gif);
|
||||
gif->fy = read_num(gif);
|
||||
gif->fw = read_num(gif);
|
||||
gif->fh = read_num(gif);
|
||||
f_gif_read(gif, &fisrz, 1);
|
||||
interlace = fisrz & 0x40;
|
||||
/* Ignore Sort Flag. */
|
||||
/* Local Color Table? */
|
||||
if (fisrz & 0x80) {
|
||||
/* Read LCT */
|
||||
gif->lct.size = 1 << ((fisrz & 0x07) + 1);
|
||||
f_gif_read(gif, gif->lct.colors, 3 * gif->lct.size);
|
||||
gif->palette = &gif->lct;
|
||||
} else
|
||||
gif->palette = &gif->gct;
|
||||
/* Image Data. */
|
||||
return read_image_data(gif, interlace);
|
||||
}
|
||||
|
||||
static void
|
||||
render_frame_rect(gd_GIF *gif, uint8_t *buffer)
|
||||
{
|
||||
int i, j, k;
|
||||
uint8_t index, *color;
|
||||
i = gif->fy * gif->width + gif->fx;
|
||||
for (j = 0; j < gif->fh; j++) {
|
||||
for (k = 0; k < gif->fw; k++) {
|
||||
index = gif->frame[(gif->fy + j) * gif->width + gif->fx + k];
|
||||
color = &gif->palette->colors[index*3];
|
||||
if (!gif->gce.transparency || index != gif->gce.tindex) {
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
buffer[(i+k)*4 + 0] = *(color + 2);
|
||||
buffer[(i+k)*4 + 1] = *(color + 1);
|
||||
buffer[(i+k)*4 + 2] = *(color + 0);
|
||||
buffer[(i+k)*4 + 3] = 0xFF;
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
lv_color_t c = lv_color_make(*(color + 0), *(color + 1), *(color + 2));
|
||||
buffer[(i+k)*3 + 0] = c.full & 0xff;
|
||||
buffer[(i+k)*3 + 1] = (c.full >> 8) & 0xff;
|
||||
buffer[(i+k)*3 + 2] = 0xff;
|
||||
#elif LV_COLOR_DEPTH == 8
|
||||
lv_color_t c = lv_color_make(*(color + 0), *(color + 1), *(color + 2));
|
||||
buffer[(i+k)*2 + 0] = c.full;
|
||||
buffer[(i+k)*2 + 1] = 0xff;
|
||||
#elif LV_COLOR_DEPTH == 1
|
||||
uint8_t b = (*(color + 0)) | (*(color + 1)) | (*(color + 2));
|
||||
buffer[(i+k)*2 + 0] = b > 128 ? 1 : 0;
|
||||
buffer[(i+k)*2 + 1] = 0xff;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
i += gif->width;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
dispose(gd_GIF *gif)
|
||||
{
|
||||
int i, j, k;
|
||||
uint8_t *bgcolor;
|
||||
switch (gif->gce.disposal) {
|
||||
case 2: /* Restore to background color. */
|
||||
bgcolor = &gif->palette->colors[gif->bgindex*3];
|
||||
|
||||
uint8_t opa = 0xff;
|
||||
if(gif->gce.transparency) opa = 0x00;
|
||||
|
||||
i = gif->fy * gif->width + gif->fx;
|
||||
for (j = 0; j < gif->fh; j++) {
|
||||
for (k = 0; k < gif->fw; k++) {
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
gif->canvas[(i+k)*4 + 0] = *(bgcolor + 2);
|
||||
gif->canvas[(i+k)*4 + 1] = *(bgcolor + 1);
|
||||
gif->canvas[(i+k)*4 + 2] = *(bgcolor + 0);
|
||||
gif->canvas[(i+k)*4 + 3] = opa;
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
|
||||
gif->canvas[(i+k)*3 + 0] = c.full & 0xff;
|
||||
gif->canvas[(i+k)*3 + 1] = (c.full >> 8) & 0xff;
|
||||
gif->canvas[(i+k)*3 + 2] = opa;
|
||||
#elif LV_COLOR_DEPTH == 8
|
||||
lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
|
||||
gif->canvas[(i+k)*2 + 0] = c.full;
|
||||
gif->canvas[(i+k)*2 + 1] = opa;
|
||||
#elif LV_COLOR_DEPTH == 1
|
||||
uint8_t b = (*(bgcolor + 0)) | (*(bgcolor + 1)) | (*(bgcolor + 2));
|
||||
gif->canvas[(i+k)*2 + 0] = b > 128 ? 1 : 0;
|
||||
gif->canvas[(i+k)*2 + 1] = opa;
|
||||
#endif
|
||||
}
|
||||
i += gif->width;
|
||||
}
|
||||
break;
|
||||
case 3: /* Restore to previous, i.e., don't update canvas.*/
|
||||
break;
|
||||
default:
|
||||
/* Add frame non-transparent pixels to canvas. */
|
||||
render_frame_rect(gif, gif->canvas);
|
||||
}
|
||||
}
|
||||
|
||||
/* Return 1 if got a frame; 0 if got GIF trailer; -1 if error. */
|
||||
int
|
||||
gd_get_frame(gd_GIF *gif)
|
||||
{
|
||||
char sep;
|
||||
|
||||
dispose(gif);
|
||||
f_gif_read(gif, &sep, 1);
|
||||
while (sep != ',') {
|
||||
if (sep == ';') {
|
||||
f_gif_seek(gif, gif->anim_start, LV_FS_SEEK_SET);
|
||||
if(gif->loop_count == 1 || gif->loop_count < 0) {
|
||||
return 0;
|
||||
}
|
||||
else if(gif->loop_count > 1) {
|
||||
gif->loop_count--;
|
||||
}
|
||||
}
|
||||
else if (sep == '!')
|
||||
read_ext(gif);
|
||||
else return -1;
|
||||
f_gif_read(gif, &sep, 1);
|
||||
}
|
||||
if (read_image(gif) == -1)
|
||||
return -1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
gd_render_frame(gd_GIF *gif, uint8_t *buffer)
|
||||
{
|
||||
// uint32_t i;
|
||||
// uint32_t j;
|
||||
// for(i = 0, j = 0; i < gif->width * gif->height * 3; i+= 3, j+=4) {
|
||||
// buffer[j + 0] = gif->canvas[i + 2];
|
||||
// buffer[j + 1] = gif->canvas[i + 1];
|
||||
// buffer[j + 2] = gif->canvas[i + 0];
|
||||
// buffer[j + 3] = 0xFF;
|
||||
// }
|
||||
// memcpy(buffer, gif->canvas, gif->width * gif->height * 3);
|
||||
render_frame_rect(gif, buffer);
|
||||
}
|
||||
|
||||
void
|
||||
gd_rewind(gd_GIF *gif)
|
||||
{
|
||||
gif->loop_count = -1;
|
||||
f_gif_seek(gif, gif->anim_start, LV_FS_SEEK_SET);
|
||||
}
|
||||
|
||||
void
|
||||
gd_close_gif(gd_GIF *gif)
|
||||
{
|
||||
f_gif_close(gif);
|
||||
lv_mem_free(gif);
|
||||
}
|
||||
|
||||
static bool f_gif_open(gd_GIF * gif, const void * path, bool is_file)
|
||||
{
|
||||
gif->f_rw_p = 0;
|
||||
gif->data = NULL;
|
||||
gif->is_file = is_file;
|
||||
|
||||
if(is_file) {
|
||||
lv_fs_res_t res = lv_fs_open(&gif->fd, path, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) return false;
|
||||
else return true;
|
||||
} else {
|
||||
gif->data = path;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
static void f_gif_read(gd_GIF * gif, void * buf, size_t len)
|
||||
{
|
||||
if(gif->is_file) {
|
||||
lv_fs_read(&gif->fd, buf, len, NULL);
|
||||
} else
|
||||
{
|
||||
memcpy(buf, &gif->data[gif->f_rw_p], len);
|
||||
gif->f_rw_p += len;
|
||||
}
|
||||
}
|
||||
|
||||
static int f_gif_seek(gd_GIF * gif, size_t pos, int k)
|
||||
{
|
||||
if(gif->is_file) {
|
||||
lv_fs_seek(&gif->fd, pos, k);
|
||||
uint32_t x;
|
||||
lv_fs_tell(&gif->fd, &x);
|
||||
return x;
|
||||
} else {
|
||||
if(k == LV_FS_SEEK_CUR) gif->f_rw_p += pos;
|
||||
else if(k == LV_FS_SEEK_SET) gif->f_rw_p = pos;
|
||||
return gif->f_rw_p;
|
||||
}
|
||||
}
|
||||
|
||||
static void f_gif_close(gd_GIF * gif)
|
||||
{
|
||||
if(gif->is_file) {
|
||||
lv_fs_close(&gif->fd);
|
||||
}
|
||||
}
|
||||
|
||||
#endif /*LV_USE_GIF*/
|
||||
@@ -0,0 +1,60 @@
|
||||
#ifndef GIFDEC_H
|
||||
#define GIFDEC_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "../../../misc/lv_fs.h"
|
||||
|
||||
#if LV_USE_GIF
|
||||
|
||||
typedef struct gd_Palette {
|
||||
int size;
|
||||
uint8_t colors[0x100 * 3];
|
||||
} gd_Palette;
|
||||
|
||||
typedef struct gd_GCE {
|
||||
uint16_t delay;
|
||||
uint8_t tindex;
|
||||
uint8_t disposal;
|
||||
int input;
|
||||
int transparency;
|
||||
} gd_GCE;
|
||||
|
||||
|
||||
|
||||
typedef struct gd_GIF {
|
||||
lv_fs_file_t fd;
|
||||
const char * data;
|
||||
uint8_t is_file;
|
||||
uint32_t f_rw_p;
|
||||
int32_t anim_start;
|
||||
uint16_t width, height;
|
||||
uint16_t depth;
|
||||
int32_t loop_count;
|
||||
gd_GCE gce;
|
||||
gd_Palette *palette;
|
||||
gd_Palette lct, gct;
|
||||
void (*plain_text)(
|
||||
struct gd_GIF *gif, uint16_t tx, uint16_t ty,
|
||||
uint16_t tw, uint16_t th, uint8_t cw, uint8_t ch,
|
||||
uint8_t fg, uint8_t bg
|
||||
);
|
||||
void (*comment)(struct gd_GIF *gif);
|
||||
void (*application)(struct gd_GIF *gif, char id[8], char auth[3]);
|
||||
uint16_t fx, fy, fw, fh;
|
||||
uint8_t bgindex;
|
||||
uint8_t *canvas, *frame;
|
||||
} gd_GIF;
|
||||
|
||||
gd_GIF * gd_open_gif_file(const char *fname);
|
||||
|
||||
gd_GIF * gd_open_gif_data(const void *data);
|
||||
|
||||
void gd_render_frame(gd_GIF *gif, uint8_t *buffer);
|
||||
|
||||
int gd_get_frame(gd_GIF *gif);
|
||||
void gd_rewind(gd_GIF *gif);
|
||||
void gd_close_gif(gd_GIF *gif);
|
||||
|
||||
#endif /*LV_USE_GIF*/
|
||||
|
||||
#endif /* GIFDEC_H */
|
||||
@@ -0,0 +1,153 @@
|
||||
/**
|
||||
* @file lv_gifenc.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "lv_gif.h"
|
||||
#if LV_USE_GIF
|
||||
|
||||
#include "gifdec.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#define MY_CLASS &lv_gif_class
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static void lv_gif_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
static void lv_gif_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
static void next_frame_task_cb(lv_timer_t * t);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
const lv_obj_class_t lv_gif_class = {
|
||||
.constructor_cb = lv_gif_constructor,
|
||||
.destructor_cb = lv_gif_destructor,
|
||||
.instance_size = sizeof(lv_gif_t),
|
||||
.base_class = &lv_img_class
|
||||
};
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
lv_obj_t * lv_gif_create(lv_obj_t * parent)
|
||||
{
|
||||
|
||||
LV_LOG_INFO("begin");
|
||||
lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
|
||||
lv_obj_class_init_obj(obj);
|
||||
return obj;
|
||||
}
|
||||
|
||||
void lv_gif_set_src(lv_obj_t * obj, const void * src)
|
||||
{
|
||||
lv_gif_t * gifobj = (lv_gif_t *) obj;
|
||||
|
||||
/*Close previous gif if any*/
|
||||
if(gifobj->gif) {
|
||||
lv_img_cache_invalidate_src(&gifobj->imgdsc);
|
||||
gd_close_gif(gifobj->gif);
|
||||
gifobj->gif = NULL;
|
||||
gifobj->imgdsc.data = NULL;
|
||||
}
|
||||
|
||||
if(lv_img_src_get_type(src) == LV_IMG_SRC_VARIABLE) {
|
||||
const lv_img_dsc_t * img_dsc = src;
|
||||
gifobj->gif = gd_open_gif_data(img_dsc->data);
|
||||
}
|
||||
else if(lv_img_src_get_type(src) == LV_IMG_SRC_FILE) {
|
||||
gifobj->gif = gd_open_gif_file(src);
|
||||
}
|
||||
if(gifobj->gif == NULL) {
|
||||
LV_LOG_WARN("Could't load the source");
|
||||
return;
|
||||
}
|
||||
|
||||
gifobj->imgdsc.data = gifobj->gif->canvas;
|
||||
gifobj->imgdsc.header.always_zero = 0;
|
||||
gifobj->imgdsc.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
|
||||
gifobj->imgdsc.header.h = gifobj->gif->height;
|
||||
gifobj->imgdsc.header.w = gifobj->gif->width;
|
||||
gifobj->last_call = lv_tick_get();
|
||||
|
||||
lv_img_set_src(obj, &gifobj->imgdsc);
|
||||
|
||||
lv_timer_resume(gifobj->timer);
|
||||
lv_timer_reset(gifobj->timer);
|
||||
|
||||
next_frame_task_cb(gifobj->timer);
|
||||
|
||||
}
|
||||
|
||||
void lv_gif_restart(lv_obj_t * obj)
|
||||
{
|
||||
lv_gif_t * gifobj = (lv_gif_t *) obj;
|
||||
gd_rewind(gifobj->gif);
|
||||
lv_timer_resume(gifobj->timer);
|
||||
lv_timer_reset(gifobj->timer);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
static void lv_gif_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
||||
{
|
||||
LV_UNUSED(class_p);
|
||||
|
||||
lv_gif_t * gifobj = (lv_gif_t *) obj;
|
||||
|
||||
gifobj->gif = NULL;
|
||||
gifobj->timer = lv_timer_create(next_frame_task_cb, 10, obj);
|
||||
lv_timer_pause(gifobj->timer);
|
||||
}
|
||||
|
||||
static void lv_gif_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
||||
{
|
||||
LV_UNUSED(class_p);
|
||||
lv_gif_t * gifobj = (lv_gif_t *) obj;
|
||||
lv_img_cache_invalidate_src(&gifobj->imgdsc);
|
||||
if(gifobj->gif)
|
||||
gd_close_gif(gifobj->gif);
|
||||
lv_timer_del(gifobj->timer);
|
||||
}
|
||||
|
||||
static void next_frame_task_cb(lv_timer_t * t)
|
||||
{
|
||||
lv_obj_t * obj = t->user_data;
|
||||
lv_gif_t * gifobj = (lv_gif_t *) obj;
|
||||
uint32_t elaps = lv_tick_elaps(gifobj->last_call);
|
||||
if(elaps < gifobj->gif->gce.delay * 10) return;
|
||||
|
||||
gifobj->last_call = lv_tick_get();
|
||||
|
||||
int has_next = gd_get_frame(gifobj->gif);
|
||||
if(has_next == 0) {
|
||||
/*It was the last repeat*/
|
||||
lv_res_t res = lv_event_send(obj, LV_EVENT_READY, NULL);
|
||||
lv_timer_pause(t);
|
||||
if(res != LV_FS_RES_OK) return;
|
||||
}
|
||||
|
||||
gd_render_frame(gifobj->gif, (uint8_t *)gifobj->imgdsc.data);
|
||||
|
||||
lv_img_cache_invalidate_src(lv_img_get_src(obj));
|
||||
lv_obj_invalidate(obj);
|
||||
}
|
||||
|
||||
#endif /*LV_USE_GIF*/
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* @file lv_gif.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_GIF_H
|
||||
#define LV_GIF_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_GIF
|
||||
|
||||
#include "gifdec.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
typedef struct {
|
||||
lv_img_t img;
|
||||
gd_GIF * gif;
|
||||
lv_timer_t * timer;
|
||||
lv_img_dsc_t imgdsc;
|
||||
uint32_t last_call;
|
||||
} lv_gif_t;
|
||||
|
||||
extern const lv_obj_class_t lv_gif_class;
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
lv_obj_t * lv_gif_create(lv_obj_t * parent);
|
||||
void lv_gif_set_src(lv_obj_t * obj, const void * src);
|
||||
void lv_gif_restart(lv_obj_t * gif);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_GIF*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /*LV_GIF_H*/
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* @file lv_libs.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_LIBS_H
|
||||
#define LV_LIBS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "bmp/lv_bmp.h"
|
||||
#include "fsdrv/lv_fsdrv.h"
|
||||
#include "png/lv_png.h"
|
||||
#include "gif/lv_gif.h"
|
||||
#include "qrcode/lv_qrcode.h"
|
||||
#include "sjpg/lv_sjpg.h"
|
||||
#include "freetype/lv_freetype.h"
|
||||
#include "rlottie/lv_rlottie.h"
|
||||
#include "ffmpeg/lv_ffmpeg.h"
|
||||
#include "tiny_ttf/lv_tiny_ttf.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /*extern "C"*/
|
||||
#endif
|
||||
|
||||
#endif /*LV_LIBS_H*/
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,275 @@
|
||||
/**
|
||||
* @file lv_png.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_PNG
|
||||
|
||||
#include "lv_png.h"
|
||||
#include "lodepng.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static lv_res_t decoder_info(struct _lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header);
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
|
||||
static void decoder_close(lv_img_decoder_t * dec, lv_img_decoder_dsc_t * dsc);
|
||||
static void convert_color_depth(uint8_t * img, uint32_t px_cnt);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Register the PNG decoder functions in LVGL
|
||||
*/
|
||||
void lv_png_init(void)
|
||||
{
|
||||
lv_img_decoder_t * dec = lv_img_decoder_create();
|
||||
lv_img_decoder_set_info_cb(dec, decoder_info);
|
||||
lv_img_decoder_set_open_cb(dec, decoder_open);
|
||||
lv_img_decoder_set_close_cb(dec, decoder_close);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Get info about a PNG image
|
||||
* @param src can be file name or pointer to a C array
|
||||
* @param header store the info here
|
||||
* @return LV_RES_OK: no error; LV_RES_INV: can't get the info
|
||||
*/
|
||||
static lv_res_t decoder_info(struct _lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)
|
||||
{
|
||||
(void) decoder; /*Unused*/
|
||||
lv_img_src_t src_type = lv_img_src_get_type(src); /*Get the source type*/
|
||||
|
||||
/*If it's a PNG file...*/
|
||||
if(src_type == LV_IMG_SRC_FILE) {
|
||||
const char * fn = src;
|
||||
if(strcmp(lv_fs_get_ext(fn), "png") == 0) { /*Check the extension*/
|
||||
|
||||
/* Read the width and height from the file. They have a constant location:
|
||||
* [16..23]: width
|
||||
* [24..27]: height
|
||||
*/
|
||||
uint32_t size[2];
|
||||
lv_fs_file_t f;
|
||||
lv_fs_res_t res = lv_fs_open(&f, fn, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) return LV_RES_INV;
|
||||
|
||||
lv_fs_seek(&f, 16, LV_FS_SEEK_SET);
|
||||
|
||||
uint32_t rn;
|
||||
lv_fs_read(&f, &size, 8, &rn);
|
||||
lv_fs_close(&f);
|
||||
|
||||
if(rn != 8) return LV_RES_INV;
|
||||
|
||||
/*Save the data in the header*/
|
||||
header->always_zero = 0;
|
||||
header->cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
|
||||
/*The width and height are stored in Big endian format so convert them to little endian*/
|
||||
header->w = (lv_coord_t)((size[0] & 0xff000000) >> 24) + ((size[0] & 0x00ff0000) >> 8);
|
||||
header->h = (lv_coord_t)((size[1] & 0xff000000) >> 24) + ((size[1] & 0x00ff0000) >> 8);
|
||||
|
||||
return LV_RES_OK;
|
||||
}
|
||||
}
|
||||
/*If it's a PNG file in a C array...*/
|
||||
else if(src_type == LV_IMG_SRC_VARIABLE) {
|
||||
const lv_img_dsc_t * img_dsc = src;
|
||||
const uint32_t data_size = img_dsc->data_size;
|
||||
const uint32_t * size = ((uint32_t *)img_dsc->data) + 4;
|
||||
const uint8_t magic[] = {0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
|
||||
if(data_size < sizeof(magic)) return LV_RES_INV;
|
||||
if(memcmp(magic, img_dsc->data, sizeof(magic))) return LV_RES_INV;
|
||||
header->always_zero = 0;
|
||||
|
||||
if(img_dsc->header.cf) {
|
||||
header->cf = img_dsc->header.cf; /*Save the color format*/
|
||||
}
|
||||
else {
|
||||
header->cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
|
||||
}
|
||||
|
||||
if(img_dsc->header.w) {
|
||||
header->w = img_dsc->header.w; /*Save the image width*/
|
||||
}
|
||||
else {
|
||||
header->w = (lv_coord_t)((size[0] & 0xff000000) >> 24) + ((size[0] & 0x00ff0000) >> 8);
|
||||
}
|
||||
|
||||
if(img_dsc->header.h) {
|
||||
header->h = img_dsc->header.h; /*Save the color height*/
|
||||
}
|
||||
else {
|
||||
header->h = (lv_coord_t)((size[1] & 0xff000000) >> 24) + ((size[1] & 0x00ff0000) >> 8);
|
||||
}
|
||||
|
||||
return LV_RES_OK;
|
||||
}
|
||||
|
||||
return LV_RES_INV; /*If didn't succeeded earlier then it's an error*/
|
||||
}
|
||||
|
||||
/**
|
||||
* Open a PNG image and return the decided image
|
||||
* @param src can be file name or pointer to a C array
|
||||
* @param style style of the image object (unused now but certain formats might use it)
|
||||
* @return pointer to the decoded image or `LV_IMG_DECODER_OPEN_FAIL` if failed
|
||||
*/
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
|
||||
(void) decoder; /*Unused*/
|
||||
uint32_t error; /*For the return values of PNG decoder functions*/
|
||||
|
||||
uint8_t * img_data = NULL;
|
||||
|
||||
/*If it's a PNG file...*/
|
||||
if(dsc->src_type == LV_IMG_SRC_FILE) {
|
||||
const char * fn = dsc->src;
|
||||
if(strcmp(lv_fs_get_ext(fn), "png") == 0) { /*Check the extension*/
|
||||
|
||||
/*Load the PNG file into buffer. It's still compressed (not decoded)*/
|
||||
unsigned char * png_data; /*Pointer to the loaded data. Same as the original file just loaded into the RAM*/
|
||||
size_t png_data_size; /*Size of `png_data` in bytes*/
|
||||
|
||||
error = lodepng_load_file(&png_data, &png_data_size, fn); /*Load the file*/
|
||||
if(error) {
|
||||
LV_LOG_WARN("error %" LV_PRIu32 ": %s\n", error, lodepng_error_text(error));
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
/*Decode the PNG image*/
|
||||
unsigned png_width; /*Will be the width of the decoded image*/
|
||||
unsigned png_height; /*Will be the width of the decoded image*/
|
||||
|
||||
/*Decode the loaded image in ARGB8888 */
|
||||
error = lodepng_decode32(&img_data, &png_width, &png_height, png_data, png_data_size);
|
||||
lv_mem_free(png_data); /*Free the loaded file*/
|
||||
if(error) {
|
||||
if(img_data != NULL) {
|
||||
lv_mem_free(img_data);
|
||||
}
|
||||
LV_LOG_WARN("error %" LV_PRIu32 ": %s\n", error, lodepng_error_text(error));
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
/*Convert the image to the system's color depth*/
|
||||
convert_color_depth(img_data, png_width * png_height);
|
||||
dsc->img_data = img_data;
|
||||
return LV_RES_OK; /*The image is fully decoded. Return with its pointer*/
|
||||
}
|
||||
}
|
||||
/*If it's a PNG file in a C array...*/
|
||||
else if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
|
||||
const lv_img_dsc_t * img_dsc = dsc->src;
|
||||
unsigned png_width; /*No used, just required by he decoder*/
|
||||
unsigned png_height; /*No used, just required by he decoder*/
|
||||
|
||||
/*Decode the image in ARGB8888 */
|
||||
error = lodepng_decode32(&img_data, &png_width, &png_height, img_dsc->data, img_dsc->data_size);
|
||||
|
||||
if(error) {
|
||||
if(img_data != NULL) {
|
||||
lv_mem_free(img_data);
|
||||
}
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
/*Convert the image to the system's color depth*/
|
||||
convert_color_depth(img_data, png_width * png_height);
|
||||
|
||||
dsc->img_data = img_data;
|
||||
return LV_RES_OK; /*Return with its pointer*/
|
||||
}
|
||||
|
||||
return LV_RES_INV; /*If not returned earlier then it failed*/
|
||||
}
|
||||
|
||||
/**
|
||||
* Free the allocated resources
|
||||
*/
|
||||
static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
LV_UNUSED(decoder); /*Unused*/
|
||||
if(dsc->img_data) {
|
||||
lv_mem_free((uint8_t *)dsc->img_data);
|
||||
dsc->img_data = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If the display is not in 32 bit format (ARGB888) then covert the image to the current color depth
|
||||
* @param img the ARGB888 image
|
||||
* @param px_cnt number of pixels in `img`
|
||||
*/
|
||||
static void convert_color_depth(uint8_t * img, uint32_t px_cnt)
|
||||
{
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
lv_color32_t * img_argb = (lv_color32_t *)img;
|
||||
lv_color_t c;
|
||||
lv_color_t * img_c = (lv_color_t *) img;
|
||||
uint32_t i;
|
||||
for(i = 0; i < px_cnt; i++) {
|
||||
c = lv_color_make(img_argb[i].ch.red, img_argb[i].ch.green, img_argb[i].ch.blue);
|
||||
img_c[i].ch.red = c.ch.blue;
|
||||
img_c[i].ch.blue = c.ch.red;
|
||||
}
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
lv_color32_t * img_argb = (lv_color32_t *)img;
|
||||
lv_color_t c;
|
||||
uint32_t i;
|
||||
for(i = 0; i < px_cnt; i++) {
|
||||
c = lv_color_make(img_argb[i].ch.blue, img_argb[i].ch.green, img_argb[i].ch.red);
|
||||
img[i * 3 + 2] = img_argb[i].ch.alpha;
|
||||
img[i * 3 + 1] = c.full >> 8;
|
||||
img[i * 3 + 0] = c.full & 0xFF;
|
||||
}
|
||||
#elif LV_COLOR_DEPTH == 8
|
||||
lv_color32_t * img_argb = (lv_color32_t *)img;
|
||||
lv_color_t c;
|
||||
uint32_t i;
|
||||
for(i = 0; i < px_cnt; i++) {
|
||||
c = lv_color_make(img_argb[i].ch.red, img_argb[i].ch.green, img_argb[i].ch.blue);
|
||||
img[i * 2 + 1] = img_argb[i].ch.alpha;
|
||||
img[i * 2 + 0] = c.full;
|
||||
}
|
||||
#elif LV_COLOR_DEPTH == 1
|
||||
lv_color32_t * img_argb = (lv_color32_t *)img;
|
||||
uint8_t b;
|
||||
uint32_t i;
|
||||
for(i = 0; i < px_cnt; i++) {
|
||||
b = img_argb[i].ch.red | img_argb[i].ch.green | img_argb[i].ch.blue;
|
||||
img[i * 2 + 1] = img_argb[i].ch.alpha;
|
||||
img[i * 2 + 0] = b > 128 ? 1 : 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /*LV_USE_PNG*/
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* @file lv_png.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_PNG_H
|
||||
#define LV_PNG_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lv_conf_internal.h"
|
||||
#if LV_USE_PNG
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Register the PNG decoder functions in LVGL
|
||||
*/
|
||||
void lv_png_init(void);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_PNG*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /*LV_PNG_H*/
|
||||
@@ -0,0 +1,214 @@
|
||||
/**
|
||||
* @file lv_qrcode.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "lv_qrcode.h"
|
||||
#if LV_USE_QRCODE
|
||||
|
||||
#include "qrcodegen.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#define MY_CLASS &lv_qrcode_class
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static void lv_qrcode_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
static void lv_qrcode_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
const lv_obj_class_t lv_qrcode_class = {
|
||||
.constructor_cb = lv_qrcode_constructor,
|
||||
.destructor_cb = lv_qrcode_destructor,
|
||||
.base_class = &lv_canvas_class
|
||||
};
|
||||
|
||||
static lv_coord_t size_param;
|
||||
static lv_color_t dark_color_param;
|
||||
static lv_color_t light_color_param;
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Create an empty QR code (an `lv_canvas`) object.
|
||||
* @param parent point to an object where to create the QR code
|
||||
* @param size width and height of the QR code
|
||||
* @param dark_color dark color of the QR code
|
||||
* @param light_color light color of the QR code
|
||||
* @return pointer to the created QR code object
|
||||
*/
|
||||
lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color)
|
||||
{
|
||||
LV_LOG_INFO("begin");
|
||||
size_param = size;
|
||||
light_color_param = light_color;
|
||||
dark_color_param = dark_color;
|
||||
|
||||
lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
|
||||
lv_obj_class_init_obj(obj);
|
||||
return obj;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the data of a QR code object
|
||||
* @param qrcode pointer to aQ code object
|
||||
* @param data data to display
|
||||
* @param data_len length of data in bytes
|
||||
* @return LV_RES_OK: if no error; LV_RES_INV: on error
|
||||
*/
|
||||
lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len)
|
||||
{
|
||||
lv_color_t c;
|
||||
c.full = 1;
|
||||
lv_canvas_fill_bg(qrcode, c, LV_OPA_COVER);
|
||||
|
||||
if(data_len > qrcodegen_BUFFER_LEN_MAX) return LV_RES_INV;
|
||||
|
||||
lv_img_dsc_t * imgdsc = lv_canvas_get_img(qrcode);
|
||||
|
||||
int32_t qr_version = qrcodegen_getMinFitVersion(qrcodegen_Ecc_MEDIUM, data_len);
|
||||
if(qr_version <= 0) return LV_RES_INV;
|
||||
int32_t qr_size = qrcodegen_version2size(qr_version);
|
||||
if(qr_size <= 0) return LV_RES_INV;
|
||||
int32_t scale = imgdsc->header.w / qr_size;
|
||||
if(scale <= 0) return LV_RES_INV;
|
||||
int32_t remain = imgdsc->header.w % qr_size;
|
||||
|
||||
/* The qr version is incremented by four point */
|
||||
uint32_t version_extend = remain / (scale << 2);
|
||||
if(version_extend && qr_version < qrcodegen_VERSION_MAX) {
|
||||
qr_version = qr_version + version_extend > qrcodegen_VERSION_MAX ?
|
||||
qrcodegen_VERSION_MAX : qr_version + version_extend;
|
||||
}
|
||||
|
||||
uint8_t * qr0 = lv_mem_alloc(qrcodegen_BUFFER_LEN_FOR_VERSION(qr_version));
|
||||
LV_ASSERT_MALLOC(qr0);
|
||||
uint8_t * data_tmp = lv_mem_alloc(qrcodegen_BUFFER_LEN_FOR_VERSION(qr_version));
|
||||
LV_ASSERT_MALLOC(data_tmp);
|
||||
lv_memcpy(data_tmp, data, data_len);
|
||||
|
||||
bool ok = qrcodegen_encodeBinary(data_tmp, data_len,
|
||||
qr0, qrcodegen_Ecc_MEDIUM,
|
||||
qr_version, qr_version,
|
||||
qrcodegen_Mask_AUTO, true);
|
||||
|
||||
if(!ok) {
|
||||
lv_mem_free(qr0);
|
||||
lv_mem_free(data_tmp);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
lv_coord_t obj_w = imgdsc->header.w;
|
||||
qr_size = qrcodegen_getSize(qr0);
|
||||
scale = obj_w / qr_size;
|
||||
int scaled = qr_size * scale;
|
||||
int margin = (obj_w - scaled) / 2;
|
||||
uint8_t * buf_u8 = (uint8_t *)imgdsc->data + 8; /*+8 skip the palette*/
|
||||
|
||||
/* Copy the qr code canvas:
|
||||
* A simple `lv_canvas_set_px` would work but it's slow for so many pixels.
|
||||
* So buffer 1 byte (8 px) from the qr code and set it in the canvas image */
|
||||
uint32_t row_byte_cnt = (imgdsc->header.w + 7) >> 3;
|
||||
int y;
|
||||
for(y = margin; y < scaled + margin; y += scale) {
|
||||
uint8_t b = 0;
|
||||
uint8_t p = 0;
|
||||
bool aligned = false;
|
||||
int x;
|
||||
for(x = margin; x < scaled + margin; x++) {
|
||||
bool a = qrcodegen_getModule(qr0, (x - margin) / scale, (y - margin) / scale);
|
||||
|
||||
if(aligned == false && (x & 0x7) == 0) aligned = true;
|
||||
|
||||
if(aligned == false) {
|
||||
c.full = a ? 0 : 1;
|
||||
lv_canvas_set_px_color(qrcode, x, y, c);
|
||||
}
|
||||
else {
|
||||
if(!a) b |= (1 << (7 - p));
|
||||
p++;
|
||||
if(p == 8) {
|
||||
uint32_t px = row_byte_cnt * y + (x >> 3);
|
||||
buf_u8[px] = b;
|
||||
b = 0;
|
||||
p = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*Process the last byte of the row*/
|
||||
if(p) {
|
||||
/*Make the rest of the bits white*/
|
||||
b |= (1 << (8 - p)) - 1;
|
||||
|
||||
uint32_t px = row_byte_cnt * y + (x >> 3);
|
||||
buf_u8[px] = b;
|
||||
}
|
||||
|
||||
/*The Qr is probably scaled so simply to the repeated rows*/
|
||||
int s;
|
||||
const uint8_t * row_ori = buf_u8 + row_byte_cnt * y;
|
||||
for(s = 1; s < scale; s++) {
|
||||
lv_memcpy((uint8_t *)buf_u8 + row_byte_cnt * (y + s), row_ori, row_byte_cnt);
|
||||
}
|
||||
}
|
||||
|
||||
lv_mem_free(qr0);
|
||||
lv_mem_free(data_tmp);
|
||||
return LV_RES_OK;
|
||||
}
|
||||
|
||||
void lv_qrcode_delete(lv_obj_t * qrcode)
|
||||
{
|
||||
lv_obj_del(qrcode);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
static void lv_qrcode_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
||||
{
|
||||
LV_UNUSED(class_p);
|
||||
|
||||
uint32_t buf_size = LV_CANVAS_BUF_SIZE_INDEXED_1BIT(size_param, size_param);
|
||||
uint8_t * buf = lv_mem_alloc(buf_size);
|
||||
LV_ASSERT_MALLOC(buf);
|
||||
if(buf == NULL) return;
|
||||
|
||||
lv_canvas_set_buffer(obj, buf, size_param, size_param, LV_IMG_CF_INDEXED_1BIT);
|
||||
lv_canvas_set_palette(obj, 0, dark_color_param);
|
||||
lv_canvas_set_palette(obj, 1, light_color_param);
|
||||
}
|
||||
|
||||
static void lv_qrcode_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
||||
{
|
||||
LV_UNUSED(class_p);
|
||||
|
||||
lv_img_dsc_t * img = lv_canvas_get_img(obj);
|
||||
lv_img_cache_invalidate_src(img);
|
||||
lv_mem_free((void *)img->data);
|
||||
img->data = NULL;
|
||||
}
|
||||
|
||||
#endif /*LV_USE_QRCODE*/
|
||||
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
* @file lv_qrcode
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_QRCODE_H
|
||||
#define LV_QRCODE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_QRCODE
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
extern const lv_obj_class_t lv_qrcode_class;
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
/**
|
||||
* Create an empty QR code (an `lv_canvas`) object.
|
||||
* @param parent point to an object where to create the QR code
|
||||
* @param size width and height of the QR code
|
||||
* @param dark_color dark color of the QR code
|
||||
* @param light_color light color of the QR code
|
||||
* @return pointer to the created QR code object
|
||||
*/
|
||||
lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color);
|
||||
|
||||
/**
|
||||
* Set the data of a QR code object
|
||||
* @param qrcode pointer to aQ code object
|
||||
* @param data data to display
|
||||
* @param data_len length of data in bytes
|
||||
* @return LV_RES_OK: if no error; LV_RES_INV: on error
|
||||
*/
|
||||
lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len);
|
||||
|
||||
/**
|
||||
* DEPRECATED: Use normal lv_obj_del instead
|
||||
* Delete a QR code object
|
||||
* @param qrcode pointer to a QR code object
|
||||
*/
|
||||
void lv_qrcode_delete(lv_obj_t * qrcode);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_QRCODE*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /*LV_QRCODE_H*/
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,319 @@
|
||||
/*
|
||||
* QR Code generator library (C)
|
||||
*
|
||||
* Copyright (c) Project Nayuki. (MIT License)
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* This library creates QR Code symbols, which is a type of two-dimension barcode.
|
||||
* Invented by Denso Wave and described in the ISO/IEC 18004 standard.
|
||||
* A QR Code structure is an immutable square grid of black and white cells.
|
||||
* The library provides functions to create a QR Code from text or binary data.
|
||||
* The library covers the QR Code Model 2 specification, supporting all versions (sizes)
|
||||
* from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
|
||||
*
|
||||
* Ways to create a QR Code object:
|
||||
* - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
|
||||
* - Low level: Custom-make the list of segments and call
|
||||
* qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
|
||||
* (Note that all ways require supplying the desired error correction level and various byte buffers.)
|
||||
*/
|
||||
|
||||
|
||||
/*---- Enum and struct types----*/
|
||||
|
||||
/*
|
||||
* The error correction level in a QR Code symbol.
|
||||
*/
|
||||
enum qrcodegen_Ecc {
|
||||
// Must be declared in ascending order of error protection
|
||||
// so that an internal qrcodegen function works properly
|
||||
qrcodegen_Ecc_LOW = 0 , // The QR Code can tolerate about 7% erroneous codewords
|
||||
qrcodegen_Ecc_MEDIUM , // The QR Code can tolerate about 15% erroneous codewords
|
||||
qrcodegen_Ecc_QUARTILE, // The QR Code can tolerate about 25% erroneous codewords
|
||||
qrcodegen_Ecc_HIGH , // The QR Code can tolerate about 30% erroneous codewords
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* The mask pattern used in a QR Code symbol.
|
||||
*/
|
||||
enum qrcodegen_Mask {
|
||||
// A special value to tell the QR Code encoder to
|
||||
// automatically select an appropriate mask pattern
|
||||
qrcodegen_Mask_AUTO = -1,
|
||||
// The eight actual mask patterns
|
||||
qrcodegen_Mask_0 = 0,
|
||||
qrcodegen_Mask_1,
|
||||
qrcodegen_Mask_2,
|
||||
qrcodegen_Mask_3,
|
||||
qrcodegen_Mask_4,
|
||||
qrcodegen_Mask_5,
|
||||
qrcodegen_Mask_6,
|
||||
qrcodegen_Mask_7,
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Describes how a segment's data bits are interpreted.
|
||||
*/
|
||||
enum qrcodegen_Mode {
|
||||
qrcodegen_Mode_NUMERIC = 0x1,
|
||||
qrcodegen_Mode_ALPHANUMERIC = 0x2,
|
||||
qrcodegen_Mode_BYTE = 0x4,
|
||||
qrcodegen_Mode_KANJI = 0x8,
|
||||
qrcodegen_Mode_ECI = 0x7,
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* A segment of character/binary/control data in a QR Code symbol.
|
||||
* The mid-level way to create a segment is to take the payload data
|
||||
* and call a factory function such as qrcodegen_makeNumeric().
|
||||
* The low-level way to create a segment is to custom-make the bit buffer
|
||||
* and initialize a qrcodegen_Segment struct with appropriate values.
|
||||
* Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
|
||||
* Any segment longer than this is meaningless for the purpose of generating QR Codes.
|
||||
* Moreover, the maximum allowed bit length is 32767 because
|
||||
* the largest QR Code (version 40) has 31329 modules.
|
||||
*/
|
||||
struct qrcodegen_Segment {
|
||||
// The mode indicator of this segment.
|
||||
enum qrcodegen_Mode mode;
|
||||
|
||||
// The length of this segment's unencoded data. Measured in characters for
|
||||
// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
|
||||
// Always zero or positive. Not the same as the data's bit length.
|
||||
int numChars;
|
||||
|
||||
// The data bits of this segment, packed in bitwise big endian.
|
||||
// Can be null if the bit length is zero.
|
||||
uint8_t *data;
|
||||
|
||||
// The number of valid data bits used in the buffer. Requires
|
||||
// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
|
||||
// The character count (numChars) must agree with the mode and the bit buffer length.
|
||||
int bitLength;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*---- Macro constants and functions ----*/
|
||||
|
||||
#define qrcodegen_VERSION_MIN 1 // The minimum version number supported in the QR Code Model 2 standard
|
||||
#define qrcodegen_VERSION_MAX 40 // The maximum version number supported in the QR Code Model 2 standard
|
||||
|
||||
// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
|
||||
// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
|
||||
// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
|
||||
// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
|
||||
#define qrcodegen_BUFFER_LEN_FOR_VERSION(n) ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
|
||||
|
||||
// The worst-case number of bytes needed to store one QR Code, up to and including
|
||||
// version 40. This value equals 3918, which is just under 4 kilobytes.
|
||||
// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
|
||||
#define qrcodegen_BUFFER_LEN_MAX qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
|
||||
|
||||
|
||||
|
||||
/*---- Functions (high level) to generate QR Codes ----*/
|
||||
|
||||
/*
|
||||
* Encodes the given text string to a QR Code, returning true if encoding succeeded.
|
||||
* If the data is too long to fit in any version in the given range
|
||||
* at the given ECC level, then false is returned.
|
||||
* - The input text must be encoded in UTF-8 and contain no NULs.
|
||||
* - The variables ecl and mask must correspond to enum constant values.
|
||||
* - Requires 1 <= minVersion <= maxVersion <= 40.
|
||||
* - The arrays tempBuffer and qrcode must each have a length
|
||||
* of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
|
||||
* - After the function returns, tempBuffer contains no useful data.
|
||||
* - If successful, the resulting QR Code may use numeric,
|
||||
* alphanumeric, or byte mode to encode the text.
|
||||
* - In the most optimistic case, a QR Code at version 40 with low ECC
|
||||
* can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
|
||||
* up to 4296 characters, or any digit string up to 7089 characters.
|
||||
* These numbers represent the hard upper limit of the QR Code standard.
|
||||
* - Please consult the QR Code specification for information on
|
||||
* data capacities per version, ECC level, and text encoding mode.
|
||||
*/
|
||||
bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
|
||||
enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
|
||||
|
||||
|
||||
/*
|
||||
* Encodes the given binary data to a QR Code, returning true if encoding succeeded.
|
||||
* If the data is too long to fit in any version in the given range
|
||||
* at the given ECC level, then false is returned.
|
||||
* - The input array range dataAndTemp[0 : dataLen] should normally be
|
||||
* valid UTF-8 text, but is not required by the QR Code standard.
|
||||
* - The variables ecl and mask must correspond to enum constant values.
|
||||
* - Requires 1 <= minVersion <= maxVersion <= 40.
|
||||
* - The arrays dataAndTemp and qrcode must each have a length
|
||||
* of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
|
||||
* - After the function returns, the contents of dataAndTemp may have changed,
|
||||
* and does not represent useful data anymore.
|
||||
* - If successful, the resulting QR Code will use byte mode to encode the data.
|
||||
* - In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
|
||||
* sequence up to length 2953. This is the hard upper limit of the QR Code standard.
|
||||
* - Please consult the QR Code specification for information on
|
||||
* data capacities per version, ECC level, and text encoding mode.
|
||||
*/
|
||||
bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
|
||||
enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
|
||||
|
||||
|
||||
/*---- Functions (low level) to generate QR Codes ----*/
|
||||
|
||||
/*
|
||||
* Renders a QR Code representing the given segments at the given error correction level.
|
||||
* The smallest possible QR Code version is automatically chosen for the output. Returns true if
|
||||
* QR Code creation succeeded, or false if the data is too long to fit in any version. The ECC level
|
||||
* of the result may be higher than the ecl argument if it can be done without increasing the version.
|
||||
* This function allows the user to create a custom sequence of segments that switches
|
||||
* between modes (such as alphanumeric and byte) to encode text in less space.
|
||||
* This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
|
||||
* To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
|
||||
* result in them being clobbered, but the QR Code output will still be correct.
|
||||
* But the qrcode array must not overlap tempBuffer or any segment's data buffer.
|
||||
*/
|
||||
bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
|
||||
enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
|
||||
|
||||
|
||||
/*
|
||||
* Renders a QR Code representing the given segments with the given encoding parameters.
|
||||
* Returns true if QR Code creation succeeded, or false if the data is too long to fit in the range of versions.
|
||||
* The smallest possible QR Code version within the given range is automatically
|
||||
* chosen for the output. Iff boostEcl is true, then the ECC level of the result
|
||||
* may be higher than the ecl argument if it can be done without increasing the
|
||||
* version. The mask number is either between 0 to 7 (inclusive) to force that
|
||||
* mask, or -1 to automatically choose an appropriate mask (which may be slow).
|
||||
* This function allows the user to create a custom sequence of segments that switches
|
||||
* between modes (such as alphanumeric and byte) to encode text in less space.
|
||||
* This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
|
||||
* To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
|
||||
* result in them being clobbered, but the QR Code output will still be correct.
|
||||
* But the qrcode array must not overlap tempBuffer or any segment's data buffer.
|
||||
*/
|
||||
bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
|
||||
int minVersion, int maxVersion, int mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
|
||||
|
||||
|
||||
/*
|
||||
* Tests whether the given string can be encoded as a segment in alphanumeric mode.
|
||||
* A string is encodable iff each character is in the following set: 0 to 9, A to Z
|
||||
* (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
|
||||
*/
|
||||
bool qrcodegen_isAlphanumeric(const char *text);
|
||||
|
||||
|
||||
/*
|
||||
* Tests whether the given string can be encoded as a segment in numeric mode.
|
||||
* A string is encodable iff each character is in the range 0 to 9.
|
||||
*/
|
||||
bool qrcodegen_isNumeric(const char *text);
|
||||
|
||||
|
||||
/*
|
||||
* Returns the number of bytes (uint8_t) needed for the data buffer of a segment
|
||||
* containing the given number of characters using the given mode. Notes:
|
||||
* - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or
|
||||
* the number of needed bits exceeds INT16_MAX (i.e. 32767).
|
||||
* - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
|
||||
* - It is okay for the user to allocate more bytes for the buffer than needed.
|
||||
* - For byte mode, numChars measures the number of bytes, not Unicode code points.
|
||||
* - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
|
||||
* An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
|
||||
*/
|
||||
size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a segment representing the given binary data encoded in
|
||||
* byte mode. All input byte arrays are acceptable. Any text string
|
||||
* can be converted to UTF-8 bytes and encoded as a byte mode segment.
|
||||
*/
|
||||
struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a segment representing the given string of decimal digits encoded in numeric mode.
|
||||
*/
|
||||
struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a segment representing the given text string encoded in alphanumeric mode.
|
||||
* The characters allowed are: 0 to 9, A to Z (uppercase only), space,
|
||||
* dollar, percent, asterisk, plus, hyphen, period, slash, colon.
|
||||
*/
|
||||
struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a segment representing an Extended Channel Interpretation
|
||||
* (ECI) designator with the given assignment value.
|
||||
*/
|
||||
struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
|
||||
|
||||
|
||||
/*---- Functions to extract raw data from QR Codes ----*/
|
||||
|
||||
/*
|
||||
* Returns the side length of the given QR Code, assuming that encoding succeeded.
|
||||
* The result is in the range [21, 177]. Note that the length of the array buffer
|
||||
* is related to the side length - every 'uint8_t qrcode[]' must have length at least
|
||||
* qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
|
||||
*/
|
||||
int qrcodegen_getSize(const uint8_t qrcode[]);
|
||||
|
||||
|
||||
/*
|
||||
* Returns the color of the module (pixel) at the given coordinates, which is false
|
||||
* for white or true for black. The top left corner has the coordinates (x=0, y=0).
|
||||
* If the given coordinates are out of bounds, then false (white) is returned.
|
||||
*/
|
||||
bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
|
||||
|
||||
/*
|
||||
* Returns the qrcode size of the specified version. Returns -1 on failure
|
||||
*/
|
||||
int qrcodegen_version2size(int version);
|
||||
/*
|
||||
* Returns the min version of the data that can be stored. Returns -1 on failure
|
||||
*/
|
||||
int qrcodegen_getMinFitVersion(enum qrcodegen_Ecc ecl, size_t dataLen);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,283 @@
|
||||
/**
|
||||
* @file lv_rlottie.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "lv_rlottie.h"
|
||||
#if LV_USE_RLOTTIE
|
||||
|
||||
#include <rlottie_capi.h>
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#define MY_CLASS &lv_rlottie_class
|
||||
#define LV_ARGB32 32
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
#define LV_ARGB32 32
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static void lv_rlottie_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
static void lv_rlottie_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
|
||||
static void next_frame_task_cb(lv_timer_t * t);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
const lv_obj_class_t lv_rlottie_class = {
|
||||
.constructor_cb = lv_rlottie_constructor,
|
||||
.destructor_cb = lv_rlottie_destructor,
|
||||
.instance_size = sizeof(lv_rlottie_t),
|
||||
.base_class = &lv_img_class
|
||||
};
|
||||
|
||||
static lv_coord_t create_width;
|
||||
static lv_coord_t create_height;
|
||||
static const char * rlottie_desc_create;
|
||||
static const char * path_create;
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
|
||||
lv_obj_t * lv_rlottie_create_from_file(lv_obj_t * parent, lv_coord_t width, lv_coord_t height, const char * path)
|
||||
{
|
||||
|
||||
create_width = width;
|
||||
create_height = height;
|
||||
path_create = path;
|
||||
rlottie_desc_create = NULL;
|
||||
|
||||
LV_LOG_INFO("begin");
|
||||
lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
|
||||
lv_obj_class_init_obj(obj);
|
||||
|
||||
return obj;
|
||||
|
||||
}
|
||||
|
||||
lv_obj_t * lv_rlottie_create_from_raw(lv_obj_t * parent, lv_coord_t width, lv_coord_t height, const char * rlottie_desc)
|
||||
{
|
||||
|
||||
create_width = width;
|
||||
create_height = height;
|
||||
rlottie_desc_create = rlottie_desc;
|
||||
path_create = NULL;
|
||||
|
||||
LV_LOG_INFO("begin");
|
||||
lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
|
||||
lv_obj_class_init_obj(obj);
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
void lv_rlottie_set_play_mode(lv_obj_t * obj, const lv_rlottie_ctrl_t ctrl)
|
||||
{
|
||||
lv_rlottie_t * rlottie = (lv_rlottie_t *) obj;
|
||||
rlottie->play_ctrl = ctrl;
|
||||
|
||||
if(rlottie->task && (rlottie->dest_frame != rlottie->current_frame ||
|
||||
(rlottie->play_ctrl & LV_RLOTTIE_CTRL_PAUSE) == LV_RLOTTIE_CTRL_PLAY)) {
|
||||
lv_timer_resume(rlottie->task);
|
||||
}
|
||||
}
|
||||
|
||||
void lv_rlottie_set_current_frame(lv_obj_t * obj, const size_t goto_frame)
|
||||
{
|
||||
lv_rlottie_t * rlottie = (lv_rlottie_t *) obj;
|
||||
rlottie->current_frame = goto_frame < rlottie->total_frames ? goto_frame : rlottie->total_frames - 1;
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
|
||||
static void lv_rlottie_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
||||
{
|
||||
LV_UNUSED(class_p);
|
||||
lv_rlottie_t * rlottie = (lv_rlottie_t *) obj;
|
||||
|
||||
if(rlottie_desc_create) {
|
||||
rlottie->animation = lottie_animation_from_data(rlottie_desc_create, rlottie_desc_create, "");
|
||||
}
|
||||
else if(path_create) {
|
||||
rlottie->animation = lottie_animation_from_file(path_create);
|
||||
}
|
||||
if(rlottie->animation == NULL) {
|
||||
LV_LOG_WARN("The aniamtion can't be opened");
|
||||
return;
|
||||
}
|
||||
|
||||
rlottie->total_frames = lottie_animation_get_totalframe(rlottie->animation);
|
||||
rlottie->framerate = (size_t)lottie_animation_get_framerate(rlottie->animation);
|
||||
rlottie->current_frame = 0;
|
||||
|
||||
rlottie->scanline_width = create_width * LV_ARGB32 / 8;
|
||||
|
||||
size_t allocaled_buf_size = (create_width * create_height * LV_ARGB32 / 8);
|
||||
rlottie->allocated_buf = lv_mem_alloc(allocaled_buf_size);
|
||||
if(rlottie->allocated_buf != NULL) {
|
||||
rlottie->allocated_buffer_size = allocaled_buf_size;
|
||||
memset(rlottie->allocated_buf, 0, allocaled_buf_size);
|
||||
}
|
||||
|
||||
rlottie->imgdsc.header.always_zero = 0;
|
||||
rlottie->imgdsc.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
|
||||
rlottie->imgdsc.header.h = create_height;
|
||||
rlottie->imgdsc.header.w = create_width;
|
||||
rlottie->imgdsc.data = (void *)rlottie->allocated_buf;
|
||||
rlottie->imgdsc.data_size = allocaled_buf_size;
|
||||
|
||||
lv_img_set_src(obj, &rlottie->imgdsc);
|
||||
|
||||
rlottie->play_ctrl = LV_RLOTTIE_CTRL_FORWARD | LV_RLOTTIE_CTRL_PLAY | LV_RLOTTIE_CTRL_LOOP;
|
||||
rlottie->dest_frame = rlottie->total_frames; /* invalid destination frame so it's possible to pause on frame 0 */
|
||||
|
||||
rlottie->task = lv_timer_create(next_frame_task_cb, 1000 / rlottie->framerate, obj);
|
||||
|
||||
lv_obj_update_layout(obj);
|
||||
}
|
||||
|
||||
static void lv_rlottie_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
|
||||
{
|
||||
LV_UNUSED(class_p);
|
||||
lv_rlottie_t * rlottie = (lv_rlottie_t *) obj;
|
||||
|
||||
if(rlottie->animation) {
|
||||
lottie_animation_destroy(rlottie->animation);
|
||||
rlottie->animation = 0;
|
||||
rlottie->current_frame = 0;
|
||||
rlottie->framerate = 0;
|
||||
rlottie->scanline_width = 0;
|
||||
rlottie->total_frames = 0;
|
||||
}
|
||||
|
||||
if(rlottie->task) {
|
||||
lv_timer_del(rlottie->task);
|
||||
rlottie->task = NULL;
|
||||
rlottie->play_ctrl = LV_RLOTTIE_CTRL_FORWARD;
|
||||
rlottie->dest_frame = 0;
|
||||
}
|
||||
|
||||
lv_img_cache_invalidate_src(&rlottie->imgdsc);
|
||||
if(rlottie->allocated_buf) {
|
||||
lv_mem_free(rlottie->allocated_buf);
|
||||
rlottie->allocated_buf = NULL;
|
||||
rlottie->allocated_buffer_size = 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#if LV_COLOR_DEPTH == 16
|
||||
static void convert_to_rgba5658(uint32_t * pix, const size_t width, const size_t height)
|
||||
{
|
||||
/* rlottie draws in ARGB32 format, but LVGL only deal with RGB565 format with (optional 8 bit alpha channel)
|
||||
so convert in place here the received buffer to LVGL format. */
|
||||
uint8_t * dest = (uint8_t *)pix;
|
||||
uint32_t * src = pix;
|
||||
for(size_t y = 0; y < height; y++) {
|
||||
/* Convert a 4 bytes per pixel in format ARGB to R5G6B5A8 format
|
||||
naive way:
|
||||
r = ((c & 0xFF0000) >> 19)
|
||||
g = ((c & 0xFF00) >> 10)
|
||||
b = ((c & 0xFF) >> 3)
|
||||
rgb565 = (r << 11) | (g << 5) | b
|
||||
a = c >> 24;
|
||||
That's 3 mask, 6 bitshift and 2 or operations
|
||||
|
||||
A bit better:
|
||||
r = ((c & 0xF80000) >> 8)
|
||||
g = ((c & 0xFC00) >> 5)
|
||||
b = ((c & 0xFF) >> 3)
|
||||
rgb565 = r | g | b
|
||||
a = c >> 24;
|
||||
That's 3 mask, 3 bitshifts and 2 or operations */
|
||||
for(size_t x = 0; x < width; x++) {
|
||||
uint32_t in = src[x];
|
||||
#if LV_COLOR_16_SWAP == 0
|
||||
uint16_t r = (uint16_t)(((in & 0xF80000) >> 8) | ((in & 0xFC00) >> 5) | ((in & 0xFF) >> 3));
|
||||
#else
|
||||
/* We want: rrrr rrrr GGGg gggg bbbb bbbb => gggb bbbb rrrr rGGG */
|
||||
uint16_t r = (uint16_t)(((in & 0xF80000) >> 16) | ((in & 0xFC00) >> 13) | ((in & 0x1C00) << 3) | ((in & 0xF8) << 5));
|
||||
#endif
|
||||
|
||||
lv_memcpy(dest, &r, sizeof(r));
|
||||
dest[sizeof(r)] = (uint8_t)(in >> 24);
|
||||
dest += LV_IMG_PX_SIZE_ALPHA_BYTE;
|
||||
}
|
||||
src += width;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void next_frame_task_cb(lv_timer_t * t)
|
||||
{
|
||||
lv_obj_t * obj = t->user_data;
|
||||
lv_rlottie_t * rlottie = (lv_rlottie_t *) obj;
|
||||
|
||||
if((rlottie->play_ctrl & LV_RLOTTIE_CTRL_PAUSE) == LV_RLOTTIE_CTRL_PAUSE) {
|
||||
if(rlottie->current_frame == rlottie->dest_frame) {
|
||||
/* Pause the timer too when it has run once to avoid CPU consumption */
|
||||
lv_timer_pause(t);
|
||||
return;
|
||||
}
|
||||
rlottie->dest_frame = rlottie->current_frame;
|
||||
}
|
||||
else {
|
||||
if((rlottie->play_ctrl & LV_RLOTTIE_CTRL_BACKWARD) == LV_RLOTTIE_CTRL_BACKWARD) {
|
||||
if(rlottie->current_frame > 0)
|
||||
--rlottie->current_frame;
|
||||
else { /* Looping ? */
|
||||
if((rlottie->play_ctrl & LV_RLOTTIE_CTRL_LOOP) == LV_RLOTTIE_CTRL_LOOP)
|
||||
rlottie->current_frame = rlottie->total_frames - 1;
|
||||
else {
|
||||
lv_event_send(obj, LV_EVENT_READY, NULL);
|
||||
lv_timer_pause(t);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
if(rlottie->current_frame < rlottie->total_frames)
|
||||
++rlottie->current_frame;
|
||||
else { /* Looping ? */
|
||||
if((rlottie->play_ctrl & LV_RLOTTIE_CTRL_LOOP) == LV_RLOTTIE_CTRL_LOOP)
|
||||
rlottie->current_frame = 0;
|
||||
else {
|
||||
lv_event_send(obj, LV_EVENT_READY, NULL);
|
||||
lv_timer_pause(t);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lottie_animation_render(
|
||||
rlottie->animation,
|
||||
rlottie->current_frame,
|
||||
rlottie->allocated_buf,
|
||||
rlottie->imgdsc.header.w,
|
||||
rlottie->imgdsc.header.h,
|
||||
rlottie->scanline_width
|
||||
);
|
||||
|
||||
#if LV_COLOR_DEPTH == 16
|
||||
convert_to_rgba5658(rlottie->allocated_buf, rlottie->imgdsc.header.w, rlottie->imgdsc.header.h);
|
||||
#endif
|
||||
|
||||
lv_obj_invalidate(obj);
|
||||
}
|
||||
|
||||
#endif /*LV_USE_RLOTTIE*/
|
||||
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* @file lv_rlottie.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_RLOTTIE_H
|
||||
#define LV_RLOTTIE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_RLOTTIE
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
typedef enum {
|
||||
LV_RLOTTIE_CTRL_FORWARD = 0,
|
||||
LV_RLOTTIE_CTRL_BACKWARD = 1,
|
||||
LV_RLOTTIE_CTRL_PAUSE = 2,
|
||||
LV_RLOTTIE_CTRL_PLAY = 0, /* Yes, play = 0 is the default mode */
|
||||
LV_RLOTTIE_CTRL_LOOP = 8,
|
||||
} lv_rlottie_ctrl_t;
|
||||
|
||||
/** definition in lottieanimation_capi.c */
|
||||
struct Lottie_Animation_S;
|
||||
typedef struct {
|
||||
lv_img_t img_ext;
|
||||
struct Lottie_Animation_S * animation;
|
||||
lv_timer_t * task;
|
||||
lv_img_dsc_t imgdsc;
|
||||
size_t total_frames;
|
||||
size_t current_frame;
|
||||
size_t framerate;
|
||||
uint32_t * allocated_buf;
|
||||
size_t allocated_buffer_size;
|
||||
size_t scanline_width;
|
||||
lv_rlottie_ctrl_t play_ctrl;
|
||||
size_t dest_frame;
|
||||
} lv_rlottie_t;
|
||||
|
||||
extern const lv_obj_class_t lv_rlottie_class;
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
lv_obj_t * lv_rlottie_create_from_file(lv_obj_t * parent, lv_coord_t width, lv_coord_t height, const char * path);
|
||||
|
||||
lv_obj_t * lv_rlottie_create_from_raw(lv_obj_t * parent, lv_coord_t width, lv_coord_t height,
|
||||
const char * rlottie_desc);
|
||||
|
||||
void lv_rlottie_set_play_mode(lv_obj_t * rlottie, const lv_rlottie_ctrl_t ctrl);
|
||||
void lv_rlottie_set_current_frame(lv_obj_t * rlottie, const size_t goto_frame);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_RLOTTIE*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /*LV_RLOTTIE_H*/
|
||||
@@ -0,0 +1,910 @@
|
||||
/**
|
||||
* @file lv_sjpg.c
|
||||
*
|
||||
*/
|
||||
|
||||
/*----------------------------------------------------------------------------------------------------------------------------------
|
||||
/ Added normal JPG support [7/10/2020]
|
||||
/ ----------
|
||||
/ SJPEG is a custom created modified JPEG file format for small embedded platforms.
|
||||
/ It will contain multiple JPEG fragments all embedded into a single file with a custom header.
|
||||
/ This makes JPEG decoding easier using any JPEG library. Overall file size will be almost
|
||||
/ similar to the parent jpeg file. We can generate sjpeg from any jpeg using a python script
|
||||
/ provided along with this project.
|
||||
/ (by vinodstanur | 2020 )
|
||||
/ SJPEG FILE STRUCTURE
|
||||
/ --------------------------------------------------------------------------------------------------------------------------------
|
||||
/ Bytes | Value |
|
||||
/ --------------------------------------------------------------------------------------------------------------------------------
|
||||
/
|
||||
/ 0 - 7 | "_SJPG__" followed by '\0'
|
||||
/
|
||||
/ 8 - 13 | "V1.00" followed by '\0' [VERSION OF SJPG FILE for future compatibiliby]
|
||||
/
|
||||
/ 14 - 15 | X_RESOLUTION (width) [little endian]
|
||||
/
|
||||
/ 16 - 17 | Y_RESOLUTION (height) [little endian]
|
||||
/
|
||||
/ 18 - 19 | TOTAL_FRAMES inside sjpeg [little endian]
|
||||
/
|
||||
/ 20 - 21 | JPEG BLOCK WIDTH (16 normally) [little endian]
|
||||
/
|
||||
/ 22 - [(TOTAL_FRAMES*2 )] | SIZE OF EACH JPEG SPLIT FRAGMENTS (FRAME_INFO_ARRAY)
|
||||
/
|
||||
/ SJPEG data | Each JPEG frame can be extracted from SJPEG data by parsing the FRAME_INFO_ARRAY one time.
|
||||
/
|
||||
/----------------------------------------------------------------------------------------------------------------------------------
|
||||
/ JPEG DECODER
|
||||
/ ------------
|
||||
/ We are using TJpgDec - Tiny JPEG Decompressor library from ELM-CHAN for decoding each split-jpeg fragments.
|
||||
/ The tjpgd.c and tjpgd.h is not modified and those are used as it is. So if any update comes for the tiny-jpeg,
|
||||
/ just replace those files with updated files.
|
||||
/---------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
|
||||
#include "../../../lvgl.h"
|
||||
#if LV_USE_SJPG
|
||||
|
||||
#include "tjpgd.h"
|
||||
#include "lv_sjpg.h"
|
||||
#include "../../../misc/lv_fs.h"
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
#define TJPGD_WORKBUFF_SIZE 4096 //Recommended by TJPGD libray
|
||||
|
||||
//NEVER EDIT THESE OFFSET VALUES
|
||||
#define SJPEG_VERSION_OFFSET 8
|
||||
#define SJPEG_X_RES_OFFSET 14
|
||||
#define SJPEG_y_RES_OFFSET 16
|
||||
#define SJPEG_TOTAL_FRAMES_OFFSET 18
|
||||
#define SJPEG_BLOCK_WIDTH_OFFSET 20
|
||||
#define SJPEG_FRAME_INFO_ARRAY_OFFSET 22
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
enum io_source_type {
|
||||
SJPEG_IO_SOURCE_C_ARRAY,
|
||||
SJPEG_IO_SOURCE_DISK,
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
enum io_source_type type;
|
||||
lv_fs_file_t lv_file;
|
||||
uint8_t * img_cache_buff;
|
||||
int img_cache_x_res;
|
||||
int img_cache_y_res;
|
||||
uint8_t * raw_sjpg_data; //Used when type==SJPEG_IO_SOURCE_C_ARRAY.
|
||||
uint32_t raw_sjpg_data_size; //Num bytes pointed to by raw_sjpg_data.
|
||||
uint32_t raw_sjpg_data_next_read_pos; //Used for all types.
|
||||
} io_source_t;
|
||||
|
||||
typedef struct {
|
||||
uint8_t * sjpeg_data;
|
||||
uint32_t sjpeg_data_size;
|
||||
int sjpeg_x_res;
|
||||
int sjpeg_y_res;
|
||||
int sjpeg_total_frames;
|
||||
int sjpeg_single_frame_height;
|
||||
int sjpeg_cache_frame_index;
|
||||
uint8_t ** frame_base_array; //to save base address of each split frames upto sjpeg_total_frames.
|
||||
int * frame_base_offset; //to save base offset for fseek
|
||||
uint8_t * frame_cache;
|
||||
uint8_t * workb; //JPG work buffer for jpeg library
|
||||
JDEC * tjpeg_jd;
|
||||
io_source_t io;
|
||||
} SJPEG;
|
||||
|
||||
/**********************
|
||||
* STATIC PROTOTYPES
|
||||
**********************/
|
||||
static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header);
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc);
|
||||
static lv_res_t 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);
|
||||
static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc);
|
||||
static size_t input_func(JDEC * jd, uint8_t * buff, size_t ndata);
|
||||
static int is_jpg(const uint8_t * raw_data, size_t len);
|
||||
static void lv_sjpg_cleanup(SJPEG * sjpeg);
|
||||
static void lv_sjpg_free(SJPEG * sjpeg);
|
||||
|
||||
/**********************
|
||||
* STATIC VARIABLES
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL FUNCTIONS
|
||||
**********************/
|
||||
void lv_split_jpeg_init(void)
|
||||
{
|
||||
lv_img_decoder_t * dec = lv_img_decoder_create();
|
||||
lv_img_decoder_set_info_cb(dec, decoder_info);
|
||||
lv_img_decoder_set_open_cb(dec, decoder_open);
|
||||
lv_img_decoder_set_close_cb(dec, decoder_close);
|
||||
lv_img_decoder_set_read_line_cb(dec, decoder_read_line);
|
||||
}
|
||||
|
||||
/**********************
|
||||
* STATIC FUNCTIONS
|
||||
**********************/
|
||||
/**
|
||||
* Get info about an SJPG / JPG image
|
||||
* @param decoder pointer to the decoder where this function belongs
|
||||
* @param src can be file name or pointer to a C array
|
||||
* @param header store the info here
|
||||
* @return LV_RES_OK: no error; LV_RES_INV: can't get the info
|
||||
*/
|
||||
static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)
|
||||
{
|
||||
LV_UNUSED(decoder);
|
||||
|
||||
/*Check whether the type `src` is known by the decoder*/
|
||||
/* Read the SJPG/JPG header and find `width` and `height` */
|
||||
|
||||
lv_img_src_t src_type = lv_img_src_get_type(src); /*Get the source type*/
|
||||
|
||||
lv_res_t ret = LV_RES_OK;
|
||||
|
||||
if(src_type == LV_IMG_SRC_VARIABLE) {
|
||||
const lv_img_dsc_t * img_dsc = src;
|
||||
uint8_t * raw_sjpeg_data = (uint8_t *)img_dsc->data;
|
||||
const uint32_t raw_sjpeg_data_size = img_dsc->data_size;
|
||||
|
||||
if(!strncmp((char *)raw_sjpeg_data, "_SJPG__", strlen("_SJPG__"))) {
|
||||
|
||||
raw_sjpeg_data += 14; //seek to res info ... refer sjpeg format
|
||||
header->always_zero = 0;
|
||||
header->cf = LV_IMG_CF_RAW;
|
||||
|
||||
header->w = *raw_sjpeg_data++;
|
||||
header->w |= *raw_sjpeg_data++ << 8;
|
||||
|
||||
header->h = *raw_sjpeg_data++;
|
||||
header->h |= *raw_sjpeg_data++ << 8;
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
else if(is_jpg(raw_sjpeg_data, raw_sjpeg_data_size) == true) {
|
||||
header->always_zero = 0;
|
||||
header->cf = LV_IMG_CF_RAW;
|
||||
|
||||
uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(!workb_temp) return LV_RES_INV;
|
||||
|
||||
io_source_t io_source_temp;
|
||||
io_source_temp.type = SJPEG_IO_SOURCE_C_ARRAY;
|
||||
io_source_temp.raw_sjpg_data = raw_sjpeg_data;
|
||||
io_source_temp.raw_sjpg_data_size = raw_sjpeg_data_size;
|
||||
io_source_temp.raw_sjpg_data_next_read_pos = 0;
|
||||
|
||||
JDEC jd_tmp;
|
||||
|
||||
JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp);
|
||||
if(rc == JDR_OK) {
|
||||
header->w = jd_tmp.width;
|
||||
header->h = jd_tmp.height;
|
||||
|
||||
}
|
||||
else {
|
||||
ret = LV_RES_INV;
|
||||
goto end;
|
||||
}
|
||||
|
||||
end:
|
||||
lv_mem_free(workb_temp);
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
}
|
||||
else if(src_type == LV_IMG_SRC_FILE) {
|
||||
const char * fn = src;
|
||||
if(strcmp(lv_fs_get_ext(fn), "sjpg") == 0) {
|
||||
|
||||
uint8_t buff[22];
|
||||
memset(buff, 0, sizeof(buff));
|
||||
|
||||
lv_fs_file_t file;
|
||||
lv_fs_res_t res = lv_fs_open(&file, fn, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) return 78;
|
||||
|
||||
uint32_t rn;
|
||||
res = lv_fs_read(&file, buff, 8, &rn);
|
||||
if(res != LV_FS_RES_OK || rn != 8) {
|
||||
lv_fs_close(&file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
if(strcmp((char *)buff, "_SJPG__") == 0) {
|
||||
lv_fs_seek(&file, 14, LV_FS_SEEK_SET);
|
||||
res = lv_fs_read(&file, buff, 4, &rn);
|
||||
if(res != LV_FS_RES_OK || rn != 4) {
|
||||
lv_fs_close(&file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
header->always_zero = 0;
|
||||
header->cf = LV_IMG_CF_RAW;
|
||||
uint8_t * raw_sjpeg_data = buff;
|
||||
header->w = *raw_sjpeg_data++;
|
||||
header->w |= *raw_sjpeg_data++ << 8;
|
||||
header->h = *raw_sjpeg_data++;
|
||||
header->h |= *raw_sjpeg_data++ << 8;
|
||||
lv_fs_close(&file);
|
||||
return LV_RES_OK;
|
||||
|
||||
}
|
||||
}
|
||||
else if(strcmp(lv_fs_get_ext(fn), "jpg") == 0) {
|
||||
lv_fs_file_t file;
|
||||
lv_fs_res_t res = lv_fs_open(&file, fn, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) return 78;
|
||||
|
||||
uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(!workb_temp) {
|
||||
lv_fs_close(&file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
io_source_t io_source_temp;
|
||||
io_source_temp.type = SJPEG_IO_SOURCE_DISK;
|
||||
io_source_temp.raw_sjpg_data_next_read_pos = 0;
|
||||
io_source_temp.img_cache_buff = NULL;
|
||||
io_source_temp.lv_file = file;
|
||||
JDEC jd_tmp;
|
||||
|
||||
JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp);
|
||||
lv_mem_free(workb_temp);
|
||||
lv_fs_close(&file);
|
||||
|
||||
if(rc == JDR_OK) {
|
||||
header->always_zero = 0;
|
||||
header->cf = LV_IMG_CF_RAW;
|
||||
header->w = jd_tmp.width;
|
||||
header->h = jd_tmp.height;
|
||||
return LV_RES_OK;
|
||||
}
|
||||
}
|
||||
}
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
static int img_data_cb(JDEC * jd, void * data, JRECT * rect)
|
||||
{
|
||||
io_source_t * io = jd->device;
|
||||
uint8_t * cache = io->img_cache_buff;
|
||||
const int xres = io->img_cache_x_res;
|
||||
uint8_t * buf = data;
|
||||
const int INPUT_PIXEL_SIZE = 3;
|
||||
const int row_width = rect->right - rect->left + 1; // Row width in pixels.
|
||||
const int row_size = row_width * INPUT_PIXEL_SIZE; // Row size (bytes).
|
||||
|
||||
for(int y = rect->top; y <= rect->bottom; y++) {
|
||||
int row_offset = y * xres * INPUT_PIXEL_SIZE + rect->left * INPUT_PIXEL_SIZE;
|
||||
memcpy(cache + row_offset, buf, row_size);
|
||||
buf += row_size;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static size_t input_func(JDEC * jd, uint8_t * buff, size_t ndata)
|
||||
{
|
||||
io_source_t * io = jd->device;
|
||||
|
||||
if(!io) return 0;
|
||||
|
||||
if(io->type == SJPEG_IO_SOURCE_C_ARRAY) {
|
||||
const uint32_t bytes_left = io->raw_sjpg_data_size - io->raw_sjpg_data_next_read_pos;
|
||||
const uint32_t to_read = ndata <= bytes_left ? (uint32_t)ndata : bytes_left;
|
||||
if(to_read == 0)
|
||||
return 0;
|
||||
if(buff) {
|
||||
memcpy(buff, io->raw_sjpg_data + io->raw_sjpg_data_next_read_pos, to_read);
|
||||
}
|
||||
io->raw_sjpg_data_next_read_pos += to_read;
|
||||
return to_read;
|
||||
}
|
||||
else if(io->type == SJPEG_IO_SOURCE_DISK) {
|
||||
|
||||
lv_fs_file_t * lv_file_p = &(io->lv_file);
|
||||
|
||||
if(buff) {
|
||||
uint32_t rn = 0;
|
||||
lv_fs_read(lv_file_p, buff, (uint32_t)ndata, &rn);
|
||||
return rn;
|
||||
}
|
||||
else {
|
||||
uint32_t pos;
|
||||
lv_fs_tell(lv_file_p, &pos);
|
||||
lv_fs_seek(lv_file_p, (uint32_t)(ndata + pos), LV_FS_SEEK_SET);
|
||||
return ndata;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Open SJPG image and return the decided image
|
||||
* @param decoder pointer to the decoder where this function belongs
|
||||
* @param dsc pointer to a descriptor which describes this decoding session
|
||||
* @return LV_RES_OK: no error; LV_RES_INV: can't get the info
|
||||
*/
|
||||
static lv_res_t decoder_open(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
LV_UNUSED(decoder);
|
||||
lv_res_t lv_ret = LV_RES_OK;
|
||||
|
||||
if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
|
||||
uint8_t * data;
|
||||
SJPEG * sjpeg = (SJPEG *) dsc->user_data;
|
||||
const uint32_t raw_sjpeg_data_size = ((lv_img_dsc_t *)dsc->src)->data_size;
|
||||
if(sjpeg == NULL) {
|
||||
sjpeg = lv_mem_alloc(sizeof(SJPEG));
|
||||
if(!sjpeg) return LV_RES_INV;
|
||||
|
||||
memset(sjpeg, 0, sizeof(SJPEG));
|
||||
|
||||
dsc->user_data = sjpeg;
|
||||
sjpeg->sjpeg_data = (uint8_t *)((lv_img_dsc_t *)(dsc->src))->data;
|
||||
sjpeg->sjpeg_data_size = ((lv_img_dsc_t *)(dsc->src))->data_size;
|
||||
}
|
||||
|
||||
if(!strncmp((char *) sjpeg->sjpeg_data, "_SJPG__", strlen("_SJPG__"))) {
|
||||
|
||||
data = sjpeg->sjpeg_data;
|
||||
data += 14;
|
||||
|
||||
sjpeg->sjpeg_x_res = *data++;
|
||||
sjpeg->sjpeg_x_res |= *data++ << 8;
|
||||
|
||||
sjpeg->sjpeg_y_res = *data++;
|
||||
sjpeg->sjpeg_y_res |= *data++ << 8;
|
||||
|
||||
sjpeg->sjpeg_total_frames = *data++;
|
||||
sjpeg->sjpeg_total_frames |= *data++ << 8;
|
||||
|
||||
sjpeg->sjpeg_single_frame_height = *data++;
|
||||
sjpeg->sjpeg_single_frame_height |= *data++ << 8;
|
||||
|
||||
sjpeg->frame_base_array = lv_mem_alloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames);
|
||||
if(! sjpeg->frame_base_array) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->frame_base_offset = NULL;
|
||||
|
||||
uint8_t * img_frame_base = data + sjpeg->sjpeg_total_frames * 2;
|
||||
sjpeg->frame_base_array[0] = img_frame_base;
|
||||
|
||||
for(int i = 1; i < sjpeg->sjpeg_total_frames; i++) {
|
||||
int offset = *data++;
|
||||
offset |= *data++ << 8;
|
||||
sjpeg->frame_base_array[i] = sjpeg->frame_base_array[i - 1] + offset;
|
||||
}
|
||||
sjpeg->sjpeg_cache_frame_index = -1;
|
||||
sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3/*2*/);
|
||||
if(! sjpeg->frame_cache) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
sjpeg->io.img_cache_buff = sjpeg->frame_cache;
|
||||
sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res;
|
||||
sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(! sjpeg->workb) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC));
|
||||
if(! sjpeg->tjpeg_jd) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
sjpeg->io.type = SJPEG_IO_SOURCE_C_ARRAY;
|
||||
sjpeg->io.lv_file.file_d = NULL;
|
||||
dsc->img_data = NULL;
|
||||
return lv_ret;
|
||||
}
|
||||
else if(is_jpg(sjpeg->sjpeg_data, raw_sjpeg_data_size) == true) {
|
||||
|
||||
uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(! workb_temp) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
io_source_t io_source_temp;
|
||||
io_source_temp.type = SJPEG_IO_SOURCE_C_ARRAY;
|
||||
io_source_temp.raw_sjpg_data = sjpeg->sjpeg_data;
|
||||
io_source_temp.raw_sjpg_data_size = sjpeg->sjpeg_data_size;
|
||||
io_source_temp.raw_sjpg_data_next_read_pos = 0;
|
||||
|
||||
JDEC jd_tmp;
|
||||
JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp);
|
||||
lv_mem_free(workb_temp);
|
||||
|
||||
if(rc == JDR_OK) {
|
||||
sjpeg->sjpeg_x_res = jd_tmp.width;
|
||||
sjpeg->sjpeg_y_res = jd_tmp.height;
|
||||
sjpeg->sjpeg_total_frames = 1;
|
||||
sjpeg->sjpeg_single_frame_height = jd_tmp.height;
|
||||
|
||||
sjpeg->frame_base_array = lv_mem_alloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames);
|
||||
if(! sjpeg->frame_base_array) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
sjpeg->frame_base_offset = NULL;
|
||||
|
||||
uint8_t * img_frame_base = sjpeg->sjpeg_data;
|
||||
sjpeg->frame_base_array[0] = img_frame_base;
|
||||
|
||||
sjpeg->sjpeg_cache_frame_index = -1;
|
||||
sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3);
|
||||
if(! sjpeg->frame_cache) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->io.img_cache_buff = sjpeg->frame_cache;
|
||||
sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res;
|
||||
sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(! sjpeg->workb) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC));
|
||||
if(! sjpeg->tjpeg_jd) {
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
sjpeg = NULL;
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->io.type = SJPEG_IO_SOURCE_C_ARRAY;
|
||||
sjpeg->io.lv_file.file_d = NULL;
|
||||
dsc->img_data = NULL;
|
||||
return lv_ret;
|
||||
}
|
||||
else {
|
||||
lv_ret = LV_RES_INV;
|
||||
goto end;
|
||||
}
|
||||
|
||||
end:
|
||||
lv_mem_free(workb_temp);
|
||||
|
||||
return lv_ret;
|
||||
}
|
||||
}
|
||||
else if(dsc->src_type == LV_IMG_SRC_FILE) {
|
||||
/* If all fine, then the file will be kept open */
|
||||
const char * fn = dsc->src;
|
||||
uint8_t * data;
|
||||
|
||||
if(strcmp(lv_fs_get_ext(fn), "sjpg") == 0) {
|
||||
|
||||
uint8_t buff[22];
|
||||
memset(buff, 0, sizeof(buff));
|
||||
|
||||
lv_fs_file_t lv_file;
|
||||
lv_fs_res_t res = lv_fs_open(&lv_file, fn, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) {
|
||||
return 78;
|
||||
}
|
||||
|
||||
uint32_t rn;
|
||||
res = lv_fs_read(&lv_file, buff, 22, &rn);
|
||||
if(res != LV_FS_RES_OK || rn != 22) {
|
||||
lv_fs_close(&lv_file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
if(strcmp((char *)buff, "_SJPG__") == 0) {
|
||||
|
||||
SJPEG * sjpeg = (SJPEG *) dsc->user_data;
|
||||
if(sjpeg == NULL) {
|
||||
sjpeg = lv_mem_alloc(sizeof(SJPEG));
|
||||
|
||||
if(! sjpeg) {
|
||||
lv_fs_close(&lv_file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
memset(sjpeg, 0, sizeof(SJPEG));
|
||||
|
||||
dsc->user_data = sjpeg;
|
||||
sjpeg->sjpeg_data = (uint8_t *)((lv_img_dsc_t *)(dsc->src))->data;
|
||||
sjpeg->sjpeg_data_size = ((lv_img_dsc_t *)(dsc->src))->data_size;
|
||||
}
|
||||
data = buff;
|
||||
data += 14;
|
||||
|
||||
sjpeg->sjpeg_x_res = *data++;
|
||||
sjpeg->sjpeg_x_res |= *data++ << 8;
|
||||
|
||||
sjpeg->sjpeg_y_res = *data++;
|
||||
sjpeg->sjpeg_y_res |= *data++ << 8;
|
||||
|
||||
sjpeg->sjpeg_total_frames = *data++;
|
||||
sjpeg->sjpeg_total_frames |= *data++ << 8;
|
||||
|
||||
sjpeg->sjpeg_single_frame_height = *data++;
|
||||
sjpeg->sjpeg_single_frame_height |= *data++ << 8;
|
||||
|
||||
sjpeg->frame_base_array = NULL;//lv_mem_alloc( sizeof(uint8_t *) * sjpeg->sjpeg_total_frames );
|
||||
sjpeg->frame_base_offset = lv_mem_alloc(sizeof(int) * sjpeg->sjpeg_total_frames);
|
||||
if(! sjpeg->frame_base_offset) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
int img_frame_start_offset = (SJPEG_FRAME_INFO_ARRAY_OFFSET + sjpeg->sjpeg_total_frames * 2);
|
||||
sjpeg->frame_base_offset[0] = img_frame_start_offset; //pointer used to save integer for now...
|
||||
|
||||
for(int i = 1; i < sjpeg->sjpeg_total_frames; i++) {
|
||||
res = lv_fs_read(&lv_file, buff, 2, &rn);
|
||||
if(res != LV_FS_RES_OK || rn != 2) {
|
||||
lv_fs_close(&lv_file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
data = buff;
|
||||
int offset = *data++;
|
||||
offset |= *data++ << 8;
|
||||
sjpeg->frame_base_offset[i] = sjpeg->frame_base_offset[i - 1] + offset;
|
||||
}
|
||||
|
||||
sjpeg->sjpeg_cache_frame_index = -1; //INVALID AT BEGINNING for a forced compare mismatch at first time.
|
||||
sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3);
|
||||
if(! sjpeg->frame_cache) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
sjpeg->io.img_cache_buff = sjpeg->frame_cache;
|
||||
sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res;
|
||||
sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(! sjpeg->workb) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC));
|
||||
if(! sjpeg->tjpeg_jd) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->io.type = SJPEG_IO_SOURCE_DISK;
|
||||
sjpeg->io.lv_file = lv_file;
|
||||
dsc->img_data = NULL;
|
||||
return LV_RES_OK;
|
||||
}
|
||||
}
|
||||
else if(strcmp(lv_fs_get_ext(fn), "jpg") == 0) {
|
||||
|
||||
lv_fs_file_t lv_file;
|
||||
lv_fs_res_t res = lv_fs_open(&lv_file, fn, LV_FS_MODE_RD);
|
||||
if(res != LV_FS_RES_OK) {
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
SJPEG * sjpeg = (SJPEG *) dsc->user_data;
|
||||
if(sjpeg == NULL) {
|
||||
sjpeg = lv_mem_alloc(sizeof(SJPEG));
|
||||
if(! sjpeg) {
|
||||
lv_fs_close(&lv_file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
memset(sjpeg, 0, sizeof(SJPEG));
|
||||
dsc->user_data = sjpeg;
|
||||
sjpeg->sjpeg_data = (uint8_t *)((lv_img_dsc_t *)(dsc->src))->data;
|
||||
sjpeg->sjpeg_data_size = ((lv_img_dsc_t *)(dsc->src))->data_size;
|
||||
}
|
||||
|
||||
uint8_t * workb_temp = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(! workb_temp) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
io_source_t io_source_temp;
|
||||
io_source_temp.type = SJPEG_IO_SOURCE_DISK;
|
||||
io_source_temp.raw_sjpg_data_next_read_pos = 0;
|
||||
io_source_temp.img_cache_buff = NULL;
|
||||
io_source_temp.lv_file = lv_file;
|
||||
|
||||
JDEC jd_tmp;
|
||||
|
||||
JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp);
|
||||
|
||||
lv_mem_free(workb_temp);
|
||||
|
||||
if(rc == JDR_OK) {
|
||||
sjpeg->sjpeg_x_res = jd_tmp.width;
|
||||
sjpeg->sjpeg_y_res = jd_tmp.height;
|
||||
sjpeg->sjpeg_total_frames = 1;
|
||||
sjpeg->sjpeg_single_frame_height = jd_tmp.height;
|
||||
|
||||
sjpeg->frame_base_array = NULL;
|
||||
sjpeg->frame_base_offset = lv_mem_alloc(sizeof(uint8_t *) * sjpeg->sjpeg_total_frames);
|
||||
if(! sjpeg->frame_base_offset) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
int img_frame_start_offset = 0;
|
||||
sjpeg->frame_base_offset[0] = img_frame_start_offset;
|
||||
|
||||
sjpeg->sjpeg_cache_frame_index = -1;
|
||||
sjpeg->frame_cache = (void *)lv_mem_alloc(sjpeg->sjpeg_x_res * sjpeg->sjpeg_single_frame_height * 3);
|
||||
if(! sjpeg->frame_cache) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->io.img_cache_buff = sjpeg->frame_cache;
|
||||
sjpeg->io.img_cache_x_res = sjpeg->sjpeg_x_res;
|
||||
sjpeg->workb = lv_mem_alloc(TJPGD_WORKBUFF_SIZE);
|
||||
if(! sjpeg->workb) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->tjpeg_jd = lv_mem_alloc(sizeof(JDEC));
|
||||
if(! sjpeg->tjpeg_jd) {
|
||||
lv_fs_close(&lv_file);
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
sjpeg->io.type = SJPEG_IO_SOURCE_DISK;
|
||||
sjpeg->io.lv_file = lv_file;
|
||||
dsc->img_data = NULL;
|
||||
return LV_RES_OK;
|
||||
|
||||
}
|
||||
else {
|
||||
if(dsc->user_data) lv_mem_free(dsc->user_data);
|
||||
lv_fs_close(&lv_file);
|
||||
return LV_RES_INV;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode `len` pixels starting from the given `x`, `y` coordinates and store them in `buf`.
|
||||
* Required only if the "open" function can't open the whole decoded pixel array. (dsc->img_data == NULL)
|
||||
* @param decoder pointer to the decoder the function associated with
|
||||
* @param dsc pointer to decoder descriptor
|
||||
* @param x start x coordinate
|
||||
* @param y start y coordinate
|
||||
* @param len number of pixels to decode
|
||||
* @param buf a buffer to store the decoded pixels
|
||||
* @return LV_RES_OK: ok; LV_RES_INV: failed
|
||||
*/
|
||||
|
||||
static lv_res_t 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_UNUSED(decoder);
|
||||
if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
|
||||
SJPEG * sjpeg = (SJPEG *) dsc->user_data;
|
||||
JRESULT rc;
|
||||
|
||||
int sjpeg_req_frame_index = y / sjpeg->sjpeg_single_frame_height;
|
||||
|
||||
/*If line not from cache, refresh cache */
|
||||
if(sjpeg_req_frame_index != sjpeg->sjpeg_cache_frame_index) {
|
||||
sjpeg->io.raw_sjpg_data = sjpeg->frame_base_array[ sjpeg_req_frame_index ];
|
||||
if(sjpeg_req_frame_index == (sjpeg->sjpeg_total_frames - 1)) {
|
||||
/*This is the last frame. */
|
||||
const uint32_t frame_offset = (uint32_t)(sjpeg->io.raw_sjpg_data - sjpeg->sjpeg_data);
|
||||
sjpeg->io.raw_sjpg_data_size = sjpeg->sjpeg_data_size - frame_offset;
|
||||
}
|
||||
else {
|
||||
sjpeg->io.raw_sjpg_data_size =
|
||||
(uint32_t)(sjpeg->frame_base_array[sjpeg_req_frame_index + 1] - sjpeg->io.raw_sjpg_data);
|
||||
}
|
||||
sjpeg->io.raw_sjpg_data_next_read_pos = 0;
|
||||
rc = jd_prepare(sjpeg->tjpeg_jd, input_func, sjpeg->workb, (size_t)TJPGD_WORKBUFF_SIZE, &(sjpeg->io));
|
||||
if(rc != JDR_OK) return LV_RES_INV;
|
||||
rc = jd_decomp(sjpeg->tjpeg_jd, img_data_cb, 0);
|
||||
if(rc != JDR_OK) return LV_RES_INV;
|
||||
sjpeg->sjpeg_cache_frame_index = sjpeg_req_frame_index;
|
||||
}
|
||||
|
||||
int offset = 0;
|
||||
uint8_t * cache = (uint8_t *)sjpeg->frame_cache + x * 3 + (y % sjpeg->sjpeg_single_frame_height) * sjpeg->sjpeg_x_res *
|
||||
3;
|
||||
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
for(int i = 0; i < len; i++) {
|
||||
buf[offset + 3] = 0xff;
|
||||
buf[offset + 2] = *cache++;
|
||||
buf[offset + 1] = *cache++;
|
||||
buf[offset + 0] = *cache++;
|
||||
offset += 4;
|
||||
}
|
||||
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
|
||||
for(int i = 0; i < len; i++) {
|
||||
uint16_t col_16bit = (*cache++ & 0xf8) << 8;
|
||||
col_16bit |= (*cache++ & 0xFC) << 3;
|
||||
col_16bit |= (*cache++ >> 3);
|
||||
#if LV_BIG_ENDIAN_SYSTEM == 1 || LV_COLOR_16_SWAP == 1
|
||||
buf[offset++] = col_16bit >> 8;
|
||||
buf[offset++] = col_16bit & 0xff;
|
||||
#else
|
||||
buf[offset++] = col_16bit & 0xff;
|
||||
buf[offset++] = col_16bit >> 8;
|
||||
#endif // LV_BIG_ENDIAN_SYSTEM
|
||||
}
|
||||
|
||||
#elif LV_COLOR_DEPTH == 8
|
||||
|
||||
for(int i = 0; i < len; i++) {
|
||||
uint8_t col_8bit = (*cache++ & 0xC0);
|
||||
col_8bit |= (*cache++ & 0xe0) >> 2;
|
||||
col_8bit |= (*cache++ & 0xe0) >> 5;
|
||||
buf[offset++] = col_8bit;
|
||||
}
|
||||
#else
|
||||
#error Unsupported LV_COLOR_DEPTH
|
||||
|
||||
#endif // LV_COLOR_DEPTH
|
||||
return LV_RES_OK;
|
||||
}
|
||||
else if(dsc->src_type == LV_IMG_SRC_FILE) {
|
||||
SJPEG * sjpeg = (SJPEG *) dsc->user_data;
|
||||
JRESULT rc;
|
||||
int sjpeg_req_frame_index = y / sjpeg->sjpeg_single_frame_height;
|
||||
|
||||
lv_fs_file_t * lv_file_p = &(sjpeg->io.lv_file);
|
||||
if(!lv_file_p) goto end;
|
||||
|
||||
/*If line not from cache, refresh cache */
|
||||
if(sjpeg_req_frame_index != sjpeg->sjpeg_cache_frame_index) {
|
||||
sjpeg->io.raw_sjpg_data_next_read_pos = (int)(sjpeg->frame_base_offset [ sjpeg_req_frame_index ]);
|
||||
lv_fs_seek(&(sjpeg->io.lv_file), sjpeg->io.raw_sjpg_data_next_read_pos, LV_FS_SEEK_SET);
|
||||
|
||||
rc = jd_prepare(sjpeg->tjpeg_jd, input_func, sjpeg->workb, (size_t)TJPGD_WORKBUFF_SIZE, &(sjpeg->io));
|
||||
if(rc != JDR_OK) return LV_RES_INV;
|
||||
|
||||
rc = jd_decomp(sjpeg->tjpeg_jd, img_data_cb, 0);
|
||||
if(rc != JDR_OK) return LV_RES_INV;
|
||||
|
||||
sjpeg->sjpeg_cache_frame_index = sjpeg_req_frame_index;
|
||||
}
|
||||
|
||||
int offset = 0;
|
||||
uint8_t * cache = (uint8_t *)sjpeg->frame_cache + x * 3 + (y % sjpeg->sjpeg_single_frame_height) * sjpeg->sjpeg_x_res *
|
||||
3;
|
||||
|
||||
#if LV_COLOR_DEPTH == 32
|
||||
for(int i = 0; i < len; i++) {
|
||||
buf[offset + 3] = 0xff;
|
||||
buf[offset + 2] = *cache++;
|
||||
buf[offset + 1] = *cache++;
|
||||
buf[offset + 0] = *cache++;
|
||||
offset += 4;
|
||||
}
|
||||
#elif LV_COLOR_DEPTH == 16
|
||||
|
||||
for(int i = 0; i < len; i++) {
|
||||
uint16_t col_8bit = (*cache++ & 0xf8) << 8;
|
||||
col_8bit |= (*cache++ & 0xFC) << 3;
|
||||
col_8bit |= (*cache++ >> 3);
|
||||
#if LV_BIG_ENDIAN_SYSTEM == 1 || LV_COLOR_16_SWAP == 1
|
||||
buf[offset++] = col_8bit >> 8;
|
||||
buf[offset++] = col_8bit & 0xff;
|
||||
#else
|
||||
buf[offset++] = col_8bit & 0xff;
|
||||
buf[offset++] = col_8bit >> 8;
|
||||
#endif // LV_BIG_ENDIAN_SYSTEM
|
||||
}
|
||||
|
||||
#elif LV_COLOR_DEPTH == 8
|
||||
|
||||
for(int i = 0; i < len; i++) {
|
||||
uint8_t col_8bit = (*cache++ & 0xC0);
|
||||
col_8bit |= (*cache++ & 0xe0) >> 2;
|
||||
col_8bit |= (*cache++ & 0xe0) >> 5;
|
||||
buf[offset++] = col_8bit;
|
||||
}
|
||||
|
||||
#else
|
||||
#error Unsupported LV_COLOR_DEPTH
|
||||
|
||||
#endif // LV_COLOR_DEPTH
|
||||
|
||||
return LV_RES_OK;
|
||||
}
|
||||
end:
|
||||
return LV_RES_INV;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free the allocated resources
|
||||
* @param decoder pointer to the decoder where this function belongs
|
||||
* @param dsc pointer to a descriptor which describes this decoding session
|
||||
*/
|
||||
static void decoder_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
|
||||
{
|
||||
LV_UNUSED(decoder);
|
||||
/*Free all allocated data*/
|
||||
SJPEG * sjpeg = (SJPEG *) dsc->user_data;
|
||||
if(!sjpeg) return;
|
||||
|
||||
switch(dsc->src_type) {
|
||||
case LV_IMG_SRC_FILE:
|
||||
if(sjpeg->io.lv_file.file_d) {
|
||||
lv_fs_close(&(sjpeg->io.lv_file));
|
||||
}
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
break;
|
||||
|
||||
case LV_IMG_SRC_VARIABLE:
|
||||
lv_sjpg_cleanup(sjpeg);
|
||||
break;
|
||||
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
static int is_jpg(const uint8_t * raw_data, size_t len)
|
||||
{
|
||||
const uint8_t jpg_signature[] = {0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46};
|
||||
if(len < sizeof(jpg_signature)) return false;
|
||||
return memcmp(jpg_signature, raw_data, sizeof(jpg_signature)) == 0;
|
||||
}
|
||||
|
||||
static void lv_sjpg_free(SJPEG * sjpeg)
|
||||
{
|
||||
if(sjpeg->frame_cache) lv_mem_free(sjpeg->frame_cache);
|
||||
if(sjpeg->frame_base_array) lv_mem_free(sjpeg->frame_base_array);
|
||||
if(sjpeg->frame_base_offset) lv_mem_free(sjpeg->frame_base_offset);
|
||||
if(sjpeg->tjpeg_jd) lv_mem_free(sjpeg->tjpeg_jd);
|
||||
if(sjpeg->workb) lv_mem_free(sjpeg->workb);
|
||||
}
|
||||
|
||||
static void lv_sjpg_cleanup(SJPEG * sjpeg)
|
||||
{
|
||||
if(! sjpeg) return;
|
||||
|
||||
lv_sjpg_free(sjpeg);
|
||||
lv_mem_free(sjpeg);
|
||||
}
|
||||
|
||||
#endif /*LV_USE_SJPG*/
|
||||
@@ -0,0 +1,43 @@
|
||||
/**
|
||||
* @file lv_sjpg.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_SJPEG_H
|
||||
#define LV_SJPEG_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
|
||||
#if LV_USE_SJPG
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
void lv_split_jpeg_init(void);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_SJPG*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* LV_SJPEG_H */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,93 @@
|
||||
/*----------------------------------------------------------------------------/
|
||||
/ TJpgDec - Tiny JPEG Decompressor R0.03 include file (C)ChaN, 2021
|
||||
/----------------------------------------------------------------------------*/
|
||||
#ifndef DEF_TJPGDEC
|
||||
#define DEF_TJPGDEC
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../../../lv_conf_internal.h"
|
||||
#if LV_USE_SJPG
|
||||
|
||||
#include "tjpgdcnf.h"
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#if JD_FASTDECODE >= 1
|
||||
typedef int16_t jd_yuv_t;
|
||||
#else
|
||||
typedef uint8_t jd_yuv_t;
|
||||
#endif
|
||||
|
||||
|
||||
/* Error code */
|
||||
typedef enum {
|
||||
JDR_OK = 0, /* 0: Succeeded */
|
||||
JDR_INTR, /* 1: Interrupted by output function */
|
||||
JDR_INP, /* 2: Device error or wrong termination of input stream */
|
||||
JDR_MEM1, /* 3: Insufficient memory pool for the image */
|
||||
JDR_MEM2, /* 4: Insufficient stream input buffer */
|
||||
JDR_PAR, /* 5: Parameter error */
|
||||
JDR_FMT1, /* 6: Data format error (may be broken data) */
|
||||
JDR_FMT2, /* 7: Right format but not supported */
|
||||
JDR_FMT3 /* 8: Not supported JPEG standard */
|
||||
} JRESULT;
|
||||
|
||||
/* Rectangular region in the output image */
|
||||
typedef struct {
|
||||
uint16_t left; /* Left end */
|
||||
uint16_t right; /* Right end */
|
||||
uint16_t top; /* Top end */
|
||||
uint16_t bottom; /* Bottom end */
|
||||
} JRECT;
|
||||
|
||||
/* Decompressor object structure */
|
||||
typedef struct JDEC JDEC;
|
||||
struct JDEC {
|
||||
size_t dctr; /* Number of bytes available in the input buffer */
|
||||
uint8_t* dptr; /* Current data read ptr */
|
||||
uint8_t* inbuf; /* Bit stream input buffer */
|
||||
uint8_t dbit; /* Number of bits availavble in wreg or reading bit mask */
|
||||
uint8_t scale; /* Output scaling ratio */
|
||||
uint8_t msx, msy; /* MCU size in unit of block (width, height) */
|
||||
uint8_t qtid[3]; /* Quantization table ID of each component, Y, Cb, Cr */
|
||||
uint8_t ncomp; /* Number of color components 1:grayscale, 3:color */
|
||||
int16_t dcv[3]; /* Previous DC element of each component */
|
||||
uint16_t nrst; /* Restart inverval */
|
||||
uint16_t width, height; /* Size of the input image (pixel) */
|
||||
uint8_t* huffbits[2][2]; /* Huffman bit distribution tables [id][dcac] */
|
||||
uint16_t* huffcode[2][2]; /* Huffman code word tables [id][dcac] */
|
||||
uint8_t* huffdata[2][2]; /* Huffman decoded data tables [id][dcac] */
|
||||
int32_t* qttbl[4]; /* Dequantizer tables [id] */
|
||||
#if JD_FASTDECODE >= 1
|
||||
uint32_t wreg; /* Working shift register */
|
||||
uint8_t marker; /* Detected marker (0:None) */
|
||||
#if JD_FASTDECODE == 2
|
||||
uint8_t longofs[2][2]; /* Table offset of long code [id][dcac] */
|
||||
uint16_t* hufflut_ac[2]; /* Fast huffman decode tables for AC short code [id] */
|
||||
uint8_t* hufflut_dc[2]; /* Fast huffman decode tables for DC short code [id] */
|
||||
#endif
|
||||
#endif
|
||||
void* workbuf; /* Working buffer for IDCT and RGB output */
|
||||
jd_yuv_t* mcubuf; /* Working buffer for the MCU */
|
||||
void* pool; /* Pointer to available memory pool */
|
||||
size_t sz_pool; /* Size of momory pool (bytes available) */
|
||||
size_t (*infunc)(JDEC*, uint8_t*, size_t); /* Pointer to jpeg stream input function */
|
||||
void* device; /* Pointer to I/O device identifiler for the session */
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* TJpgDec API functions */
|
||||
JRESULT jd_prepare (JDEC* jd, size_t (*infunc)(JDEC*,uint8_t*,size_t), void* pool, size_t sz_pool, void* dev);
|
||||
JRESULT jd_decomp (JDEC* jd, int (*outfunc)(JDEC*,void*,JRECT*), uint8_t scale);
|
||||
|
||||
#endif /*LV_USE_SJPG*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _TJPGDEC */
|
||||
@@ -0,0 +1,33 @@
|
||||
/*----------------------------------------------*/
|
||||
/* TJpgDec System Configurations R0.03 */
|
||||
/*----------------------------------------------*/
|
||||
|
||||
#define JD_SZBUF 512
|
||||
/* Specifies size of stream input buffer */
|
||||
|
||||
#define JD_FORMAT 0
|
||||
/* Specifies output pixel format.
|
||||
/ 0: RGB888 (24-bit/pix)
|
||||
/ 1: RGB565 (16-bit/pix)
|
||||
/ 2: Grayscale (8-bit/pix)
|
||||
*/
|
||||
|
||||
#define JD_USE_SCALE 1
|
||||
/* Switches output descaling feature.
|
||||
/ 0: Disable
|
||||
/ 1: Enable
|
||||
*/
|
||||
|
||||
#define JD_TBLCLIP 1
|
||||
/* Use table conversion for saturation arithmetic. A bit faster, but increases 1 KB of code size.
|
||||
/ 0: Disable
|
||||
/ 1: Enable
|
||||
*/
|
||||
|
||||
#define JD_FASTDECODE 0
|
||||
/* Optimization level
|
||||
/ 0: Basic optimization. Suitable for 8/16-bit MCUs.
|
||||
/ 1: + 32-bit barrel shifter. Suitable for 32-bit MCUs.
|
||||
/ 2: + Table conversion for huffman decoding (wants 6 << HUFF_BIT bytes of RAM)
|
||||
*/
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
#include "lv_tiny_ttf.h"
|
||||
|
||||
#if LV_USE_TINY_TTF
|
||||
#include <stdio.h>
|
||||
#include "../../../misc/lv_lru.h"
|
||||
|
||||
#define STB_RECT_PACK_IMPLEMENTATION
|
||||
#define STBRP_STATIC
|
||||
#define STBTT_STATIC
|
||||
#define STB_TRUETYPE_IMPLEMENTATION
|
||||
#define STBTT_HEAP_FACTOR_SIZE_32 50
|
||||
#define STBTT_HEAP_FACTOR_SIZE_128 20
|
||||
#define STBTT_HEAP_FACTOR_SIZE_DEFAULT 10
|
||||
#define STBTT_malloc(x, u) ((void)(u), lv_mem_alloc(x))
|
||||
#define STBTT_free(x, u) ((void)(u), lv_mem_free(x))
|
||||
#define TTF_MALLOC(x) (lv_mem_alloc(x))
|
||||
#define TTF_FREE(x) (lv_mem_free(x))
|
||||
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
/* a hydra stream that can be in memory or from a file*/
|
||||
typedef struct ttf_cb_stream {
|
||||
lv_fs_file_t * file;
|
||||
const void * data;
|
||||
size_t size;
|
||||
size_t position;
|
||||
} ttf_cb_stream_t;
|
||||
|
||||
static void ttf_cb_stream_read(ttf_cb_stream_t * stream, void * data, size_t to_read)
|
||||
{
|
||||
if(stream->file != NULL) {
|
||||
uint32_t br;
|
||||
lv_fs_read(stream->file, data, to_read, &br);
|
||||
}
|
||||
else {
|
||||
if(to_read + stream->position >= stream->size) {
|
||||
to_read = stream->size - stream->position;
|
||||
}
|
||||
lv_memcpy(data, ((const unsigned char *)stream->data + stream->position), to_read);
|
||||
stream->position += to_read;
|
||||
}
|
||||
}
|
||||
static void ttf_cb_stream_seek(ttf_cb_stream_t * stream, size_t position)
|
||||
{
|
||||
if(stream->file != NULL) {
|
||||
lv_fs_seek(stream->file, position, LV_FS_SEEK_SET);
|
||||
}
|
||||
else {
|
||||
if(position > stream->size) {
|
||||
stream->position = stream->size;
|
||||
}
|
||||
else {
|
||||
stream->position = position;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* for stream support */
|
||||
#define STBTT_STREAM_TYPE ttf_cb_stream_t *
|
||||
#define STBTT_STREAM_SEEK(s, x) ttf_cb_stream_seek(s, x);
|
||||
#define STBTT_STREAM_READ(s, x, y) ttf_cb_stream_read(s, x, y);
|
||||
#endif /*LV_TINY_TTF_FILE_SUPPORT*/
|
||||
|
||||
#include "stb_rect_pack.h"
|
||||
#include "stb_truetype_htcw.h"
|
||||
|
||||
typedef struct ttf_font_desc {
|
||||
lv_fs_file_t file;
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
ttf_cb_stream_t stream;
|
||||
#else
|
||||
const uint8_t * stream;
|
||||
#endif
|
||||
stbtt_fontinfo info;
|
||||
float scale;
|
||||
int ascent;
|
||||
int descent;
|
||||
lv_lru_t * bitmap_cache;
|
||||
} ttf_font_desc_t;
|
||||
|
||||
typedef struct ttf_bitmap_cache_key {
|
||||
uint32_t unicode_letter;
|
||||
lv_coord_t line_height;
|
||||
} ttf_bitmap_cache_key_t;
|
||||
|
||||
static bool ttf_get_glyph_dsc_cb(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter,
|
||||
uint32_t unicode_letter_next)
|
||||
{
|
||||
if(unicode_letter < 0x20 ||
|
||||
unicode_letter == 0xf8ff || /*LV_SYMBOL_DUMMY*/
|
||||
unicode_letter == 0x200c) { /*ZERO WIDTH NON-JOINER*/
|
||||
dsc_out->box_w = 0;
|
||||
dsc_out->adv_w = 0;
|
||||
dsc_out->box_h = 0; /*height of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = 0; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = 0; /*Y offset of the bitmap in [pf]*/
|
||||
dsc_out->bpp = 0;
|
||||
dsc_out->is_placeholder = false;
|
||||
return true;
|
||||
}
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
|
||||
int g1 = stbtt_FindGlyphIndex(&dsc->info, (int)unicode_letter);
|
||||
if(g1 == 0) {
|
||||
/* Glyph not found */
|
||||
return false;
|
||||
}
|
||||
int x1, y1, x2, y2;
|
||||
|
||||
stbtt_GetGlyphBitmapBox(&dsc->info, g1, dsc->scale, dsc->scale, &x1, &y1, &x2, &y2);
|
||||
int g2 = 0;
|
||||
if(unicode_letter_next != 0) {
|
||||
g2 = stbtt_FindGlyphIndex(&dsc->info, (int)unicode_letter_next);
|
||||
}
|
||||
int advw, lsb;
|
||||
stbtt_GetGlyphHMetrics(&dsc->info, g1, &advw, &lsb);
|
||||
int k = stbtt_GetGlyphKernAdvance(&dsc->info, g1, g2);
|
||||
dsc_out->adv_w = (uint16_t)floor((((float)advw + (float)k) * dsc->scale) +
|
||||
0.5f); /*Horizontal space required by the glyph in [px]*/
|
||||
|
||||
dsc_out->adv_w = (uint16_t)floor((((float)advw + (float)k) * dsc->scale) +
|
||||
0.5f); /*Horizontal space required by the glyph in [px]*/
|
||||
dsc_out->box_w = (x2 - x1 + 1); /*width of the bitmap in [px]*/
|
||||
dsc_out->box_h = (y2 - y1 + 1); /*height of the bitmap in [px]*/
|
||||
dsc_out->ofs_x = x1; /*X offset of the bitmap in [pf]*/
|
||||
dsc_out->ofs_y = -y2; /*Y offset of the bitmap measured from the as line*/
|
||||
dsc_out->bpp = 8; /*Bits per pixel: 1/2/4/8*/
|
||||
dsc_out->is_placeholder = false;
|
||||
return true; /*true: glyph found; false: glyph was not found*/
|
||||
}
|
||||
|
||||
static const uint8_t * ttf_get_glyph_bitmap_cb(const lv_font_t * font, uint32_t unicode_letter)
|
||||
{
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
|
||||
const stbtt_fontinfo * info = (const stbtt_fontinfo *)&dsc->info;
|
||||
int g1 = stbtt_FindGlyphIndex(info, (int)unicode_letter);
|
||||
if(g1 == 0) {
|
||||
/* Glyph not found */
|
||||
return NULL;
|
||||
}
|
||||
int x1, y1, x2, y2;
|
||||
stbtt_GetGlyphBitmapBox(info, g1, dsc->scale, dsc->scale, &x1, &y1, &x2, &y2);
|
||||
int w, h;
|
||||
w = x2 - x1 + 1;
|
||||
h = y2 - y1 + 1;
|
||||
uint32_t stride = w;
|
||||
/*Try to load from cache*/
|
||||
ttf_bitmap_cache_key_t cache_key;
|
||||
lv_memset(&cache_key, 0, sizeof(cache_key)); /*Zero padding*/
|
||||
cache_key.unicode_letter = unicode_letter;
|
||||
cache_key.line_height = font->line_height;
|
||||
uint8_t * buffer = NULL;
|
||||
lv_lru_get(dsc->bitmap_cache, &cache_key, sizeof(cache_key), (void **)&buffer);
|
||||
if(buffer) {
|
||||
return buffer;
|
||||
}
|
||||
LV_LOG_TRACE("cache miss for letter: %u", unicode_letter);
|
||||
/*Prepare space in cache*/
|
||||
size_t szb = h * stride;
|
||||
buffer = lv_mem_alloc(szb);
|
||||
if(!buffer) {
|
||||
LV_LOG_ERROR("failed to allocate cache value");
|
||||
return NULL;
|
||||
}
|
||||
lv_memset(buffer, 0, szb);
|
||||
if(LV_LRU_OK != lv_lru_set(dsc->bitmap_cache, &cache_key, sizeof(cache_key), buffer, szb)) {
|
||||
LV_LOG_ERROR("failed to add cache value");
|
||||
lv_mem_free(buffer);
|
||||
return NULL;
|
||||
}
|
||||
/*Render into cache*/
|
||||
stbtt_MakeGlyphBitmap(info, buffer, w, h, stride, dsc->scale, dsc->scale, g1);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static lv_font_t * lv_tiny_ttf_create(const char * path, const void * data, size_t data_size, lv_coord_t font_size,
|
||||
size_t cache_size)
|
||||
{
|
||||
if((path == NULL && data == NULL) || 0 >= font_size) {
|
||||
LV_LOG_ERROR("tiny_ttf: invalid argument\n");
|
||||
return NULL;
|
||||
}
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)TTF_MALLOC(sizeof(ttf_font_desc_t));
|
||||
if(dsc == NULL) {
|
||||
LV_LOG_ERROR("tiny_ttf: out of memory\n");
|
||||
return NULL;
|
||||
}
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
if(path != NULL) {
|
||||
if(LV_FS_RES_OK != lv_fs_open(&dsc->file, path, LV_FS_MODE_RD)) {
|
||||
LV_LOG_ERROR("tiny_ttf: unable to open %s\n", path);
|
||||
goto err_after_dsc;
|
||||
}
|
||||
dsc->stream.file = &dsc->file;
|
||||
}
|
||||
else {
|
||||
dsc->stream.file = NULL;
|
||||
dsc->stream.data = (const uint8_t *)data;
|
||||
dsc->stream.size = data_size;
|
||||
dsc->stream.position = 0;
|
||||
}
|
||||
if(0 == stbtt_InitFont(&dsc->info, &dsc->stream, stbtt_GetFontOffsetForIndex(&dsc->stream, 0))) {
|
||||
LV_LOG_ERROR("tiny_ttf: init failed\n");
|
||||
goto err_after_dsc;
|
||||
}
|
||||
|
||||
#else
|
||||
dsc->stream = (const uint8_t *)data;
|
||||
LV_UNUSED(data_size);
|
||||
if(0 == stbtt_InitFont(&dsc->info, dsc->stream, stbtt_GetFontOffsetForIndex(dsc->stream, 0))) {
|
||||
LV_LOG_ERROR("tiny_ttf: init failed\n");
|
||||
goto err_after_dsc;
|
||||
}
|
||||
#endif
|
||||
|
||||
dsc->bitmap_cache = lv_lru_create(cache_size, font_size * font_size, lv_mem_free, lv_mem_free);
|
||||
if(dsc->bitmap_cache == NULL) {
|
||||
LV_LOG_ERROR("failed to create lru cache");
|
||||
goto err_after_dsc;
|
||||
}
|
||||
|
||||
lv_font_t * out_font = (lv_font_t *)TTF_MALLOC(sizeof(lv_font_t));
|
||||
if(out_font == NULL) {
|
||||
LV_LOG_ERROR("tiny_ttf: out of memory\n");
|
||||
goto err_after_bitmap_cache;
|
||||
}
|
||||
lv_memset(out_font, 0, sizeof(lv_font_t));
|
||||
out_font->get_glyph_dsc = ttf_get_glyph_dsc_cb;
|
||||
out_font->get_glyph_bitmap = ttf_get_glyph_bitmap_cb;
|
||||
out_font->dsc = dsc;
|
||||
lv_tiny_ttf_set_size(out_font, font_size);
|
||||
return out_font;
|
||||
err_after_bitmap_cache:
|
||||
lv_lru_del(dsc->bitmap_cache);
|
||||
err_after_dsc:
|
||||
TTF_FREE(dsc);
|
||||
return NULL;
|
||||
}
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
lv_font_t * lv_tiny_ttf_create_file_ex(const char * path, lv_coord_t font_size, size_t cache_size)
|
||||
{
|
||||
return lv_tiny_ttf_create(path, NULL, 0, font_size, cache_size);
|
||||
}
|
||||
lv_font_t * lv_tiny_ttf_create_file(const char * path, lv_coord_t font_size)
|
||||
{
|
||||
return lv_tiny_ttf_create_file_ex(path, font_size, 4096);
|
||||
}
|
||||
#endif /*LV_TINY_TTF_FILE_SUPPORT*/
|
||||
lv_font_t * lv_tiny_ttf_create_data_ex(const void * data, size_t data_size, lv_coord_t font_size, size_t cache_size)
|
||||
{
|
||||
return lv_tiny_ttf_create(NULL, data, data_size, font_size, cache_size);
|
||||
}
|
||||
lv_font_t * lv_tiny_ttf_create_data(const void * data, size_t data_size, lv_coord_t font_size)
|
||||
{
|
||||
return lv_tiny_ttf_create_data_ex(data, data_size, font_size, 4096);
|
||||
}
|
||||
void lv_tiny_ttf_set_size(lv_font_t * font, lv_coord_t font_size)
|
||||
{
|
||||
if(font_size <= 0) {
|
||||
LV_LOG_ERROR("invalid font size: %"PRIx32, font_size);
|
||||
return;
|
||||
}
|
||||
ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
|
||||
dsc->scale = stbtt_ScaleForMappingEmToPixels(&dsc->info, font_size);
|
||||
int line_gap = 0;
|
||||
stbtt_GetFontVMetrics(&dsc->info, &dsc->ascent, &dsc->descent, &line_gap);
|
||||
font->line_height = (lv_coord_t)(dsc->scale * (dsc->ascent - dsc->descent + line_gap));
|
||||
font->base_line = (lv_coord_t)(dsc->scale * (line_gap - dsc->descent));
|
||||
}
|
||||
void lv_tiny_ttf_destroy(lv_font_t * font)
|
||||
{
|
||||
if(font != NULL) {
|
||||
if(font->dsc != NULL) {
|
||||
ttf_font_desc_t * ttf = (ttf_font_desc_t *)font->dsc;
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
if(ttf->stream.file != NULL) {
|
||||
lv_fs_close(&ttf->file);
|
||||
}
|
||||
#endif
|
||||
lv_lru_del(ttf->bitmap_cache);
|
||||
TTF_FREE(ttf);
|
||||
}
|
||||
TTF_FREE(font);
|
||||
}
|
||||
}
|
||||
#endif /*LV_USE_TINY_TTF*/
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* @file lv_tiny_ttf.h
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef LV_TINY_TTF_H
|
||||
#define LV_TINY_TTF_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*********************
|
||||
* INCLUDES
|
||||
*********************/
|
||||
#include "../../../lvgl.h"
|
||||
|
||||
#if LV_USE_TINY_TTF
|
||||
|
||||
/*********************
|
||||
* DEFINES
|
||||
*********************/
|
||||
|
||||
/**********************
|
||||
* TYPEDEFS
|
||||
**********************/
|
||||
|
||||
/**********************
|
||||
* GLOBAL PROTOTYPES
|
||||
**********************/
|
||||
|
||||
#if LV_TINY_TTF_FILE_SUPPORT
|
||||
/* create a font from the specified file or path with the specified line height.*/
|
||||
lv_font_t * lv_tiny_ttf_create_file(const char * path, lv_coord_t font_size);
|
||||
|
||||
/* create a font from the specified file or path with the specified line height with the specified cache size.*/
|
||||
lv_font_t * lv_tiny_ttf_create_file_ex(const char * path, lv_coord_t font_size, size_t cache_size);
|
||||
#endif /*LV_TINY_TTF_FILE_SUPPORT*/
|
||||
|
||||
/* create a font from the specified data pointer with the specified line height.*/
|
||||
lv_font_t * lv_tiny_ttf_create_data(const void * data, size_t data_size, lv_coord_t font_size);
|
||||
|
||||
/* create a font from the specified data pointer with the specified line height and the specified cache size.*/
|
||||
lv_font_t * lv_tiny_ttf_create_data_ex(const void * data, size_t data_size, lv_coord_t font_size, size_t cache_size);
|
||||
|
||||
/* set the size of the font to a new font_size*/
|
||||
void lv_tiny_ttf_set_size(lv_font_t * font, lv_coord_t font_size);
|
||||
|
||||
/* destroy a font previously created with lv_tiny_ttf_create_xxxx()*/
|
||||
void lv_tiny_ttf_destroy(lv_font_t * font);
|
||||
|
||||
/**********************
|
||||
* MACROS
|
||||
**********************/
|
||||
|
||||
#endif /*LV_USE_TINY_TTF*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /*extern "C"*/
|
||||
#endif
|
||||
|
||||
#endif /*LV_TINY_TTF_H*/
|
||||
@@ -0,0 +1,633 @@
|
||||
// stb_rect_pack.h - v1.01 - public domain - rectangle packing
|
||||
// Sean Barrett 2014
|
||||
//
|
||||
// Useful for e.g. packing rectangular textures into an atlas.
|
||||
// Does not do rotation.
|
||||
//
|
||||
// Before #including,
|
||||
//
|
||||
// #define STB_RECT_PACK_IMPLEMENTATION
|
||||
//
|
||||
// in the file that you want to have the implementation.
|
||||
//
|
||||
// Not necessarily the awesomest packing method, but better than
|
||||
// the totally naive one in stb_truetype (which is primarily what
|
||||
// this is meant to replace).
|
||||
//
|
||||
// Has only had a few tests run, may have issues.
|
||||
//
|
||||
// More docs to come.
|
||||
//
|
||||
// No memory allocations; uses qsort() and assert() from stdlib.
|
||||
// Can override those by defining STBRP_SORT and STBRP_ASSERT.
|
||||
//
|
||||
// This library currently uses the Skyline Bottom-Left algorithm.
|
||||
//
|
||||
// Please note: better rectangle packers are welcome! Please
|
||||
// implement them to the same API, but with a different init
|
||||
// function.
|
||||
//
|
||||
// Credits
|
||||
//
|
||||
// Library
|
||||
// Sean Barrett
|
||||
// Minor features
|
||||
// Martins Mozeiko
|
||||
// github:IntellectualKitty
|
||||
//
|
||||
// Bugfixes / warning fixes
|
||||
// Jeremy Jaussaud
|
||||
// Fabian Giesen
|
||||
//
|
||||
// Version history:
|
||||
//
|
||||
// 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section
|
||||
// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles
|
||||
// 0.99 (2019-02-07) warning fixes
|
||||
// 0.11 (2017-03-03) return packing success/fail result
|
||||
// 0.10 (2016-10-25) remove cast-away-const to avoid warnings
|
||||
// 0.09 (2016-08-27) fix compiler warnings
|
||||
// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0)
|
||||
// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0)
|
||||
// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort
|
||||
// 0.05: added STBRP_ASSERT to allow replacing assert
|
||||
// 0.04: fixed minor bug in STBRP_LARGE_RECTS support
|
||||
// 0.01: initial release
|
||||
//
|
||||
// LICENSE
|
||||
//
|
||||
// See end of file for license information.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// INCLUDE SECTION
|
||||
//
|
||||
|
||||
#ifndef STB_INCLUDE_STB_RECT_PACK_H
|
||||
#define STB_INCLUDE_STB_RECT_PACK_H
|
||||
|
||||
#define STB_RECT_PACK_VERSION 1
|
||||
|
||||
#ifdef STBRP_STATIC
|
||||
#define STBRP_DEF static
|
||||
#else
|
||||
#define STBRP_DEF extern
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/// @cond
|
||||
/**
|
||||
* Tells Doxygen to ignore a duplicate declaration
|
||||
*/
|
||||
typedef struct stbrp_context stbrp_context;
|
||||
typedef struct stbrp_node stbrp_node;
|
||||
typedef struct stbrp_rect stbrp_rect;
|
||||
/// @endcond
|
||||
|
||||
typedef int stbrp_coord;
|
||||
|
||||
#define STBRP__MAXVAL 0x7fffffff
|
||||
// Mostly for internal use, but this is the maximum supported coordinate value.
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#endif
|
||||
|
||||
STBRP_DEF int stbrp_pack_rects(stbrp_context * context, stbrp_rect * rects, int num_rects);
|
||||
// Assign packed locations to rectangles. The rectangles are of type
|
||||
// 'stbrp_rect' defined below, stored in the array 'rects', and there
|
||||
// are 'num_rects' many of them.
|
||||
//
|
||||
// Rectangles which are successfully packed have the 'was_packed' flag
|
||||
// set to a non-zero value and 'x' and 'y' store the minimum location
|
||||
// on each axis (i.e. bottom-left in cartesian coordinates, top-left
|
||||
// if you imagine y increasing downwards). Rectangles which do not fit
|
||||
// have the 'was_packed' flag set to 0.
|
||||
//
|
||||
// You should not try to access the 'rects' array from another thread
|
||||
// while this function is running, as the function temporarily reorders
|
||||
// the array while it executes.
|
||||
//
|
||||
// To pack into another rectangle, you need to call stbrp_init_target
|
||||
// again. To continue packing into the same rectangle, you can call
|
||||
// this function again. Calling this multiple times with multiple rect
|
||||
// arrays will probably produce worse packing results than calling it
|
||||
// a single time with the full rectangle array, but the option is
|
||||
// available.
|
||||
//
|
||||
// The function returns 1 if all of the rectangles were successfully
|
||||
// packed and 0 otherwise.
|
||||
|
||||
struct stbrp_rect {
|
||||
// reserved for your use:
|
||||
int id;
|
||||
|
||||
// input:
|
||||
stbrp_coord w, h;
|
||||
|
||||
// output:
|
||||
stbrp_coord x, y;
|
||||
int was_packed; // non-zero if valid packing
|
||||
|
||||
}; // 16 bytes, nominally
|
||||
|
||||
STBRP_DEF void stbrp_init_target(stbrp_context * context, int width, int height, stbrp_node * nodes, int num_nodes);
|
||||
// Initialize a rectangle packer to:
|
||||
// pack a rectangle that is 'width' by 'height' in dimensions
|
||||
// using temporary storage provided by the array 'nodes', which is 'num_nodes' long
|
||||
//
|
||||
// You must call this function every time you start packing into a new target.
|
||||
//
|
||||
// There is no "shutdown" function. The 'nodes' memory must stay valid for
|
||||
// the following stbrp_pack_rects() call (or calls), but can be freed after
|
||||
// the call (or calls) finish.
|
||||
//
|
||||
// Note: to guarantee best results, either:
|
||||
// 1. make sure 'num_nodes' >= 'width'
|
||||
// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
|
||||
//
|
||||
// If you don't do either of the above things, widths will be quantized to multiples
|
||||
// of small integers to guarantee the algorithm doesn't run out of temporary storage.
|
||||
//
|
||||
// If you do #2, then the non-quantized algorithm will be used, but the algorithm
|
||||
// may run out of temporary storage and be unable to pack some rectangles.
|
||||
|
||||
STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context * context, int allow_out_of_mem);
|
||||
// Optionally call this function after init but before doing any packing to
|
||||
// change the handling of the out-of-temp-memory scenario, described above.
|
||||
// If you call init again, this will be reset to the default (false).
|
||||
|
||||
STBRP_DEF void stbrp_setup_heuristic(stbrp_context * context, int heuristic);
|
||||
// Optionally select which packing heuristic the library should use. Different
|
||||
// heuristics will produce better/worse results for different data sets.
|
||||
// If you call init again, this will be reset to the default.
|
||||
|
||||
enum {
|
||||
STBRP_HEURISTIC_Skyline_default = 0,
|
||||
STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
|
||||
STBRP_HEURISTIC_Skyline_BF_sortHeight
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// the details of the following structures don't matter to you, but they must
|
||||
// be visible so you can handle the memory allocations for them
|
||||
|
||||
struct stbrp_node {
|
||||
stbrp_coord x, y;
|
||||
stbrp_node * next;
|
||||
};
|
||||
|
||||
struct stbrp_context {
|
||||
int width;
|
||||
int height;
|
||||
int align;
|
||||
int init_mode;
|
||||
int heuristic;
|
||||
int num_nodes;
|
||||
stbrp_node * active_head;
|
||||
stbrp_node * free_head;
|
||||
stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPLEMENTATION SECTION
|
||||
//
|
||||
|
||||
#ifdef STB_RECT_PACK_IMPLEMENTATION
|
||||
#ifndef STBRP_SORT
|
||||
#include <stdlib.h>
|
||||
#define STBRP_SORT qsort
|
||||
#endif
|
||||
|
||||
#ifndef STBRP_ASSERT
|
||||
#include <assert.h>
|
||||
#define STBRP_ASSERT assert
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define STBRP__NOTUSED(v) (void)(v)
|
||||
#define STBRP__CDECL __cdecl
|
||||
#else
|
||||
#define STBRP__NOTUSED(v) (void)sizeof(v)
|
||||
#define STBRP__CDECL
|
||||
#endif
|
||||
|
||||
enum {
|
||||
STBRP__INIT_skyline = 1
|
||||
};
|
||||
|
||||
STBRP_DEF void stbrp_setup_heuristic(stbrp_context * context, int heuristic)
|
||||
{
|
||||
switch(context->init_mode) {
|
||||
case STBRP__INIT_skyline:
|
||||
STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
|
||||
context->heuristic = heuristic;
|
||||
break;
|
||||
default:
|
||||
STBRP_ASSERT(0);
|
||||
}
|
||||
}
|
||||
|
||||
STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context * context, int allow_out_of_mem)
|
||||
{
|
||||
if(allow_out_of_mem)
|
||||
// if it's ok to run out of memory, then don't bother aligning them;
|
||||
// this gives better packing, but may fail due to OOM (even though
|
||||
// the rectangles easily fit). @TODO a smarter approach would be to only
|
||||
// quantize once we've hit OOM, then we could get rid of this parameter.
|
||||
context->align = 1;
|
||||
else {
|
||||
// if it's not ok to run out of memory, then quantize the widths
|
||||
// so that num_nodes is always enough nodes.
|
||||
//
|
||||
// I.e. num_nodes * align >= width
|
||||
// align >= width / num_nodes
|
||||
// align = ceil(width/num_nodes)
|
||||
|
||||
context->align = (context->width + context->num_nodes - 1) / context->num_nodes;
|
||||
}
|
||||
}
|
||||
|
||||
STBRP_DEF void stbrp_init_target(stbrp_context * context, int width, int height, stbrp_node * nodes, int num_nodes)
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i = 0; i < num_nodes - 1; ++i)
|
||||
nodes[i].next = &nodes[i + 1];
|
||||
nodes[i].next = NULL;
|
||||
context->init_mode = STBRP__INIT_skyline;
|
||||
context->heuristic = STBRP_HEURISTIC_Skyline_default;
|
||||
context->free_head = &nodes[0];
|
||||
context->active_head = &context->extra[0];
|
||||
context->width = width;
|
||||
context->height = height;
|
||||
context->num_nodes = num_nodes;
|
||||
stbrp_setup_allow_out_of_mem(context, 0);
|
||||
|
||||
// node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
|
||||
context->extra[0].x = 0;
|
||||
context->extra[0].y = 0;
|
||||
context->extra[0].next = &context->extra[1];
|
||||
context->extra[1].x = (stbrp_coord) width;
|
||||
context->extra[1].y = (1 << 30);
|
||||
context->extra[1].next = NULL;
|
||||
}
|
||||
|
||||
// find minimum y position if it starts at x1
|
||||
static int stbrp__skyline_find_min_y(stbrp_context * c, stbrp_node * first, int x0, int width, int * pwaste)
|
||||
{
|
||||
stbrp_node * node = first;
|
||||
int x1 = x0 + width;
|
||||
int min_y, visited_width, waste_area;
|
||||
|
||||
STBRP__NOTUSED(c);
|
||||
|
||||
STBRP_ASSERT(first->x <= x0);
|
||||
|
||||
#if 0
|
||||
// skip in case we're past the node
|
||||
while(node->next->x <= x0)
|
||||
++node;
|
||||
#else
|
||||
STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
|
||||
#endif
|
||||
|
||||
STBRP_ASSERT(node->x <= x0);
|
||||
|
||||
min_y = 0;
|
||||
waste_area = 0;
|
||||
visited_width = 0;
|
||||
while(node->x < x1) {
|
||||
if(node->y > min_y) {
|
||||
// raise min_y higher.
|
||||
// we've accounted for all waste up to min_y,
|
||||
// but we'll now add more waste for everything we've visited
|
||||
waste_area += visited_width * (node->y - min_y);
|
||||
min_y = node->y;
|
||||
// the first time through, visited_width might be reduced
|
||||
if(node->x < x0)
|
||||
visited_width += node->next->x - x0;
|
||||
else
|
||||
visited_width += node->next->x - node->x;
|
||||
}
|
||||
else {
|
||||
// add waste area
|
||||
int under_width = node->next->x - node->x;
|
||||
if(under_width + visited_width > width)
|
||||
under_width = width - visited_width;
|
||||
waste_area += under_width * (min_y - node->y);
|
||||
visited_width += under_width;
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
*pwaste = waste_area;
|
||||
return min_y;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
stbrp_node ** prev_link;
|
||||
} stbrp__findresult;
|
||||
|
||||
static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context * c, int width, int height)
|
||||
{
|
||||
int best_waste = (1 << 30), best_x, best_y = (1 << 30);
|
||||
stbrp__findresult fr;
|
||||
stbrp_node ** prev, * node, * tail, ** best = NULL;
|
||||
|
||||
// align to multiple of c->align
|
||||
width = (width + c->align - 1);
|
||||
width -= width % c->align;
|
||||
STBRP_ASSERT(width % c->align == 0);
|
||||
|
||||
// if it can't possibly fit, bail immediately
|
||||
if(width > c->width || height > c->height) {
|
||||
fr.prev_link = NULL;
|
||||
fr.x = fr.y = 0;
|
||||
return fr;
|
||||
}
|
||||
|
||||
node = c->active_head;
|
||||
prev = &c->active_head;
|
||||
while(node->x + width <= c->width) {
|
||||
int y, waste;
|
||||
y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
|
||||
if(c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
|
||||
// bottom left
|
||||
if(y < best_y) {
|
||||
best_y = y;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// best-fit
|
||||
if(y + height <= c->height) {
|
||||
// can only use it if it first vertically
|
||||
if(y < best_y || (y == best_y && waste < best_waste)) {
|
||||
best_y = y;
|
||||
best_waste = waste;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
prev = &node->next;
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
best_x = (best == NULL) ? 0 : (*best)->x;
|
||||
|
||||
// if doing best-fit (BF), we also have to try aligning right edge to each node position
|
||||
//
|
||||
// e.g, if fitting
|
||||
//
|
||||
// ____________________
|
||||
// |____________________|
|
||||
//
|
||||
// into
|
||||
//
|
||||
// | |
|
||||
// | ____________|
|
||||
// |____________|
|
||||
//
|
||||
// then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
|
||||
//
|
||||
// This makes BF take about 2x the time
|
||||
|
||||
if(c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
|
||||
tail = c->active_head;
|
||||
node = c->active_head;
|
||||
prev = &c->active_head;
|
||||
// find first node that's admissible
|
||||
while(tail->x < width)
|
||||
tail = tail->next;
|
||||
while(tail) {
|
||||
int xpos = tail->x - width;
|
||||
int y, waste;
|
||||
STBRP_ASSERT(xpos >= 0);
|
||||
// find the left position that matches this
|
||||
while(node->next->x <= xpos) {
|
||||
prev = &node->next;
|
||||
node = node->next;
|
||||
}
|
||||
STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
|
||||
y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
|
||||
if(y + height <= c->height) {
|
||||
if(y <= best_y) {
|
||||
if(y < best_y || waste < best_waste || (waste == best_waste && xpos < best_x)) {
|
||||
best_x = xpos;
|
||||
STBRP_ASSERT(y <= best_y);
|
||||
best_y = y;
|
||||
best_waste = waste;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
tail = tail->next;
|
||||
}
|
||||
}
|
||||
|
||||
fr.prev_link = best;
|
||||
fr.x = best_x;
|
||||
fr.y = best_y;
|
||||
return fr;
|
||||
}
|
||||
|
||||
static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context * context, int width, int height)
|
||||
{
|
||||
// find best position according to heuristic
|
||||
stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
|
||||
stbrp_node * node, * cur;
|
||||
|
||||
// bail if:
|
||||
// 1. it failed
|
||||
// 2. the best node doesn't fit (we don't always check this)
|
||||
// 3. we're out of memory
|
||||
if(res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
|
||||
res.prev_link = NULL;
|
||||
return res;
|
||||
}
|
||||
|
||||
// on success, create new node
|
||||
node = context->free_head;
|
||||
node->x = (stbrp_coord) res.x;
|
||||
node->y = (stbrp_coord)(res.y + height);
|
||||
|
||||
context->free_head = node->next;
|
||||
|
||||
// insert the new node into the right starting point, and
|
||||
// let 'cur' point to the remaining nodes needing to be
|
||||
// stiched back in
|
||||
|
||||
cur = *res.prev_link;
|
||||
if(cur->x < res.x) {
|
||||
// preserve the existing one, so start testing with the next one
|
||||
stbrp_node * next = cur->next;
|
||||
cur->next = node;
|
||||
cur = next;
|
||||
}
|
||||
else {
|
||||
*res.prev_link = node;
|
||||
}
|
||||
|
||||
// from here, traverse cur and free the nodes, until we get to one
|
||||
// that shouldn't be freed
|
||||
while(cur->next && cur->next->x <= res.x + width) {
|
||||
stbrp_node * next = cur->next;
|
||||
// move the current node to the free list
|
||||
cur->next = context->free_head;
|
||||
context->free_head = cur;
|
||||
cur = next;
|
||||
}
|
||||
|
||||
// stitch the list back in
|
||||
node->next = cur;
|
||||
|
||||
if(cur->x < res.x + width)
|
||||
cur->x = (stbrp_coord)(res.x + width);
|
||||
|
||||
#ifdef _DEBUG
|
||||
cur = context->active_head;
|
||||
while(cur->x < context->width) {
|
||||
STBRP_ASSERT(cur->x < cur->next->x);
|
||||
cur = cur->next;
|
||||
}
|
||||
STBRP_ASSERT(cur->next == NULL);
|
||||
|
||||
{
|
||||
int count = 0;
|
||||
cur = context->active_head;
|
||||
while(cur) {
|
||||
cur = cur->next;
|
||||
++count;
|
||||
}
|
||||
cur = context->free_head;
|
||||
while(cur) {
|
||||
cur = cur->next;
|
||||
++count;
|
||||
}
|
||||
STBRP_ASSERT(count == context->num_nodes + 2);
|
||||
}
|
||||
#endif
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int STBRP__CDECL rect_height_compare(const void * a, const void * b)
|
||||
{
|
||||
const stbrp_rect * p = (const stbrp_rect *) a;
|
||||
const stbrp_rect * q = (const stbrp_rect *) b;
|
||||
if(p->h > q->h)
|
||||
return -1;
|
||||
if(p->h < q->h)
|
||||
return 1;
|
||||
return (p->w > q->w) ? -1 : (p->w < q->w);
|
||||
}
|
||||
|
||||
static int STBRP__CDECL rect_original_order(const void * a, const void * b)
|
||||
{
|
||||
const stbrp_rect * p = (const stbrp_rect *) a;
|
||||
const stbrp_rect * q = (const stbrp_rect *) b;
|
||||
return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
|
||||
}
|
||||
|
||||
STBRP_DEF int stbrp_pack_rects(stbrp_context * context, stbrp_rect * rects, int num_rects)
|
||||
{
|
||||
int i, all_rects_packed = 1;
|
||||
|
||||
// we use the 'was_packed' field internally to allow sorting/unsorting
|
||||
for(i = 0; i < num_rects; ++i) {
|
||||
rects[i].was_packed = i;
|
||||
}
|
||||
|
||||
// sort according to heuristic
|
||||
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
|
||||
|
||||
for(i = 0; i < num_rects; ++i) {
|
||||
if(rects[i].w == 0 || rects[i].h == 0) {
|
||||
rects[i].x = rects[i].y = 0; // empty rect needs no space
|
||||
}
|
||||
else {
|
||||
stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
|
||||
if(fr.prev_link) {
|
||||
rects[i].x = (stbrp_coord) fr.x;
|
||||
rects[i].y = (stbrp_coord) fr.y;
|
||||
}
|
||||
else {
|
||||
rects[i].x = rects[i].y = STBRP__MAXVAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// unsort
|
||||
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
|
||||
|
||||
// set was_packed flags and all_rects_packed status
|
||||
for(i = 0; i < num_rects; ++i) {
|
||||
rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
|
||||
if(!rects[i].was_packed)
|
||||
all_rects_packed = 0;
|
||||
}
|
||||
|
||||
// return the all_rects_packed status
|
||||
return all_rects_packed;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
/*
|
||||
------------------------------------------------------------------------------
|
||||
This software is available under 2 licenses -- choose whichever you prefer.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE A - MIT License
|
||||
Copyright (c) 2017 Sean Barrett
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE B - Public Domain (www.unlicense.org)
|
||||
This is free and unencumbered software released into the public domain.
|
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
||||
software, either in source code form or as a compiled binary, for any purpose,
|
||||
commercial or non-commercial, and by any means.
|
||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
||||
software dedicate any and all copyright interest in the software to the public
|
||||
domain. We make this dedication for the benefit of the public at large and to
|
||||
the detriment of our heirs and successors. We intend this dedication to be an
|
||||
overt act of relinquishment in perpetuity of all present and future rights to
|
||||
this software under copyright law.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
*/
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user