add: lvgl添加jpg和sjpg支持,前者内存消耗大

bsp/win32/port/luat_base_win32.c

@@ -9,6 +9,7 @@
 void luat_lv_fs_init(void);
 void lv_bmp_init(void);
 void lv_png_init(void);
+void lv_split_jpeg_init(void);
 #endif
 
 LUAMOD_API int luaopen_win32( lua_State *L );
@@ -122,6 +123,7 @@ int luat_fs_init(void) {
 	luat_lv_fs_init();
 	lv_bmp_init();
 	lv_png_init();
+	lv_split_jpeg_init();
 	#endif
 	return 0;
 }

bsp/win32/test/lvgl_demo/sjpg/main.lua

@@ -0,0 +1,21 @@
+local sys = require ("sys")
+
+
+sys.taskInit(function()
+    sys.wait(500)
+    lvgl.init()
+
+    local img1 = lvgl.img_create(lvgl.scr_act())
+    local img2 = lvgl.img_create(lvgl.scr_act())
+
+    -- jpg from file
+    lvgl.img_set_src(img1, "/wallpaper.jpg")
+    lvgl.img_set_src(img2, "/wallpaper.sjpg")
+
+    lvgl.obj_set_x(img2, 100)
+    lvgl.obj_set_y(img2, 100)
+
+end)
+
+
+sys.run()

components/lvgl/exts/lv_sjpg/lv_sjpg.c

@@ -0,0 +1,912 @@
+/**
+ * @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 "tjpgd.h"
+#include "lv_sjpg.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef LV_LVGL_H_INCLUDE_SIMPLE
+#include <lvgl.h>
+#else
+#include <lvgl/lvgl.h>
+#endif
+
+/*********************
+ *      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
+ **********************/
+
+/**********************
+ *  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 unsigned int input_func ( JDEC* jd, uint8_t* buff, unsigned int ndata );
+static int is_jpg( const uint8_t *raw_data );
+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 )
+{
+  /*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) {
+      uint8_t *raw_sjpeg_data = (uint8_t *)((lv_img_dsc_t * )src)->data;
+
+      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 ) == 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;
+
+        JDEC jd_tmp;
+
+        JRESULT rc = jd_prepare( &jd_tmp, input_func, workb_temp, (unsigned int)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;
+
+    }
+  }
+ #if LV_USE_FILESYSTEM
+  else if( src_type == LV_IMG_SRC_FILE ) {
+        const char * fn = src;
+        if(!strcmp(&fn[strlen(fn) - 5], ".sjpg")) {
+
+            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);
+                //fseek(file, 14, SEEK_SET); //seek to res info ... refer sjpeg format
+//                int rn = fread(buff, 1, 4, file);
+
+                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(&fn[strlen(fn) - 4], ".jpg")) {
+#if LV_USE_FILESYSTEM == 0
+        return LV_RES_INV;
+#else
+            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.file_seek_offset = 0;
+            io_source_temp.img_cache_buff = NULL;
+            memcpy(&(io_source_temp.lv_file), &file, sizeof(file));
+            JDEC jd_tmp;
+
+            JRESULT rc = jd_prepare( &jd_tmp, input_func, workb_temp, (unsigned int)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;
+            }
+#endif
+    }
+
+  }
+ #endif
+  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 unsigned int input_func ( JDEC* jd, uint8_t* buff, unsigned int ndata )
+{
+    io_source_t *io = jd->device;
+
+    if(!io) return 0;
+
+    if(io->type == SJPEG_IO_SOURCE_C_ARRAY) {
+        if(buff) {
+            memcpy(buff, io->raw_sjpg_data, ndata);
+        }
+        io->raw_sjpg_data += ndata;
+        return ndata;
+    }
+ #if LV_USE_FILESYSTEM
+
+    else if(io->type == SJPEG_IO_SOURCE_DISK) {
+
+        //FILE *file = io->file;
+        lv_fs_file_t* lv_file_p = &(io->lv_file);
+
+        if( buff ) {
+           // int rn =  fread( buff, 1, ndata, file );
+           //return rn;
+            uint32_t rn = 0;
+            lv_fs_read(lv_file_p, buff, ndata, &rn);
+            return rn;
+        } else {
+            uint32_t pos;
+            lv_fs_tell(lv_file_p, &pos);
+            lv_fs_seek(lv_file_p, ndata + pos);
+            return ndata;
+        }
+    }
+#endif // LV_USE_FS_IF
+
+    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_res_t lv_ret = LV_RES_OK;
+
+    if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
+        uint8_t *data;
+        SJPEG* sjpeg = ( SJPEG* ) dsc->user_data;
+        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;
+        }
+
+        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;
+#if LV_USE_FILESYSTEM
+            sjpeg->io.lv_file.file_d = NULL;
+#endif
+            dsc->img_data = NULL;
+            return lv_ret;
+        }
+
+        else if( is_jpg( sjpeg->sjpeg_data ) == 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;
+
+            JDEC jd_tmp;
+            JRESULT rc = jd_prepare( &jd_tmp, input_func, workb_temp, (unsigned int)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;
+#if LV_USE_FILESYSTEM
+                sjpeg->io.lv_file.file_d = NULL;
+#endif
+                dsc->img_data = NULL;
+                return lv_ret;
+            } else {
+                lv_ret = LV_RES_INV;
+                goto end;
+            }
+
+            end:
+                lv_mem_free(workb_temp);
+
+            return lv_ret;
+
+        }
+
+    }
+
+#if  LV_USE_FILESYSTEM
+
+    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(&fn[strlen(fn) - 5], ".sjpg")) {
+
+            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;
+                }
+                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++ ) {
+                    uint32_t rn;
+                    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;
+                memcpy(&(sjpeg->io.lv_file), &lv_file, sizeof(lv_file));
+                dsc->img_data = NULL;
+                return LV_RES_OK;
+            }
+        }
+         else if( !strcmp(&fn[strlen(fn) - 4], ".jpg" ) ) {
+
+            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;
+            }
+
+            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.file_seek_offset = 0;
+            io_source_temp.img_cache_buff = NULL;
+            memcpy(&(io_source_temp.lv_file), &lv_file, sizeof(lv_file));
+
+            JDEC jd_tmp;
+
+            JRESULT rc = jd_prepare( &jd_tmp, input_func, workb_temp, (unsigned int)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;
+                memcpy(&(sjpeg->io.lv_file), &lv_file, sizeof(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;
+            }
+        }
+    }
+#endif // LV_USE_FILESYSTEM
+
+    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 )
+{
+
+    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 ];
+            rc = jd_prepare( sjpeg->tjpeg_jd, input_func, sjpeg->workb, (unsigned int)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;
+        }
+
+        //memcpy( buf, (uint8_t *)sjpeg->frame_cache + (x * 3) + ( y % sjpeg->sjpeg_single_frame_height ) * sjpeg->sjpeg_x_res*3/*2*/ , len*3/*2*/ );
+
+        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);
+#ifdef LV_BIG_ENDIAN_SYSTEM
+            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;
+    }
+
+#if LV_USE_FILESYSTEM
+
+    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.file_seek_offset = (int)(sjpeg->frame_base_offset [ sjpeg_req_frame_index ]);
+            //fseek(sjpeg->io.file,  sjpeg->io.file_seek_offset , SEEK_SET);
+            lv_fs_seek( &(sjpeg->io.lv_file), sjpeg->io.file_seek_offset );
+            rc = jd_prepare( sjpeg->tjpeg_jd, input_func, sjpeg->workb, (unsigned int)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;
+        }
+
+        //memcpy( buf, (uint8_t *)sjpeg->frame_cache + (x * 2) + ( y % sjpeg->sjpeg_single_frame_height ) * sjpeg->sjpeg_x_res*2 , len*2 );
+        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);
+#ifdef LV_BIG_ENDIAN_SYSTEM
+            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;
+    }
+#endif // LV_USE_FS_IF
+
+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 )
+{
+  /*Free all allocated data*/
+    SJPEG* sjpeg = ( SJPEG* ) dsc->user_data;
+    if(!sjpeg) return;
+
+    switch(dsc->src_type) {
+
+        case LV_IMG_SRC_FILE:
+#if LV_USE_FILESYSTEM
+            if(sjpeg->io.lv_file.file_d) {
+                lv_fs_close(&(sjpeg->io.lv_file));
+            }
+#endif
+            lv_sjpg_free(sjpeg);
+            break;
+
+        case LV_IMG_SRC_VARIABLE:
+            lv_sjpg_free(sjpeg);
+            break;
+
+        default:
+            ;
+    }
+}
+
+
+static int is_jpg( const uint8_t *raw_data )
+{
+    const uint8_t jpg_signature[] = {0xFF, 0xD8, 0xFF,  0xE0,  0x00,  0x10, 0x4A,  0x46, 0x49, 0x46};//ÿØÿà�JFIF
+    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 );
+}

