diff options
Diffstat (limited to 'plugins/FreeImage/src/LibMNG/libmng_jpeg.c')
| -rw-r--r-- | plugins/FreeImage/src/LibMNG/libmng_jpeg.c | 1088 |
1 files changed, 1088 insertions, 0 deletions
diff --git a/plugins/FreeImage/src/LibMNG/libmng_jpeg.c b/plugins/FreeImage/src/LibMNG/libmng_jpeg.c new file mode 100644 index 0000000000..409f6df74d --- /dev/null +++ b/plugins/FreeImage/src/LibMNG/libmng_jpeg.c @@ -0,0 +1,1088 @@ +/* ************************************************************************** */
+/* * For conditions of distribution and use, * */
+/* * see copyright notice in libmng.h * */
+/* ************************************************************************** */
+/* * * */
+/* * project : libmng * */
+/* * file : libmng_jpeg.c copyright (c) 2000-2004 G.Juyn * */
+/* * version : 1.0.9 * */
+/* * * */
+/* * purpose : JPEG library interface (implementation) * */
+/* * * */
+/* * author : G.Juyn * */
+/* * * */
+/* * comment : implementation of the JPEG library interface * */
+/* * * */
+/* * changes : 0.5.1 - 05/08/2000 - G.Juyn * */
+/* * - changed strict-ANSI stuff * */
+/* * * */
+/* * 0.5.2 - 05/22/2000 - G.Juyn * */
+/* * - implemented all the JNG routines * */
+/* * * */
+/* * 0.5.3 - 06/17/2000 - G.Juyn * */
+/* * - added tracing of JPEG calls * */
+/* * 0.5.3 - 06/24/2000 - G.Juyn * */
+/* * - fixed inclusion of IJG read/write code * */
+/* * 0.5.3 - 06/29/2000 - G.Juyn * */
+/* * - fixed some 64-bit warnings * */
+/* * * */
+/* * 0.9.2 - 08/05/2000 - G.Juyn * */
+/* * - changed file-prefixes * */
+/* * * */
+/* * 0.9.3 - 10/16/2000 - G.Juyn * */
+/* * - added support for JDAA * */
+/* * * */
+/* * 1.0.1 - 04/19/2001 - G.Juyn * */
+/* * - added export of JPEG functions for DLL * */
+/* * 1.0.1 - 04/22/2001 - G.Juyn * */
+/* * - fixed memory-leaks (Thanks Gregg!) * */
+/* * * */
+/* * 1.0.4 - 06/22/2002 - G.Juyn * */
+/* * - B526138 - returned IJGSRC6B calling convention to * */
+/* * default for MSVC * */
+/* * * */
+/* * 1.0.5 - 24/02/2003 - G.Juyn * */
+/* * - B683152 - libjpeg suspension not always honored correctly* */
+/* * * */
+/* * 1.0.6 - 03/04/2003 - G.Juyn * */
+/* * - fixed some compiler-warnings * */
+/* * * */
+/* * 1.0.8 - 08/01/2004 - G.Juyn * */
+/* * - added support for 3+byte pixelsize for JPEG's * */
+/* * * */
+/* * 1.0.9 - 12/20/2004 - G.Juyn * */
+/* * - cleaned up macro-invocations (thanks to D. Airlie) * */
+/* * * */
+/* ************************************************************************** */
+
+#include "libmng.h"
+#include "libmng_data.h"
+#include "libmng_error.h"
+#include "libmng_trace.h"
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+#include "libmng_memory.h"
+#include "libmng_pixels.h"
+#include "libmng_jpeg.h"
+
+#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
+#pragma option -A /* force ANSI-C */
+#endif
+
+/* ************************************************************************** */
+
+#if defined(MNG_INCLUDE_JNG) && defined(MNG_INCLUDE_DISPLAY_PROCS)
+
+/* ************************************************************************** */
+/* * * */
+/* * Local IJG callback routines (source-manager, error-manager and such) * */
+/* * * */
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_IJG6B
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+#ifdef MNG_DEFINE_JPEG_STDCALL
+void MNG_DECL mng_init_source (j_decompress_ptr cinfo)
+#else
+void mng_init_source (j_decompress_ptr cinfo)
+#endif
+{
+ return; /* nothing needed */
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+#ifdef MNG_DEFINE_JPEG_STDCALL
+boolean MNG_DECL mng_fill_input_buffer (j_decompress_ptr cinfo)
+#else
+boolean mng_fill_input_buffer (j_decompress_ptr cinfo)
+#endif
+{
+ return FALSE; /* force IJG routine to return to caller */
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+#ifdef MNG_DEFINE_JPEG_STDCALL
+void MNG_DECL mng_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+#else
+void mng_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+#endif
+{
+ if (num_bytes > 0) /* ignore fony calls */
+ { /* address my generic structure */
+ mng_datap pData = (mng_datap)cinfo->client_data;
+ /* address source manager */
+ mngjpeg_sourcep pSrc = pData->pJPEGdinfo->src;
+ /* problem scenario ? */
+ if (pSrc->bytes_in_buffer < (size_t)num_bytes)
+ { /* tell the boss we need to skip some data! */
+ pData->iJPEGtoskip = (mng_uint32)((size_t)num_bytes - pSrc->bytes_in_buffer);
+
+ pSrc->bytes_in_buffer = 0; /* let the JPEG lib suspend */
+ pSrc->next_input_byte = MNG_NULL;
+ }
+ else
+ { /* simply advance in the buffer */
+ pSrc->bytes_in_buffer -= num_bytes;
+ pSrc->next_input_byte += num_bytes;
+ }
+ }
+
+ return;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+#ifdef MNG_DEFINE_JPEG_STDCALL
+void MNG_DECL mng_skip_input_data2 (j_decompress_ptr cinfo, long num_bytes)
+#else
+void mng_skip_input_data2 (j_decompress_ptr cinfo, long num_bytes)
+#endif
+{
+ if (num_bytes > 0) /* ignore fony calls */
+ { /* address my generic structure */
+ mng_datap pData = (mng_datap)cinfo->client_data;
+ /* address source manager */
+ mngjpeg_sourcep pSrc = pData->pJPEGdinfo2->src;
+ /* problem scenario ? */
+ if (pSrc->bytes_in_buffer < (size_t)num_bytes)
+ { /* tell the boss we need to skip some data! */
+ pData->iJPEGtoskip2 = (mng_uint32)((size_t)num_bytes - pSrc->bytes_in_buffer);
+
+ pSrc->bytes_in_buffer = 0; /* let the JPEG lib suspend */
+ pSrc->next_input_byte = MNG_NULL;
+ }
+ else
+ { /* simply advance in the buffer */
+ pSrc->bytes_in_buffer -= num_bytes;
+ pSrc->next_input_byte += num_bytes;
+ }
+ }
+
+ return;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+#ifdef MNG_DEFINE_JPEG_STDCALL
+void MNG_DECL mng_term_source (j_decompress_ptr cinfo)
+#else
+void mng_term_source (j_decompress_ptr cinfo)
+#endif
+{
+ return; /* nothing needed */
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_USE_SETJMP
+#ifdef MNG_DEFINE_JPEG_STDCALL
+void MNG_DECL mng_error_exit (j_common_ptr cinfo)
+#else
+void mng_error_exit (j_common_ptr cinfo)
+#endif
+{ /* address my generic structure */
+ mng_datap pData = (mng_datap)cinfo->client_data;
+
+#ifdef MNG_ERROR_TELLTALE /* fill the message text ??? */
+ (*cinfo->err->output_message) (cinfo);
+#endif
+ /* return to the point of no return... */
+ longjmp (pData->sErrorbuf, cinfo->err->msg_code);
+}
+#endif /* MNG_USE_SETJMP */
+
+/* ************************************************************************** */
+
+#ifdef MNG_USE_SETJMP
+#ifdef MNG_DEFINE_JPEG_STDCALL
+void MNG_DECL mng_output_message (j_common_ptr cinfo)
+#else
+void mng_output_message (j_common_ptr cinfo)
+#endif
+{
+ return; /* just do nothing ! */
+}
+#endif /* MNG_USE_SETJMP */
+
+/* ************************************************************************** */
+
+#endif /* MNG_INCLUDE_IJG6B */
+
+/* ************************************************************************** */
+/* * * */
+/* * Global JPEG routines * */
+/* * * */
+/* ************************************************************************** */
+
+mng_retcode mngjpeg_initialize (mng_datap pData)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_INITIALIZE, MNG_LC_START);
+#endif
+ /* allocate space for JPEG structures if necessary */
+#ifdef MNG_INCLUDE_JNG_READ
+ if (pData->pJPEGderr == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGderr, sizeof (mngjpeg_error ));
+ if (pData->pJPEGdsrc == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGdsrc, sizeof (mngjpeg_source));
+ if (pData->pJPEGdinfo == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGdinfo, sizeof (mngjpeg_decomp));
+ /* enable reverse addressing */
+ pData->pJPEGdinfo->client_data = pData;
+
+ if (pData->pJPEGderr2 == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGderr2, sizeof (mngjpeg_error ));
+ if (pData->pJPEGdsrc2 == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGdsrc2, sizeof (mngjpeg_source));
+ if (pData->pJPEGdinfo2 == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGdinfo2, sizeof (mngjpeg_decomp));
+ /* enable reverse addressing */
+ pData->pJPEGdinfo2->client_data = pData;
+#endif
+
+#ifdef MNG_INCLUDE_JNG_WRITE
+ if (pData->pJPEGcerr == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGcerr, sizeof (mngjpeg_error ));
+ if (pData->pJPEGcinfo == MNG_NULL)
+ MNG_ALLOC (pData, pData->pJPEGcinfo, sizeof (mngjpeg_comp ));
+ /* enable reverse addressing */
+ pData->pJPEGcinfo->client_data = pData;
+#endif
+
+ if (pData->pJPEGbuf == MNG_NULL) /* initialize temporary buffers */
+ {
+ pData->iJPEGbufmax = MNG_JPEG_MAXBUF;
+ MNG_ALLOC (pData, pData->pJPEGbuf, pData->iJPEGbufmax);
+ }
+
+ if (pData->pJPEGbuf2 == MNG_NULL)
+ {
+ pData->iJPEGbufmax2 = MNG_JPEG_MAXBUF;
+ MNG_ALLOC (pData, pData->pJPEGbuf2, pData->iJPEGbufmax2);
+ }
+
+ pData->pJPEGcurrent = pData->pJPEGbuf;
+ pData->iJPEGbufremain = 0;
+ pData->pJPEGrow = MNG_NULL;
+ pData->iJPEGrowlen = 0;
+ pData->iJPEGtoskip = 0;
+
+ pData->pJPEGcurrent2 = pData->pJPEGbuf2;
+ pData->iJPEGbufremain2 = 0;
+ pData->pJPEGrow2 = MNG_NULL;
+ pData->iJPEGrowlen2 = 0;
+ pData->iJPEGtoskip2 = 0;
+ /* not doing anything yet ! */
+ pData->bJPEGcompress = MNG_FALSE;
+
+ pData->bJPEGdecompress = MNG_FALSE;
+ pData->bJPEGhasheader = MNG_FALSE;
+ pData->bJPEGdecostarted = MNG_FALSE;
+ pData->bJPEGscanstarted = MNG_FALSE;
+ pData->bJPEGscanending = MNG_FALSE;
+
+ pData->bJPEGdecompress2 = MNG_FALSE;
+ pData->bJPEGhasheader2 = MNG_FALSE;
+ pData->bJPEGdecostarted2 = MNG_FALSE;
+ pData->bJPEGscanstarted2 = MNG_FALSE;
+
+ pData->iJPEGrow = 0; /* zero input/output lines */
+ pData->iJPEGalpharow = 0;
+ pData->iJPEGrgbrow = 0;
+ pData->iJPEGdisprow = 0;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_INITIALIZE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngjpeg_cleanup (mng_datap pData)
+{
+#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ mng_retcode iRetcode;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_CLEANUP, MNG_LC_START);
+#endif
+
+#ifdef MNG_INCLUDE_IJG6B
+#ifdef MNG_USE_SETJMP
+ iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif
+
+#ifdef MNG_INCLUDE_JNG_READ /* still decompressing something ? */
+ if (pData->bJPEGdecompress)
+ jpeg_destroy_decompress (pData->pJPEGdinfo);
+ if (pData->bJPEGdecompress2)
+ jpeg_destroy_decompress (pData->pJPEGdinfo2);
+#endif
+
+#ifdef MNG_INCLUDE_JNG_WRITE
+ if (pData->bJPEGcompress) /* still compressing something ? */
+ jpeg_destroy_compress (pData->pJPEGcinfo);
+#endif
+
+#endif /* MNG_INCLUDE_IJG6B */
+ /* cleanup temporary buffers */
+ MNG_FREE (pData, pData->pJPEGbuf2, pData->iJPEGbufmax2);
+ MNG_FREE (pData, pData->pJPEGbuf, pData->iJPEGbufmax);
+ /* cleanup space for JPEG structures */
+#ifdef MNG_INCLUDE_JNG_WRITE
+ MNG_FREE (pData, pData->pJPEGcinfo, sizeof (mngjpeg_comp ));
+ MNG_FREE (pData, pData->pJPEGcerr, sizeof (mngjpeg_error ));
+#endif
+
+#ifdef MNG_INCLUDE_JNG_READ
+ MNG_FREE (pData, pData->pJPEGdinfo, sizeof (mngjpeg_decomp));
+ MNG_FREE (pData, pData->pJPEGdsrc, sizeof (mngjpeg_source));
+ MNG_FREE (pData, pData->pJPEGderr, sizeof (mngjpeg_error ));
+ MNG_FREE (pData, pData->pJPEGdinfo2, sizeof (mngjpeg_decomp));
+ MNG_FREE (pData, pData->pJPEGdsrc2, sizeof (mngjpeg_source));
+ MNG_FREE (pData, pData->pJPEGderr2, sizeof (mngjpeg_error ));
+#endif
+
+ MNG_FREE (pData, pData->pJPEGrow2, pData->iJPEGrowlen2);
+ MNG_FREE (pData, pData->pJPEGrow, pData->iJPEGrowlen);
+ /* whatever we were doing ... */
+ /* we don't anymore ... */
+ pData->bJPEGcompress = MNG_FALSE;
+
+ pData->bJPEGdecompress = MNG_FALSE;
+ pData->bJPEGhasheader = MNG_FALSE;
+ pData->bJPEGdecostarted = MNG_FALSE;
+ pData->bJPEGscanstarted = MNG_FALSE;
+ pData->bJPEGscanending = MNG_FALSE;
+
+ pData->bJPEGdecompress2 = MNG_FALSE;
+ pData->bJPEGhasheader2 = MNG_FALSE;
+ pData->bJPEGdecostarted2 = MNG_FALSE;
+ pData->bJPEGscanstarted2 = MNG_FALSE;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_CLEANUP, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+/* * * */
+/* * JPEG decompression routines (JDAT) * */
+/* * * */
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+mng_retcode mngjpeg_decompressinit (mng_datap pData)
+{
+#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ mng_retcode iRetcode;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_START);
+#endif
+
+#ifdef MNG_INCLUDE_IJG6B
+ /* allocate and initialize a JPEG decompression object */
+ pData->pJPEGdinfo->err = jpeg_std_error (pData->pJPEGderr);
+
+#ifdef MNG_USE_SETJMP /* setup local JPEG error-routines */
+ pData->pJPEGderr->error_exit = mng_error_exit;
+ pData->pJPEGderr->output_message = mng_output_message;
+
+ iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif /* MNG_USE_SETJMP */
+
+ /* allocate and initialize a JPEG decompression object (continued) */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_JPEG_CREATE_DECOMPRESS)
+#endif
+ jpeg_create_decompress (pData->pJPEGdinfo);
+
+ pData->bJPEGdecompress = MNG_TRUE; /* indicate it's initialized */
+
+ /* specify the source of the compressed data (eg, a file) */
+ /* no, not a file; we have buffered input */
+ pData->pJPEGdinfo->src = pData->pJPEGdsrc;
+ /* use the default handler */
+ pData->pJPEGdinfo->src->resync_to_restart = jpeg_resync_to_restart;
+ /* setup local source routine & parms */
+ pData->pJPEGdinfo->src->init_source = mng_init_source;
+ pData->pJPEGdinfo->src->fill_input_buffer = mng_fill_input_buffer;
+ pData->pJPEGdinfo->src->skip_input_data = mng_skip_input_data;
+ pData->pJPEGdinfo->src->term_source = mng_term_source;
+ pData->pJPEGdinfo->src->next_input_byte = pData->pJPEGcurrent;
+ pData->pJPEGdinfo->src->bytes_in_buffer = pData->iJPEGbufremain;
+
+#endif /* MNG_INCLUDE_IJG6B */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+mng_retcode mngjpeg_decompressdata (mng_datap pData,
+ mng_uint32 iRawsize,
+ mng_uint8p pRawdata)
+{
+ mng_retcode iRetcode;
+ mng_uint32 iRemain;
+ mng_uint8p pWork;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_START);
+#endif
+
+#if defined (MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ iRetcode = setjmp (pData->sErrorbuf);/* initialize local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif
+
+ pWork = pRawdata;
+ iRemain = iRawsize;
+
+ if (pData->iJPEGtoskip) /* JPEG-lib told us to skip some more data ? */
+ {
+ if (iRemain > pData->iJPEGtoskip) /* enough data in this buffer ? */
+ {
+ iRemain -= pData->iJPEGtoskip; /* skip enough to access the next byte */
+ pWork += pData->iJPEGtoskip;
+
+ pData->iJPEGtoskip = 0; /* no more to skip then */
+ }
+ else
+ {
+ pData->iJPEGtoskip -= iRemain; /* skip all data in the buffer */
+ iRemain = 0; /* and indicate this accordingly */
+ }
+ /* the skip set current-pointer to NULL ! */
+ pData->pJPEGcurrent = pData->pJPEGbuf;
+ }
+
+ while (iRemain) /* repeat until no more input-bytes */
+ { /* need to shift anything ? */
+ if ((pData->pJPEGcurrent > pData->pJPEGbuf) &&
+ (pData->pJPEGcurrent - pData->pJPEGbuf + pData->iJPEGbufremain + iRemain > pData->iJPEGbufmax))
+ {
+ if (pData->iJPEGbufremain > 0) /* then do so */
+ MNG_COPY (pData->pJPEGbuf, pData->pJPEGcurrent, pData->iJPEGbufremain);
+
+ pData->pJPEGcurrent = pData->pJPEGbuf;
+ }
+ /* does the remaining input fit into the buffer ? */
+ if (pData->iJPEGbufremain + iRemain <= pData->iJPEGbufmax)
+ { /* move the lot */
+ MNG_COPY ((pData->pJPEGcurrent + pData->iJPEGbufremain), pWork, iRemain);
+
+ pData->iJPEGbufremain += iRemain;/* adjust remaining_bytes counter */
+ iRemain = 0; /* and indicate there's no input left */
+ }
+ else
+ { /* calculate what does fit */
+ mng_uint32 iFits = pData->iJPEGbufmax - pData->iJPEGbufremain;
+
+ if (iFits <= 0) /* no space is just bugger 'm all */
+ MNG_ERROR (pData, MNG_JPEGBUFTOOSMALL);
+ /* move that */
+ MNG_COPY ((pData->pJPEGcurrent + pData->iJPEGbufremain), pWork, iFits);
+
+ pData->iJPEGbufremain += iFits; /* adjust remain_bytes counter */
+ iRemain -= iFits; /* and the input-parms */
+ pWork += iFits;
+ }
+
+#ifdef MNG_INCLUDE_IJG6B
+ pData->pJPEGdinfo->src->next_input_byte = pData->pJPEGcurrent;
+ pData->pJPEGdinfo->src->bytes_in_buffer = pData->iJPEGbufremain;
+
+ if (!pData->bJPEGhasheader) /* haven't got the header yet ? */
+ {
+ /* call jpeg_read_header() to obtain image info */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_READ_HEADER)
+#endif
+ if (jpeg_read_header (pData->pJPEGdinfo, TRUE) != JPEG_SUSPENDED)
+ { /* indicate the header's oke */
+ pData->bJPEGhasheader = MNG_TRUE;
+ /* let's do some sanity checks ! */
+ if ((pData->pJPEGdinfo->image_width != pData->iDatawidth ) ||
+ (pData->pJPEGdinfo->image_height != pData->iDataheight) )
+ MNG_ERROR (pData, MNG_JPEGPARMSERR);
+
+ if ( ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAY ) ||
+ (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA) ) &&
+ (pData->pJPEGdinfo->jpeg_color_space != JCS_GRAYSCALE ) )
+ MNG_ERROR (pData, MNG_JPEGPARMSERR);
+
+ if ( ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLOR ) ||
+ (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) ) &&
+ (pData->pJPEGdinfo->jpeg_color_space != JCS_YCbCr ) )
+ MNG_ERROR (pData, MNG_JPEGPARMSERR);
+ /* indicate whether or not it's progressive */
+ pData->bJPEGprogressive = (mng_bool)jpeg_has_multiple_scans (pData->pJPEGdinfo);
+ /* progressive+alpha can't display "on-the-fly"!! */
+ if ((pData->bJPEGprogressive) &&
+ ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
+ (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) ))
+ pData->fDisplayrow = MNG_NULL;
+ /* allocate a row of JPEG-samples */
+ if (pData->pJPEGdinfo->jpeg_color_space == JCS_YCbCr)
+ pData->iJPEGrowlen = pData->pJPEGdinfo->image_width * RGB_PIXELSIZE;
+ else
+ pData->iJPEGrowlen = pData->pJPEGdinfo->image_width;
+
+ MNG_ALLOC (pData, pData->pJPEGrow, pData->iJPEGrowlen);
+
+ pData->iJPEGrgbrow = 0; /* quite empty up to now */
+ }
+
+ pData->pJPEGcurrent = (mng_uint8p)pData->pJPEGdinfo->src->next_input_byte;
+ pData->iJPEGbufremain = (mng_uint32)pData->pJPEGdinfo->src->bytes_in_buffer;
+ }
+ /* decompress not started ? */
+ if ((pData->bJPEGhasheader) && (!pData->bJPEGdecostarted))
+ {
+ /* set parameters for decompression */
+
+ if (pData->bJPEGprogressive) /* progressive display ? */
+ pData->pJPEGdinfo->buffered_image = TRUE;
+
+ /* jpeg_start_decompress(...); */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_START_DECOMPRESS)
+#endif
+ if (jpeg_start_decompress (pData->pJPEGdinfo) == TRUE)
+ /* indicate it started */
+ pData->bJPEGdecostarted = MNG_TRUE;
+
+ pData->pJPEGcurrent = (mng_uint8p)pData->pJPEGdinfo->src->next_input_byte;
+ pData->iJPEGbufremain = (mng_uint32)pData->pJPEGdinfo->src->bytes_in_buffer;
+ }
+ /* process some scanlines ? */
+ if ((pData->bJPEGhasheader) && (pData->bJPEGdecostarted) &&
+ ((!jpeg_input_complete (pData->pJPEGdinfo)) ||
+ (pData->pJPEGdinfo->output_scanline < pData->pJPEGdinfo->output_height) ||
+ ((pData->bJPEGprogressive) && (pData->bJPEGscanending))))
+ {
+ mng_int32 iLines = 0;
+
+ /* for (each output pass) */
+ do
+ { /* address the row output buffer */
+ JSAMPROW pRow = (JSAMPROW)pData->pJPEGrow;
+
+ /* init new pass ? */
+ if ((pData->bJPEGprogressive) && (!pData->bJPEGscanstarted))
+ {
+ pData->bJPEGscanstarted = MNG_TRUE;
+
+ /* adjust output decompression parameters if required */
+ /* nop */
+
+ /* start a new output pass */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_START_OUTPUT)
+#endif
+ jpeg_start_output (pData->pJPEGdinfo, pData->pJPEGdinfo->input_scan_number);
+
+ pData->iJPEGrow = 0; /* start at row 0 in the image again */
+ }
+
+ /* while (scan lines remain to be read) */
+ if ((!pData->bJPEGprogressive) || (!pData->bJPEGscanending))
+ {
+ do
+ {
+ /* jpeg_read_scanlines(...); */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_READ_SCANLINES)
+#endif
+ iLines = jpeg_read_scanlines (pData->pJPEGdinfo, (JSAMPARRAY)&pRow, 1);
+
+ pData->pJPEGcurrent = (mng_uint8p)pData->pJPEGdinfo->src->next_input_byte;
+ pData->iJPEGbufremain = (mng_uint32)pData->pJPEGdinfo->src->bytes_in_buffer;
+
+ if (iLines > 0) /* got something ? */
+ {
+ if (pData->fStorerow2) /* store in object ? */
+ {
+ iRetcode = ((mng_storerow)pData->fStorerow2) (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+ }
+ }
+ }
+ while ((pData->pJPEGdinfo->output_scanline < pData->pJPEGdinfo->output_height) &&
+ (iLines > 0)); /* until end-of-image or not enough input-data */
+ }
+
+ /* terminate output pass */
+ if ((pData->bJPEGprogressive) &&
+ (pData->pJPEGdinfo->output_scanline >= pData->pJPEGdinfo->output_height))
+ {
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_FINISH_OUTPUT)
+#endif
+ if (jpeg_finish_output (pData->pJPEGdinfo) != JPEG_SUSPENDED)
+ { /* this scan has ended */
+ pData->bJPEGscanstarted = MNG_FALSE;
+ pData->bJPEGscanending = MNG_FALSE;
+ }
+ else
+ {
+ pData->bJPEGscanending = MNG_TRUE;
+ }
+ }
+ }
+ while ((!jpeg_input_complete (pData->pJPEGdinfo)) &&
+ (iLines > 0) && (!pData->bJPEGscanending));
+ }
+ /* end of image ? */
+ if ((pData->bJPEGhasheader) && (pData->bJPEGdecostarted) &&
+ (!pData->bJPEGscanending) && (jpeg_input_complete (pData->pJPEGdinfo)) &&
+ (pData->pJPEGdinfo->input_scan_number == pData->pJPEGdinfo->output_scan_number))
+ {
+ /* jpeg_finish_decompress(...); */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_FINISH_DECOMPRESS)
+#endif
+ if (jpeg_finish_decompress (pData->pJPEGdinfo) == TRUE)
+ { /* indicate it's done */
+ pData->bJPEGhasheader = MNG_FALSE;
+ pData->bJPEGdecostarted = MNG_FALSE;
+ pData->pJPEGcurrent = (mng_uint8p)pData->pJPEGdinfo->src->next_input_byte;
+ pData->iJPEGbufremain = (mng_uint32)pData->pJPEGdinfo->src->bytes_in_buffer;
+ /* remaining fluff is an error ! */
+ if ((pData->iJPEGbufremain > 0) || (iRemain > 0))
+ MNG_ERROR (pData, MNG_TOOMUCHJDAT);
+ }
+ }
+#endif /* MNG_INCLUDE_IJG6B */
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+mng_retcode mngjpeg_decompressfree (mng_datap pData)
+{
+#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ mng_retcode iRetcode;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSFREE, MNG_LC_START);
+#endif
+
+#ifdef MNG_INCLUDE_IJG6B
+#ifdef MNG_USE_SETJMP
+ iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif
+ /* free the row of JPEG-samples*/
+ MNG_FREE (pData, pData->pJPEGrow, pData->iJPEGrowlen);
+
+ /* release the JPEG decompression object */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSFREE, MNG_LC_JPEG_DESTROY_DECOMPRESS)
+#endif
+ jpeg_destroy_decompress (pData->pJPEGdinfo);
+
+ pData->bJPEGdecompress = MNG_FALSE; /* indicate it's done */
+
+#endif /* MNG_INCLUDE_IJG6B */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSFREE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+/* * * */
+/* * JPEG decompression routines (JDAA) * */
+/* * * */
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+mng_retcode mngjpeg_decompressinit2 (mng_datap pData)
+{
+#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ mng_retcode iRetcode;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_START);
+#endif
+
+#ifdef MNG_INCLUDE_IJG6B
+ /* allocate and initialize a JPEG decompression object */
+ pData->pJPEGdinfo2->err = jpeg_std_error (pData->pJPEGderr2);
+
+#ifdef MNG_USE_SETJMP /* setup local JPEG error-routines */
+ pData->pJPEGderr2->error_exit = mng_error_exit;
+ pData->pJPEGderr2->output_message = mng_output_message;
+
+ iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif /* MNG_USE_SETJMP */
+
+ /* allocate and initialize a JPEG decompression object (continued) */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_JPEG_CREATE_DECOMPRESS)
+#endif
+ jpeg_create_decompress (pData->pJPEGdinfo2);
+
+ pData->bJPEGdecompress2 = MNG_TRUE; /* indicate it's initialized */
+
+ /* specify the source of the compressed data (eg, a file) */
+ /* no, not a file; we have buffered input */
+ pData->pJPEGdinfo2->src = pData->pJPEGdsrc2;
+ /* use the default handler */
+ pData->pJPEGdinfo2->src->resync_to_restart = jpeg_resync_to_restart;
+ /* setup local source routine & parms */
+ pData->pJPEGdinfo2->src->init_source = mng_init_source;
+ pData->pJPEGdinfo2->src->fill_input_buffer = mng_fill_input_buffer;
+ pData->pJPEGdinfo2->src->skip_input_data = mng_skip_input_data2;
+ pData->pJPEGdinfo2->src->term_source = mng_term_source;
+ pData->pJPEGdinfo2->src->next_input_byte = pData->pJPEGcurrent2;
+ pData->pJPEGdinfo2->src->bytes_in_buffer = pData->iJPEGbufremain2;
+
+#endif /* MNG_INCLUDE_IJG6B */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+mng_retcode mngjpeg_decompressdata2 (mng_datap pData,
+ mng_uint32 iRawsize,
+ mng_uint8p pRawdata)
+{
+ mng_retcode iRetcode;
+ mng_uint32 iRemain;
+ mng_uint8p pWork;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_START);
+#endif
+
+#if defined (MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ iRetcode = setjmp (pData->sErrorbuf);/* initialize local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif
+
+ pWork = pRawdata;
+ iRemain = iRawsize;
+
+ if (pData->iJPEGtoskip2) /* JPEG-lib told us to skip some more data ? */
+ {
+ if (iRemain > pData->iJPEGtoskip2) /* enough data in this buffer ? */
+ {
+ iRemain -= pData->iJPEGtoskip2; /* skip enough to access the next byte */
+ pWork += pData->iJPEGtoskip2;
+
+ pData->iJPEGtoskip2 = 0; /* no more to skip then */
+ }
+ else
+ {
+ pData->iJPEGtoskip2 -= iRemain; /* skip all data in the buffer */
+ iRemain = 0; /* and indicate this accordingly */
+ }
+ /* the skip set current-pointer to NULL ! */
+ pData->pJPEGcurrent2 = pData->pJPEGbuf2;
+ }
+
+ while (iRemain) /* repeat until no more input-bytes */
+ { /* need to shift anything ? */
+ if ((pData->pJPEGcurrent2 > pData->pJPEGbuf2) &&
+ (pData->pJPEGcurrent2 - pData->pJPEGbuf2 + pData->iJPEGbufremain2 + iRemain > pData->iJPEGbufmax2))
+ {
+ if (pData->iJPEGbufremain2 > 0) /* then do so */
+ MNG_COPY (pData->pJPEGbuf2, pData->pJPEGcurrent2, pData->iJPEGbufremain2);
+
+ pData->pJPEGcurrent2 = pData->pJPEGbuf2;
+ }
+ /* does the remaining input fit into the buffer ? */
+ if (pData->iJPEGbufremain2 + iRemain <= pData->iJPEGbufmax2)
+ { /* move the lot */
+ MNG_COPY ((pData->pJPEGcurrent2 + pData->iJPEGbufremain2), pWork, iRemain);
+ /* adjust remaining_bytes counter */
+ pData->iJPEGbufremain2 += iRemain;
+ iRemain = 0; /* and indicate there's no input left */
+ }
+ else
+ { /* calculate what does fit */
+ mng_uint32 iFits = pData->iJPEGbufmax2 - pData->iJPEGbufremain2;
+
+ if (iFits <= 0) /* no space is just bugger 'm all */
+ MNG_ERROR (pData, MNG_JPEGBUFTOOSMALL);
+ /* move that */
+ MNG_COPY ((pData->pJPEGcurrent2 + pData->iJPEGbufremain2), pWork, iFits);
+
+ pData->iJPEGbufremain2 += iFits; /* adjust remain_bytes counter */
+ iRemain -= iFits; /* and the input-parms */
+ pWork += iFits;
+ }
+
+#ifdef MNG_INCLUDE_IJG6B
+ pData->pJPEGdinfo2->src->next_input_byte = pData->pJPEGcurrent2;
+ pData->pJPEGdinfo2->src->bytes_in_buffer = pData->iJPEGbufremain2;
+
+ if (!pData->bJPEGhasheader2) /* haven't got the header yet ? */
+ {
+ /* call jpeg_read_header() to obtain image info */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_READ_HEADER)
+#endif
+ if (jpeg_read_header (pData->pJPEGdinfo2, TRUE) != JPEG_SUSPENDED)
+ { /* indicate the header's oke */
+ pData->bJPEGhasheader2 = MNG_TRUE;
+ /* let's do some sanity checks ! */
+ if ((pData->pJPEGdinfo2->image_width != pData->iDatawidth ) ||
+ (pData->pJPEGdinfo2->image_height != pData->iDataheight) )
+ MNG_ERROR (pData, MNG_JPEGPARMSERR);
+
+ if (pData->pJPEGdinfo2->jpeg_color_space != JCS_GRAYSCALE)
+ MNG_ERROR (pData, MNG_JPEGPARMSERR);
+ /* indicate whether or not it's progressive */
+ pData->bJPEGprogressive2 = (mng_bool)jpeg_has_multiple_scans (pData->pJPEGdinfo2);
+
+ if (pData->bJPEGprogressive2) /* progressive alphachannel not allowed !!! */
+ MNG_ERROR (pData, MNG_JPEGPARMSERR);
+ /* allocate a row of JPEG-samples */
+ if (pData->pJPEGdinfo2->jpeg_color_space == JCS_YCbCr)
+ pData->iJPEGrowlen2 = pData->pJPEGdinfo2->image_width * RGB_PIXELSIZE;
+ else
+ pData->iJPEGrowlen2 = pData->pJPEGdinfo2->image_width;
+
+ MNG_ALLOC (pData, pData->pJPEGrow2, pData->iJPEGrowlen2);
+
+ pData->iJPEGalpharow = 0; /* quite empty up to now */
+ }
+
+ pData->pJPEGcurrent2 = (mng_uint8p)pData->pJPEGdinfo2->src->next_input_byte;
+ pData->iJPEGbufremain2 = (mng_uint32)pData->pJPEGdinfo2->src->bytes_in_buffer;
+ }
+ /* decompress not started ? */
+ if ((pData->bJPEGhasheader2) && (!pData->bJPEGdecostarted2))
+ {
+ /* set parameters for decompression */
+
+ if (pData->bJPEGprogressive2) /* progressive display ? */
+ pData->pJPEGdinfo2->buffered_image = TRUE;
+
+ /* jpeg_start_decompress(...); */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_START_DECOMPRESS)
+#endif
+ if (jpeg_start_decompress (pData->pJPEGdinfo2) == TRUE)
+ /* indicate it started */
+ pData->bJPEGdecostarted2 = MNG_TRUE;
+
+ pData->pJPEGcurrent2 = (mng_uint8p)pData->pJPEGdinfo2->src->next_input_byte;
+ pData->iJPEGbufremain2 = (mng_uint32)pData->pJPEGdinfo2->src->bytes_in_buffer;
+ }
+ /* process some scanlines ? */
+ if ((pData->bJPEGhasheader2) && (pData->bJPEGdecostarted2) &&
+ ((!jpeg_input_complete (pData->pJPEGdinfo2)) ||
+ (pData->pJPEGdinfo2->output_scanline < pData->pJPEGdinfo2->output_height)))
+ {
+ mng_int32 iLines;
+
+ /* for (each output pass) */
+ do
+ { /* address the row output buffer */
+ JSAMPROW pRow = (JSAMPROW)pData->pJPEGrow2;
+
+ /* init new pass ? */
+ if ((pData->bJPEGprogressive2) &&
+ ((!pData->bJPEGscanstarted2) ||
+ (pData->pJPEGdinfo2->output_scanline >= pData->pJPEGdinfo2->output_height)))
+ {
+ pData->bJPEGscanstarted2 = MNG_TRUE;
+
+ /* adjust output decompression parameters if required */
+ /* nop */
+
+ /* start a new output pass */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_START_OUTPUT)
+#endif
+ jpeg_start_output (pData->pJPEGdinfo2, pData->pJPEGdinfo2->input_scan_number);
+
+ pData->iJPEGrow = 0; /* start at row 0 in the image again */
+ }
+
+ /* while (scan lines remain to be read) */
+ do
+ {
+ /* jpeg_read_scanlines(...); */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_READ_SCANLINES)
+#endif
+ iLines = jpeg_read_scanlines (pData->pJPEGdinfo2, (JSAMPARRAY)&pRow, 1);
+
+ pData->pJPEGcurrent2 = (mng_uint8p)pData->pJPEGdinfo2->src->next_input_byte;
+ pData->iJPEGbufremain2 = (mng_uint32)pData->pJPEGdinfo2->src->bytes_in_buffer;
+
+ if (iLines > 0) /* got something ? */
+ {
+ if (pData->fStorerow3) /* store in object ? */
+ {
+ iRetcode = ((mng_storerow)pData->fStorerow3) (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+ }
+ }
+ }
+ while ((pData->pJPEGdinfo2->output_scanline < pData->pJPEGdinfo2->output_height) &&
+ (iLines > 0)); /* until end-of-image or not enough input-data */
+
+ /* terminate output pass */
+ if ((pData->bJPEGprogressive2) &&
+ (pData->pJPEGdinfo2->output_scanline >= pData->pJPEGdinfo2->output_height))
+ {
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_FINISH_OUTPUT)
+#endif
+ if (jpeg_finish_output (pData->pJPEGdinfo2) == JPEG_SUSPENDED)
+ jpeg_finish_output (pData->pJPEGdinfo2);
+ /* this scan has ended */
+ pData->bJPEGscanstarted2 = MNG_FALSE;
+ }
+ }
+ while ((!jpeg_input_complete (pData->pJPEGdinfo2)) && (iLines > 0));
+ }
+ /* end of image ? */
+ if ((pData->bJPEGhasheader2) && (pData->bJPEGdecostarted2) &&
+ (jpeg_input_complete (pData->pJPEGdinfo2)) &&
+ (pData->pJPEGdinfo2->input_scan_number == pData->pJPEGdinfo2->output_scan_number))
+ {
+ /* jpeg_finish_decompress(...); */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_FINISH_DECOMPRESS)
+#endif
+ if (jpeg_finish_decompress (pData->pJPEGdinfo2) == TRUE)
+ { /* indicate it's done */
+ pData->bJPEGhasheader2 = MNG_FALSE;
+ pData->bJPEGdecostarted2 = MNG_FALSE;
+ pData->pJPEGcurrent2 = (mng_uint8p)pData->pJPEGdinfo2->src->next_input_byte;
+ pData->iJPEGbufremain2 = (mng_uint32)pData->pJPEGdinfo2->src->bytes_in_buffer;
+ /* remaining fluff is an error ! */
+ if ((pData->iJPEGbufremain2 > 0) || (iRemain > 0))
+ MNG_ERROR (pData, MNG_TOOMUCHJDAT);
+ }
+ }
+#endif /* MNG_INCLUDE_IJG6B */
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_JNG_READ
+mng_retcode mngjpeg_decompressfree2 (mng_datap pData)
+{
+#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
+ mng_retcode iRetcode;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSFREE, MNG_LC_START);
+#endif
+
+#ifdef MNG_INCLUDE_IJG6B
+#ifdef MNG_USE_SETJMP
+ iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
+ if (iRetcode != 0) /* got here from longjmp ? */
+ MNG_ERRORJ (pData, iRetcode); /* then IJG-lib issued an error */
+#endif
+ /* free the row of JPEG-samples*/
+ MNG_FREE (pData, pData->pJPEGrow2, pData->iJPEGrowlen2);
+
+ /* release the JPEG decompression object */
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSFREE, MNG_LC_JPEG_DESTROY_DECOMPRESS)
+#endif
+ jpeg_destroy_decompress (pData->pJPEGdinfo2);
+
+ pData->bJPEGdecompress2 = MNG_FALSE; /* indicate it's done */
+
+#endif /* MNG_INCLUDE_IJG6B */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSFREE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif /* MNG_INCLUDE_JNG_READ */
+
+/* ************************************************************************** */
+
+#endif /* MNG_INCLUDE_JNG && MNG_INCLUDE_DISPLAY_PROCS */
+
+/* ************************************************************************** */
+/* * end of file * */
+/* ************************************************************************** */
+
|