/* * File : image_jpg.c * This file is part of RT-Thread GUI Engine * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Change Logs: * Date Author Notes * 2010-09-15 Bernard first version * 2012-01-24 onelife add TJpgDec (Tiny JPEG Decompressor) support */ #include #include #ifdef RTGUI_IMAGE_JPEG #include #include #include "jpeglib.h" #include #include #include #ifdef RTGUI_USING_DFS_FILERW #include #endif static rt_bool_t rtgui_image_jpeg_check(struct rtgui_filerw *file); static rt_bool_t rtgui_image_jpeg_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load); static void rtgui_image_jpeg_unload(struct rtgui_image *image); static void rtgui_image_jpeg_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *rect); struct rtgui_jpeg_error_mgr { struct jpeg_error_mgr pub; /* "public" fields */ }; struct rtgui_image_jpeg { rt_bool_t is_loaded; struct rtgui_filerw *filerw; /* jpeg structure */ struct jpeg_decompress_struct cinfo; struct rtgui_jpeg_error_mgr errmgr; rt_uint8_t *pixels; rt_uint8_t *line_pixels; }; struct rtgui_image_engine rtgui_image_jpeg_engine = { "jpeg", {RT_NULL}, rtgui_image_jpeg_check, rtgui_image_jpeg_load, rtgui_image_jpeg_unload, rtgui_image_jpeg_blit }; struct rtgui_image_engine rtgui_image_jpg_engine = { "jpg", {RT_NULL}, rtgui_image_jpeg_check, rtgui_image_jpeg_load, rtgui_image_jpeg_unload, rtgui_image_jpeg_blit }; #define INPUT_BUFFER_SIZE 4096 typedef struct { struct jpeg_source_mgr pub; struct rtgui_filerw *ctx; rt_uint8_t buffer[INPUT_BUFFER_SIZE]; } rtgui_jpeg_source_mgr; /* * Initialize source --- called by jpeg_read_header * before any data is actually read. */ static void init_source(j_decompress_ptr cinfo) { /* We don't actually need to do anything */ return; } /* * Fill the input buffer --- called whenever buffer is emptied. */ static boolean fill_input_buffer(j_decompress_ptr cinfo) { rtgui_jpeg_source_mgr *src = (rtgui_jpeg_source_mgr *) cinfo->src; int nbytes; nbytes = rtgui_filerw_read(src->ctx, src->buffer, 1, INPUT_BUFFER_SIZE); if (nbytes <= 0) { /* Insert a fake EOI marker */ src->buffer[0] = (rt_uint8_t) 0xFF; src->buffer[1] = (rt_uint8_t) JPEG_EOI; nbytes = 2; } src->pub.next_input_byte = src->buffer; src->pub.bytes_in_buffer = nbytes; return TRUE; } /* * Skip data --- used to skip over a potentially large amount of * uninteresting data (such as an APPn marker). * * Writers of suspendable-input applications must note that skip_input_data * is not granted the right to give a suspension return. If the skip extends * beyond the data currently in the buffer, the buffer can be marked empty so * that the next read will cause a fill_input_buffer call that can suspend. * Arranging for additional bytes to be discarded before reloading the input * buffer is the application writer's problem. */ static void skip_input_data(j_decompress_ptr cinfo, long num_bytes) { rtgui_jpeg_source_mgr *src = (rtgui_jpeg_source_mgr *) cinfo->src; /* Just a dumb implementation for now. Could use fseek() except * it doesn't work on pipes. Not clear that being smart is worth * any trouble anyway --- large skips are infrequent. */ if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; (void) src->pub.fill_input_buffer(cinfo); /* note we assume that fill_input_buffer will never * return FALSE, so suspension need not be handled. */ } src->pub.next_input_byte += (size_t) num_bytes; src->pub.bytes_in_buffer -= (size_t) num_bytes; } } /* * Terminate source --- called by jpeg_finish_decompress * after all data has been read. */ static void term_source(j_decompress_ptr cinfo) { /* We don't actually need to do anything */ return; } /* * Prepare for input from a stdio stream. * The caller must have already opened the stream, and is responsible * for closing it after finishing decompression. */ static void rtgui_jpeg_filerw_src_init(j_decompress_ptr cinfo, struct rtgui_filerw *ctx) { rtgui_jpeg_source_mgr *src; /* The source object and input buffer are made permanent so that a series * of JPEG images can be read from the same file by calling jpeg_stdio_src * only before the first one. (If we discarded the buffer at the end of * one image, we'd likely lose the start of the next one.) * This makes it unsafe to use this manager and a different source * manager serially with the same JPEG object. Caveat programmer. */ if (cinfo->src == NULL) /* first time for this JPEG object? */ { cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(rtgui_jpeg_source_mgr)); src = (rtgui_jpeg_source_mgr *) cinfo->src; } src = (rtgui_jpeg_source_mgr *) cinfo->src; src->pub.init_source = init_source; src->pub.fill_input_buffer = fill_input_buffer; src->pub.skip_input_data = skip_input_data; src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ src->pub.term_source = term_source; src->ctx = ctx; src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ src->pub.next_input_byte = NULL; /* until buffer loaded */ } /* get line data of a jpeg image */ static rt_uint8_t *rtgui_image_get_line(struct rtgui_image *image, int h) { struct rtgui_image_jpeg *jpeg; rt_uint8_t *result_ptr; JSAMPARRAY buffer; /* Output row buffer */ int row_stride; RT_ASSERT(image != RT_NULL); jpeg = (struct rtgui_image_jpeg *) image->data; RT_ASSERT(jpeg != RT_NULL); if (h < 0 || h > image->h) return RT_NULL; /* if the image is loaded, */ if (jpeg->is_loaded == RT_TRUE) { result_ptr = jpeg->pixels + (image->w * sizeof(rtgui_color_t)) * h; return result_ptr; } if (jpeg->line_pixels == RT_NULL) jpeg->line_pixels = rtgui_malloc(image->w * sizeof(rtgui_color_t)); row_stride = jpeg->cinfo.output_width * jpeg->cinfo.output_components; buffer = (*jpeg->cinfo.mem->alloc_sarray) ((j_common_ptr) &jpeg->cinfo, JPOOL_IMAGE, row_stride, 1); /* decompress line data */ jpeg->cinfo.output_scanline = h; jpeg_read_scanlines(&jpeg->cinfo, buffer, (JDIMENSION) 1); /* copy pixels memory */ { int index; rtgui_color_t *ptr; ptr = (rtgui_color_t *)jpeg->line_pixels; for (index = 0; index < image->w; index ++) ptr[index] = RTGUI_ARGB(0, buffer[0][index * 3], buffer[0][index * 3 + 1], buffer[0][index * 3 + 2]); } return jpeg->line_pixels; } static rt_bool_t rtgui_image_jpeg_loadall(struct rtgui_image *image) { struct rtgui_image_jpeg *jpeg; rt_uint8_t *line_ptr; JSAMPARRAY buffer; /* Output row buffer */ int row_stride; jpeg = (struct rtgui_image_jpeg *) image->data; RT_ASSERT(jpeg != RT_NULL); /* already load */ if (jpeg->pixels != RT_NULL) return RT_TRUE; /* allocate all pixels */ jpeg->pixels = rtgui_malloc(image->h * image->w * sizeof(rtgui_color_t)); if (jpeg->pixels == RT_NULL) return RT_FALSE; /* reset scan line to zero */ jpeg->cinfo.output_scanline = 0; line_ptr = jpeg->pixels; row_stride = jpeg->cinfo.output_width * jpeg->cinfo.output_components; buffer = (*jpeg->cinfo.mem->alloc_sarray) ((j_common_ptr) &jpeg->cinfo, JPOOL_IMAGE, row_stride, 1); /* decompress all pixels */ while (jpeg->cinfo.output_scanline < jpeg->cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ (void) jpeg_read_scanlines(&jpeg->cinfo, buffer, 1); /* copy pixels memory */ { int index; rtgui_color_t *ptr; ptr = (rtgui_color_t *)line_ptr; for (index = 0; index < image->w; index ++) ptr[index] = RTGUI_ARGB(0, buffer[0][index * 3], buffer[0][index * 3 + 1], buffer[0][index * 3 + 2]); } /* move to next line */ line_ptr += image->w * sizeof(rtgui_color_t); } /* decompress done */ rtgui_filerw_close(jpeg->filerw); jpeg_finish_decompress(&jpeg->cinfo); jpeg->is_loaded = RT_TRUE; return RT_TRUE; } void rtgui_image_jpeg_init() { /* register jpeg on image system */ rtgui_image_register_engine(&rtgui_image_jpeg_engine); /* register jpg on image system */ rtgui_image_register_engine(&rtgui_image_jpg_engine); } static void my_error_exit(j_common_ptr cinfo) { } static void output_no_message(j_common_ptr cinfo) { /* do nothing */ } static rt_bool_t rtgui_image_jpeg_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load) { struct rtgui_image_jpeg *jpeg; jpeg = (struct rtgui_image_jpeg *) rtgui_malloc(sizeof(struct rtgui_image_jpeg)); if (jpeg == RT_NULL) return RT_FALSE; jpeg->filerw = file; /* read file header */ /* Create a decompression structure and load the JPEG header */ jpeg->cinfo.err = jpeg_std_error(&jpeg->errmgr.pub); jpeg->errmgr.pub.error_exit = my_error_exit; jpeg->errmgr.pub.output_message = output_no_message; jpeg_create_decompress(&jpeg->cinfo); rtgui_jpeg_filerw_src_init(&jpeg->cinfo, jpeg->filerw); (void)jpeg_read_header(&jpeg->cinfo, TRUE); image->w = jpeg->cinfo.image_width; image->h = jpeg->cinfo.image_height; /* set image private data and engine */ image->data = jpeg; image->engine = &rtgui_image_jpeg_engine; /* start decompression */ (void) jpeg_start_decompress(&jpeg->cinfo); jpeg->cinfo.out_color_space = JCS_RGB; jpeg->cinfo.quantize_colors = FALSE; /* use fast jpeg */ jpeg->cinfo.scale_num = 1; jpeg->cinfo.scale_denom = 1; jpeg->cinfo.dct_method = JDCT_FASTEST; jpeg->cinfo.do_fancy_upsampling = FALSE; jpeg->pixels = RT_NULL; jpeg->is_loaded = RT_FALSE; /* allocate line pixels */ jpeg->line_pixels = rtgui_malloc(image->w * sizeof(rtgui_color_t)); if (jpeg->line_pixels == RT_NULL) { /* no memory */ jpeg_finish_decompress(&jpeg->cinfo); jpeg_destroy_decompress(&jpeg->cinfo); rt_free(jpeg); return RT_FALSE; } if (load == RT_TRUE) rtgui_image_jpeg_loadall(image); /* create jpeg image successful */ return RT_TRUE; } static void rtgui_image_jpeg_unload(struct rtgui_image *image) { if (image != RT_NULL) { struct rtgui_image_jpeg *jpeg; jpeg = (struct rtgui_image_jpeg *) image->data; RT_ASSERT(jpeg != RT_NULL); if (jpeg->is_loaded == RT_TRUE) rtgui_free(jpeg->pixels); if (jpeg->line_pixels != RT_NULL) rtgui_free(jpeg->line_pixels); if (jpeg->is_loaded != RT_TRUE) { rtgui_filerw_close(jpeg->filerw); jpeg_finish_decompress(&jpeg->cinfo); } jpeg_destroy_decompress(&jpeg->cinfo); rt_free(jpeg); } } static void rtgui_image_jpeg_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *rect) { rt_uint16_t x, y; rtgui_color_t *ptr; struct rtgui_image_jpeg *jpeg; RT_ASSERT(image != RT_NULL && dc != RT_NULL && rect != RT_NULL); jpeg = (struct rtgui_image_jpeg *) image->data; RT_ASSERT(jpeg != RT_NULL); if (jpeg->pixels != RT_NULL) { ptr = (rtgui_color_t *) jpeg->pixels; if (dc->type == RTGUI_DC_BUFFER) { /* blit ARGB888 to this buffered DC */ int dst_x, dst_y; int w, h; struct rtgui_blit_info info; struct rtgui_dc_buffer *buffer = (struct rtgui_dc_buffer*)dc; w = _UI_MIN(image->w, rtgui_rect_width(*rect)); h = _UI_MIN(image->h, rtgui_rect_height(*rect)); info.a = 0; /* initialize source blit information */ info.src_fmt = RTGRAPHIC_PIXEL_FORMAT_ARGB888;; info.src_h = h; info.src_w = w; info.src_pitch = image->w * rtgui_color_get_bpp(RTGRAPHIC_PIXEL_FORMAT_ARGB888); info.src_skip = info.src_pitch - w * rtgui_color_get_bpp(RTGRAPHIC_PIXEL_FORMAT_ARGB888); info.src = (rt_uint8_t *)image->data + y * info.src_pitch + x * rtgui_color_get_bpp(RTGRAPHIC_PIXEL_FORMAT_ARGB888); if (rect->x1 < 0) dst_x = 0; else dst_x = rect->x1; if (rect->y1 < 0) dst_y = 0; else dst_y = rect->y1; /* initialize destination blit information */ info.dst = rtgui_dc_buffer_get_pixel(RTGUI_DC(buffer)) + dst_y * buffer->pitch + dst_x * rtgui_color_get_bpp(buffer->pixel_format); info.dst_h = h; info.dst_w = w; info.dst_fmt = buffer->pixel_format; info.dst_pitch = buffer->pitch; info.dst_skip = info.dst_pitch - info.dst_w * rtgui_color_get_bpp(buffer->pixel_format); rtgui_blit(&info); } else { /* draw each point within dc */ for (y = 0; y < image->h; y ++) { for (x = 0; x < image->w; x++) { /* not alpha */ if ((*ptr >> 24) != 255) { rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1, *ptr); } /* move to next color buffer */ ptr ++; } } } } else { /* seek to the begin of file */ rtgui_filerw_seek(jpeg->filerw, 0, RTGUI_FILE_SEEK_SET); /* decompress line and line */ for (y = 0; y < image->h; y ++) { ptr = (rtgui_color_t *)rtgui_image_get_line(image, y); for (x = 0; x < image->w; x++) { /* not alpha */ if ((*ptr >> 24) != 255) { rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1, *ptr); } /* move to next color buffer */ ptr ++; } } } } static rt_bool_t rtgui_image_jpeg_check(struct rtgui_filerw *file) { int start; rt_bool_t is_JPG; int in_scan; rt_uint8_t magic[4]; if (file == RT_NULL) return RT_FALSE; /* open file failed */ start = rtgui_filerw_tell(file); is_JPG = RT_FALSE; in_scan = 0; /* seek to the begining of file */ rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET); if (rtgui_filerw_read(file, magic, 2, 1)) { if ((magic[0] == 0xFF) && (magic[1] == 0xD8)) { is_JPG = RT_TRUE; while (is_JPG == RT_TRUE) { if (rtgui_filerw_read(file, magic, 1, 2) != 2) { is_JPG = RT_FALSE; } else if ((magic[0] != 0xFF) && (in_scan == 0)) { is_JPG = RT_FALSE; } else if ((magic[0] != 0xFF) || (magic[1] == 0xFF)) { /* Extra padding in JPEG (legal) */ /* or this is data and we are scanning */ rtgui_filerw_seek(file, -1, RTGUI_FILE_SEEK_CUR); } else if (magic[1] == 0xD9) { /* Got to end of good JPEG */ break; } else if ((in_scan == 1) && (magic[1] == 0x00)) { /* This is an encoded 0xFF within the data */ } else if ((magic[1] >= 0xD0) && (magic[1] < 0xD9)) { /* These have nothing else */ } else if (rtgui_filerw_read(file, magic + 2, 1, 2) != 2) { is_JPG = RT_FALSE; } else { /* Yes, it's big-endian */ rt_uint32_t start; rt_uint32_t size; rt_uint32_t end; start = rtgui_filerw_tell(file); size = (magic[2] << 8) + magic[3]; end = rtgui_filerw_seek(file, size - 2, RTGUI_FILE_SEEK_CUR); if (end != start + size - 2) is_JPG = RT_FALSE; if (magic[1] == 0xDA) { /* Now comes the actual JPEG meat */ /* It is a JPEG. */ break; } } } } } rtgui_filerw_seek(file, start, RTGUI_FILE_SEEK_SET); return is_JPG; } #endif #if defined(RTGUI_IMAGE_TJPGD) /***************************************************************************//** * @file image_jpg.c * @brief JPEG decoder using TJpgDec module (elm-chan.org) * COPYRIGHT (C) 2012, RT-Thread Development Team * @author onelife * @version 1.0 ******************************************************************************* * @section License * The license and distribution terms for this file may be found in the file * LICENSE in this distribution or at http://www.rt-thread.org/license/LICENSE ******************************************************************************* * @section Change Logs * Date Author Notes * 2012-01-24 onelife Initial creation for limited memory devices ******************************************************************************/ /***************************************************************************//** * @addtogroup TJpgDec * @{ ******************************************************************************/ /* Includes ------------------------------------------------------------------*/ #include "tjpgd.h" #include #include #include #include #ifdef RTGUI_USING_DFS_FILERW #include #endif /* Private typedef -----------------------------------------------------------*/ struct rtgui_image_jpeg { struct rtgui_filerw *filerw; struct rtgui_dc *dc; rt_uint16_t dst_x, dst_y; rt_uint16_t dst_w, dst_h; rt_bool_t is_loaded; rt_uint8_t byte_per_pixel; JDEC tjpgd; /* jpeg structure */ void *pool; rt_uint8_t *pixels; }; /* Private define ------------------------------------------------------------*/ #define TJPGD_WORKING_BUFFER_SIZE (32 * 1024) /* Private macro -------------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ static rt_bool_t rtgui_image_jpeg_check(struct rtgui_filerw *file); static rt_bool_t rtgui_image_jpeg_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load); static void rtgui_image_jpeg_unload(struct rtgui_image *image); static void rtgui_image_jpeg_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *dst_rect); /* Private variables ---------------------------------------------------------*/ struct rtgui_image_engine rtgui_image_jpeg_engine = { "jpeg", {RT_NULL}, rtgui_image_jpeg_check, rtgui_image_jpeg_load, rtgui_image_jpeg_unload, rtgui_image_jpeg_blit }; struct rtgui_image_engine rtgui_image_jpg_engine = { "jpg", {RT_NULL}, rtgui_image_jpeg_check, rtgui_image_jpeg_load, rtgui_image_jpeg_unload, rtgui_image_jpeg_blit }; /* Private functions ---------------------------------------------------------*/ void rtgui_image_jpeg_init() { /* register jpeg on image system */ rtgui_image_register_engine(&rtgui_image_jpeg_engine); /* register jpg on image system */ rtgui_image_register_engine(&rtgui_image_jpg_engine); } static UINT tjpgd_in_func(JDEC *jdec, BYTE *buff, UINT ndata) { struct rtgui_filerw *file = *(struct rtgui_filerw **)jdec->device; if (buff == RT_NULL) { return rtgui_filerw_seek(file, ndata, RTGUI_FILE_SEEK_CUR); } return rtgui_filerw_read(file, (void *)buff, 1, ndata); } static UINT tjpgd_out_func(JDEC *jdec, void *bitmap, JRECT *rect) { struct rtgui_image_jpeg *jpeg = (struct rtgui_image_jpeg *)jdec->device; rt_uint16_t w, h, y; rt_uint16_t rectWidth; /* Width of source rectangular (bytes) */ rt_uint8_t *src, *dst; /* Copy the decompressed RGB rectangular to the frame buffer */ rectWidth = (rect->right - rect->left + 1) * jpeg->byte_per_pixel; src = (rt_uint8_t *)bitmap; if (jpeg->is_loaded == RT_TRUE) { rt_uint16_t imageWidth; /* Width of image (bytes) */ imageWidth = (jdec->width >> jdec->scale) * jpeg->byte_per_pixel; dst = jpeg->pixels + rect->top * imageWidth + rect->left * jpeg->byte_per_pixel; /* Left-top of destination rectangular */ for (h = rect->top; h <= rect->bottom; h++) { rt_memcpy(dst, src, rectWidth); src += rectWidth; dst += imageWidth; /* Next line */ } } else { /* we decompress from top to bottom if the block is beyond the right * boundary, just continue to next block. However, if the block is * beyond the bottom boundary, we don't need to decompress the rest. */ if (rect->left > jpeg->dst_w) return 1; if (rect->top > jpeg->dst_h) return 0; w = _UI_MIN(rect->right, jpeg->dst_w); w = w - rect->left + 1; h = _UI_MIN(rect->bottom, jpeg->dst_h); h = h - rect->top + 1; for (y = 0; y < h; y++) { jpeg->dc->engine->blit_line(jpeg->dc, jpeg->dst_x + rect->left, jpeg->dst_x + rect->left + w, jpeg->dst_y + rect->top + y, src); src += rectWidth; } } return 1; /* Continue to decompress */ } static rt_bool_t rtgui_image_jpeg_check(struct rtgui_filerw *file) { rt_uint8_t soi[2]; rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET); rtgui_filerw_read(file, &soi, 2, 1); rtgui_filerw_seek(file, 0, RTGUI_FILE_SEEK_SET); /* check SOI==FFD8 */ if (soi[0] == 0xff && soi[1] == 0xd8) return RT_TRUE; return RT_FALSE; } static rt_bool_t rtgui_image_jpeg_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load) { rt_bool_t res = RT_FALSE; struct rtgui_image_jpeg *jpeg; JRESULT ret; struct rtgui_graphic_driver *hw_driver; do { jpeg = (struct rtgui_image_jpeg *)rt_malloc(sizeof(struct rtgui_image_jpeg)); if (jpeg == RT_NULL) break; jpeg->filerw = file; jpeg->is_loaded = load; jpeg->pixels = RT_NULL; /* allocate memory pool */ jpeg->pool = rt_malloc(TJPGD_WORKING_BUFFER_SIZE); if (jpeg->pool == RT_NULL) { rt_kprintf("TJPGD err: no mem (%d)\n", TJPGD_WORKING_BUFFER_SIZE); break; } if (rtgui_filerw_seek(jpeg->filerw, 0, RTGUI_FILE_SEEK_SET) == -1) { break; } ret = jd_prepare(&jpeg->tjpgd, tjpgd_in_func, jpeg->pool, TJPGD_WORKING_BUFFER_SIZE, (void *)jpeg); if (ret != JDR_OK) { if (ret == JDR_FMT3) { rt_kprintf("TJPGD: not supported format\n"); } break; } /* use RGB565 format */ hw_driver = rtgui_graphic_driver_get_default(); if (hw_driver->pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565) { jpeg->tjpgd.format = 1; jpeg->byte_per_pixel = 2; } /* else use RGB888 format */ else jpeg->byte_per_pixel = 3; image->w = (rt_uint16_t)jpeg->tjpgd.width; image->h = (rt_uint16_t)jpeg->tjpgd.height; /* set image private data and engine */ image->data = jpeg; image->engine = &rtgui_image_jpeg_engine; if (jpeg->is_loaded == RT_TRUE) { jpeg->pixels = (rt_uint8_t *)rtgui_malloc( jpeg->byte_per_pixel * image->w * image->h); if (jpeg->pixels == RT_NULL) { rt_kprintf("TJPGD err: no mem to load (%d)\n", jpeg->byte_per_pixel * image->w * image->h); break; } ret = jd_decomp(&jpeg->tjpgd, tjpgd_out_func, 0); if (ret != JDR_OK) break; rtgui_filerw_close(jpeg->filerw); jpeg->filerw = RT_NULL; } res = RT_TRUE; } while (0); if (jpeg && (!res || jpeg->is_loaded)) { rt_free(jpeg->pool); jpeg->pool = RT_NULL; } if (!res) { if (jpeg) rtgui_free(jpeg->pixels); rt_free(jpeg); image->data = RT_NULL; image->engine = RT_NULL; } /* create jpeg image successful */ return res; } static void rtgui_image_jpeg_unload(struct rtgui_image *image) { if (image != RT_NULL) { struct rtgui_image_jpeg *jpeg; jpeg = (struct rtgui_image_jpeg *) image->data; RT_ASSERT(jpeg != RT_NULL); if (jpeg->is_loaded == RT_TRUE) { rtgui_free(jpeg->pixels); } else { rt_free(jpeg->pool); rtgui_filerw_close(jpeg->filerw); } rt_free(jpeg); } } static void rtgui_image_jpeg_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *dst_rect) { rt_uint16_t y, w, h, xoff, yoff; struct rtgui_image_jpeg *jpeg; jpeg = (struct rtgui_image_jpeg *) image->data; RT_ASSERT(image != RT_NULL || dc != RT_NULL || dst_rect != RT_NULL || jpeg != RT_NULL); /* this dc is not visible */ if (rtgui_dc_get_visible(dc) != RT_TRUE) return; jpeg->dc = dc; xoff = 0; if (dst_rect->x1 < 0) { xoff = -dst_rect->x1; dst_rect->x1 = 0; } yoff = 0; if (dst_rect->y1 < 0) { yoff = -dst_rect->y1; dst_rect->y1 = 0; } if (xoff >= image->w || yoff >= image->h) return; /* the minimum rect */ w = _UI_MIN(image->w - xoff, rtgui_rect_width (*dst_rect)); h = _UI_MIN(image->h - yoff, rtgui_rect_height(*dst_rect)); if (rtgui_dc_get_pixel_format(dc) == RTGRAPHIC_PIXEL_FORMAT_RGB888 && jpeg->tjpgd.format != 0) { jpeg->tjpgd.format = 0; jpeg->byte_per_pixel = 3; } else if (rtgui_dc_get_pixel_format(dc) == RTGRAPHIC_PIXEL_FORMAT_RGB565 && jpeg->tjpgd.format != 1) { jpeg->tjpgd.format = 1; jpeg->byte_per_pixel = 2; } if (!jpeg->is_loaded) { JRESULT ret; /* TODO support xoff/yoff. */ jpeg->dst_x = dst_rect->x1; jpeg->dst_y = dst_rect->y1; jpeg->dst_w = w; jpeg->dst_h = h; ret = jd_decomp(&jpeg->tjpgd, tjpgd_out_func, 0); if (ret != JDR_OK) return; } else { if ((rtgui_dc_get_pixel_format(dc) == RTGRAPHIC_PIXEL_FORMAT_RGB888 && jpeg->tjpgd.format == 0) || (rtgui_dc_get_pixel_format(dc) == RTGRAPHIC_PIXEL_FORMAT_RGB565 && jpeg->tjpgd.format == 1)) { rt_uint16_t imageWidth = image->w * jpeg->byte_per_pixel; rt_uint8_t *src = jpeg->pixels + yoff * imageWidth + xoff + jpeg->byte_per_pixel; for (y = 0; y < h; y++) { dc->engine->blit_line(dc, dst_rect->x1, dst_rect->x1 + w, dst_rect->y1 + y, src); src += imageWidth; } } /* if the format is not match, only support DC buffer */ else if (dc->type == RTGUI_DC_BUFFER) { struct rtgui_blit_info info; struct rtgui_dc_buffer *buffer; buffer = (struct rtgui_dc_buffer*)dc; info.src = jpeg->pixels + yoff * image->w * jpeg->byte_per_pixel + xoff + jpeg->byte_per_pixel; info.src_h = rtgui_rect_height(*dst_rect); info.src_w = rtgui_rect_width(*dst_rect); info.src_fmt = (jpeg->tjpgd.format == 0? RTGRAPHIC_PIXEL_FORMAT_RGB888 : RTGRAPHIC_PIXEL_FORMAT_RGB565); info.src_pitch = info.src_w * jpeg->byte_per_pixel; info.src_skip = info.src_pitch - info.src_w * jpeg->byte_per_pixel; info.dst = rtgui_dc_buffer_get_pixel(RTGUI_DC(buffer)) + dst_rect->y1 * buffer->pitch + dst_rect->x1 * rtgui_color_get_bpp(buffer->pixel_format); info.dst_h = rtgui_rect_height(*dst_rect); info.dst_w = rtgui_rect_width(*dst_rect); info.dst_fmt = buffer->pixel_format; info.dst_pitch = buffer->pitch; info.dst_skip = info.dst_pitch - info.dst_w * rtgui_color_get_bpp(buffer->pixel_format); rtgui_blit(&info); } } } #endif /* defined(RTGUI_IMAGE_TJPGD) */