2008-11-05 09:21:04 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
2006-10-27 20:02:23 -07:00
|
|
|
|
2006-01-14 12:03:42 -08:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <jpeglib.h>
|
|
|
|
#include <setjmp.h>
|
|
|
|
|
2008-11-05 09:21:04 -08:00
|
|
|
#ifdef HAVE_EVIL
|
|
|
|
# include <Evil.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "evas_common.h"
|
|
|
|
#include "evas_private.h"
|
|
|
|
|
2006-01-14 12:03:42 -08:00
|
|
|
|
|
|
|
typedef struct _JPEG_error_mgr *emptr;
|
|
|
|
struct _JPEG_error_mgr
|
|
|
|
{
|
|
|
|
struct jpeg_error_mgr pub;
|
|
|
|
jmp_buf setjmp_buffer;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void _JPEGFatalErrorHandler(j_common_ptr cinfo);
|
|
|
|
static void _JPEGErrorHandler(j_common_ptr cinfo);
|
|
|
|
static void _JPEGErrorHandler2(j_common_ptr cinfo, int msg_level);
|
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool evas_image_load_file_head_jpeg_internal(Image_Entry *ie, FILE *f, int *error) EINA_ARG_NONNULL(1, 2, 3);
|
|
|
|
static Eina_Bool evas_image_load_file_data_jpeg_internal(Image_Entry *ie, FILE *f, int *error) EINA_ARG_NONNULL(1, 2, 3);
|
2006-01-14 12:03:42 -08:00
|
|
|
#if 0 /* not used at the moment */
|
2009-12-22 15:11:57 -08:00
|
|
|
static int evas_image_load_file_data_jpeg_alpha_internal(Image_Entry *ie, FILE *f) EINA_ARG_NONNULL(1, 2);
|
2006-01-14 12:03:42 -08:00
|
|
|
#endif
|
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool evas_image_load_file_head_jpeg(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);
|
|
|
|
static Eina_Bool evas_image_load_file_data_jpeg(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);
|
2006-01-14 12:03:42 -08:00
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static Evas_Image_Load_Func evas_image_load_jpeg_func =
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
2009-12-24 05:15:34 -08:00
|
|
|
EINA_TRUE,
|
2006-01-14 12:03:42 -08:00
|
|
|
evas_image_load_file_head_jpeg,
|
|
|
|
evas_image_load_file_data_jpeg
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_JPEGFatalErrorHandler(j_common_ptr cinfo)
|
|
|
|
{
|
|
|
|
emptr errmgr;
|
|
|
|
|
|
|
|
errmgr = (emptr) cinfo->err;
|
|
|
|
/* cinfo->err->output_message(cinfo);*/
|
|
|
|
longjmp(errmgr->setjmp_buffer, 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-10-22 15:33:06 -07:00
|
|
|
_JPEGErrorHandler(j_common_ptr cinfo __UNUSED__)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
2009-10-22 15:33:06 -07:00
|
|
|
/* emptr errmgr; */
|
2006-01-14 12:03:42 -08:00
|
|
|
|
2009-10-22 15:33:06 -07:00
|
|
|
/* errmgr = (emptr) cinfo->err; */
|
2006-01-14 12:03:42 -08:00
|
|
|
/* cinfo->err->output_message(cinfo);*/
|
|
|
|
/* longjmp(errmgr->setjmp_buffer, 1);*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-10-22 15:33:06 -07:00
|
|
|
_JPEGErrorHandler2(j_common_ptr cinfo __UNUSED__, int msg_level __UNUSED__)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
2009-10-22 15:33:06 -07:00
|
|
|
/* emptr errmgr; */
|
2006-01-14 12:03:42 -08:00
|
|
|
|
2009-10-22 15:33:06 -07:00
|
|
|
/* errmgr = (emptr) cinfo->err; */
|
2006-01-14 12:03:42 -08:00
|
|
|
/* cinfo->err->output_message(cinfo);*/
|
|
|
|
/* longjmp(errmgr->setjmp_buffer, 1);*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool
|
|
|
|
evas_image_load_file_head_jpeg_internal(Image_Entry *ie, FILE *f, int *error)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
2006-08-18 18:48:13 -07:00
|
|
|
int w, h, scalew, scaleh;
|
2006-01-14 12:03:42 -08:00
|
|
|
struct jpeg_decompress_struct cinfo;
|
|
|
|
struct _JPEG_error_mgr jerr;
|
|
|
|
|
|
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
if (cinfo.saw_JFIF_marker)
|
|
|
|
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
|
|
|
|
else
|
|
|
|
*error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
|
|
|
|
return EINA_FALSE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
jpeg_stdio_src(&cinfo, f);
|
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
|
|
cinfo.do_fancy_upsampling = FALSE;
|
|
|
|
cinfo.do_block_smoothing = FALSE;
|
2008-04-11 17:32:30 -07:00
|
|
|
cinfo.dct_method = JDCT_IFAST;
|
|
|
|
cinfo.dither_mode = JDITHER_ORDERED;
|
2006-01-14 12:03:42 -08:00
|
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
|
|
|
|
/* head decoding */
|
2006-08-18 18:48:13 -07:00
|
|
|
w = cinfo.output_width;
|
|
|
|
h = cinfo.output_height;
|
2009-09-16 02:48:05 -07:00
|
|
|
if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) ||
|
|
|
|
(IMG_TOO_BIG(w, h)))
|
2009-05-05 14:48:50 -07:00
|
|
|
{
|
2006-11-04 21:07:53 -08:00
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
if (IMG_TOO_BIG(w, h))
|
|
|
|
*error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
|
|
|
|
else
|
|
|
|
*error = EVAS_LOAD_ERROR_GENERIC;
|
|
|
|
return EINA_FALSE;
|
2006-11-04 21:07:53 -08:00
|
|
|
}
|
2008-06-03 02:09:39 -07:00
|
|
|
if (ie->load_opts.scale_down_by > 1)
|
2006-08-18 18:48:13 -07:00
|
|
|
{
|
2008-06-03 02:09:39 -07:00
|
|
|
w /= ie->load_opts.scale_down_by;
|
|
|
|
h /= ie->load_opts.scale_down_by;
|
2006-08-18 18:48:13 -07:00
|
|
|
}
|
2008-06-03 02:09:39 -07:00
|
|
|
else if (ie->load_opts.dpi > 0.0)
|
2006-08-18 18:48:13 -07:00
|
|
|
{
|
2008-06-03 02:09:39 -07:00
|
|
|
w = (w * ie->load_opts.dpi) / 90.0;
|
|
|
|
h = (h * ie->load_opts.dpi) / 90.0;
|
2006-08-18 18:48:13 -07:00
|
|
|
}
|
2010-03-01 18:14:39 -08:00
|
|
|
else if ((ie->load_opts.w > 0) && (ie->load_opts.h > 0))
|
2006-08-18 18:48:13 -07:00
|
|
|
{
|
2010-03-01 18:14:39 -08:00
|
|
|
int w2 = w, h2 = h;
|
2009-01-29 08:45:14 -08:00
|
|
|
if (ie->load_opts.w > 0)
|
|
|
|
{
|
|
|
|
w2 = ie->load_opts.w;
|
|
|
|
h2 = (ie->load_opts.w * h) / w;
|
|
|
|
if ((ie->load_opts.h > 0) && (h2 > ie->load_opts.h))
|
|
|
|
{
|
2010-08-30 23:50:48 -07:00
|
|
|
int w3;
|
2009-01-29 08:45:14 -08:00
|
|
|
h2 = ie->load_opts.h;
|
2010-08-30 23:50:48 -07:00
|
|
|
w3 = (ie->load_opts.h * w) / h;
|
|
|
|
if (w3 > w2)
|
|
|
|
w2 = w3;
|
2009-01-29 08:45:14 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ie->load_opts.h > 0)
|
2006-08-18 18:48:13 -07:00
|
|
|
{
|
2008-06-03 02:09:39 -07:00
|
|
|
h2 = ie->load_opts.h;
|
|
|
|
w2 = (ie->load_opts.h * w) / h;
|
2006-08-18 18:48:13 -07:00
|
|
|
}
|
|
|
|
w = w2;
|
|
|
|
h = h2;
|
|
|
|
}
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (h < 1) h = 1;
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2006-08-18 18:48:13 -07:00
|
|
|
if ((w != cinfo.output_width) || (h != cinfo.output_height))
|
|
|
|
{
|
|
|
|
scalew = cinfo.output_width / w;
|
|
|
|
scaleh = cinfo.output_height / h;
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2008-06-03 02:09:39 -07:00
|
|
|
ie->scale = scalew;
|
|
|
|
if (scaleh < scalew) ie->scale = scaleh;
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2008-06-03 02:09:39 -07:00
|
|
|
if (ie->scale > 8) ie->scale = 8;
|
|
|
|
else if (ie->scale < 1) ie->scale = 1;
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2008-06-03 02:09:39 -07:00
|
|
|
if (ie->scale == 3) ie->scale = 2;
|
|
|
|
else if (ie->scale == 5) ie->scale = 4;
|
|
|
|
else if (ie->scale == 6) ie->scale = 4;
|
|
|
|
else if (ie->scale == 7) ie->scale = 4;
|
2006-08-18 18:48:13 -07:00
|
|
|
}
|
|
|
|
|
2008-06-03 02:09:39 -07:00
|
|
|
if (ie->scale > 1)
|
2006-08-18 18:48:13 -07:00
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2006-08-18 18:48:13 -07:00
|
|
|
rewind(f);
|
|
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
jpeg_stdio_src(&cinfo, f);
|
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
|
|
cinfo.do_fancy_upsampling = FALSE;
|
|
|
|
cinfo.do_block_smoothing = FALSE;
|
|
|
|
cinfo.scale_num = 1;
|
2008-06-03 02:09:39 -07:00
|
|
|
cinfo.scale_denom = ie->scale;
|
2006-08-18 18:48:13 -07:00
|
|
|
jpeg_calc_output_dimensions(&(cinfo));
|
|
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2008-06-03 02:09:39 -07:00
|
|
|
ie->w = cinfo.output_width;
|
|
|
|
ie->h = cinfo.output_height;
|
2009-09-16 02:48:05 -07:00
|
|
|
|
|
|
|
// be nice and clip region to image. if its totally outside, fail load
|
|
|
|
if ((ie->load_opts.region.w > 0) && (ie->load_opts.region.h > 0))
|
|
|
|
{
|
|
|
|
RECTS_CLIP_TO_RECT(ie->load_opts.region.x, ie->load_opts.region.y,
|
|
|
|
ie->load_opts.region.w, ie->load_opts.region.h,
|
|
|
|
0, 0, ie->w, ie->h);
|
|
|
|
if ((ie->load_opts.region.w <= 0) || (ie->load_opts.region.h <= 0))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_GENERIC;
|
|
|
|
return EINA_FALSE;
|
2009-09-16 02:48:05 -07:00
|
|
|
}
|
|
|
|
ie->w = ie->load_opts.region.w;
|
|
|
|
ie->h = ie->load_opts.region.h;
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
/* end head decoding */
|
|
|
|
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
|
2009-10-22 15:33:06 -07:00
|
|
|
/*
|
2009-09-21 05:49:31 -07:00
|
|
|
static double
|
|
|
|
get_time(void)
|
|
|
|
{
|
|
|
|
struct timeval timev;
|
|
|
|
|
|
|
|
gettimeofday(&timev, NULL);
|
|
|
|
return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
|
|
|
|
}
|
2009-10-22 15:33:06 -07:00
|
|
|
*/
|
2009-09-21 05:49:31 -07:00
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool
|
|
|
|
evas_image_load_file_data_jpeg_internal(Image_Entry *ie, FILE *f, int *error)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
int w, h;
|
|
|
|
struct jpeg_decompress_struct cinfo;
|
|
|
|
struct _JPEG_error_mgr jerr;
|
|
|
|
DATA8 *ptr, *line[16], *data;
|
|
|
|
DATA32 *ptr2;
|
2010-07-31 09:57:09 -07:00
|
|
|
int x, y, l, i, scans;
|
2009-09-16 02:48:05 -07:00
|
|
|
int region = 0;
|
2006-01-14 12:03:42 -08:00
|
|
|
|
|
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
|
|
|
|
return EINA_FALSE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
jpeg_stdio_src(&cinfo, f);
|
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
|
|
cinfo.do_fancy_upsampling = FALSE;
|
|
|
|
cinfo.do_block_smoothing = FALSE;
|
2006-08-18 18:48:13 -07:00
|
|
|
cinfo.dct_method = JDCT_IFAST;
|
2008-04-11 17:32:30 -07:00
|
|
|
cinfo.dither_mode = JDITHER_ORDERED;
|
|
|
|
|
2008-06-03 02:09:39 -07:00
|
|
|
if (ie->scale > 1)
|
2006-08-18 18:48:13 -07:00
|
|
|
{
|
|
|
|
cinfo.scale_num = 1;
|
2008-06-03 02:09:39 -07:00
|
|
|
cinfo.scale_denom = ie->scale;
|
2006-08-18 18:48:13 -07:00
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
|
|
|
|
/* Colorspace conversion options */
|
|
|
|
/* libjpeg can do the following conversions: */
|
|
|
|
/* GRAYSCLAE => RGB YCbCr => RGB and YCCK => CMYK */
|
|
|
|
switch (cinfo.jpeg_color_space)
|
|
|
|
{
|
|
|
|
case JCS_UNKNOWN:
|
|
|
|
break;
|
|
|
|
case JCS_GRAYSCALE:
|
|
|
|
case JCS_RGB:
|
|
|
|
case JCS_YCbCr:
|
|
|
|
cinfo.out_color_space = JCS_RGB;
|
|
|
|
break;
|
|
|
|
case JCS_CMYK:
|
|
|
|
case JCS_YCCK:
|
|
|
|
cinfo.out_color_space = JCS_CMYK;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-01-14 12:03:42 -08:00
|
|
|
/* head decoding */
|
2006-08-18 18:48:13 -07:00
|
|
|
jpeg_calc_output_dimensions(&(cinfo));
|
|
|
|
jpeg_start_decompress(&cinfo);
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2006-08-18 18:48:13 -07:00
|
|
|
w = cinfo.output_width;
|
|
|
|
h = cinfo.output_height;
|
2009-05-05 14:48:50 -07:00
|
|
|
|
2009-09-16 02:48:05 -07:00
|
|
|
if ((ie->load_opts.region.w > 0) && (ie->load_opts.region.h > 0))
|
2009-09-21 05:49:31 -07:00
|
|
|
{
|
|
|
|
region = 1;
|
|
|
|
#ifdef BUILD_LOADER_JPEG_REGION
|
|
|
|
cinfo.region_x = ie->load_opts.region.x;
|
|
|
|
cinfo.region_y = ie->load_opts.region.y;
|
|
|
|
cinfo.region_w = ie->load_opts.region.w;
|
|
|
|
cinfo.region_h = ie->load_opts.region.h;
|
|
|
|
#endif
|
|
|
|
}
|
2010-04-21 06:47:42 -07:00
|
|
|
if ((!region) && ((w != ie->w) || (h != ie->h)))
|
2006-08-18 18:49:33 -07:00
|
|
|
{
|
2010-04-21 06:47:42 -07:00
|
|
|
// race condition, the file could have change from when we call header
|
|
|
|
// this test will not solve the problem with region code.
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
|
|
|
*error = EVAS_LOAD_ERROR_GENERIC;
|
|
|
|
return EINA_FALSE;
|
2009-09-16 02:48:05 -07:00
|
|
|
}
|
2010-04-21 06:47:42 -07:00
|
|
|
if ((region) &&
|
2009-09-16 02:48:05 -07:00
|
|
|
((ie->w != ie->load_opts.region.w) || (ie->h != ie->load_opts.region.h)))
|
|
|
|
{
|
|
|
|
ie->w = ie->load_opts.region.w;
|
|
|
|
ie->h = ie->load_opts.region.h;
|
2006-08-18 18:49:33 -07:00
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
|
|
|
|
if (!(((cinfo.out_color_space == JCS_RGB) &&
|
|
|
|
((cinfo.output_components == 3) || (cinfo.output_components == 1))) ||
|
2009-06-16 06:01:36 -07:00
|
|
|
((cinfo.out_color_space == JCS_CMYK) && (cinfo.output_components == 4))))
|
2009-05-05 14:48:50 -07:00
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
|
|
|
|
return EINA_FALSE;
|
2009-05-05 14:48:50 -07:00
|
|
|
}
|
|
|
|
|
2006-01-14 12:03:42 -08:00
|
|
|
/* end head decoding */
|
|
|
|
/* data decoding */
|
|
|
|
if (cinfo.rec_outbuf_height > 16)
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
|
|
|
|
return EINA_FALSE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
data = alloca(w * 16 * cinfo.output_components);
|
2009-09-16 02:48:05 -07:00
|
|
|
evas_cache_image_surface_alloc(ie, ie->w, ie->h);
|
2008-06-03 02:09:39 -07:00
|
|
|
if (ie->flags.loaded)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2008-06-03 02:09:39 -07:00
|
|
|
ptr2 = evas_cache_image_pixels(ie);
|
2010-07-31 09:57:09 -07:00
|
|
|
|
2009-05-05 14:48:50 -07:00
|
|
|
/* We handle first CMYK (4 components) */
|
|
|
|
if (cinfo.output_components == 4)
|
|
|
|
{
|
2009-09-16 02:48:05 -07:00
|
|
|
// FIXME: handle region
|
2009-05-05 14:48:50 -07:00
|
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
|
|
line[i] = data + (i * w * 4);
|
|
|
|
for (l = 0; l < h; l += cinfo.rec_outbuf_height)
|
|
|
|
{
|
|
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
|
|
scans = cinfo.rec_outbuf_height;
|
|
|
|
if ((h - l) < scans) scans = h - l;
|
|
|
|
ptr = data;
|
2009-09-20 07:31:48 -07:00
|
|
|
if (!region)
|
|
|
|
{
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
2009-05-05 14:48:50 -07:00
|
|
|
if (cinfo.saw_Adobe_marker)
|
2009-09-20 07:31:48 -07:00
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
|
|
|
/* According to libjpeg doc, Photoshop inverse the values of C, M, Y and K, */
|
|
|
|
/* that is C is replaces by 255 - C, etc...*/
|
|
|
|
/* See the comment below for the computation of RGB values from CMYK ones. */
|
|
|
|
*ptr2 =
|
|
|
|
(0xff000000) |
|
|
|
|
((ptr[0] * ptr[3] / 255) << 16) |
|
|
|
|
((ptr[1] * ptr[3] / 255) << 8) |
|
|
|
|
((ptr[2] * ptr[3] / 255));
|
|
|
|
ptr += 4;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
else
|
2009-09-20 07:31:48 -07:00
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
|
|
|
/* Conversion from CMYK to RGB is done in 2 steps: */
|
|
|
|
/* CMYK => CMY => RGB (see http://www.easyrgb.com/index.php?X=MATH) */
|
|
|
|
/* after computation, if C, M, Y and K are between 0 and 1, we have: */
|
|
|
|
/* R = (1 - C) * (1 - K) * 255 */
|
|
|
|
/* G = (1 - M) * (1 - K) * 255 */
|
|
|
|
/* B = (1 - Y) * (1 - K) * 255 */
|
|
|
|
/* libjpeg stores CMYK values between 0 and 255, */
|
|
|
|
/* so we replace C by C * 255 / 255, etc... and we obtain: */
|
|
|
|
/* R = (255 - C) * (255 - K) / 255 */
|
|
|
|
/* G = (255 - M) * (255 - K) / 255 */
|
|
|
|
/* B = (255 - Y) * (255 - K) / 255 */
|
|
|
|
/* with C, M, Y and K between 0 and 255. */
|
|
|
|
*ptr2 =
|
|
|
|
(0xff000000) |
|
|
|
|
(((255 - ptr[0]) * (255 - ptr[3]) / 255) << 16) |
|
|
|
|
(((255 - ptr[1]) * (255 - ptr[3]) / 255) << 8) |
|
|
|
|
(((255 - ptr[2]) * (255 - ptr[3]) / 255));
|
|
|
|
ptr += 4;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 07:31:48 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// if line # > region last line, break
|
|
|
|
if (l >= (ie->load_opts.region.y + ie->load_opts.region.h))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_FALSE;
|
2009-09-20 07:31:48 -07:00
|
|
|
}
|
|
|
|
// els if scan block intersects region start or later
|
|
|
|
else if ((l + scans) >
|
|
|
|
(ie->load_opts.region.y))
|
|
|
|
{
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
if (((y + l) >= ie->load_opts.region.y) &&
|
|
|
|
((y + l) < (ie->load_opts.region.y + ie->load_opts.region.h)))
|
|
|
|
{
|
|
|
|
ptr += ie->load_opts.region.x;
|
|
|
|
if (cinfo.saw_Adobe_marker)
|
|
|
|
{
|
|
|
|
for (x = 0; x < ie->load_opts.region.w; x++)
|
|
|
|
{
|
|
|
|
/* According to libjpeg doc, Photoshop inverse the values of C, M, Y and K, */
|
|
|
|
/* that is C is replaces by 255 - C, etc...*/
|
|
|
|
/* See the comment below for the computation of RGB values from CMYK ones. */
|
|
|
|
*ptr2 =
|
|
|
|
(0xff000000) |
|
|
|
|
((ptr[0] * ptr[3] / 255) << 16) |
|
|
|
|
((ptr[1] * ptr[3] / 255) << 8) |
|
|
|
|
((ptr[2] * ptr[3] / 255));
|
|
|
|
ptr += 4;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (x = 0; x < ie->load_opts.region.w; x++)
|
|
|
|
{
|
|
|
|
/* Conversion from CMYK to RGB is done in 2 steps: */
|
|
|
|
/* CMYK => CMY => RGB (see http://www.easyrgb.com/index.php?X=MATH) */
|
|
|
|
/* after computation, if C, M, Y and K are between 0 and 1, we have: */
|
|
|
|
/* R = (1 - C) * (1 - K) * 255 */
|
|
|
|
/* G = (1 - M) * (1 - K) * 255 */
|
|
|
|
/* B = (1 - Y) * (1 - K) * 255 */
|
|
|
|
/* libjpeg stores CMYK values between 0 and 255, */
|
|
|
|
/* so we replace C by C * 255 / 255, etc... and we obtain: */
|
|
|
|
/* R = (255 - C) * (255 - K) / 255 */
|
|
|
|
/* G = (255 - M) * (255 - K) / 255 */
|
|
|
|
/* B = (255 - Y) * (255 - K) / 255 */
|
|
|
|
/* with C, M, Y and K between 0 and 255. */
|
|
|
|
*ptr2 =
|
|
|
|
(0xff000000) |
|
|
|
|
(((255 - ptr[0]) * (255 - ptr[3]) / 255) << 16) |
|
|
|
|
(((255 - ptr[1]) * (255 - ptr[3]) / 255) << 8) |
|
|
|
|
(((255 - ptr[2]) * (255 - ptr[3]) / 255));
|
|
|
|
ptr += 4;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ptr += (4 * (w - (ie->load_opts.region.x + ie->load_opts.region.w)));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ptr += (4 * w);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* We handle then RGB with 3 components */
|
|
|
|
else if (cinfo.output_components == 3)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
2009-09-21 05:49:31 -07:00
|
|
|
/*
|
|
|
|
double t;
|
2009-09-16 02:48:05 -07:00
|
|
|
if (region)
|
|
|
|
{
|
2009-09-20 07:31:48 -07:00
|
|
|
// debug for now
|
2009-09-21 05:49:31 -07:00
|
|
|
printf("R| %p %5ix%5i %s: %5i %5i %5ix%5i - ",
|
2009-09-20 07:31:48 -07:00
|
|
|
ie,
|
2009-09-16 02:48:05 -07:00
|
|
|
ie->w, ie->h,
|
|
|
|
ie->file,
|
|
|
|
ie->load_opts.region.x,
|
|
|
|
ie->load_opts.region.y,
|
|
|
|
ie->load_opts.region.w,
|
|
|
|
ie->load_opts.region.h);
|
|
|
|
}
|
2009-09-21 05:49:31 -07:00
|
|
|
t = get_time();
|
|
|
|
*/
|
2009-09-20 07:31:48 -07:00
|
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
2006-01-14 12:03:42 -08:00
|
|
|
line[i] = data + (i * w * 3);
|
|
|
|
for (l = 0; l < h; l += cinfo.rec_outbuf_height)
|
|
|
|
{
|
|
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
|
|
scans = cinfo.rec_outbuf_height;
|
|
|
|
if ((h - l) < scans) scans = h - l;
|
|
|
|
ptr = data;
|
2009-09-16 02:48:05 -07:00
|
|
|
if (!region)
|
|
|
|
{
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
2010-06-07 22:39:46 -07:00
|
|
|
*ptr2 = ARGB_JOIN(0xff, ptr[0], ptr[1], ptr[2]);
|
2009-09-16 02:48:05 -07:00
|
|
|
ptr += 3;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2009-09-16 02:48:05 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// if line # > region last line, break
|
|
|
|
if (l >= (ie->load_opts.region.y + ie->load_opts.region.h))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-09-21 05:49:31 -07:00
|
|
|
/*
|
|
|
|
t = get_time() - t;
|
|
|
|
printf("%3.3f\n", t);
|
|
|
|
*/
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2009-09-16 02:48:05 -07:00
|
|
|
}
|
2009-09-21 05:49:31 -07:00
|
|
|
// else if scan block intersects region start or later
|
2009-09-16 02:48:05 -07:00
|
|
|
else if ((l + scans) >
|
|
|
|
(ie->load_opts.region.y))
|
|
|
|
{
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
if (((y + l) >= ie->load_opts.region.y) &&
|
|
|
|
((y + l) < (ie->load_opts.region.y + ie->load_opts.region.h)))
|
|
|
|
{
|
|
|
|
ptr += (3 * ie->load_opts.region.x);
|
|
|
|
for (x = 0; x < ie->load_opts.region.w; x++)
|
|
|
|
{
|
2010-06-07 22:39:46 -07:00
|
|
|
*ptr2 = ARGB_JOIN(0xff, ptr[0], ptr[1], ptr[2]);
|
2009-09-16 02:48:05 -07:00
|
|
|
ptr += 3;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
ptr += (3 * (w - (ie->load_opts.region.x + ie->load_opts.region.w)));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ptr += (3 * w);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2009-09-21 05:49:31 -07:00
|
|
|
/*
|
|
|
|
t = get_time() - t;
|
|
|
|
printf("%3.3f\n", t);
|
|
|
|
*/
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2009-05-05 14:48:50 -07:00
|
|
|
/* We finally handle RGB with 1 component */
|
2006-01-14 12:03:42 -08:00
|
|
|
else if (cinfo.output_components == 1)
|
|
|
|
{
|
|
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
|
|
line[i] = data + (i * w);
|
|
|
|
for (l = 0; l < h; l += cinfo.rec_outbuf_height)
|
|
|
|
{
|
|
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
|
|
scans = cinfo.rec_outbuf_height;
|
|
|
|
if ((h - l) < scans) scans = h - l;
|
|
|
|
ptr = data;
|
2009-09-20 07:31:48 -07:00
|
|
|
if (!region)
|
|
|
|
{
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
2010-06-07 22:39:46 -07:00
|
|
|
*ptr2 = ARGB_JOIN(0xff, ptr[0], ptr[0], ptr[0]);
|
2009-09-20 07:31:48 -07:00
|
|
|
ptr++;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2009-09-20 07:31:48 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// if line # > region last line, break
|
|
|
|
if (l >= (ie->load_opts.region.y + ie->load_opts.region.h))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2009-09-20 07:31:48 -07:00
|
|
|
}
|
|
|
|
// els if scan block intersects region start or later
|
|
|
|
else if ((l + scans) >
|
|
|
|
(ie->load_opts.region.y))
|
|
|
|
{
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
if (((y + l) >= ie->load_opts.region.y) &&
|
|
|
|
((y + l) < (ie->load_opts.region.y + ie->load_opts.region.h)))
|
|
|
|
{
|
|
|
|
ptr += ie->load_opts.region.x;
|
|
|
|
for (x = 0; x < ie->load_opts.region.w; x++)
|
|
|
|
{
|
2010-06-07 22:39:46 -07:00
|
|
|
*ptr2 = ARGB_JOIN(0xff, ptr[0], ptr[0], ptr[0]);
|
2009-09-20 07:31:48 -07:00
|
|
|
ptr++;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
ptr += w - (ie->load_opts.region.x + ie->load_opts.region.w);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ptr += w;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* end data decoding */
|
|
|
|
jpeg_finish_decompress(&cinfo);
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0 /* not used at the moment */
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool
|
|
|
|
evas_image_load_file_data_jpeg_alpha_internal(Image_Entry *ie, FILE *f, int *error)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
int w, h;
|
|
|
|
struct jpeg_decompress_struct cinfo;
|
|
|
|
struct _JPEG_error_mgr jerr;
|
|
|
|
DATA8 *ptr, *line[16], *data;
|
|
|
|
DATA32 *ptr2;
|
2010-07-31 09:57:09 -07:00
|
|
|
int x, y, l, i, scans, prevy;
|
2006-01-14 12:03:42 -08:00
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
if (!f)
|
|
|
|
{
|
|
|
|
*error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
cinfo.err = jpeg_std_error(&(jerr.pub));
|
|
|
|
jerr.pub.error_exit = _JPEGFatalErrorHandler;
|
|
|
|
jerr.pub.emit_message = _JPEGErrorHandler2;
|
|
|
|
jerr.pub.output_message = _JPEGErrorHandler;
|
|
|
|
if (setjmp(jerr.setjmp_buffer))
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_CORRUPT_FILE;
|
|
|
|
return EINA_FALSE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
jpeg_stdio_src(&cinfo, f);
|
|
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
|
|
cinfo.do_fancy_upsampling = FALSE;
|
|
|
|
cinfo.do_block_smoothing = FALSE;
|
|
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
|
|
|
|
/* head decoding */
|
2008-06-03 02:09:39 -07:00
|
|
|
ie->w = w = cinfo.output_width;
|
|
|
|
ie->h = h = cinfo.output_height;
|
2006-01-14 12:03:42 -08:00
|
|
|
/* end head decoding */
|
|
|
|
/* data decoding */
|
|
|
|
if (cinfo.rec_outbuf_height > 16)
|
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
|
|
|
|
return EINA_FALSE;;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
data = alloca(w * 16 * 3);
|
2008-06-03 02:09:39 -07:00
|
|
|
if (!ie->flags.loaded)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
2008-06-03 02:09:39 -07:00
|
|
|
ptr2 = evas_cache_image_pixels(ie);
|
2006-01-14 12:03:42 -08:00
|
|
|
prevy = 0;
|
|
|
|
if (cinfo.output_components == 3)
|
|
|
|
{
|
|
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
|
|
line[i] = data + (i * w * 3);
|
|
|
|
for (l = 0; l < h; l += cinfo.rec_outbuf_height)
|
|
|
|
{
|
|
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
|
|
scans = cinfo.rec_outbuf_height;
|
|
|
|
if ((h - l) < scans) scans = h - l;
|
|
|
|
ptr = data;
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
|
|
|
*ptr2 =
|
|
|
|
((*ptr2) & 0x00ffffff) |
|
|
|
|
(((ptr[0] + ptr[1] + ptr[2]) / 3) << 24);
|
|
|
|
ptr += 3;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (cinfo.output_components == 1)
|
|
|
|
{
|
|
|
|
for (i = 0; i < cinfo.rec_outbuf_height; i++)
|
|
|
|
line[i] = data + (i * w);
|
|
|
|
for (l = 0; l < h; l += cinfo.rec_outbuf_height)
|
|
|
|
{
|
|
|
|
jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
|
|
|
|
scans = cinfo.rec_outbuf_height;
|
|
|
|
if ((h - l) < scans) scans = h - l;
|
|
|
|
ptr = data;
|
|
|
|
for (y = 0; y < scans; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
{
|
|
|
|
*ptr2 =
|
|
|
|
((*ptr2) & 0x00ffffff) |
|
|
|
|
((ptr[0]) << 24);
|
|
|
|
ptr++;
|
|
|
|
ptr2++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* end data decoding */
|
|
|
|
jpeg_finish_decompress(&cinfo);
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
2009-12-22 15:11:57 -08:00
|
|
|
*error = EVAS_LOAD_ERROR_NONE;
|
|
|
|
return EINA_TRUE;
|
2006-01-14 12:03:42 -08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool
|
|
|
|
evas_image_load_file_head_jpeg(Image_Entry *ie, const char *file, const char *key, int *error)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
int val;
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
f = fopen(file, "rb");
|
2009-12-22 15:11:57 -08:00
|
|
|
if (!f)
|
|
|
|
{
|
|
|
|
*error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
val = evas_image_load_file_head_jpeg_internal(ie, f, error);
|
2006-01-14 12:03:42 -08:00
|
|
|
fclose(f);
|
|
|
|
return val;
|
|
|
|
key = 0;
|
|
|
|
}
|
|
|
|
|
2009-12-22 15:11:57 -08:00
|
|
|
static Eina_Bool
|
|
|
|
evas_image_load_file_data_jpeg(Image_Entry *ie, const char *file, const char *key, int *error)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
int val;
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
f = fopen(file, "rb");
|
2009-12-22 15:11:57 -08:00
|
|
|
if (!f)
|
|
|
|
{
|
|
|
|
*error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
val = evas_image_load_file_data_jpeg_internal(ie, f, error);
|
2006-01-14 12:03:42 -08:00
|
|
|
fclose(f);
|
|
|
|
return val;
|
|
|
|
key = 0;
|
|
|
|
}
|
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static int
|
2006-09-06 00:28:46 -07:00
|
|
|
module_open(Evas_Module *em)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
if (!em) return 0;
|
|
|
|
em->functions = (void *)(&evas_image_load_jpeg_func);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static void
|
cleanup: fix some "unused" errors from -Wextra.
As we're heading for a release we better remove as much errors as
possible and as the first step I'm removing warnings due unused
parameters, variables and functions. These tend to pollute real errors
spotted by -Wall and clang/llvm.
This does not fixes all, just the clear that could be set to
__UNUSED__, particularly to do (and I'd like some help from the
authors):
* src/lib/engines/common/evas_font_{draw,query}.c (tasn):
intl_props is just used while doing BIDI, but also used in other
#ifdef blocks :-/
* evas_map_* (raster):
huge amount of warnings, code is quite confusing and thus I'm not
touching it. I have no idea whenever the commented blocks or extra
parameters are intended to be used or no.
* src/modules/engines/fbevas_fb_main.c (raster?):
is fb_setvt() to be used? If not do you mind removing it?
* src/modules/engines/gl_{common,x11} (raster):
huge amount of warnings, code is quite nested and full of #ifdefs
that does not help to give a clear picture of what's going on.
* src/bin/evas_cserve_main.c (raster):
I could have ignored most of the errors, but is the code correct? I
mean, there is no unload of images being applied. If you confirm
none of those warnings are harmful I can flag them as unused.
* src/lib/engines/common_8 (dottedmag):
lots of unused functions that were acquired from common_16, they
are unused and if they will not, then they should be removed.
SVN revision: 52421
2010-09-18 12:17:41 -07:00
|
|
|
module_close(Evas_Module *em __UNUSED__)
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-06-16 06:01:36 -07:00
|
|
|
static Evas_Module_Api evas_modapi =
|
2006-01-14 12:03:42 -08:00
|
|
|
{
|
|
|
|
EVAS_MODULE_API_VERSION,
|
2009-06-16 06:01:36 -07:00
|
|
|
"jpeg",
|
|
|
|
"none",
|
|
|
|
{
|
|
|
|
module_open,
|
|
|
|
module_close
|
|
|
|
}
|
2006-01-14 12:03:42 -08:00
|
|
|
};
|
2009-06-16 06:01:36 -07:00
|
|
|
|
|
|
|
EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_IMAGE_LOADER, image_loader, jpeg);
|
|
|
|
|
|
|
|
#ifndef EVAS_STATIC_BUILD_JPEG
|
|
|
|
EVAS_EINA_MODULE_DEFINE(image_loader, jpeg);
|
|
|
|
#endif
|
|
|
|
|