python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-01-12 10:16:17 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #221 from wiredfool/jpeg_memoryleak

Browse Source 
Jpeg Decode memory leak fix.
This commit is contained in:
Alex Clark ☺ 2013-05-16 12:42:45 -07:00
commit aea9570a2c
4 changed files with 252 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
PIL/ImageFile.py
View File

@ -209,6 +209,10 @@ class ImageFile(Image.Image):
if not s: # truncated jpeg
self.tile = []
# JpegDecode needs to clean things up here either way
# If we don't destroy the decompressor, we have a memory leak.
d.cleanup()
if LOAD_TRUNCATED_IMAGES:
break
else:

240
decode.c
View File

@ -41,13 +41,14 @@
/* -------------------------------------------------------------------- */
/* Common */
/* Common */
/* -------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
int (*decode)(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
UINT8* buffer, int bytes);
int (*cleanup)(ImagingCodecState state);
struct ImagingCodecStateInstance state;
Imaging im;
PyObject* lock;
@ -66,21 +67,21 @@ PyImaging_DecoderNew(int contextsize)
decoder = PyObject_New(ImagingDecoderObject, &ImagingDecoderType);
if (decoder == NULL)
return NULL;
return NULL;
/* Clear the decoder state */
memset(&decoder->state, 0, sizeof(decoder->state));
/* Allocate decoder context */
if (contextsize > 0) {
context = (void*) calloc(1, contextsize);
if (!context) {
Py_DECREF(decoder);
(void) PyErr_NoMemory();
return NULL;
}
context = (void*) calloc(1, contextsize);
if (!context) {
Py_DECREF(decoder);
(void) PyErr_NoMemory();
return NULL;
}
} else
context = 0;
context = 0;
/* Initialize decoder context */
decoder->state.context = context;
@ -88,6 +89,9 @@ PyImaging_DecoderNew(int contextsize)
/* Target image */
decoder->lock = NULL;
decoder->im = NULL;
/* Initialize the cleanup function pointer */
decoder->cleanup = NULL;
return decoder;
}
@ -108,13 +112,27 @@ _decode(ImagingDecoderObject* decoder, PyObject* args)
int bufsize, status;
if (!PyArg_ParseTuple(args, PY_ARG_BYTES_LENGTH, &buffer, &bufsize))
return NULL;
return NULL;
status = decoder->decode(decoder->im, &decoder->state, buffer, bufsize);
return Py_BuildValue("ii", status, decoder->state.errcode);
}
static PyObject*
_decode_cleanup(ImagingDecoderObject* decoder, PyObject* args)
{
int status = 0;
if (decoder->cleanup){
status = decoder->cleanup(&decoder->state);
}
return Py_BuildValue("i", status);
}
extern Imaging PyImaging_AsImaging(PyObject *op);
static PyObject*
@ -129,10 +147,10 @@ _setimage(ImagingDecoderObject* decoder, PyObject* args)
/* FIXME: should publish the ImagingType descriptor */
if (!PyArg_ParseTuple(args, "O|(iiii)", &op, &x0, &y0, &x1, &y1))
return NULL;
return NULL;
im = PyImaging_AsImaging(op);
if (!im)
return NULL;
return NULL;
decoder->im = im;
@ -140,30 +158,30 @@ _setimage(ImagingDecoderObject* decoder, PyObject* args)
/* Setup decoding tile extent */
if (x0 == 0 && x1 == 0) {
state->xsize = im->xsize;
state->ysize = im->ysize;
state->xsize = im->xsize;
state->ysize = im->ysize;
} else {
state->xoff = x0;
state->yoff = y0;
state->xsize = x1 - x0;
state->ysize = y1 - y0;
state->xoff = x0;
state->yoff = y0;
state->xsize = x1 - x0;
state->ysize = y1 - y0;
}
if (state->xsize <= 0 ||
state->xsize + state->xoff > (int) im->xsize ||
state->ysize <= 0 ||
state->ysize + state->yoff > (int) im->ysize) {
PyErr_SetString(PyExc_ValueError, "tile cannot extend outside image");
return NULL;
state->xsize + state->xoff > (int) im->xsize ||
state->ysize <= 0 ||
state->ysize + state->yoff > (int) im->ysize) {
PyErr_SetString(PyExc_ValueError, "tile cannot extend outside image");
return NULL;
}
/* Allocate memory buffer (if bits field is set) */
if (state->bits > 0) {
if (!state->bytes)
state->bytes = (state->bits * state->xsize+7)/8;
state->buffer = (UINT8*) malloc(state->bytes);
if (!state->buffer)
return PyErr_NoMemory();
state->buffer = (UINT8*) malloc(state->bytes);
if (!state->buffer)
return PyErr_NoMemory();
}
/* Keep a reference to the image object, to make sure it doesn't
@ -178,18 +196,19 @@ _setimage(ImagingDecoderObject* decoder, PyObject* args)
static struct PyMethodDef methods[] = {
{"decode", (PyCFunction)_decode, 1},
{"cleanup", (PyCFunction)_decode_cleanup, 1},
{"setimage", (PyCFunction)_setimage, 1},
{NULL, NULL} /* sentinel */
};
static PyTypeObject ImagingDecoderType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ImagingDecoder", /*tp_name*/
sizeof(ImagingDecoderObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
(destructor)_dealloc, /*tp_dealloc*/
0, /*tp_print*/
PyVarObject_HEAD_INIT(NULL, 0)
"ImagingDecoder", /*tp_name*/
sizeof(ImagingDecoderObject), /*tp_size*/
0, /*tp_itemsize*/
/* methods */
(destructor)_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
@ -227,9 +246,9 @@ get_unpacker(ImagingDecoderObject* decoder, const char* mode,
unpack = ImagingFindUnpacker(mode, rawmode, &bits);
if (!unpack) {
Py_DECREF(decoder);
PyErr_SetString(PyExc_ValueError, "unknown raw mode");
return -1;
Py_DECREF(decoder);
PyErr_SetString(PyExc_ValueError, "unknown raw mode");
return -1;
}
decoder->state.shuffle = unpack;
@ -240,7 +259,7 @@ get_unpacker(ImagingDecoderObject* decoder, const char* mode,
/* -------------------------------------------------------------------- */
/* BIT (packed fields) */
/* BIT (packed fields) */
/* -------------------------------------------------------------------- */
PyObject*
@ -256,16 +275,16 @@ PyImaging_BitDecoderNew(PyObject* self, PyObject* args)
int ystep = 1;
if (!PyArg_ParseTuple(args, "s|iiiii", &mode, &bits, &pad, &fill,
&sign, &ystep))
return NULL;
return NULL;
if (strcmp(mode, "F") != 0) {
PyErr_SetString(PyExc_ValueError, "bad image mode");
PyErr_SetString(PyExc_ValueError, "bad image mode");
return NULL;
}
decoder = PyImaging_DecoderNew(sizeof(BITSTATE));
if (decoder == NULL)
return NULL;
return NULL;
decoder->decode = ImagingBitDecode;
@ -281,7 +300,7 @@ PyImaging_BitDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* FLI */
/* FLI */
/* -------------------------------------------------------------------- */
PyObject*
@ -291,7 +310,7 @@ PyImaging_FliDecoderNew(PyObject* self, PyObject* args)
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
decoder->decode = ImagingFliDecode;
@ -300,7 +319,7 @@ PyImaging_FliDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* GIF */
/* GIF */
/* -------------------------------------------------------------------- */
PyObject*
@ -312,16 +331,16 @@ PyImaging_GifDecoderNew(PyObject* self, PyObject* args)
int bits = 8;
int interlace = 0;
if (!PyArg_ParseTuple(args, "s|ii", &mode, &bits, &interlace))
return NULL;
return NULL;
if (strcmp(mode, "L") != 0 && strcmp(mode, "P") != 0) {
PyErr_SetString(PyExc_ValueError, "bad image mode");
PyErr_SetString(PyExc_ValueError, "bad image mode");
return NULL;
}
decoder = PyImaging_DecoderNew(sizeof(GIFDECODERSTATE));
if (decoder == NULL)
return NULL;
return NULL;
decoder->decode = ImagingGifDecode;
@ -333,7 +352,7 @@ PyImaging_GifDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* HEX */
/* HEX */
/* -------------------------------------------------------------------- */
PyObject*
@ -344,14 +363,14 @@ PyImaging_HexDecoderNew(PyObject* self, PyObject* args)
char* mode;
char* rawmode;
if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingHexDecode;
@ -360,7 +379,7 @@ PyImaging_HexDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* LZW */
/* LZW */
/* -------------------------------------------------------------------- */
PyObject*
@ -372,14 +391,14 @@ PyImaging_TiffLzwDecoderNew(PyObject* self, PyObject* args)
char* rawmode;
int filter = 0;
if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &filter))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(sizeof(LZWSTATE));
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingLzwDecode;
@ -389,7 +408,7 @@ PyImaging_TiffLzwDecoderNew(PyObject* self, PyObject* args)
}
/* -------------------------------------------------------------------- */
/* LibTiff */
/* LibTiff */
/* -------------------------------------------------------------------- */
#ifdef HAVE_LIBTIFF
@ -409,17 +428,17 @@ PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args)
char* rawmode;
char* compname;
int compression;
int fp;
int fp;
if (! PyArg_ParseTuple(args, "sssi", &mode, &rawmode, &compname, &fp))
return NULL;
return NULL;
TRACE(("new tiff decoder %s\n", compname));
/* UNDONE -- we can probably do almost any arbitrary compression here,
* since we're effective passing in the whole file in one shot and
* getting back the data row by row. V2 maybe
*/
/* UNDONE -- we can probably do almost any arbitrary compression here,
* since we're effective passing in the whole file in one shot and
* getting back the data row by row. V2 maybe
*/
if (strcasecmp(compname, "tiff_ccitt") == 0) {
compression = COMPRESSION_CCITTRLE;
@ -459,7 +478,7 @@ PyImaging_LibTiffDecoderNew(PyObject* self, PyObject* args)
#endif
/* -------------------------------------------------------------------- */
/* MSP */
/* MSP */
/* -------------------------------------------------------------------- */
PyObject*
@ -469,10 +488,10 @@ PyImaging_MspDecoderNew(PyObject* self, PyObject* args)
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, "1", "1") < 0)
return NULL;
return NULL;
decoder->decode = ImagingMspDecode;
@ -481,7 +500,7 @@ PyImaging_MspDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* PackBits */
/* PackBits */
/* -------------------------------------------------------------------- */
PyObject*
@ -492,14 +511,14 @@ PyImaging_PackbitsDecoderNew(PyObject* self, PyObject* args)
char* mode;
char* rawmode;
if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingPackbitsDecode;
@ -508,7 +527,7 @@ PyImaging_PackbitsDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* PCD */
/* PCD */
/* -------------------------------------------------------------------- */
PyObject*
@ -518,11 +537,11 @@ PyImaging_PcdDecoderNew(PyObject* self, PyObject* args)
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
/* Unpack from PhotoYCC to RGB */
if (get_unpacker(decoder, "RGB", "YCC;P") < 0)
return NULL;
return NULL;
decoder->decode = ImagingPcdDecode;
@ -531,7 +550,7 @@ PyImaging_PcdDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* PCX */
/* PCX */
/* -------------------------------------------------------------------- */
PyObject*
@ -543,14 +562,14 @@ PyImaging_PcxDecoderNew(PyObject* self, PyObject* args)
char* rawmode;
int stride;
if (!PyArg_ParseTuple(args, "ssi", &mode, &rawmode, &stride))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->state.bytes = stride;
@ -561,7 +580,7 @@ PyImaging_PcxDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* RAW */
/* RAW */
/* -------------------------------------------------------------------- */
PyObject*
@ -574,14 +593,14 @@ PyImaging_RawDecoderNew(PyObject* self, PyObject* args)
int stride = 0;
int ystep = 1;
if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &stride, &ystep))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(sizeof(RAWSTATE));
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingRawDecode;
@ -594,7 +613,7 @@ PyImaging_RawDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* SUN RLE */
/* SUN RLE */
/* -------------------------------------------------------------------- */
PyObject*
@ -605,14 +624,14 @@ PyImaging_SunRleDecoderNew(PyObject* self, PyObject* args)
char* mode;
char* rawmode;
if (!PyArg_ParseTuple(args, "ss", &mode, &rawmode))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingSunRleDecode;
@ -621,7 +640,7 @@ PyImaging_SunRleDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* TGA RLE */
/* TGA RLE */
/* -------------------------------------------------------------------- */
PyObject*
@ -634,14 +653,14 @@ PyImaging_TgaRleDecoderNew(PyObject* self, PyObject* args)
int ystep = 1;
int depth = 8;
if (!PyArg_ParseTuple(args, "ss|ii", &mode, &rawmode, &ystep, &depth))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingTgaRleDecode;
@ -653,7 +672,7 @@ PyImaging_TgaRleDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* XBM */
/* XBM */
/* -------------------------------------------------------------------- */
PyObject*
@ -663,10 +682,10 @@ PyImaging_XbmDecoderNew(PyObject* self, PyObject* args)
decoder = PyImaging_DecoderNew(0);
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, "1", "1;R") < 0)
return NULL;
return NULL;
decoder->decode = ImagingXbmDecode;
@ -675,7 +694,7 @@ PyImaging_XbmDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* ZIP */
/* ZIP */
/* -------------------------------------------------------------------- */
#ifdef HAVE_LIBZ
@ -691,14 +710,14 @@ PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
char* rawmode;
int interlaced = 0;
if (!PyArg_ParseTuple(args, "ss|i", &mode, &rawmode, &interlaced))
return NULL;
return NULL;
decoder = PyImaging_DecoderNew(sizeof(ZIPSTATE));
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingZipDecode;
@ -710,7 +729,7 @@ PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
/* -------------------------------------------------------------------- */
/* JPEG */
/* JPEG */
/* -------------------------------------------------------------------- */
#ifdef HAVE_LIBJPEG
@ -718,15 +737,15 @@ PyImaging_ZipDecoderNew(PyObject* self, PyObject* args)
/* We better define this decoder last in this file, so the following
undef's won't mess things up for the Imaging library proper. */
#undef HAVE_PROTOTYPES
#undef HAVE_STDDEF_H
#undef HAVE_STDLIB_H
#undef UINT8
#undef UINT16
#undef UINT32
#undef INT8
#undef INT16
#undef INT32
#undef HAVE_PROTOTYPES
#undef HAVE_STDDEF_H
#undef HAVE_STDLIB_H
#undef UINT8
#undef UINT16
#undef UINT32
#undef INT8
#undef INT16
#undef INT32
#include "Jpeg.h"
@ -742,19 +761,20 @@ PyImaging_JpegDecoderNew(PyObject* self, PyObject* args)
int draft = 0;
if (!PyArg_ParseTuple(args, "ssz|ii", &mode, &rawmode, &jpegmode,
&scale, &draft))
return NULL;
return NULL;
if (!jpegmode)
jpegmode = "";
jpegmode = "";
decoder = PyImaging_DecoderNew(sizeof(JPEGSTATE));
if (decoder == NULL)
return NULL;
return NULL;
if (get_unpacker(decoder, mode, rawmode) < 0)
return NULL;
return NULL;
decoder->decode = ImagingJpegDecode;
decoder->cleanup = ImagingJpegDecodeCleanup;
strncpy(((JPEGSTATE*)decoder->state.context)->rawmode, rawmode, 8);
strncpy(((JPEGSTATE*)decoder->state.context)->jpegmode, jpegmode, 8);