components/lvgl/exts/lv_sjpg/lv_sjpg.h

@@ -0,0 +1,88 @@
+/**
+ * @file lv_sjpg.h
+ *
+ */
+
+#ifndef _LV_SJPEG_
+#define _LV_SJPEG_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include <stdio.h>
+#include "tjpgd.h"
+
+#define LV_LVGL_H_INCLUDE_SIMPLE
+
+#ifdef LV_LVGL_H_INCLUDE_SIMPLE
+#include <lvgl.h>
+#else
+#include <lvgl/lvgl.h>
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum io_source_type {
+    SJPEG_IO_SOURCE_C_ARRAY,
+    SJPEG_IO_SOURCE_DISK,
+};
+
+typedef struct {
+    enum io_source_type type;
+#if LV_USE_FILESYSTEM
+    lv_fs_file_t lv_file;
+#endif
+    uint8_t* img_cache_buff;
+    int img_cache_x_res;
+    int img_cache_y_res;
+    union {
+        uint8_t *raw_sjpg_data;
+        uint32_t file_seek_offset;
+    };
+} io_source_t;
+
+
+typedef struct {
+    uint8_t *sjpeg_data;
+    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;
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_split_jpeg_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LV_JPEG_WRAPPER */

components/lvgl/exts/lv_sjpg/tjpgd.c

@@ -0,0 +1,963 @@
+/*----------------------------------------------------------------------------/
+/ TJpgDec - Tiny JPEG Decompressor R0.01d                     (C)ChaN, 2020
+/-----------------------------------------------------------------------------/
+/ The TJpgDec is a generic JPEG decompressor module for tiny embedded systems.
+/ This is a free software that opened for education, research and commercial
+/  developments under license policy of following terms.
+/
+/  Copyright (C) 2020, ChaN, all right reserved.
+/
+/ * The TJpgDec module is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/-----------------------------------------------------------------------------/
+/ Oct 04, 2011 R0.01  First release.
+/ Feb 19, 2012 R0.01a Fixed decompression fails when scan starts with an escape seq.
+/ Sep 03, 2012 R0.01b Added JD_TBLCLIP option.
+/ Mar 16, 2019 R0.01c Supprted stdint.h.
+/ Jul 01, 2020 R0.01d Fixed wrong integer type usage.
+/----------------------------------------------------------------------------*/
+
+#include "tjpgd.h"
+
+
+/*-----------------------------------------------*/
+/* Zigzag-order to raster-order conversion table */
+/*-----------------------------------------------*/
+
+#define ZIG(n)	Zig[n]
+
+static const uint8_t Zig[64] = {	/* Zigzag-order to raster-order conversion table */
+	 0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
+	12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
+	35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
+	58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
+};
+
+
+
+/*-------------------------------------------------*/
+/* Input scale factor of Arai algorithm            */
+/* (scaled up 16 bits for fixed point operations)  */
+/*-------------------------------------------------*/
+
+#define IPSF(n)	Ipsf[n]
+
+static const uint16_t Ipsf[64] = {	/* See also aa_idct.png */
+	(uint16_t)(1.00000*8192), (uint16_t)(1.38704*8192), (uint16_t)(1.30656*8192), (uint16_t)(1.17588*8192), (uint16_t)(1.00000*8192), (uint16_t)(0.78570*8192), (uint16_t)(0.54120*8192), (uint16_t)(0.27590*8192),
+	(uint16_t)(1.38704*8192), (uint16_t)(1.92388*8192), (uint16_t)(1.81226*8192), (uint16_t)(1.63099*8192), (uint16_t)(1.38704*8192), (uint16_t)(1.08979*8192), (uint16_t)(0.75066*8192), (uint16_t)(0.38268*8192),
+	(uint16_t)(1.30656*8192), (uint16_t)(1.81226*8192), (uint16_t)(1.70711*8192), (uint16_t)(1.53636*8192), (uint16_t)(1.30656*8192), (uint16_t)(1.02656*8192), (uint16_t)(0.70711*8192), (uint16_t)(0.36048*8192),
+	(uint16_t)(1.17588*8192), (uint16_t)(1.63099*8192), (uint16_t)(1.53636*8192), (uint16_t)(1.38268*8192), (uint16_t)(1.17588*8192), (uint16_t)(0.92388*8192), (uint16_t)(0.63638*8192), (uint16_t)(0.32442*8192),
+	(uint16_t)(1.00000*8192), (uint16_t)(1.38704*8192), (uint16_t)(1.30656*8192), (uint16_t)(1.17588*8192), (uint16_t)(1.00000*8192), (uint16_t)(0.78570*8192), (uint16_t)(0.54120*8192), (uint16_t)(0.27590*8192),
+	(uint16_t)(0.78570*8192), (uint16_t)(1.08979*8192), (uint16_t)(1.02656*8192), (uint16_t)(0.92388*8192), (uint16_t)(0.78570*8192), (uint16_t)(0.61732*8192), (uint16_t)(0.42522*8192), (uint16_t)(0.21677*8192),
+	(uint16_t)(0.54120*8192), (uint16_t)(0.75066*8192), (uint16_t)(0.70711*8192), (uint16_t)(0.63638*8192), (uint16_t)(0.54120*8192), (uint16_t)(0.42522*8192), (uint16_t)(0.29290*8192), (uint16_t)(0.14932*8192),
+	(uint16_t)(0.27590*8192), (uint16_t)(0.38268*8192), (uint16_t)(0.36048*8192), (uint16_t)(0.32442*8192), (uint16_t)(0.27590*8192), (uint16_t)(0.21678*8192), (uint16_t)(0.14932*8192), (uint16_t)(0.07612*8192)
+};
+
+
+
+/*---------------------------------------------*/
+/* Conversion table for fast clipping process  */
+/*---------------------------------------------*/
+
+#if JD_TBLCLIP
+
+#define BYTECLIP(v) Clip8[(unsigned int)(v) & 0x3FF]
+
+static const uint8_t Clip8[1024] = {
+	/* 0..255 */
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+	32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+	64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+	96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+	128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+	160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+	192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+	224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+	/* 256..511 */
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+	/* -512..-257 */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	/* -256..-1 */
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+#else	/* JD_TBLCLIP */
+
+inline uint8_t BYTECLIP (
+	int val
+)
+{
+	if (val < 0) val = 0;
+	if (val > 255) val = 255;
+
+	return (uint8_t)val;
+}
+
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Allocate a memory block from memory pool                              */
+/*-----------------------------------------------------------------------*/
+
+static void* alloc_pool (	/* Pointer to allocated memory block (NULL:no memory available) */
+	JDEC* jd,				/* Pointer to the decompressor object */
+	unsigned int nd			/* Number of bytes to allocate */
+)
+{
+	char *rp = 0;
+
+
+	nd = (nd + 3) & ~3;			/* Align block size to the word boundary */
+
+	if (jd->sz_pool >= nd) {
+		jd->sz_pool -= nd;
+		rp = (char*)jd->pool;			/* Get start of available memory pool */
+		jd->pool = (void*)(rp + nd);	/* Allocate requierd bytes */
+	}
+
+	return (void*)rp;	/* Return allocated memory block (NULL:no memory to allocate) */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create de-quantization and prescaling tables with a DQT segment       */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT create_qt_tbl (	/* 0:OK, !0:Failed */
+	JDEC* jd,				/* Pointer to the decompressor object */
+	const uint8_t* data,	/* Pointer to the quantizer tables */
+	unsigned int ndata		/* Size of input data */
+)
+{
+	unsigned int i;
+	uint8_t d, z;
+	int32_t *pb;
+
+
+	while (ndata) {	/* Process all tables in the segment */
+		if (ndata < 65) return JDR_FMT1;	/* Err: table size is unaligned */
+		ndata -= 65;
+		d = *data++;							/* Get table property */
+		if (d & 0xF0) return JDR_FMT1;			/* Err: not 8-bit resolution */
+		i = d & 3;								/* Get table ID */
+		pb = alloc_pool(jd, 64 * sizeof (int32_t));/* Allocate a memory block for the table */
+		if (!pb) return JDR_MEM1;				/* Err: not enough memory */
+		jd->qttbl[i] = pb;						/* Register the table */
+		for (i = 0; i < 64; i++) {				/* Load the table */
+			z = ZIG(i);							/* Zigzag-order to raster-order conversion */
+			pb[z] = (int32_t)((uint32_t)*data++ * IPSF(z));	/* Apply scale factor of Arai algorithm to the de-quantizers */
+		}
+	}
+
+	return JDR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create huffman code tables with a DHT segment                         */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT create_huffman_tbl (	/* 0:OK, !0:Failed */
+	JDEC* jd,					/* Pointer to the decompressor object */
+	const uint8_t* data,		/* Pointer to the packed huffman tables */
+	unsigned int ndata			/* Size of input data */
+)
+{
+	unsigned int i, j, b, np, cls, num;
+	uint8_t d, *pb, *pd;
+	uint16_t hc, *ph;
+
+
+	while (ndata) {	/* Process all tables in the segment */
+		if (ndata < 17) return JDR_FMT1;	/* Err: wrong data size */
+		ndata -= 17;
+		d = *data++;						/* Get table number and class */
+		if (d & 0xEE) return JDR_FMT1;		/* Err: invalid class/number */
+		cls = d >> 4; num = d & 0x0F;		/* class = dc(0)/ac(1), table number = 0/1 */
+		pb = alloc_pool(jd, 16);			/* Allocate a memory block for the bit distribution table */
+		if (!pb) return JDR_MEM1;			/* Err: not enough memory */
+		jd->huffbits[num][cls] = pb;
+		for (np = i = 0; i < 16; i++) {		/* Load number of patterns for 1 to 16-bit code */
+			np += (pb[i] = *data++);		/* Get sum of code words for each code */
+		}
+		ph = alloc_pool(jd, (unsigned int)(np * sizeof (uint16_t)));/* Allocate a memory block for the code word table */
+		if (!ph) return JDR_MEM1;			/* Err: not enough memory */
+		jd->huffcode[num][cls] = ph;
+		hc = 0;
+		for (j = i = 0; i < 16; i++) {		/* Re-build huffman code word table */
+			b = pb[i];
+			while (b--) ph[j++] = hc++;
+			hc <<= 1;
+		}
+
+		if (ndata < np) return JDR_FMT1;	/* Err: wrong data size */
+		ndata -= np;
+		pd = alloc_pool(jd, np);			/* Allocate a memory block for the decoded data */
+		if (!pd) return JDR_MEM1;			/* Err: not enough memory */
+		jd->huffdata[num][cls] = pd;
+		for (i = 0; i < np; i++) {			/* Load decoded data corresponds to each code ward */
+			d = *data++;
+			if (!cls && d > 11) return JDR_FMT1;
+			*pd++ = d;
+		}
+	}
+
+	return JDR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Extract N bits from input stream                                      */
+/*-----------------------------------------------------------------------*/
+
+static int bitext (	/* >=0: extracted data, <0: error code */
+	JDEC* jd,			/* Pointer to the decompressor object */
+	unsigned int nbit	/* Number of bits to extract (1 to 11) */
+)
+{
+	uint8_t msk, s, *dp;
+	unsigned int dc, v, f;
+
+
+	msk = jd->dmsk; dc = jd->dctr; dp = jd->dptr;	/* Bit mask, number of data available, read ptr */
+	s = *dp; v = f = 0;
+
+	do {
+		if (!msk) {				/* Next byte? */
+			if (!dc) {			/* No input data is available, re-fill input buffer */
+				dp = jd->inbuf;	/* Top of input buffer */
+				dc = jd->infunc(jd, dp, JD_SZBUF);
+				if (!dc) return 0 - (int)JDR_INP;	/* Err: read error or wrong stream termination */
+			} else {
+				dp++;			/* Next data ptr */
+			}
+			dc--;				/* Decrement number of available bytes */
+			if (f) {			/* In flag sequence? */
+				f = 0;			/* Exit flag sequence */
+				if (*dp != 0) return 0 - (int)JDR_FMT1;	/* Err: unexpected flag is detected (may be collapted data) */
+				*dp = s = 0xFF;			/* The flag is a data 0xFF */
+			} else {
+				s = *dp;				/* Get next data byte */
+				if (s == 0xFF) {		/* Is start of flag sequence? */
+					f = 1; continue;	/* Enter flag sequence */
+				}
+			}
+			msk = 0x80;		/* Read from MSB */
+		}
+		v <<= 1;	/* Get a bit */
+		if (s & msk) v++;
+		msk >>= 1;
+		nbit--;
+	} while (nbit);
+
+	jd->dmsk = msk; jd->dctr = dc; jd->dptr = dp;
+
+	return (int)v;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Extract a huffman decoded data from input stream                      */
+/*-----------------------------------------------------------------------*/
+
+static int huffext (		/* >=0: decoded data, <0: error code */
+	JDEC* jd,				/* Pointer to the decompressor object */
+	const uint8_t* hbits,	/* Pointer to the bit distribution table */
+	const uint16_t* hcode,	/* Pointer to the code word table */
+	const uint8_t* hdata	/* Pointer to the data table */
+)
+{
+	uint8_t msk, s, *dp;
+	unsigned int dc, v, f, bl, nd;
+
+
+	msk = jd->dmsk; dc = jd->dctr; dp = jd->dptr;	/* Bit mask, number of data available, read ptr */
+	s = *dp; v = f = 0;
+	bl = 16;	/* Max code length */
+	do {
+		if (!msk) {		/* Next byte? */
+			if (!dc) {	/* No input data is available, re-fill input buffer */
+				dp = jd->inbuf;	/* Top of input buffer */
+				dc = jd->infunc(jd, dp, JD_SZBUF);
+				if (!dc) return 0 - (int)JDR_INP;	/* Err: read error or wrong stream termination */
+			} else {
+				dp++;	/* Next data ptr */
+			}
+			dc--;		/* Decrement number of available bytes */
+			if (f) {		/* In flag sequence? */
+				f = 0;		/* Exit flag sequence */
+				if (*dp != 0) return 0 - (int)JDR_FMT1;	/* Err: unexpected flag is detected (may be collapted data) */
+				*dp = s = 0xFF;			/* The flag is a data 0xFF */
+			} else {
+				s = *dp;				/* Get next data byte */
+				if (s == 0xFF) {		/* Is start of flag sequence? */
+					f = 1; continue;	/* Enter flag sequence, get trailing byte */
+				}
+			}
+			msk = 0x80;		/* Read from MSB */
+		}
+		v <<= 1;	/* Get a bit */
+		if (s & msk) v++;
+		msk >>= 1;
+
+		for (nd = *hbits++; nd; nd--) {	/* Search the code word in this bit length */
+			if (v == *hcode++) {		/* Matched? */
+				jd->dmsk = msk; jd->dctr = dc; jd->dptr = dp;
+				return *hdata;			/* Return the decoded data */
+			}
+			hdata++;
+		}
+		bl--;
+	} while (bl);
+
+	return 0 - (int)JDR_FMT1;	/* Err: code not found (may be collapted data) */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Apply Inverse-DCT in Arai Algorithm (see also aa_idct.png)            */
+/*-----------------------------------------------------------------------*/
+
+static void block_idct (
+	int32_t* src,	/* Input block data (de-quantized and pre-scaled for Arai Algorithm) */
+	uint8_t* dst	/* Pointer to the destination to store the block as byte array */
+)
+{
+	const int32_t M13 = (int32_t)(1.41421*4096), M2 = (int32_t)(1.08239*4096), M4 = (int32_t)(2.61313*4096), M5 = (int32_t)(1.84776*4096);
+	int32_t v0, v1, v2, v3, v4, v5, v6, v7;
+	int32_t t10, t11, t12, t13;
+	int i;
+
+	/* Process columns */
+	for (i = 0; i < 8; i++) {
+		v0 = src[8 * 0];	/* Get even elements */
+		v1 = src[8 * 2];
+		v2 = src[8 * 4];
+		v3 = src[8 * 6];
+
+		t10 = v0 + v2;		/* Process the even elements */
+		t12 = v0 - v2;
+		t11 = (v1 - v3) * M13 >> 12;
+		v3 += v1;
+		t11 -= v3;
+		v0 = t10 + v3;
+		v3 = t10 - v3;
+		v1 = t11 + t12;
+		v2 = t12 - t11;
+
+		v4 = src[8 * 7];	/* Get odd elements */
+		v5 = src[8 * 1];
+		v6 = src[8 * 5];
+		v7 = src[8 * 3];
+
+		t10 = v5 - v4;		/* Process the odd elements */
+		t11 = v5 + v4;
+		t12 = v6 - v7;
+		v7 += v6;
+		v5 = (t11 - v7) * M13 >> 12;
+		v7 += t11;
+		t13 = (t10 + t12) * M5 >> 12;
+		v4 = t13 - (t10 * M2 >> 12);
+		v6 = t13 - (t12 * M4 >> 12) - v7;
+		v5 -= v6;
+		v4 -= v5;
+
+		src[8 * 0] = v0 + v7;	/* Write-back transformed values */
+		src[8 * 7] = v0 - v7;
+		src[8 * 1] = v1 + v6;
+		src[8 * 6] = v1 - v6;
+		src[8 * 2] = v2 + v5;
+		src[8 * 5] = v2 - v5;
+		src[8 * 3] = v3 + v4;
+		src[8 * 4] = v3 - v4;
+
+		src++;	/* Next column */
+	}
+
+	/* Process rows */
+	src -= 8;
+	for (i = 0; i < 8; i++) {
+		v0 = src[0] + (128L << 8);	/* Get even elements (remove DC offset (-128) here) */
+		v1 = src[2];
+		v2 = src[4];
+		v3 = src[6];
+
+		t10 = v0 + v2;				/* Process the even elements */
+		t12 = v0 - v2;
+		t11 = (v1 - v3) * M13 >> 12;
+		v3 += v1;
+		t11 -= v3;
+		v0 = t10 + v3;
+		v3 = t10 - v3;
+		v1 = t11 + t12;
+		v2 = t12 - t11;
+
+		v4 = src[7];				/* Get odd elements */
+		v5 = src[1];
+		v6 = src[5];
+		v7 = src[3];
+
+		t10 = v5 - v4;				/* Process the odd elements */
+		t11 = v5 + v4;
+		t12 = v6 - v7;
+		v7 += v6;
+		v5 = (t11 - v7) * M13 >> 12;
+		v7 += t11;
+		t13 = (t10 + t12) * M5 >> 12;
+		v4 = t13 - (t10 * M2 >> 12);
+		v6 = t13 - (t12 * M4 >> 12) - v7;
+		v5 -= v6;
+		v4 -= v5;
+
+		dst[0] = BYTECLIP((v0 + v7) >> 8);	/* Descale the transformed values 8 bits and output */
+		dst[7] = BYTECLIP((v0 - v7) >> 8);
+		dst[1] = BYTECLIP((v1 + v6) >> 8);
+		dst[6] = BYTECLIP((v1 - v6) >> 8);
+		dst[2] = BYTECLIP((v2 + v5) >> 8);
+		dst[5] = BYTECLIP((v2 - v5) >> 8);
+		dst[3] = BYTECLIP((v3 + v4) >> 8);
+		dst[4] = BYTECLIP((v3 - v4) >> 8);
+		dst += 8;
+
+		src += 8;	/* Next row */
+	}
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Load all blocks in the MCU into working buffer                        */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT mcu_load (
+	JDEC* jd		/* Pointer to the decompressor object */
+)
+{
+	int32_t *tmp = (int32_t*)jd->workbuf;	/* Block working buffer for de-quantize and IDCT */
+	int b, d, e;
+	unsigned int blk, nby, nbc, i, z, id, cmp;
+	uint8_t *bp;
+	const uint8_t *hb, *hd;
+	const uint16_t *hc;
+	const int32_t *dqf;
+
+
+	nby = jd->msx * jd->msy;	/* Number of Y blocks (1, 2 or 4) */
+	nbc = 2;					/* Number of C blocks (2) */
+	bp = jd->mcubuf;			/* Pointer to the first block */
+
+	for (blk = 0; blk < nby + nbc; blk++) {
+		cmp = (blk < nby) ? 0 : blk - nby + 1;	/* Component number 0:Y, 1:Cb, 2:Cr */
+		id = cmp ? 1 : 0;						/* Huffman table ID of the component */
+
+		/* Extract a DC element from input stream */
+		hb = jd->huffbits[id][0];				/* Huffman table for the DC element */
+		hc = jd->huffcode[id][0];
+		hd = jd->huffdata[id][0];
+		b = huffext(jd, hb, hc, hd);			/* Extract a huffman coded data (bit length) */
+		if (b < 0) return 0 - b;				/* Err: invalid code or input */
+		d = jd->dcv[cmp];						/* DC value of previous block */
+		if (b) {								/* If there is any difference from previous block */
+			e = bitext(jd, b);					/* Extract data bits */
+			if (e < 0) return 0 - e;			/* Err: input */
+			b = 1 << (b - 1);					/* MSB position */
+			if (!(e & b)) e -= (b << 1) - 1;	/* Restore sign if needed */
+			d += e;								/* Get current value */
+			jd->dcv[cmp] = (int16_t)d;			/* Save current DC value for next block */
+		}
+		dqf = jd->qttbl[jd->qtid[cmp]];			/* De-quantizer table ID for this component */
+		tmp[0] = d * dqf[0] >> 8;				/* De-quantize, apply scale factor of Arai algorithm and descale 8 bits */
+
+		/* Extract following 63 AC elements from input stream */
+		for (i = 1; i < 64; tmp[i++] = 0) ;		/* Clear rest of elements */
+		hb = jd->huffbits[id][1];				/* Huffman table for the AC elements */
+		hc = jd->huffcode[id][1];
+		hd = jd->huffdata[id][1];
+		i = 1;					/* Top of the AC elements */
+		do {
+			b = huffext(jd, hb, hc, hd);		/* Extract a huffman coded value (zero runs and bit length) */
+			if (b == 0) break;					/* EOB? */
+			if (b < 0) return 0 - b;			/* Err: invalid code or input error */
+			z = (unsigned int)b >> 4;			/* Number of leading zero elements */
+			if (z) {
+				i += z;							/* Skip zero elements */
+				if (i >= 64) return JDR_FMT1;	/* Too long zero run */
+			}
+			if (b &= 0x0F) {					/* Bit length */
+				d = bitext(jd, b);				/* Extract data bits */
+				if (d < 0) return 0 - d;		/* Err: input device */
+				b = 1 << (b - 1);				/* MSB position */
+				if (!(d & b)) d -= (b << 1) - 1;/* Restore negative value if needed */
+				z = ZIG(i);						/* Zigzag-order to raster-order converted index */
+				tmp[z] = d * dqf[z] >> 8;		/* De-quantize, apply scale factor of Arai algorithm and descale 8 bits */
+			}
+		} while (++i < 64);		/* Next AC element */
+
+		if (JD_USE_SCALE && jd->scale == 3) {
+			*bp = (uint8_t)((*tmp / 256) + 128);	/* If scale ratio is 1/8, IDCT can be ommited and only DC element is used */
+		} else {
+			block_idct(tmp, bp);		/* Apply IDCT and store the block to the MCU buffer */
+		}
+
+		bp += 64;				/* Next block */
+	}
+
+	return JDR_OK;	/* All blocks have been loaded successfully */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Output an MCU: Convert YCrCb to RGB and output it in RGB form         */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT mcu_output (
+	JDEC* jd,			/* Pointer to the decompressor object */
+	int (*outfunc)(JDEC*, void*, JRECT*),	/* RGB output function */
+	unsigned int x,		/* MCU position in the image (left of the MCU) */
+	unsigned int y		/* MCU position in the image (top of the MCU) */
+)
+{
+	const int CVACC = (sizeof (int) > 2) ? 1024 : 128;	/* Adaptive accuracy for both 16-/32-bit systems */
+	unsigned int ix, iy, mx, my, rx, ry;
+	int yy, cb, cr;
+	uint8_t *py, *pc, *rgb24;
+	JRECT rect;
+
+
+	mx = jd->msx * 8; my = jd->msy * 8;					/* MCU size (pixel) */
+	rx = (x + mx <= jd->width) ? mx : jd->width - x;	/* Output rectangular size (it may be clipped at right/bottom end) */
+	ry = (y + my <= jd->height) ? my : jd->height - y;
+	if (JD_USE_SCALE) {
+		rx >>= jd->scale; ry >>= jd->scale;
+		if (!rx || !ry) return JDR_OK;					/* Skip this MCU if all pixel is to be rounded off */
+		x >>= jd->scale; y >>= jd->scale;
+	}
+	rect.left = x; rect.right = x + rx - 1;				/* Rectangular area in the frame buffer */
+	rect.top = y; rect.bottom = y + ry - 1;
+
+
+	if (!JD_USE_SCALE || jd->scale != 3) {	/* Not for 1/8 scaling */
+
+		/* Build an RGB MCU from discrete comopnents */
+		rgb24 = (uint8_t*)jd->workbuf;
+		for (iy = 0; iy < my; iy++) {
+			pc = jd->mcubuf;
+			py = pc + iy * 8;
+			if (my == 16) {		/* Double block height? */
+				pc += 64 * 4 + (iy >> 1) * 8;
+				if (iy >= 8) py += 64;
+			} else {			/* Single block height */
+				pc += mx * 8 + iy * 8;
+			}
+			for (ix = 0; ix < mx; ix++) {
+				cb = pc[0] - 128; 	/* Get Cb/Cr component and restore right level */
+				cr = pc[64] - 128;
+				if (mx == 16) {					/* Double block width? */
+					if (ix == 8) py += 64 - 8;	/* Jump to next block if double block heigt */
+					pc += ix & 1;				/* Increase chroma pointer every two pixels */
+				} else {						/* Single block width */
+					pc++;						/* Increase chroma pointer every pixel */
+				}
+				yy = *py++;			/* Get Y component */
+
+				/* Convert YCbCr to RGB */
+				*rgb24++ = /* R */ BYTECLIP(yy + ((int)(1.402 * CVACC) * cr) / CVACC);
+				*rgb24++ = /* G */ BYTECLIP(yy - ((int)(0.344 * CVACC) * cb + (int)(0.714 * CVACC) * cr) / CVACC);
+				*rgb24++ = /* B */ BYTECLIP(yy + ((int)(1.772 * CVACC) * cb) / CVACC);
+			}
+		}
+
+		/* Descale the MCU rectangular if needed */
+		if (JD_USE_SCALE && jd->scale) {
+			unsigned int x, y, r, g, b, s, w, a;
+			uint8_t *op;
+
+			/* Get averaged RGB value of each square correcponds to a pixel */
+			s = jd->scale * 2;	/* Bumber of shifts for averaging */
+			w = 1 << jd->scale;	/* Width of square */
+			a = (mx - w) * 3;	/* Bytes to skip for next line in the square */
+			op = (uint8_t*)jd->workbuf;
+			for (iy = 0; iy < my; iy += w) {
+				for (ix = 0; ix < mx; ix += w) {
+					rgb24 = (uint8_t*)jd->workbuf + (iy * mx + ix) * 3;
+					r = g = b = 0;
+					for (y = 0; y < w; y++) {	/* Accumulate RGB value in the square */
+						for (x = 0; x < w; x++) {
+							r += *rgb24++;
+							g += *rgb24++;
+							b += *rgb24++;
+						}
+						rgb24 += a;
+					}							/* Put the averaged RGB value as a pixel */
+					*op++ = (uint8_t)(r >> s);
+					*op++ = (uint8_t)(g >> s);
+					*op++ = (uint8_t)(b >> s);
+				}
+			}
+		}
+
+	} else {	/* For only 1/8 scaling (left-top pixel in each block are the DC value of the block) */
+
+		/* Build a 1/8 descaled RGB MCU from discrete comopnents */
+		rgb24 = (uint8_t*)jd->workbuf;
+		pc = jd->mcubuf + mx * my;
+		cb = pc[0] - 128;		/* Get Cb/Cr component and restore right level */
+		cr = pc[64] - 128;
+		for (iy = 0; iy < my; iy += 8) {
+			py = jd->mcubuf;
+			if (iy == 8) py += 64 * 2;
+			for (ix = 0; ix < mx; ix += 8) {
+				yy = *py;	/* Get Y component */
+				py += 64;
+
+				/* Convert YCbCr to RGB */
+				*rgb24++ = /* R */ BYTECLIP(yy + ((int)(1.402 * CVACC) * cr / CVACC));
+				*rgb24++ = /* G */ BYTECLIP(yy - ((int)(0.344 * CVACC) * cb + (int)(0.714 * CVACC) * cr) / CVACC);
+				*rgb24++ = /* B */ BYTECLIP(yy + ((int)(1.772 * CVACC) * cb / CVACC));
+			}
+		}
+	}
+
+	/* Squeeze up pixel table if a part of MCU is to be truncated */
+	mx >>= jd->scale;
+	if (rx < mx) {
+		uint8_t *s, *d;
+		unsigned int x, y;
+
+		s = d = (uint8_t*)jd->workbuf;
+		for (y = 0; y < ry; y++) {
+			for (x = 0; x < rx; x++) {	/* Copy effective pixels */
+				*d++ = *s++;
+				*d++ = *s++;
+				*d++ = *s++;
+			}
+			s += (mx - rx) * 3;	/* Skip truncated pixels */
+		}
+	}
+
+	/* Convert RGB888 to RGB565 if needed */
+	if (JD_FORMAT == 1) {
+		uint8_t *s = (uint8_t*)jd->workbuf;
+		uint16_t w, *d = (uint16_t*)s;
+		unsigned int n = rx * ry;
+
+		do {
+			w = (*s++ & 0xF8) << 8;		/* RRRRR----------- */
+			w |= (*s++ & 0xFC) << 3;	/* -----GGGGGG----- */
+			w |= *s++ >> 3;				/* -----------BBBBB */
+			*d++ = w;
+		} while (--n);
+	}
+
+	/* Output the RGB rectangular */
+	return outfunc(jd, jd->workbuf, &rect) ? JDR_OK : JDR_INTR;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Process restart interval                                              */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT restart (
+	JDEC* jd,		/* Pointer to the decompressor object */
+	uint16_t rstn	/* Expected restert sequense number */
+)
+{
+	unsigned int i, dc;
+	uint16_t d;
+	uint8_t *dp;
+
+
+	/* Discard padding bits and get two bytes from the input stream */
+	dp = jd->dptr; dc = jd->dctr;
+	d = 0;
+	for (i = 0; i < 2; i++) {
+		if (!dc) {	/* No input data is available, re-fill input buffer */
+			dp = jd->inbuf;
+			dc = jd->infunc(jd, dp, JD_SZBUF);
+			if (!dc) return JDR_INP;
+		} else {
+			dp++;
+		}
+		dc--;
+		d = (d << 8) | *dp;	/* Get a byte */
+	}
+	jd->dptr = dp; jd->dctr = dc; jd->dmsk = 0;
+
+	/* Check the marker */
+	if ((d & 0xFFD8) != 0xFFD0 || (d & 7) != (rstn & 7)) {
+		return JDR_FMT1;	/* Err: expected RSTn marker is not detected (may be collapted data) */
+	}
+
+	/* Reset DC offset */
+	jd->dcv[2] = jd->dcv[1] = jd->dcv[0] = 0;
+
+	return JDR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Analyze the JPEG image and Initialize decompressor object             */
+/*-----------------------------------------------------------------------*/
+
+#define	LDB_WORD(ptr)		(uint16_t)(((uint16_t)*((uint8_t*)(ptr))<<8)|(uint16_t)*(uint8_t*)((ptr)+1))
+
+
+JRESULT jd_prepare (
+	JDEC* jd,				/* Blank decompressor object */
+	unsigned int (*infunc)(JDEC*, uint8_t*, unsigned int),	/* JPEG strem input function */
+	void* pool,				/* Working buffer for the decompression session */
+	unsigned int sz_pool,	/* Size of working buffer */
+	void* dev				/* I/O device identifier for the session */
+)
+{
+	uint8_t *seg, b;
+	uint16_t marker;
+	uint32_t ofs;
+	unsigned int n, i, j, len;
+	JRESULT rc;
+
+
+	if (!pool) return JDR_PAR;
+
+	jd->pool = pool;		/* Work memroy */
+	jd->sz_pool = sz_pool;	/* Size of given work memory */
+	jd->infunc = infunc;	/* Stream input function */
+	jd->device = dev;		/* I/O device identifier */
+	jd->nrst = 0;			/* No restart interval (default) */
+
+	for (i = 0; i < 2; i++) {	/* Nulls pointers */
+		for (j = 0; j < 2; j++) {
+			jd->huffbits[i][j] = 0;
+			jd->huffcode[i][j] = 0;
+			jd->huffdata[i][j] = 0;
+		}
+	}
+	for (i = 0; i < 4; jd->qttbl[i++] = 0) ;
+
+	jd->inbuf = seg = alloc_pool(jd, JD_SZBUF);		/* Allocate stream input buffer */
+	if (!seg) return JDR_MEM1;
+
+	if (jd->infunc(jd, seg, 2) != 2) return JDR_INP;/* Check SOI marker */
+	if (LDB_WORD(seg) != 0xFFD8) return JDR_FMT1;	/* Err: SOI is not detected */
+	ofs = 2;
+
+	for (;;) {
+		/* Get a JPEG marker */
+		if (jd->infunc(jd, seg, 4) != 4) return JDR_INP;
+		marker = LDB_WORD(seg);		/* Marker */
+		len = LDB_WORD(seg + 2);	/* Length field */
+		if (len <= 2 || (marker >> 8) != 0xFF) return JDR_FMT1;
+		len -= 2;		/* Content size excluding length field */
+		ofs += 4 + len;	/* Number of bytes loaded */
+
+		switch (marker & 0xFF) {
+		case 0xC0:	/* SOF0 (baseline JPEG) */
+			/* Load segment data */
+			if (len > JD_SZBUF) return JDR_MEM2;
+			if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+			jd->width = LDB_WORD(seg+3);		/* Image width in unit of pixel */
+			jd->height = LDB_WORD(seg+1);		/* Image height in unit of pixel */
+			if (seg[5] != 3) return JDR_FMT3;	/* Err: Supports only Y/Cb/Cr format */
+
+			/* Check three image components */
+			for (i = 0; i < 3; i++) {
+				b = seg[7 + 3 * i];							/* Get sampling factor */
+				if (!i) {	/* Y component */
+					if (b != 0x11 && b != 0x22 && b != 0x21) {	/* Check sampling factor */
+						return JDR_FMT3;					/* Err: Supports only 4:4:4, 4:2:0 or 4:2:2 */
+					}
+					jd->msx = b >> 4; jd->msy = b & 15;		/* Size of MCU [blocks] */
+				} else {	/* Cb/Cr component */
+					if (b != 0x11) return JDR_FMT3;			/* Err: Sampling factor of Cr/Cb must be 1 */
+				}
+				b = seg[8 + 3 * i];							/* Get dequantizer table ID for this component */
+				if (b > 3) return JDR_FMT3;					/* Err: Invalid ID */
+				jd->qtid[i] = b;
+			}
+			break;
+
+		case 0xDD:	/* DRI */
+			/* Load segment data */
+			if (len > JD_SZBUF) return JDR_MEM2;
+			if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+			/* Get restart interval (MCUs) */
+			jd->nrst = LDB_WORD(seg);
+			break;
+
+		case 0xC4:	/* DHT */
+			/* Load segment data */
+			if (len > JD_SZBUF) return JDR_MEM2;
+			if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+			/* Create huffman tables */
+			rc = create_huffman_tbl(jd, seg, len);
+			if (rc) return rc;
+			break;
+
+		case 0xDB:	/* DQT */
+			/* Load segment data */
+			if (len > JD_SZBUF) return JDR_MEM2;
+			if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+			/* Create de-quantizer tables */
+			rc = create_qt_tbl(jd, seg, len);
+			if (rc) return rc;
+			break;
+
+		case 0xDA:	/* SOS */
+			/* Load segment data */
+			if (len > JD_SZBUF) return JDR_MEM2;
+			if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+			if (!jd->width || !jd->height) return JDR_FMT1;	/* Err: Invalid image size */
+
+			if (seg[0] != 3) return JDR_FMT3;				/* Err: Supports only three color components format */
+
+			/* Check if all tables corresponding to each components have been loaded */
+			for (i = 0; i < 3; i++) {
+				b = seg[2 + 2 * i];	/* Get huffman table ID */
+				if (b != 0x00 && b != 0x11)	return JDR_FMT3;	/* Err: Different table number for DC/AC element */
+				b = i ? 1 : 0;
+				if (!jd->huffbits[b][0] || !jd->huffbits[b][1]) {	/* Check dc/ac huffman table for this component */
+					return JDR_FMT1;					/* Err: Nnot loaded */
+				}
+				if (!jd->qttbl[jd->qtid[i]]) {			/* Check dequantizer table for this component */
+					return JDR_FMT1;					/* Err: Not loaded */
+				}
+			}
+
+			/* Allocate working buffer for MCU and RGB */
+			n = jd->msy * jd->msx;						/* Number of Y blocks in the MCU */
+			if (!n) return JDR_FMT1;					/* Err: SOF0 has not been loaded */
+			len = n * 64 * 2 + 64;						/* Allocate buffer for IDCT and RGB output */
+			if (len < 256) len = 256;					/* but at least 256 byte is required for IDCT */
+			jd->workbuf = alloc_pool(jd, len);			/* and it may occupy a part of following MCU working buffer for RGB output */
+			if (!jd->workbuf) return JDR_MEM1;			/* Err: not enough memory */
+			jd->mcubuf = (uint8_t*)alloc_pool(jd, (unsigned int)((n + 2) * 64));	/* Allocate MCU working buffer */
+			if (!jd->mcubuf) return JDR_MEM1;			/* Err: not enough memory */
+
+			/* Pre-load the JPEG data to extract it from the bit stream */
+			jd->dptr = seg; jd->dctr = 0; jd->dmsk = 0;	/* Prepare to read bit stream */
+			if (ofs %= JD_SZBUF) {						/* Align read offset to JD_SZBUF */
+				jd->dctr = jd->infunc(jd, seg + ofs, (unsigned int)(JD_SZBUF - ofs));
+				jd->dptr = seg + ofs - 1;
+			}
+
+			return JDR_OK;		/* Initialization succeeded. Ready to decompress the JPEG image. */
+
+		case 0xC1:	/* SOF1 */
+		case 0xC2:	/* SOF2 */
+		case 0xC3:	/* SOF3 */
+		case 0xC5:	/* SOF5 */
+		case 0xC6:	/* SOF6 */
+		case 0xC7:	/* SOF7 */
+		case 0xC9:	/* SOF9 */
+		case 0xCA:	/* SOF10 */
+		case 0xCB:	/* SOF11 */
+		case 0xCD:	/* SOF13 */
+		case 0xCE:	/* SOF14 */
+		case 0xCF:	/* SOF15 */
+		case 0xD9:	/* EOI */
+			return JDR_FMT3;	/* Unsuppoted JPEG standard (may be progressive JPEG) */
+
+		default:	/* Unknown segment (comment, exif or etc..) */
+			/* Skip segment data */
+			if (jd->infunc(jd, 0, len) != len) {	/* Null pointer specifies to skip bytes of stream */
+				return JDR_INP;
+			}
+		}
+	}
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Start to decompress the JPEG picture                                  */
+/*-----------------------------------------------------------------------*/
+
+JRESULT jd_decomp (
+	JDEC* jd,								/* Initialized decompression object */
+	int (*outfunc)(JDEC*, void*, JRECT*),	/* RGB output function */
+	uint8_t scale							/* Output de-scaling factor (0 to 3) */
+)
+{
+	unsigned int x, y, mx, my;
+	uint16_t rst, rsc;
+	JRESULT rc;
+
+
+	if (scale > (JD_USE_SCALE ? 3 : 0)) return JDR_PAR;
+	jd->scale = scale;
+
+	mx = jd->msx * 8; my = jd->msy * 8;			/* Size of the MCU (pixel) */
+
+	jd->dcv[2] = jd->dcv[1] = jd->dcv[0] = 0;	/* Initialize DC values */
+	rst = rsc = 0;
+
+	rc = JDR_OK;
+	for (y = 0; y < jd->height; y += my) {		/* Vertical loop of MCUs */
+		for (x = 0; x < jd->width; x += mx) {	/* Horizontal loop of MCUs */
+			if (jd->nrst && rst++ == jd->nrst) {	/* Process restart interval if enabled */
+				rc = restart(jd, rsc++);
+				if (rc != JDR_OK) return rc;
+				rst = 1;
+			}
+			rc = mcu_load(jd);					/* Load an MCU (decompress huffman coded stream and apply IDCT) */
+			if (rc != JDR_OK) return rc;
+			rc = mcu_output(jd, outfunc, x, y);	/* Output the MCU (color space conversion, scaling and output) */
+			if (rc != JDR_OK) return rc;
+		}
+	}
+
+	return rc;
+}
+
+
+

components/lvgl/exts/lv_sjpg/tjpgd.h

@@ -0,0 +1,88 @@
+/*----------------------------------------------------------------------------/
+/ TJpgDec - Tiny JPEG Decompressor include file               (C)ChaN, 2020
+/----------------------------------------------------------------------------*/
+#ifndef DEF_TJPGDEC
+#define DEF_TJPGDEC
+/*---------------------------------------------------------------------------*/
+/* System Configurations */
+
+#define	JD_SZBUF		512	/* Size of stream input buffer */
+#define JD_FORMAT		0	/* Output pixel format 0:RGB888 (3 BYTE/pix), 1:RGB565 (1 WORD/pix) */
+#define	JD_USE_SCALE	1	/* Use descaling feature for output */
+#define JD_TBLCLIP		1	/* Use table for saturation (might be a bit faster but increases 1K bytes of code size) */
+
+/*---------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(___WIN32)	/* Main development platform */
+typedef unsigned char	uint8_t;
+typedef unsigned short	uint16_t;
+typedef short			int16_t;
+typedef unsigned long	uint32_t;
+typedef long			int32_t;
+#else
+#include "stdint.h"
+#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 damaged data) */
+	JDR_FMT2,	/* 7: Right format but not supported */
+	JDR_FMT3	/* 8: Not supported JPEG standard */
+} JRESULT;
+
+
+
+/* Rectangular structure */
+typedef struct {
+	uint16_t left, right, top, bottom;
+} JRECT;
+
+
+
+/* Decompressor object structure */
+typedef struct JDEC JDEC;
+struct JDEC {
+	unsigned int 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 dmsk;				/* Current bit in the current read byte */
+	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 */
+	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] */
+	void* workbuf;				/* Working buffer for IDCT and RGB output */
+	uint8_t* mcubuf;			/* Working buffer for the MCU */
+	void* pool;					/* Pointer to available memory pool */
+	unsigned int sz_pool;		/* Size of momory pool (bytes available) */
+	unsigned int (*infunc)(JDEC*, uint8_t*, unsigned int);	/* 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, unsigned int (*infunc)(JDEC*,uint8_t*,unsigned int), void* pool, unsigned int sz_pool, void* dev);
+JRESULT jd_decomp (JDEC* jd, int (*outfunc)(JDEC*,void*,JRECT*), uint8_t scale);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _TJPGDEC */