diff options
Diffstat (limited to 'plugins/FreeImage/src/LibMNG/libmng_chunk_io.c')
| -rw-r--r-- | plugins/FreeImage/src/LibMNG/libmng_chunk_io.c | 10740 |
1 files changed, 0 insertions, 10740 deletions
diff --git a/plugins/FreeImage/src/LibMNG/libmng_chunk_io.c b/plugins/FreeImage/src/LibMNG/libmng_chunk_io.c deleted file mode 100644 index a75945f063..0000000000 --- a/plugins/FreeImage/src/LibMNG/libmng_chunk_io.c +++ /dev/null @@ -1,10740 +0,0 @@ -/** ************************************************************************* */
-/* * For conditions of distribution and use, * */
-/* * see copyright notice in libmng.h * */
-/* ************************************************************************** */
-/* * * */
-/* * project : libmng * */
-/* * file : libmng_chunk_io.c copyright (c) 2000-2007 G.Juyn * */
-/* * version : 1.0.10 * */
-/* * * */
-/* * purpose : Chunk I/O routines (implementation) * */
-/* * * */
-/* * author : G.Juyn * */
-/* * * */
-/* * comment : implementation of chunk input/output routines * */
-/* * * */
-/* * changes : 0.5.1 - 05/01/2000 - G.Juyn * */
-/* * - cleaned up left-over teststuff in the BACK chunk routine * */
-/* * 0.5.1 - 05/04/2000 - G.Juyn * */
-/* * - changed CRC initialization to use dynamic structure * */
-/* * (wasn't thread-safe the old way !) * */
-/* * 0.5.1 - 05/06/2000 - G.Juyn * */
-/* * - filled in many missing sequence&length checks * */
-/* * - filled in many missing chunk-store snippets * */
-/* * 0.5.1 - 05/08/2000 - G.Juyn * */
-/* * - added checks for running animations * */
-/* * - filled some write routines * */
-/* * - changed strict-ANSI stuff * */
-/* * 0.5.1 - 05/10/2000 - G.Juyn * */
-/* * - filled some more write routines * */
-/* * 0.5.1 - 05/11/2000 - G.Juyn * */
-/* * - filled remaining write routines * */
-/* * - fixed read_pplt with regard to deltatype * */
-/* * - added callback error-reporting support * */
-/* * - added pre-draft48 support (short MHDR, frame_mode, LOOP) * */
-/* * 0.5.1 - 05/12/2000 - G.Juyn * */
-/* * - changed trace to macro for callback error-reporting * */
-/* * - fixed chunk-storage bit in several routines * */
-/* * 0.5.1 - 05/13/2000 - G.Juyn * */
-/* * - added eMNGma hack (will be removed in 1.0.0 !!!) * */
-/* * - added TERM animation object pointer (easier reference) * */
-/* * - supplemented the SAVE & SEEK display processing * */
-/* * * */
-/* * 0.5.2 - 05/18/2000 - G.Juyn * */
-/* * - B004 - fixed problem with MNG_SUPPORT_WRITE not defined * */
-/* * also for MNG_SUPPORT_WRITE without MNG_INCLUDE_JNG * */
-/* * 0.5.2 - 05/19/2000 - G.Juyn * */
-/* * - cleaned up some code regarding mixed support * */
-/* * 0.5.2 - 05/20/2000 - G.Juyn * */
-/* * - implemented JNG support * */
-/* * 0.5.2 - 05/24/2000 - G.Juyn * */
-/* * - added support for global color-chunks in animation * */
-/* * - added support for global PLTE,tRNS,bKGD in animation * */
-/* * - added support for SAVE & SEEK in animation * */
-/* * 0.5.2 - 05/29/2000 - G.Juyn * */
-/* * - changed ani_create calls not returning object pointer * */
-/* * - create ani objects always (not just inside TERM/LOOP) * */
-/* * 0.5.2 - 05/30/2000 - G.Juyn * */
-/* * - added support for delta-image processing * */
-/* * 0.5.2 - 05/31/2000 - G.Juyn * */
-/* * - fixed up punctuation (contributed by Tim Rowley) * */
-/* * 0.5.2 - 06/02/2000 - G.Juyn * */
-/* * - changed SWAP_ENDIAN to BIGENDIAN_SUPPORTED * */
-/* * 0.5.2 - 06/03/2000 - G.Juyn * */
-/* * - fixed makeup for Linux gcc compile * */
-/* * * */
-/* * 0.5.3 - 06/12/2000 - G.Juyn * */
-/* * - added processing of color-info on delta-image * */
-/* * 0.5.3 - 06/13/2000 - G.Juyn * */
-/* * - fixed handling of empty SAVE chunk * */
-/* * 0.5.3 - 06/17/2000 - G.Juyn * */
-/* * - changed to support delta-images * */
-/* * - added extra checks for delta-images * */
-/* * 0.5.3 - 06/20/2000 - G.Juyn * */
-/* * - fixed possible trouble if IEND display-process got * */
-/* * broken up * */
-/* * 0.5.3 - 06/21/2000 - G.Juyn * */
-/* * - added processing of PLTE & tRNS for delta-images * */
-/* * - added administration of imagelevel parameter * */
-/* * 0.5.3 - 06/22/2000 - G.Juyn * */
-/* * - implemented support for PPLT chunk * */
-/* * 0.5.3 - 06/26/2000 - G.Juyn * */
-/* * - added precaution against faulty iCCP chunks from PS * */
-/* * 0.5.3 - 06/29/2000 - G.Juyn * */
-/* * - fixed some 64-bit warnings * */
-/* * * */
-/* * 0.9.1 - 07/14/2000 - G.Juyn * */
-/* * - changed pre-draft48 frame_mode=3 to frame_mode=1 * */
-/* * 0.9.1 - 07/16/2000 - G.Juyn * */
-/* * - fixed storage of images during mng_read() * */
-/* * - fixed support for mng_display() after mng_read() * */
-/* * 0.9.1 - 07/19/2000 - G.Juyn * */
-/* * - fixed several chunk-writing routines * */
-/* * 0.9.1 - 07/24/2000 - G.Juyn * */
-/* * - fixed reading of still-images * */
-/* * * */
-/* * 0.9.2 - 08/05/2000 - G.Juyn * */
-/* * - changed file-prefixes * */
-/* * * */
-/* * 0.9.3 - 08/07/2000 - G.Juyn * */
-/* * - B111300 - fixup for improved portability * */
-/* * 0.9.3 - 08/08/2000 - G.Juyn * */
-/* * - fixed compiler-warnings from Mozilla * */
-/* * 0.9.3 - 08/09/2000 - G.Juyn * */
-/* * - added check for simplicity-bits in MHDR * */
-/* * 0.9.3 - 08/12/2000 - G.Juyn * */
-/* * - fixed check for simplicity-bits in MHDR (JNG) * */
-/* * 0.9.3 - 08/12/2000 - G.Juyn * */
-/* * - added workaround for faulty PhotoShop iCCP chunk * */
-/* * 0.9.3 - 08/22/2000 - G.Juyn * */
-/* * - fixed write-code for zTXt & iTXt * */
-/* * - fixed read-code for iTXt * */
-/* * 0.9.3 - 08/26/2000 - G.Juyn * */
-/* * - added MAGN chunk * */
-/* * 0.9.3 - 09/07/2000 - G.Juyn * */
-/* * - added support for new filter_types * */
-/* * 0.9.3 - 09/10/2000 - G.Juyn * */
-/* * - fixed DEFI behavior * */
-/* * 0.9.3 - 10/02/2000 - G.Juyn * */
-/* * - fixed simplicity-check in compliance with draft 81/0.98a * */
-/* * 0.9.3 - 10/10/2000 - G.Juyn * */
-/* * - added support for alpha-depth prediction * */
-/* * 0.9.3 - 10/11/2000 - G.Juyn * */
-/* * - added support for nEED * */
-/* * 0.9.3 - 10/16/2000 - G.Juyn * */
-/* * - added support for JDAA * */
-/* * 0.9.3 - 10/17/2000 - G.Juyn * */
-/* * - fixed support for MAGN * */
-/* * - implemented nEED "xxxx" (where "xxxx" is a chunkid) * */
-/* * - added callback to process non-critical unknown chunks * */
-/* * - fixed support for bKGD * */
-/* * 0.9.3 - 10/23/2000 - G.Juyn * */
-/* * - fixed bug in empty PLTE handling * */
-/* * * */
-/* * 0.9.4 - 11/20/2000 - G.Juyn * */
-/* * - changed IHDR filter_method check for PNGs * */
-/* * 0.9.4 - 1/18/2001 - G.Juyn * */
-/* * - added errorchecking for MAGN methods * */
-/* * - removed test filter-methods 1 & 65 * */
-/* * * */
-/* * 0.9.5 - 1/25/2001 - G.Juyn * */
-/* * - fixed some small compiler warnings (thanks Nikki) * */
-/* * * */
-/* * 1.0.2 - 05/05/2000 - G.Juyn * */
-/* * - B421427 - writes wrong format in bKGD and tRNS * */
-/* * 1.0.2 - 06/20/2000 - G.Juyn * */
-/* * - B434583 - compiler-warning if MNG_STORE_CHUNKS undefined * */
-/* * * */
-/* * 1.0.5 - 07/08/2002 - G.Juyn * */
-/* * - B578572 - removed eMNGma hack (thanks Dimitri!) * */
-/* * 1.0.5 - 08/07/2002 - G.Juyn * */
-/* * - added test-option for PNG filter method 193 (=no filter) * */
-/* * 1.0.5 - 08/15/2002 - G.Juyn * */
-/* * - completed PROM support * */
-/* * 1.0.5 - 08/19/2002 - G.Juyn * */
-/* * - B597134 - libmng pollutes the linker namespace * */
-/* * 1.0.5 - 09/07/2002 - G.Juyn * */
-/* * - fixed reading of FRAM with just frame_mode and name * */
-/* * 1.0.5 - 09/13/2002 - G.Juyn * */
-/* * - fixed read/write of MAGN chunk * */
-/* * 1.0.5 - 09/14/2002 - G.Juyn * */
-/* * - added event handling for dynamic MNG * */
-/* * 1.0.5 - 09/15/2002 - G.Juyn * */
-/* * - fixed LOOP iteration=0 special case * */
-/* * 1.0.5 - 09/19/2002 - G.Juyn * */
-/* * - misplaced TERM is now treated as warning * */
-/* * 1.0.5 - 09/20/2002 - G.Juyn * */
-/* * - added support for PAST * */
-/* * 1.0.5 - 10/03/2002 - G.Juyn * */
-/* * - fixed chunk-storage for evNT chunk * */
-/* * 1.0.5 - 10/07/2002 - G.Juyn * */
-/* * - fixed DISC support * */
-/* * - added another fix for misplaced TERM chunk * */
-/* * 1.0.5 - 10/17/2002 - G.Juyn * */
-/* * - fixed initializtion of pIds in dISC read routine * */
-/* * 1.0.5 - 11/06/2002 - G.Juyn * */
-/* * - added support for nEED "MNG 1.1" * */
-/* * - added support for nEED "CACHEOFF" * */
-/* * * */
-/* * 1.0.6 - 05/25/2003 - G.R-P * */
-/* * - added MNG_SKIPCHUNK_cHNK footprint optimizations * */
-/* * 1.0.6 - 06/02/2003 - G.R-P * */
-/* * - removed some redundant checks for iRawlen==0 * */
-/* * 1.0.6 - 06/22/2003 - G.R-P * */
-/* * - added MNG_NO_16BIT_SUPPORT, MNG_NO_DELTA_PNG reductions * */
-/* * - optionally use zlib's crc32 function instead of * */
-/* * local mng_update_crc * */
-/* * 1.0.6 - 07/14/2003 - G.R-P * */
-/* * - added MNG_NO_LOOP_SIGNALS_SUPPORTED conditional * */
-/* * 1.0.6 - 07/29/2003 - G.R-P * */
-/* * - added conditionals around PAST chunk support * */
-/* * 1.0.6 - 08/17/2003 - G.R-P * */
-/* * - added conditionals around non-VLC chunk support * */
-/* * * */
-/* * 1.0.7 - 10/29/2003 - G.R-P * */
-/* * - revised JDAA and JDAT readers to avoid compiler bug * */
-/* * 1.0.7 - 01/25/2004 - J.S * */
-/* * - added premultiplied alpha canvas' for RGBA, ARGB, ABGR * */
-/* * 1.0.7 - 01/27/2004 - J.S * */
-/* * - fixed inclusion of IJNG chunk for non-JNG use * */
-/* * 1.0.7 - 02/26/2004 - G.Juyn * */
-/* * - fixed bug in chunk-storage of SHOW chunk (from == to) * */
-/* * * */
-/* * 1.0.8 - 04/02/2004 - G.Juyn * */
-/* * - added CRC existence & checking flags * */
-/* * 1.0.8 - 07/07/2004 - G.R-P * */
-/* * - change worst-case iAlphadepth to 1 for standalone PNGs * */
-/* * * */
-/* * 1.0.9 - 09/28/2004 - G.R-P * */
-/* * - improved handling of cheap transparency when 16-bit * */
-/* * support is disabled * */
-/* * 1.0.9 - 10/04/2004 - G.Juyn * */
-/* * - fixed bug in writing sBIT for indexed color * */
-/* * 1.0.9 - 10/10/2004 - G.R-P. * */
-/* * - added MNG_NO_1_2_4BIT_SUPPORT * */
-/* * 1.0.9 - 12/05/2004 - G.Juyn * */
-/* * - added conditional MNG_OPTIMIZE_CHUNKINITFREE * */
-/* * 1.0.9 - 12/06/2004 - G.Juyn * */
-/* * - added conditional MNG_OPTIMIZE_CHUNKASSIGN * */
-/* * 1.0.9 - 12/07/2004 - G.Juyn * */
-/* * - added conditional MNG_OPTIMIZE_CHUNKREADER * */
-/* * 1.0.9 - 12/11/2004 - G.Juyn * */
-/* * - added conditional MNG_OPTIMIZE_DISPLAYCALLS * */
-/* * 1.0.9 - 12/20/2004 - G.Juyn * */
-/* * - cleaned up macro-invocations (thanks to D. Airlie) * */
-/* * 1.0.9 - 01/17/2005 - G.Juyn * */
-/* * - fixed problem with global PLTE/tRNS * */
-/* * * */
-/* * 1.0.10 - 02/07/2005 - G.Juyn * */
-/* * - fixed display routines called twice for FULL_MNG * */
-/* * support in mozlibmngconf.h * */
-/* * 1.0.10 - 12/04/2005 - G.R-P. * */
-/* * - #ifdef out use of mng_inflate_buffer when it is not * */
-/* * available. * */
-/* * 1.0.10 - 04/08/2007 - G.Juyn * */
-/* * - added support for mPNG proposal * */
-/* * 1.0.10 - 04/12/2007 - G.Juyn * */
-/* * - added support for ANG proposal * */
-/* * 1.0.10 - 05/02/2007 - G.Juyn * */
-/* * - fixed inflate_buffer for extreme compression ratios * */
-/* * * */
-/* ************************************************************************** */
-
-#include "libmng.h"
-#include "libmng_data.h"
-#include "libmng_error.h"
-#include "libmng_trace.h"
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-#include "libmng_objects.h"
-#include "libmng_object_prc.h"
-#include "libmng_chunks.h"
-#ifdef MNG_CHECK_BAD_ICCP
-#include "libmng_chunk_prc.h"
-#endif
-#include "libmng_memory.h"
-#include "libmng_display.h"
-#include "libmng_zlib.h"
-#include "libmng_pixels.h"
-#include "libmng_chunk_io.h"
-
-#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
-#pragma option -A /* force ANSI-C */
-#endif
-
-/* ************************************************************************** */
-/* * * */
-/* * CRC - Cyclic Redundancy Check * */
-/* * * */
-/* * The code below is taken directly from the sample provided with the * */
-/* * PNG specification. * */
-/* * (it is only adapted to the library's internal data-definitions) * */
-/* * * */
-/* ************************************************************************** */
-/* Make the table for a fast CRC. */
-#ifndef MNG_USE_ZLIB_CRC
-MNG_LOCAL void make_crc_table (mng_datap pData)
-{
- mng_uint32 iC;
- mng_int32 iN, iK;
-
- for (iN = 0; iN < 256; iN++)
- {
- iC = (mng_uint32) iN;
-
- for (iK = 0; iK < 8; iK++)
- {
- if (iC & 1)
- iC = 0xedb88320U ^ (iC >> 1);
- else
- iC = iC >> 1;
- }
-
- pData->aCRCtable [iN] = iC;
- }
-
- pData->bCRCcomputed = MNG_TRUE;
-}
-#endif
-
-/* Update a running CRC with the bytes buf[0..len-1]--the CRC
- should be initialized to all 1's, and the transmitted value
- is the 1's complement of the final running CRC (see the
- crc() routine below). */
-
-MNG_LOCAL mng_uint32 update_crc (mng_datap pData,
- mng_uint32 iCrc,
- mng_uint8p pBuf,
- mng_int32 iLen)
-{
-#ifdef MNG_USE_ZLIB_CRC
- return crc32 (iCrc, pBuf, iLen);
-#else
- mng_uint32 iC = iCrc;
- mng_int32 iN;
-
- if (!pData->bCRCcomputed)
- make_crc_table (pData);
-
- for (iN = 0; iN < iLen; iN++)
- iC = pData->aCRCtable [(iC ^ pBuf [iN]) & 0xff] ^ (iC >> 8);
-
- return iC;
-#endif
-}
-
-/* Return the CRC of the bytes buf[0..len-1]. */
-mng_uint32 mng_crc (mng_datap pData,
- mng_uint8p pBuf,
- mng_int32 iLen)
-{
-#ifdef MNG_USE_ZLIB_CRC
- return update_crc (pData, 0, pBuf, iLen);
-#else
- return update_crc (pData, 0xffffffffU, pBuf, iLen) ^ 0xffffffffU;
-#endif
-}
-
-/* ************************************************************************** */
-/* * * */
-/* * Routines for swapping byte-order from and to graphic files * */
-/* * (This code is adapted from the libpng package) * */
-/* * * */
-/* ************************************************************************** */
-
-#ifndef MNG_BIGENDIAN_SUPPORTED
-
-/* ************************************************************************** */
-
-mng_uint32 mng_get_uint32 (mng_uint8p pBuf)
-{
- mng_uint32 i = ((mng_uint32)(*pBuf) << 24) +
- ((mng_uint32)(*(pBuf + 1)) << 16) +
- ((mng_uint32)(*(pBuf + 2)) << 8) +
- (mng_uint32)(*(pBuf + 3));
- return (i);
-}
-
-/* ************************************************************************** */
-
-mng_int32 mng_get_int32 (mng_uint8p pBuf)
-{
- mng_int32 i = ((mng_int32)(*pBuf) << 24) +
- ((mng_int32)(*(pBuf + 1)) << 16) +
- ((mng_int32)(*(pBuf + 2)) << 8) +
- (mng_int32)(*(pBuf + 3));
- return (i);
-}
-
-/* ************************************************************************** */
-
-mng_uint16 mng_get_uint16 (mng_uint8p pBuf)
-{
- mng_uint16 i = (mng_uint16)(((mng_uint16)(*pBuf) << 8) +
- (mng_uint16)(*(pBuf + 1)));
- return (i);
-}
-
-/* ************************************************************************** */
-
-void mng_put_uint32 (mng_uint8p pBuf,
- mng_uint32 i)
-{
- *pBuf = (mng_uint8)((i >> 24) & 0xff);
- *(pBuf+1) = (mng_uint8)((i >> 16) & 0xff);
- *(pBuf+2) = (mng_uint8)((i >> 8) & 0xff);
- *(pBuf+3) = (mng_uint8)(i & 0xff);
-}
-
-/* ************************************************************************** */
-
-void mng_put_int32 (mng_uint8p pBuf,
- mng_int32 i)
-{
- *pBuf = (mng_uint8)((i >> 24) & 0xff);
- *(pBuf+1) = (mng_uint8)((i >> 16) & 0xff);
- *(pBuf+2) = (mng_uint8)((i >> 8) & 0xff);
- *(pBuf+3) = (mng_uint8)(i & 0xff);
-}
-
-/* ************************************************************************** */
-
-void mng_put_uint16 (mng_uint8p pBuf,
- mng_uint16 i)
-{
- *pBuf = (mng_uint8)((i >> 8) & 0xff);
- *(pBuf+1) = (mng_uint8)(i & 0xff);
-}
-
-/* ************************************************************************** */
-
-#endif /* !MNG_BIGENDIAN_SUPPORTED */
-
-/* ************************************************************************** */
-/* * * */
-/* * Helper routines to simplify chunk-data extraction * */
-/* * * */
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_READ_PROCS
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-MNG_LOCAL mng_uint8p find_null (mng_uint8p pIn)
-{
- mng_uint8p pOut = pIn;
- while (*pOut) /* the read_graphic routine has made sure there's */
- pOut++; /* always at least 1 zero-byte in the buffer */
- return pOut;
-}
-#endif
-
-/* ************************************************************************** */
-
-#if !defined(MNG_SKIPCHUNK_iCCP) || !defined(MNG_SKIPCHUNK_zTXt) || \
- !defined(MNG_SKIPCHUNK_iTXt) || defined(MNG_INCLUDE_MPNG_PROPOSAL) || \
- defined(MNG_INCLUDE_ANG_PROPOSAL)
-mng_retcode mng_inflate_buffer (mng_datap pData,
- mng_uint8p pInbuf,
- mng_uint32 iInsize,
- mng_uint8p *pOutbuf,
- mng_uint32 *iOutsize,
- mng_uint32 *iRealsize)
-{
- mng_retcode iRetcode = MNG_NOERROR;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_INFLATE_BUFFER, MNG_LC_START);
-#endif
-
- if (iInsize) /* anything to do ? */
- {
- *iOutsize = iInsize * 3; /* estimate uncompressed size */
- /* and allocate a temporary buffer */
- MNG_ALLOC (pData, *pOutbuf, *iOutsize);
-
- do
- {
- mngzlib_inflateinit (pData); /* initialize zlib */
- /* let zlib know where to store the output */
- pData->sZlib.next_out = *pOutbuf;
- /* "size - 1" so we've got space for the
- zero-termination of a possible string */
- pData->sZlib.avail_out = *iOutsize - 1;
- /* ok; let's inflate... */
- iRetcode = mngzlib_inflatedata (pData, iInsize, pInbuf);
- /* determine actual output size */
- *iRealsize = (mng_uint32)pData->sZlib.total_out;
-
- mngzlib_inflatefree (pData); /* zlib's done */
-
- if (iRetcode == MNG_BUFOVERFLOW) /* not enough space ? */
- { /* then get some more */
- MNG_FREEX (pData, *pOutbuf, *iOutsize);
- *iOutsize = *iOutsize + *iOutsize;
- MNG_ALLOC (pData, *pOutbuf, *iOutsize);
- }
- } /* repeat if we didn't have enough space */
- while ((iRetcode == MNG_BUFOVERFLOW) &&
- (*iOutsize < 200 * iInsize));
-
- if (!iRetcode) /* if oke ? */
- *((*pOutbuf) + *iRealsize) = 0; /* then put terminator zero */
-
- }
- else
- {
- *pOutbuf = 0; /* nothing to do; then there's no output */
- *iOutsize = 0;
- *iRealsize = 0;
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_INFLATE_BUFFER, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#endif /* MNG_INCLUDE_READ_PROCS */
-
-/* ************************************************************************** */
-/* * * */
-/* * Helper routines to simplify chunk writing * */
-/* * * */
-/* ************************************************************************** */
-#ifdef MNG_INCLUDE_WRITE_PROCS
-/* ************************************************************************** */
-
-#if !defined(MNG_SKIPCHUNK_iCCP) || !defined(MNG_SKIPCHUNK_zTXt) || !defined(MNG_SKIPCHUNK_iTXt)
-MNG_LOCAL mng_retcode deflate_buffer (mng_datap pData,
- mng_uint8p pInbuf,
- mng_uint32 iInsize,
- mng_uint8p *pOutbuf,
- mng_uint32 *iOutsize,
- mng_uint32 *iRealsize)
-{
- mng_retcode iRetcode = MNG_NOERROR;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_DEFLATE_BUFFER, MNG_LC_START);
-#endif
-
- if (iInsize) /* anything to do ? */
- {
- *iOutsize = (iInsize * 5) >> 2; /* estimate compressed size */
- /* and allocate a temporary buffer */
- MNG_ALLOC (pData, *pOutbuf, *iOutsize);
-
- do
- {
- mngzlib_deflateinit (pData); /* initialize zlib */
- /* let zlib know where to store the output */
- pData->sZlib.next_out = *pOutbuf;
- pData->sZlib.avail_out = *iOutsize;
- /* ok; let's deflate... */
- iRetcode = mngzlib_deflatedata (pData, iInsize, pInbuf);
- /* determine actual output size */
- *iRealsize = pData->sZlib.total_out;
-
- mngzlib_deflatefree (pData); /* zlib's done */
-
- if (iRetcode == MNG_BUFOVERFLOW) /* not enough space ? */
- { /* then get some more */
- MNG_FREEX (pData, *pOutbuf, *iOutsize);
- *iOutsize = *iOutsize + (iInsize >> 1);
- MNG_ALLOC (pData, *pOutbuf, *iOutsize);
- }
- } /* repeat if we didn't have enough space */
- while (iRetcode == MNG_BUFOVERFLOW);
- }
- else
- {
- *pOutbuf = 0; /* nothing to do; then there's no output */
- *iOutsize = 0;
- *iRealsize = 0;
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_DEFLATE_BUFFER, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-MNG_LOCAL mng_retcode write_raw_chunk (mng_datap pData,
- mng_chunkid iChunkname,
- mng_uint32 iRawlen,
- mng_uint8p pRawdata)
-{
- mng_uint32 iCrc;
- mng_uint32 iWritten;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_RAW_CHUNK, MNG_LC_START);
-#endif
- /* temporary buffer ? */
- if ((pRawdata != 0) && (pRawdata != pData->pWritebuf+8))
- { /* store length & chunktype in default buffer */
- mng_put_uint32 (pData->pWritebuf, iRawlen);
- mng_put_uint32 (pData->pWritebuf+4, (mng_uint32)iChunkname);
-
- if (pData->iCrcmode & MNG_CRC_OUTPUT)
- {
- if ((pData->iCrcmode & MNG_CRC_OUTPUT) == MNG_CRC_OUTPUT_GENERATE)
- { /* calculate the crc */
- iCrc = update_crc (pData, 0xffffffffL, pData->pWritebuf+4, 4);
- iCrc = update_crc (pData, iCrc, pRawdata, iRawlen) ^ 0xffffffffL;
- } else {
- iCrc = 0; /* dummy crc */
- } /* store in default buffer */
- mng_put_uint32 (pData->pWritebuf+8, iCrc);
- }
- /* write the length & chunktype */
- if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, 8, &iWritten))
- MNG_ERROR (pData, MNG_APPIOERROR);
-
- if (iWritten != 8) /* disk full ? */
- MNG_ERROR (pData, MNG_OUTPUTERROR);
- /* write the temporary buffer */
- if (!pData->fWritedata ((mng_handle)pData, pRawdata, iRawlen, &iWritten))
- MNG_ERROR (pData, MNG_APPIOERROR);
-
- if (iWritten != iRawlen) /* disk full ? */
- MNG_ERROR (pData, MNG_OUTPUTERROR);
-
- if (pData->iCrcmode & MNG_CRC_OUTPUT)
- { /* write the crc */
- if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf+8, 4, &iWritten))
- MNG_ERROR (pData, MNG_APPIOERROR);
-
- if (iWritten != 4) /* disk full ? */
- MNG_ERROR (pData, MNG_OUTPUTERROR);
- }
- }
- else
- { /* prefix with length & chunktype */
- mng_put_uint32 (pData->pWritebuf, iRawlen);
- mng_put_uint32 (pData->pWritebuf+4, (mng_uint32)iChunkname);
-
- if (pData->iCrcmode & MNG_CRC_OUTPUT)
- {
- if ((pData->iCrcmode & MNG_CRC_OUTPUT) == MNG_CRC_OUTPUT_GENERATE)
- /* calculate the crc */
- iCrc = mng_crc (pData, pData->pWritebuf+4, iRawlen + 4);
- else
- iCrc = 0; /* dummy crc */
- /* add it to the buffer */
- mng_put_uint32 (pData->pWritebuf + iRawlen + 8, iCrc);
- /* write it in a single pass */
- if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, iRawlen + 12, &iWritten))
- MNG_ERROR (pData, MNG_APPIOERROR);
-
- if (iWritten != iRawlen + 12) /* disk full ? */
- MNG_ERROR (pData, MNG_OUTPUTERROR);
- } else {
- if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, iRawlen + 8, &iWritten))
- MNG_ERROR (pData, MNG_APPIOERROR);
-
- if (iWritten != iRawlen + 8) /* disk full ? */
- MNG_ERROR (pData, MNG_OUTPUTERROR);
- }
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_RAW_CHUNK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-/* B004 */
-#endif /* MNG_INCLUDE_WRITE_PROCS */
-/* B004 */
-/* ************************************************************************** */
-/* * * */
-/* * chunk read functions * */
-/* * * */
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_READ_PROCS
-
-/* ************************************************************************** */
-
-#ifdef MNG_OPTIMIZE_CHUNKREADER
-
-/* ************************************************************************** */
-
-MNG_LOCAL mng_retcode create_chunk_storage (mng_datap pData,
- mng_chunkp pHeader,
- mng_uint32 iRawlen,
- mng_uint8p pRawdata,
- mng_field_descp pField,
- mng_uint16 iFields,
- mng_chunkp* ppChunk,
- mng_bool bWorkcopy)
-{
- mng_field_descp pTempfield = pField;
- mng_uint16 iFieldcount = iFields;
- mng_uint8p pTempdata = pRawdata;
- mng_uint32 iTemplen = iRawlen;
- mng_uint16 iLastgroup = 0;
- mng_uint8p pChunkdata;
- mng_uint32 iDatalen;
- mng_uint8 iColortype;
- mng_bool bProcess;
- /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- if (((mng_chunk_headerp)(*ppChunk))->iChunkname == MNG_UINT_HUH)
- ((mng_chunk_headerp)(*ppChunk))->iChunkname = pData->iChunkname;
-
- if ((!bWorkcopy) ||
- ((((mng_chunk_headerp)pHeader)->iChunkname != MNG_UINT_IDAT) &&
- (((mng_chunk_headerp)pHeader)->iChunkname != MNG_UINT_JDAT) &&
- (((mng_chunk_headerp)pHeader)->iChunkname != MNG_UINT_JDAA) ))
- {
- pChunkdata = (mng_uint8p)(*ppChunk);
-
-#ifdef MNG_INCLUDE_JNG /* determine current colortype */
- if (pData->bHasJHDR)
- iColortype = (mng_uint8)(pData->iJHDRcolortype - 8);
- else
-#endif /* MNG_INCLUDE_JNG */
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- iColortype = pData->iColortype;
- else
- iColortype = 6;
-
- if (iTemplen) /* not empty ? */
- { /* then go fill the fields */
- while ((iFieldcount) && (iTemplen))
- {
- if (pTempfield->iOffsetchunk)
- {
- if (pTempfield->iFlags & MNG_FIELD_PUTIMGTYPE)
- {
- *(pChunkdata+pTempfield->iOffsetchunk) = iColortype;
- bProcess = MNG_FALSE;
- }
- else
- if (pTempfield->iFlags & MNG_FIELD_IFIMGTYPES)
- bProcess = (mng_bool)(((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE0) && (iColortype == 0)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE2) && (iColortype == 2)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE3) && (iColortype == 3)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE4) && (iColortype == 4)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE6) && (iColortype == 6)) );
- else
- bProcess = MNG_TRUE;
-
- if (bProcess)
- {
- iLastgroup = (mng_uint16)(pTempfield->iFlags & MNG_FIELD_GROUPMASK);
- /* numeric field ? */
- if (pTempfield->iFlags & MNG_FIELD_INT)
- {
- if (iTemplen < pTempfield->iLengthmax)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- switch (pTempfield->iLengthmax)
- {
- case 1 : { mng_uint8 iNum = *pTempdata;
- if (((mng_uint16)iNum < pTempfield->iMinvalue) ||
- ((mng_uint16)iNum > pTempfield->iMaxvalue) )
- MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
- *(pChunkdata+pTempfield->iOffsetchunk) = iNum;
- break; }
- case 2 : { mng_uint16 iNum = mng_get_uint16 (pTempdata);
- if ((iNum < pTempfield->iMinvalue) || (iNum > pTempfield->iMaxvalue))
- MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
- *((mng_uint16p)(pChunkdata+pTempfield->iOffsetchunk)) = iNum;
- break; }
- case 4 : { mng_uint32 iNum = mng_get_uint32 (pTempdata);
- if ((iNum < pTempfield->iMinvalue) ||
- ((pTempfield->iFlags & MNG_FIELD_NOHIGHBIT) && (iNum & 0x80000000)) )
- MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
- *((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunk)) = iNum;
- break; }
- }
-
- pTempdata += pTempfield->iLengthmax;
- iTemplen -= pTempfield->iLengthmax;
-
- } else { /* not numeric so it's a bunch of bytes */
-
- if (!pTempfield->iOffsetchunklen) /* big fat NONO */
- MNG_ERROR (pData, MNG_INTERNALERROR);
- /* with terminating 0 ? */
- if (pTempfield->iFlags & MNG_FIELD_TERMINATOR)
- {
- mng_uint8p pWork = pTempdata;
- while (*pWork) /* find the zero */
- pWork++;
- iDatalen = (mng_uint32)(pWork - pTempdata);
- } else { /* no terminator, so everything that's left ! */
- iDatalen = iTemplen;
- }
-
- if ((pTempfield->iLengthmax) && (iDatalen > pTempfield->iLengthmax))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-#if !defined(MNG_SKIPCHUNK_iCCP) || !defined(MNG_SKIPCHUNK_zTXt) || \
- !defined(MNG_SKIPCHUNK_iTXt) || defined(MNG_INCLUDE_MPNG_PROPOSAL) || \
- defined(MNG_INCLUDE_ANG_PROPOSAL)
- /* needs decompression ? */
- if (pTempfield->iFlags & MNG_FIELD_DEFLATED)
- {
- mng_uint8p pBuf = 0;
- mng_uint32 iBufsize = 0;
- mng_uint32 iRealsize;
- mng_ptr pWork;
-
- iRetcode = mng_inflate_buffer (pData, pTempdata, iDatalen,
- &pBuf, &iBufsize, &iRealsize);
-
-#ifdef MNG_CHECK_BAD_ICCP /* Check for bad iCCP chunk */
- if ((iRetcode) && (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_iCCP))
- {
- *((mng_ptr *)(pChunkdata+pTempfield->iOffsetchunk)) = MNG_NULL;
- *((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunklen)) = iDatalen;
- }
- else
-#endif
- {
- if (iRetcode)
- return iRetcode;
-
-#if defined(MNG_INCLUDE_MPNG_PROPOSAL) || defined(MNG_INCLUDE_ANG_PROPOSAL)
- if ( (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_mpNG) ||
- (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_adAT) )
- {
- MNG_ALLOC (pData, pWork, iRealsize);
- }
- else
- {
-#endif
- /* don't forget to generate null terminator */
- MNG_ALLOC (pData, pWork, iRealsize+1);
-#if defined(MNG_INCLUDE_MPNG_PROPOSAL) || defined(MNG_INCLUDE_ANG_PROPOSAL)
- }
-#endif
- MNG_COPY (pWork, pBuf, iRealsize);
-
- *((mng_ptr *)(pChunkdata+pTempfield->iOffsetchunk)) = pWork;
- *((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunklen)) = iRealsize;
- }
-
- if (pBuf) /* free the temporary buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
-
- } else
-#endif
- { /* no decompression, so just copy */
-
- mng_ptr pWork;
- /* don't forget to generate null terminator */
- MNG_ALLOC (pData, pWork, iDatalen+1);
- MNG_COPY (pWork, pTempdata, iDatalen);
-
- *((mng_ptr *)(pChunkdata+pTempfield->iOffsetchunk)) = pWork;
- *((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunklen)) = iDatalen;
- }
-
- if (pTempfield->iFlags & MNG_FIELD_TERMINATOR)
- iDatalen++; /* skip the terminating zero as well !!! */
-
- iTemplen -= iDatalen;
- pTempdata += iDatalen;
- }
- /* need to set an indicator ? */
- if (pTempfield->iOffsetchunkind)
- *((mng_uint8p)(pChunkdata+pTempfield->iOffsetchunkind)) = MNG_TRUE;
- }
- }
-
- if (pTempfield->pSpecialfunc) /* special function required ? */
- {
- iRetcode = pTempfield->pSpecialfunc(pData, *ppChunk, &iTemplen, &pTempdata);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-
- pTempfield++; /* Neeeeeeexxxtt */
- iFieldcount--;
- }
-
- if (iTemplen) /* extra data ??? */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- while (iFieldcount) /* not enough data ??? */
- {
- if (pTempfield->iFlags & MNG_FIELD_IFIMGTYPES)
- bProcess = (mng_bool)(((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE0) && (iColortype == 0)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE2) && (iColortype == 2)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE3) && (iColortype == 3)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE4) && (iColortype == 4)) ||
- ((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE6) && (iColortype == 6)) );
- else
- bProcess = MNG_TRUE;
-
- if (bProcess)
- {
- if (!(pTempfield->iFlags & MNG_FIELD_OPTIONAL))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- if ((pTempfield->iFlags & MNG_FIELD_GROUPMASK) &&
- ((mng_uint16)(pTempfield->iFlags & MNG_FIELD_GROUPMASK) == iLastgroup))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
- pTempfield++;
- iFieldcount--;
- }
- }
- }
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-READ_CHUNK (mng_read_general)
-{
- mng_retcode iRetcode = MNG_NOERROR;
- mng_chunk_descp pDescr = ((mng_chunk_headerp)pHeader)->pChunkdescr;
- mng_field_descp pField;
- mng_uint16 iFields;
-
- if (!pDescr) /* this is a bad booboo !!! */
- MNG_ERROR (pData, MNG_INTERNALERROR);
-
- pField = pDescr->pFielddesc;
- iFields = pDescr->iFielddesc;
- /* check chunk against signature */
- if ((pDescr->eImgtype == mng_it_mng) && (pData->eSigtype != mng_it_mng))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
-
- if ((pDescr->eImgtype == mng_it_jng) && (pData->eSigtype == mng_it_png))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
- /* empties allowed ? */
- if ((iRawlen == 0) && (!(pDescr->iAllowed & MNG_DESCR_EMPTY)))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->eImagetype != mng_it_mng) || (!(pDescr->iAllowed & MNG_DESCR_GLOBAL)))
- { /* *a* header required ? */
- if ((pDescr->iMusthaves & MNG_DESCR_GenHDR) &&
-#ifdef MNG_INCLUDE_JNG
- (!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- (!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pDescr->iMusthaves & MNG_DESCR_JngHDR) &&
- (!pData->bHasDHDR) && (!pData->bHasJHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-#endif
- }
- /* specific chunk pre-requisite ? */
- if (((pDescr->iMusthaves & MNG_DESCR_IHDR) && (!pData->bHasIHDR)) ||
-#ifdef MNG_INCLUDE_JNG
- ((pDescr->iMusthaves & MNG_DESCR_JHDR) && (!pData->bHasJHDR)) ||
-#endif
- ((pDescr->iMusthaves & MNG_DESCR_DHDR) && (!pData->bHasDHDR)) ||
- ((pDescr->iMusthaves & MNG_DESCR_LOOP) && (!pData->bHasLOOP)) ||
- ((pDescr->iMusthaves & MNG_DESCR_PLTE) && (!pData->bHasPLTE)) ||
- ((pDescr->iMusthaves & MNG_DESCR_MHDR) && (!pData->bHasMHDR)) ||
- ((pDescr->iMusthaves & MNG_DESCR_SAVE) && (!pData->bHasSAVE)) )
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* specific chunk undesired ? */
- if (((pDescr->iMustNOThaves & MNG_DESCR_NOIHDR) && (pData->bHasIHDR)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOBASI) && (pData->bHasBASI)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NODHDR) && (pData->bHasDHDR)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOIDAT) && (pData->bHasIDAT)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOPLTE) && (pData->bHasPLTE)) ||
-#ifdef MNG_INCLUDE_JNG
- ((pDescr->iMustNOThaves & MNG_DESCR_NOJHDR) && (pData->bHasJHDR)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOJDAT) && (pData->bHasJDAT)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOJDAA) && (pData->bHasJDAA)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOJSEP) && (pData->bHasJSEP)) ||
-#endif
- ((pDescr->iMustNOThaves & MNG_DESCR_NOMHDR) && (pData->bHasMHDR)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOLOOP) && (pData->bHasLOOP)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOTERM) && (pData->bHasTERM)) ||
- ((pDescr->iMustNOThaves & MNG_DESCR_NOSAVE) && (pData->bHasSAVE)) )
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (pData->eSigtype == mng_it_mng) /* check global and embedded empty chunks */
- {
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- {
- if ((iRawlen == 0) && (!(pDescr->iAllowed & MNG_DESCR_EMPTYEMBED)))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- } else {
- if ((iRawlen == 0) && (!(pDescr->iAllowed & MNG_DESCR_EMPTYGLOBAL)))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- }
-
- if (pDescr->pSpecialfunc) /* need special processing ? */
- {
- iRetcode = create_chunk_storage (pData, pHeader, iRawlen, pRawdata,
- pField, iFields, ppChunk, MNG_TRUE);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* empty indicator ? */
- if ((!iRawlen) && (pDescr->iOffsetempty))
- *(((mng_uint8p)*ppChunk)+pDescr->iOffsetempty) = MNG_TRUE;
-
- iRetcode = pDescr->pSpecialfunc(pData, *ppChunk);
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- if ((((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_IDAT) ||
- (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAT) ||
- (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAA) )
- {
- iRetcode = ((mng_chunk_headerp)*ppChunk)->fCleanup (pData, *ppChunk);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- *ppChunk = MNG_NULL;
- } else {
-#ifdef MNG_STORE_CHUNKS
- if (!pData->bStorechunks)
-#endif
- {
- iRetcode = ((mng_chunk_headerp)*ppChunk)->fCleanup (pData, *ppChunk);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- *ppChunk = MNG_NULL;
- }
- }
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- if (iRawlen)
- {
-#ifdef MNG_OPTIMIZE_DISPLAYCALLS
- pData->iRawlen = iRawlen;
- pData->pRawdata = pRawdata;
-#endif
-
- /* display processing */
-#ifndef MNG_OPTIMIZE_DISPLAYCALLS
- if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_IDAT)
- iRetcode = mng_process_display_idat (pData, iRawlen, pRawdata);
-#ifdef MNG_INCLUDE_JNG
- else
- if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAT)
- iRetcode = mng_process_display_jdat (pData, iRawlen, pRawdata);
- else
- if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAA)
- iRetcode = mng_process_display_jdaa (pData, iRawlen, pRawdata);
-#endif
-#else
- if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_IDAT)
- iRetcode = mng_process_display_idat (pData);
-#ifdef MNG_INCLUDE_JNG
- else
- if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAT)
- iRetcode = mng_process_display_jdat (pData);
- else
- if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAA)
- iRetcode = mng_process_display_jdaa (pData);
-#endif
-#endif
-
- if (iRetcode)
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if ((pData->bStorechunks) && (!(*ppChunk)))
- {
- iRetcode = create_chunk_storage (pData, pHeader, iRawlen, pRawdata,
- pField, iFields, ppChunk, MNG_FALSE);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* empty indicator ? */
- if ((!iRawlen) && (pDescr->iOffsetempty))
- *(((mng_uint8p)*ppChunk)+pDescr->iOffsetempty) = MNG_TRUE;
- }
-#endif /* MNG_STORE_CHUNKS */
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#endif /* MNG_OPTIMIZE_CHUNKREADER */
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_ihdr)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IHDR, MNG_LC_START);
-#endif
-
- if (iRawlen != 13) /* length oke ? */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- /* only allowed inside PNG or MNG */
- if ((pData->eSigtype != mng_it_png) && (pData->eSigtype != mng_it_mng))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
- /* sequence checks */
- if ((pData->eSigtype == mng_it_png) && (pData->iChunkseq > 1))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasIDAT) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasIDAT))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- pData->bHasIHDR = MNG_TRUE; /* indicate IHDR is present */
- /* and store interesting fields */
- if ((!pData->bHasDHDR) || (pData->iDeltatype == MNG_DELTATYPE_NOCHANGE))
- {
- pData->iDatawidth = mng_get_uint32 (pRawdata);
- pData->iDataheight = mng_get_uint32 (pRawdata+4);
- }
-
- pData->iBitdepth = *(pRawdata+8);
- pData->iColortype = *(pRawdata+9);
- pData->iCompression = *(pRawdata+10);
- pData->iFilter = *(pRawdata+11);
- pData->iInterlace = *(pRawdata+12);
-
-#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
- pData->iPNGmult = 1;
- pData->iPNGdepth = pData->iBitdepth;
-#endif
-
-#ifdef MNG_NO_1_2_4BIT_SUPPORT
- if (pData->iBitdepth < 8)
- pData->iBitdepth = 8;
-#endif
-
-#ifdef MNG_NO_16BIT_SUPPORT
- if (pData->iBitdepth > 8)
- {
- pData->iBitdepth = 8;
- pData->iPNGmult = 2;
- }
-#endif
-
- if ((pData->iBitdepth != 8) /* parameter validity checks */
-#ifndef MNG_NO_1_2_4BIT_SUPPORT
- && (pData->iBitdepth != 1) &&
- (pData->iBitdepth != 2) &&
- (pData->iBitdepth != 4)
-#endif
-#ifndef MNG_NO_16BIT_SUPPORT
- && (pData->iBitdepth != 16)
-#endif
- )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if ((pData->iColortype != MNG_COLORTYPE_GRAY ) &&
- (pData->iColortype != MNG_COLORTYPE_RGB ) &&
- (pData->iColortype != MNG_COLORTYPE_INDEXED) &&
- (pData->iColortype != MNG_COLORTYPE_GRAYA ) &&
- (pData->iColortype != MNG_COLORTYPE_RGBA ) )
- MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
-
- if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if (((pData->iColortype == MNG_COLORTYPE_RGB ) ||
- (pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
- (pData->iColortype == MNG_COLORTYPE_RGBA ) ) &&
- (pData->iBitdepth < 8 ) )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
-#if defined(FILTER192) || defined(FILTER193)
- if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
-#if defined(FILTER192) && defined(FILTER193)
- (pData->iFilter != MNG_FILTER_DIFFERING) &&
- (pData->iFilter != MNG_FILTER_NOFILTER ) )
-#else
-#ifdef FILTER192
- (pData->iFilter != MNG_FILTER_DIFFERING) )
-#else
- (pData->iFilter != MNG_FILTER_NOFILTER ) )
-#endif
-#endif
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-#else
- if (pData->iFilter)
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-#endif
-
- if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
- (pData->iInterlace != MNG_INTERLACE_ADAM7) )
- MNG_ERROR (pData, MNG_INVALIDINTERLACE);
-
-#ifdef MNG_SUPPORT_DISPLAY
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* check the colortype for delta-images ! */
- {
- mng_imagedatap pBuf = ((mng_imagep)pData->pObjzero)->pImgbuf;
-
- if (pData->iColortype != pBuf->iColortype)
- {
- if ( ( (pData->iColortype != MNG_COLORTYPE_INDEXED) ||
- (pBuf->iColortype == MNG_COLORTYPE_GRAY ) ) &&
- ( (pData->iColortype != MNG_COLORTYPE_GRAY ) ||
- (pBuf->iColortype == MNG_COLORTYPE_INDEXED) ) )
- MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
- }
- }
-#endif
-#endif
-
- if (!pData->bHasheader) /* first chunk ? */
- {
- pData->bHasheader = MNG_TRUE; /* we've got a header */
- pData->eImagetype = mng_it_png; /* then this must be a PNG */
- pData->iWidth = pData->iDatawidth;
- pData->iHeight = pData->iDataheight;
- /* predict alpha-depth ! */
- if ((pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
- (pData->iColortype == MNG_COLORTYPE_RGBA ) )
- pData->iAlphadepth = pData->iBitdepth;
- else
- if (pData->iColortype == MNG_COLORTYPE_INDEXED)
- pData->iAlphadepth = 8; /* worst case scenario */
- else
- pData->iAlphadepth = 1; /* Possible tRNS cheap binary transparency */
- /* fits on maximum canvas ? */
- if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
- MNG_WARNING (pData, MNG_IMAGETOOLARGE);
-
-#if !defined(MNG_INCLUDE_MPNG_PROPOSAL) || !defined(MNG_SUPPORT_DISPLAY)
- if (pData->fProcessheader) /* inform the app ? */
- if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
- MNG_ERROR (pData, MNG_APPMISCERROR);
-#endif
- }
-
- if (!pData->bHasDHDR)
- pData->iImagelevel++; /* one level deeper */
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode = mng_process_display_ihdr (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the fields */
- ((mng_ihdrp)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
- ((mng_ihdrp)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
- ((mng_ihdrp)*ppChunk)->iBitdepth = pData->iBitdepth;
- ((mng_ihdrp)*ppChunk)->iColortype = pData->iColortype;
- ((mng_ihdrp)*ppChunk)->iCompression = pData->iCompression;
- ((mng_ihdrp)*ppChunk)->iFilter = pData->iFilter;
- ((mng_ihdrp)*ppChunk)->iInterlace = pData->iInterlace;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif /* MNG_OPTIMIZE_CHUNKREADER */
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_plte)
-{
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- mng_uint32 iX;
- mng_uint8p pRawdata2;
-#endif
-#ifdef MNG_SUPPORT_DISPLAY
- mng_uint32 iRawlen2;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PLTE, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasJHDR))
-#else
- if (pData->bHasIDAT)
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* multiple PLTE only inside BASI */
- if ((pData->bHasPLTE) && (!pData->bHasBASI))
- MNG_ERROR (pData, MNG_MULTIPLEERROR);
- /* length must be multiple of 3 */
- if (((iRawlen % 3) != 0) || (iRawlen > 768))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- { /* only allowed for indexed-color or
- rgb(a)-color! */
- if ((pData->iColortype != 2) && (pData->iColortype != 3) && (pData->iColortype != 6))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
- /* empty only allowed if global present */
- if ((iRawlen == 0) && (!pData->bHasglobalPLTE))
- MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
- }
- else
- {
- if (iRawlen == 0) /* cannot be empty as global! */
- MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
- }
-
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- pData->bHasPLTE = MNG_TRUE; /* got it! */
- else
- pData->bHasglobalPLTE = MNG_TRUE;
-
- pData->iPLTEcount = iRawlen / 3;
-
-#ifdef MNG_SUPPORT_DISPLAY
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- {
- mng_imagep pImage;
- mng_imagedatap pBuf;
-
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* processing delta-image ? */
- { /* store in object 0 !!! */
- pImage = (mng_imagep)pData->pObjzero;
- pBuf = pImage->pImgbuf;
- pBuf->bHasPLTE = MNG_TRUE; /* it's definitely got a PLTE now */
- pBuf->iPLTEcount = iRawlen / 3; /* this is the exact length */
- pRawdata2 = pRawdata; /* copy the entries */
-
- for (iX = 0; iX < iRawlen / 3; iX++)
- {
- pBuf->aPLTEentries[iX].iRed = *pRawdata2;
- pBuf->aPLTEentries[iX].iGreen = *(pRawdata2+1);
- pBuf->aPLTEentries[iX].iBlue = *(pRawdata2+2);
-
- pRawdata2 += 3;
- }
- }
- else
-#endif
- { /* get the current object */
- pImage = (mng_imagep)pData->pCurrentobj;
-
- if (!pImage) /* no object then dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
-
- pBuf = pImage->pImgbuf; /* address the object buffer */
- pBuf->bHasPLTE = MNG_TRUE; /* and tell it it's got a PLTE now */
-
- if (!iRawlen) /* if empty, inherit from global */
- {
- pBuf->iPLTEcount = pData->iGlobalPLTEcount;
- MNG_COPY (pBuf->aPLTEentries, pData->aGlobalPLTEentries,
- sizeof (pBuf->aPLTEentries));
-
- if (pData->bHasglobalTRNS) /* also copy global tRNS ? */
- { /* indicate tRNS available */
- pBuf->bHasTRNS = MNG_TRUE;
-
- iRawlen2 = pData->iGlobalTRNSrawlen;
- pRawdata2 = (mng_uint8p)(pData->aGlobalTRNSrawdata);
- /* global length oke ? */
- if ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount))
- MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
- /* copy it */
- pBuf->iTRNScount = iRawlen2;
- MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2);
- }
- }
- else
- { /* store fields for future reference */
- pBuf->iPLTEcount = iRawlen / 3;
- pRawdata2 = pRawdata;
-
- for (iX = 0; iX < pBuf->iPLTEcount; iX++)
- {
- pBuf->aPLTEentries[iX].iRed = *pRawdata2;
- pBuf->aPLTEentries[iX].iGreen = *(pRawdata2+1);
- pBuf->aPLTEentries[iX].iBlue = *(pRawdata2+2);
-
- pRawdata2 += 3;
- }
- }
- }
- }
- else /* store as global */
- {
- pData->iGlobalPLTEcount = iRawlen / 3;
- pRawdata2 = pRawdata;
-
- for (iX = 0; iX < pData->iGlobalPLTEcount; iX++)
- {
- pData->aGlobalPLTEentries[iX].iRed = *pRawdata2;
- pData->aGlobalPLTEentries[iX].iGreen = *(pRawdata2+1);
- pData->aGlobalPLTEentries[iX].iBlue = *(pRawdata2+2);
-
- pRawdata2 += 3;
- }
-
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_plte (pData, pData->iGlobalPLTEcount,
- pData->aGlobalPLTEentries);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_pltep)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_pltep)*ppChunk)->iEntrycount = iRawlen / 3;
- pRawdata2 = pRawdata;
-
- for (iX = 0; iX < ((mng_pltep)*ppChunk)->iEntrycount; iX++)
- {
- ((mng_pltep)*ppChunk)->aEntries[iX].iRed = *pRawdata2;
- ((mng_pltep)*ppChunk)->aEntries[iX].iGreen = *(pRawdata2+1);
- ((mng_pltep)*ppChunk)->aEntries[iX].iBlue = *(pRawdata2+2);
-
- pRawdata2 += 3;
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PLTE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif /* MNG_OPTIMIZE_CHUNKREADER */
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_idat)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IDAT, MNG_LC_START);
-#endif
-
-#ifdef MNG_INCLUDE_JNG /* sequence checks */
- if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasJHDR) &&
- (pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (pData->bHasJSEP)
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-#endif
- /* not allowed for deltatype NO_CHANGE */
-#ifndef MNG_NO_DELTA_PNG
- if ((pData->bHasDHDR) && ((pData->iDeltatype == MNG_DELTATYPE_NOCHANGE)))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
-#endif
- /* can only be empty in BASI-block! */
- if ((iRawlen == 0) && (!pData->bHasBASI))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- /* indexed-color requires PLTE */
- if ((pData->bHasIHDR) && (pData->iColortype == 3) && (!pData->bHasPLTE))
- MNG_ERROR (pData, MNG_PLTEMISSING);
-
- pData->bHasIDAT = MNG_TRUE; /* got some IDAT now, don't we */
-
-#ifdef MNG_SUPPORT_DISPLAY
- if (iRawlen)
- { /* display processing */
- mng_retcode iRetcode = mng_process_display_idat (pData, iRawlen, pRawdata);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_idatp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_idatp)*ppChunk)->iDatasize = iRawlen;
-
- if (iRawlen != 0) /* is there any data ? */
- {
- MNG_ALLOC (pData, ((mng_idatp)*ppChunk)->pData, iRawlen);
- MNG_COPY (((mng_idatp)*ppChunk)->pData, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IDAT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_iend)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IEND, MNG_LC_START);
-#endif
-
- if (iRawlen > 0) /* must not contain data! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_INCLUDE_JNG /* sequence checks */
- if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* IHDR-block requires IDAT */
- if ((pData->bHasIHDR) && (!pData->bHasIDAT))
- MNG_ERROR (pData, MNG_IDATMISSING);
-
- pData->iImagelevel--; /* one level up */
-
-#ifdef MNG_SUPPORT_DISPLAY
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_image (pData);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* display processing */
- iRetcode = mng_process_display_iend (pData);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_SUPPORT_DISPLAY
- if (!pData->bTimerset) /* reset only if not broken !!! */
- {
-#endif
- /* IEND signals the end for most ... */
- pData->bHasIHDR = MNG_FALSE;
- pData->bHasBASI = MNG_FALSE;
- pData->bHasDHDR = MNG_FALSE;
-#ifdef MNG_INCLUDE_JNG
- pData->bHasJHDR = MNG_FALSE;
- pData->bHasJSEP = MNG_FALSE;
- pData->bHasJDAA = MNG_FALSE;
- pData->bHasJDAT = MNG_FALSE;
-#endif
- pData->bHasPLTE = MNG_FALSE;
- pData->bHasTRNS = MNG_FALSE;
- pData->bHasGAMA = MNG_FALSE;
- pData->bHasCHRM = MNG_FALSE;
- pData->bHasSRGB = MNG_FALSE;
- pData->bHasICCP = MNG_FALSE;
- pData->bHasBKGD = MNG_FALSE;
- pData->bHasIDAT = MNG_FALSE;
-#ifdef MNG_SUPPORT_DISPLAY
- }
-#endif
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IEND, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_trns)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TRNS, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasJHDR))
-#else
- if (pData->bHasIDAT)
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* multiple tRNS only inside BASI */
- if ((pData->bHasTRNS) && (!pData->bHasBASI))
- MNG_ERROR (pData, MNG_MULTIPLEERROR);
-
- if (iRawlen > 256) /* it just can't be bigger than that! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- { /* not allowed with full alpha-channel */
- if ((pData->iColortype == 4) || (pData->iColortype == 6))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
-
- if (iRawlen != 0) /* filled ? */
- { /* length checks */
- if ((pData->iColortype == 0) && (iRawlen != 2))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iColortype == 2) && (iRawlen != 6))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- if (pData->iColortype == 3)
- {
- mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
- mng_imagedatap pBuf;
-
- if (!pImage) /* no object then check obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
-
- pBuf = pImage->pImgbuf; /* address object buffer */
-
- if (iRawlen > pBuf->iPLTEcount)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-#endif
- }
- else /* if empty there must be global stuff! */
- {
- if (!pData->bHasglobalTRNS)
- MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
- }
- }
-
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- pData->bHasTRNS = MNG_TRUE; /* indicate tRNS available */
- else
- pData->bHasglobalTRNS = MNG_TRUE;
-
-#ifdef MNG_SUPPORT_DISPLAY
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- {
- mng_imagep pImage;
- mng_imagedatap pBuf;
- mng_uint8p pRawdata2;
- mng_uint32 iRawlen2;
-
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* processing delta-image ? */
- { /* store in object 0 !!! */
- pImage = (mng_imagep)pData->pObjzero;
- pBuf = pImage->pImgbuf; /* address object buffer */
-
- switch (pData->iColortype) /* store fields for future reference */
- {
- case 0: { /* gray */
-#if defined(MNG_NO_1_2_4BIT_SUPPORT)
- mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1,
- 0,0,0,0,0,0,0,1};
-#endif
- pBuf->iTRNSgray = mng_get_uint16 (pRawdata);
- pBuf->iTRNSred = 0;
- pBuf->iTRNSgreen = 0;
- pBuf->iTRNSblue = 0;
- pBuf->iTRNScount = 0;
-#if defined(MNG_NO_1_2_4BIT_SUPPORT)
- pBuf->iTRNSgray *= multiplier[pData->iPNGdepth];
-#endif
-#if defined(MNG_NO_16BIT_SUPPORT)
- if (pData->iPNGmult == 2)
- pBuf->iTRNSgray >>= 8;
-#endif
- break;
- }
- case 2: { /* rgb */
- pBuf->iTRNSgray = 0;
- pBuf->iTRNSred = mng_get_uint16 (pRawdata);
- pBuf->iTRNSgreen = mng_get_uint16 (pRawdata+2);
- pBuf->iTRNSblue = mng_get_uint16 (pRawdata+4);
- pBuf->iTRNScount = 0;
-#if defined(MNG_NO_16BIT_SUPPORT)
- if (pData->iPNGmult == 2)
- {
- pBuf->iTRNSred >>= 8;
- pBuf->iTRNSgreen >>= 8;
- pBuf->iTRNSblue >>= 8;
- }
-#endif
- break;
- }
- case 3: { /* indexed */
- pBuf->iTRNSgray = 0;
- pBuf->iTRNSred = 0;
- pBuf->iTRNSgreen = 0;
- pBuf->iTRNSblue = 0;
- pBuf->iTRNScount = iRawlen;
- MNG_COPY (pBuf->aTRNSentries, pRawdata, iRawlen);
- break;
- }
- }
-
- pBuf->bHasTRNS = MNG_TRUE; /* tell it it's got a tRNS now */
- }
- else
-#endif
- { /* address current object */
- pImage = (mng_imagep)pData->pCurrentobj;
-
- if (!pImage) /* no object then dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
-
- pBuf = pImage->pImgbuf; /* address object buffer */
- pBuf->bHasTRNS = MNG_TRUE; /* and tell it it's got a tRNS now */
-
- if (iRawlen == 0) /* if empty, inherit from global */
- {
- iRawlen2 = pData->iGlobalTRNSrawlen;
- pRawdata2 = (mng_ptr)(pData->aGlobalTRNSrawdata);
- /* global length oke ? */
- if ((pData->iColortype == 0) && (iRawlen2 != 2))
- MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
-
- if ((pData->iColortype == 2) && (iRawlen2 != 6))
- MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
-
- if ((pData->iColortype == 3) && ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount)))
- MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
- }
- else
- {
- iRawlen2 = iRawlen;
- pRawdata2 = pRawdata;
- }
-
- switch (pData->iColortype) /* store fields for future reference */
- {
- case 0: { /* gray */
- pBuf->iTRNSgray = mng_get_uint16 (pRawdata2);
- pBuf->iTRNSred = 0;
- pBuf->iTRNSgreen = 0;
- pBuf->iTRNSblue = 0;
- pBuf->iTRNScount = 0;
-#if defined(MNG_NO_16BIT_SUPPORT)
- if (pData->iPNGmult == 2)
- pBuf->iTRNSgray >>= 8;
-#endif
- break;
- }
- case 2: { /* rgb */
- pBuf->iTRNSgray = 0;
- pBuf->iTRNSred = mng_get_uint16 (pRawdata2);
- pBuf->iTRNSgreen = mng_get_uint16 (pRawdata2+2);
- pBuf->iTRNSblue = mng_get_uint16 (pRawdata2+4);
- pBuf->iTRNScount = 0;
-#if defined(MNG_NO_16BIT_SUPPORT)
- if (pData->iPNGmult == 2)
- {
- pBuf->iTRNSred >>= 8;
- pBuf->iTRNSgreen >>= 8;
- pBuf->iTRNSblue >>= 8;
- }
-#endif
- break;
- }
- case 3: { /* indexed */
- pBuf->iTRNSgray = 0;
- pBuf->iTRNSred = 0;
- pBuf->iTRNSgreen = 0;
- pBuf->iTRNSblue = 0;
- pBuf->iTRNScount = iRawlen2;
- MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2);
- break;
- }
- }
- }
- }
- else /* store as global */
- {
- pData->iGlobalTRNSrawlen = iRawlen;
- MNG_COPY (pData->aGlobalTRNSrawdata, pRawdata, iRawlen);
-
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_trns (pData, pData->iGlobalTRNSrawlen,
- pData->aGlobalTRNSrawdata);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- { /* not global! */
- ((mng_trnsp)*ppChunk)->bGlobal = MNG_FALSE;
- ((mng_trnsp)*ppChunk)->iType = pData->iColortype;
-
- if (iRawlen == 0) /* if empty, indicate so */
- ((mng_trnsp)*ppChunk)->bEmpty = MNG_TRUE;
- else
- {
- ((mng_trnsp)*ppChunk)->bEmpty = MNG_FALSE;
-
- switch (pData->iColortype) /* store fields */
- {
- case 0: { /* gray */
- ((mng_trnsp)*ppChunk)->iGray = mng_get_uint16 (pRawdata);
- break;
- }
- case 2: { /* rgb */
- ((mng_trnsp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
- ((mng_trnsp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
- ((mng_trnsp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
- break;
- }
- case 3: { /* indexed */
- ((mng_trnsp)*ppChunk)->iCount = iRawlen;
- MNG_COPY (((mng_trnsp)*ppChunk)->aEntries, pRawdata, iRawlen);
- break;
- }
- }
- }
- }
- else /* it's global! */
- {
- ((mng_trnsp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_trnsp)*ppChunk)->bGlobal = MNG_TRUE;
- ((mng_trnsp)*ppChunk)->iType = 0;
- ((mng_trnsp)*ppChunk)->iRawlen = iRawlen;
-
- MNG_COPY (((mng_trnsp)*ppChunk)->aRawdata, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TRNS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_gama)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_GAMA, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if ((pData->bHasIDAT) || (pData->bHasPLTE))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- { /* length must be exactly 4 */
- if (iRawlen != 4)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- { /* length must be empty or exactly 4 */
- if ((iRawlen != 0) && (iRawlen != 4))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- pData->bHasGAMA = MNG_TRUE; /* indicate we've got it */
- else
- pData->bHasglobalGAMA = (mng_bool)(iRawlen != 0);
-
-#ifdef MNG_SUPPORT_DISPLAY
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- {
- mng_imagep pImage;
-
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* update delta image ? */
- { /* store in object 0 ! */
- pImage = (mng_imagep)pData->pObjzero;
- /* store for color-processing routines */
- pImage->pImgbuf->iGamma = mng_get_uint32 (pRawdata);
- pImage->pImgbuf->bHasGAMA = MNG_TRUE;
- }
- else
-#endif
- {
- pImage = (mng_imagep)pData->pCurrentobj;
-
- if (!pImage) /* no object then dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
- /* store for color-processing routines */
- pImage->pImgbuf->iGamma = mng_get_uint32 (pRawdata);
- pImage->pImgbuf->bHasGAMA = MNG_TRUE;
- }
- }
- else
- { /* store as global */
- if (iRawlen != 0)
- pData->iGlobalGamma = mng_get_uint32 (pRawdata);
-
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_gama (pData, (mng_bool)(iRawlen == 0),
- pData->iGlobalGamma);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_gamap)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- ((mng_gamap)*ppChunk)->iGamma = mng_get_uint32 (pRawdata);
-
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_GAMA, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_cHRM
-READ_CHUNK (mng_read_chrm)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_CHRM, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if ((pData->bHasIDAT) || (pData->bHasPLTE))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- { /* length must be exactly 32 */
- if (iRawlen != 32)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- { /* length must be empty or exactly 32 */
- if ((iRawlen != 0) && (iRawlen != 32))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- pData->bHasCHRM = MNG_TRUE; /* indicate we've got it */
- else
- pData->bHasglobalCHRM = (mng_bool)(iRawlen != 0);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_uint32 iWhitepointx, iWhitepointy;
- mng_uint32 iPrimaryredx, iPrimaryredy;
- mng_uint32 iPrimarygreenx, iPrimarygreeny;
- mng_uint32 iPrimarybluex, iPrimarybluey;
-
- iWhitepointx = mng_get_uint32 (pRawdata);
- iWhitepointy = mng_get_uint32 (pRawdata+4);
- iPrimaryredx = mng_get_uint32 (pRawdata+8);
- iPrimaryredy = mng_get_uint32 (pRawdata+12);
- iPrimarygreenx = mng_get_uint32 (pRawdata+16);
- iPrimarygreeny = mng_get_uint32 (pRawdata+20);
- iPrimarybluex = mng_get_uint32 (pRawdata+24);
- iPrimarybluey = mng_get_uint32 (pRawdata+28);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- {
- mng_imagep pImage;
- mng_imagedatap pBuf;
-
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* update delta image ? */
- { /* store it in object 0 ! */
- pImage = (mng_imagep)pData->pObjzero;
-
- pBuf = pImage->pImgbuf; /* address object buffer */
- pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */
- /* store for color-processing routines */
- pBuf->iWhitepointx = iWhitepointx;
- pBuf->iWhitepointy = iWhitepointy;
- pBuf->iPrimaryredx = iPrimaryredx;
- pBuf->iPrimaryredy = iPrimaryredy;
- pBuf->iPrimarygreenx = iPrimarygreenx;
- pBuf->iPrimarygreeny = iPrimarygreeny;
- pBuf->iPrimarybluex = iPrimarybluex;
- pBuf->iPrimarybluey = iPrimarybluey;
- }
- else
-#endif
- {
- pImage = (mng_imagep)pData->pCurrentobj;
-
- if (!pImage) /* no object then dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
-
- pBuf = pImage->pImgbuf; /* address object buffer */
- pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */
- /* store for color-processing routines */
- pBuf->iWhitepointx = iWhitepointx;
- pBuf->iWhitepointy = iWhitepointy;
- pBuf->iPrimaryredx = iPrimaryredx;
- pBuf->iPrimaryredy = iPrimaryredy;
- pBuf->iPrimarygreenx = iPrimarygreenx;
- pBuf->iPrimarygreeny = iPrimarygreeny;
- pBuf->iPrimarybluex = iPrimarybluex;
- pBuf->iPrimarybluey = iPrimarybluey;
- }
- }
- else
- { /* store as global */
- if (iRawlen != 0)
- {
- pData->iGlobalWhitepointx = iWhitepointx;
- pData->iGlobalWhitepointy = iWhitepointy;
- pData->iGlobalPrimaryredx = iPrimaryredx;
- pData->iGlobalPrimaryredy = iPrimaryredy;
- pData->iGlobalPrimarygreenx = iPrimarygreenx;
- pData->iGlobalPrimarygreeny = iPrimarygreeny;
- pData->iGlobalPrimarybluex = iPrimarybluex;
- pData->iGlobalPrimarybluey = iPrimarybluey;
- }
-
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_chrm (pData, (mng_bool)(iRawlen == 0),
- iWhitepointx, iWhitepointy,
- iPrimaryredx, iPrimaryredy,
- iPrimarygreenx, iPrimarygreeny,
- iPrimarybluex, iPrimarybluey);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_chrmp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
- ((mng_chrmp)*ppChunk)->iWhitepointx = mng_get_uint32 (pRawdata);
- ((mng_chrmp)*ppChunk)->iWhitepointy = mng_get_uint32 (pRawdata+4);
- ((mng_chrmp)*ppChunk)->iRedx = mng_get_uint32 (pRawdata+8);
- ((mng_chrmp)*ppChunk)->iRedy = mng_get_uint32 (pRawdata+12);
- ((mng_chrmp)*ppChunk)->iGreenx = mng_get_uint32 (pRawdata+16);
- ((mng_chrmp)*ppChunk)->iGreeny = mng_get_uint32 (pRawdata+20);
- ((mng_chrmp)*ppChunk)->iBluex = mng_get_uint32 (pRawdata+24);
- ((mng_chrmp)*ppChunk)->iBluey = mng_get_uint32 (pRawdata+28);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_CHRM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_srgb)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SRGB, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if ((pData->bHasIDAT) || (pData->bHasPLTE))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- { /* length must be exactly 1 */
- if (iRawlen != 1)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- { /* length must be empty or exactly 1 */
- if ((iRawlen != 0) && (iRawlen != 1))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- pData->bHasSRGB = MNG_TRUE; /* indicate we've got it */
- else
- pData->bHasglobalSRGB = (mng_bool)(iRawlen != 0);
-
-#ifdef MNG_SUPPORT_DISPLAY
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- {
- mng_imagep pImage;
-
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* update delta image ? */
- { /* store in object 0 ! */
- pImage = (mng_imagep)pData->pObjzero;
- /* store for color-processing routines */
- pImage->pImgbuf->iRenderingintent = *pRawdata;
- pImage->pImgbuf->bHasSRGB = MNG_TRUE;
- }
- else
-#endif
- {
- pImage = (mng_imagep)pData->pCurrentobj;
-
- if (!pImage) /* no object then dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
- /* store for color-processing routines */
- pImage->pImgbuf->iRenderingintent = *pRawdata;
- pImage->pImgbuf->bHasSRGB = MNG_TRUE;
- }
- }
- else
- { /* store as global */
- if (iRawlen != 0)
- pData->iGlobalRendintent = *pRawdata;
-
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_srgb (pData, (mng_bool)(iRawlen == 0),
- pData->iGlobalRendintent);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_srgbp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- ((mng_srgbp)*ppChunk)->iRenderingintent = *pRawdata;
-
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SRGB, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_iCCP
-READ_CHUNK (mng_read_iccp)
-{
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint32 iCompressedsize;
- mng_uint32 iProfilesize;
- mng_uint32 iBufsize = 0;
- mng_uint8p pBuf = 0;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ICCP, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if ((pData->bHasIDAT) || (pData->bHasPLTE))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- { /* length must be at least 2 */
- if (iRawlen < 2)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- { /* length must be empty or at least 2 */
- if ((iRawlen != 0) && (iRawlen < 2))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
- pTemp = find_null (pRawdata); /* find null-separator */
- /* not found inside input-data ? */
- if ((pTemp - pRawdata) > (mng_int32)iRawlen)
- MNG_ERROR (pData, MNG_NULLNOTFOUND);
- /* determine size of compressed profile */
- iCompressedsize = (mng_uint32)(iRawlen - (pTemp - pRawdata) - 2);
- /* decompress the profile */
- iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
- &pBuf, &iBufsize, &iProfilesize);
-
-#ifdef MNG_CHECK_BAD_ICCP /* Check for bad iCCP chunk */
- if ((iRetcode) && (!strncmp ((char *)pRawdata, "Photoshop ICC profile", 21)))
- {
- if (iRawlen == 2615) /* is it the sRGB profile ? */
- {
- mng_chunk_header chunk_srgb =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_sRGB, mng_init_general, mng_free_general, mng_read_srgb, mng_write_srgb, mng_assign_general, 0, 0, sizeof(mng_srgb)};
-#else
- {MNG_UINT_sRGB, mng_init_srgb, mng_free_srgb, mng_read_srgb, mng_write_srgb, mng_assign_srgb, 0, 0};
-#endif
- /* pretend it's an sRGB chunk then ! */
- iRetcode = mng_read_srgb (pData, &chunk_srgb, 1, (mng_ptr)"0", ppChunk);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- }
- }
- else
- {
-#endif /* MNG_CHECK_BAD_ICCP */
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- pData->bHasICCP = MNG_TRUE; /* indicate we've got it */
- else
- pData->bHasglobalICCP = (mng_bool)(iRawlen != 0);
-
-#ifdef MNG_SUPPORT_DISPLAY
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- {
- mng_imagep pImage;
-
-#ifndef MNG_NO_DELTA_PNG
- if (pData->bHasDHDR) /* update delta image ? */
- { /* store in object 0 ! */
- pImage = (mng_imagep)pData->pObjzero;
-
- if (pImage->pImgbuf->pProfile) /* profile existed ? */
- MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize);
- /* allocate a buffer & copy it */
- MNG_ALLOC (pData, pImage->pImgbuf->pProfile, iProfilesize);
- MNG_COPY (pImage->pImgbuf->pProfile, pBuf, iProfilesize);
- /* store its length as well */
- pImage->pImgbuf->iProfilesize = iProfilesize;
- pImage->pImgbuf->bHasICCP = MNG_TRUE;
- }
- else
-#endif
- {
- pImage = (mng_imagep)pData->pCurrentobj;
-
- if (!pImage) /* no object then dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
-
- if (pImage->pImgbuf->pProfile) /* profile existed ? */
- MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize);
- /* allocate a buffer & copy it */
- MNG_ALLOC (pData, pImage->pImgbuf->pProfile, iProfilesize);
- MNG_COPY (pImage->pImgbuf->pProfile, pBuf, iProfilesize);
- /* store its length as well */
- pImage->pImgbuf->iProfilesize = iProfilesize;
- pImage->pImgbuf->bHasICCP = MNG_TRUE;
- }
- }
- else
- { /* store as global */
- if (iRawlen == 0) /* empty chunk ? */
- {
- if (pData->pGlobalProfile) /* did we have a global profile ? */
- MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize);
-
- pData->iGlobalProfilesize = 0; /* reset to null */
- pData->pGlobalProfile = MNG_NULL;
- }
- else
- { /* allocate a global buffer & copy it */
- MNG_ALLOC (pData, pData->pGlobalProfile, iProfilesize);
- MNG_COPY (pData->pGlobalProfile, pBuf, iProfilesize);
- /* store its length as well */
- pData->iGlobalProfilesize = iProfilesize;
- }
-
- /* create an animation object */
- iRetcode = mng_create_ani_iccp (pData, (mng_bool)(iRawlen == 0),
- pData->iGlobalProfilesize,
- pData->pGlobalProfile);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- /* store the fields */
- ((mng_iccpp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen) /* not empty ? */
- {
- if (!pBuf) /* hasn't been unpuzzled it yet ? */
- { /* find null-separator */
- pTemp = find_null (pRawdata);
- /* not found inside input-data ? */
- if ((pTemp - pRawdata) > (mng_int32)iRawlen)
- MNG_ERROR (pData, MNG_NULLNOTFOUND);
- /* determine size of compressed profile */
- iCompressedsize = iRawlen - (pTemp - pRawdata) - 2;
- /* decompress the profile */
- iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
- &pBuf, &iBufsize, &iProfilesize);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- }
-
- ((mng_iccpp)*ppChunk)->iNamesize = (mng_uint32)(pTemp - pRawdata);
-
- if (((mng_iccpp)*ppChunk)->iNamesize)
- {
- MNG_ALLOC (pData, ((mng_iccpp)*ppChunk)->zName,
- ((mng_iccpp)*ppChunk)->iNamesize + 1);
- MNG_COPY (((mng_iccpp)*ppChunk)->zName, pRawdata,
- ((mng_iccpp)*ppChunk)->iNamesize);
- }
-
- ((mng_iccpp)*ppChunk)->iCompression = *(pTemp+1);
- ((mng_iccpp)*ppChunk)->iProfilesize = iProfilesize;
-
- MNG_ALLOC (pData, ((mng_iccpp)*ppChunk)->pProfile, iProfilesize);
- MNG_COPY (((mng_iccpp)*ppChunk)->pProfile, pBuf, iProfilesize);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
- if (pBuf) /* free the temporary buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
-
-#ifdef MNG_CHECK_BAD_ICCP
- }
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ICCP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_tEXt
-READ_CHUNK (mng_read_text)
-{
- mng_uint32 iKeywordlen, iTextlen;
- mng_pchar zKeyword, zText;
- mng_uint8p pTemp;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TEXT, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 2) /* length must be at least 2 */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pTemp = find_null (pRawdata); /* find the null separator */
- /* not found inside input-data ? */
- if ((pTemp - pRawdata) > (mng_int32)iRawlen)
- MNG_ERROR (pData, MNG_NULLNOTFOUND);
-
- if (pTemp == pRawdata) /* there must be at least 1 char for keyword */
- MNG_ERROR (pData, MNG_KEYWORDNULL);
-
- iKeywordlen = (mng_uint32)(pTemp - pRawdata);
- iTextlen = iRawlen - iKeywordlen - 1;
-
- if (pData->fProcesstext) /* inform the application ? */
- {
- mng_bool bOke;
-
- MNG_ALLOC (pData, zKeyword, iKeywordlen + 1);
- MNG_COPY (zKeyword, pRawdata, iKeywordlen);
-
- MNG_ALLOCX (pData, zText, iTextlen + 1);
-
- if (!zText) /* on error bail out */
- {
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- if (iTextlen)
- MNG_COPY (zText, pTemp+1, iTextlen);
-
- bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_TEXT, zKeyword, zText, 0, 0);
-
- MNG_FREEX (pData, zText, iTextlen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
-
- if (!bOke)
- MNG_ERROR (pData, MNG_APPMISCERROR);
-
- }
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_textp)*ppChunk)->iKeywordsize = iKeywordlen;
- ((mng_textp)*ppChunk)->iTextsize = iTextlen;
-
- if (iKeywordlen)
- {
- MNG_ALLOC (pData, ((mng_textp)*ppChunk)->zKeyword, iKeywordlen+1);
- MNG_COPY (((mng_textp)*ppChunk)->zKeyword, pRawdata, iKeywordlen);
- }
-
- if (iTextlen)
- {
- MNG_ALLOC (pData, ((mng_textp)*ppChunk)->zText, iTextlen+1);
- MNG_COPY (((mng_textp)*ppChunk)->zText, pTemp+1, iTextlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TEXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_zTXt
-READ_CHUNK (mng_read_ztxt)
-{
- mng_retcode iRetcode;
- mng_uint32 iKeywordlen, iTextlen;
- mng_pchar zKeyword;
- mng_uint8p pTemp;
- mng_uint32 iCompressedsize;
- mng_uint32 iBufsize;
- mng_uint8p pBuf;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ZTXT, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 3) /* length must be at least 3 */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pTemp = find_null (pRawdata); /* find the null separator */
- /* not found inside input-data ? */
- if ((pTemp - pRawdata) > (mng_int32)iRawlen)
- MNG_ERROR (pData, MNG_NULLNOTFOUND);
-
- if (pTemp == pRawdata) /* there must be at least 1 char for keyword */
- MNG_ERROR (pData, MNG_KEYWORDNULL);
-
- if (*(pTemp+1) != 0) /* only deflate compression-method allowed */
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
- iKeywordlen = (mng_uint32)(pTemp - pRawdata);
- iCompressedsize = (mng_uint32)(iRawlen - iKeywordlen - 2);
-
- zKeyword = 0; /* there's no keyword buffer yet */
- pBuf = 0; /* or a temporary buffer ! */
-
- if (pData->fProcesstext) /* inform the application ? */
- { /* decompress the text */
- iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
- &pBuf, &iBufsize, &iTextlen);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
-
- MNG_ALLOCX (pData, zKeyword, iKeywordlen+1);
-
- if (!zKeyword) /* on error bail out */
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- MNG_COPY (zKeyword, pRawdata, iKeywordlen);
-
- if (!pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ZTXT, zKeyword, (mng_pchar)pBuf, 0, 0))
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_FREEX (pData, zKeyword, iKeywordlen+1);
- MNG_ERROR (pData, MNG_APPMISCERROR);
- }
- }
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_FREEX (pData, zKeyword, iKeywordlen+1);
- return iRetcode;
- }
- /* store the fields */
- ((mng_ztxtp)*ppChunk)->iKeywordsize = iKeywordlen;
- ((mng_ztxtp)*ppChunk)->iCompression = *(pTemp+1);
-
- if ((!pBuf) && (iCompressedsize)) /* did we not get a text-buffer yet ? */
- { /* decompress the text */
- iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
- &pBuf, &iBufsize, &iTextlen);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_FREEX (pData, zKeyword, iKeywordlen+1);
- return iRetcode;
- }
- }
-
- MNG_ALLOCX (pData, ((mng_ztxtp)*ppChunk)->zKeyword, iKeywordlen + 1);
- /* on error bail out */
- if (!((mng_ztxtp)*ppChunk)->zKeyword)
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_FREEX (pData, zKeyword, iKeywordlen+1);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- MNG_COPY (((mng_ztxtp)*ppChunk)->zKeyword, pRawdata, iKeywordlen);
-
- ((mng_ztxtp)*ppChunk)->iTextsize = iTextlen;
-
- if (iCompressedsize)
- {
- MNG_ALLOCX (pData, ((mng_ztxtp)*ppChunk)->zText, iTextlen + 1);
- /* on error bail out */
- if (!((mng_ztxtp)*ppChunk)->zText)
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_FREEX (pData, zKeyword, iKeywordlen+1);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- MNG_COPY (((mng_ztxtp)*ppChunk)->zText, pBuf, iTextlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
- MNG_FREEX (pData, pBuf, iBufsize); /* free the temporary buffers */
- MNG_FREEX (pData, zKeyword, iKeywordlen+1);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ZTXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_iTXt
-READ_CHUNK (mng_read_itxt)
-{
- mng_retcode iRetcode;
- mng_uint32 iKeywordlen, iTextlen, iLanguagelen, iTranslationlen;
- mng_pchar zKeyword, zLanguage, zTranslation;
- mng_uint8p pNull1, pNull2, pNull3;
- mng_uint32 iCompressedsize;
- mng_uint8 iCompressionflag;
- mng_uint32 iBufsize;
- mng_uint8p pBuf;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ITXT, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 6) /* length must be at least 6 */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pNull1 = find_null (pRawdata); /* find the null separators */
- pNull2 = find_null (pNull1+3);
- pNull3 = find_null (pNull2+1);
- /* not found inside input-data ? */
- if (((pNull1 - pRawdata) > (mng_int32)iRawlen) ||
- ((pNull2 - pRawdata) > (mng_int32)iRawlen) ||
- ((pNull3 - pRawdata) > (mng_int32)iRawlen) )
- MNG_ERROR (pData, MNG_NULLNOTFOUND);
-
- if (pNull1 == pRawdata) /* there must be at least 1 char for keyword */
- MNG_ERROR (pData, MNG_KEYWORDNULL);
- /* compression or not ? */
- if ((*(pNull1+1) != 0) && (*(pNull1+1) != 1))
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
- if (*(pNull1+2) != 0) /* only deflate compression-method allowed */
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
- iKeywordlen = (mng_uint32)(pNull1 - pRawdata);
- iLanguagelen = (mng_uint32)(pNull2 - pNull1 - 3);
- iTranslationlen = (mng_uint32)(pNull3 - pNull2 - 1);
- iCompressedsize = (mng_uint32)(iRawlen - iKeywordlen - iLanguagelen - iTranslationlen - 5);
- iCompressionflag = *(pNull1+1);
-
- zKeyword = 0; /* no buffers acquired yet */
- zLanguage = 0;
- zTranslation = 0;
- pBuf = 0;
- iTextlen = 0;
-
- if (pData->fProcesstext) /* inform the application ? */
- {
- if (iCompressionflag) /* decompress the text ? */
- {
- iRetcode = mng_inflate_buffer (pData, pNull3+1, iCompressedsize,
- &pBuf, &iBufsize, &iTextlen);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffer */
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- }
- else
- {
- iTextlen = iCompressedsize;
- iBufsize = iTextlen+1; /* plus 1 for terminator byte!!! */
-
- MNG_ALLOC (pData, pBuf, iBufsize);
- MNG_COPY (pBuf, pNull3+1, iTextlen);
- }
-
- MNG_ALLOCX (pData, zKeyword, iKeywordlen + 1);
- MNG_ALLOCX (pData, zLanguage, iLanguagelen + 1);
- MNG_ALLOCX (pData, zTranslation, iTranslationlen + 1);
- /* on error bail out */
- if ((!zKeyword) || (!zLanguage) || (!zTranslation))
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- MNG_COPY (zKeyword, pRawdata, iKeywordlen);
- MNG_COPY (zLanguage, pNull1+3, iLanguagelen);
- MNG_COPY (zTranslation, pNull2+1, iTranslationlen);
-
- if (!pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ITXT, zKeyword, (mng_pchar)pBuf,
- zLanguage, zTranslation))
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
-
- MNG_ERROR (pData, MNG_APPMISCERROR);
- }
- }
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- /* store the fields */
- ((mng_itxtp)*ppChunk)->iKeywordsize = iKeywordlen;
- ((mng_itxtp)*ppChunk)->iLanguagesize = iLanguagelen;
- ((mng_itxtp)*ppChunk)->iTranslationsize = iTranslationlen;
- ((mng_itxtp)*ppChunk)->iCompressionflag = *(pNull1+1);
- ((mng_itxtp)*ppChunk)->iCompressionmethod = *(pNull1+2);
-
- if ((!pBuf) && (iCompressedsize)) /* did we not get a text-buffer yet ? */
- {
- if (iCompressionflag) /* decompress the text ? */
- {
- iRetcode = mng_inflate_buffer (pData, pNull3+1, iCompressedsize,
- &pBuf, &iBufsize, &iTextlen);
-
- if (iRetcode) /* on error bail out */
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- }
- else
- {
- iTextlen = iCompressedsize;
- iBufsize = iTextlen+1; /* plus 1 for terminator byte!!! */
-
- MNG_ALLOC (pData, pBuf, iBufsize);
- MNG_COPY (pBuf, pNull3+1, iTextlen);
- }
- }
-
- MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zKeyword, iKeywordlen + 1);
- MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zLanguage, iLanguagelen + 1);
- MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zTranslation, iTranslationlen + 1);
- /* on error bail out */
- if ((!((mng_itxtp)*ppChunk)->zKeyword ) ||
- (!((mng_itxtp)*ppChunk)->zLanguage ) ||
- (!((mng_itxtp)*ppChunk)->zTranslation) )
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- MNG_COPY (((mng_itxtp)*ppChunk)->zKeyword, pRawdata, iKeywordlen);
- MNG_COPY (((mng_itxtp)*ppChunk)->zLanguage, pNull1+3, iLanguagelen);
- MNG_COPY (((mng_itxtp)*ppChunk)->zTranslation, pNull2+1, iTranslationlen);
-
- ((mng_itxtp)*ppChunk)->iTextsize = iTextlen;
-
- if (iTextlen)
- {
- MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zText, iTextlen + 1);
-
- if (!((mng_itxtp)*ppChunk)->zText)
- { /* don't forget to drop the temp buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- MNG_COPY (((mng_itxtp)*ppChunk)->zText, pBuf, iTextlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
- /* free the temporary buffers */
- MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
- MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
- MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
- MNG_FREEX (pData, pBuf, iBufsize);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ITXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_bKGD
-READ_CHUNK (mng_read_bkgd)
-{
-#ifdef MNG_SUPPORT_DISPLAY
- mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
- mng_imagedatap pBuf;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_BKGD, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if (pData->bHasIDAT)
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen > 6) /* it just can't be bigger than that! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_INCLUDE_JNG /* length checks */
- if (pData->bHasJHDR)
- {
- if (((pData->iJHDRcolortype == 8) || (pData->iJHDRcolortype == 12)) && (iRawlen != 2))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if (((pData->iJHDRcolortype == 10) || (pData->iJHDRcolortype == 14)) && (iRawlen != 6))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
-#endif /* MNG_INCLUDE_JNG */
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- {
- if (((pData->iColortype == 0) || (pData->iColortype == 4)) && (iRawlen != 2))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if (((pData->iColortype == 2) || (pData->iColortype == 6)) && (iRawlen != 6))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iColortype == 3) && (iRawlen != 1))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- {
- if (iRawlen != 6) /* global is always 16-bit RGB ! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- pData->bHasBKGD = MNG_TRUE; /* indicate bKGD available */
- else
- pData->bHasglobalBKGD = (mng_bool)(iRawlen != 0);
-
-#ifdef MNG_SUPPORT_DISPLAY
- if (!pImage) /* if no object dump it in obj 0 */
- pImage = (mng_imagep)pData->pObjzero;
-
- pBuf = pImage->pImgbuf; /* address object buffer */
-
-#ifdef MNG_INCLUDE_JNG
- if (pData->bHasJHDR)
- {
- pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */
-
- switch (pData->iJHDRcolortype) /* store fields for future reference */
- {
- case 8 : ; /* gray */
- case 12 : { /* graya */
- pBuf->iBKGDgray = mng_get_uint16 (pRawdata);
- break;
- }
- case 10 : ; /* rgb */
- case 14 : { /* rgba */
- pBuf->iBKGDred = mng_get_uint16 (pRawdata);
- pBuf->iBKGDgreen = mng_get_uint16 (pRawdata+2);
- pBuf->iBKGDblue = mng_get_uint16 (pRawdata+4);
- break;
- }
- }
- }
- else
-#endif /* MNG_INCLUDE_JNG */
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- {
- pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */
-
- switch (pData->iColortype) /* store fields for future reference */
- {
- case 0 : ; /* gray */
- case 4 : { /* graya */
- pBuf->iBKGDgray = mng_get_uint16 (pRawdata);
- break;
- }
- case 2 : ; /* rgb */
- case 6 : { /* rgba */
- pBuf->iBKGDred = mng_get_uint16 (pRawdata);
- pBuf->iBKGDgreen = mng_get_uint16 (pRawdata+2);
- pBuf->iBKGDblue = mng_get_uint16 (pRawdata+4);
- break;
- }
- case 3 : { /* indexed */
- pBuf->iBKGDindex = *pRawdata;
- break;
- }
- }
- }
- else /* store as global */
- {
- if (iRawlen)
- {
- pData->iGlobalBKGDred = mng_get_uint16 (pRawdata);
- pData->iGlobalBKGDgreen = mng_get_uint16 (pRawdata+2);
- pData->iGlobalBKGDblue = mng_get_uint16 (pRawdata+4);
- }
-
- { /* create an animation object */
- mng_retcode iRetcode = mng_create_ani_bkgd (pData, pData->iGlobalBKGDred,
- pData->iGlobalBKGDgreen,
- pData->iGlobalBKGDblue);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_bkgdp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_bkgdp)*ppChunk)->iType = pData->iColortype;
-
- if (iRawlen)
- {
- switch (iRawlen) /* guess from length */
- {
- case 1 : { /* indexed */
- ((mng_bkgdp)*ppChunk)->iType = 3;
- ((mng_bkgdp)*ppChunk)->iIndex = *pRawdata;
- break;
- }
- case 2 : { /* gray */
- ((mng_bkgdp)*ppChunk)->iType = 0;
- ((mng_bkgdp)*ppChunk)->iGray = mng_get_uint16 (pRawdata);
- break;
- }
- case 6 : { /* rgb */
- ((mng_bkgdp)*ppChunk)->iType = 2;
- ((mng_bkgdp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
- ((mng_bkgdp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
- ((mng_bkgdp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
- break;
- }
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_BKGD, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_pHYs
-READ_CHUNK (mng_read_phys)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PHYS, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if (pData->bHasIDAT)
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* it's 9 bytes or empty; no more, no less! */
- if ((iRawlen != 9) && (iRawlen != 0))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_physp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
- ((mng_physp)*ppChunk)->iSizex = mng_get_uint32 (pRawdata);
- ((mng_physp)*ppChunk)->iSizey = mng_get_uint32 (pRawdata+4);
- ((mng_physp)*ppChunk)->iUnit = *(pRawdata+8);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PHYS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_sBIT
-READ_CHUNK (mng_read_sbit)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SBIT, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasPLTE) || (pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
-#else
- if ((pData->bHasPLTE) || (pData->bHasIDAT))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen > 4) /* it just can't be bigger than that! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_INCLUDE_JNG /* length checks */
- if (pData->bHasJHDR)
- {
- if ((pData->iJHDRcolortype == 8) && (iRawlen != 1))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iJHDRcolortype == 10) && (iRawlen != 3))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iJHDRcolortype == 12) && (iRawlen != 2))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iJHDRcolortype == 14) && (iRawlen != 4))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
-#endif /* MNG_INCLUDE_JNG */
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
- {
- if ((pData->iColortype == 0) && (iRawlen != 1))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iColortype == 2) && (iRawlen != 3))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iColortype == 3) && (iRawlen != 3))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iColortype == 4) && (iRawlen != 2))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((pData->iColortype == 6) && (iRawlen != 4))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- { /* global = empty or RGBA */
- if ((iRawlen != 0) && (iRawlen != 4))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_sbitp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
-#ifdef MNG_INCLUDE_JNG
- if (pData->bHasJHDR)
- ((mng_sbitp)*ppChunk)->iType = pData->iJHDRcolortype;
- else
-#endif
- if (pData->bHasIHDR)
- ((mng_sbitp)*ppChunk)->iType = pData->iColortype;
- else /* global ! */
- ((mng_sbitp)*ppChunk)->iType = 6;
-
- if (iRawlen > 0)
- ((mng_sbitp)*ppChunk)->aBits [0] = *pRawdata;
- if (iRawlen > 1)
- ((mng_sbitp)*ppChunk)->aBits [1] = *(pRawdata+1);
- if (iRawlen > 2)
- ((mng_sbitp)*ppChunk)->aBits [2] = *(pRawdata+2);
- if (iRawlen > 3)
- ((mng_sbitp)*ppChunk)->aBits [3] = *(pRawdata+3);
-
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SBIT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_sPLT
-READ_CHUNK (mng_read_splt)
-{
- mng_uint8p pTemp;
- mng_uint32 iNamelen;
- mng_uint8 iSampledepth;
- mng_uint32 iRemain;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SPLT, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (pData->bHasIDAT)
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen)
- {
- pTemp = find_null (pRawdata); /* find null-separator */
- /* not found inside input-data ? */
- if ((pTemp - pRawdata) > (mng_int32)iRawlen)
- MNG_ERROR (pData, MNG_NULLNOTFOUND);
-
- iNamelen = (mng_uint32)(pTemp - pRawdata);
- iSampledepth = *(pTemp+1);
- iRemain = (iRawlen - 2 - iNamelen);
-
- if ((iSampledepth != 1) && (iSampledepth != 2))
- MNG_ERROR (pData, MNG_INVSAMPLEDEPTH);
- /* check remaining length */
- if ( ((iSampledepth == 1) && (iRemain % 6 != 0)) ||
- ((iSampledepth == 2) && (iRemain % 10 != 0)) )
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- }
- else
- {
- pTemp = MNG_NULL;
- iNamelen = 0;
- iSampledepth = 0;
- iRemain = 0;
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_spltp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
- ((mng_spltp)*ppChunk)->iNamesize = iNamelen;
- ((mng_spltp)*ppChunk)->iSampledepth = iSampledepth;
-
- if (iSampledepth == 1)
- ((mng_spltp)*ppChunk)->iEntrycount = iRemain / 6;
- else
- ((mng_spltp)*ppChunk)->iEntrycount = iRemain / 10;
-
- if (iNamelen)
- {
- MNG_ALLOC (pData, ((mng_spltp)*ppChunk)->zName, iNamelen+1);
- MNG_COPY (((mng_spltp)*ppChunk)->zName, pRawdata, iNamelen);
- }
-
- if (iRemain)
- {
- MNG_ALLOC (pData, ((mng_spltp)*ppChunk)->pEntries, iRemain);
- MNG_COPY (((mng_spltp)*ppChunk)->pEntries, pTemp+2, iRemain);
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SPLT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_hIST
-READ_CHUNK (mng_read_hist)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_HIST, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) )
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if ((!pData->bHasPLTE) || (pData->bHasIDAT))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* length oke ? */
- if ( ((iRawlen & 0x01) != 0) || ((iRawlen >> 1) != pData->iPLTEcount) )
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- {
- mng_uint32 iX;
- /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_histp)*ppChunk)->iEntrycount = iRawlen >> 1;
-
- for (iX = 0; iX < (iRawlen >> 1); iX++)
- {
- ((mng_histp)*ppChunk)->aEntries [iX] = mng_get_uint16 (pRawdata);
- pRawdata += 2;
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_HIST, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_tIME
-READ_CHUNK (mng_read_time)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TIME, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 7) /* length must be exactly 7 */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-/* if (pData->fProcesstime) */ /* inform the application ? */
-/* {
-
- pData->fProcesstime ((mng_handle)pData, );
- } */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_timep)*ppChunk)->iYear = mng_get_uint16 (pRawdata);
- ((mng_timep)*ppChunk)->iMonth = *(pRawdata+2);
- ((mng_timep)*ppChunk)->iDay = *(pRawdata+3);
- ((mng_timep)*ppChunk)->iHour = *(pRawdata+4);
- ((mng_timep)*ppChunk)->iMinute = *(pRawdata+5);
- ((mng_timep)*ppChunk)->iSecond = *(pRawdata+6);
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TIME, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_mhdr)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MHDR, MNG_LC_START);
-#endif
-
- if (pData->eSigtype != mng_it_mng) /* sequence checks */
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
-
- if (pData->bHasheader) /* can only be the first chunk! */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* correct length ? */
-#ifndef MNG_NO_OLD_VERSIONS
- if ((iRawlen != 28) && (iRawlen != 12))
-#else
- if ((iRawlen != 28))
-#endif
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasMHDR = MNG_TRUE; /* oh boy, a real MNG */
- pData->bHasheader = MNG_TRUE; /* we've got a header */
- pData->eImagetype = mng_it_mng; /* fill header fields */
- pData->iWidth = mng_get_uint32 (pRawdata);
- pData->iHeight = mng_get_uint32 (pRawdata+4);
- pData->iTicks = mng_get_uint32 (pRawdata+8);
-
-#ifndef MNG_NO_OLD_VERSIONS
- if (iRawlen == 28) /* proper MHDR ? */
- {
-#endif
- pData->iLayercount = mng_get_uint32 (pRawdata+12);
- pData->iFramecount = mng_get_uint32 (pRawdata+16);
- pData->iPlaytime = mng_get_uint32 (pRawdata+20);
- pData->iSimplicity = mng_get_uint32 (pRawdata+24);
-
-#ifndef MNG_NO_OLD_VERSIONS
- pData->bPreDraft48 = MNG_FALSE;
- }
- else /* probably pre-draft48 then */
- {
- pData->iLayercount = 0;
- pData->iFramecount = 0;
- pData->iPlaytime = 0;
- pData->iSimplicity = 0;
-
- pData->bPreDraft48 = MNG_TRUE;
- }
-#endif
- /* predict alpha-depth */
- if ((pData->iSimplicity & 0x00000001) == 0)
-#ifndef MNG_NO_16BIT_SUPPORT
- pData->iAlphadepth = 16; /* no indicators = assume the worst */
-#else
- pData->iAlphadepth = 8; /* anything else = assume the worst */
-#endif
- else
- if ((pData->iSimplicity & 0x00000008) == 0)
- pData->iAlphadepth = 0; /* no transparency at all */
- else
- if ((pData->iSimplicity & 0x00000140) == 0x00000040)
- pData->iAlphadepth = 1; /* no semi-transparency guaranteed */
- else
-#ifndef MNG_NO_16BIT_SUPPORT
- pData->iAlphadepth = 16; /* anything else = assume the worst */
-#else
- pData->iAlphadepth = 8; /* anything else = assume the worst */
-#endif
-
-#ifdef MNG_INCLUDE_JNG /* can we handle the complexity ? */
- if (pData->iSimplicity & 0x0000FC00)
-#else
- if (pData->iSimplicity & 0x0000FC10)
-#endif
- MNG_ERROR (pData, MNG_MNGTOOCOMPLEX);
- /* fits on maximum canvas ? */
- if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
- MNG_WARNING (pData, MNG_IMAGETOOLARGE);
-
- if (pData->fProcessheader) /* inform the app ? */
- if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
- MNG_ERROR (pData, MNG_APPMISCERROR);
-
- pData->iImagelevel++; /* one level deeper */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_mhdrp)*ppChunk)->iWidth = pData->iWidth;
- ((mng_mhdrp)*ppChunk)->iHeight = pData->iHeight;
- ((mng_mhdrp)*ppChunk)->iTicks = pData->iTicks;
- ((mng_mhdrp)*ppChunk)->iLayercount = pData->iLayercount;
- ((mng_mhdrp)*ppChunk)->iFramecount = pData->iFramecount;
- ((mng_mhdrp)*ppChunk)->iPlaytime = pData->iPlaytime;
- ((mng_mhdrp)*ppChunk)->iSimplicity = pData->iSimplicity;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_mend)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MEND, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen > 0) /* must not contain data! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- { /* do something */
- mng_retcode iRetcode = mng_process_display_mend (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- if (!pData->iTotalframes) /* save totals */
- pData->iTotalframes = pData->iFrameseq;
- if (!pData->iTotallayers)
- pData->iTotallayers = pData->iLayerseq;
- if (!pData->iTotalplaytime)
- pData->iTotalplaytime = pData->iFrametime;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
- pData->bHasMHDR = MNG_FALSE; /* end of the line, bro! */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MEND, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_LOOP
-READ_CHUNK (mng_read_loop)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_LOOP, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (!pData->bCacheplayback) /* must store playback info to work!! */
- MNG_ERROR (pData, MNG_LOOPWITHCACHEOFF);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen >= 5) /* length checks */
- {
- if (iRawlen >= 6)
- {
- if ((iRawlen - 6) % 4 != 0)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_uint8 iLevel;
- mng_uint32 iRepeat;
- mng_uint8 iTermination = 0;
- mng_uint32 iItermin = 1;
- mng_uint32 iItermax = 0x7fffffffL;
- mng_retcode iRetcode;
-
- pData->bHasLOOP = MNG_TRUE; /* indicate we're inside a loop */
-
- iLevel = *pRawdata; /* determine the fields for processing */
-
-#ifndef MNG_NO_OLD_VERSIONS
- if (pData->bPreDraft48)
- {
- iTermination = *(pRawdata+1);
-
- iRepeat = mng_get_uint32 (pRawdata+2);
- }
- else
-#endif
- iRepeat = mng_get_uint32 (pRawdata+1);
-
- if (iRawlen >= 6)
- {
-#ifndef MNG_NO_OLD_VERSIONS
- if (!pData->bPreDraft48)
-#endif
- iTermination = *(pRawdata+5);
-
- if (iRawlen >= 10)
- {
- iItermin = mng_get_uint32 (pRawdata+6);
-
- if (iRawlen >= 14)
- {
- iItermax = mng_get_uint32 (pRawdata+10);
-
- /* TODO: process signals */
-
- }
- }
- }
- /* create the LOOP ani-object */
- iRetcode = mng_create_ani_loop (pData, iLevel, iRepeat, iTermination,
- iItermin, iItermax, 0, 0);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* skip till matching ENDL if iteration=0 */
- if ((!pData->bSkipping) && (iRepeat == 0))
- pData->bSkipping = MNG_TRUE;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- if (iRawlen >= 5) /* store the fields */
- {
- ((mng_loopp)*ppChunk)->iLevel = *pRawdata;
-
-#ifndef MNG_NO_OLD_VERSIONS
- if (pData->bPreDraft48)
- {
- ((mng_loopp)*ppChunk)->iTermination = *(pRawdata+1);
- ((mng_loopp)*ppChunk)->iRepeat = mng_get_uint32 (pRawdata+2);
- }
- else
-#endif
- {
- ((mng_loopp)*ppChunk)->iRepeat = mng_get_uint32 (pRawdata+1);
- }
-
- if (iRawlen >= 6)
- {
-#ifndef MNG_NO_OLD_VERSIONS
- if (!pData->bPreDraft48)
-#endif
- ((mng_loopp)*ppChunk)->iTermination = *(pRawdata+5);
-
- if (iRawlen >= 10)
- {
- ((mng_loopp)*ppChunk)->iItermin = mng_get_uint32 (pRawdata+6);
-
-#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
- if (iRawlen >= 14)
- {
- ((mng_loopp)*ppChunk)->iItermax = mng_get_uint32 (pRawdata+10);
- ((mng_loopp)*ppChunk)->iCount = (iRawlen - 14) / 4;
-
- if (((mng_loopp)*ppChunk)->iCount)
- {
- MNG_ALLOC (pData, ((mng_loopp)*ppChunk)->pSignals,
- ((mng_loopp)*ppChunk)->iCount << 2);
-
-#ifndef MNG_BIGENDIAN_SUPPORTED
- {
- mng_uint32 iX;
- mng_uint8p pIn = pRawdata + 14;
- mng_uint32p pOut = (mng_uint32p)((mng_loopp)*ppChunk)->pSignals;
-
- for (iX = 0; iX < ((mng_loopp)*ppChunk)->iCount; iX++)
- {
- *pOut++ = mng_get_uint32 (pIn);
- pIn += 4;
- }
- }
-#else
- MNG_COPY (((mng_loopp)*ppChunk)->pSignals, pRawdata + 14,
- ((mng_loopp)*ppChunk)->iCount << 2);
-#endif /* !MNG_BIGENDIAN_SUPPORTED */
- }
- }
-#endif
- }
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_LOOP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_LOOP
-READ_CHUNK (mng_read_endl)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ENDL, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 1) /* length must be exactly 1 */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- if (pData->bHasLOOP) /* are we really processing a loop ? */
- {
- mng_uint8 iLevel = *pRawdata; /* get the nest level */
- /* create an ENDL animation object */
- mng_retcode iRetcode = mng_create_ani_endl (pData, iLevel);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
-/* {
- mng_ani_endlp pENDL = (mng_ani_endlp)pData->pLastaniobj;
-
- iRetcode = pENDL->sHeader.fProcess (pData, pENDL);
-
- if (iRetcode)
- return iRetcode;
- } */
- }
- else
- MNG_ERROR (pData, MNG_NOMATCHINGLOOP);
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_endlp)*ppChunk)->iLevel = *pRawdata;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ENDL, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_DEFI
-READ_CHUNK (mng_read_defi)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DEFI, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check the length */
- if ((iRawlen != 2) && (iRawlen != 3) && (iRawlen != 4) &&
- (iRawlen != 12) && (iRawlen != 28))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
-
- pData->iDEFIobjectid = mng_get_uint16 (pRawdata);
-
- if (iRawlen > 2)
- {
- pData->bDEFIhasdonotshow = MNG_TRUE;
- pData->iDEFIdonotshow = *(pRawdata+2);
- }
- else
- {
- pData->bDEFIhasdonotshow = MNG_FALSE;
- pData->iDEFIdonotshow = 0;
- }
-
- if (iRawlen > 3)
- {
- pData->bDEFIhasconcrete = MNG_TRUE;
- pData->iDEFIconcrete = *(pRawdata+3);
- }
- else
- {
- pData->bDEFIhasconcrete = MNG_FALSE;
- pData->iDEFIconcrete = 0;
- }
-
- if (iRawlen > 4)
- {
- pData->bDEFIhasloca = MNG_TRUE;
- pData->iDEFIlocax = mng_get_int32 (pRawdata+4);
- pData->iDEFIlocay = mng_get_int32 (pRawdata+8);
- }
- else
- {
- pData->bDEFIhasloca = MNG_FALSE;
- pData->iDEFIlocax = 0;
- pData->iDEFIlocay = 0;
- }
-
- if (iRawlen > 12)
- {
- pData->bDEFIhasclip = MNG_TRUE;
- pData->iDEFIclipl = mng_get_int32 (pRawdata+12);
- pData->iDEFIclipr = mng_get_int32 (pRawdata+16);
- pData->iDEFIclipt = mng_get_int32 (pRawdata+20);
- pData->iDEFIclipb = mng_get_int32 (pRawdata+24);
- }
- else
- {
- pData->bDEFIhasclip = MNG_FALSE;
- pData->iDEFIclipl = 0;
- pData->iDEFIclipr = 0;
- pData->iDEFIclipt = 0;
- pData->iDEFIclipb = 0;
- }
- /* create an animation object */
- iRetcode = mng_create_ani_defi (pData);
-
- if (!iRetcode) /* do display processing */
- iRetcode = mng_process_display_defi (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_defip)*ppChunk)->iObjectid = mng_get_uint16 (pRawdata);
-
- if (iRawlen > 2)
- {
- ((mng_defip)*ppChunk)->bHasdonotshow = MNG_TRUE;
- ((mng_defip)*ppChunk)->iDonotshow = *(pRawdata+2);
- }
- else
- ((mng_defip)*ppChunk)->bHasdonotshow = MNG_FALSE;
-
- if (iRawlen > 3)
- {
- ((mng_defip)*ppChunk)->bHasconcrete = MNG_TRUE;
- ((mng_defip)*ppChunk)->iConcrete = *(pRawdata+3);
- }
- else
- ((mng_defip)*ppChunk)->bHasconcrete = MNG_FALSE;
-
- if (iRawlen > 4)
- {
- ((mng_defip)*ppChunk)->bHasloca = MNG_TRUE;
- ((mng_defip)*ppChunk)->iXlocation = mng_get_int32 (pRawdata+4);
- ((mng_defip)*ppChunk)->iYlocation = mng_get_int32 (pRawdata+8);
- }
- else
- ((mng_defip)*ppChunk)->bHasloca = MNG_FALSE;
-
- if (iRawlen > 12)
- {
- ((mng_defip)*ppChunk)->bHasclip = MNG_TRUE;
- ((mng_defip)*ppChunk)->iLeftcb = mng_get_int32 (pRawdata+12);
- ((mng_defip)*ppChunk)->iRightcb = mng_get_int32 (pRawdata+16);
- ((mng_defip)*ppChunk)->iTopcb = mng_get_int32 (pRawdata+20);
- ((mng_defip)*ppChunk)->iBottomcb = mng_get_int32 (pRawdata+24);
- }
- else
- ((mng_defip)*ppChunk)->bHasclip = MNG_FALSE;
-
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DEFI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_BASI
-READ_CHUNK (mng_read_basi)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_BASI, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check the length */
- if ((iRawlen != 13) && (iRawlen != 19) && (iRawlen != 21) && (iRawlen != 22))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasBASI = MNG_TRUE; /* inside a BASI-IEND block now */
- /* store interesting fields */
- pData->iDatawidth = mng_get_uint32 (pRawdata);
- pData->iDataheight = mng_get_uint32 (pRawdata+4);
- pData->iBitdepth = *(pRawdata+8);
- pData->iColortype = *(pRawdata+9);
- pData->iCompression = *(pRawdata+10);
- pData->iFilter = *(pRawdata+11);
- pData->iInterlace = *(pRawdata+12);
-
-
-#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
- pData->iPNGmult = 1;
- pData->iPNGdepth = pData->iBitdepth;
-#endif
-
-#ifdef MNG_NO_1_2_4BIT_SUPPORT
- if (pData->iBitdepth < 8)
- pData->iBitdepth = 8;
-#endif
-#ifdef MNG_NO_16BIT_SUPPORT
- if (pData->iBitdepth > 8)
- {
- pData->iBitdepth = 8;
- pData->iPNGmult = 2;
- }
-#endif
-
- if ((pData->iBitdepth != 8) /* parameter validity checks */
-#ifndef MNG_NO_1_2_4BIT_SUPPORT
- && (pData->iBitdepth != 1) &&
- (pData->iBitdepth != 2) &&
- (pData->iBitdepth != 4)
-#endif
-#ifndef MNG_NO_16BIT_SUPPORT
- && (pData->iBitdepth != 16)
-#endif
- )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if ((pData->iColortype != MNG_COLORTYPE_GRAY ) &&
- (pData->iColortype != MNG_COLORTYPE_RGB ) &&
- (pData->iColortype != MNG_COLORTYPE_INDEXED) &&
- (pData->iColortype != MNG_COLORTYPE_GRAYA ) &&
- (pData->iColortype != MNG_COLORTYPE_RGBA ) )
- MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
-
- if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if (((pData->iColortype == MNG_COLORTYPE_RGB ) ||
- (pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
- (pData->iColortype == MNG_COLORTYPE_RGBA ) ) &&
- (pData->iBitdepth < 8 ) )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
-#if defined(FILTER192) || defined(FILTER193)
- if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
-#if defined(FILTER192) && defined(FILTER193)
- (pData->iFilter != MNG_FILTER_DIFFERING) &&
- (pData->iFilter != MNG_FILTER_NOFILTER ) )
-#else
-#ifdef FILTER192
- (pData->iFilter != MNG_FILTER_DIFFERING) )
-#else
- (pData->iFilter != MNG_FILTER_NOFILTER ) )
-#endif
-#endif
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-#else
- if (pData->iFilter)
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-#endif
-
- if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
- (pData->iInterlace != MNG_INTERLACE_ADAM7) )
- MNG_ERROR (pData, MNG_INVALIDINTERLACE);
-
- pData->iImagelevel++; /* one level deeper */
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_uint16 iRed = 0;
- mng_uint16 iGreen = 0;
- mng_uint16 iBlue = 0;
- mng_bool bHasalpha = MNG_FALSE;
- mng_uint16 iAlpha = 0xFFFF;
- mng_uint8 iViewable = 0;
- mng_retcode iRetcode;
-
- if (iRawlen > 13) /* get remaining fields, if any */
- {
- iRed = mng_get_uint16 (pRawdata+13);
- iGreen = mng_get_uint16 (pRawdata+15);
- iBlue = mng_get_uint16 (pRawdata+17);
- }
-
- if (iRawlen > 19)
- {
- bHasalpha = MNG_TRUE;
- iAlpha = mng_get_uint16 (pRawdata+19);
- }
-
- if (iRawlen > 21)
- iViewable = *(pRawdata+21);
- /* create an animation object */
- iRetcode = mng_create_ani_basi (pData, iRed, iGreen, iBlue,
- bHasalpha, iAlpha, iViewable);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_basi (pData, iRed, iGreen, iBlue,
- bHasalpha, iAlpha, iViewable); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_basip)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
- ((mng_basip)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
-#ifdef MNG_NO_16BIT_SUPPORT
- if (*(pRawdata+8) > 8)
- ((mng_basip)*ppChunk)->iBitdepth = 8;
- else
-#endif
- ((mng_basip)*ppChunk)->iBitdepth = *(pRawdata+8);
- ((mng_basip)*ppChunk)->iColortype = *(pRawdata+9);
- ((mng_basip)*ppChunk)->iCompression = *(pRawdata+10);
- ((mng_basip)*ppChunk)->iFilter = *(pRawdata+11);
- ((mng_basip)*ppChunk)->iInterlace = *(pRawdata+12);
-
- if (iRawlen > 13)
- {
- ((mng_basip)*ppChunk)->iRed = mng_get_uint16 (pRawdata+13);
- ((mng_basip)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+15);
- ((mng_basip)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+17);
- }
-
- if (iRawlen > 19)
- ((mng_basip)*ppChunk)->iAlpha = mng_get_uint16 (pRawdata+19);
-
- if (iRawlen > 21)
- ((mng_basip)*ppChunk)->iViewable = *(pRawdata+21);
-
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_BASI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_CLON
-READ_CHUNK (mng_read_clon)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_CLON, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check the length */
- if ((iRawlen != 4) && (iRawlen != 5) && (iRawlen != 6) &&
- (iRawlen != 7) && (iRawlen != 16))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_uint16 iSourceid, iCloneid;
- mng_uint8 iClonetype = 0;
- mng_bool bHasdonotshow = MNG_FALSE;
- mng_uint8 iDonotshow = 0;
- mng_uint8 iConcrete = 0;
- mng_bool bHasloca = MNG_FALSE;
- mng_uint8 iLocationtype = 0;
- mng_int32 iLocationx = 0;
- mng_int32 iLocationy = 0;
- mng_retcode iRetcode;
-
- iSourceid = mng_get_uint16 (pRawdata);
- iCloneid = mng_get_uint16 (pRawdata+2);
-
- if (iRawlen > 4)
- iClonetype = *(pRawdata+4);
-
- if (iRawlen > 5)
- {
- bHasdonotshow = MNG_TRUE;
- iDonotshow = *(pRawdata+5);
- }
-
- if (iRawlen > 6)
- iConcrete = *(pRawdata+6);
-
- if (iRawlen > 7)
- {
- bHasloca = MNG_TRUE;
- iLocationtype = *(pRawdata+7);
- iLocationx = mng_get_int32 (pRawdata+8);
- iLocationy = mng_get_int32 (pRawdata+12);
- }
-
- iRetcode = mng_create_ani_clon (pData, iSourceid, iCloneid, iClonetype,
- bHasdonotshow, iDonotshow, iConcrete,
- bHasloca, iLocationtype, iLocationx, iLocationy);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_clon (pData, iSourceid, iCloneid, iClonetype,
- bHasdonotshow, iDonotshow, iConcrete,
- bHasloca, iLocationtype, iLocationx,
- iLocationy); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_clonp)*ppChunk)->iSourceid = mng_get_uint16 (pRawdata);
- ((mng_clonp)*ppChunk)->iCloneid = mng_get_uint16 (pRawdata+2);
-
- if (iRawlen > 4)
- ((mng_clonp)*ppChunk)->iClonetype = *(pRawdata+4);
-
- if (iRawlen > 5)
- ((mng_clonp)*ppChunk)->iDonotshow = *(pRawdata+5);
-
- if (iRawlen > 6)
- ((mng_clonp)*ppChunk)->iConcrete = *(pRawdata+6);
-
- if (iRawlen > 7)
- {
- ((mng_clonp)*ppChunk)->bHasloca = MNG_TRUE;
- ((mng_clonp)*ppChunk)->iLocationtype = *(pRawdata+7);
- ((mng_clonp)*ppChunk)->iLocationx = mng_get_int32 (pRawdata+8);
- ((mng_clonp)*ppChunk)->iLocationy = mng_get_int32 (pRawdata+12);
- }
- else
- {
- ((mng_clonp)*ppChunk)->bHasloca = MNG_FALSE;
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_CLON, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_PAST
-READ_CHUNK (mng_read_past)
-{
-#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
- mng_retcode iRetcode;
- mng_uint16 iTargetid;
- mng_uint8 iTargettype;
- mng_int32 iTargetx;
- mng_int32 iTargety;
- mng_uint32 iCount;
- mng_uint32 iSize;
- mng_ptr pSources;
- mng_uint32 iX;
- mng_past_sourcep pSource;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PAST, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- /* check the length */
- if ((iRawlen < 41) || (((iRawlen - 11) % 30) != 0))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
- iTargetid = mng_get_uint16 (pRawdata);
- iTargettype = *(pRawdata+2);
- iTargetx = mng_get_int32 (pRawdata+3);
- iTargety = mng_get_int32 (pRawdata+7);
- iCount = ((iRawlen - 11) / 30); /* how many entries again? */
- iSize = iCount * sizeof (mng_past_source);
-
- pRawdata += 11;
- /* get a buffer for all the source blocks */
- MNG_ALLOC (pData, pSources, iSize);
-
- pSource = (mng_past_sourcep)pSources;
-
- for (iX = 0; iX < iCount; iX++) /* now copy the source blocks */
- {
- pSource->iSourceid = mng_get_uint16 (pRawdata);
- pSource->iComposition = *(pRawdata+2);
- pSource->iOrientation = *(pRawdata+3);
- pSource->iOffsettype = *(pRawdata+4);
- pSource->iOffsetx = mng_get_int32 (pRawdata+5);
- pSource->iOffsety = mng_get_int32 (pRawdata+9);
- pSource->iBoundarytype = *(pRawdata+13);
- pSource->iBoundaryl = mng_get_int32 (pRawdata+14);
- pSource->iBoundaryr = mng_get_int32 (pRawdata+18);
- pSource->iBoundaryt = mng_get_int32 (pRawdata+22);
- pSource->iBoundaryb = mng_get_int32 (pRawdata+26);
-
- pSource++;
- pRawdata += 30;
- }
-#endif
-
-#ifdef MNG_SUPPORT_DISPLAY
- { /* create playback object */
- iRetcode = mng_create_ani_past (pData, iTargetid, iTargettype, iTargetx,
- iTargety, iCount, pSources);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_past (pData, iTargetid, iTargettype, iTargetx,
- iTargety, iCount, pSources); */
-
- if (iRetcode) /* on error bail out */
- {
- MNG_FREEX (pData, pSources, iSize);
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- {
- MNG_FREEX (pData, pSources, iSize);
- return iRetcode;
- }
- /* store the fields */
- ((mng_pastp)*ppChunk)->iDestid = iTargetid;
- ((mng_pastp)*ppChunk)->iTargettype = iTargettype;
- ((mng_pastp)*ppChunk)->iTargetx = iTargetx;
- ((mng_pastp)*ppChunk)->iTargety = iTargety;
- ((mng_pastp)*ppChunk)->iCount = iCount;
- /* get a buffer & copy the source blocks */
- MNG_ALLOC (pData, ((mng_pastp)*ppChunk)->pSources, iSize);
- MNG_COPY (((mng_pastp)*ppChunk)->pSources, pSources, iSize);
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
- /* free the source block buffer */
- MNG_FREEX (pData, pSources, iSize);
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PAST, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_DISC
-READ_CHUNK (mng_read_disc)
-{
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- mng_uint32 iCount;
- mng_uint16p pIds = MNG_NULL;
- mng_retcode iRetcode;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DISC, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if ((iRawlen % 2) != 0) /* check the length */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- iCount = (iRawlen / sizeof (mng_uint16));
-
- if (iCount)
- {
- MNG_ALLOC (pData, pIds, iRawlen);
-
-#ifndef MNG_BIGENDIAN_SUPPORTED
- {
- mng_uint32 iX;
- mng_uint8p pIn = pRawdata;
- mng_uint16p pOut = pIds;
-
- for (iX = 0; iX < iCount; iX++)
- {
- *pOut++ = mng_get_uint16 (pIn);
- pIn += 2;
- }
- }
-#else
- MNG_COPY (pIds, pRawdata, iRawlen);
-#endif /* !MNG_BIGENDIAN_SUPPORTED */
- }
-#endif
-
-#ifdef MNG_SUPPORT_DISPLAY
- { /* create playback object */
- iRetcode = mng_create_ani_disc (pData, iCount, pIds);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_disc (pData, iCount, pIds); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_discp)*ppChunk)->iCount = iCount;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_discp)*ppChunk)->pObjectids, iRawlen);
- MNG_COPY (((mng_discp)*ppChunk)->pObjectids, pIds, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- if (iRawlen)
- MNG_FREEX (pData, pIds, iRawlen);
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DISC, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_BACK
-READ_CHUNK (mng_read_back)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_BACK, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check the length */
- if ((iRawlen != 6) && (iRawlen != 7) && (iRawlen != 9) && (iRawlen != 10))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
- /* retrieve the fields */
- pData->bHasBACK = MNG_TRUE;
- pData->iBACKred = mng_get_uint16 (pRawdata);
- pData->iBACKgreen = mng_get_uint16 (pRawdata+2);
- pData->iBACKblue = mng_get_uint16 (pRawdata+4);
-
- if (iRawlen > 6)
- pData->iBACKmandatory = *(pRawdata+6);
- else
- pData->iBACKmandatory = 0;
-
- if (iRawlen > 7)
- pData->iBACKimageid = mng_get_uint16 (pRawdata+7);
- else
- pData->iBACKimageid = 0;
-
- if (iRawlen > 9)
- pData->iBACKtile = *(pRawdata+9);
- else
- pData->iBACKtile = 0;
-
- iRetcode = mng_create_ani_back (pData, pData->iBACKred, pData->iBACKgreen,
- pData->iBACKblue, pData->iBACKmandatory,
- pData->iBACKimageid, pData->iBACKtile);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_backp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
- ((mng_backp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
- ((mng_backp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
-
- if (iRawlen > 6)
- ((mng_backp)*ppChunk)->iMandatory = *(pRawdata+6);
-
- if (iRawlen > 7)
- ((mng_backp)*ppChunk)->iImageid = mng_get_uint16 (pRawdata+7);
-
- if (iRawlen > 9)
- ((mng_backp)*ppChunk)->iTile = *(pRawdata+9);
-
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_BACK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_FRAM
-READ_CHUNK (mng_read_fram)
-{
- mng_uint8p pTemp;
-#ifdef MNG_STORE_CHUNKS
- mng_uint32 iNamelen;
-#endif
- mng_uint32 iRemain;
- mng_uint32 iRequired = 0;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_FRAM, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen <= 1) /* only framing-mode ? */
- {
-#ifdef MNG_STORE_CHUNKS
- iNamelen = 0; /* indicate so */
-#endif
- iRemain = 0;
- pTemp = MNG_NULL;
- }
- else
- {
- pTemp = find_null (pRawdata+1); /* find null-separator */
- /* not found inside input-data ? */
- if ((pTemp - pRawdata) > (mng_int32)iRawlen)
- pTemp = pRawdata + iRawlen; /* than remainder is name */
-
-#ifdef MNG_STORE_CHUNKS
- iNamelen = (mng_uint32)((pTemp - pRawdata) - 1);
-#endif
- iRemain = (mng_uint32)(iRawlen - (pTemp - pRawdata));
-
- if (iRemain) /* if there is remaining data it's less 1 byte */
- iRemain--;
-
- if ((iRemain) && (iRemain < 4)) /* remains must be empty or at least 4 bytes */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if (iRemain)
- {
- iRequired = 4; /* calculate and check required remaining length */
-
- if (*(pTemp+1)) { iRequired += 4; }
- if (*(pTemp+2)) { iRequired += 4; }
- if (*(pTemp+3)) { iRequired += 17; }
-
- if (*(pTemp+4))
- {
- if ((iRemain - iRequired) % 4 != 0)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- else
- {
- if (iRemain != iRequired)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
- }
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_uint8p pWork = pTemp;
- mng_uint8 iFramemode = 0;
- mng_uint8 iChangedelay = 0;
- mng_uint32 iDelay = 0;
- mng_uint8 iChangetimeout = 0;
- mng_uint32 iTimeout = 0;
- mng_uint8 iChangeclipping = 0;
- mng_uint8 iCliptype = 0;
- mng_int32 iClipl = 0;
- mng_int32 iClipr = 0;
- mng_int32 iClipt = 0;
- mng_int32 iClipb = 0;
- mng_retcode iRetcode;
-
- if (iRawlen) /* any data specified ? */
- {
- if (*(pRawdata)) /* save the new framing mode ? */
- {
- iFramemode = *(pRawdata);
-
-#ifndef MNG_NO_OLD_VERSIONS
- if (pData->bPreDraft48) /* old style input-stream ? */
- {
- switch (iFramemode)
- {
- case 0: { break; }
- case 1: { iFramemode = 3; break; }
- case 2: { iFramemode = 4; break; }
- case 3: { iFramemode = 1; break; }
- case 4: { iFramemode = 1; break; }
- case 5: { iFramemode = 2; break; }
- default: { iFramemode = 1; break; }
- }
- }
-#endif
- }
-
- if (iRemain)
- {
- iChangedelay = *(pWork+1);
- iChangetimeout = *(pWork+2);
- iChangeclipping = *(pWork+3);
- pWork += 5;
-
- if (iChangedelay) /* delay changed ? */
- {
- iDelay = mng_get_uint32 (pWork);
- pWork += 4;
- }
-
- if (iChangetimeout) /* timeout changed ? */
- {
- iTimeout = mng_get_uint32 (pWork);
- pWork += 4;
- }
-
- if (iChangeclipping) /* clipping changed ? */
- {
- iCliptype = *pWork;
- iClipl = mng_get_int32 (pWork+1);
- iClipr = mng_get_int32 (pWork+5);
- iClipt = mng_get_int32 (pWork+9);
- iClipb = mng_get_int32 (pWork+13);
- }
- }
- }
-
- iRetcode = mng_create_ani_fram (pData, iFramemode, iChangedelay, iDelay,
- iChangetimeout, iTimeout,
- iChangeclipping, iCliptype,
- iClipl, iClipr, iClipt, iClipb);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_fram (pData, iFramemode, iChangedelay, iDelay,
- iChangetimeout, iTimeout,
- iChangeclipping, iCliptype,
- iClipl, iClipr, iClipt, iClipb); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_framp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
- mng_uint8 iFramemode = *(pRawdata);
-
-#ifndef MNG_NO_OLD_VERSIONS
- if (pData->bPreDraft48) /* old style input-stream ? */
- {
- switch (iFramemode)
- {
- case 1: { iFramemode = 3; break; }
- case 2: { iFramemode = 4; break; }
- case 3: { iFramemode = 5; break; } /* TODO: provision for mode=5 ??? */
- case 4: { iFramemode = 1; break; }
- case 5: { iFramemode = 2; break; }
- default: { iFramemode = 1; break; }
- }
- }
-#endif
-
- ((mng_framp)*ppChunk)->iMode = iFramemode;
- ((mng_framp)*ppChunk)->iNamesize = iNamelen;
-
- if (iNamelen)
- {
- MNG_ALLOC (pData, ((mng_framp)*ppChunk)->zName, iNamelen+1);
- MNG_COPY (((mng_framp)*ppChunk)->zName, pRawdata+1, iNamelen);
- }
-
- if (iRemain)
- {
- ((mng_framp)*ppChunk)->iChangedelay = *(pTemp+1);
- ((mng_framp)*ppChunk)->iChangetimeout = *(pTemp+2);
- ((mng_framp)*ppChunk)->iChangeclipping = *(pTemp+3);
- ((mng_framp)*ppChunk)->iChangesyncid = *(pTemp+4);
-
- pTemp += 5;
-
- if (((mng_framp)*ppChunk)->iChangedelay)
- {
- ((mng_framp)*ppChunk)->iDelay = mng_get_uint32 (pTemp);
- pTemp += 4;
- }
-
- if (((mng_framp)*ppChunk)->iChangetimeout)
- {
- ((mng_framp)*ppChunk)->iTimeout = mng_get_uint32 (pTemp);
- pTemp += 4;
- }
-
- if (((mng_framp)*ppChunk)->iChangeclipping)
- {
- ((mng_framp)*ppChunk)->iBoundarytype = *pTemp;
- ((mng_framp)*ppChunk)->iBoundaryl = mng_get_int32 (pTemp+1);
- ((mng_framp)*ppChunk)->iBoundaryr = mng_get_int32 (pTemp+5);
- ((mng_framp)*ppChunk)->iBoundaryt = mng_get_int32 (pTemp+9);
- ((mng_framp)*ppChunk)->iBoundaryb = mng_get_int32 (pTemp+13);
- pTemp += 17;
- }
-
- if (((mng_framp)*ppChunk)->iChangesyncid)
- {
- ((mng_framp)*ppChunk)->iCount = (iRemain - iRequired) / 4;
-
- if (((mng_framp)*ppChunk)->iCount)
- {
- MNG_ALLOC (pData, ((mng_framp)*ppChunk)->pSyncids,
- ((mng_framp)*ppChunk)->iCount * 4);
-
-#ifndef MNG_BIGENDIAN_SUPPORTED
- {
- mng_uint32 iX;
- mng_uint32p pOut = ((mng_framp)*ppChunk)->pSyncids;
-
- for (iX = 0; iX < ((mng_framp)*ppChunk)->iCount; iX++)
- {
- *pOut++ = mng_get_uint32 (pTemp);
- pTemp += 4;
- }
- }
-#else
- MNG_COPY (((mng_framp)*ppChunk)->pSyncids, pTemp,
- ((mng_framp)*ppChunk)->iCount * 4);
-#endif /* !MNG_BIGENDIAN_SUPPORTED */
- }
- }
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_FRAM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_MOVE
-READ_CHUNK (mng_read_move)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MOVE, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 13) /* check the length */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
- /* create a MOVE animation object */
- iRetcode = mng_create_ani_move (pData, mng_get_uint16 (pRawdata),
- mng_get_uint16 (pRawdata+2),
- *(pRawdata+4),
- mng_get_int32 (pRawdata+5),
- mng_get_int32 (pRawdata+9));
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_move (pData,
- mng_get_uint16 (pRawdata),
- mng_get_uint16 (pRawdata+2),
- *(pRawdata+4),
- mng_get_int32 (pRawdata+5),
- mng_get_int32 (pRawdata+9)); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_movep)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
- ((mng_movep)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
- ((mng_movep)*ppChunk)->iMovetype = *(pRawdata+4);
- ((mng_movep)*ppChunk)->iMovex = mng_get_int32 (pRawdata+5);
- ((mng_movep)*ppChunk)->iMovey = mng_get_int32 (pRawdata+9);
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MOVE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_CLIP
-READ_CHUNK (mng_read_clip)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_CLIP, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 21) /* check the length */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
- /* create a CLIP animation object */
- iRetcode = mng_create_ani_clip (pData, mng_get_uint16 (pRawdata),
- mng_get_uint16 (pRawdata+2),
- *(pRawdata+4),
- mng_get_int32 (pRawdata+5),
- mng_get_int32 (pRawdata+9),
- mng_get_int32 (pRawdata+13),
- mng_get_int32 (pRawdata+17));
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_clip (pData,
- mng_get_uint16 (pRawdata),
- mng_get_uint16 (pRawdata+2),
- *(pRawdata+4),
- mng_get_int32 (pRawdata+5),
- mng_get_int32 (pRawdata+9),
- mng_get_int32 (pRawdata+13),
- mng_get_int32 (pRawdata+17)); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_clipp)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
- ((mng_clipp)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
- ((mng_clipp)*ppChunk)->iCliptype = *(pRawdata+4);
- ((mng_clipp)*ppChunk)->iClipl = mng_get_int32 (pRawdata+5);
- ((mng_clipp)*ppChunk)->iClipr = mng_get_int32 (pRawdata+9);
- ((mng_clipp)*ppChunk)->iClipt = mng_get_int32 (pRawdata+13);
- ((mng_clipp)*ppChunk)->iClipb = mng_get_int32 (pRawdata+17);
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_CLIP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_SHOW
-READ_CHUNK (mng_read_show)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SHOW, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check the length */
- if ((iRawlen != 0) && (iRawlen != 2) && (iRawlen != 4) && (iRawlen != 5))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
-
- if (iRawlen) /* determine parameters if any */
- {
- pData->iSHOWfromid = mng_get_uint16 (pRawdata);
-
- if (iRawlen > 2)
- pData->iSHOWtoid = mng_get_uint16 (pRawdata+2);
- else
- pData->iSHOWtoid = pData->iSHOWfromid;
-
- if (iRawlen > 4)
- pData->iSHOWmode = *(pRawdata+4);
- else
- pData->iSHOWmode = 0;
- }
- else /* use defaults then */
- {
- pData->iSHOWmode = 2;
- pData->iSHOWfromid = 1;
- pData->iSHOWtoid = 65535;
- }
- /* create a SHOW animation object */
- iRetcode = mng_create_ani_show (pData, pData->iSHOWfromid,
- pData->iSHOWtoid, pData->iSHOWmode);
-
- if (!iRetcode)
- iRetcode = mng_process_display_show (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_showp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
- ((mng_showp)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
-
- if (iRawlen > 2)
- ((mng_showp)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
- else
- ((mng_showp)*ppChunk)->iLastid = ((mng_showp)*ppChunk)->iFirstid;
-
- if (iRawlen > 4)
- ((mng_showp)*ppChunk)->iMode = *(pRawdata+4);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SHOW, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_TERM
-READ_CHUNK (mng_read_term)
-{
- mng_uint8 iTermaction;
- mng_uint8 iIteraction = 0;
- mng_uint32 iDelay = 0;
- mng_uint32 iItermax = 0;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TERM, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- /* should be behind MHDR or SAVE !! */
- if ((!pData->bHasSAVE) && (pData->iChunkseq > 2))
- {
- pData->bMisplacedTERM = MNG_TRUE; /* indicate we found a misplaced TERM */
- /* and send a warning signal!!! */
- MNG_WARNING (pData, MNG_SEQUENCEERROR);
- }
-
- if (pData->bHasLOOP) /* no way, jose! */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (pData->bHasTERM) /* only 1 allowed! */
- MNG_ERROR (pData, MNG_MULTIPLEERROR);
- /* check the length */
- if ((iRawlen != 1) && (iRawlen != 10))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasTERM = MNG_TRUE;
-
- iTermaction = *pRawdata; /* get the fields */
-
- if (iRawlen > 1)
- {
- iIteraction = *(pRawdata+1);
- iDelay = mng_get_uint32 (pRawdata+2);
- iItermax = mng_get_uint32 (pRawdata+6);
- }
-
- if (pData->fProcessterm) /* inform the app ? */
- if (!pData->fProcessterm (((mng_handle)pData), iTermaction, iIteraction,
- iDelay, iItermax))
- MNG_ERROR (pData, MNG_APPMISCERROR);
-
-#ifdef MNG_SUPPORT_DISPLAY
- { /* create the TERM ani-object */
- mng_retcode iRetcode = mng_create_ani_term (pData, iTermaction, iIteraction,
- iDelay, iItermax);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* save for future reference */
- pData->pTermaniobj = pData->pLastaniobj;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_termp)*ppChunk)->iTermaction = iTermaction;
- ((mng_termp)*ppChunk)->iIteraction = iIteraction;
- ((mng_termp)*ppChunk)->iDelay = iDelay;
- ((mng_termp)*ppChunk)->iItermax = iItermax;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_TERM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_SAVE
-READ_CHUNK (mng_read_save)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SAVE, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (pData->bHasSAVE))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- pData->bHasSAVE = MNG_TRUE;
-
- if (pData->fProcesssave) /* inform the application ? */
- {
- mng_bool bOke = pData->fProcesssave ((mng_handle)pData);
-
- if (!bOke)
- MNG_ERROR (pData, MNG_APPMISCERROR);
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
-
-
- /* TODO: something with the parameters */
-
-
- /* create a SAVE animation object */
- iRetcode = mng_create_ani_save (pData);
-
- if (!iRetcode)
- iRetcode = mng_process_display_save (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_savep)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen) /* not empty ? */
- {
- mng_uint8 iOtype = *pRawdata;
- mng_uint8 iEtype;
- mng_uint32 iCount = 0;
- mng_uint8p pTemp;
- mng_uint8p pNull;
- mng_uint32 iLen;
- mng_uint32 iOffset[2];
- mng_uint32 iStarttime[2];
- mng_uint32 iFramenr;
- mng_uint32 iLayernr;
- mng_uint32 iX;
- mng_save_entryp pEntry = MNG_NULL;
- mng_uint32 iNamesize;
-
- if ((iOtype != 4) && (iOtype != 8))
- MNG_ERROR (pData, MNG_INVOFFSETSIZE);
-
- ((mng_savep)*ppChunk)->iOffsettype = iOtype;
-
- for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */
- {
- pTemp = pRawdata + 1;
- iLen = iRawlen - 1;
-
- if (iX) /* second run ? */
- {
- MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_save_entry)));
-
- ((mng_savep)*ppChunk)->iCount = iCount;
- ((mng_savep)*ppChunk)->pEntries = pEntry;
- }
-
- while (iLen) /* anything left ? */
- {
- iEtype = *pTemp; /* entrytype */
-
- if ((iEtype != 0) && (iEtype != 1) && (iEtype != 2) && (iEtype != 3))
- MNG_ERROR (pData, MNG_INVENTRYTYPE);
-
- pTemp++;
-
- if (iEtype > 1)
- {
- iOffset [0] = 0;
- iOffset [1] = 0;
- iStarttime [0] = 0;
- iStarttime [1] = 0;
- iLayernr = 0;
- iFramenr = 0;
- }
- else
- {
- if (iOtype == 4)
- {
- iOffset [0] = 0;
- iOffset [1] = mng_get_uint32 (pTemp);
-
- pTemp += 4;
- }
- else
- {
- iOffset [0] = mng_get_uint32 (pTemp);
- iOffset [1] = mng_get_uint32 (pTemp+4);
-
- pTemp += 8;
- }
-
- if (iEtype > 0)
- {
- iStarttime [0] = 0;
- iStarttime [1] = 0;
- iLayernr = 0;
- iFramenr = 0;
- }
- else
- {
- if (iOtype == 4)
- {
- iStarttime [0] = 0;
- iStarttime [1] = mng_get_uint32 (pTemp+0);
- iLayernr = mng_get_uint32 (pTemp+4);
- iFramenr = mng_get_uint32 (pTemp+8);
-
- pTemp += 12;
- }
- else
- {
- iStarttime [0] = mng_get_uint32 (pTemp+0);
- iStarttime [1] = mng_get_uint32 (pTemp+4);
- iLayernr = mng_get_uint32 (pTemp+8);
- iFramenr = mng_get_uint32 (pTemp+12);
-
- pTemp += 16;
- }
- }
- }
-
- pNull = find_null (pTemp); /* get the name length */
-
- if ((pNull - pRawdata) > (mng_int32)iRawlen)
- {
- iNamesize = iLen; /* no null found; so end of SAVE */
- iLen = 0;
- }
- else
- {
- iNamesize = pNull - pTemp; /* should be another entry */
- iLen -= iNamesize;
-
- if (!iLen) /* must not end with a null ! */
- MNG_ERROR (pData, MNG_ENDWITHNULL);
- }
-
- if (!pEntry)
- {
- iCount++;
- }
- else
- {
- pEntry->iEntrytype = iEtype;
- pEntry->iOffset [0] = iOffset [0];
- pEntry->iOffset [1] = iOffset [1];
- pEntry->iStarttime [0] = iStarttime [0];
- pEntry->iStarttime [1] = iStarttime [1];
- pEntry->iLayernr = iLayernr;
- pEntry->iFramenr = iFramenr;
- pEntry->iNamesize = iNamesize;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, pEntry->zName, iNamesize+1);
- MNG_COPY (pEntry->zName, pTemp, iNamesize);
- }
-
- pEntry++;
- }
-
- pTemp += iNamesize;
- }
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SAVE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_SEEK
-READ_CHUNK (mng_read_seek)
-{
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SEEK, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasSAVE))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_SUPPORT_DISPLAY
- /* create a SEEK animation object */
- iRetcode = mng_create_ani_seek (pData, iRawlen, (mng_pchar)pRawdata);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
-#endif /* MNG_SUPPORT_DISPLAY */
-
- if (pData->fProcessseek) /* inform the app ? */
- {
- mng_bool bOke;
- mng_pchar zName;
-
- MNG_ALLOC (pData, zName, iRawlen + 1);
-
- if (iRawlen)
- MNG_COPY (zName, pRawdata, iRawlen);
-
- bOke = pData->fProcessseek ((mng_handle)pData, zName);
-
- MNG_FREEX (pData, zName, iRawlen + 1);
-
- if (!bOke)
- MNG_ERROR (pData, MNG_APPMISCERROR);
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- /* do display processing of the SEEK */
- iRetcode = mng_process_display_seek (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_seekp)*ppChunk)->iNamesize = iRawlen;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_seekp)*ppChunk)->zName, iRawlen+1);
- MNG_COPY (((mng_seekp)*ppChunk)->zName, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_SEEK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_eXPI
-READ_CHUNK (mng_read_expi)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_EXPI, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 3) /* check the length */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_expip)*ppChunk)->iSnapshotid = mng_get_uint16 (pRawdata);
- ((mng_expip)*ppChunk)->iNamesize = iRawlen - 2;
-
- if (((mng_expip)*ppChunk)->iNamesize)
- {
- MNG_ALLOC (pData, ((mng_expip)*ppChunk)->zName,
- ((mng_expip)*ppChunk)->iNamesize + 1);
- MNG_COPY (((mng_expip)*ppChunk)->zName, pRawdata+2,
- ((mng_expip)*ppChunk)->iNamesize);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_EXPI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_fPRI
-READ_CHUNK (mng_read_fpri)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_FPRI, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 2) /* must be two bytes long */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_fprip)*ppChunk)->iDeltatype = *pRawdata;
- ((mng_fprip)*ppChunk)->iPriority = *(pRawdata+1);
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_FPRI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_nEED
-MNG_LOCAL mng_bool CheckKeyword (mng_datap pData,
- mng_uint8p pKeyword)
-{
- mng_chunkid handled_chunks [] =
- {
- MNG_UINT_BACK, /* keep it sorted !!!! */
- MNG_UINT_BASI,
- MNG_UINT_CLIP,
- MNG_UINT_CLON,
-#ifndef MNG_NO_DELTA_PNG
-/* TODO: MNG_UINT_DBYK, */
-#endif
- MNG_UINT_DEFI,
-#ifndef MNG_NO_DELTA_PNG
- MNG_UINT_DHDR,
-#endif
- MNG_UINT_DISC,
-#ifndef MNG_NO_DELTA_PNG
-/* TODO: MNG_UINT_DROP, */
-#endif
- MNG_UINT_ENDL,
- MNG_UINT_FRAM,
- MNG_UINT_IDAT,
- MNG_UINT_IEND,
- MNG_UINT_IHDR,
-#ifndef MNG_NO_DELTA_PNG
-#ifdef MNG_INCLUDE_JNG
- MNG_UINT_IJNG,
-#endif
- MNG_UINT_IPNG,
-#endif
-#ifdef MNG_INCLUDE_JNG
- MNG_UINT_JDAA,
- MNG_UINT_JDAT,
- MNG_UINT_JHDR,
-/* TODO: MNG_UINT_JSEP, */
- MNG_UINT_JdAA,
-#endif
- MNG_UINT_LOOP,
- MNG_UINT_MAGN,
- MNG_UINT_MEND,
- MNG_UINT_MHDR,
- MNG_UINT_MOVE,
-/* TODO: MNG_UINT_ORDR, */
- MNG_UINT_PAST,
- MNG_UINT_PLTE,
-#ifndef MNG_NO_DELTA_PNG
- MNG_UINT_PPLT,
- MNG_UINT_PROM,
-#endif
- MNG_UINT_SAVE,
- MNG_UINT_SEEK,
- MNG_UINT_SHOW,
- MNG_UINT_TERM,
-#ifdef MNG_INCLUDE_ANG_PROPOSAL
- MNG_UINT_adAT,
- MNG_UINT_ahDR,
-#endif
- MNG_UINT_bKGD,
- MNG_UINT_cHRM,
-/* TODO: MNG_UINT_eXPI, */
- MNG_UINT_evNT,
-/* TODO: MNG_UINT_fPRI, */
- MNG_UINT_gAMA,
-/* TODO: MNG_UINT_hIST, */
- MNG_UINT_iCCP,
- MNG_UINT_iTXt,
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
- MNG_UINT_mpNG,
-#endif
- MNG_UINT_nEED,
-/* TODO: MNG_UINT_oFFs, */
-/* TODO: MNG_UINT_pCAL, */
-/* TODO: MNG_UINT_pHYg, */
-/* TODO: MNG_UINT_pHYs, */
-/* TODO: MNG_UINT_sBIT, */
-/* TODO: MNG_UINT_sCAL, */
-/* TODO: MNG_UINT_sPLT, */
- MNG_UINT_sRGB,
- MNG_UINT_tEXt,
- MNG_UINT_tIME,
- MNG_UINT_tRNS,
- MNG_UINT_zTXt,
- };
-
- mng_bool bOke = MNG_FALSE;
-
- if (pData->fProcessneed) /* does the app handle it ? */
- bOke = pData->fProcessneed ((mng_handle)pData, (mng_pchar)pKeyword);
-
- if (!bOke)
- { /* find the keyword length */
- mng_uint8p pNull = find_null (pKeyword);
-
- if (pNull - pKeyword == 4) /* test a chunk ? */
- { /* get the chunk-id */
- mng_chunkid iChunkid = (*pKeyword << 24) + (*(pKeyword+1) << 16) +
- (*(pKeyword+2) << 8) + (*(pKeyword+3) );
- /* binary search variables */
- mng_int32 iTop, iLower, iUpper, iMiddle;
- /* determine max index of table */
- iTop = (sizeof (handled_chunks) / sizeof (handled_chunks [0])) - 1;
-
- /* binary search; with 52 chunks, worst-case is 7 comparisons */
- iLower = 0;
- iMiddle = iTop >> 1;
- iUpper = iTop;
-
- do /* the binary search itself */
- {
- if (handled_chunks [iMiddle] < iChunkid)
- iLower = iMiddle + 1;
- else if (handled_chunks [iMiddle] > iChunkid)
- iUpper = iMiddle - 1;
- else
- {
- bOke = MNG_TRUE;
- break;
- }
-
- iMiddle = (iLower + iUpper) >> 1;
- }
- while (iLower <= iUpper);
- }
- /* test draft ? */
- if ((!bOke) && (pNull - pKeyword == 8) &&
- (*pKeyword == 'd') && (*(pKeyword+1) == 'r') &&
- (*(pKeyword+2) == 'a') && (*(pKeyword+3) == 'f') &&
- (*(pKeyword+4) == 't') && (*(pKeyword+5) == ' '))
- {
- mng_uint32 iDraft;
-
- iDraft = (*(pKeyword+6) - '0') * 10 + (*(pKeyword+7) - '0');
- bOke = (mng_bool)(iDraft <= MNG_MNG_DRAFT);
- }
- /* test MNG 1.0/1.1 ? */
- if ((!bOke) && (pNull - pKeyword == 7) &&
- (*pKeyword == 'M') && (*(pKeyword+1) == 'N') &&
- (*(pKeyword+2) == 'G') && (*(pKeyword+3) == '-') &&
- (*(pKeyword+4) == '1') && (*(pKeyword+5) == '.') &&
- ((*(pKeyword+6) == '0') || (*(pKeyword+6) == '1')))
- bOke = MNG_TRUE;
- /* test CACHEOFF ? */
- if ((!bOke) && (pNull - pKeyword == 8) &&
- (*pKeyword == 'C') && (*(pKeyword+1) == 'A') &&
- (*(pKeyword+2) == 'C') && (*(pKeyword+3) == 'H') &&
- (*(pKeyword+4) == 'E') && (*(pKeyword+5) == 'O') &&
- (*(pKeyword+6) == 'F') && (*(pKeyword+7) == 'F'))
- {
- if (!pData->pFirstaniobj) /* only if caching hasn't started yet ! */
- {
- bOke = MNG_TRUE;
- pData->bCacheplayback = MNG_FALSE;
- pData->bStorechunks = MNG_FALSE;
- }
- }
- }
-
- return bOke;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_nEED
-READ_CHUNK (mng_read_need)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_NEED, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 1) /* check the length */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- { /* let's check it */
- mng_bool bOke = MNG_TRUE;
- mng_pchar zKeywords;
- mng_uint8p pNull, pTemp;
-
- MNG_ALLOC (pData, zKeywords, iRawlen + 1);
-
- if (iRawlen)
- MNG_COPY (zKeywords, pRawdata, iRawlen);
-
- pTemp = (mng_uint8p)zKeywords;
- pNull = find_null (pTemp);
-
- while ((bOke) && (pNull < (mng_uint8p)zKeywords + iRawlen))
- {
- bOke = CheckKeyword (pData, pTemp);
- pTemp = pNull + 1;
- pNull = find_null (pTemp);
- }
-
- if (bOke)
- bOke = CheckKeyword (pData, pTemp);
-
- MNG_FREEX (pData, zKeywords, iRawlen + 1);
-
- if (!bOke)
- MNG_ERROR (pData, MNG_UNSUPPORTEDNEED);
- }
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_needp)*ppChunk)->iKeywordssize = iRawlen;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_needp)*ppChunk)->zKeywords, iRawlen+1);
- MNG_COPY (((mng_needp)*ppChunk)->zKeywords, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_NEED, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_pHYg
-READ_CHUNK (mng_read_phyg)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PHYG, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* it's 9 bytes or empty; no more, no less! */
- if ((iRawlen != 9) && (iRawlen != 0))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_phygp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
-
- if (iRawlen)
- {
- ((mng_phygp)*ppChunk)->iSizex = mng_get_uint32 (pRawdata);
- ((mng_phygp)*ppChunk)->iSizey = mng_get_uint32 (pRawdata+4);
- ((mng_phygp)*ppChunk)->iUnit = *(pRawdata+8);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PHYG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_INCLUDE_JNG
-READ_CHUNK (mng_read_jhdr)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JHDR, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((pData->eSigtype != mng_it_jng) && (pData->eSigtype != mng_it_mng))
- MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
-
- if ((pData->eSigtype == mng_it_jng) && (pData->iChunkseq > 1))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 16) /* length oke ? */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- /* inside a JHDR-IEND block now */
- pData->bHasJHDR = MNG_TRUE;
- /* and store interesting fields */
- pData->iDatawidth = mng_get_uint32 (pRawdata);
- pData->iDataheight = mng_get_uint32 (pRawdata+4);
- pData->iJHDRcolortype = *(pRawdata+8);
- pData->iJHDRimgbitdepth = *(pRawdata+9);
- pData->iJHDRimgcompression = *(pRawdata+10);
- pData->iJHDRimginterlace = *(pRawdata+11);
- pData->iJHDRalphabitdepth = *(pRawdata+12);
- pData->iJHDRalphacompression = *(pRawdata+13);
- pData->iJHDRalphafilter = *(pRawdata+14);
- pData->iJHDRalphainterlace = *(pRawdata+15);
-
-
-#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
- pData->iPNGmult = 1;
- pData->iPNGdepth = pData->iJHDRalphabitdepth;
-#endif
-
-#ifdef MNG_NO_1_2_4BIT_SUPPORT
- if (pData->iJHDRalphabitdepth < 8)
- pData->iJHDRalphabitdepth = 8;
-#endif
-
-#ifdef MNG_NO_16BIT_SUPPORT
- if (pData->iJHDRalphabitdepth > 8)
- {
- pData->iPNGmult = 2;
- pData->iJHDRalphabitdepth = 8;
- }
-#endif
- /* parameter validity checks */
- if ((pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAY ) &&
- (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLOR ) &&
- (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAYA ) &&
- (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLORA) )
- MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
-
- if ((pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8 ) &&
- (pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG12 ) &&
- (pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8AND12) )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if (pData->iJHDRimgcompression != MNG_COMPRESSION_BASELINEJPEG)
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
- if ((pData->iJHDRimginterlace != MNG_INTERLACE_SEQUENTIAL ) &&
- (pData->iJHDRimginterlace != MNG_INTERLACE_PROGRESSIVE) )
- MNG_ERROR (pData, MNG_INVALIDINTERLACE);
-
- if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
- (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) )
- {
- if ((pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 )
-#ifndef MNG_NO_1_2_4BIT_SUPPORT
- && (pData->iJHDRalphabitdepth != MNG_BITDEPTH_1 ) &&
- (pData->iJHDRalphabitdepth != MNG_BITDEPTH_2 ) &&
- (pData->iJHDRalphabitdepth != MNG_BITDEPTH_4 )
-#endif
-#ifndef MNG_NO_16BIT_SUPPORT
- && (pData->iJHDRalphabitdepth != MNG_BITDEPTH_16)
-#endif
- )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if ((pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE ) &&
- (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG) )
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
- if ((pData->iJHDRalphacompression == MNG_COMPRESSION_BASELINEJPEG) &&
- (pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 ) )
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
-#if defined(FILTER192) || defined(FILTER193)
- if ((pData->iJHDRalphafilter != MNG_FILTER_ADAPTIVE ) &&
-#if defined(FILTER192) && defined(FILTER193)
- (pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) &&
- (pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) )
-#else
-#ifdef FILTER192
- (pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) )
-#else
- (pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) )
-#endif
-#endif
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-#else
- if (pData->iJHDRalphafilter)
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-#endif
-
- if ((pData->iJHDRalphainterlace != MNG_INTERLACE_NONE ) &&
- (pData->iJHDRalphainterlace != MNG_INTERLACE_ADAM7) )
- MNG_ERROR (pData, MNG_INVALIDINTERLACE);
-
- }
- else
- {
- if (pData->iJHDRalphabitdepth)
- MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
-
- if (pData->iJHDRalphacompression)
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
- if (pData->iJHDRalphafilter)
- MNG_ERROR (pData, MNG_INVALIDFILTER);
-
- if (pData->iJHDRalphainterlace)
- MNG_ERROR (pData, MNG_INVALIDINTERLACE);
-
- }
-
- if (!pData->bHasheader) /* first chunk ? */
- {
- pData->bHasheader = MNG_TRUE; /* we've got a header */
- pData->eImagetype = mng_it_jng; /* then this must be a JNG */
- pData->iWidth = mng_get_uint32 (pRawdata);
- pData->iHeight = mng_get_uint32 (pRawdata+4);
- /* predict alpha-depth ! */
- if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
- (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) )
- pData->iAlphadepth = pData->iJHDRalphabitdepth;
- else
- pData->iAlphadepth = 0;
- /* fits on maximum canvas ? */
- if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
- MNG_WARNING (pData, MNG_IMAGETOOLARGE);
-
- if (pData->fProcessheader) /* inform the app ? */
- if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
- MNG_ERROR (pData, MNG_APPMISCERROR);
-
- }
-
- pData->iColortype = 0; /* fake grayscale for other routines */
- pData->iImagelevel++; /* one level deeper */
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode = mng_process_display_jhdr (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_jhdrp)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
- ((mng_jhdrp)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
- ((mng_jhdrp)*ppChunk)->iColortype = *(pRawdata+8);
- ((mng_jhdrp)*ppChunk)->iImagesampledepth = *(pRawdata+9);
- ((mng_jhdrp)*ppChunk)->iImagecompression = *(pRawdata+10);
- ((mng_jhdrp)*ppChunk)->iImageinterlace = *(pRawdata+11);
- ((mng_jhdrp)*ppChunk)->iAlphasampledepth = *(pRawdata+12);
-#ifdef MNG_NO_16BIT_SUPPORT
- if (*(pRawdata+12) > 8)
- ((mng_jhdrp)*ppChunk)->iAlphasampledepth = 8;
-#endif
- ((mng_jhdrp)*ppChunk)->iAlphacompression = *(pRawdata+13);
- ((mng_jhdrp)*ppChunk)->iAlphafilter = *(pRawdata+14);
- ((mng_jhdrp)*ppChunk)->iAlphainterlace = *(pRawdata+15);
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#else
-#define read_jhdr 0
-#endif /* MNG_INCLUDE_JNG */
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_INCLUDE_JNG
-READ_CHUNK (mng_read_jdaa)
-{
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- volatile mng_retcode iRetcode;
-
- iRetcode=MNG_NOERROR;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JDAA, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasJHDR) && (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (pData->bHasJSEP)
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG)
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen == 0) /* can never be empty */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasJDAA = MNG_TRUE; /* got some JDAA now, don't we */
-
-#ifdef MNG_SUPPORT_DISPLAY
- iRetcode = mng_process_display_jdaa (pData, iRawlen, pRawdata);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_jdaap)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_jdaap)*ppChunk)->iDatasize = iRawlen;
-
- if (iRawlen != 0) /* is there any data ? */
- {
- MNG_ALLOC (pData, ((mng_jdaap)*ppChunk)->pData, iRawlen);
- MNG_COPY (((mng_jdaap)*ppChunk)->pData, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JDAA, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#else
-#define read_jdaa 0
-#endif /* MNG_INCLUDE_JNG */
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_INCLUDE_JNG
-READ_CHUNK (mng_read_jdat)
-{
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- volatile mng_retcode iRetcode;
-
- iRetcode=MNG_NOERROR;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JDAT, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasJHDR) && (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen == 0) /* can never be empty */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasJDAT = MNG_TRUE; /* got some JDAT now, don't we */
-
-#ifdef MNG_SUPPORT_DISPLAY
- iRetcode = mng_process_display_jdat (pData, iRawlen, pRawdata);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_jdatp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_jdatp)*ppChunk)->iDatasize = iRawlen;
-
- if (iRawlen != 0) /* is there any data ? */
- {
- MNG_ALLOC (pData, ((mng_jdatp)*ppChunk)->pData, iRawlen);
- MNG_COPY (((mng_jdatp)*ppChunk)->pData, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JDAT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#else
-#define read_jdat 0
-#endif /* MNG_INCLUDE_JNG */
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_INCLUDE_JNG
-READ_CHUNK (mng_read_jsep)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JSEP, MNG_LC_START);
-#endif
-
- if (!pData->bHasJHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 0) /* must be empty ! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasJSEP = MNG_TRUE; /* indicate we've had the 8-/12-bit separator */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_JSEP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#else
-#define read_jsep 0
-#endif /* MNG_INCLUDE_JNG */
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-READ_CHUNK (mng_read_dhdr)
-{
- mng_uint8 iImagetype, iDeltatype;
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DHDR, MNG_LC_START);
-#endif
-
- if (!pData->bHasMHDR) /* sequence checks */
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check for valid length */
- if ((iRawlen != 4) && (iRawlen != 12) && (iRawlen != 20))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- iImagetype = *(pRawdata+2); /* check fields for validity */
- iDeltatype = *(pRawdata+3);
-
- if (iImagetype > MNG_IMAGETYPE_JNG)
- MNG_ERROR (pData, MNG_INVIMAGETYPE);
-
- if (iDeltatype > MNG_DELTATYPE_NOCHANGE)
- MNG_ERROR (pData, MNG_INVDELTATYPE);
-
- if ((iDeltatype == MNG_DELTATYPE_REPLACE) && (iRawlen > 12))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((iDeltatype == MNG_DELTATYPE_NOCHANGE) && (iRawlen > 4))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- pData->bHasDHDR = MNG_TRUE; /* inside a DHDR-IEND block now */
- pData->iDeltatype = iDeltatype;
-
- pData->iImagelevel++; /* one level deeper */
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_uint16 iObjectid = mng_get_uint16 (pRawdata);
- mng_uint32 iBlockwidth = 0;
- mng_uint32 iBlockheight = 0;
- mng_uint32 iBlockx = 0;
- mng_uint32 iBlocky = 0;
- mng_retcode iRetcode;
-
- if (iRawlen > 4)
- {
- iBlockwidth = mng_get_uint32 (pRawdata+4);
- iBlockheight = mng_get_uint32 (pRawdata+8);
- }
-
- if (iRawlen > 12)
- {
- iBlockx = mng_get_uint32 (pRawdata+12);
- iBlocky = mng_get_uint32 (pRawdata+16);
- }
-
- iRetcode = mng_create_ani_dhdr (pData, iObjectid, iImagetype, iDeltatype,
- iBlockwidth, iBlockheight, iBlockx, iBlocky);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_dhdr (pData, iObjectid, iImagetype, iDeltatype,
- iBlockwidth, iBlockheight, iBlockx, iBlocky); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_dhdrp)*ppChunk)->iObjectid = mng_get_uint16 (pRawdata);
- ((mng_dhdrp)*ppChunk)->iImagetype = iImagetype;
- ((mng_dhdrp)*ppChunk)->iDeltatype = iDeltatype;
-
- if (iRawlen > 4)
- {
- ((mng_dhdrp)*ppChunk)->iBlockwidth = mng_get_uint32 (pRawdata+4);
- ((mng_dhdrp)*ppChunk)->iBlockheight = mng_get_uint32 (pRawdata+8);
- }
-
- if (iRawlen > 12)
- {
- ((mng_dhdrp)*ppChunk)->iBlockx = mng_get_uint32 (pRawdata+12);
- ((mng_dhdrp)*ppChunk)->iBlocky = mng_get_uint32 (pRawdata+16);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-READ_CHUNK (mng_read_prom)
-{
- mng_uint8 iColortype;
- mng_uint8 iSampledepth;
- mng_uint8 iFilltype;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PROM, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 3) /* gotta be exactly 3 bytes */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- iColortype = *pRawdata; /* check fields for validity */
- iSampledepth = *(pRawdata+1);
- iFilltype = *(pRawdata+2);
-
- if ((iColortype != MNG_COLORTYPE_GRAY ) &&
- (iColortype != MNG_COLORTYPE_RGB ) &&
- (iColortype != MNG_COLORTYPE_INDEXED) &&
- (iColortype != MNG_COLORTYPE_GRAYA ) &&
- (iColortype != MNG_COLORTYPE_RGBA ) )
- MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
-
-#ifdef MNG_NO_16BIT_SUPPORT
- if (iSampledepth == MNG_BITDEPTH_16 )
- iSampledepth = MNG_BITDEPTH_8;
-#endif
-
- if ((iSampledepth != MNG_BITDEPTH_1 ) &&
- (iSampledepth != MNG_BITDEPTH_2 ) &&
- (iSampledepth != MNG_BITDEPTH_4 ) &&
- (iSampledepth != MNG_BITDEPTH_8 )
-#ifndef MNG_NO_16BIT_SUPPORT
- && (iSampledepth != MNG_BITDEPTH_16)
-#endif
- )
- MNG_ERROR (pData, MNG_INVSAMPLEDEPTH);
-
- if ((iFilltype != MNG_FILLMETHOD_LEFTBITREPLICATE) &&
- (iFilltype != MNG_FILLMETHOD_ZEROFILL ) )
- MNG_ERROR (pData, MNG_INVFILLMETHOD);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode = mng_create_ani_prom (pData, iSampledepth,
- iColortype, iFilltype);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_prom (pData, iSampledepth,
- iColortype, iFilltype); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_promp)*ppChunk)->iColortype = iColortype;
- ((mng_promp)*ppChunk)->iSampledepth = iSampledepth;
- ((mng_promp)*ppChunk)->iFilltype = iFilltype;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PROM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-READ_CHUNK (mng_read_ipng)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IPNG, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 0) /* gotta be empty */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode = mng_create_ani_ipng (pData);
-
- if (!iRetcode)
- iRetcode = mng_process_display_ipng (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IPNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-READ_CHUNK (mng_read_pplt)
-{
- mng_uint8 iDeltatype;
- mng_uint8p pTemp;
- mng_uint32 iLen;
- mng_uint8 iX, iM;
- mng_uint32 iY;
- mng_uint32 iMax;
- mng_rgbpaltab aIndexentries;
- mng_uint8arr aAlphaentries;
- mng_uint8arr aUsedentries;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PPLT, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) && (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 1) /* must have at least 1 byte */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- iDeltatype = *pRawdata;
- /* valid ? */
- if (iDeltatype > MNG_DELTATYPE_DELTARGBA)
- MNG_ERROR (pData, MNG_INVDELTATYPE);
- /* must be indexed color ! */
- if (pData->iColortype != MNG_COLORTYPE_INDEXED)
- MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
-
- pTemp = pRawdata + 1;
- iLen = iRawlen - 1;
- iMax = 0;
-
- for (iY = 0; iY < 256; iY++) /* reset arrays */
- {
- aIndexentries [iY].iRed = 0;
- aIndexentries [iY].iGreen = 0;
- aIndexentries [iY].iBlue = 0;
- aAlphaentries [iY] = 255;
- aUsedentries [iY] = 0;
- }
-
- while (iLen) /* as long as there are entries left ... */
- {
- mng_uint32 iDiff;
-
- if (iLen < 2)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- iX = *pTemp; /* get start and end index */
- iM = *(pTemp+1);
-
- if (iM < iX)
- MNG_ERROR (pData, MNG_INVALIDINDEX);
-
- if ((mng_uint32)iM >= iMax) /* determine highest used index */
- iMax = (mng_uint32)iM + 1;
-
- pTemp += 2;
- iLen -= 2;
- iDiff = (iM - iX + 1);
- if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) ||
- (iDeltatype == MNG_DELTATYPE_DELTARGB ) )
- iDiff = iDiff * 3;
- else
- if ((iDeltatype == MNG_DELTATYPE_REPLACERGBA) ||
- (iDeltatype == MNG_DELTATYPE_DELTARGBA ) )
- iDiff = iDiff * 4;
-
- if (iLen < iDiff)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) ||
- (iDeltatype == MNG_DELTATYPE_DELTARGB ) )
- {
- for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
- {
- aIndexentries [iY].iRed = *pTemp;
- aIndexentries [iY].iGreen = *(pTemp+1);
- aIndexentries [iY].iBlue = *(pTemp+2);
- aUsedentries [iY] = 1;
-
- pTemp += 3;
- iLen -= 3;
- }
- }
- else
- if ((iDeltatype == MNG_DELTATYPE_REPLACEALPHA) ||
- (iDeltatype == MNG_DELTATYPE_DELTAALPHA ) )
- {
- for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
- {
- aAlphaentries [iY] = *pTemp;
- aUsedentries [iY] = 1;
-
- pTemp++;
- iLen--;
- }
- }
- else
- {
- for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
- {
- aIndexentries [iY].iRed = *pTemp;
- aIndexentries [iY].iGreen = *(pTemp+1);
- aIndexentries [iY].iBlue = *(pTemp+2);
- aAlphaentries [iY] = *(pTemp+3);
- aUsedentries [iY] = 1;
-
- pTemp += 4;
- iLen -= 4;
- }
- }
- }
-
- switch (pData->iBitdepth) /* check maximum allowed entries for bitdepth */
- {
- case MNG_BITDEPTH_1 : {
- if (iMax > 2)
- MNG_ERROR (pData, MNG_INVALIDINDEX);
- break;
- }
- case MNG_BITDEPTH_2 : {
- if (iMax > 4)
- MNG_ERROR (pData, MNG_INVALIDINDEX);
- break;
- }
- case MNG_BITDEPTH_4 : {
- if (iMax > 16)
- MNG_ERROR (pData, MNG_INVALIDINDEX);
- break;
- }
- }
-
-#ifdef MNG_SUPPORT_DISPLAY
- { /* create animation object */
- mng_retcode iRetcode = mng_create_ani_pplt (pData, iDeltatype, iMax,
- aIndexentries, aAlphaentries,
- aUsedentries);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_pplt (pData, iDeltatype, iMax, aIndexentries,
- aAlphaentries, aUsedentries); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_ppltp)*ppChunk)->iDeltatype = iDeltatype;
- ((mng_ppltp)*ppChunk)->iCount = iMax;
-
- for (iY = 0; iY < 256; iY++)
- {
- ((mng_ppltp)*ppChunk)->aEntries [iY].iRed = aIndexentries [iY].iRed;
- ((mng_ppltp)*ppChunk)->aEntries [iY].iGreen = aIndexentries [iY].iGreen;
- ((mng_ppltp)*ppChunk)->aEntries [iY].iBlue = aIndexentries [iY].iBlue;
- ((mng_ppltp)*ppChunk)->aEntries [iY].iAlpha = aAlphaentries [iY];
- ((mng_ppltp)*ppChunk)->aEntries [iY].bUsed = (mng_bool)(aUsedentries [iY]);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_PPLT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-#ifdef MNG_INCLUDE_JNG
-READ_CHUNK (mng_read_ijng)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IJNG, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen != 0) /* gotta be empty */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode = mng_create_ani_ijng (pData);
-
- if (!iRetcode)
- iRetcode = mng_process_display_ijng (pData);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_IJNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-READ_CHUNK (mng_read_drop)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DROP, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check length */
- if ((iRawlen < 4) || ((iRawlen % 4) != 0))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_dropp)*ppChunk)->iCount = iRawlen / 4;
-
- if (iRawlen)
- {
- mng_uint32 iX;
- mng_uint8p pTemp = pRawdata;
- mng_uint32p pEntry;
-
- MNG_ALLOC (pData, pEntry, iRawlen);
-
- ((mng_dropp)*ppChunk)->pChunknames = (mng_ptr)pEntry;
-
- for (iX = 0; iX < iRawlen / 4; iX++)
- {
- *pEntry = mng_get_uint32 (pTemp);
-
- pTemp += 4;
- pEntry++;
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DROP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_DBYK
-READ_CHUNK (mng_read_dbyk)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DBYK, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 6) /* must be at least 6 long */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_dbykp)*ppChunk)->iChunkname = mng_get_uint32 (pRawdata);
- ((mng_dbykp)*ppChunk)->iPolarity = *(pRawdata+4);
- ((mng_dbykp)*ppChunk)->iKeywordssize = iRawlen - 5;
-
- if (iRawlen > 5)
- {
- MNG_ALLOC (pData, ((mng_dbykp)*ppChunk)->zKeywords, iRawlen-4);
- MNG_COPY (((mng_dbykp)*ppChunk)->zKeywords, pRawdata+5, iRawlen-5);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_DBYK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_ORDR
-READ_CHUNK (mng_read_ordr)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ORDR, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check length */
- if ((iRawlen < 5) || ((iRawlen % 5) != 0))
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
-
-
- /* TODO: something !!! */
-
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_ordrp)*ppChunk)->iCount = iRawlen / 5;
-
- if (iRawlen)
- {
- mng_uint32 iX;
- mng_ordr_entryp pEntry;
- mng_uint8p pTemp = pRawdata;
-
- MNG_ALLOC (pData, pEntry, iRawlen);
-
- ((mng_ordrp)*ppChunk)->pEntries = pEntry;
-
- for (iX = 0; iX < iRawlen / 5; iX++)
- {
- pEntry->iChunkname = mng_get_uint32 (pTemp);
- pEntry->iOrdertype = *(pTemp+4);
-
- pTemp += 5;
- pEntry++;
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_ORDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_MAGN
-READ_CHUNK (mng_read_magn)
-{
- mng_uint16 iFirstid, iLastid;
- mng_uint8 iMethodX, iMethodY;
- mng_uint16 iMX, iMY, iML, iMR, iMT, iMB;
- mng_bool bFaulty;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MAGN, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_SUPPORT_JNG
- if ((!pData->bHasMHDR) || (pData->bHasIHDR) || (pData->bHasDHDR) || (pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) || (pData->bHasIHDR) || (pData->bHasDHDR))
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* check length */
- if (iRawlen > 20)
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- /* following is an ugly hack to allow faulty layout caused by previous
- versions of libmng and MNGeye, which wrote MAGN with a 16-bit
- MethodX/MethodY (as opposed to the proper 8-bit as defined in the spec!) */
-
- if ((iRawlen == 6) || (iRawlen == 8) || (iRawlen == 10) || (iRawlen == 12) ||
- (iRawlen == 14) || (iRawlen == 16) || (iRawlen == 20))
- bFaulty = MNG_TRUE; /* these lengths are all wrong */
- else /* length 18 can be right or wrong !!! */
- if ((iRawlen == 18) && (mng_get_uint16 (pRawdata+4) <= 5) &&
- (mng_get_uint16 (pRawdata+6) < 256) &&
- (mng_get_uint16 (pRawdata+8) < 256) &&
- (mng_get_uint16 (pRawdata+10) < 256) &&
- (mng_get_uint16 (pRawdata+12) < 256) &&
- (mng_get_uint16 (pRawdata+14) < 256) &&
- (mng_get_uint16 (pRawdata+16) < 256))
- bFaulty = MNG_TRUE; /* this is very likely the wrong layout */
- else
- bFaulty = MNG_FALSE; /* all other cases are handled as right */
-
- if (bFaulty) /* wrong layout ? */
- {
- if (iRawlen > 0) /* get the fields */
- iFirstid = mng_get_uint16 (pRawdata);
- else
- iFirstid = 0;
-
- if (iRawlen > 2)
- iLastid = mng_get_uint16 (pRawdata+2);
- else
- iLastid = iFirstid;
-
- if (iRawlen > 4)
- iMethodX = (mng_uint8)(mng_get_uint16 (pRawdata+4));
- else
- iMethodX = 0;
-
- if (iRawlen > 6)
- iMX = mng_get_uint16 (pRawdata+6);
- else
- iMX = 1;
-
- if (iRawlen > 8)
- iMY = mng_get_uint16 (pRawdata+8);
- else
- iMY = iMX;
-
- if (iRawlen > 10)
- iML = mng_get_uint16 (pRawdata+10);
- else
- iML = iMX;
-
- if (iRawlen > 12)
- iMR = mng_get_uint16 (pRawdata+12);
- else
- iMR = iMX;
-
- if (iRawlen > 14)
- iMT = mng_get_uint16 (pRawdata+14);
- else
- iMT = iMY;
-
- if (iRawlen > 16)
- iMB = mng_get_uint16 (pRawdata+16);
- else
- iMB = iMY;
-
- if (iRawlen > 18)
- iMethodY = (mng_uint8)(mng_get_uint16 (pRawdata+18));
- else
- iMethodY = iMethodX;
- }
- else /* proper layout !!!! */
- {
- if (iRawlen > 0) /* get the fields */
- iFirstid = mng_get_uint16 (pRawdata);
- else
- iFirstid = 0;
-
- if (iRawlen > 2)
- iLastid = mng_get_uint16 (pRawdata+2);
- else
- iLastid = iFirstid;
-
- if (iRawlen > 4)
- iMethodX = *(pRawdata+4);
- else
- iMethodX = 0;
-
- if (iRawlen > 5)
- iMX = mng_get_uint16 (pRawdata+5);
- else
- iMX = 1;
-
- if (iRawlen > 7)
- iMY = mng_get_uint16 (pRawdata+7);
- else
- iMY = iMX;
-
- if (iRawlen > 9)
- iML = mng_get_uint16 (pRawdata+9);
- else
- iML = iMX;
-
- if (iRawlen > 11)
- iMR = mng_get_uint16 (pRawdata+11);
- else
- iMR = iMX;
-
- if (iRawlen > 13)
- iMT = mng_get_uint16 (pRawdata+13);
- else
- iMT = iMY;
-
- if (iRawlen > 15)
- iMB = mng_get_uint16 (pRawdata+15);
- else
- iMB = iMY;
-
- if (iRawlen > 17)
- iMethodY = *(pRawdata+17);
- else
- iMethodY = iMethodX;
- }
- /* check field validity */
- if ((iMethodX > 5) || (iMethodY > 5))
- MNG_ERROR (pData, MNG_INVALIDMETHOD);
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- mng_retcode iRetcode;
-
- iRetcode = mng_create_ani_magn (pData, iFirstid, iLastid, iMethodX,
- iMX, iMY, iML, iMR, iMT, iMB, iMethodY);
-
-/* if (!iRetcode)
- iRetcode = mng_process_display_magn (pData, iFirstid, iLastid, iMethodX,
- iMX, iMY, iML, iMR, iMT, iMB, iMethodY); */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_magnp)*ppChunk)->iFirstid = iFirstid;
- ((mng_magnp)*ppChunk)->iLastid = iLastid;
- ((mng_magnp)*ppChunk)->iMethodX = iMethodX;
- ((mng_magnp)*ppChunk)->iMX = iMX;
- ((mng_magnp)*ppChunk)->iMY = iMY;
- ((mng_magnp)*ppChunk)->iML = iML;
- ((mng_magnp)*ppChunk)->iMR = iMR;
- ((mng_magnp)*ppChunk)->iMT = iMT;
- ((mng_magnp)*ppChunk)->iMB = iMB;
- ((mng_magnp)*ppChunk)->iMethodY = iMethodY;
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MAGN, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
-READ_CHUNK (mng_read_mpng)
-{
- mng_uint32 iFramewidth;
- mng_uint32 iFrameheight;
- mng_uint16 iTickspersec;
- mng_uint32 iFramessize;
- mng_uint32 iCompressedsize;
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- mng_retcode iRetcode;
- mng_uint16 iNumplays;
- mng_uint32 iBufsize;
- mng_uint8p pBuf = 0;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MPNG, MNG_LC_START);
-#endif
- /* sequence checks */
- if (!pData->bHasIHDR)
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 41) /* length must be at least 41 */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
- iFramewidth = mng_get_int32 (pRawdata);
- if (iFramewidth == 0) /* frame_width must not be zero */
- MNG_ERROR (pData, MNG_INVALIDWIDTH);
-
- iFrameheight = mng_get_int32 (pRawdata+4);
- if (iFrameheight == 0) /* frame_height must not be zero */
- MNG_ERROR (pData, MNG_INVALIDHEIGHT);
-
- iTickspersec = mng_get_uint16 (pRawdata+10);
- if (iTickspersec == 0) /* delay_den must not be zero */
- MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
-
- if (*(pRawdata+12) != 0) /* only deflate compression-method allowed */
- MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
-
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- iNumplays = mng_get_uint16 (pRawdata+8);
- iCompressedsize = (mng_uint32)(iRawlen - 13);
-#endif
-
-#ifdef MNG_SUPPORT_DISPLAY
- {
- iRetcode = mng_inflate_buffer (pData, pRawdata+13, iCompressedsize,
- &pBuf, &iBufsize, &iFramessize);
- if (iRetcode) /* on error bail out */
- {
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
-
- if (iFramessize % 26)
- {
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-
- iRetcode = mng_create_mpng_obj (pData, iFramewidth, iFrameheight, iNumplays,
- iTickspersec, iFramessize, pBuf);
- if (iRetcode) /* on error bail out */
- {
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the fields */
- ((mng_mpngp)*ppChunk)->iFramewidth = iFramewidth;
- ((mng_mpngp)*ppChunk)->iFrameheight = iFrameheight;
- ((mng_mpngp)*ppChunk)->iNumplays = iNumplays;
- ((mng_mpngp)*ppChunk)->iTickspersec = iTickspersec;
- ((mng_mpngp)*ppChunk)->iCompressionmethod = *(pRawdata+14);
-
-#ifndef MNG_SUPPORT_DISPLAY
- iRetcode = mng_inflate_buffer (pData, pRawdata+13, iCompressedsize,
- &pBuf, &iBufsize, &iFramessize);
- if (iRetcode) /* on error bail out */
- {
- MNG_FREEX (pData, pBuf, iBufsize);
- return iRetcode;
- }
-
- if (iFramessize % 26)
- {
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- }
-#endif
-
- if (iFramessize)
- {
- MNG_ALLOCX (pData, ((mng_mpngp)*ppChunk)->pFrames, iFramessize);
- if (((mng_mpngp)*ppChunk)->pFrames == 0)
- {
- MNG_FREEX (pData, pBuf, iBufsize);
- MNG_ERROR (pData, MNG_OUTOFMEMORY);
- }
-
- ((mng_mpngp)*ppChunk)->iFramessize = iFramessize;
- MNG_COPY (((mng_mpngp)*ppChunk)->pFrames, pBuf, iFramessize);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
- MNG_FREEX (pData, pBuf, iBufsize);
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_MPNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifndef MNG_SKIPCHUNK_evNT
-READ_CHUNK (mng_read_evnt)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_EVNT, MNG_LC_START);
-#endif
- /* sequence checks */
- if ((!pData->bHasMHDR) || (pData->bHasSAVE))
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
-
- if (iRawlen < 2) /* must have at least 1 entry ! */
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
-
-#if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG)
- {
- if (iRawlen) /* not empty ? */
- {
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint8p pNull;
- mng_uint32 iLen;
- mng_uint8 iEventtype;
- mng_uint8 iMasktype;
- mng_int32 iLeft;
- mng_int32 iRight;
- mng_int32 iTop;
- mng_int32 iBottom;
- mng_uint16 iObjectid;
- mng_uint8 iIndex;
- mng_uint32 iNamesize;
-
- pTemp = pRawdata;
- iLen = iRawlen;
-
- while (iLen) /* anything left ? */
- {
- iEventtype = *pTemp; /* eventtype */
- if (iEventtype > 5)
- MNG_ERROR (pData, MNG_INVALIDEVENT);
-
- pTemp++;
-
- iMasktype = *pTemp; /* masktype */
- if (iMasktype > 5)
- MNG_ERROR (pData, MNG_INVALIDMASK);
-
- pTemp++;
- iLen -= 2;
-
- iLeft = 0;
- iRight = 0;
- iTop = 0;
- iBottom = 0;
- iObjectid = 0;
- iIndex = 0;
-
- switch (iMasktype)
- {
- case 1 :
- {
- if (iLen > 16)
- {
- iLeft = mng_get_int32 (pTemp);
- iRight = mng_get_int32 (pTemp+4);
- iTop = mng_get_int32 (pTemp+8);
- iBottom = mng_get_int32 (pTemp+12);
- pTemp += 16;
- iLen -= 16;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 2 :
- {
- if (iLen > 2)
- {
- iObjectid = mng_get_uint16 (pTemp);
- pTemp += 2;
- iLen -= 2;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 3 :
- {
- if (iLen > 3)
- {
- iObjectid = mng_get_uint16 (pTemp);
- iIndex = *(pTemp+2);
- pTemp += 3;
- iLen -= 3;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 4 :
- {
- if (iLen > 18)
- {
- iLeft = mng_get_int32 (pTemp);
- iRight = mng_get_int32 (pTemp+4);
- iTop = mng_get_int32 (pTemp+8);
- iBottom = mng_get_int32 (pTemp+12);
- iObjectid = mng_get_uint16 (pTemp+16);
- pTemp += 18;
- iLen -= 18;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 5 :
- {
- if (iLen > 19)
- {
- iLeft = mng_get_int32 (pTemp);
- iRight = mng_get_int32 (pTemp+4);
- iTop = mng_get_int32 (pTemp+8);
- iBottom = mng_get_int32 (pTemp+12);
- iObjectid = mng_get_uint16 (pTemp+16);
- iIndex = *(pTemp+18);
- pTemp += 19;
- iLen -= 19;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- }
-
- pNull = find_null (pTemp); /* get the name length */
-
- if ((pNull - pTemp) > (mng_int32)iLen)
- {
- iNamesize = iLen; /* no null found; so end of evNT */
- iLen = 0;
- }
- else
- {
- iNamesize = pNull - pTemp; /* should be another entry */
- iLen = iLen - iNamesize - 1;
-
- if (!iLen) /* must not end with a null ! */
- MNG_ERROR (pData, MNG_ENDWITHNULL);
- }
-
- iRetcode = mng_create_event (pData, iEventtype, iMasktype, iLeft, iRight,
- iTop, iBottom, iObjectid, iIndex,
- iNamesize, (mng_pchar)pTemp);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- pTemp = pTemp + iNamesize + 1;
- }
- }
- }
-#endif /* MNG_SUPPORT_DISPLAY && MNG_SUPPORT_DYNAMICMNG */
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- if (iRawlen) /* not empty ? */
- {
- mng_uint32 iX;
- mng_uint32 iCount = 0;
- mng_uint8p pTemp;
- mng_uint8p pNull;
- mng_uint32 iLen;
- mng_uint8 iEventtype;
- mng_uint8 iMasktype;
- mng_int32 iLeft;
- mng_int32 iRight;
- mng_int32 iTop;
- mng_int32 iBottom;
- mng_uint16 iObjectid;
- mng_uint8 iIndex;
- mng_uint32 iNamesize;
- mng_evnt_entryp pEntry = MNG_NULL;
-
- for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */
- {
- pTemp = pRawdata;
- iLen = iRawlen;
-
- if (iX) /* second run ? */
- {
- MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_evnt_entry)));
-
- ((mng_evntp)*ppChunk)->iCount = iCount;
- ((mng_evntp)*ppChunk)->pEntries = pEntry;
- }
-
- while (iLen) /* anything left ? */
- {
- iEventtype = *pTemp; /* eventtype */
- if (iEventtype > 5)
- MNG_ERROR (pData, MNG_INVALIDEVENT);
-
- pTemp++;
-
- iMasktype = *pTemp; /* masktype */
- if (iMasktype > 5)
- MNG_ERROR (pData, MNG_INVALIDMASK);
-
- pTemp++;
- iLen -= 2;
-
- iLeft = 0;
- iRight = 0;
- iTop = 0;
- iBottom = 0;
- iObjectid = 0;
- iIndex = 0;
-
- switch (iMasktype)
- {
- case 1 :
- {
- if (iLen > 16)
- {
- iLeft = mng_get_int32 (pTemp);
- iRight = mng_get_int32 (pTemp+4);
- iTop = mng_get_int32 (pTemp+8);
- iBottom = mng_get_int32 (pTemp+12);
- pTemp += 16;
- iLen -= 16;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 2 :
- {
- if (iLen > 2)
- {
- iObjectid = mng_get_uint16 (pTemp);
- pTemp += 2;
- iLen -= 2;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 3 :
- {
- if (iLen > 3)
- {
- iObjectid = mng_get_uint16 (pTemp);
- iIndex = *(pTemp+2);
- pTemp += 3;
- iLen -= 3;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 4 :
- {
- if (iLen > 18)
- {
- iLeft = mng_get_int32 (pTemp);
- iRight = mng_get_int32 (pTemp+4);
- iTop = mng_get_int32 (pTemp+8);
- iBottom = mng_get_int32 (pTemp+12);
- iObjectid = mng_get_uint16 (pTemp+16);
- pTemp += 18;
- iLen -= 18;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- case 5 :
- {
- if (iLen > 19)
- {
- iLeft = mng_get_int32 (pTemp);
- iRight = mng_get_int32 (pTemp+4);
- iTop = mng_get_int32 (pTemp+8);
- iBottom = mng_get_int32 (pTemp+12);
- iObjectid = mng_get_uint16 (pTemp+16);
- iIndex = *(pTemp+18);
- pTemp += 19;
- iLen -= 19;
- }
- else
- MNG_ERROR (pData, MNG_INVALIDLENGTH);
- break;
- }
- }
-
- pNull = find_null (pTemp); /* get the name length */
-
- if ((pNull - pTemp) > (mng_int32)iLen)
- {
- iNamesize = iLen; /* no null found; so end of evNT */
- iLen = 0;
- }
- else
- {
- iNamesize = pNull - pTemp; /* should be another entry */
- iLen = iLen - iNamesize - 1;
-
- if (!iLen) /* must not end with a null ! */
- MNG_ERROR (pData, MNG_ENDWITHNULL);
- }
-
- if (!iX)
- {
- iCount++;
- }
- else
- {
- pEntry->iEventtype = iEventtype;
- pEntry->iMasktype = iMasktype;
- pEntry->iLeft = iLeft;
- pEntry->iRight = iRight;
- pEntry->iTop = iTop;
- pEntry->iBottom = iBottom;
- pEntry->iObjectid = iObjectid;
- pEntry->iIndex = iIndex;
- pEntry->iSegmentnamesize = iNamesize;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, pEntry->zSegmentname, iNamesize+1);
- MNG_COPY (pEntry->zSegmentname, pTemp, iNamesize);
- }
-
- pEntry++;
- }
-
- pTemp = pTemp + iNamesize + 1;
- }
- }
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_EVNT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-READ_CHUNK (mng_read_unknown)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_UNKNOWN, MNG_LC_START);
-#endif
- /* sequence checks */
-#ifdef MNG_INCLUDE_JNG
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
-#else
- if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
- (!pData->bHasBASI) && (!pData->bHasDHDR) )
-#endif
- MNG_ERROR (pData, MNG_SEQUENCEERROR);
- /* critical chunk ? */
- if ((((mng_uint32)pData->iChunkname & 0x20000000) == 0)
-#ifdef MNG_SKIPCHUNK_SAVE
- && (pData->iChunkname != MNG_UINT_SAVE)
-#endif
-#ifdef MNG_SKIPCHUNK_SEEK
- && (pData->iChunkname != MNG_UINT_SEEK)
-#endif
-#ifdef MNG_SKIPCHUNK_DBYK
- && (pData->iChunkname != MNG_UINT_DBYK)
-#endif
-#ifdef MNG_SKIPCHUNK_ORDR
- && (pData->iChunkname != MNG_UINT_ORDR)
-#endif
- )
- MNG_ERROR (pData, MNG_UNKNOWNCRITICAL);
-
- if (pData->fProcessunknown) /* let the app handle it ? */
- {
- mng_bool bOke = pData->fProcessunknown ((mng_handle)pData, pData->iChunkname,
- iRawlen, (mng_ptr)pRawdata);
-
- if (!bOke)
- MNG_ERROR (pData, MNG_APPMISCERROR);
- }
-
-#ifdef MNG_STORE_CHUNKS
- if (pData->bStorechunks)
- { /* initialize storage */
- mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* store the length */
- ((mng_chunk_headerp)*ppChunk)->iChunkname = pData->iChunkname;
- ((mng_unknown_chunkp)*ppChunk)->iDatasize = iRawlen;
-
- if (iRawlen == 0) /* any data at all ? */
- ((mng_unknown_chunkp)*ppChunk)->pData = 0;
- else
- { /* then store it */
- MNG_ALLOC (pData, ((mng_unknown_chunkp)*ppChunk)->pData, iRawlen);
- MNG_COPY (((mng_unknown_chunkp)*ppChunk)->pData, pRawdata, iRawlen);
- }
- }
-#endif /* MNG_STORE_CHUNKS */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_READ_UNKNOWN, MNG_LC_END);
-#endif
-
- return MNG_NOERROR; /* done */
-}
-#endif
-
-/* ************************************************************************** */
-
-#endif /* MNG_INCLUDE_READ_PROCS */
-
-/* ************************************************************************** */
-/* * * */
-/* * chunk write functions * */
-/* * * */
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_WRITE_PROCS
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_ihdr)
-{
- mng_ihdrp pIHDR;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IHDR, MNG_LC_START);
-#endif
-
- pIHDR = (mng_ihdrp)pChunk; /* address the proper chunk */
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 13;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pIHDR->iWidth);
- mng_put_uint32 (pRawdata+4, pIHDR->iHeight);
-
- *(pRawdata+8) = pIHDR->iBitdepth;
- *(pRawdata+9) = pIHDR->iColortype;
- *(pRawdata+10) = pIHDR->iCompression;
- *(pRawdata+11) = pIHDR->iFilter;
- *(pRawdata+12) = pIHDR->iInterlace;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pIHDR->sHeader.iChunkname, iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IHDR, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_plte)
-{
- mng_pltep pPLTE;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint32 iX;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PLTE, MNG_LC_START);
-#endif
-
- pPLTE = (mng_pltep)pChunk; /* address the proper chunk */
-
- if (pPLTE->bEmpty) /* write empty chunk ? */
- iRetcode = write_raw_chunk (pData, pPLTE->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pPLTE->iEntrycount * 3;
- /* fill the output buffer */
- pTemp = pRawdata;
-
- for (iX = 0; iX < pPLTE->iEntrycount; iX++)
- {
- *pTemp = pPLTE->aEntries [iX].iRed;
- *(pTemp+1) = pPLTE->aEntries [iX].iGreen;
- *(pTemp+2) = pPLTE->aEntries [iX].iBlue;
-
- pTemp += 3;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pPLTE->sHeader.iChunkname, iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PLTE, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_idat)
-{
- mng_idatp pIDAT;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IDAT, MNG_LC_START);
-#endif
-
- pIDAT = (mng_idatp)pChunk; /* address the proper chunk */
-
- if (pIDAT->bEmpty) /* and write it */
- iRetcode = write_raw_chunk (pData, pIDAT->sHeader.iChunkname, 0, 0);
- else
- iRetcode = write_raw_chunk (pData, pIDAT->sHeader.iChunkname,
- pIDAT->iDatasize, pIDAT->pData);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IDAT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_iend)
-{
- mng_iendp pIEND;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IEND, MNG_LC_START);
-#endif
-
- pIEND = (mng_iendp)pChunk; /* address the proper chunk */
- /* and write it */
- iRetcode = write_raw_chunk (pData, pIEND->sHeader.iChunkname, 0, 0);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IEND, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_trns)
-{
- mng_trnsp pTRNS;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint32 iX;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TRNS, MNG_LC_START);
-#endif
-
- pTRNS = (mng_trnsp)pChunk; /* address the proper chunk */
-
- if (pTRNS->bEmpty) /* write empty chunk ? */
- iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname, 0, 0);
- else
- if (pTRNS->bGlobal) /* write global chunk ? */
- iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname,
- pTRNS->iRawlen, (mng_uint8p)pTRNS->aRawdata);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer */
- iRawlen = 0; /* and default size */
-
- switch (pTRNS->iType)
- {
- case 0: {
- iRawlen = 2; /* fill the size & output buffer */
- mng_put_uint16 (pRawdata, pTRNS->iGray);
-
- break;
- }
- case 2: {
- iRawlen = 6; /* fill the size & output buffer */
- mng_put_uint16 (pRawdata, pTRNS->iRed);
- mng_put_uint16 (pRawdata+2, pTRNS->iGreen);
- mng_put_uint16 (pRawdata+4, pTRNS->iBlue);
-
- break;
- }
- case 3: { /* init output buffer size */
- iRawlen = pTRNS->iCount;
-
- pTemp = pRawdata; /* fill the output buffer */
-
- for (iX = 0; iX < pTRNS->iCount; iX++)
- {
- *pTemp = pTRNS->aEntries[iX];
- pTemp++;
- }
-
- break;
- }
- }
- /* write the chunk */
- iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TRNS, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_gama)
-{
- mng_gamap pGAMA;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_GAMA, MNG_LC_START);
-#endif
-
- pGAMA = (mng_gamap)pChunk; /* address the proper chunk */
-
- if (pGAMA->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pGAMA->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 4;
- /* fill the buffer */
- mng_put_uint32 (pRawdata, pGAMA->iGamma);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pGAMA->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_GAMA, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_cHRM
-WRITE_CHUNK (mng_write_chrm)
-{
- mng_chrmp pCHRM;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_CHRM, MNG_LC_START);
-#endif
-
- pCHRM = (mng_chrmp)pChunk; /* address the proper chunk */
-
- if (pCHRM->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pCHRM->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 32;
- /* fill the buffer */
- mng_put_uint32 (pRawdata, pCHRM->iWhitepointx);
- mng_put_uint32 (pRawdata+4, pCHRM->iWhitepointy);
- mng_put_uint32 (pRawdata+8, pCHRM->iRedx);
- mng_put_uint32 (pRawdata+12, pCHRM->iRedy);
- mng_put_uint32 (pRawdata+16, pCHRM->iGreenx);
- mng_put_uint32 (pRawdata+20, pCHRM->iGreeny);
- mng_put_uint32 (pRawdata+24, pCHRM->iBluex);
- mng_put_uint32 (pRawdata+28, pCHRM->iBluey);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pCHRM->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_CHRM, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_srgb)
-{
- mng_srgbp pSRGB;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SRGB, MNG_LC_START);
-#endif
-
- pSRGB = (mng_srgbp)pChunk; /* address the proper chunk */
-
- if (pSRGB->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pSRGB->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 1;
- /* fill the buffer */
- *pRawdata = pSRGB->iRenderingintent;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pSRGB->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SRGB, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_iCCP
-WRITE_CHUNK (mng_write_iccp)
-{
- mng_iccpp pICCP;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint8p pBuf = 0;
- mng_uint32 iBuflen;
- mng_uint32 iReallen;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ICCP, MNG_LC_START);
-#endif
-
- pICCP = (mng_iccpp)pChunk; /* address the proper chunk */
-
- if (pICCP->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pICCP->sHeader.iChunkname, 0, 0);
- else
- { /* compress the profile */
- iRetcode = deflate_buffer (pData, pICCP->pProfile, pICCP->iProfilesize,
- &pBuf, &iBuflen, &iReallen);
-
- if (!iRetcode) /* still oke ? */
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pICCP->iNamesize + 2 + iReallen;
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
-
- pTemp = pRawdata; /* fill the buffer */
-
- if (pICCP->iNamesize)
- {
- MNG_COPY (pTemp, pICCP->zName, pICCP->iNamesize);
- pTemp += pICCP->iNamesize;
- }
-
- *pTemp = 0;
- *(pTemp+1) = pICCP->iCompression;
- pTemp += 2;
-
- if (iReallen)
- MNG_COPY (pTemp, pBuf, iReallen);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pICCP->sHeader.iChunkname,
- iRawlen, pRawdata);
- /* drop the temp buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_FREEX (pData, pRawdata, iRawlen);
-
- }
-
- MNG_FREEX (pData, pBuf, iBuflen); /* always drop the extra buffer */
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ICCP, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_tEXt
-WRITE_CHUNK (mng_write_text)
-{
- mng_textp pTEXT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TEXT, MNG_LC_START);
-#endif
-
- pTEXT = (mng_textp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pTEXT->iKeywordsize + 1 + pTEXT->iTextsize;
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
-
- pTemp = pRawdata; /* fill the buffer */
-
- if (pTEXT->iKeywordsize)
- {
- MNG_COPY (pTemp, pTEXT->zKeyword, pTEXT->iKeywordsize);
- pTemp += pTEXT->iKeywordsize;
- }
-
- *pTemp = 0;
- pTemp += 1;
-
- if (pTEXT->iTextsize)
- MNG_COPY (pTemp, pTEXT->zText, pTEXT->iTextsize);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pTEXT->sHeader.iChunkname,
- iRawlen, pRawdata);
-
- if (iRawlen > pData->iWritebufsize) /* drop the temp buffer ? */
- MNG_FREEX (pData, pRawdata, iRawlen);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TEXT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_zTXt
-WRITE_CHUNK (mng_write_ztxt)
-{
- mng_ztxtp pZTXT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint8p pBuf = 0;
- mng_uint32 iBuflen;
- mng_uint32 iReallen;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ZTXT, MNG_LC_START);
-#endif
-
- pZTXT = (mng_ztxtp)pChunk; /* address the proper chunk */
- /* compress the text */
- iRetcode = deflate_buffer (pData, (mng_uint8p)pZTXT->zText, pZTXT->iTextsize,
- &pBuf, &iBuflen, &iReallen);
-
- if (!iRetcode) /* all ok ? */
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pZTXT->iKeywordsize + 2 + iReallen;
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
-
- pTemp = pRawdata; /* fill the buffer */
-
- if (pZTXT->iKeywordsize)
- {
- MNG_COPY (pTemp, pZTXT->zKeyword, pZTXT->iKeywordsize);
- pTemp += pZTXT->iKeywordsize;
- }
-
- *pTemp = 0; /* terminator zero */
- pTemp++;
- *pTemp = 0; /* compression type */
- pTemp++;
-
- if (iReallen)
- MNG_COPY (pTemp, pBuf, iReallen);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pZTXT->sHeader.iChunkname,
- iRawlen, pRawdata);
- /* drop the temp buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_FREEX (pData, pRawdata, iRawlen);
-
- }
-
- MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ZTXT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_iTXt
-WRITE_CHUNK (mng_write_itxt)
-{
- mng_itxtp pITXT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint8p pBuf = 0;
- mng_uint32 iBuflen;
- mng_uint32 iReallen;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ITXT, MNG_LC_START);
-#endif
-
- pITXT = (mng_itxtp)pChunk; /* address the proper chunk */
-
- if (pITXT->iCompressionflag) /* compress the text */
- iRetcode = deflate_buffer (pData, (mng_uint8p)pITXT->zText, pITXT->iTextsize,
- &pBuf, &iBuflen, &iReallen);
- else
- iRetcode = MNG_NOERROR;
-
- if (!iRetcode) /* all ok ? */
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pITXT->iKeywordsize + pITXT->iLanguagesize +
- pITXT->iTranslationsize + 5;
-
- if (pITXT->iCompressionflag)
- iRawlen = iRawlen + iReallen;
- else
- iRawlen = iRawlen + pITXT->iTextsize;
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
-
- pTemp = pRawdata; /* fill the buffer */
-
- if (pITXT->iKeywordsize)
- {
- MNG_COPY (pTemp, pITXT->zKeyword, pITXT->iKeywordsize);
- pTemp += pITXT->iKeywordsize;
- }
-
- *pTemp = 0;
- pTemp++;
- *pTemp = pITXT->iCompressionflag;
- pTemp++;
- *pTemp = pITXT->iCompressionmethod;
- pTemp++;
-
- if (pITXT->iLanguagesize)
- {
- MNG_COPY (pTemp, pITXT->zLanguage, pITXT->iLanguagesize);
- pTemp += pITXT->iLanguagesize;
- }
-
- *pTemp = 0;
- pTemp++;
-
- if (pITXT->iTranslationsize)
- {
- MNG_COPY (pTemp, pITXT->zTranslation, pITXT->iTranslationsize);
- pTemp += pITXT->iTranslationsize;
- }
-
- *pTemp = 0;
- pTemp++;
-
- if (pITXT->iCompressionflag)
- {
- if (iReallen)
- MNG_COPY (pTemp, pBuf, iReallen);
- }
- else
- {
- if (pITXT->iTextsize)
- MNG_COPY (pTemp, pITXT->zText, pITXT->iTextsize);
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pITXT->sHeader.iChunkname,
- iRawlen, pRawdata);
- /* drop the temp buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_FREEX (pData, pRawdata, iRawlen);
-
- }
-
- MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ITXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_bKGD
-WRITE_CHUNK (mng_write_bkgd)
-{
- mng_bkgdp pBKGD;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_BKGD, MNG_LC_START);
-#endif
-
- pBKGD = (mng_bkgdp)pChunk; /* address the proper chunk */
-
- if (pBKGD->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pBKGD->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 0; /* and default size */
-
- switch (pBKGD->iType)
- {
- case 0: { /* gray */
- iRawlen = 2; /* fill the size & output buffer */
- mng_put_uint16 (pRawdata, pBKGD->iGray);
-
- break;
- }
- case 2: { /* rgb */
- iRawlen = 6; /* fill the size & output buffer */
- mng_put_uint16 (pRawdata, pBKGD->iRed);
- mng_put_uint16 (pRawdata+2, pBKGD->iGreen);
- mng_put_uint16 (pRawdata+4, pBKGD->iBlue);
-
- break;
- }
- case 3: { /* indexed */
- iRawlen = 1; /* fill the size & output buffer */
- *pRawdata = pBKGD->iIndex;
-
- break;
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pBKGD->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_BKGD, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_pHYs
-WRITE_CHUNK (mng_write_phys)
-{
- mng_physp pPHYS;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PHYS, MNG_LC_START);
-#endif
-
- pPHYS = (mng_physp)pChunk; /* address the proper chunk */
-
- if (pPHYS->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pPHYS->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 9;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pPHYS->iSizex);
- mng_put_uint32 (pRawdata+4, pPHYS->iSizey);
-
- *(pRawdata+8) = pPHYS->iUnit;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pPHYS->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PHYS, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sBIT
-WRITE_CHUNK (mng_write_sbit)
-{
- mng_sbitp pSBIT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SBIT, MNG_LC_START);
-#endif
-
- pSBIT = (mng_sbitp)pChunk; /* address the proper chunk */
-
- if (pSBIT->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pSBIT->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 0; /* and default size */
-
- switch (pSBIT->iType)
- {
- case 0: { /* gray */
- iRawlen = 1; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
-
- break;
- }
- case 2: { /* rgb */
- iRawlen = 3; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *(pRawdata+1) = pSBIT->aBits[1];
- *(pRawdata+2) = pSBIT->aBits[2];
-
- break;
- }
- case 3: { /* indexed */
- iRawlen = 3; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *pRawdata = pSBIT->aBits[1];
- *pRawdata = pSBIT->aBits[2];
-
- break;
- }
- case 4: { /* gray + alpha */
- iRawlen = 2; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *(pRawdata+1) = pSBIT->aBits[1];
-
- break;
- }
- case 6: { /* rgb + alpha */
- iRawlen = 4; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *(pRawdata+1) = pSBIT->aBits[1];
- *(pRawdata+2) = pSBIT->aBits[2];
- *(pRawdata+3) = pSBIT->aBits[3];
-
- break;
- }
- case 10: { /* jpeg gray */
- iRawlen = 1; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
-
- break;
- }
- case 12: { /* jpeg rgb */
- iRawlen = 3; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *(pRawdata+1) = pSBIT->aBits[1];
- *(pRawdata+2) = pSBIT->aBits[2];
-
- break;
- }
- case 14: { /* jpeg gray + alpha */
- iRawlen = 2; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *(pRawdata+1) = pSBIT->aBits[1];
-
- break;
- }
- case 16: { /* jpeg rgb + alpha */
- iRawlen = 4; /* fill the size & output buffer */
- *pRawdata = pSBIT->aBits[0];
- *(pRawdata+1) = pSBIT->aBits[1];
- *(pRawdata+2) = pSBIT->aBits[2];
- *(pRawdata+3) = pSBIT->aBits[3];
-
- break;
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pSBIT->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SBIT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sPLT
-WRITE_CHUNK (mng_write_splt)
-{
- mng_spltp pSPLT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint32 iEntrieslen;
- mng_uint8p pTemp;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SPLT, MNG_LC_START);
-#endif
-
- pSPLT = (mng_spltp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iEntrieslen = ((pSPLT->iSampledepth >> 3) * 4 + 2) * pSPLT->iEntrycount;
- iRawlen = pSPLT->iNamesize + 2 + iEntrieslen;
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
-
- pTemp = pRawdata; /* fill the buffer */
-
- if (pSPLT->iNamesize)
- {
- MNG_COPY (pTemp, pSPLT->zName, pSPLT->iNamesize);
- pTemp += pSPLT->iNamesize;
- }
-
- *pTemp = 0;
- *(pTemp+1) = pSPLT->iSampledepth;
- pTemp += 2;
-
- if (pSPLT->iEntrycount)
- MNG_COPY (pTemp, pSPLT->pEntries, iEntrieslen);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pSPLT->sHeader.iChunkname,
- iRawlen, pRawdata);
-
- if (iRawlen > pData->iWritebufsize) /* drop the temp buffer ? */
- MNG_FREEX (pData, pRawdata, iRawlen);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SPLT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_hIST
-WRITE_CHUNK (mng_write_hist)
-{
- mng_histp pHIST;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint32 iX;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_HIST, MNG_LC_START);
-#endif
-
- pHIST = (mng_histp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pHIST->iEntrycount << 1;
-
- pTemp = pRawdata; /* fill the output buffer */
-
- for (iX = 0; iX < pHIST->iEntrycount; iX++)
- {
- mng_put_uint16 (pTemp, pHIST->aEntries [iX]);
- pTemp += 2;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pHIST->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_HIST, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_tIME
-WRITE_CHUNK (mng_write_time)
-{
- mng_timep pTIME;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TIME, MNG_LC_START);
-#endif
-
- pTIME = (mng_timep)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 7;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pTIME->iYear);
-
- *(pRawdata+2) = pTIME->iMonth;
- *(pRawdata+3) = pTIME->iDay;
- *(pRawdata+4) = pTIME->iHour;
- *(pRawdata+5) = pTIME->iMinute;
- *(pRawdata+6) = pTIME->iSecond;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pTIME->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TIME, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_mhdr)
-{
- mng_mhdrp pMHDR;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MHDR, MNG_LC_START);
-#endif
-
- pMHDR = (mng_mhdrp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 28;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pMHDR->iWidth);
- mng_put_uint32 (pRawdata+4, pMHDR->iHeight);
- mng_put_uint32 (pRawdata+8, pMHDR->iTicks);
- mng_put_uint32 (pRawdata+12, pMHDR->iLayercount);
- mng_put_uint32 (pRawdata+16, pMHDR->iFramecount);
- mng_put_uint32 (pRawdata+20, pMHDR->iPlaytime);
- mng_put_uint32 (pRawdata+24, pMHDR->iSimplicity);
-
- /* and write it */
- iRetcode = write_raw_chunk (pData, pMHDR->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MHDR, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_mend)
-{
- mng_mendp pMEND;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MEND, MNG_LC_START);
-#endif
-
- pMEND = (mng_mendp)pChunk; /* address the proper chunk */
- /* and write it */
- iRetcode = write_raw_chunk (pData, pMEND->sHeader.iChunkname, 0, 0);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MEND, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_loop)
-{
- mng_loopp pLOOP;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
- mng_uint8p pTemp1;
- mng_uint32p pTemp2;
- mng_uint32 iX;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_LOOP, MNG_LC_START);
-#endif
-
- pLOOP = (mng_loopp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 5;
- /* fill the output buffer */
- *pRawdata = pLOOP->iLevel;
- mng_put_uint32 (pRawdata+1, pLOOP->iRepeat);
-
- if (pLOOP->iTermination)
- {
- iRawlen++;
- *(pRawdata+5) = pLOOP->iTermination;
-
- if ((pLOOP->iCount) ||
- (pLOOP->iItermin != 1) || (pLOOP->iItermax != 0x7FFFFFFFL))
- {
- iRawlen += 8;
-
- mng_put_uint32 (pRawdata+6, pLOOP->iItermin);
- mng_put_uint32 (pRawdata+10, pLOOP->iItermax);
-
-#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
- if (pLOOP->iCount)
- {
- iRawlen += pLOOP->iCount * 4;
-
- pTemp1 = pRawdata+14;
- pTemp2 = pLOOP->pSignals;
-
- for (iX = 0; iX < pLOOP->iCount; iX++)
- {
- mng_put_uint32 (pTemp1, *pTemp2);
-
- pTemp1 += 4;
- pTemp2++;
- }
- }
-#endif
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pLOOP->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_LOOP, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_endl)
-{
- mng_endlp pENDL;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ENDL, MNG_LC_START);
-#endif
-
- pENDL = (mng_endlp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 1;
-
- *pRawdata = pENDL->iLevel; /* fill the output buffer */
- /* and write it */
- iRetcode = write_raw_chunk (pData, pENDL->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ENDL, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_defi)
-{
- mng_defip pDEFI;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DEFI, MNG_LC_START);
-#endif
-
- pDEFI = (mng_defip)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 2;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pDEFI->iObjectid);
-
- if ((pDEFI->iDonotshow) || (pDEFI->iConcrete) || (pDEFI->bHasloca) || (pDEFI->bHasclip))
- {
- iRawlen++;
- *(pRawdata+2) = pDEFI->iDonotshow;
-
- if ((pDEFI->iConcrete) || (pDEFI->bHasloca) || (pDEFI->bHasclip))
- {
- iRawlen++;
- *(pRawdata+3) = pDEFI->iConcrete;
-
- if ((pDEFI->bHasloca) || (pDEFI->bHasclip))
- {
- iRawlen += 8;
-
- mng_put_uint32 (pRawdata+4, pDEFI->iXlocation);
- mng_put_uint32 (pRawdata+8, pDEFI->iYlocation);
-
- if (pDEFI->bHasclip)
- {
- iRawlen += 16;
-
- mng_put_uint32 (pRawdata+12, pDEFI->iLeftcb);
- mng_put_uint32 (pRawdata+16, pDEFI->iRightcb);
- mng_put_uint32 (pRawdata+20, pDEFI->iTopcb);
- mng_put_uint32 (pRawdata+24, pDEFI->iBottomcb);
- }
- }
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pDEFI->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DEFI, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_basi)
-{
- mng_basip pBASI;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_bool bOpaque;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_BASI, MNG_LC_START);
-#endif
-
- pBASI = (mng_basip)pChunk; /* address the proper chunk */
-
-#ifndef MNG_NO_16BIT_SUPPORT
- if (pBASI->iBitdepth <= 8) /* determine opacity alpha-field */
-#endif
- bOpaque = (mng_bool)(pBASI->iAlpha == 0xFF);
-#ifndef MNG_NO_16BIT_SUPPORT
- else
- bOpaque = (mng_bool)(pBASI->iAlpha == 0xFFFF);
-#endif
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 13;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pBASI->iWidth);
- mng_put_uint32 (pRawdata+4, pBASI->iHeight);
-
- *(pRawdata+8) = pBASI->iBitdepth;
- *(pRawdata+9) = pBASI->iColortype;
- *(pRawdata+10) = pBASI->iCompression;
- *(pRawdata+11) = pBASI->iFilter;
- *(pRawdata+12) = pBASI->iInterlace;
-
- if ((pBASI->iRed) || (pBASI->iGreen) || (pBASI->iBlue) ||
- (!bOpaque) || (pBASI->iViewable))
- {
- iRawlen += 6;
- mng_put_uint16 (pRawdata+13, pBASI->iRed);
- mng_put_uint16 (pRawdata+15, pBASI->iGreen);
- mng_put_uint16 (pRawdata+17, pBASI->iBlue);
-
- if ((!bOpaque) || (pBASI->iViewable))
- {
- iRawlen += 2;
- mng_put_uint16 (pRawdata+19, pBASI->iAlpha);
-
- if (pBASI->iViewable)
- {
- iRawlen++;
- *(pRawdata+21) = pBASI->iViewable;
- }
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pBASI->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_BASI, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_clon)
-{
- mng_clonp pCLON;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_CLON, MNG_LC_START);
-#endif
-
- pCLON = (mng_clonp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 4;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pCLON->iSourceid);
- mng_put_uint16 (pRawdata+2, pCLON->iCloneid);
-
- if ((pCLON->iClonetype) || (pCLON->iDonotshow) || (pCLON->iConcrete) || (pCLON->bHasloca))
- {
- iRawlen++;
- *(pRawdata+4) = pCLON->iClonetype;
-
- if ((pCLON->iDonotshow) || (pCLON->iConcrete) || (pCLON->bHasloca))
- {
- iRawlen++;
- *(pRawdata+5) = pCLON->iDonotshow;
-
- if ((pCLON->iConcrete) || (pCLON->bHasloca))
- {
- iRawlen++;
- *(pRawdata+6) = pCLON->iConcrete;
-
- if (pCLON->bHasloca)
- {
- iRawlen += 9;
- *(pRawdata+7) = pCLON->iLocationtype;
- mng_put_int32 (pRawdata+8, pCLON->iLocationx);
- mng_put_int32 (pRawdata+12, pCLON->iLocationy);
- }
- }
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pCLON->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_CLON, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_PAST
-WRITE_CHUNK (mng_write_past)
-{
- mng_pastp pPAST;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_past_sourcep pSource;
- mng_uint32 iX;
- mng_uint8p pTemp;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PAST, MNG_LC_START);
-#endif
-
- pPAST = (mng_pastp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 11 + (30 * pPAST->iCount);
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pPAST->iDestid);
-
- *(pRawdata+2) = pPAST->iTargettype;
-
- mng_put_int32 (pRawdata+3, pPAST->iTargetx);
- mng_put_int32 (pRawdata+7, pPAST->iTargety);
-
- pTemp = pRawdata+11;
- pSource = pPAST->pSources;
-
- for (iX = 0; iX < pPAST->iCount; iX++)
- {
- mng_put_uint16 (pTemp, pSource->iSourceid);
-
- *(pTemp+2) = pSource->iComposition;
- *(pTemp+3) = pSource->iOrientation;
- *(pTemp+4) = pSource->iOffsettype;
-
- mng_put_int32 (pTemp+5, pSource->iOffsetx);
- mng_put_int32 (pTemp+9, pSource->iOffsety);
-
- *(pTemp+13) = pSource->iBoundarytype;
-
- mng_put_int32 (pTemp+14, pSource->iBoundaryl);
- mng_put_int32 (pTemp+18, pSource->iBoundaryr);
- mng_put_int32 (pTemp+22, pSource->iBoundaryt);
- mng_put_int32 (pTemp+26, pSource->iBoundaryb);
-
- pSource++;
- pTemp += 30;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pPAST->sHeader.iChunkname,
- iRawlen, pRawdata);
- /* free temporary buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_FREEX (pData, pRawdata, iRawlen);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PAST, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_disc)
-{
- mng_discp pDISC;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint32 iX;
- mng_uint8p pTemp1;
- mng_uint16p pTemp2;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DISC, MNG_LC_START);
-#endif
-
- pDISC = (mng_discp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pDISC->iCount << 1;
-
- pTemp1 = pRawdata; /* fill the output buffer */
- pTemp2 = pDISC->pObjectids;
-
- for (iX = 0; iX < pDISC->iCount; iX++)
- {
- mng_put_uint16 (pTemp1, *pTemp2);
-
- pTemp2++;
- pTemp1 += 2;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pDISC->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DISC, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_back)
-{
- mng_backp pBACK;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_BACK, MNG_LC_START);
-#endif
-
- pBACK = (mng_backp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 6;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pBACK->iRed);
- mng_put_uint16 (pRawdata+2, pBACK->iGreen);
- mng_put_uint16 (pRawdata+4, pBACK->iBlue);
-
- if ((pBACK->iMandatory) || (pBACK->iImageid) || (pBACK->iTile))
- {
- iRawlen++;
- *(pRawdata+6) = pBACK->iMandatory;
-
- if ((pBACK->iImageid) || (pBACK->iTile))
- {
- iRawlen += 2;
- mng_put_uint16 (pRawdata+7, pBACK->iImageid);
-
- if (pBACK->iTile)
- {
- iRawlen++;
- *(pRawdata+9) = pBACK->iTile;
- }
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pBACK->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_BACK, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_fram)
-{
- mng_framp pFRAM;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_uint32p pTemp2;
- mng_uint32 iX;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_FRAM, MNG_LC_START);
-#endif
-
- pFRAM = (mng_framp)pChunk; /* address the proper chunk */
-
- if (pFRAM->bEmpty) /* empty ? */
- iRetcode = write_raw_chunk (pData, pFRAM->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 1;
- /* fill the output buffer */
- *pRawdata = pFRAM->iMode;
-
- if ((pFRAM->iNamesize ) ||
- (pFRAM->iChangedelay ) || (pFRAM->iChangetimeout) ||
- (pFRAM->iChangeclipping) || (pFRAM->iChangesyncid ) )
- {
- if (pFRAM->iNamesize)
- MNG_COPY (pRawdata+1, pFRAM->zName, pFRAM->iNamesize);
-
- iRawlen += pFRAM->iNamesize;
- pTemp = pRawdata + pFRAM->iNamesize + 1;
-
- if ((pFRAM->iChangedelay ) || (pFRAM->iChangetimeout) ||
- (pFRAM->iChangeclipping) || (pFRAM->iChangesyncid ) )
- {
- *pTemp = 0;
- *(pTemp+1) = pFRAM->iChangedelay;
- *(pTemp+2) = pFRAM->iChangetimeout;
- *(pTemp+3) = pFRAM->iChangeclipping;
- *(pTemp+4) = pFRAM->iChangesyncid;
-
- iRawlen += 5;
- pTemp += 5;
-
- if (pFRAM->iChangedelay)
- {
- mng_put_uint32 (pTemp, pFRAM->iDelay);
- iRawlen += 4;
- pTemp += 4;
- }
-
- if (pFRAM->iChangetimeout)
- {
- mng_put_uint32 (pTemp, pFRAM->iTimeout);
- iRawlen += 4;
- pTemp += 4;
- }
-
- if (pFRAM->iChangeclipping)
- {
- *pTemp = pFRAM->iBoundarytype;
-
- mng_put_uint32 (pTemp+1, pFRAM->iBoundaryl);
- mng_put_uint32 (pTemp+5, pFRAM->iBoundaryr);
- mng_put_uint32 (pTemp+9, pFRAM->iBoundaryt);
- mng_put_uint32 (pTemp+13, pFRAM->iBoundaryb);
-
- iRawlen += 17;
- pTemp += 17;
- }
-
- if (pFRAM->iChangesyncid)
- {
- iRawlen += pFRAM->iCount * 4;
- pTemp2 = pFRAM->pSyncids;
-
- for (iX = 0; iX < pFRAM->iCount; iX++)
- {
- mng_put_uint32 (pTemp, *pTemp2);
-
- pTemp2++;
- pTemp += 4;
- }
- }
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pFRAM->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_FRAM, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_move)
-{
- mng_movep pMOVE;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MOVE, MNG_LC_START);
-#endif
-
- pMOVE = (mng_movep)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 13;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pMOVE->iFirstid);
- mng_put_uint16 (pRawdata+2, pMOVE->iLastid);
-
- *(pRawdata+4) = pMOVE->iMovetype;
-
- mng_put_int32 (pRawdata+5, pMOVE->iMovex);
- mng_put_int32 (pRawdata+9, pMOVE->iMovey);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pMOVE->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MOVE, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_clip)
-{
- mng_clipp pCLIP;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_CLIP, MNG_LC_START);
-#endif
-
- pCLIP = (mng_clipp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 21;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pCLIP->iFirstid);
- mng_put_uint16 (pRawdata+2, pCLIP->iLastid);
-
- *(pRawdata+4) = pCLIP->iCliptype;
-
- mng_put_int32 (pRawdata+5, pCLIP->iClipl);
- mng_put_int32 (pRawdata+9, pCLIP->iClipr);
- mng_put_int32 (pRawdata+13, pCLIP->iClipt);
- mng_put_int32 (pRawdata+17, pCLIP->iClipb);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pCLIP->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_CLIP, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_show)
-{
- mng_showp pSHOW;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SHOW, MNG_LC_START);
-#endif
-
- pSHOW = (mng_showp)pChunk; /* address the proper chunk */
-
- if (pSHOW->bEmpty) /* empty ? */
- iRetcode = write_raw_chunk (pData, pSHOW->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 2;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pSHOW->iFirstid);
-
- if ((pSHOW->iLastid != pSHOW->iFirstid) || (pSHOW->iMode))
- {
- iRawlen += 2;
- mng_put_uint16 (pRawdata+2, pSHOW->iLastid);
-
- if (pSHOW->iMode)
- {
- iRawlen++;
- *(pRawdata+4) = pSHOW->iMode;
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pSHOW->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SHOW, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_term)
-{
- mng_termp pTERM;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TERM, MNG_LC_START);
-#endif
-
- pTERM = (mng_termp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 1;
-
- *pRawdata = pTERM->iTermaction; /* fill the output buffer */
-
- if (pTERM->iTermaction == 3)
- {
- iRawlen = 10;
- *(pRawdata+1) = pTERM->iIteraction;
-
- mng_put_uint32 (pRawdata+2, pTERM->iDelay);
- mng_put_uint32 (pRawdata+6, pTERM->iItermax);
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pTERM->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_TERM, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SAVE
-WRITE_CHUNK (mng_write_save)
-{
- mng_savep pSAVE;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_save_entryp pEntry;
- mng_uint32 iEntrysize;
- mng_uint8p pTemp;
- mng_uint32 iX;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SAVE, MNG_LC_START);
-#endif
-
- pSAVE = (mng_savep)pChunk; /* address the proper chunk */
-
- if (pSAVE->bEmpty) /* empty ? */
- iRetcode = write_raw_chunk (pData, pSAVE->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 1;
-
- *pRawdata = pSAVE->iOffsettype; /* fill the output buffer */
-
- if (pSAVE->iOffsettype == 16)
- iEntrysize = 25;
- else
- iEntrysize = 17;
-
- pTemp = pRawdata+1;
- pEntry = pSAVE->pEntries;
-
- for (iX = 0; iX < pSAVE->iCount; iX++)
- {
- if (iX) /* put separator null-byte, except the first */
- {
- *pTemp = 0;
- pTemp++;
- iRawlen++;
- }
-
- iRawlen += iEntrysize + pEntry->iNamesize;
- *pTemp = pEntry->iEntrytype;
-
- if (pSAVE->iOffsettype == 16)
- {
- mng_put_uint32 (pTemp+1, pEntry->iOffset[0]);
- mng_put_uint32 (pTemp+5, pEntry->iOffset[1]);
- mng_put_uint32 (pTemp+9, pEntry->iStarttime[0]);
- mng_put_uint32 (pTemp+13, pEntry->iStarttime[1]);
- mng_put_uint32 (pTemp+17, pEntry->iLayernr);
- mng_put_uint32 (pTemp+21, pEntry->iFramenr);
-
- pTemp += 25;
- }
- else
- {
- mng_put_uint32 (pTemp+1, pEntry->iOffset[1]);
- mng_put_uint32 (pTemp+5, pEntry->iStarttime[1]);
- mng_put_uint32 (pTemp+9, pEntry->iLayernr);
- mng_put_uint32 (pTemp+13, pEntry->iFramenr);
-
- pTemp += 17;
- }
-
- if (pEntry->iNamesize)
- {
- MNG_COPY (pTemp, pEntry->zName, pEntry->iNamesize);
- pTemp += pEntry->iNamesize;
- }
-
- pEntry++;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pSAVE->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SAVE, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SEEK
-WRITE_CHUNK (mng_write_seek)
-{
- mng_seekp pSEEK;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SEEK, MNG_LC_START);
-#endif
-
- pSEEK = (mng_seekp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pSEEK->iNamesize;
-
- if (iRawlen) /* fill the output buffer */
- MNG_COPY (pRawdata, pSEEK->zName, iRawlen);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pSEEK->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_SEEK, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_eXPI
-WRITE_CHUNK (mng_write_expi)
-{
- mng_expip pEXPI;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_EXPI, MNG_LC_START);
-#endif
-
- pEXPI = (mng_expip)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 2 + pEXPI->iNamesize;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pEXPI->iSnapshotid);
-
- if (pEXPI->iNamesize)
- MNG_COPY (pRawdata+2, pEXPI->zName, pEXPI->iNamesize);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pEXPI->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_EXPI, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_fPRI
-WRITE_CHUNK (mng_write_fpri)
-{
- mng_fprip pFPRI;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_FPRI, MNG_LC_START);
-#endif
-
- pFPRI = (mng_fprip)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 2;
-
- *pRawdata = pFPRI->iDeltatype; /* fill the output buffer */
- *(pRawdata+1) = pFPRI->iPriority;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pFPRI->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_FPRI, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_nEED
-WRITE_CHUNK (mng_write_need)
-{
- mng_needp pNEED;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_NEED, MNG_LC_START);
-#endif
-
- pNEED = (mng_needp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pNEED->iKeywordssize;
- /* fill the output buffer */
- if (pNEED->iKeywordssize)
- MNG_COPY (pRawdata, pNEED->zKeywords, pNEED->iKeywordssize);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pNEED->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_NEED, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_pHYg
-WRITE_CHUNK (mng_write_phyg)
-{
- mng_phygp pPHYG;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PHYG, MNG_LC_START);
-#endif
-
- pPHYG = (mng_phygp)pChunk; /* address the proper chunk */
-
- if (pPHYG->bEmpty) /* write empty ? */
- iRetcode = write_raw_chunk (pData, pPHYG->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 9;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pPHYG->iSizex);
- mng_put_uint32 (pRawdata+4, pPHYG->iSizey);
-
- *(pRawdata+8) = pPHYG->iUnit;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pPHYG->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PHYG, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-/* B004 */
-#ifdef MNG_INCLUDE_JNG
-/* B004 */
-WRITE_CHUNK (mng_write_jhdr)
-{
- mng_jhdrp pJHDR;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JHDR, MNG_LC_START);
-#endif
-
- pJHDR = (mng_jhdrp)pChunk; /* address the proper chunk */
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 16;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pJHDR->iWidth);
- mng_put_uint32 (pRawdata+4, pJHDR->iHeight);
-
- *(pRawdata+8) = pJHDR->iColortype;
- *(pRawdata+9) = pJHDR->iImagesampledepth;
- *(pRawdata+10) = pJHDR->iImagecompression;
- *(pRawdata+11) = pJHDR->iImageinterlace;
- *(pRawdata+12) = pJHDR->iAlphasampledepth;
- *(pRawdata+13) = pJHDR->iAlphacompression;
- *(pRawdata+14) = pJHDR->iAlphafilter;
- *(pRawdata+15) = pJHDR->iAlphainterlace;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pJHDR->sHeader.iChunkname, iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JHDR, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#else
-#define write_jhdr 0
-/* B004 */
-#endif /* MNG_INCLUDE_JNG */
-/* B004 */
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-WRITE_CHUNK (mng_write_jdaa)
-{
- mng_jdatp pJDAA;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JDAA, MNG_LC_START);
-#endif
-
- pJDAA = (mng_jdaap)pChunk; /* address the proper chunk */
-
- if (pJDAA->bEmpty) /* and write it */
- iRetcode = write_raw_chunk (pData, pJDAA->sHeader.iChunkname, 0, 0);
- else
- iRetcode = write_raw_chunk (pData, pJDAA->sHeader.iChunkname,
- pJDAA->iDatasize, pJDAA->pData);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JDAA, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#else
-#define write_jdaa 0
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-/* B004 */
-#ifdef MNG_INCLUDE_JNG
-/* B004 */
-WRITE_CHUNK (mng_write_jdat)
-{
- mng_jdatp pJDAT;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JDAT, MNG_LC_START);
-#endif
-
- pJDAT = (mng_jdatp)pChunk; /* address the proper chunk */
-
- if (pJDAT->bEmpty) /* and write it */
- iRetcode = write_raw_chunk (pData, pJDAT->sHeader.iChunkname, 0, 0);
- else
- iRetcode = write_raw_chunk (pData, pJDAT->sHeader.iChunkname,
- pJDAT->iDatasize, pJDAT->pData);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JDAT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#else
-#define write_jdat 0
-/* B004 */
-#endif /* MNG_INCLUDE_JNG */
-/* B004 */
-
-/* ************************************************************************** */
-
-/* B004 */
-#ifdef MNG_INCLUDE_JNG
-/* B004 */
-WRITE_CHUNK (mng_write_jsep)
-{
- mng_jsepp pJSEP;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JSEP, MNG_LC_START);
-#endif
-
- pJSEP = (mng_jsepp)pChunk; /* address the proper chunk */
- /* and write it */
- iRetcode = write_raw_chunk (pData, pJSEP->sHeader.iChunkname, 0, 0);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_JSEP, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#else
-#define write_jsep 0
-/* B004 */
-#endif /* MNG_INCLUDE_JNG */
-/* B004 */
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-WRITE_CHUNK (mng_write_dhdr)
-{
- mng_dhdrp pDHDR;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DHDR, MNG_LC_START);
-#endif
-
- pDHDR = (mng_dhdrp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 4;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pDHDR->iObjectid);
-
- *(pRawdata+2) = pDHDR->iImagetype;
- *(pRawdata+3) = pDHDR->iDeltatype;
-
- if (pDHDR->iDeltatype != 7)
- {
- iRawlen += 8;
- mng_put_uint32 (pRawdata+4, pDHDR->iBlockwidth);
- mng_put_uint32 (pRawdata+8, pDHDR->iBlockheight);
-
- if (pDHDR->iDeltatype != 0)
- {
- iRawlen += 8;
- mng_put_uint32 (pRawdata+12, pDHDR->iBlockx);
- mng_put_uint32 (pRawdata+16, pDHDR->iBlocky);
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pDHDR->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DHDR, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-WRITE_CHUNK (mng_write_prom)
-{
- mng_promp pPROM;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PROM, MNG_LC_START);
-#endif
-
- pPROM = (mng_promp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 3;
-
- *pRawdata = pPROM->iColortype; /* fill the output buffer */
- *(pRawdata+1) = pPROM->iSampledepth;
- *(pRawdata+2) = pPROM->iFilltype;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pPROM->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PROM, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-WRITE_CHUNK (mng_write_ipng)
-{
- mng_ipngp pIPNG;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IPNG, MNG_LC_START);
-#endif
-
- pIPNG = (mng_ipngp)pChunk; /* address the proper chunk */
- /* and write it */
- iRetcode = write_raw_chunk (pData, pIPNG->sHeader.iChunkname, 0, 0);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IPNG, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-WRITE_CHUNK (mng_write_pplt)
-{
- mng_ppltp pPPLT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_pplt_entryp pEntry;
- mng_uint8p pTemp;
- mng_uint32 iX;
- mng_bool bHasgroup;
- mng_uint8p pLastid = 0;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PPLT, MNG_LC_START);
-#endif
-
- pPPLT = (mng_ppltp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 1;
-
- *pRawdata = pPPLT->iDeltatype; /* fill the output buffer */
-
- pTemp = pRawdata+1;
- bHasgroup = MNG_FALSE;
-
- for (iX = 0; iX < pPPLT->iCount; iX++)
- {
- pEntry = &pPPLT->aEntries[iX];
-
- if (pEntry->bUsed) /* valid entry ? */
- {
- if (!bHasgroup) /* start a new group ? */
- {
- bHasgroup = MNG_TRUE;
- pLastid = pTemp+1;
-
- *pTemp = (mng_uint8)iX;
- *(pTemp+1) = 0;
-
- pTemp += 2;
- iRawlen += 2;
- }
-
- switch (pPPLT->iDeltatype) /* add group-entry depending on type */
- {
- case 0: ;
- case 1: {
- *pTemp = pEntry->iRed;
- *(pTemp+1) = pEntry->iGreen;
- *(pTemp+2) = pEntry->iBlue;
-
- pTemp += 3;
- iRawlen += 3;
-
- break;
- }
-
- case 2: ;
- case 3: {
- *pTemp = pEntry->iAlpha;
-
- pTemp++;
- iRawlen++;
-
- break;
- }
-
- case 4: ;
- case 5: {
- *pTemp = pEntry->iRed;
- *(pTemp+1) = pEntry->iGreen;
- *(pTemp+2) = pEntry->iBlue;
- *(pTemp+3) = pEntry->iAlpha;
-
- pTemp += 4;
- iRawlen += 4;
-
- break;
- }
-
- }
- }
- else
- {
- if (bHasgroup) /* finish off a group ? */
- *pLastid = (mng_uint8)(iX-1);
-
- bHasgroup = MNG_FALSE;
- }
- }
-
- if (bHasgroup) /* last group unfinished ? */
- *pLastid = (mng_uint8)(pPPLT->iCount-1);
- /* write the output buffer */
- iRetcode = write_raw_chunk (pData, pPPLT->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_PPLT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifdef MNG_INCLUDE_JNG
-WRITE_CHUNK (mng_write_ijng)
-{
- mng_ijngp pIJNG;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IJNG, MNG_LC_START);
-#endif
-
- pIJNG = (mng_ijngp)pChunk; /* address the proper chunk */
- /* and write it */
- iRetcode = write_raw_chunk (pData, pIJNG->sHeader.iChunkname, 0, 0);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_IJNG, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-WRITE_CHUNK (mng_write_drop)
-{
- mng_dropp pDROP;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint32 iX;
- mng_uint8p pTemp1;
- mng_chunkidp pTemp2;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DROP, MNG_LC_START);
-#endif
-
- pDROP = (mng_dropp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pDROP->iCount << 2;
-
- pTemp1 = pRawdata; /* fill the output buffer */
- pTemp2 = pDROP->pChunknames;
-
- for (iX = 0; iX < pDROP->iCount; iX++)
- {
- mng_put_uint32 (pTemp1, (mng_uint32)*pTemp2);
-
- pTemp2++;
- pTemp1 += 4;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pDROP->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DROP, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_DBYK
-WRITE_CHUNK (mng_write_dbyk)
-{
- mng_dbykp pDBYK;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DBYK, MNG_LC_START);
-#endif
-
- pDBYK = (mng_dbykp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 5 + pDBYK->iKeywordssize;
- /* fill the output buffer */
- mng_put_uint32 (pRawdata, pDBYK->iChunkname);
- *(pRawdata+4) = pDBYK->iPolarity;
-
- if (pDBYK->iKeywordssize)
- MNG_COPY (pRawdata+5, pDBYK->zKeywords, pDBYK->iKeywordssize);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pDBYK->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_DBYK, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_ORDR
-WRITE_CHUNK (mng_write_ordr)
-{
- mng_ordrp pORDR;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pTemp;
- mng_ordr_entryp pEntry;
- mng_uint32 iX;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ORDR, MNG_LC_START);
-#endif
-
- pORDR = (mng_ordrp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = pORDR->iCount * 5;
-
- pTemp = pRawdata; /* fill the output buffer */
- pEntry = pORDR->pEntries;
-
- for (iX = 0; iX < pORDR->iCount; iX++)
- {
- mng_put_uint32 (pTemp, pEntry->iChunkname);
- *(pTemp+4) = pEntry->iOrdertype;
- pTemp += 5;
- pEntry++;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pORDR->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_ORDR, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_magn)
-{
- mng_magnp pMAGN;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MAGN, MNG_LC_START);
-#endif
-
- pMAGN = (mng_magnp)pChunk; /* address the proper chunk */
-
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 18;
- /* fill the output buffer */
- mng_put_uint16 (pRawdata, pMAGN->iFirstid);
- mng_put_uint16 (pRawdata+2, pMAGN->iLastid);
- *(pRawdata+4) = pMAGN->iMethodX;
- mng_put_uint16 (pRawdata+5, pMAGN->iMX);
- mng_put_uint16 (pRawdata+7, pMAGN->iMY);
- mng_put_uint16 (pRawdata+9, pMAGN->iML);
- mng_put_uint16 (pRawdata+11, pMAGN->iMR);
- mng_put_uint16 (pRawdata+13, pMAGN->iMT);
- mng_put_uint16 (pRawdata+15, pMAGN->iMB);
- *(pRawdata+17) = pMAGN->iMethodY;
- /* optimize length */
- if (pMAGN->iMethodY == pMAGN->iMethodX)
- {
- iRawlen--;
-
- if (pMAGN->iMB == pMAGN->iMY)
- {
- iRawlen -= 2;
-
- if (pMAGN->iMT == pMAGN->iMY)
- {
- iRawlen -= 2;
-
- if (pMAGN->iMR == pMAGN->iMX)
- {
- iRawlen -= 2;
-
- if (pMAGN->iML == pMAGN->iMX)
- {
- iRawlen -= 2;
-
- if (pMAGN->iMY == pMAGN->iMX)
- {
- iRawlen -= 2;
-
- if (pMAGN->iMX == 1)
- {
- iRawlen -= 2;
-
- if (pMAGN->iMethodX == 0)
- {
- iRawlen--;
-
- if (pMAGN->iLastid == pMAGN->iFirstid)
- {
- iRawlen -= 2;
-
- if (pMAGN->iFirstid == 0)
- iRawlen = 0;
-
- }
- }
- }
- }
- }
- }
- }
- }
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pMAGN->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MAGN, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
-WRITE_CHUNK (mng_write_mpng)
-{
- mng_mpngp pMPNG;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_uint8p pBuf = 0;
- mng_uint32 iBuflen;
- mng_uint32 iReallen;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MPNG, MNG_LC_START);
-#endif
-
- pMPNG = (mng_mpngp)pChunk; /* address the proper chunk */
- /* compress the frame structures */
- iRetcode = deflate_buffer (pData, (mng_uint8p)pMPNG->pFrames, pMPNG->iFramessize,
- &pBuf, &iBuflen, &iReallen);
-
- if (!iRetcode) /* all ok ? */
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 15 + iReallen;
- /* requires large buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_ALLOC (pData, pRawdata, iRawlen);
- /* fill the buffer */
- mng_put_uint32 (pRawdata, pMPNG->iFramewidth);
- mng_put_uint32 (pRawdata+4, pMPNG->iFrameheight);
- mng_put_uint16 (pRawdata+8, pMPNG->iNumplays);
- mng_put_uint16 (pRawdata+10, pMPNG->iTickspersec);
- *(pRawdata+12) = pMPNG->iCompressionmethod;
-
- if (iReallen)
- MNG_COPY (pRawdata+13, pBuf, iReallen);
- /* and write it */
- iRetcode = write_raw_chunk (pData, pMPNG->sHeader.iChunkname,
- iRawlen, pRawdata);
- /* drop the temp buffer ? */
- if (iRawlen > pData->iWritebufsize)
- MNG_FREEX (pData, pRawdata, iRawlen);
- }
-
- MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_MPNG, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_ANG_PROPOSAL
-WRITE_CHUNK (mng_write_ahdr)
-{
- mng_ahdrp pAHDR;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_AHDR, MNG_LC_START);
-#endif
-
- pAHDR = (mng_ahdrp)pChunk; /* address the proper chunk */
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 22;
- /* fill the buffer */
- mng_put_uint32 (pRawdata, pAHDR->iNumframes);
- mng_put_uint32 (pRawdata+4, pAHDR->iTickspersec);
- mng_put_uint32 (pRawdata+8, pAHDR->iNumplays);
- mng_put_uint32 (pRawdata+12, pAHDR->iTilewidth);
- mng_put_uint32 (pRawdata+16, pAHDR->iTileheight);
- *(pRawdata+20) = pAHDR->iInterlace;
- *(pRawdata+21) = pAHDR->iStillused;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pAHDR->sHeader.iChunkname,
- iRawlen, pRawdata);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_AHDR, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_ANG_PROPOSAL
-WRITE_CHUNK (mng_write_adat)
-{
-
- /* TODO: something */
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_evNT
-WRITE_CHUNK (mng_write_evnt)
-{
- mng_evntp pEVNT;
- mng_uint8p pRawdata;
- mng_uint32 iRawlen;
- mng_retcode iRetcode;
- mng_evnt_entryp pEntry;
- mng_uint8p pTemp;
- mng_uint32 iX;
- mng_uint32 iNamesize;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_EVNT, MNG_LC_START);
-#endif
-
- pEVNT = (mng_evntp)pChunk; /* address the proper chunk */
-
- if (!pEVNT->iCount) /* empty ? */
- iRetcode = write_raw_chunk (pData, pEVNT->sHeader.iChunkname, 0, 0);
- else
- {
- pRawdata = pData->pWritebuf+8; /* init output buffer & size */
- iRawlen = 0;
- pTemp = pRawdata;
- pEntry = pEVNT->pEntries;
-
- for (iX = 0; iX < pEVNT->iCount; iX++)
- {
- if (iX) /* put separator null-byte, except the first */
- {
- *pTemp = 0;
- pTemp++;
- iRawlen++;
- }
-
- *pTemp = pEntry->iEventtype;
- *(pTemp+1) = pEntry->iMasktype;
- pTemp += 2;
- iRawlen += 2;
-
- switch (pEntry->iMasktype)
- {
- case 1 :
- {
- mng_put_int32 (pTemp, pEntry->iLeft);
- mng_put_int32 (pTemp+4, pEntry->iRight);
- mng_put_int32 (pTemp+8, pEntry->iTop);
- mng_put_int32 (pTemp+12, pEntry->iBottom);
- pTemp += 16;
- iRawlen += 16;
- break;
- }
- case 2 :
- {
- mng_put_uint16 (pTemp, pEntry->iObjectid);
- pTemp += 2;
- iRawlen += 2;
- break;
- }
- case 3 :
- {
- mng_put_uint16 (pTemp, pEntry->iObjectid);
- *(pTemp+2) = pEntry->iIndex;
- pTemp += 3;
- iRawlen += 3;
- break;
- }
- case 4 :
- {
- mng_put_int32 (pTemp, pEntry->iLeft);
- mng_put_int32 (pTemp+4, pEntry->iRight);
- mng_put_int32 (pTemp+8, pEntry->iTop);
- mng_put_int32 (pTemp+12, pEntry->iBottom);
- mng_put_uint16 (pTemp+16, pEntry->iObjectid);
- pTemp += 18;
- iRawlen += 18;
- break;
- }
- case 5 :
- {
- mng_put_int32 (pTemp, pEntry->iLeft);
- mng_put_int32 (pTemp+4, pEntry->iRight);
- mng_put_int32 (pTemp+8, pEntry->iTop);
- mng_put_int32 (pTemp+12, pEntry->iBottom);
- mng_put_uint16 (pTemp+16, pEntry->iObjectid);
- *(pTemp+18) = pEntry->iIndex;
- pTemp += 19;
- iRawlen += 19;
- break;
- }
- }
-
- iNamesize = pEntry->iSegmentnamesize;
-
- if (iNamesize)
- {
- MNG_COPY (pTemp, pEntry->zSegmentname, iNamesize);
- pTemp += iNamesize;
- iRawlen += iNamesize;
- }
-
- pEntry++;
- }
- /* and write it */
- iRetcode = write_raw_chunk (pData, pEVNT->sHeader.iChunkname,
- iRawlen, pRawdata);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_EVNT, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-#endif
-
-/* ************************************************************************** */
-
-WRITE_CHUNK (mng_write_unknown)
-{
- mng_unknown_chunkp pUnknown;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_UNKNOWN, MNG_LC_START);
-#endif
- /* address the proper chunk */
- pUnknown = (mng_unknown_chunkp)pChunk;
- /* and write it */
- iRetcode = write_raw_chunk (pData, pUnknown->sHeader.iChunkname,
- pUnknown->iDatasize, pUnknown->pData);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (pData, MNG_FN_WRITE_UNKNOWN, MNG_LC_END);
-#endif
-
- return iRetcode;
-}
-
-/* ************************************************************************** */
-
-#endif /* MNG_INCLUDE_WRITE_PROCS */
-
-/* ************************************************************************** */
-/* * end of file * */
-/* ************************************************************************** */
-
|