2
libImaging/Imaging.h
View File

@ -417,6 +417,8 @@ extern int ImagingHexDecode(Imaging im, ImagingCodecState state,
#ifdef HAVE_LIBJPEG
extern int ImagingJpegDecode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
extern int ImagingJpegDecodeCleanup(ImagingCodecState state);
extern int ImagingJpegEncode(Imaging im, ImagingCodecState state,
UINT8* buffer, int bytes);
#endif

217
libImaging/JpegDecode.c
View File

@ -24,7 +24,7 @@
#include "Imaging.h"
#ifdef HAVE_LIBJPEG
#ifdef HAVE_LIBJPEG
#undef HAVE_PROTOTYPES
#undef HAVE_STDLIB_H
@ -39,7 +39,7 @@
/* -------------------------------------------------------------------- */
/* Suspending input handler */
/* Suspending input handler */
/* -------------------------------------------------------------------- */
METHODDEF(void)
@ -61,16 +61,16 @@ skip_input_data(j_decompress_ptr cinfo, long num_bytes)
JPEGSOURCE* source = (JPEGSOURCE*) cinfo->src;
if (num_bytes > (long) source->pub.bytes_in_buffer) {
/* We need to skip more data than we have in the buffer.
This will force the JPEG library to suspend decoding. */
source->skip = num_bytes - source->pub.bytes_in_buffer;
source->pub.next_input_byte += source->pub.bytes_in_buffer;
source->pub.bytes_in_buffer = 0;
/* We need to skip more data than we have in the buffer.
This will force the JPEG library to suspend decoding. */
source->skip = num_bytes - source->pub.bytes_in_buffer;
source->pub.next_input_byte += source->pub.bytes_in_buffer;
source->pub.bytes_in_buffer = 0;
} else {
/* Skip portion of the buffer */
source->pub.bytes_in_buffer -= num_bytes;
source->pub.next_input_byte += num_bytes;
source->skip = 0;
/* Skip portion of the buffer */
source->pub.bytes_in_buffer -= num_bytes;
source->pub.next_input_byte += num_bytes;
source->skip = 0;
}
}
@ -93,7 +93,7 @@ jpeg_buffer_src(j_decompress_ptr cinfo, JPEGSOURCE* source)
/* -------------------------------------------------------------------- */
/* Error handler */
/* Error handler */
/* -------------------------------------------------------------------- */
METHODDEF(void)
@ -111,7 +111,7 @@ output(j_common_ptr cinfo)
}
/* -------------------------------------------------------------------- */
/* Decoder */
/* Decoder */
/* -------------------------------------------------------------------- */
int
@ -121,23 +121,23 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
int ok;
if (setjmp(context->error.setjmp_buffer)) {
/* JPEG error handler */
jpeg_destroy_decompress(&context->cinfo);
state->errcode = IMAGING_CODEC_BROKEN;
return -1;
/* JPEG error handler */
jpeg_destroy_decompress(&context->cinfo);
state->errcode = IMAGING_CODEC_BROKEN;
return -1;
}
if (!state->state) {
/* Setup decompression context */
context->cinfo.err = jpeg_std_error(&context->error.pub);
context->error.pub.error_exit = error;
context->error.pub.output_message = output;
jpeg_create_decompress(&context->cinfo);
jpeg_buffer_src(&context->cinfo, &context->source);
/* Setup decompression context */
context->cinfo.err = jpeg_std_error(&context->error.pub);
context->error.pub.error_exit = error;
context->error.pub.output_message = output;
jpeg_create_decompress(&context->cinfo);
jpeg_buffer_src(&context->cinfo, &context->source);
/* Ready to decode */
state->state = 1;
/* Ready to decode */
state->state = 1;
}
@ -146,115 +146,115 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
context->source.pub.bytes_in_buffer = bytes;
if (context->source.skip > 0) {
skip_input_data(&context->cinfo, context->source.skip);
if (context->source.skip > 0)
return context->source.pub.next_input_byte - buf;
skip_input_data(&context->cinfo, context->source.skip);
if (context->source.skip > 0)
return context->source.pub.next_input_byte - buf;
}
switch (state->state) {
case 1:
/* Read JPEG header, until we find an image body. */
do {
/* Note that we cannot return unless we have decoded
as much data as possible. */
ok = jpeg_read_header(&context->cinfo, FALSE);
/* Read JPEG header, until we find an image body. */
do {
/* Note that we cannot return unless we have decoded
as much data as possible. */
ok = jpeg_read_header(&context->cinfo, FALSE);
} while (ok == JPEG_HEADER_TABLES_ONLY);
} while (ok == JPEG_HEADER_TABLES_ONLY);
if (ok == JPEG_SUSPENDED)
break;
if (ok == JPEG_SUSPENDED)
break;
/* Decoder settings */
/* Decoder settings */
/* jpegmode indicates whats in the file; if not set, we'll
trust the decoder */
if (strcmp(context->jpegmode, "L") == 0)
context->cinfo.jpeg_color_space = JCS_GRAYSCALE;
else if (strcmp(context->jpegmode, "RGB") == 0)
context->cinfo.jpeg_color_space = JCS_RGB;
else if (strcmp(context->jpegmode, "CMYK") == 0)
context->cinfo.jpeg_color_space = JCS_CMYK;
else if (strcmp(context->jpegmode, "YCbCr") == 0)
context->cinfo.jpeg_color_space = JCS_YCbCr;
else if (strcmp(context->jpegmode, "YCbCrK") == 0) {
context->cinfo.jpeg_color_space = JCS_YCCK;
}
/* jpegmode indicates whats in the file; if not set, we'll
trust the decoder */
if (strcmp(context->jpegmode, "L") == 0)
context->cinfo.jpeg_color_space = JCS_GRAYSCALE;
else if (strcmp(context->jpegmode, "RGB") == 0)
context->cinfo.jpeg_color_space = JCS_RGB;
else if (strcmp(context->jpegmode, "CMYK") == 0)
context->cinfo.jpeg_color_space = JCS_CMYK;
else if (strcmp(context->jpegmode, "YCbCr") == 0)
context->cinfo.jpeg_color_space = JCS_YCbCr;
else if (strcmp(context->jpegmode, "YCbCrK") == 0) {
context->cinfo.jpeg_color_space = JCS_YCCK;
}
/* rawmode indicates what we want from the decoder. if not
set, conversions are disabled */
if (strcmp(context->rawmode, "L") == 0)
context->cinfo.out_color_space = JCS_GRAYSCALE;
else if (strcmp(context->rawmode, "RGB") == 0)
context->cinfo.out_color_space = JCS_RGB;
else if (strcmp(context->rawmode, "CMYK") == 0 ||
/* rawmode indicates what we want from the decoder. if not
set, conversions are disabled */
if (strcmp(context->rawmode, "L") == 0)
context->cinfo.out_color_space = JCS_GRAYSCALE;
else if (strcmp(context->rawmode, "RGB") == 0)
context->cinfo.out_color_space = JCS_RGB;
else if (strcmp(context->rawmode, "CMYK") == 0 ||
strcmp(context->rawmode, "CMYK;I") == 0)
context->cinfo.out_color_space = JCS_CMYK;
else if (strcmp(context->rawmode, "YCbCr") == 0)
context->cinfo.out_color_space = JCS_YCbCr;
else if (strcmp(context->rawmode, "YCbCrK") == 0)
context->cinfo.out_color_space = JCS_YCCK;
else {
/* Disable decoder conversions */
context->cinfo.jpeg_color_space = JCS_UNKNOWN;
context->cinfo.out_color_space = JCS_UNKNOWN;
}
context->cinfo.out_color_space = JCS_CMYK;
else if (strcmp(context->rawmode, "YCbCr") == 0)
context->cinfo.out_color_space = JCS_YCbCr;
else if (strcmp(context->rawmode, "YCbCrK") == 0)
context->cinfo.out_color_space = JCS_YCCK;
else {
/* Disable decoder conversions */
context->cinfo.jpeg_color_space = JCS_UNKNOWN;
context->cinfo.out_color_space = JCS_UNKNOWN;
}
if (context->scale > 1) {
context->cinfo.scale_num = 1;
context->cinfo.scale_denom = context->scale;
}
if (context->draft) {
context->cinfo.do_fancy_upsampling = FALSE;
context->cinfo.dct_method = JDCT_FASTEST;
}
if (context->scale > 1) {
context->cinfo.scale_num = 1;
context->cinfo.scale_denom = context->scale;
}
if (context->draft) {
context->cinfo.do_fancy_upsampling = FALSE;
context->cinfo.dct_method = JDCT_FASTEST;
}
state->state++;
/* fall through */
/* fall through */
case 2:
/* Set things up for decompression (this processes the entire
file if necessary to return data line by line) */
if (!jpeg_start_decompress(&context->cinfo))
if (!jpeg_start_decompress(&context->cinfo))
break;
state->state++;
/* fall through */
state->state++;
/* fall through */
case 3:
/* Decompress a single line of data */
ok = 1;
while (state->y < state->ysize) {
ok = jpeg_read_scanlines(&context->cinfo, &state->buffer, 1);
if (ok != 1)
break;
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->xsize);
state->y++;
}
if (ok != 1)
break;
state->state++;
/* fall through */
/* Decompress a single line of data */
ok = 1;
while (state->y < state->ysize) {
ok = jpeg_read_scanlines(&context->cinfo, &state->buffer, 1);
if (ok != 1)
break;
state->shuffle((UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->buffer,
state->xsize);
state->y++;
}
if (ok != 1)
break;
state->state++;
/* fall through */
case 4:
/* Finish decompression */
if (!jpeg_finish_decompress(&context->cinfo)) {
/* Finish decompression */
if (!jpeg_finish_decompress(&context->cinfo)) {
/* FIXME: add strictness mode test */
if (state->y < state->ysize)
break;
}
/* Clean up */
jpeg_destroy_decompress(&context->cinfo);
/* if (jerr.pub.num_warnings) return BROKEN; */
return -1;
/* Clean up */
jpeg_destroy_decompress(&context->cinfo);
/* if (jerr.pub.num_warnings) return BROKEN; */
return -1;
}
@ -263,5 +263,20 @@ ImagingJpegDecode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
int ImagingJpegDecodeCleanup(ImagingCodecState state){
/* called to fee the decompression engine when the decode terminates
due to a corrupt or truncated image
*/
JPEGSTATE* context = (JPEGSTATE*) state->context;
/* Clean up */
jpeg_destroy_decompress(&context->cinfo);
return -1;
}
#endif