What LVGL version are you using?
8.3.11
Description
I need to use the screenshot function and store the image in SD so that it can be accessed on devices such as PC.
This is the relevant configuration in my ‘lv_conf.h’
#define LV_COLOR_DEPTH 16
#define LV_USE_BMP 1
#define LV_USE_SJPG 1
#define LV_USE_SNAPSHOT 1
/*API for open, read, etc*/
#define LV_USE_FS_POSIX 0
#if LV_USE_FS_POSIX
#define LV_FS_POSIX_LETTER 'P' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
#define LV_FS_POSIX_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/
#define LV_FS_POSIX_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
#endif
First, I tried to use ‘lv_snapshot’ to get the image stored in bmp format.
I used ‘LV_IMG_CF_TRUE_COLOR’ and ‘biBitCount=16’. To be honest, it works well, at least it is displayed normally on the MCU. But when I copied the image to the computer, it had color distortion. I don’t know if it is related to the color depth of 16.
lv_img_dsc_t imgdsc;
lv_res_t res = lv_snapshot_take_to_buf(lv_scr_act(), LV_IMG_CF_TRUE_COLOR, &imgdsc, &buffer, buffer_size);
if (res == LV_RES_INV)
{
rt_kprintf("lv_snapshot_take_to_buf failed\n");
return false;
}
lv_img_dsc_t *imgFinal = &imgdsc;
if (imgFinal)
{
// data_pre_processing(imgFinal);
success = save_as_bmp_file(imgFinal->data, imgFinal->header.w, imgFinal->header.h, 16, fileName);
}
filename:“/sd/screenshot/pic.bmp”
bool save_as_bmp_file(const uint8_t * image, uint32_t w, uint32_t h, uint32_t bpp, char *filename)
{
BITMAPFILEHEADER tBmpFileHead;
BITMAPINFOHEADER tBmpInfoHead;
uint32_t dwSize;
const uint8_t *pPos = 0;
uint32_t bw;
// lv_fs_file_t f;
memset(&tBmpFileHead, 0, sizeof(BITMAPFILEHEADER));
memset(&tBmpInfoHead, 0, sizeof(BITMAPINFOHEADER));
int fd = open(filename, O_RDWR | O_CREAT | O_TRUNC);
if (fd <= 0)
{
rt_kprintf("\nopen file failed : %s\n", filename);
return false;
}
tBmpFileHead.bfType = 0x4d42;
tBmpFileHead.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + w * h * (bpp / 8);
tBmpFileHead.bfReserved1 = 0;
tBmpFileHead.bfReserved2 = 0;
tBmpFileHead.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
tBmpInfoHead.biSize = sizeof(BITMAPINFOHEADER);
tBmpInfoHead.biWidth = w;
tBmpInfoHead.biHeight = h;
tBmpInfoHead.biPlanes = 1;
tBmpInfoHead.biBitCount = bpp;
tBmpInfoHead.biCompression = 0;
tBmpInfoHead.biSizeImage = 1;
tBmpInfoHead.biXPelsPerMeter = 0;
tBmpInfoHead.biYPelsPerMeter = 0;
tBmpInfoHead.biClrUsed = 0;
tBmpInfoHead.biClrImportant = 0;
bw = write(fd, &tBmpFileHead, sizeof(tBmpFileHead));
if (bw != sizeof(tBmpFileHead)) {
rt_kprintf("Error writing BMP File Header");
close(fd);
return false;
}
bw = write(fd, &tBmpInfoHead, sizeof(tBmpInfoHead));
if (bw != sizeof(tBmpInfoHead)) {
rt_kprintf("Error writing BMP Info Header");
close(fd);
return false;
}
dwSize = w * bpp / 8;
pPos = image + (h - 1) * dwSize;
while (pPos >= image)
{
bw = write(fd, pPos, dwSize);
if (bw != dwSize) {
rt_kprintf("Error writing image data");
close(fd);
return false;
}
pPos -= dwSize;
}
close(fd);
return true;
}
I have previously set the drive letter ‘P’ in ‘lv_conf’ and used lv_bmp to load the bmp image, so it is displayed completely normally on the device.
lv_obj_t *img = lv_img_create(lv_scr_act());
lv_obj_center(img);
lv_img_set_src(img,"P:/sd/screenshot/pic.bmp");
But I copied it from the device’s SD card to the computer and read it, and it works like this(Since I can’t upload bmp files, this is a computer screenshot of bmp，Actually looking at the properties, it is a 16-bit color depth image):
If I change the parameters of generating bmp images to ‘LV_IMG_CF_TRUE_COLOR_ALPHA’ and set ‘bpp’ to 24, the image can be displayed normally on the computer（It is a 24-bit color depth image.）:
but lv_bmp ‘decoder_open’ cannot be used on the device, and it cannot be displayed correctly even if I force change the code of lv_bmp.c.
For example, I delete this judgment : “LV_COLOR_DEPTH == 16 but bpp is 24 (should be 16)”
Later, I tried to save the screenshot as jpg format…
lv_img_dsc_t *imgFinal = &imgdsc;
if (imgFinal)
{
jpg_data_process(imgFinal,16);
//jpg
int r = tje_encode_to_file(fileName,imgFinal->header.w, imgFinal->header.h,3,imgFinal->data);
}
static void jpg_data_process(lv_img_dsc_t * snapshot, uint16_t bpp) {
if(bpp == 16)
{
uint16_t rgb565_data = 0;
uint32_t count = 0;
for(int w = 0; w < snapshot->header.w; w++)
{
for(int h = 0; h < snapshot->header.h; h++)
{
rgb565_data = (uint16_t)((*(uint8_t *)(snapshot->data + count + 1) << 8) | *(uint8_t *)(snapshot->data + count));
*(uint8_t *)(snapshot->data + count) = (((rgb565_data) >> 11) << 3);
*(uint8_t *)(snapshot->data + count + 1) = (((rgb565_data) >> 5 ) << 2);
*(uint8_t *)(snapshot->data + count + 2) = (((rgb565_data) >> 0 ) << 3);
count += 3;
}
}
}
}
‘tje_encode_to_file’,fileName is ‘P:/sd/screenshot/pic.jpg’
I used ‘TinyJPG’ to write the screenshot data to a file, which is very convenient and effective. There is no problem reading the jpg screenshot on the computer, but I still cannot use lv_sjpg to parse and load it on the device.
Jpg images are smaller in size and their display effect on a computer (its attribute is still 24-bit color depth), I can’t add more pictures, you can refer to the second picture above, that is the correct result.
I turned on ‘LV_USE_SJPG’ so I processed the jpg like a bmp file in my code but it wouldn’t display anything and after debugging I found that it was returning wrong results in ‘static lv_res_t decoder_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)’ which is in ‘lv_sjpg.c’.
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;
}
}
JRESULT rc = jd_prepare(&jd_tmp, input_func, workb_temp, (size_t)TJPGD_WORKBUFF_SIZE, &io_source_temp);
it’s returned ‘JDR_INP, /* 2: Device error or wrong termination of input stream */’ not JDR_OK
But I don’t understand where the problem is or how to solve it.