summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/libmng/libmng_object_prc.c
diff options
context:
space:
mode:
authorLars Knoll <lars.knoll@nokia.com>2009-03-23 09:34:13 (GMT)
committerSimon Hausmann <simon.hausmann@nokia.com>2009-03-23 09:34:13 (GMT)
commit67ad0519fd165acee4a4d2a94fa502e9e4847bd0 (patch)
tree1dbf50b3dff8d5ca7e9344733968c72704eb15ff /src/3rdparty/libmng/libmng_object_prc.c
downloadQt-67ad0519fd165acee4a4d2a94fa502e9e4847bd0.zip
Qt-67ad0519fd165acee4a4d2a94fa502e9e4847bd0.tar.gz
Qt-67ad0519fd165acee4a4d2a94fa502e9e4847bd0.tar.bz2
Long live Qt!
Diffstat (limited to 'src/3rdparty/libmng/libmng_object_prc.c')
-rw-r--r--src/3rdparty/libmng/libmng_object_prc.c6998
1 files changed, 6998 insertions, 0 deletions
diff --git a/src/3rdparty/libmng/libmng_object_prc.c b/src/3rdparty/libmng/libmng_object_prc.c
new file mode 100644
index 0000000..f6691ff
--- /dev/null
+++ b/src/3rdparty/libmng/libmng_object_prc.c
@@ -0,0 +1,6998 @@
+/* ************************************************************************** */
+/* * For conditions of distribution and use, * */
+/* * see copyright notice in libmng.h * */
+/* ************************************************************************** */
+/* * * */
+/* * project : libmng * */
+/* * file : libmng_object_prc.c copyright (c) 2000-2007 G.Juyn * */
+/* * version : 1.0.10 * */
+/* * * */
+/* * purpose : Object processing routines (implementation) * */
+/* * * */
+/* * author : G.Juyn * */
+/* * * */
+/* * comment : implementation of the internal object processing routines * */
+/* * * */
+/* * changes : 0.5.1 - 05/08/2000 - G.Juyn * */
+/* * - changed strict-ANSI stuff * */
+/* * 0.5.1 - 05/12/2000 - G.Juyn * */
+/* * - changed trace to macro for callback error-reporting * */
+/* * * */
+/* * 0.5.2 - 05/20/2000 - G.Juyn * */
+/* * - fixed to support JNG objects * */
+/* * 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 SAVE & SEEK animation objects * */
+/* * 0.5.2 - 05/29/2000 - G.Juyn * */
+/* * - added initialization of framenr/layernr/playtime * */
+/* * - changed ani_object create routines not to return the * */
+/* * created object (wasn't necessary) * */
+/* * 0.5.2 - 05/30/2000 - G.Juyn * */
+/* * - added object promotion routine (PROM handling) * */
+/* * - added ani-object routines for delta-image processing * */
+/* * - added compression/filter/interlace fields to * */
+/* * object-buffer for delta-image processing * */
+/* * * */
+/* * 0.5.3 - 06/17/2000 - G.Juyn * */
+/* * - changed support for delta-image processing * */
+/* * 0.5.3 - 06/20/2000 - G.Juyn * */
+/* * - fixed some small things (as precaution) * */
+/* * 0.5.3 - 06/21/2000 - G.Juyn * */
+/* * - added processing of PLTE/tRNS & color-info for * */
+/* * delta-images in the ani_objects chain * */
+/* * 0.5.3 - 06/22/2000 - G.Juyn * */
+/* * - added support for PPLT chunk * */
+/* * * */
+/* * 0.9.1 - 07/07/2000 - G.Juyn * */
+/* * - added support for freeze/restart/resume & go_xxxx * */
+/* * 0.9.1 - 07/16/2000 - G.Juyn * */
+/* * - fixed support for mng_display() after mng_read() * */
+/* * * */
+/* * 0.9.2 - 07/29/2000 - G.Juyn * */
+/* * - fixed small bugs in display processing * */
+/* * 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/26/2000 - G.Juyn * */
+/* * - added MAGN chunk * */
+/* * 0.9.3 - 09/10/2000 - G.Juyn * */
+/* * - fixed DEFI behavior * */
+/* * 0.9.3 - 10/17/2000 - G.Juyn * */
+/* * - added valid-flag to stored objects for read() / display()* */
+/* * - added routine to discard "invalid" objects * */
+/* * 0.9.3 - 10/18/2000 - G.Juyn * */
+/* * - fixed delta-processing behavior * */
+/* * 0.9.3 - 10/19/2000 - G.Juyn * */
+/* * - added storage for pixel-/alpha-sampledepth for delta's * */
+/* * * */
+/* * 0.9.4 - 1/18/2001 - G.Juyn * */
+/* * - removed "old" MAGN methods 3 & 4 * */
+/* * - added "new" MAGN methods 3, 4 & 5 * */
+/* * * */
+/* * 0.9.5 - 1/22/2001 - G.Juyn * */
+/* * - B129681 - fixed compiler warnings SGI/Irix * */
+/* * * */
+/* * 1.0.2 - 06/23/2001 - G.Juyn * */
+/* * - added optimization option for MNG-video playback * */
+/* * * */
+/* * 1.0.5 - 08/15/2002 - G.Juyn * */
+/* * - completed PROM support * */
+/* * 1.0.5 - 08/16/2002 - G.Juyn * */
+/* * - completed MAGN support (16-bit functions) * */
+/* * 1.0.5 - 08/19/2002 - G.Juyn * */
+/* * - B597134 - libmng pollutes the linker namespace * */
+/* * 1.0.5 - 09/13/2002 - G.Juyn * */
+/* * - fixed read/write of MAGN chunk * */
+/* * 1.0.5 - 09/15/2002 - G.Juyn * */
+/* * - added event handling for dynamic MNG * */
+/* * 1.0.5 - 09/20/2002 - G.Juyn * */
+/* * - added support for PAST * */
+/* * 1.0.5 - 09/23/2002 - G.Juyn * */
+/* * - fixed reset_object_detail to clear old buffer * */
+/* * - added in-memory color-correction of abstract images * */
+/* * 1.0.5 - 10/05/2002 - G.Juyn * */
+/* * - fixed problem with cloned objects marked as invalid * */
+/* * - fixed problem cloning frozen object_buffers * */
+/* * 1.0.5 - 10/07/2002 - G.Juyn * */
+/* * - fixed DISC support * */
+/* * 1.0.5 - 11/04/2002 - G.Juyn * */
+/* * - fixed goframe/golayer/gotime processing * */
+/* * 1.0.5 - 11/07/2002 - G.Juyn * */
+/* * - fixed magnification bug with object 0 * */
+/* * 1.0.5 - 01/19/2003 - G.Juyn * */
+/* * - B664911 - fixed buffer overflow during init * */
+/* * * */
+/* * 1.0.6 - 04/19/2003 - G.Juyn * */
+/* * - fixed problem with infinite loops during readdisplay() * */
+/* * 1.0.6 - 05/25/2003 - G.R-P * */
+/* * - added MNG_SKIPCHUNK_cHNK footprint optimizations * */
+/* * 1.0.6 - 06/09/2003 - G. R-P * */
+/* * - added conditionals around 8-bit magn routines * */
+/* * 1.0.6 - 07/07/2003 - G.R-P * */
+/* * - added conditionals around some JNG-supporting code * */
+/* * - removed conditionals around 8-bit magn routines * */
+/* * - added conditionals around delta-png and 16-bit code * */
+/* * 1.0.6 - 07/14/2003 - G.R-P * */
+/* * - added MNG_NO_LOOP_SIGNALS_SUPPORTED conditional * */
+/* * 1.0.6 - 07/29/2003 - G.Juyn * */
+/* * - fixed invalid test in promote_imageobject * */
+/* * 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 MAGN chunk support * */
+/* * * */
+/* * 1.0.7 - 03/21/2004 - G.Juyn * */
+/* * - fixed some 64-bit platform compiler warnings * */
+/* * * */
+/* * 1.0.9 - 10/10/2004 - G.R-P. * */
+/* * - added MNG_NO_1_2_4BIT_SUPPORT support * */
+/* * 1.0.9 - 12/05/2004 - G.Juyn * */
+/* * - added conditional MNG_OPTIMIZE_OBJCLEANUP * */
+/* * 1.0.9 - 12/11/2004 - G.Juyn * */
+/* * - added conditional MNG_OPTIMIZE_DISPLAYCALLS * */
+/* * 1.0.9 - 12/31/2004 - G.R-P. * */
+/* * - fixed warnings about possible uninitialized pointers * */
+/* * 1.0.9 - 01/02/2005 - G.Juyn * */
+/* * - fixing some compiler-warnings * */
+/* * * */
+/* * 1.0.10 - 02/07/2005 - G.Juyn * */
+/* * - fixed some compiler-warnings * */
+/* * 1.0.10 - 07/30/2005 - G.Juyn * */
+/* * - fixed problem with CLON object during readdisplay() * */
+/* * 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 * */
+/* * * */
+/* ************************************************************************** */
+
+#include "libmng.h"
+#include "libmng_data.h"
+#include "libmng_error.h"
+#include "libmng_trace.h"
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+#include "libmng_memory.h"
+#include "libmng_chunks.h"
+#include "libmng_objects.h"
+#include "libmng_display.h"
+#include "libmng_pixels.h"
+#include "libmng_object_prc.h"
+#include "libmng_cms.h"
+
+#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
+#pragma option -A /* force ANSI-C */
+#endif
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_DISPLAY_PROCS
+
+/* ************************************************************************** */
+/* * * */
+/* * Generic object routines * */
+/* * * */
+/* ************************************************************************** */
+
+mng_retcode mng_drop_invalid_objects (mng_datap pData)
+{
+ mng_objectp pObject;
+ mng_objectp pNext;
+ mng_cleanupobject fCleanup;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_DROP_INVALID_OBJECTS, MNG_LC_START);
+#endif
+
+ pObject = pData->pFirstimgobj; /* get first stored image-object (if any) */
+
+ while (pObject) /* more objects to check ? */
+ {
+ pNext = ((mng_object_headerp)pObject)->pNext;
+ /* invalid ? */
+ if (!((mng_imagep)pObject)->bValid)
+ { /* call appropriate cleanup */
+ fCleanup = ((mng_object_headerp)pObject)->fCleanup;
+ fCleanup (pData, pObject);
+ }
+
+ pObject = pNext; /* neeeext */
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_DROP_INVALID_OBJECTS, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+MNG_LOCAL mng_retcode create_obj_general (mng_datap pData,
+ mng_size_t iObjsize,
+ mng_cleanupobject fCleanup,
+ mng_processobject fProcess,
+ mng_ptr *ppObject)
+{
+ mng_object_headerp pWork;
+
+ MNG_ALLOC (pData, pWork, iObjsize);
+
+ pWork->fCleanup = fCleanup;
+ pWork->fProcess = fProcess;
+ pWork->iObjsize = iObjsize;
+ *ppObject = (mng_ptr)pWork;
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+MNG_LOCAL mng_retcode mng_free_obj_general (mng_datap pData,
+ mng_objectp pObject)
+{
+ MNG_FREEX (pData, pObject, ((mng_object_headerp)pObject)->iObjsize);
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* * * */
+/* * Image-data-object routines * */
+/* * * */
+/* * these handle the "object buffer" as defined by the MNG specification * */
+/* * * */
+/* ************************************************************************** */
+
+mng_retcode mng_create_imagedataobject (mng_datap pData,
+ mng_bool bConcrete,
+ mng_bool bViewable,
+ mng_uint32 iWidth,
+ mng_uint32 iHeight,
+ mng_uint8 iBitdepth,
+ mng_uint8 iColortype,
+ mng_uint8 iCompression,
+ mng_uint8 iFilter,
+ mng_uint8 iInterlace,
+ mng_imagedatap *ppObject)
+{
+ mng_imagedatap pImagedata;
+ mng_uint32 iSamplesize = 0;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_IMGDATAOBJECT, MNG_LC_START);
+#endif
+ /* get a buffer */
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ {
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_imagedata),
+ (mng_cleanupobject)mng_free_imagedataobject,
+ MNG_NULL, &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pImagedata = (mng_imagedatap)pTemp;
+ }
+#else
+ MNG_ALLOC (pData, pImagedata, sizeof (mng_imagedata));
+ /* fill the appropriate fields */
+ pImagedata->sHeader.fCleanup = (mng_cleanupobject)mng_free_imagedataobject;
+ pImagedata->sHeader.fProcess = MNG_NULL;
+#endif
+ pImagedata->iRefcount = 1;
+ pImagedata->bFrozen = MNG_FALSE;
+ pImagedata->bConcrete = bConcrete;
+ pImagedata->bViewable = bViewable;
+ pImagedata->iWidth = iWidth;
+ pImagedata->iHeight = iHeight;
+ pImagedata->iBitdepth = iBitdepth;
+ pImagedata->iColortype = iColortype;
+ pImagedata->iCompression = iCompression;
+ pImagedata->iFilter = iFilter;
+ pImagedata->iInterlace = iInterlace;
+ pImagedata->bCorrected = MNG_FALSE;
+ pImagedata->iAlphabitdepth = 0;
+ pImagedata->iJHDRcompression = 0;
+ pImagedata->iJHDRinterlace = 0;
+ pImagedata->iPixelsampledepth = iBitdepth;
+ pImagedata->iAlphasampledepth = iBitdepth;
+ /* determine samplesize from color_type/bit_depth */
+ switch (iColortype) /* for < 8-bit samples we just reserve 8 bits */
+ {
+ case 0 : ; /* gray */
+ case 8 : { /* JPEG gray */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 2;
+ else
+#endif
+ iSamplesize = 1;
+
+ break;
+ }
+ case 2 : ; /* rgb */
+ case 10 : { /* JPEG rgb */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 6;
+ else
+#endif
+ iSamplesize = 3;
+
+ break;
+ }
+ case 3 : { /* indexed */
+ iSamplesize = 1;
+ break;
+ }
+ case 4 : ; /* gray+alpha */
+ case 12 : { /* JPEG gray+alpha */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 4;
+ else
+#endif
+ iSamplesize = 2;
+
+ break;
+ }
+ case 6 : ; /* rgb+alpha */
+ case 14 : { /* JPEG rgb+alpha */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 8;
+ else
+#endif
+ iSamplesize = 4;
+
+ break;
+ }
+ }
+ /* make sure we remember all this */
+ pImagedata->iSamplesize = iSamplesize;
+ pImagedata->iRowsize = iSamplesize * iWidth;
+ pImagedata->iImgdatasize = pImagedata->iRowsize * iHeight;
+
+ if (pImagedata->iImgdatasize) /* need a buffer ? */
+ { /* so allocate it */
+ MNG_ALLOCX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize);
+
+ if (!pImagedata->pImgdata) /* enough memory ? */
+ {
+ MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata));
+ MNG_ERROR (pData, MNG_OUTOFMEMORY);
+ }
+ }
+ /* check global stuff */
+ pImagedata->bHasGAMA = pData->bHasglobalGAMA;
+#ifndef MNG_SKIPCHUNK_cHRM
+ pImagedata->bHasCHRM = pData->bHasglobalCHRM;
+#endif
+ pImagedata->bHasSRGB = pData->bHasglobalSRGB;
+#ifndef MNG_SKIPCHUNK_iCCP
+ pImagedata->bHasICCP = pData->bHasglobalICCP;
+#endif
+#ifndef MNG_SKIPCHUNK_bKGD
+ pImagedata->bHasBKGD = pData->bHasglobalBKGD;
+#endif
+
+ if (pData->bHasglobalGAMA) /* global gAMA present ? */
+ pImagedata->iGamma = pData->iGlobalGamma;
+
+#ifndef MNG_SKIPCHUNK_cHRM
+ if (pData->bHasglobalCHRM) /* global cHRM present ? */
+ {
+ pImagedata->iWhitepointx = pData->iGlobalWhitepointx;
+ pImagedata->iWhitepointy = pData->iGlobalWhitepointy;
+ pImagedata->iPrimaryredx = pData->iGlobalPrimaryredx;
+ pImagedata->iPrimaryredy = pData->iGlobalPrimaryredy;
+ pImagedata->iPrimarygreenx = pData->iGlobalPrimarygreenx;
+ pImagedata->iPrimarygreeny = pData->iGlobalPrimarygreeny;
+ pImagedata->iPrimarybluex = pData->iGlobalPrimarybluex;
+ pImagedata->iPrimarybluey = pData->iGlobalPrimarybluey;
+ }
+#endif
+
+ if (pData->bHasglobalSRGB) /* glbal sRGB present ? */
+ pImagedata->iRenderingintent = pData->iGlobalRendintent;
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pData->bHasglobalICCP) /* glbal iCCP present ? */
+ {
+ pImagedata->iProfilesize = pData->iGlobalProfilesize;
+
+ if (pImagedata->iProfilesize)
+ {
+ MNG_ALLOCX (pData, pImagedata->pProfile, pImagedata->iProfilesize);
+
+ if (!pImagedata->pProfile) /* enough memory ? */
+ {
+ MNG_FREEX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize);
+ MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata));
+ MNG_ERROR (pData, MNG_OUTOFMEMORY);
+ }
+
+ MNG_COPY (pImagedata->pProfile, pData->pGlobalProfile, pImagedata->iProfilesize);
+ }
+ }
+#endif
+
+#ifndef MNG_SKIPCHUNK_bKGD
+ if (pData->bHasglobalBKGD) /* global bKGD present ? */
+ {
+ pImagedata->iBKGDred = pData->iGlobalBKGDred;
+ pImagedata->iBKGDgreen = pData->iGlobalBKGDgreen;
+ pImagedata->iBKGDblue = pData->iGlobalBKGDblue;
+ }
+#endif
+
+ *ppObject = pImagedata; /* return it */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_IMGDATAOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_imagedataobject (mng_datap pData,
+ mng_imagedatap pImagedata)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_IMGDATAOBJECT, MNG_LC_START);
+#endif
+
+ if (pImagedata->iRefcount) /* decrease reference count */
+ pImagedata->iRefcount--;
+
+ if (!pImagedata->iRefcount) /* reached zero ? */
+ {
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pImagedata->iProfilesize) /* stored an iCCP profile ? */
+ MNG_FREEX (pData, pImagedata->pProfile, pImagedata->iProfilesize);
+#endif
+ if (pImagedata->iImgdatasize) /* sample-buffer present ? */
+ MNG_FREEX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize);
+ /* drop the buffer */
+ MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata));
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_IMGDATAOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_clone_imagedataobject (mng_datap pData,
+ mng_bool bConcrete,
+ mng_imagedatap pSource,
+ mng_imagedatap *ppClone)
+{
+ mng_imagedatap pNewdata;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CLONE_IMGDATAOBJECT, MNG_LC_START);
+#endif
+ /* get a buffer */
+ MNG_ALLOC (pData, pNewdata, sizeof (mng_imagedata));
+ /* blatently copy the original buffer */
+ MNG_COPY (pNewdata, pSource, sizeof (mng_imagedata));
+
+ pNewdata->iRefcount = 1; /* only the reference count */
+ pNewdata->bConcrete = bConcrete; /* and concrete-flag are different */
+ pNewdata->bFrozen = MNG_FALSE;
+
+ if (pNewdata->iImgdatasize) /* sample buffer present ? */
+ {
+ MNG_ALLOCX (pData, pNewdata->pImgdata, pNewdata->iImgdatasize);
+
+ if (!pNewdata->pImgdata) /* not enough memory ? */
+ {
+ MNG_FREEX (pData, pNewdata, sizeof (mng_imagedata));
+ MNG_ERROR (pData, MNG_OUTOFMEMORY);
+ }
+ /* make a copy */
+ MNG_COPY (pNewdata->pImgdata, pSource->pImgdata, pNewdata->iImgdatasize);
+ }
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pNewdata->iProfilesize) /* iCCP profile present ? */
+ {
+ MNG_ALLOCX (pData, pNewdata->pProfile, pNewdata->iProfilesize);
+
+ if (!pNewdata->pProfile) /* enough memory ? */
+ {
+ MNG_FREEX (pData, pNewdata, sizeof (mng_imagedata));
+ MNG_ERROR (pData, MNG_OUTOFMEMORY);
+ }
+ /* make a copy */
+ MNG_COPY (pNewdata->pProfile, pSource->pProfile, pNewdata->iProfilesize);
+ }
+#endif
+
+ *ppClone = pNewdata; /* return the clone */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CLONE_IMGDATAOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+/* * * */
+/* * Image-object routines * */
+/* * * */
+/* * these handle the "object" as defined by the MNG specification * */
+/* * * */
+/* ************************************************************************** */
+
+mng_retcode mng_create_imageobject (mng_datap pData,
+ mng_uint16 iId,
+ mng_bool bConcrete,
+ mng_bool bVisible,
+ mng_bool bViewable,
+ mng_uint32 iWidth,
+ mng_uint32 iHeight,
+ mng_uint8 iBitdepth,
+ mng_uint8 iColortype,
+ mng_uint8 iCompression,
+ mng_uint8 iFilter,
+ mng_uint8 iInterlace,
+ mng_int32 iPosx,
+ mng_int32 iPosy,
+ mng_bool bClipped,
+ mng_int32 iClipl,
+ mng_int32 iClipr,
+ mng_int32 iClipt,
+ mng_int32 iClipb,
+ mng_imagep *ppObject)
+{
+ mng_imagep pImage;
+ mng_imagep pPrev, pNext;
+ mng_retcode iRetcode;
+ mng_imagedatap pImgbuf;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_IMGOBJECT, MNG_LC_START);
+#endif
+ /* get a buffer */
+ MNG_ALLOC (pData, pImage, sizeof (mng_image));
+ /* now get a new "object buffer" */
+ iRetcode = mng_create_imagedataobject (pData, bConcrete, bViewable,
+ iWidth, iHeight, iBitdepth, iColortype,
+ iCompression, iFilter, iInterlace,
+ &pImgbuf);
+
+ if (iRetcode) /* on error bail out */
+ {
+ MNG_FREEX (pData, pImage, sizeof (mng_image));
+ return iRetcode;
+ }
+ /* fill the appropriate fields */
+ pImage->sHeader.fCleanup = (mng_cleanupobject)mng_free_imageobject;
+ pImage->sHeader.fProcess = MNG_NULL;
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ pImage->sHeader.iObjsize = sizeof (mng_image);
+#endif
+ pImage->iId = iId;
+ pImage->bFrozen = MNG_FALSE;
+ pImage->bVisible = bVisible;
+ pImage->bViewable = bViewable;
+ pImage->bValid = (mng_bool)((pData->bDisplaying) &&
+ ((pData->bRunning) || (pData->bSearching)) &&
+ (!pData->bFreezing));
+ pImage->iPosx = iPosx;
+ pImage->iPosy = iPosy;
+ pImage->bClipped = bClipped;
+ pImage->iClipl = iClipl;
+ pImage->iClipr = iClipr;
+ pImage->iClipt = iClipt;
+ pImage->iClipb = iClipb;
+#ifndef MNG_SKIPCHUNK_MAGN
+ pImage->iMAGN_MethodX = 0;
+ pImage->iMAGN_MethodY = 0;
+ pImage->iMAGN_MX = 0;
+ pImage->iMAGN_MY = 0;
+ pImage->iMAGN_ML = 0;
+ pImage->iMAGN_MR = 0;
+ pImage->iMAGN_MT = 0;
+ pImage->iMAGN_MB = 0;
+#endif
+#ifndef MNG_SKIPCHUNK_PAST
+ pImage->iPastx = 0;
+ pImage->iPasty = 0;
+#endif
+ pImage->pImgbuf = pImgbuf;
+
+ if (iId) /* only if not object 0 ! */
+ { /* find previous lower object-id */
+ pPrev = (mng_imagep)pData->pLastimgobj;
+
+ while ((pPrev) && (pPrev->iId > iId))
+ pPrev = (mng_imagep)pPrev->sHeader.pPrev;
+
+ if (pPrev) /* found it ? */
+ {
+ pImage->sHeader.pPrev = pPrev; /* than link it in place */
+ pImage->sHeader.pNext = pPrev->sHeader.pNext;
+ pPrev->sHeader.pNext = pImage;
+ }
+ else /* if not found, it becomes the first ! */
+ {
+ pImage->sHeader.pNext = pData->pFirstimgobj;
+ pData->pFirstimgobj = pImage;
+ }
+
+ pNext = (mng_imagep)pImage->sHeader.pNext;
+
+ if (pNext)
+ pNext->sHeader.pPrev = pImage;
+ else
+ pData->pLastimgobj = pImage;
+
+ }
+
+ *ppObject = pImage; /* and return the new buffer */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR; /* okido */
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_imageobject (mng_datap pData,
+ mng_imagep pImage)
+{
+ mng_retcode iRetcode;
+ mng_imagep pPrev = pImage->sHeader.pPrev;
+ mng_imagep pNext = pImage->sHeader.pNext;
+ mng_imagedatap pImgbuf = pImage->pImgbuf;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_IMGOBJECT, MNG_LC_START);
+#endif
+
+ if (pImage->iId) /* not for object 0 */
+ {
+ if (pPrev) /* unlink from the list first ! */
+ pPrev->sHeader.pNext = pImage->sHeader.pNext;
+ else
+ pData->pFirstimgobj = pImage->sHeader.pNext;
+
+ if (pNext)
+ pNext->sHeader.pPrev = pImage->sHeader.pPrev;
+ else
+ pData->pLastimgobj = pImage->sHeader.pPrev;
+
+ }
+ /* unlink the image-data buffer */
+ iRetcode = mng_free_imagedataobject (pData, pImgbuf);
+ /* drop its own buffer */
+ MNG_FREEX (pData, pImage, sizeof (mng_image));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+mng_imagep mng_find_imageobject (mng_datap pData,
+ mng_uint16 iId)
+{
+ mng_imagep pImage = (mng_imagep)pData->pFirstimgobj;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_START);
+#endif
+ /* look up the right id */
+ while ((pImage) && (pImage->iId != iId))
+ pImage = (mng_imagep)pImage->sHeader.pNext;
+
+#ifdef MNG_INCLUDE_MPNG_PROPOSAL
+ if ((!pImage) && (pData->eImagetype == mng_it_mpng))
+ pImage = pData->pObjzero;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return pImage;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_clone_imageobject (mng_datap pData,
+ mng_uint16 iId,
+ mng_bool bPartial,
+ mng_bool bVisible,
+ mng_bool bAbstract,
+ mng_bool bHasloca,
+ mng_uint8 iLocationtype,
+ mng_int32 iLocationx,
+ mng_int32 iLocationy,
+ mng_imagep pSource,
+ mng_imagep *ppClone)
+{
+ mng_imagep pNew;
+ mng_imagep pPrev, pNext;
+ mng_retcode iRetcode;
+ mng_imagedatap pImgbuf;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CLONE_IMGOBJECT, MNG_LC_START);
+#endif
+
+#ifndef MNG_SKIPCHUNK_MAGN
+ if ((pSource->iId) && /* needs magnification ? */
+ ((pSource->iMAGN_MethodX) || (pSource->iMAGN_MethodY)))
+ {
+ iRetcode = mng_magnify_imageobject (pData, pSource);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+ }
+#endif
+ /* get a buffer */
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ {
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_image),
+ (mng_cleanupobject)mng_free_imageobject,
+ MNG_NULL, &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pNew = (mng_imagep)pTemp;
+ }
+#else
+ MNG_ALLOC (pData, pNew, sizeof (mng_image));
+ /* fill or copy the appropriate fields */
+ pNew->sHeader.fCleanup = (mng_cleanupobject)mng_free_imageobject;
+ pNew->sHeader.fProcess = MNG_NULL;
+#endif
+ pNew->iId = iId;
+ pNew->bFrozen = MNG_FALSE;
+ pNew->bVisible = bVisible;
+ pNew->bViewable = pSource->bViewable;
+ pNew->bValid = MNG_TRUE;
+
+ if (bHasloca) /* location info available ? */
+ {
+ if (iLocationtype == 0) /* absolute position ? */
+ {
+ pNew->iPosx = iLocationx;
+ pNew->iPosy = iLocationy;
+ }
+ else /* relative */
+ {
+ pNew->iPosx = pSource->iPosx + iLocationx;
+ pNew->iPosy = pSource->iPosy + iLocationy;
+ }
+ }
+ else /* copy from source */
+ {
+ pNew->iPosx = pSource->iPosx;
+ pNew->iPosy = pSource->iPosy;
+ }
+ /* copy clipping info */
+ pNew->bClipped = pSource->bClipped;
+ pNew->iClipl = pSource->iClipl;
+ pNew->iClipr = pSource->iClipr;
+ pNew->iClipt = pSource->iClipt;
+ pNew->iClipb = pSource->iClipb;
+#ifndef MNG_SKIPCHUNK_MAGN
+ /* copy magnification info */
+/* pNew->iMAGN_MethodX = pSource->iMAGN_MethodX; LET'S NOT !!!!!!
+ pNew->iMAGN_MethodY = pSource->iMAGN_MethodY;
+ pNew->iMAGN_MX = pSource->iMAGN_MX;
+ pNew->iMAGN_MY = pSource->iMAGN_MY;
+ pNew->iMAGN_ML = pSource->iMAGN_ML;
+ pNew->iMAGN_MR = pSource->iMAGN_MR;
+ pNew->iMAGN_MT = pSource->iMAGN_MT;
+ pNew->iMAGN_MB = pSource->iMAGN_MB; */
+#endif
+
+#ifndef MNG_SKIPCHUNK_PAST
+ pNew->iPastx = 0; /* initialize PAST info */
+ pNew->iPasty = 0;
+#endif
+
+ if (iId) /* not for object 0 */
+ { /* find previous lower object-id */
+ pPrev = (mng_imagep)pData->pLastimgobj;
+ while ((pPrev) && (pPrev->iId > iId))
+ pPrev = (mng_imagep)pPrev->sHeader.pPrev;
+
+ if (pPrev) /* found it ? */
+ {
+ pNew->sHeader.pPrev = pPrev; /* than link it in place */
+ pNew->sHeader.pNext = pPrev->sHeader.pNext;
+ pPrev->sHeader.pNext = pNew;
+ }
+ else /* if not found, it becomes the first ! */
+ {
+ pNew->sHeader.pNext = pData->pFirstimgobj;
+ pData->pFirstimgobj = pNew;
+ }
+
+ pNext = (mng_imagep)pNew->sHeader.pNext;
+
+ if (pNext)
+ pNext->sHeader.pPrev = pNew;
+ else
+ pData->pLastimgobj = pNew;
+
+ }
+
+ if (bPartial) /* partial clone ? */
+ {
+ pNew->pImgbuf = pSource->pImgbuf; /* use the same object buffer */
+ pNew->pImgbuf->iRefcount++; /* and increase the reference count */
+ }
+ else /* create a full clone ! */
+ {
+ mng_bool bConcrete = MNG_FALSE; /* it's abstract by default (?) */
+
+ if (!bAbstract) /* determine concreteness from source ? */
+ bConcrete = pSource->pImgbuf->bConcrete;
+ /* create a full clone ! */
+ iRetcode = mng_clone_imagedataobject (pData, bConcrete, pSource->pImgbuf, &pImgbuf);
+
+ if (iRetcode) /* on error bail out */
+ {
+ MNG_FREEX (pData, pNew, sizeof (mng_image));
+ return iRetcode;
+ }
+
+ pNew->pImgbuf = pImgbuf; /* and remember it */
+ }
+
+ *ppClone = pNew; /* return it */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CLONE_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_renum_imageobject (mng_datap pData,
+ mng_imagep pSource,
+ mng_uint16 iId,
+ mng_bool bVisible,
+ mng_bool bAbstract,
+ mng_bool bHasloca,
+ mng_uint8 iLocationtype,
+ mng_int32 iLocationx,
+ mng_int32 iLocationy)
+{
+ mng_imagep pPrev, pNext;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_RENUM_IMGOBJECT, MNG_LC_START);
+#endif
+
+ pSource->bVisible = bVisible; /* store the new visibility */
+
+ if (bHasloca) /* location info available ? */
+ {
+ if (iLocationtype == 0) /* absolute position ? */
+ {
+ pSource->iPosx = iLocationx;
+ pSource->iPosy = iLocationy;
+ }
+ else /* relative */
+ {
+ pSource->iPosx = pSource->iPosx + iLocationx;
+ pSource->iPosy = pSource->iPosy + iLocationy;
+ }
+ }
+
+ if (iId) /* not for object 0 */
+ { /* find previous lower object-id */
+ pPrev = (mng_imagep)pData->pLastimgobj;
+ while ((pPrev) && (pPrev->iId > iId))
+ pPrev = (mng_imagep)pPrev->sHeader.pPrev;
+ /* different from current ? */
+ if (pPrev != (mng_imagep)pSource->sHeader.pPrev)
+ {
+ if (pSource->sHeader.pPrev) /* unlink from current position !! */
+ ((mng_imagep)pSource->sHeader.pPrev)->sHeader.pNext = pSource->sHeader.pNext;
+ else
+ pData->pFirstimgobj = pSource->sHeader.pNext;
+
+ if (pSource->sHeader.pNext)
+ ((mng_imagep)pSource->sHeader.pNext)->sHeader.pPrev = pSource->sHeader.pPrev;
+ else
+ pData->pLastimgobj = pSource->sHeader.pPrev;
+
+ if (pPrev) /* found the previous ? */
+ { /* than link it in place */
+ pSource->sHeader.pPrev = pPrev;
+ pSource->sHeader.pNext = pPrev->sHeader.pNext;
+ pPrev->sHeader.pNext = pSource;
+ }
+ else /* if not found, it becomes the first ! */
+ {
+ pSource->sHeader.pNext = pData->pFirstimgobj;
+ pData->pFirstimgobj = pSource;
+ }
+
+ pNext = (mng_imagep)pSource->sHeader.pNext;
+
+ if (pNext)
+ pNext->sHeader.pPrev = pSource;
+ else
+ pData->pLastimgobj = pSource;
+
+ }
+ }
+
+ pSource->iId = iId; /* now set the new id! */
+
+ if (bAbstract) /* force it to abstract ? */
+ pSource->pImgbuf->bConcrete = MNG_FALSE;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_RENUM_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_reset_object_details (mng_datap pData,
+ mng_imagep pImage,
+ mng_uint32 iWidth,
+ mng_uint32 iHeight,
+ mng_uint8 iBitdepth,
+ mng_uint8 iColortype,
+ mng_uint8 iCompression,
+ mng_uint8 iFilter,
+ mng_uint8 iInterlace,
+ mng_bool bResetall)
+{
+ mng_imagedatap pBuf = pImage->pImgbuf;
+ mng_uint32 iSamplesize = 0;
+ mng_uint32 iRowsize;
+ mng_uint32 iImgdatasize;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_RESET_OBJECTDETAILS, MNG_LC_START);
+#endif
+
+ pBuf->iWidth = iWidth; /* set buffer characteristics */
+ pBuf->iHeight = iHeight;
+ pBuf->iBitdepth = iBitdepth;
+ pBuf->iColortype = iColortype;
+ pBuf->iCompression = iCompression;
+ pBuf->iFilter = iFilter;
+ pBuf->iInterlace = iInterlace;
+ pBuf->bCorrected = MNG_FALSE;
+ pBuf->iAlphabitdepth = 0;
+ /* determine samplesize from color_type/bit_depth */
+ switch (iColortype) /* for < 8-bit samples we just reserve 8 bits */
+ {
+ case 0 : ; /* gray */
+ case 8 : { /* JPEG gray */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 2;
+ else
+#endif
+ iSamplesize = 1;
+
+ break;
+ }
+ case 2 : ; /* rgb */
+ case 10 : { /* JPEG rgb */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 6;
+ else
+#endif
+ iSamplesize = 3;
+
+ break;
+ }
+ case 3 : { /* indexed */
+ iSamplesize = 1;
+ break;
+ }
+ case 4 : ; /* gray+alpha */
+ case 12 : { /* JPEG gray+alpha */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 4;
+ else
+#endif
+ iSamplesize = 2;
+
+ break;
+ }
+ case 6 : ; /* rgb+alpha */
+ case 14 : { /* JPEG rgb+alpha */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iSamplesize = 8;
+ else
+#endif
+ iSamplesize = 4;
+
+ break;
+ }
+ }
+
+ iRowsize = iSamplesize * iWidth;
+ iImgdatasize = iRowsize * iHeight;
+ /* buffer size changed ? */
+ if (iImgdatasize != pBuf->iImgdatasize)
+ { /* drop the old one */
+ MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+
+ if (iImgdatasize) /* allocate new sample-buffer ? */
+ MNG_ALLOC (pData, pBuf->pImgdata, iImgdatasize);
+ }
+ else
+ {
+ if (iImgdatasize) /* clear old buffer */
+ {
+ mng_uint8p pTemp = pBuf->pImgdata;
+ mng_uint32 iX;
+
+ for (iX = 0; iX < (iImgdatasize & (mng_uint32)(~3L)); iX += 4)
+ {
+ *((mng_uint32p)pTemp) = 0x00000000l;
+ pTemp += 4;
+ }
+
+ while (pTemp < (pBuf->pImgdata + iImgdatasize))
+ {
+ *pTemp = 0;
+ pTemp++;
+ }
+ }
+ }
+
+ pBuf->iSamplesize = iSamplesize; /* remember new sizes */
+ pBuf->iRowsize = iRowsize;
+ pBuf->iImgdatasize = iImgdatasize;
+
+ if (!pBuf->iPixelsampledepth) /* set delta sampledepths if empty */
+ pBuf->iPixelsampledepth = iBitdepth;
+ if (!pBuf->iAlphasampledepth)
+ pBuf->iAlphasampledepth = iBitdepth;
+ /* dimension set and clipping not ? */
+ if ((iWidth) && (iHeight) && (!pImage->bClipped))
+ {
+ pImage->iClipl = 0; /* set clipping to dimension by default */
+ pImage->iClipr = iWidth;
+ pImage->iClipt = 0;
+ pImage->iClipb = iHeight;
+ }
+
+#ifndef MNG_SKIPCHUNK_MAGN
+ if (pImage->iId) /* reset magnification info ? */
+ {
+ pImage->iMAGN_MethodX = 0;
+ pImage->iMAGN_MethodY = 0;
+ pImage->iMAGN_MX = 0;
+ pImage->iMAGN_MY = 0;
+ pImage->iMAGN_ML = 0;
+ pImage->iMAGN_MR = 0;
+ pImage->iMAGN_MT = 0;
+ pImage->iMAGN_MB = 0;
+ }
+#endif
+
+ if (bResetall) /* reset the other characteristics ? */
+ {
+#ifndef MNG_SKIPCHUNK_PAST
+ pImage->iPastx = 0;
+ pImage->iPasty = 0;
+#endif
+
+ pBuf->bHasPLTE = MNG_FALSE;
+ pBuf->bHasTRNS = MNG_FALSE;
+ pBuf->bHasGAMA = pData->bHasglobalGAMA;
+#ifndef MNG_SKIPCHUNK_cHRM
+ pBuf->bHasCHRM = pData->bHasglobalCHRM;
+#endif
+ pBuf->bHasSRGB = pData->bHasglobalSRGB;
+#ifndef MNG_SKIPCHUNK_iCCP
+ pBuf->bHasICCP = pData->bHasglobalICCP;
+#endif
+#ifndef MNG_SKIPCHUNK_bKGD
+ pBuf->bHasBKGD = pData->bHasglobalBKGD;
+#endif
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pBuf->iProfilesize) /* drop possibly old ICC profile */
+ {
+ MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize);
+ pBuf->iProfilesize = 0;
+ }
+#endif
+
+ if (pData->bHasglobalGAMA) /* global gAMA present ? */
+ pBuf->iGamma = pData->iGlobalGamma;
+
+#ifndef MNG_SKIPCHUNK_cHRM
+ if (pData->bHasglobalCHRM) /* global cHRM present ? */
+ {
+ pBuf->iWhitepointx = pData->iGlobalWhitepointx;
+ pBuf->iWhitepointy = pData->iGlobalWhitepointy;
+ pBuf->iPrimaryredx = pData->iGlobalPrimaryredx;
+ pBuf->iPrimaryredy = pData->iGlobalPrimaryredy;
+ pBuf->iPrimarygreenx = pData->iGlobalPrimarygreenx;
+ pBuf->iPrimarygreeny = pData->iGlobalPrimarygreeny;
+ pBuf->iPrimarybluex = pData->iGlobalPrimarybluex;
+ pBuf->iPrimarybluey = pData->iGlobalPrimarybluey;
+ }
+#endif
+
+ if (pData->bHasglobalSRGB) /* global sRGB present ? */
+ pBuf->iRenderingintent = pData->iGlobalRendintent;
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pData->bHasglobalICCP) /* global iCCP present ? */
+ {
+ if (pData->iGlobalProfilesize)
+ {
+ MNG_ALLOC (pData, pBuf->pProfile, pData->iGlobalProfilesize);
+ MNG_COPY (pBuf->pProfile, pData->pGlobalProfile, pData->iGlobalProfilesize);
+ }
+
+ pBuf->iProfilesize = pData->iGlobalProfilesize;
+ }
+#endif
+
+#ifndef MNG_SKIPCHUNK_bKGD
+ if (pData->bHasglobalBKGD) /* global bKGD present ? */
+ {
+ pBuf->iBKGDred = pData->iGlobalBKGDred;
+ pBuf->iBKGDgreen = pData->iGlobalBKGDgreen;
+ pBuf->iBKGDblue = pData->iGlobalBKGDblue;
+ }
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_RESET_OBJECTDETAILS, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#if !defined(MNG_NO_DELTA_PNG) || !defined(MNG_SKIPCHUNK_PAST) || !defined(MNG_SKIPCHUNK_MAGN)
+mng_retcode mng_promote_imageobject (mng_datap pData,
+ mng_imagep pImage,
+ mng_uint8 iBitdepth,
+ mng_uint8 iColortype,
+ mng_uint8 iFilltype)
+{
+ mng_retcode iRetcode = MNG_NOERROR;
+ mng_imagedatap pBuf = pImage->pImgbuf;
+ mng_uint32 iW = pBuf->iWidth;
+ mng_uint32 iH = pBuf->iHeight;
+ mng_uint8p pNewbuf;
+ mng_uint32 iNewbufsize;
+ mng_uint32 iNewrowsize;
+ mng_uint32 iNewsamplesize = pBuf->iSamplesize;
+ mng_uint32 iY;
+ mng_uint8 iTempdepth;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROMOTE_IMGOBJECT, MNG_LC_START);
+#endif
+
+#ifdef MNG_NO_1_2_4BIT_SUPPORT
+ if (iBitdepth < 8)
+ iBitdepth=8;
+ if (pBuf->iBitdepth < 8)
+ pBuf->iBitdepth=8;
+#endif
+#ifdef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth > 8)
+ iBitdepth=8;
+ if (pBuf->iBitdepth > 8)
+ pBuf->iBitdepth=8;
+#endif
+
+ pData->fPromoterow = MNG_NULL; /* init promotion fields */
+ pData->fPromBitdepth = MNG_NULL;
+ pData->iPromColortype = iColortype;
+ pData->iPromBitdepth = iBitdepth;
+ pData->iPromFilltype = iFilltype;
+
+ if (iBitdepth != pBuf->iBitdepth) /* determine bitdepth promotion */
+ {
+ if (pBuf->iColortype == MNG_COLORTYPE_INDEXED)
+ iTempdepth = 8;
+ else
+ iTempdepth = pBuf->iBitdepth;
+
+#ifndef MNG_NO_DELTA_PNG
+ if (iFilltype == MNG_FILLMETHOD_ZEROFILL)
+ {
+ switch (iTempdepth)
+ {
+#ifndef MNG_NO_1_2_4BIT_SUPPORT
+ case 1 : {
+ switch (iBitdepth)
+ {
+ case 2 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_2; break; }
+ case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_4; break; }
+ case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_8; break; }
+#ifndef MNG_NO_16BIT_SUPPORT
+ case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_16; break; }
+#endif
+ }
+ break;
+ }
+ case 2 : {
+ switch (iBitdepth)
+ {
+ case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_2_4; break; }
+ case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_2_8; break; }
+#ifndef MNG_NO_16BIT_SUPPORT
+ case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_2_16; break; }
+#endif
+ }
+ break;
+ }
+ case 4 : {
+ switch (iBitdepth)
+ {
+ case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_4_8; break; }
+#ifndef MNG_NO_16BIT_SUPPORT
+ case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_4_16; break; }
+#endif
+ }
+ break;
+ }
+#endif /* MNG_NO_1_2_4BIT_SUPPORT */
+ case 8 : {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_8_16;
+#endif
+ break;
+ }
+ }
+ }
+ else
+#endif
+ {
+ switch (iTempdepth)
+ {
+#ifndef MNG_NO_1_2_4BIT_SUPPORT
+ case 1 : {
+ switch (iBitdepth)
+ {
+ case 2 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_2; break; }
+ case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_4; break; }
+ case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_8; break; }
+#ifndef MNG_NO_16BIT_SUPPORT
+ case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_16; break; }
+#endif
+ }
+ break;
+ }
+ case 2 : {
+ switch (iBitdepth)
+ {
+ case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_2_4; break; }
+ case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_2_8; break; }
+#ifndef MNG_NO_16BIT_SUPPORT
+ case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_2_16; break; }
+#endif
+ }
+ break;
+ }
+ case 4 : {
+ switch (iBitdepth)
+ {
+ case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_4_8; break; }
+#ifndef MNG_NO_16BIT_SUPPORT
+ case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_4_16; break; }
+#endif
+ }
+ break;
+ }
+#endif /* MNG_NO_1_2_4BIT_SUPPORT */
+ case 8 : {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_8_16;
+#endif
+ break;
+ }
+ }
+ }
+ }
+ /* g -> g */
+ if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
+ (iColortype == MNG_COLORTYPE_GRAY))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_g16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_g8;
+ }
+
+ iNewsamplesize = 1;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 2;
+#endif
+ }
+ else /* g -> ga */
+ if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
+ (iColortype == MNG_COLORTYPE_GRAYA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_ga16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_ga8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_g16_ga16;
+#endif
+
+ iNewsamplesize = 2;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 4;
+#endif
+ }
+ else /* g -> rgb */
+ if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
+ (iColortype == MNG_COLORTYPE_RGB))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_g16_rgb16;
+#endif
+
+ iNewsamplesize = 3;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 6;
+#endif
+ }
+ else /* g -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
+ (iColortype == MNG_COLORTYPE_RGBA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_g16_rgba16;
+#endif
+
+ iNewsamplesize = 4;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* ga -> ga */
+ if ((pBuf->iColortype == MNG_COLORTYPE_GRAYA) &&
+ (iColortype == MNG_COLORTYPE_GRAYA))
+ {
+ iNewsamplesize = 2;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_ga8_ga16;
+ if (iBitdepth == 16)
+ iNewsamplesize = 4;
+#endif
+ }
+ else /* ga -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_GRAYA) &&
+ (iColortype == MNG_COLORTYPE_RGBA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_ga16_rgba16;
+#endif
+
+ iNewsamplesize = 4;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* rgb -> rgb */
+ if ((pBuf->iColortype == MNG_COLORTYPE_RGB) &&
+ (iColortype == MNG_COLORTYPE_RGB))
+ {
+ iNewsamplesize = 3;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgb16;
+ if (iBitdepth == 16)
+ iNewsamplesize = 6;
+#endif
+ }
+ else /* rgb -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_RGB) &&
+ (iColortype == MNG_COLORTYPE_RGBA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb16_rgba16;
+#endif
+
+ iNewsamplesize = 4;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* indexed -> rgb */
+ if ((pBuf->iColortype == MNG_COLORTYPE_INDEXED) &&
+ (iColortype == MNG_COLORTYPE_RGB))
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgb16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgb8;
+
+ iNewsamplesize = 3;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 6;
+#endif
+ }
+ else /* indexed -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_INDEXED) &&
+ (iColortype == MNG_COLORTYPE_RGBA))
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgba8;
+
+ iNewsamplesize = 4;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* rgba -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_RGBA) &&
+ (iColortype == MNG_COLORTYPE_RGBA))
+ {
+ iNewsamplesize = 4;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_rgba8_rgba16;
+ }
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+#ifdef MNG_INCLUDE_JNG
+ else /* JPEG g -> g */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
+ (iColortype == MNG_COLORTYPE_JPEGGRAY))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_g16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_g8;
+ }
+
+ iNewsamplesize = 1;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 2;
+#endif
+ }
+ else /* JPEG g -> ga */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
+ (iColortype == MNG_COLORTYPE_JPEGGRAYA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_ga16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_ga8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_g16_ga16;
+#endif
+
+ iNewsamplesize = 2;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 4;
+#endif
+ }
+ else /* JPEG g -> rgb */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
+ (iColortype == MNG_COLORTYPE_JPEGCOLOR))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_g16_rgb16;
+#endif
+
+ iNewsamplesize = 3;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 6;
+#endif
+ }
+ else /* JPEG g -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
+ (iColortype == MNG_COLORTYPE_JPEGCOLORA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_g16_rgba16;
+#endif
+
+ iNewsamplesize = 4;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* JPEG ga -> ga */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAYA) &&
+ (iColortype == MNG_COLORTYPE_JPEGGRAYA))
+ {
+ iNewsamplesize = 2;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_ga8_ga16;
+ if (iBitdepth == 16)
+ iNewsamplesize = 4;
+#endif
+
+ }
+ else /* JPEG ga -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAYA) &&
+ (iColortype == MNG_COLORTYPE_JPEGCOLORA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_ga16_rgba16;
+#endif
+
+ iNewsamplesize = 4;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* JPEG rgb -> rgb */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGCOLOR) &&
+ (iColortype == MNG_COLORTYPE_JPEGCOLOR))
+ {
+ iNewsamplesize = 3;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgb16;
+ if (iBitdepth == 16)
+ iNewsamplesize = 6;
+#endif
+
+ }
+ else /* JPEG rgb -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGCOLOR) &&
+ (iColortype == MNG_COLORTYPE_JPEGCOLORA))
+ {
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ {
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba16;
+ else
+#endif
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba8;
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else /* source = 16 bits */
+ pData->fPromoterow = (mng_fptr)mng_promote_rgb16_rgba16;
+#endif
+
+ iNewsamplesize = 4;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (iBitdepth == 16) /* 16-bit wide ? */
+ iNewsamplesize = 8;
+#endif
+ }
+ else /* JPEG rgba -> rgba */
+ if ((pBuf->iColortype == MNG_COLORTYPE_JPEGCOLORA) &&
+ (iColortype == MNG_COLORTYPE_JPEGCOLORA))
+ {
+ iNewsamplesize = 4;
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
+ if (iBitdepth == 16)
+ pData->fPromoterow = (mng_fptr)mng_promote_rgba8_rgba16;
+ if (iBitdepth == 16)
+ iNewsamplesize = 8;
+#endif
+ }
+#endif /* JNG */
+
+ /* found a proper promotion ? */
+ if (pData->fPromoterow)
+ {
+ pData->pPromBuf = (mng_ptr)pBuf;
+ pData->iPromWidth = pBuf->iWidth;
+ iNewrowsize = iW * iNewsamplesize;
+ iNewbufsize = iH * iNewrowsize;
+
+ MNG_ALLOC (pData, pNewbuf, iNewbufsize);
+
+ pData->pPromSrc = (mng_ptr)pBuf->pImgdata;
+ pData->pPromDst = (mng_ptr)pNewbuf;
+ iY = 0;
+
+ while ((!iRetcode) && (iY < iH))
+ {
+ iRetcode = ((mng_promoterow)pData->fPromoterow) (pData);
+ pData->pPromSrc = (mng_uint8p)pData->pPromSrc + pBuf->iRowsize;
+ pData->pPromDst = (mng_uint8p)pData->pPromDst + iNewrowsize;
+/* pData->pPromSrc = (mng_ptr)((mng_uint32)pData->pPromSrc + pBuf->iRowsize); */
+/* pData->pPromDst = (mng_ptr)((mng_uint32)pData->pPromDst + iNewrowsize); */
+ iY++;
+ }
+
+ MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+
+ pBuf->iBitdepth = iBitdepth;
+ pBuf->iColortype = iColortype;
+ pBuf->iSamplesize = iNewsamplesize;
+ pBuf->iRowsize = iNewrowsize;
+ pBuf->iImgdatasize = iNewbufsize;
+ pBuf->pImgdata = pNewbuf;
+ pBuf->bHasPLTE = MNG_FALSE;
+ pBuf->iPLTEcount = 0;
+ pBuf->bHasTRNS = MNG_FALSE;
+ pBuf->iTRNScount = 0;
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROMOTE_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_MAGN
+mng_retcode mng_magnify_imageobject (mng_datap pData,
+ mng_imagep pImage)
+{
+ mng_uint8p pNewdata;
+ mng_uint8p pSrcline1;
+ mng_uint8p pSrcline2;
+ mng_uint8p pTempline;
+ mng_uint8p pDstline;
+ mng_uint32 iNewrowsize;
+ mng_uint32 iNewsize;
+ mng_uint32 iY;
+ mng_int32 iS, iM;
+ mng_retcode iRetcode;
+
+ mng_imagedatap pBuf = pImage->pImgbuf;
+ mng_uint32 iNewW = pBuf->iWidth;
+ mng_uint32 iNewH = pBuf->iHeight;
+ mng_magnify_x fMagnifyX = MNG_NULL;
+ mng_magnify_y fMagnifyY = MNG_NULL;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_MAGNIFY_IMGOBJECT, MNG_LC_START);
+#endif
+
+ if (pBuf->iColortype == MNG_COLORTYPE_INDEXED) /* indexed color ? */
+ { /* concrete buffer ? */
+ if ((pBuf->bConcrete) && (pImage->iId))
+ MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
+
+#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
+ if (pBuf->iTRNScount) /* with transparency ? */
+ iRetcode = mng_promote_imageobject (pData, pImage, 8, 6, 0);
+ else
+ iRetcode = mng_promote_imageobject (pData, pImage, 8, 2, 0);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+#endif
+ }
+
+#ifdef MNG_OPTIMIZE_FOOTPRINT_MAGN
+ /* Promote everything to RGBA, using fill method 0 (LBR) */
+ iRetcode = mng_promote_imageobject (pData, pImage, 8, 6, 0);
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+#endif
+
+ if (pImage->iMAGN_MethodX) /* determine new width */
+ {
+ if (pImage->iMAGN_MethodX == 1)
+ {
+ iNewW = pImage->iMAGN_ML;
+ if (pBuf->iWidth > 1)
+ iNewW = iNewW + pImage->iMAGN_MR;
+ if (pBuf->iWidth > 2)
+ iNewW = iNewW + (pBuf->iWidth - 2) * (pImage->iMAGN_MX);
+ }
+ else
+ {
+ iNewW = pBuf->iWidth + pImage->iMAGN_ML - 1;
+ if (pBuf->iWidth > 2)
+ iNewW = iNewW + pImage->iMAGN_MR - 1;
+ if (pBuf->iWidth > 3)
+ iNewW = iNewW + (pBuf->iWidth - 3) * (pImage->iMAGN_MX - 1);
+ }
+ }
+
+ if (pImage->iMAGN_MethodY) /* determine new height */
+ {
+ if (pImage->iMAGN_MethodY == 1)
+ {
+ iNewH = pImage->iMAGN_MT;
+ if (pBuf->iHeight > 1)
+ iNewH = iNewH + pImage->iMAGN_ML;
+ if (pBuf->iHeight > 2)
+ iNewH = iNewH + (pBuf->iHeight - 2) * (pImage->iMAGN_MY);
+ }
+ else
+ {
+ iNewH = pBuf->iHeight + pImage->iMAGN_MT - 1;
+ if (pBuf->iHeight > 2)
+ iNewH = iNewH + pImage->iMAGN_MB - 1;
+ if (pBuf->iHeight > 3)
+ iNewH = iNewH + (pBuf->iHeight - 3) * (pImage->iMAGN_MY - 1);
+ }
+ }
+ /* get new buffer */
+ iNewrowsize = iNewW * pBuf->iSamplesize;
+ iNewsize = iNewH * iNewrowsize;
+
+ MNG_ALLOC (pData, pNewdata, iNewsize);
+
+ switch (pBuf->iColortype) /* determine magnification routines */
+ {
+#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
+ case 0 : ;
+ case 8 : {
+ if (pBuf->iBitdepth <= 8)
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_g8_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_g8_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_g8_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_g8_x2; break; }
+ case 5 : { fMagnifyX = mng_magnify_g8_x3; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_g8_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_g8_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_g8_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_g8_y2; break; }
+ case 5 : { fMagnifyY = mng_magnify_g8_y3; break; }
+ }
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_g16_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_g16_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_g16_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_g16_x2; break; }
+ case 5 : { fMagnifyX = mng_magnify_g16_x3; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_g16_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_g16_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_g16_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_g16_y2; break; }
+ case 5 : { fMagnifyY = mng_magnify_g16_y3; break; }
+ }
+ }
+#endif
+
+ break;
+ }
+
+ case 2 : ;
+ case 10 : {
+ if (pBuf->iBitdepth <= 8)
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_rgb8_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_rgb8_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_rgb8_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_rgb8_x2; break; }
+ case 5 : { fMagnifyX = mng_magnify_rgb8_x3; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_rgb8_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_rgb8_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_rgb8_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_rgb8_y2; break; }
+ case 5 : { fMagnifyY = mng_magnify_rgb8_y3; break; }
+ }
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_rgb16_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_rgb16_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_rgb16_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_rgb16_x2; break; }
+ case 5 : { fMagnifyX = mng_magnify_rgb16_x3; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_rgb16_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_rgb16_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_rgb16_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_rgb16_y2; break; }
+ case 5 : { fMagnifyY = mng_magnify_rgb16_y3; break; }
+ }
+ }
+#endif
+
+ break;
+ }
+
+ case 4 : ;
+ case 12 : {
+ if (pBuf->iBitdepth <= 8)
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_ga8_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_ga8_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_ga8_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_ga8_x4; break; }
+ case 5 : { fMagnifyX = mng_magnify_ga8_x5; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_ga8_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_ga8_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_ga8_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_ga8_y4; break; }
+ case 5 : { fMagnifyY = mng_magnify_ga8_y5; break; }
+ }
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+ else
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_ga16_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_ga16_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_ga16_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_ga16_x4; break; }
+ case 5 : { fMagnifyX = mng_magnify_ga16_x5; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_ga16_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_ga16_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_ga16_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_ga16_y4; break; }
+ case 5 : { fMagnifyY = mng_magnify_ga16_y5; break; }
+ }
+ }
+#endif
+
+ break;
+ }
+#endif
+
+ case 6 : ;
+ case 14 : {
+ if (pBuf->iBitdepth <= 8)
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_rgba8_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_rgba8_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_rgba8_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_rgba8_x4; break; }
+ case 5 : { fMagnifyX = mng_magnify_rgba8_x5; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_rgba8_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_rgba8_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_rgba8_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_rgba8_y4; break; }
+ case 5 : { fMagnifyY = mng_magnify_rgba8_y5; break; }
+ }
+ }
+#ifndef MNG_NO_16BIT_SUPPORT
+#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
+ else
+ {
+ switch (pImage->iMAGN_MethodX)
+ {
+ case 1 : { fMagnifyX = mng_magnify_rgba16_x1; break; }
+ case 2 : { fMagnifyX = mng_magnify_rgba16_x2; break; }
+ case 3 : { fMagnifyX = mng_magnify_rgba16_x3; break; }
+ case 4 : { fMagnifyX = mng_magnify_rgba16_x4; break; }
+ case 5 : { fMagnifyX = mng_magnify_rgba16_x5; break; }
+ }
+
+ switch (pImage->iMAGN_MethodY)
+ {
+ case 1 : { fMagnifyY = mng_magnify_rgba16_y1; break; }
+ case 2 : { fMagnifyY = mng_magnify_rgba16_y2; break; }
+ case 3 : { fMagnifyY = mng_magnify_rgba16_y3; break; }
+ case 4 : { fMagnifyY = mng_magnify_rgba16_y4; break; }
+ case 5 : { fMagnifyY = mng_magnify_rgba16_y5; break; }
+ }
+ }
+#endif
+#endif
+ break;
+ }
+ }
+
+ pSrcline1 = pBuf->pImgdata; /* initialize row-loop variables */
+ pDstline = pNewdata;
+ /* allocate temporary row */
+ MNG_ALLOC (pData, pTempline, iNewrowsize);
+
+ for (iY = 0; iY < pBuf->iHeight; iY++)
+ {
+ pSrcline2 = pSrcline1 + pBuf->iRowsize;
+
+ if (fMagnifyX) /* magnifying in X-direction ? */
+ {
+ iRetcode = fMagnifyX (pData, pImage->iMAGN_MX,
+ pImage->iMAGN_ML, pImage->iMAGN_MR,
+ pBuf->iWidth, pSrcline1, pDstline);
+
+ if (iRetcode) /* on error bail out */
+ {
+ MNG_FREEX (pData, pTempline, iNewrowsize);
+ MNG_FREEX (pData, pNewdata, iNewsize);
+ return iRetcode;
+ }
+ }
+ else
+ {
+ MNG_COPY (pDstline, pSrcline1, iNewrowsize);
+ }
+
+ pDstline += iNewrowsize;
+ /* magnifying in Y-direction ? */
+ if ((fMagnifyY) &&
+ ((iY < pBuf->iHeight - 1) || (pBuf->iHeight == 1) || (pImage->iMAGN_MethodY == 1)))
+ {
+ if (iY == 0) /* first interval ? */
+ {
+ if (pBuf->iHeight == 1) /* single row ? */
+ pSrcline2 = MNG_NULL;
+
+ iM = (mng_int32)pImage->iMAGN_MT;
+ }
+ else /* last interval ? */
+ if (((pImage->iMAGN_MethodY == 1) && (iY == (pBuf->iHeight - 1))) ||
+ ((pImage->iMAGN_MethodY != 1) && (iY == (pBuf->iHeight - 2))) )
+ iM = (mng_int32)pImage->iMAGN_MB;
+ else /* middle interval */
+ iM = (mng_int32)pImage->iMAGN_MY;
+
+ for (iS = 1; iS < iM; iS++)
+ {
+ iRetcode = fMagnifyY (pData, iS, iM, pBuf->iWidth,
+ pSrcline1, pSrcline2, pTempline);
+
+ if (iRetcode) /* on error bail out */
+ {
+ MNG_FREEX (pData, pTempline, iNewrowsize);
+ MNG_FREEX (pData, pNewdata, iNewsize);
+ return iRetcode;
+ }
+
+ if (fMagnifyX) /* magnifying in X-direction ? */
+ {
+ iRetcode = fMagnifyX (pData, pImage->iMAGN_MX,
+ pImage->iMAGN_ML, pImage->iMAGN_MR,
+ pBuf->iWidth, pTempline, pDstline);
+
+ if (iRetcode) /* on error bail out */
+ {
+ MNG_FREEX (pData, pTempline, iNewrowsize);
+ MNG_FREEX (pData, pNewdata, iNewsize);
+ return iRetcode;
+ }
+ }
+ else
+ {
+ MNG_COPY (pDstline, pTempline, iNewrowsize);
+ }
+
+ pDstline += iNewrowsize;
+ }
+ }
+
+ pSrcline1 += pBuf->iRowsize;
+ }
+ /* drop temporary row */
+ MNG_FREEX (pData, pTempline, iNewrowsize);
+ /* drop old pixel-data */
+ MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+
+ pBuf->pImgdata = pNewdata; /* save new buffer dimensions */
+ pBuf->iRowsize = iNewrowsize;
+ pBuf->iImgdatasize = iNewsize;
+ pBuf->iWidth = iNewW;
+ pBuf->iHeight = iNewH;
+
+ if (pImage->iId) /* real object ? */
+ {
+ pImage->iMAGN_MethodX = 0; /* it's done; don't do it again !!! */
+ pImage->iMAGN_MethodY = 0;
+ pImage->iMAGN_MX = 0;
+ pImage->iMAGN_MY = 0;
+ pImage->iMAGN_ML = 0;
+ pImage->iMAGN_MR = 0;
+ pImage->iMAGN_MT = 0;
+ pImage->iMAGN_MB = 0;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_MAGNIFY_IMGOBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_colorcorrect_object (mng_datap pData,
+ mng_imagep pImage)
+{
+ mng_imagedatap pBuf = pImage->pImgbuf;
+ mng_retcode iRetcode;
+ mng_uint32 iY;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_COLORCORRECT_OBJECT, MNG_LC_START);
+#endif
+
+#ifdef MNG_INCLUDE_JNG
+ if ((pBuf->iBitdepth < 8) || /* we need 8- or 16-bit RGBA !!! */
+ ((pBuf->iColortype != MNG_COLORTYPE_RGBA ) &&
+ (pBuf->iColortype != MNG_COLORTYPE_JPEGCOLORA) ))
+#else
+ if (pBuf->iBitdepth < 8) /* we need 8- or 16-bit RGBA !!! */
+#endif
+ MNG_ERROR (pData, MNG_OBJNOTABSTRACT);
+
+ if (!pBuf->bCorrected) /* only if not already done ! */
+ { /* so the row routines now to find it */
+ pData->pRetrieveobj = (mng_objectp)pImage;
+ pData->pStoreobj = (mng_objectp)pImage;
+ pData->pStorebuf = (mng_objectp)pImage->pImgbuf;
+
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth > 8)
+ {
+ pData->fRetrieverow = (mng_fptr)mng_retrieve_rgba16;
+ pData->fStorerow = (mng_fptr)mng_store_rgba16;
+ }
+ else
+#endif
+ {
+ pData->fRetrieverow = (mng_fptr)mng_retrieve_rgba8;
+ pData->fStorerow = (mng_fptr)mng_store_rgba8;
+ }
+
+ pData->bIsOpaque = MNG_FALSE;
+
+ pData->iPass = -1; /* these are the object's dimensions now */
+ pData->iRow = 0;
+ pData->iRowinc = 1;
+ pData->iCol = 0;
+ pData->iColinc = 1;
+ pData->iRowsamples = pBuf->iWidth;
+ pData->iRowsize = pData->iRowsamples << 2;
+ pData->iPixelofs = 0;
+ pData->bIsRGBA16 = MNG_FALSE;
+ /* adjust for 16-bit object ? */
+#ifndef MNG_NO_16BIT_SUPPORT
+ if (pBuf->iBitdepth > 8)
+ {
+ pData->bIsRGBA16 = MNG_TRUE;
+ pData->iRowsize = pData->iRowsamples << 3;
+ }
+#endif
+
+ pData->fCorrectrow = MNG_NULL; /* default no color-correction */
+
+#ifdef MNG_NO_CMS
+ iRetcode = MNG_NOERROR;
+#else
+#if defined(MNG_FULL_CMS) /* determine color-management routine */
+ iRetcode = mng_init_full_cms (pData, MNG_FALSE, MNG_FALSE, MNG_TRUE);
+#elif defined(MNG_GAMMA_ONLY)
+ iRetcode = mng_init_gamma_only (pData, MNG_FALSE, MNG_FALSE, MNG_TRUE);
+#elif defined(MNG_APP_CMS)
+ iRetcode = mng_init_app_cms (pData, MNG_FALSE, MNG_FALSE, MNG_TRUE);
+#endif
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+#endif /* MNG_NO_CMS */
+
+ if (pData->fCorrectrow) /* really correct something ? */
+ { /* get a temporary row-buffer */
+ MNG_ALLOC (pData, pData->pRGBArow, pData->iRowsize);
+
+ pData->pWorkrow = pData->pRGBArow;
+ iY = 0; /* start from the top */
+
+ while ((!iRetcode) && (iY < pBuf->iHeight))
+ { /* get a row */
+ iRetcode = ((mng_retrieverow)pData->fRetrieverow) (pData);
+
+ if (!iRetcode) /* color correct it */
+ iRetcode = ((mng_correctrow)pData->fCorrectrow) (pData);
+
+ if (!iRetcode) /* store it back ! */
+ iRetcode = ((mng_storerow)pData->fStorerow) (pData);
+
+ if (!iRetcode) /* adjust variables for next row */
+ iRetcode = mng_next_row (pData);
+
+ iY++; /* and next line */
+ }
+ /* drop the temporary row-buffer */
+ MNG_FREEX (pData, pData->pRGBArow, pData->iRowsize);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+#if defined(MNG_FULL_CMS) /* cleanup cms stuff */
+ iRetcode = mng_clear_cms (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+#endif
+ }
+
+ pBuf->bCorrected = MNG_TRUE; /* let's not go through that again ! */
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_COLORCORRECT_OBJECT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+/* * * */
+/* * Animation-object routines * */
+/* * * */
+/* * these handle the animation objects used to re-run parts of a MNG. * */
+/* * eg. during LOOP or TERM processing * */
+/* * * */
+/* ************************************************************************** */
+
+void mng_add_ani_object (mng_datap pData,
+ mng_object_headerp pObject)
+{
+ mng_object_headerp pLast = (mng_object_headerp)pData->pLastaniobj;
+
+ if (pLast) /* link it as last in the chain */
+ {
+ pObject->pPrev = pLast;
+ pLast->pNext = pObject;
+ }
+ else
+ {
+ pObject->pPrev = MNG_NULL; /* be on the safe side */
+ pData->pFirstaniobj = pObject;
+ }
+
+ pObject->pNext = MNG_NULL; /* be on the safe side */
+ pData->pLastaniobj = pObject;
+ /* keep track for jumping */
+ pObject->iFramenr = pData->iFrameseq;
+ pObject->iLayernr = pData->iLayerseq;
+ pObject->iPlaytime = pData->iFrametime;
+ /* save restart object ? */
+ if ((pData->bDisplaying) && (!pData->bRunning) && (!pData->pCurraniobj))
+ pData->pCurraniobj = pObject;
+
+ return;
+}
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+mng_retcode mng_create_ani_image (mng_datap pData)
+{
+ mng_ani_imagep pImage;
+ mng_imagep pCurrent;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_IMAGE, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifndef MNG_NO_DELTA_PNG
+ if (pData->bHasDHDR) /* processing delta-image ? */
+ pCurrent = (mng_imagep)pData->pObjzero;
+ else /* get the current object */
+#endif
+ pCurrent = (mng_imagep)pData->pCurrentobj;
+
+ if (!pCurrent) /* otherwise object 0 */
+ pCurrent = (mng_imagep)pData->pObjzero;
+ /* now just clone the object !!! */
+ iRetcode = mng_clone_imageobject (pData, 0, MNG_FALSE, pCurrent->bVisible,
+ MNG_FALSE, MNG_FALSE, 0, 0, 0, pCurrent,
+ &pImage);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+ pImage->sHeader.fCleanup = mng_free_ani_image;
+ pImage->sHeader.fProcess = mng_process_ani_image;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pImage);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_IMAGE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR; /* okido */
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_ani_image (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_imagep pImage = (mng_ani_imagep)pObject;
+ mng_imagedatap pImgbuf = pImage->pImgbuf;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_IMAGE, MNG_LC_START);
+#endif
+ /* unlink the image-data buffer */
+ iRetcode = mng_free_imagedataobject (pData, pImgbuf);
+ /* drop its own buffer */
+ MNG_FREEX (pData, pImage, sizeof (mng_ani_image));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_IMAGE, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_image (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode = MNG_NOERROR;
+ mng_ani_imagep pImage = (mng_imagep)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IMAGE, MNG_LC_START);
+#endif
+
+#ifndef MNG_NO_DELTA_PNG
+ if (pData->bHasDHDR) /* processing delta-image ? */
+ {
+ mng_imagep pDelta = (mng_imagep)pData->pDeltaImage;
+
+ if (!pData->iBreakpoint) /* only execute if not broken before */
+ { /* make sure to process pixels as well */
+ pData->bDeltaimmediate = MNG_FALSE;
+ /* execute the delta process */
+ iRetcode = mng_execute_delta_image (pData, pDelta, (mng_imagep)pObject);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+ }
+ /* now go and shoot it off (if required) */
+ if ((pDelta->bVisible) && (pDelta->bViewable))
+ iRetcode = mng_display_image (pData, pDelta, MNG_FALSE);
+
+ if (!pData->bTimerset)
+ pData->bHasDHDR = MNG_FALSE; /* this image signifies IEND !! */
+
+ }
+ else
+#endif
+ if (pData->pCurrentobj) /* active object ? */
+ {
+ mng_imagep pCurrent = (mng_imagep)pData->pCurrentobj;
+ mng_imagedatap pBuf = pCurrent->pImgbuf;
+
+ if (!pData->iBreakpoint) /* don't copy it again ! */
+ {
+ if (pBuf->iImgdatasize) /* buffer present in active object ? */
+ /* then drop it */
+ MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pBuf->iProfilesize) /* iCCP profile present ? */
+ /* then drop it */
+ MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize);
+#endif
+ /* now blatently copy the animation buffer */
+ MNG_COPY (pBuf, pImage->pImgbuf, sizeof (mng_imagedata));
+ /* copy viewability */
+ pCurrent->bViewable = pImage->bViewable;
+
+ if (pBuf->iImgdatasize) /* sample buffer present ? */
+ { /* then make a copy */
+ MNG_ALLOC (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+ MNG_COPY (pBuf->pImgdata, pImage->pImgbuf->pImgdata, pBuf->iImgdatasize);
+ }
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pBuf->iProfilesize) /* iCCP profile present ? */
+ { /* then make a copy */
+ MNG_ALLOC (pData, pBuf->pProfile, pBuf->iProfilesize);
+ MNG_COPY (pBuf->pProfile, pImage->pImgbuf->pProfile, pBuf->iProfilesize);
+ }
+#endif
+ }
+ /* now go and shoot it off (if required) */
+ if ((pCurrent->bVisible) && (pCurrent->bViewable))
+ iRetcode = mng_display_image (pData, pCurrent, MNG_FALSE);
+ }
+ else
+ {
+ mng_imagep pObjzero = (mng_imagep)pData->pObjzero;
+ mng_imagedatap pBuf = pObjzero->pImgbuf;
+
+ if (!pData->iBreakpoint) /* don't copy it again ! */
+ {
+ if (pBuf->iImgdatasize) /* buffer present in active object ? */
+ /* then drop it */
+ MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pBuf->iProfilesize) /* iCCP profile present ? */
+ /* then drop it */
+ MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize);
+#endif
+ /* now blatently copy the animation buffer */
+ MNG_COPY (pBuf, pImage->pImgbuf, sizeof (mng_imagedata));
+ /* copy viewability */
+ pObjzero->bViewable = pImage->bViewable;
+
+ if (pBuf->iImgdatasize) /* sample buffer present ? */
+ { /* then make a copy */
+ MNG_ALLOC (pData, pBuf->pImgdata, pBuf->iImgdatasize);
+ MNG_COPY (pBuf->pImgdata, pImage->pImgbuf->pImgdata, pBuf->iImgdatasize);
+ }
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ if (pBuf->iProfilesize) /* iCCP profile present ? */
+ { /* then make a copy */
+ MNG_ALLOC (pData, pBuf->pProfile, pBuf->iProfilesize);
+ MNG_COPY (pBuf->pProfile, pImage->pImgbuf->pProfile, pBuf->iProfilesize);
+ }
+#endif
+ }
+ /* now go and show it */
+ iRetcode = mng_display_image (pData, pObjzero, MNG_FALSE);
+ }
+
+ if (!iRetcode) /* all's well ? */
+ {
+ if (pData->bTimerset) /* timer break ? */
+ pData->iBreakpoint = 99; /* fictive number; no more processing needed! */
+ else
+ pData->iBreakpoint = 0; /* else clear it */
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IMAGE, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_plte (mng_datap pData,
+ mng_uint32 iEntrycount,
+ mng_palette8ep paEntries)
+#else
+mng_retcode mng_create_ani_plte (mng_datap pData)
+#endif
+{
+ mng_ani_pltep pPLTE;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PLTE, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_plte),
+ mng_free_obj_general,
+ mng_process_ani_plte,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pPLTE = (mng_ani_pltep)pTemp;
+#else
+ MNG_ALLOC (pData, pPLTE, sizeof (mng_ani_plte));
+
+ pPLTE->sHeader.fCleanup = mng_free_ani_plte;
+ pPLTE->sHeader.fProcess = mng_process_ani_plte;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pPLTE);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pPLTE->iEntrycount = iEntrycount;
+ MNG_COPY (pPLTE->aEntries, paEntries, sizeof (pPLTE->aEntries));
+#else
+ pPLTE->iEntrycount = pData->iGlobalPLTEcount;
+ MNG_COPY (pPLTE->aEntries, pData->aGlobalPLTEentries, sizeof (pPLTE->aEntries));
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PLTE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_plte (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PLTE, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_plte));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PLTE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_plte (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_pltep pPLTE = (mng_ani_pltep)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PLTE, MNG_LC_START);
+#endif
+
+ pData->bHasglobalPLTE = MNG_TRUE;
+ pData->iGlobalPLTEcount = pPLTE->iEntrycount;
+
+ MNG_COPY (pData->aGlobalPLTEentries, pPLTE->aEntries, sizeof (pPLTE->aEntries));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PLTE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_trns (mng_datap pData,
+ mng_uint32 iRawlen,
+ mng_uint8p pRawdata)
+#else
+mng_retcode mng_create_ani_trns (mng_datap pData)
+#endif
+{
+ mng_ani_trnsp pTRNS;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_TRNS, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_trns),
+ mng_free_obj_general,
+ mng_process_ani_trns,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pTRNS = (mng_ani_trnsp)pTemp;
+#else
+ MNG_ALLOC (pData, pTRNS, sizeof (mng_ani_trns));
+
+ pTRNS->sHeader.fCleanup = mng_free_ani_trns;
+ pTRNS->sHeader.fProcess = mng_process_ani_trns;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pTRNS);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pTRNS->iRawlen = iRawlen;
+ MNG_COPY (pTRNS->aRawdata, pRawdata, sizeof (pTRNS->aRawdata));
+#else
+ pTRNS->iRawlen = pData->iGlobalTRNSrawlen;
+ MNG_COPY (pTRNS->aRawdata, pData->aGlobalTRNSrawdata, sizeof (pTRNS->aRawdata));
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_TRNS, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_trns (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_TRNS, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_trns));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_TRNS, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_trns (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_trnsp pTRNS = (mng_ani_trnsp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TRNS, MNG_LC_START);
+#endif
+
+ pData->bHasglobalTRNS = MNG_TRUE;
+ pData->iGlobalTRNSrawlen = pTRNS->iRawlen;
+
+ MNG_COPY (pData->aGlobalTRNSrawdata, pTRNS->aRawdata, sizeof (pTRNS->aRawdata));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TRNS, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_gAMA
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_gama (mng_datap pData,
+ mng_bool bEmpty,
+ mng_uint32 iGamma)
+#else
+mng_retcode mng_create_ani_gama (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_gamap pGAMA;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_GAMA, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_gama),
+ mng_free_obj_general,
+ mng_process_ani_gama,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pGAMA = (mng_ani_gamap)pTemp;
+#else
+ MNG_ALLOC (pData, pGAMA, sizeof (mng_ani_gama));
+
+ pGAMA->sHeader.fCleanup = mng_free_ani_gama;
+ pGAMA->sHeader.fProcess = mng_process_ani_gama;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pGAMA);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pGAMA->bEmpty = bEmpty;
+ pGAMA->iGamma = iGamma;
+#else
+ pGAMA->bEmpty = ((mng_gamap)pChunk)->bEmpty;
+ pGAMA->iGamma = ((mng_gamap)pChunk)->iGamma;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_GAMA, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_gama (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_GAMA, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_gama));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_GAMA, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_gama (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_gamap pGAMA = (mng_ani_gamap)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_GAMA, MNG_LC_START);
+#endif
+
+ if (pGAMA->bEmpty) /* empty chunk ? */
+ { /* clear global gAMA */
+ pData->bHasglobalGAMA = MNG_FALSE;
+ pData->iGlobalGamma = 0;
+ }
+ else
+ { /* set global gAMA */
+ pData->bHasglobalGAMA = MNG_TRUE;
+ pData->iGlobalGamma = pGAMA->iGamma;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_GAMA, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_cHRM
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_chrm (mng_datap pData,
+ mng_bool bEmpty,
+ mng_uint32 iWhitepointx,
+ mng_uint32 iWhitepointy,
+ mng_uint32 iRedx,
+ mng_uint32 iRedy,
+ mng_uint32 iGreenx,
+ mng_uint32 iGreeny,
+ mng_uint32 iBluex,
+ mng_uint32 iBluey)
+#else
+mng_retcode mng_create_ani_chrm (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ptr pTemp;
+ mng_ani_chrmp pCHRM;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_CHRM, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_chrm),
+ mng_free_obj_general,
+ mng_process_ani_chrm,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pCHRM = (mng_ani_chrmp)pTemp;
+#else
+ MNG_ALLOC (pData, pCHRM, sizeof (mng_ani_chrm));
+
+ pCHRM->sHeader.fCleanup = mng_free_ani_chrm;
+ pCHRM->sHeader.fProcess = mng_process_ani_chrm;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pCHRM);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pCHRM->bEmpty = bEmpty;
+ pCHRM->iWhitepointx = iWhitepointx;
+ pCHRM->iWhitepointy = iWhitepointy;
+ pCHRM->iRedx = iRedx;
+ pCHRM->iRedy = iRedy;
+ pCHRM->iGreenx = iGreenx;
+ pCHRM->iGreeny = iGreeny;
+ pCHRM->iBluex = iBluex;
+ pCHRM->iBluey = iBluey;
+#else
+ pCHRM->bEmpty = ((mng_chrmp)pChunk)->bEmpty;
+ pCHRM->iWhitepointx = ((mng_chrmp)pChunk)->iWhitepointx;
+ pCHRM->iWhitepointy = ((mng_chrmp)pChunk)->iWhitepointy;
+ pCHRM->iRedx = ((mng_chrmp)pChunk)->iRedx;
+ pCHRM->iRedy = ((mng_chrmp)pChunk)->iRedy;
+ pCHRM->iGreenx = ((mng_chrmp)pChunk)->iGreenx;
+ pCHRM->iGreeny = ((mng_chrmp)pChunk)->iGreeny;
+ pCHRM->iBluex = ((mng_chrmp)pChunk)->iBluex;
+ pCHRM->iBluey = ((mng_chrmp)pChunk)->iBluey;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_CHRM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_chrm (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_CHRM, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_chrm));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_CHRM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_chrm (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_chrmp pCHRM = (mng_ani_chrmp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CHRM, MNG_LC_START);
+#endif
+
+ if (pCHRM->bEmpty) /* empty chunk ? */
+ { /* clear global cHRM */
+ pData->bHasglobalCHRM = MNG_FALSE;
+ pData->iGlobalWhitepointx = 0;
+ pData->iGlobalWhitepointy = 0;
+ pData->iGlobalPrimaryredx = 0;
+ pData->iGlobalPrimaryredy = 0;
+ pData->iGlobalPrimarygreenx = 0;
+ pData->iGlobalPrimarygreeny = 0;
+ pData->iGlobalPrimarybluex = 0;
+ pData->iGlobalPrimarybluey = 0;
+ }
+ else
+ { /* set global cHRM */
+ pData->bHasglobalCHRM = MNG_TRUE;
+ pData->iGlobalWhitepointx = pCHRM->iWhitepointx;
+ pData->iGlobalWhitepointy = pCHRM->iWhitepointy;
+ pData->iGlobalPrimaryredx = pCHRM->iRedx;
+ pData->iGlobalPrimaryredy = pCHRM->iRedy;
+ pData->iGlobalPrimarygreenx = pCHRM->iGreenx;
+ pData->iGlobalPrimarygreeny = pCHRM->iGreeny;
+ pData->iGlobalPrimarybluex = pCHRM->iBluex;
+ pData->iGlobalPrimarybluey = pCHRM->iBluey;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CHRM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_sRGB
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_srgb (mng_datap pData,
+ mng_bool bEmpty,
+ mng_uint8 iRenderingintent)
+#else
+mng_retcode mng_create_ani_srgb (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_srgbp pSRGB;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SRGB, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_srgb),
+ mng_free_obj_general,
+ mng_process_ani_srgb,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pSRGB = (mng_ani_srgbp)pTemp;
+#else
+ MNG_ALLOC (pData, pSRGB, sizeof (mng_ani_srgb));
+
+ pSRGB->sHeader.fCleanup = mng_free_ani_srgb;
+ pSRGB->sHeader.fProcess = mng_process_ani_srgb;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pSRGB);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pSRGB->bEmpty = bEmpty;
+ pSRGB->iRenderingintent = iRenderingintent;
+#else
+ pSRGB->bEmpty = ((mng_srgbp)pChunk)->bEmpty;
+ pSRGB->iRenderingintent = ((mng_srgbp)pChunk)->iRenderingintent;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SRGB, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_srgb (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SRGB, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_srgb));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SRGB, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_srgb (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_srgbp pSRGB = (mng_ani_srgbp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SRGB, MNG_LC_START);
+#endif
+
+ if (pSRGB->bEmpty) /* empty chunk ? */
+ { /* clear global sRGB */
+ pData->bHasglobalSRGB = MNG_FALSE;
+ pData->iGlobalRendintent = 0;
+ }
+ else
+ { /* set global sRGB */
+ pData->bHasglobalSRGB = MNG_TRUE;
+ pData->iGlobalRendintent = pSRGB->iRenderingintent;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SRGB, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_iCCP
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_iccp (mng_datap pData,
+ mng_bool bEmpty,
+ mng_uint32 iProfilesize,
+ mng_ptr pProfile)
+#else
+mng_retcode mng_create_ani_iccp (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ptr pTemp;
+ mng_ani_iccpp pICCP;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_ICCP, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_iccp),
+ mng_free_ani_iccp,
+ mng_process_ani_iccp,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pICCP = (mng_ani_iccpp)pTemp;
+#else
+ MNG_ALLOC (pData, pICCP, sizeof (mng_ani_iccp));
+
+ pICCP->sHeader.fCleanup = mng_free_ani_iccp;
+ pICCP->sHeader.fProcess = mng_process_ani_iccp;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pICCP);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pICCP->bEmpty = bEmpty;
+ pICCP->iProfilesize = iProfilesize;
+
+ if (iProfilesize)
+ {
+ MNG_ALLOC (pData, pICCP->pProfile, iProfilesize);
+ MNG_COPY (pICCP->pProfile, pProfile, iProfilesize);
+ }
+#else
+ pICCP->bEmpty = ((mng_iccpp)pChunk)->bEmpty;
+ pICCP->iProfilesize = ((mng_iccpp)pChunk)->iProfilesize;
+
+ if (pICCP->iProfilesize)
+ {
+ MNG_ALLOC (pData, pICCP->pProfile, pICCP->iProfilesize);
+ MNG_COPY (pICCP->pProfile, ((mng_iccpp)pChunk)->pProfile, pICCP->iProfilesize);
+ }
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_ICCP, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_ani_iccp (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_iccpp pICCP = (mng_ani_iccpp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_ICCP, MNG_LC_START);
+#endif
+
+ if (pICCP->iProfilesize)
+ MNG_FREEX (pData, pICCP->pProfile, pICCP->iProfilesize);
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_iccp));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_ICCP, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_iccp (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_iccpp pICCP = (mng_ani_iccpp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ICCP, MNG_LC_START);
+#endif
+
+ if (pICCP->bEmpty) /* empty chunk ? */
+ { /* clear global iCCP */
+ pData->bHasglobalICCP = MNG_FALSE;
+
+ if (pData->iGlobalProfilesize)
+ MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize);
+
+ pData->iGlobalProfilesize = 0;
+ pData->pGlobalProfile = MNG_NULL;
+ }
+ else
+ { /* set global iCCP */
+ pData->bHasglobalICCP = MNG_TRUE;
+ pData->iGlobalProfilesize = pICCP->iProfilesize;
+
+ if (pICCP->iProfilesize)
+ {
+ MNG_ALLOC (pData, pData->pGlobalProfile, pICCP->iProfilesize);
+ MNG_COPY (pData->pGlobalProfile, pICCP->pProfile, pICCP->iProfilesize);
+ }
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ICCP, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_bKGD
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_bkgd (mng_datap pData,
+ mng_uint16 iRed,
+ mng_uint16 iGreen,
+ mng_uint16 iBlue)
+#else
+mng_retcode mng_create_ani_bkgd (mng_datap pData)
+#endif
+{
+ mng_ptr pTemp;
+ mng_ani_bkgdp pBKGD;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_BKGD, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_bkgd),
+ mng_free_obj_general,
+ mng_process_ani_bkgd,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pBKGD = (mng_ani_bkgdp)pTemp;
+#else
+ MNG_ALLOC (pData, pBKGD, sizeof (mng_ani_bkgd));
+
+ pBKGD->sHeader.fCleanup = mng_free_ani_bkgd;
+ pBKGD->sHeader.fProcess = mng_process_ani_bkgd;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pBKGD);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pBKGD->iRed = iRed;
+ pBKGD->iGreen = iGreen;
+ pBKGD->iBlue = iBlue;
+#else
+ pBKGD->iRed = pData->iGlobalBKGDred;
+ pBKGD->iGreen = pData->iGlobalBKGDgreen;
+ pBKGD->iBlue = pData->iGlobalBKGDblue;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_BKGD, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_bkgd (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_BKGD, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_bkgd));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_BKGD, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_bkgd (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_bkgdp pBKGD = (mng_ani_bkgdp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BKGD, MNG_LC_START);
+#endif
+
+ pData->bHasglobalBKGD = MNG_TRUE;
+ pData->iGlobalBKGDred = pBKGD->iRed;
+ pData->iGlobalBKGDgreen = pBKGD->iGreen;
+ pData->iGlobalBKGDblue = pBKGD->iBlue;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BKGD, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_LOOP
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_loop (mng_datap pData,
+ mng_uint8 iLevel,
+ mng_uint32 iRepeatcount,
+ mng_uint8 iTermcond,
+ mng_uint32 iItermin,
+ mng_uint32 iItermax,
+ mng_uint32 iCount,
+ mng_uint32p pSignals)
+#else
+mng_retcode mng_create_ani_loop (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_loopp pLOOP;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_LOOP, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
+ mng_free_ani_loop,
+ mng_process_ani_loop,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pLOOP = (mng_ani_loopp)pTemp;
+#else
+ MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
+
+ pLOOP->sHeader.fCleanup = mng_free_ani_loop;
+ pLOOP->sHeader.fProcess = mng_process_ani_loop;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pLOOP->iLevel = iLevel;
+ pLOOP->iRepeatcount = iRepeatcount;
+ pLOOP->iTermcond = iTermcond;
+ pLOOP->iItermin = iItermin;
+ pLOOP->iItermax = iItermax;
+ pLOOP->iCount = iCount;
+
+#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
+ if (iCount)
+ {
+ MNG_ALLOC (pData, pLOOP->pSignals, (iCount << 1));
+ MNG_COPY (pLOOP->pSignals, pSignals, (iCount << 1));
+ }
+#endif
+#else /* MNG_OPTIMIZE_CHUNKREADER */
+ pLOOP->iLevel = ((mng_loopp)pChunk)->iLevel;
+ pLOOP->iRepeatcount = ((mng_loopp)pChunk)->iRepeat;
+ pLOOP->iTermcond = ((mng_loopp)pChunk)->iTermination;
+ pLOOP->iItermin = ((mng_loopp)pChunk)->iItermin;
+ pLOOP->iItermax = ((mng_loopp)pChunk)->iItermax;
+ pLOOP->iCount = ((mng_loopp)pChunk)->iCount;
+
+#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
+ if (pLOOP->iCount)
+ {
+ MNG_ALLOC (pData, pLOOP->pSignals, (pLOOP->iCount << 1));
+ MNG_COPY (pLOOP->pSignals, ((mng_loopp)pChunk)->pSignals, (pLOOP->iCount << 1));
+ }
+#endif
+#endif /* MNG_OPTIMIZE_CHUNKREADER */
+ /* running counter starts with repeat_count */
+ pLOOP->iRunningcount = pLOOP->iRepeatcount;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_LOOP, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_ani_loop (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
+ mng_ani_loopp pLOOP = (mng_ani_loopp)pObject;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_LOOP, MNG_LC_START);
+#endif
+
+#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
+ if (pLOOP->iCount) /* drop signal buffer ? */
+ MNG_FREEX (pData, pLOOP->pSignals, (pLOOP->iCount << 1));
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_loop));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_LOOP, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_loop (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_loopp pLOOP = (mng_ani_loopp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_LOOP, MNG_LC_START);
+#endif
+ /* just reset the running counter */
+ pLOOP->iRunningcount = pLOOP->iRepeatcount;
+ /* iteration=0 means we're skipping ! */
+ if ((!pData->bSkipping) && (pLOOP->iRepeatcount == 0))
+ pData->bSkipping = MNG_TRUE;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_LOOP, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+mng_retcode mng_create_ani_endl (mng_datap pData,
+ mng_uint8 iLevel)
+{
+ mng_ani_endlp pENDL;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_ENDL, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+ mng_retcode iRetcode;
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
+ mng_free_obj_general,
+ mng_process_ani_endl,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pENDL = (mng_ani_endlp)pTemp;
+#else
+ MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
+
+ pENDL->sHeader.fCleanup = mng_free_ani_endl;
+ pENDL->sHeader.fProcess = mng_process_ani_endl;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pENDL);
+
+ pENDL->iLevel = iLevel;
+
+ iRetcode = mng_process_ani_endl (pData, (mng_objectp)pENDL);
+ if (iRetcode)
+ return iRetcode;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_ENDL, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_endl (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_ENDL, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_endl));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_ENDL, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_endl (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_endlp pENDL = (mng_ani_endlp)pObject;
+ mng_ani_loopp pLOOP;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ENDL, MNG_LC_START);
+#endif
+
+ if (((pData->bDisplaying) && ((pData->bRunning) || (pData->bSearching))) ||
+ (pData->bReading) )
+ {
+ pLOOP = pENDL->pLOOP; /* determine matching LOOP */
+
+ if (!pLOOP) /* haven't got it yet ? */
+ { /* go and look back in the list */
+ pLOOP = (mng_ani_loopp)pENDL->sHeader.pPrev;
+
+ while ((pLOOP) &&
+ ((pLOOP->sHeader.fCleanup != mng_free_ani_loop) ||
+ (pLOOP->iLevel != pENDL->iLevel) ))
+ pLOOP = pLOOP->sHeader.pPrev;
+ }
+ /* got it now ? */
+ if ((pLOOP) && (pLOOP->iLevel == pENDL->iLevel))
+ {
+ pENDL->pLOOP = pLOOP; /* save for next time ! */
+ /* decrease running counter ? */
+ if ((pLOOP->iRunningcount) && (pLOOP->iRunningcount < 0x7fffffffL))
+ pLOOP->iRunningcount--;
+
+ if ((!pData->bDisplaying) && (pData->bReading) &&
+ (pLOOP->iRunningcount >= 0x7fffffffL))
+ {
+ pData->iTotalframes = 0x7fffffffL;
+ pData->iTotallayers = 0x7fffffffL;
+ pData->iTotalplaytime = 0x7fffffffL;
+ }
+ else
+ {
+ /* TODO: we're cheating out on the termination_condition,
+ iteration_min, iteration_max and possible signals;
+ the code is just not ready for that can of worms.... */
+
+ if (!pLOOP->iRunningcount) /* reached zero ? */
+ { /* was this the outer LOOP ? */
+ if (pData->pFirstaniobj == (mng_objectp)pLOOP) /* TODO: THIS IS WRONG!! */
+ pData->bHasLOOP = MNG_FALSE;
+ }
+ else
+ {
+ if (pData->pCurraniobj) /* was we processing objects ? */
+ pData->pCurraniobj = pLOOP;/* then restart with LOOP */
+ else /* else restart behind LOOP !!! */
+ pData->pCurraniobj = pLOOP->sHeader.pNext;
+ }
+ }
+ /* does this match a 'skipping' LOOP? */
+ if ((pData->bSkipping) && (pLOOP->iRepeatcount == 0))
+ pData->bSkipping = MNG_FALSE;
+ }
+ else
+ MNG_ERROR (pData, MNG_NOMATCHINGLOOP);
+
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ENDL, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_DEFI
+mng_retcode mng_create_ani_defi (mng_datap pData)
+{
+ mng_ani_defip pDEFI;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_DEFI, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_defi),
+ mng_free_obj_general,
+ mng_process_ani_defi,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pDEFI = (mng_ani_defip)pTemp;
+#else
+ MNG_ALLOC (pData, pDEFI, sizeof (mng_ani_defi));
+
+ pDEFI->sHeader.fCleanup = mng_free_ani_defi;
+ pDEFI->sHeader.fProcess = mng_process_ani_defi;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pDEFI);
+
+ pDEFI->iId = pData->iDEFIobjectid;
+ pDEFI->bHasdonotshow = pData->bDEFIhasdonotshow;
+ pDEFI->iDonotshow = pData->iDEFIdonotshow;
+ pDEFI->bHasconcrete = pData->bDEFIhasconcrete;
+ pDEFI->iConcrete = pData->iDEFIconcrete;
+ pDEFI->bHasloca = pData->bDEFIhasloca;
+ pDEFI->iLocax = pData->iDEFIlocax;
+ pDEFI->iLocay = pData->iDEFIlocay;
+ pDEFI->bHasclip = pData->bDEFIhasclip;
+ pDEFI->iClipl = pData->iDEFIclipl;
+ pDEFI->iClipr = pData->iDEFIclipr;
+ pDEFI->iClipt = pData->iDEFIclipt;
+ pDEFI->iClipb = pData->iDEFIclipb;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_DEFI, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_defi (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_DEFI, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_defi));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_DEFI, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_defi (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_defip pDEFI = (mng_ani_defip)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DEFI, MNG_LC_START);
+#endif
+
+ pData->iDEFIobjectid = pDEFI->iId;
+ pData->bDEFIhasdonotshow = pDEFI->bHasdonotshow;
+ pData->iDEFIdonotshow = pDEFI->iDonotshow;
+ pData->bDEFIhasconcrete = pDEFI->bHasconcrete;
+ pData->iDEFIconcrete = pDEFI->iConcrete;
+ pData->bDEFIhasloca = pDEFI->bHasloca;
+ pData->iDEFIlocax = pDEFI->iLocax;
+ pData->iDEFIlocay = pDEFI->iLocay;
+ pData->bDEFIhasclip = pDEFI->bHasclip;
+ pData->iDEFIclipl = pDEFI->iClipl;
+ pData->iDEFIclipr = pDEFI->iClipr;
+ pData->iDEFIclipt = pDEFI->iClipt;
+ pData->iDEFIclipb = pDEFI->iClipb;
+
+ iRetcode = mng_process_display_defi (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DEFI, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_BASI
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_basi (mng_datap pData,
+ mng_uint16 iRed,
+ mng_uint16 iGreen,
+ mng_uint16 iBlue,
+ mng_bool bHasalpha,
+ mng_uint16 iAlpha,
+ mng_uint8 iViewable)
+#else
+mng_retcode mng_create_ani_basi (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_basip pBASI;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_BASI, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_basi),
+ mng_free_obj_general,
+ mng_process_ani_basi,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pBASI = (mng_ani_basip)pTemp;
+#else
+ MNG_ALLOC (pData, pBASI, sizeof (mng_ani_basi));
+
+ pBASI->sHeader.fCleanup = mng_free_ani_basi;
+ pBASI->sHeader.fProcess = mng_process_ani_basi;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pBASI);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pBASI->iRed = iRed;
+ pBASI->iGreen = iGreen;
+ pBASI->iBlue = iBlue;
+ pBASI->bHasalpha = bHasalpha;
+ pBASI->iAlpha = iAlpha;
+ pBASI->iViewable = iViewable;
+#else
+ pBASI->iRed = ((mng_basip)pChunk)->iRed;
+ pBASI->iGreen = ((mng_basip)pChunk)->iGreen;
+ pBASI->iBlue = ((mng_basip)pChunk)->iBlue;
+ pBASI->bHasalpha = ((mng_basip)pChunk)->bHasalpha;
+ pBASI->iAlpha = ((mng_basip)pChunk)->iAlpha;
+ pBASI->iViewable = ((mng_basip)pChunk)->iViewable;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_basi (pData, iRed, iGreen, iBlue,
+ bHasalpha, iAlpha, iViewable);
+#else
+ iRetcode = mng_process_display_basi (pData,
+ ((mng_basip)pChunk)->iRed,
+ ((mng_basip)pChunk)->iGreen,
+ ((mng_basip)pChunk)->iBlue,
+ ((mng_basip)pChunk)->bHasalpha,
+ ((mng_basip)pChunk)->iAlpha,
+ ((mng_basip)pChunk)->iViewable);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iBASIred = iRed;
+ pData->iBASIgreen = iGreen;
+ pData->iBASIblue = iBlue;
+ pData->bBASIhasalpha = bHasalpha;
+ pData->iBASIalpha = iAlpha;
+ pData->iBASIviewable = iViewable;
+#else
+ pData->iBASIred = ((mng_basip)pChunk)->iRed;
+ pData->iBASIgreen = ((mng_basip)pChunk)->iGreen;
+ pData->iBASIblue = ((mng_basip)pChunk)->iBlue;
+ pData->bBASIhasalpha = ((mng_basip)pChunk)->bHasalpha;
+ pData->iBASIalpha = ((mng_basip)pChunk)->iAlpha;
+ pData->iBASIviewable = ((mng_basip)pChunk)->iViewable;
+#endif
+
+ iRetcode = mng_process_display_basi (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_BASI, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_basi (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_BASI, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_basi));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_BASI, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_basi (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_basip pBASI = (mng_ani_basip)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BASI, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_basi (pData, pBASI->iRed, pBASI->iGreen, pBASI->iBlue,
+ pBASI->bHasalpha, pBASI->iAlpha, pBASI->iViewable);
+#else
+ pData->iBASIred = pBASI->iRed;
+ pData->iBASIgreen = pBASI->iGreen;
+ pData->iBASIblue = pBASI->iBlue;
+ pData->bBASIhasalpha = pBASI->bHasalpha;
+ pData->iBASIalpha = pBASI->iAlpha;
+ pData->iBASIviewable = pBASI->iViewable;
+
+ iRetcode = mng_process_display_basi (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BASI, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_CLON
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_clon (mng_datap pData,
+ mng_uint16 iSourceid,
+ mng_uint16 iCloneid,
+ mng_uint8 iClonetype,
+ mng_bool bHasdonotshow,
+ mng_uint8 iDonotshow,
+ mng_uint8 iConcrete,
+ mng_bool bHasloca,
+ mng_uint8 iLocatype,
+ mng_int32 iLocax,
+ mng_int32 iLocay)
+#else
+mng_retcode mng_create_ani_clon (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_clonp pCLON;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLON, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_clon),
+ mng_free_obj_general,
+ mng_process_ani_clon,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pCLON = (mng_ani_clonp)pTemp;
+#else
+ MNG_ALLOC (pData, pCLON, sizeof (mng_ani_clon));
+
+ pCLON->sHeader.fCleanup = mng_free_ani_clon;
+ pCLON->sHeader.fProcess = mng_process_ani_clon;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pCLON);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pCLON->iSourceid = iSourceid;
+ pCLON->iCloneid = iCloneid;
+ pCLON->iClonetype = iClonetype;
+ pCLON->bHasdonotshow = bHasdonotshow;
+ pCLON->iDonotshow = iDonotshow;
+ pCLON->iConcrete = iConcrete;
+ pCLON->bHasloca = bHasloca;
+ pCLON->iLocatype = iLocatype;
+ pCLON->iLocax = iLocax;
+ pCLON->iLocay = iLocay;
+#else
+ pCLON->iSourceid = ((mng_clonp)pChunk)->iSourceid;
+ pCLON->iCloneid = ((mng_clonp)pChunk)->iCloneid;
+ pCLON->iClonetype = ((mng_clonp)pChunk)->iClonetype;
+ pCLON->bHasdonotshow = ((mng_clonp)pChunk)->bHasdonotshow;
+ pCLON->iDonotshow = ((mng_clonp)pChunk)->iDonotshow;
+ pCLON->iConcrete = ((mng_clonp)pChunk)->iConcrete;
+ pCLON->bHasloca = ((mng_clonp)pChunk)->bHasloca;
+ pCLON->iLocatype = ((mng_clonp)pChunk)->iLocationtype;
+ pCLON->iLocax = ((mng_clonp)pChunk)->iLocationx;
+ pCLON->iLocay = ((mng_clonp)pChunk)->iLocationy;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_clon (pData, iSourceid, iCloneid, iClonetype,
+ bHasdonotshow, iDonotshow, iConcrete,
+ bHasloca, iLocatype, iLocax, iLocay);
+#else
+ iRetcode = mng_process_display_clon (pData,
+ ((mng_clonp)pChunk)->iSourceid,
+ ((mng_clonp)pChunk)->iCloneid,
+ ((mng_clonp)pChunk)->iClonetype,
+ ((mng_clonp)pChunk)->bHasdonotshow,
+ ((mng_clonp)pChunk)->iDonotshow,
+ ((mng_clonp)pChunk)->iConcrete,
+ ((mng_clonp)pChunk)->bHasloca,
+ ((mng_clonp)pChunk)->iLocationtype,
+ ((mng_clonp)pChunk)->iLocationx,
+ ((mng_clonp)pChunk)->iLocationy);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iCLONsourceid = iSourceid;
+ pData->iCLONcloneid = iCloneid;
+ pData->iCLONclonetype = iClonetype;
+ pData->bCLONhasdonotshow = bHasdonotshow;
+ pData->iCLONdonotshow = iDonotshow;
+ pData->iCLONconcrete = iConcrete;
+ pData->bCLONhasloca = bHasloca;
+ pData->iCLONlocationtype = iLocatype;
+ pData->iCLONlocationx = iLocax;
+ pData->iCLONlocationy = iLocay;
+#else
+ pData->iCLONsourceid = ((mng_clonp)pChunk)->iSourceid;
+ pData->iCLONcloneid = ((mng_clonp)pChunk)->iCloneid;
+ pData->iCLONclonetype = ((mng_clonp)pChunk)->iClonetype;
+ pData->bCLONhasdonotshow = ((mng_clonp)pChunk)->bHasdonotshow;
+ pData->iCLONdonotshow = ((mng_clonp)pChunk)->iDonotshow;
+ pData->iCLONconcrete = ((mng_clonp)pChunk)->iConcrete;
+ pData->bCLONhasloca = ((mng_clonp)pChunk)->bHasloca;
+ pData->iCLONlocationtype = ((mng_clonp)pChunk)->iLocationtype;
+ pData->iCLONlocationx = ((mng_clonp)pChunk)->iLocationx;
+ pData->iCLONlocationy = ((mng_clonp)pChunk)->iLocationy;
+#endif
+
+ iRetcode = mng_process_display_clon (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLON, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_clon (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_CLON, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_clon));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_CLON, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_clon (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_clonp pCLON = (mng_ani_clonp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLON, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_clon (pData, pCLON->iSourceid, pCLON->iCloneid,
+ pCLON->iClonetype, pCLON->bHasdonotshow,
+ pCLON->iDonotshow, pCLON->iConcrete,
+ pCLON->bHasloca, pCLON->iLocatype,
+ pCLON->iLocax, pCLON->iLocay);
+#else
+ pData->iCLONcloneid = pCLON->iCloneid;
+ pData->iCLONsourceid = pCLON->iSourceid;
+ pData->iCLONclonetype = pCLON->iClonetype;
+ pData->bCLONhasdonotshow = pCLON->bHasdonotshow;
+ pData->iCLONdonotshow = pCLON->iDonotshow;
+ pData->iCLONconcrete = pCLON->iConcrete;
+ pData->bCLONhasloca = pCLON->bHasloca;
+ pData->iCLONlocationtype = pCLON->iLocatype;
+ pData->iCLONlocationx = pCLON->iLocax;
+ pData->iCLONlocationy = pCLON->iLocay;
+
+ iRetcode = mng_process_display_clon (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLON, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_BACK
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_back (mng_datap pData,
+ mng_uint16 iRed,
+ mng_uint16 iGreen,
+ mng_uint16 iBlue,
+ mng_uint8 iMandatory,
+ mng_uint16 iImageid,
+ mng_uint8 iTile)
+#else
+mng_retcode mng_create_ani_back (mng_datap pData)
+#endif
+{
+ mng_ani_backp pBACK;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_BACK, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_back),
+ mng_free_obj_general,
+ mng_process_ani_back,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pBACK = (mng_ani_backp)pTemp;
+#else
+ MNG_ALLOC (pData, pBACK, sizeof (mng_ani_back));
+
+ pBACK->sHeader.fCleanup = mng_free_ani_back;
+ pBACK->sHeader.fProcess = mng_process_ani_back;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pBACK);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pBACK->iRed = iRed;
+ pBACK->iGreen = iGreen;
+ pBACK->iBlue = iBlue;
+ pBACK->iMandatory = iMandatory;
+ pBACK->iImageid = iImageid;
+ pBACK->iTile = iTile;
+#else
+ pBACK->iRed = pData->iBACKred;
+ pBACK->iGreen = pData->iBACKgreen;
+ pBACK->iBlue = pData->iBACKblue;
+ pBACK->iMandatory = pData->iBACKmandatory;
+ pBACK->iImageid = pData->iBACKimageid;
+ pBACK->iTile = pData->iBACKtile;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_BACK, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_back (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_BACK, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_back));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_BACK, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_back (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_backp pBACK = (mng_ani_backp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BACK, MNG_LC_START);
+#endif
+
+ pData->iBACKred = pBACK->iRed;
+ pData->iBACKgreen = pBACK->iGreen;
+ pData->iBACKblue = pBACK->iBlue;
+ pData->iBACKmandatory = pBACK->iMandatory;
+ pData->iBACKimageid = pBACK->iImageid;
+ pData->iBACKtile = pBACK->iTile;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BACK, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_FRAM
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_fram (mng_datap pData,
+ mng_uint8 iFramemode,
+ mng_uint8 iChangedelay,
+ mng_uint32 iDelay,
+ mng_uint8 iChangetimeout,
+ mng_uint32 iTimeout,
+ mng_uint8 iChangeclipping,
+ mng_uint8 iCliptype,
+ mng_int32 iClipl,
+ mng_int32 iClipr,
+ mng_int32 iClipt,
+ mng_int32 iClipb)
+#else
+mng_retcode mng_create_ani_fram (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_framp pFRAM;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_FRAM, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
+ mng_free_obj_general,
+ mng_process_ani_fram,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pFRAM = (mng_ani_framp)pTemp;
+#else
+ MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
+
+ pFRAM->sHeader.fCleanup = mng_free_ani_fram;
+ pFRAM->sHeader.fProcess = mng_process_ani_fram;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pFRAM->iFramemode = iFramemode;
+ pFRAM->iChangedelay = iChangedelay;
+ pFRAM->iDelay = iDelay;
+ pFRAM->iChangetimeout = iChangetimeout;
+ pFRAM->iTimeout = iTimeout;
+ pFRAM->iChangeclipping = iChangeclipping;
+ pFRAM->iCliptype = iCliptype;
+ pFRAM->iClipl = iClipl;
+ pFRAM->iClipr = iClipr;
+ pFRAM->iClipt = iClipt;
+ pFRAM->iClipb = iClipb;
+#else
+ pFRAM->iFramemode = ((mng_framp)pChunk)->iMode;
+ pFRAM->iChangedelay = ((mng_framp)pChunk)->iChangedelay;
+ pFRAM->iDelay = ((mng_framp)pChunk)->iDelay;
+ pFRAM->iChangetimeout = ((mng_framp)pChunk)->iChangetimeout;
+ pFRAM->iTimeout = ((mng_framp)pChunk)->iTimeout;
+ pFRAM->iChangeclipping = ((mng_framp)pChunk)->iChangeclipping;
+ pFRAM->iCliptype = ((mng_framp)pChunk)->iBoundarytype;
+ pFRAM->iClipl = ((mng_framp)pChunk)->iBoundaryl;
+ pFRAM->iClipr = ((mng_framp)pChunk)->iBoundaryr;
+ pFRAM->iClipt = ((mng_framp)pChunk)->iBoundaryt;
+ pFRAM->iClipb = ((mng_framp)pChunk)->iBoundaryb;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_fram (pData, iFramemode,
+ iChangedelay, iDelay,
+ iChangetimeout, iTimeout,
+ iChangeclipping, iCliptype,
+ iClipl, iClipr,
+ iClipt, iClipb);
+#else
+ iRetcode = mng_process_display_fram (pData,
+ ((mng_framp)pChunk)->iMode,
+ ((mng_framp)pChunk)->iChangedelay,
+ ((mng_framp)pChunk)->iDelay,
+ ((mng_framp)pChunk)->iChangetimeout,
+ ((mng_framp)pChunk)->iTimeout,
+ ((mng_framp)pChunk)->iChangeclipping,
+ ((mng_framp)pChunk)->iBoundarytype,
+ ((mng_framp)pChunk)->iBoundaryl,
+ ((mng_framp)pChunk)->iBoundaryr,
+ ((mng_framp)pChunk)->iBoundaryt,
+ ((mng_framp)pChunk)->iBoundaryb);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iTempFramemode = iFramemode;
+ pData->iTempChangedelay = iChangedelay;
+ pData->iTempDelay = iDelay;
+ pData->iTempChangetimeout = iChangetimeout;
+ pData->iTempTimeout = iTimeout;
+ pData->iTempChangeclipping = iChangeclipping;
+ pData->iTempCliptype = iCliptype;
+ pData->iTempClipl = iClipl;
+ pData->iTempClipr = iClipr;
+ pData->iTempClipt = iClipt;
+ pData->iTempClipb = iClipb;
+#else
+ pData->iTempFramemode = ((mng_framp)pChunk)->iMode;
+ pData->iTempChangedelay = ((mng_framp)pChunk)->iChangedelay;
+ pData->iTempDelay = ((mng_framp)pChunk)->iDelay;
+ pData->iTempChangetimeout = ((mng_framp)pChunk)->iChangetimeout;
+ pData->iTempTimeout = ((mng_framp)pChunk)->iTimeout;
+ pData->iTempChangeclipping = ((mng_framp)pChunk)->iChangeclipping;
+ pData->iTempCliptype = ((mng_framp)pChunk)->iBoundarytype;
+ pData->iTempClipl = ((mng_framp)pChunk)->iBoundaryl;
+ pData->iTempClipr = ((mng_framp)pChunk)->iBoundaryr;
+ pData->iTempClipt = ((mng_framp)pChunk)->iBoundaryt;
+ pData->iTempClipb = ((mng_framp)pChunk)->iBoundaryb;
+#endif
+
+ iRetcode = mng_process_display_fram (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_FRAM, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_fram (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_FRAM, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_fram));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_FRAM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_fram (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_framp pFRAM = (mng_ani_framp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_FRAM, MNG_LC_START);
+#endif
+
+ if (pData->iBreakpoint) /* previously broken ? */
+ {
+ iRetcode = mng_process_display_fram2 (pData);
+ pData->iBreakpoint = 0; /* not again */
+ }
+ else
+ {
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_fram (pData, pFRAM->iFramemode,
+ pFRAM->iChangedelay, pFRAM->iDelay,
+ pFRAM->iChangetimeout, pFRAM->iTimeout,
+ pFRAM->iChangeclipping, pFRAM->iCliptype,
+ pFRAM->iClipl, pFRAM->iClipr,
+ pFRAM->iClipt, pFRAM->iClipb);
+#else
+ pData->iTempFramemode = pFRAM->iFramemode;
+ pData->iTempChangedelay = pFRAM->iChangedelay;
+ pData->iTempDelay = pFRAM->iDelay;
+ pData->iTempChangetimeout = pFRAM->iChangetimeout;
+ pData->iTempTimeout = pFRAM->iTimeout;
+ pData->iTempChangeclipping = pFRAM->iChangeclipping;
+ pData->iTempCliptype = pFRAM->iCliptype;
+ pData->iTempClipl = pFRAM->iClipl;
+ pData->iTempClipr = pFRAM->iClipr;
+ pData->iTempClipt = pFRAM->iClipt;
+ pData->iTempClipb = pFRAM->iClipb;
+
+ iRetcode = mng_process_display_fram (pData);
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_FRAM, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_MOVE
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_move (mng_datap pData,
+ mng_uint16 iFirstid,
+ mng_uint16 iLastid,
+ mng_uint8 iType,
+ mng_int32 iLocax,
+ mng_int32 iLocay)
+#else
+mng_retcode mng_create_ani_move (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_movep pMOVE;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_MOVE, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
+ mng_free_obj_general,
+ mng_process_ani_move,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pMOVE = (mng_ani_movep)pTemp;
+#else
+ MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
+
+ pMOVE->sHeader.fCleanup = mng_free_ani_move;
+ pMOVE->sHeader.fProcess = mng_process_ani_move;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pMOVE->iFirstid = iFirstid;
+ pMOVE->iLastid = iLastid;
+ pMOVE->iType = iType;
+ pMOVE->iLocax = iLocax;
+ pMOVE->iLocay = iLocay;
+#else
+ pMOVE->iFirstid = ((mng_movep)pChunk)->iFirstid;
+ pMOVE->iLastid = ((mng_movep)pChunk)->iLastid;
+ pMOVE->iType = ((mng_movep)pChunk)->iMovetype;
+ pMOVE->iLocax = ((mng_movep)pChunk)->iMovex;
+ pMOVE->iLocay = ((mng_movep)pChunk)->iMovey;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_move (pData, iFirstid, iLastid,
+ iType, iLocax, iLocay);
+#else
+ iRetcode = mng_process_display_move (pData,
+ ((mng_movep)pChunk)->iFirstid,
+ ((mng_movep)pChunk)->iLastid,
+ ((mng_movep)pChunk)->iMovetype,
+ ((mng_movep)pChunk)->iMovex,
+ ((mng_movep)pChunk)->iMovey);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iMOVEfromid = iFirstid;
+ pData->iMOVEtoid = iLastid;
+ pData->iMOVEmovetype = iType;
+ pData->iMOVEmovex = iLocax;
+ pData->iMOVEmovey = iLocay;
+#else
+ pData->iMOVEfromid = ((mng_movep)pChunk)->iFirstid;
+ pData->iMOVEtoid = ((mng_movep)pChunk)->iLastid;
+ pData->iMOVEmovetype = ((mng_movep)pChunk)->iMovetype;
+ pData->iMOVEmovex = ((mng_movep)pChunk)->iMovex;
+ pData->iMOVEmovey = ((mng_movep)pChunk)->iMovey;
+#endif
+
+ iRetcode = mng_process_display_move (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_MOVE, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_move (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_MOVE, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_move));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_MOVE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_move (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode;
+ mng_ani_movep pMOVE = (mng_ani_movep)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MOVE, MNG_LC_START);
+#endif
+ /* re-process the MOVE chunk */
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_move (pData, pMOVE->iFirstid, pMOVE->iLastid,
+ pMOVE->iType, pMOVE->iLocax, pMOVE->iLocay);
+#else
+ pData->iMOVEfromid = pMOVE->iFirstid;
+ pData->iMOVEtoid = pMOVE->iLastid;
+ pData->iMOVEmovetype = pMOVE->iType;
+ pData->iMOVEmovex = pMOVE->iLocax;
+ pData->iMOVEmovey = pMOVE->iLocay;
+
+ iRetcode = mng_process_display_move (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MOVE, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_CLIP
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_clip (mng_datap pData,
+ mng_uint16 iFirstid,
+ mng_uint16 iLastid,
+ mng_uint8 iType,
+ mng_int32 iClipl,
+ mng_int32 iClipr,
+ mng_int32 iClipt,
+ mng_int32 iClipb)
+#else
+mng_retcode mng_create_ani_clip (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_clipp pCLIP;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLIP, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_clip),
+ mng_free_obj_general,
+ mng_process_ani_clip,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pCLIP = (mng_ani_clipp)pTemp;
+#else
+ MNG_ALLOC (pData, pCLIP, sizeof (mng_ani_clip));
+
+ pCLIP->sHeader.fCleanup = mng_free_ani_clip;
+ pCLIP->sHeader.fProcess = mng_process_ani_clip;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pCLIP);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pCLIP->iFirstid = iFirstid;
+ pCLIP->iLastid = iLastid;
+ pCLIP->iType = iType;
+ pCLIP->iClipl = iClipl;
+ pCLIP->iClipr = iClipr;
+ pCLIP->iClipt = iClipt;
+ pCLIP->iClipb = iClipb;
+#else
+ pCLIP->iFirstid = ((mng_clipp)pChunk)->iFirstid;
+ pCLIP->iLastid = ((mng_clipp)pChunk)->iLastid;
+ pCLIP->iType = ((mng_clipp)pChunk)->iCliptype;
+ pCLIP->iClipl = ((mng_clipp)pChunk)->iClipl;
+ pCLIP->iClipr = ((mng_clipp)pChunk)->iClipr;
+ pCLIP->iClipt = ((mng_clipp)pChunk)->iClipt;
+ pCLIP->iClipb = ((mng_clipp)pChunk)->iClipb;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_clip (pData, iFirstid, iLastid,
+ iType, iClipl, iClipr,
+ iClipt, iClipb);
+#else
+ iRetcode = mng_process_display_clip (pData,
+ ((mng_clipp)pChunk)->iFirstid,
+ ((mng_clipp)pChunk)->iLastid,
+ ((mng_clipp)pChunk)->iCliptype,
+ ((mng_clipp)pChunk)->iClipl,
+ ((mng_clipp)pChunk)->iClipr,
+ ((mng_clipp)pChunk)->iClipt,
+ ((mng_clipp)pChunk)->iClipb);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iCLIPfromid = iFirstid;
+ pData->iCLIPtoid = iLastid;
+ pData->iCLIPcliptype = iType;
+ pData->iCLIPclipl = iClipl;
+ pData->iCLIPclipr = iClipr;
+ pData->iCLIPclipt = iClipt;
+ pData->iCLIPclipb = iClipb;
+#else
+ pData->iCLIPfromid = ((mng_clipp)pChunk)->iFirstid;
+ pData->iCLIPtoid = ((mng_clipp)pChunk)->iLastid;
+ pData->iCLIPcliptype = ((mng_clipp)pChunk)->iCliptype;
+ pData->iCLIPclipl = ((mng_clipp)pChunk)->iClipl;
+ pData->iCLIPclipr = ((mng_clipp)pChunk)->iClipr;
+ pData->iCLIPclipt = ((mng_clipp)pChunk)->iClipt;
+ pData->iCLIPclipb = ((mng_clipp)pChunk)->iClipb;
+#endif
+
+ iRetcode = mng_process_display_clip (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLIP, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_clip (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_CLIP, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_clip));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_CLIP, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_clip (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode;
+ mng_ani_clipp pCLIP = (mng_ani_clipp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLIP, MNG_LC_START);
+#endif
+ /* re-process the CLIP chunk */
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_clip (pData, pCLIP->iFirstid, pCLIP->iLastid,
+ pCLIP->iType, pCLIP->iClipl, pCLIP->iClipr,
+ pCLIP->iClipt, pCLIP->iClipb);
+#else
+ pData->iCLIPfromid = pCLIP->iFirstid;
+ pData->iCLIPtoid = pCLIP->iLastid;
+ pData->iCLIPcliptype = pCLIP->iType;
+ pData->iCLIPclipl = pCLIP->iClipl;
+ pData->iCLIPclipr = pCLIP->iClipr;
+ pData->iCLIPclipt = pCLIP->iClipt;
+ pData->iCLIPclipb = pCLIP->iClipb;
+
+ iRetcode = mng_process_display_clip (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLIP, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_SHOW
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_show (mng_datap pData,
+ mng_uint16 iFirstid,
+ mng_uint16 iLastid,
+ mng_uint8 iMode)
+#else
+mng_retcode mng_create_ani_show (mng_datap pData)
+#endif
+{
+ mng_ani_showp pSHOW;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SHOW, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
+ mng_free_obj_general,
+ mng_process_ani_show,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pSHOW = (mng_ani_showp)pTemp;
+#else
+ MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
+
+ pSHOW->sHeader.fCleanup = mng_free_ani_show;
+ pSHOW->sHeader.fProcess = mng_process_ani_show;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pSHOW->iFirstid = iFirstid;
+ pSHOW->iLastid = iLastid;
+ pSHOW->iMode = iMode;
+#else
+ pSHOW->iFirstid = pData->iSHOWfromid;
+ pSHOW->iLastid = pData->iSHOWtoid;
+ pSHOW->iMode = pData->iSHOWmode;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SHOW, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_show (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SHOW, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_show));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SHOW, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_show (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode;
+ mng_ani_showp pSHOW = (mng_ani_showp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SHOW, MNG_LC_START);
+#endif
+
+ if (pData->iBreakpoint) /* returning from breakpoint ? */
+ {
+ iRetcode = mng_process_display_show (pData);
+ }
+ else
+ { /* "re-run" SHOW chunk */
+ pData->iSHOWmode = pSHOW->iMode;
+ pData->iSHOWfromid = pSHOW->iFirstid;
+ pData->iSHOWtoid = pSHOW->iLastid;
+
+ iRetcode = mng_process_display_show (pData);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SHOW, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_TERM
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_term (mng_datap pData,
+ mng_uint8 iTermaction,
+ mng_uint8 iIteraction,
+ mng_uint32 iDelay,
+ mng_uint32 iItermax)
+#else
+mng_retcode mng_create_ani_term (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_termp pTERM;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_TERM, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_term),
+ mng_free_obj_general,
+ mng_process_ani_term,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pTERM = (mng_ani_termp)pTemp;
+#else
+ MNG_ALLOC (pData, pTERM, sizeof (mng_ani_term));
+
+ pTERM->sHeader.fCleanup = mng_free_ani_term;
+ pTERM->sHeader.fProcess = mng_process_ani_term;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pTERM);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pTERM->iTermaction = iTermaction;
+ pTERM->iIteraction = iIteraction;
+ pTERM->iDelay = iDelay;
+ pTERM->iItermax = iItermax;
+#else
+ pTERM->iTermaction = ((mng_termp)pChunk)->iTermaction;
+ pTERM->iIteraction = ((mng_termp)pChunk)->iIteraction;
+ pTERM->iDelay = ((mng_termp)pChunk)->iDelay;
+ pTERM->iItermax = ((mng_termp)pChunk)->iItermax;
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_TERM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_term (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_TERM, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_term));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_TERM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_term (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TERM, MNG_LC_START);
+#endif
+
+ /* dummy: no action required! */
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TERM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_SAVE
+mng_retcode mng_create_ani_save (mng_datap pData)
+{
+ mng_ptr pTemp;
+ mng_ani_savep pSAVE;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SAVE, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_save),
+ mng_free_obj_general,
+ mng_process_ani_save,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pSAVE = (mng_ani_savep)pTemp;
+#else
+ MNG_ALLOC (pData, pSAVE, sizeof (mng_ani_save));
+
+ pSAVE->sHeader.fCleanup = mng_free_ani_save;
+ pSAVE->sHeader.fProcess = mng_process_ani_save;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pSAVE);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SAVE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_save (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SAVE, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_save));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SAVE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_save (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SAVE, MNG_LC_START);
+#endif
+
+ iRetcode = mng_process_display_save (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SAVE, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_SEEK
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_seek (mng_datap pData,
+ mng_uint32 iSegmentnamesize,
+ mng_pchar zSegmentname)
+#else
+mng_retcode mng_create_ani_seek (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ptr pTemp;
+ mng_ani_seekp pSEEK;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SEEK, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_seek),
+ mng_free_ani_seek,
+ mng_process_ani_seek,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pSEEK = (mng_ani_seekp)pTemp;
+#else
+ MNG_ALLOC (pData, pSEEK, sizeof (mng_ani_seek));
+
+ pSEEK->sHeader.fCleanup = mng_free_ani_seek;
+ pSEEK->sHeader.fProcess = mng_process_ani_seek;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pSEEK);
+
+ pData->pLastseek = (mng_objectp)pSEEK;
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pSEEK->iSegmentnamesize = iSegmentnamesize;
+ if (iSegmentnamesize)
+ {
+ MNG_ALLOC (pData, pSEEK->zSegmentname, iSegmentnamesize + 1);
+ MNG_COPY (pSEEK->zSegmentname, zSegmentname, iSegmentnamesize);
+ }
+#else
+ pSEEK->iSegmentnamesize = ((mng_seekp)pChunk)->iNamesize;
+ if (pSEEK->iSegmentnamesize)
+ {
+ MNG_ALLOC (pData, pSEEK->zSegmentname, pSEEK->iSegmentnamesize + 1);
+ MNG_COPY (pSEEK->zSegmentname, ((mng_seekp)pChunk)->zName, pSEEK->iSegmentnamesize);
+ }
+#endif
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_SEEK, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_ani_seek (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_seekp pSEEK = (mng_ani_seekp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SEEK, MNG_LC_START);
+#endif
+
+ if (pSEEK->iSegmentnamesize)
+ MNG_FREEX (pData, pSEEK->zSegmentname, pSEEK->iSegmentnamesize + 1);
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_seek));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_SEEK, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_seek (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_seekp pSEEK = (mng_ani_seekp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SEEK, MNG_LC_START);
+#endif
+
+#ifdef MNG_SUPPORT_DYNAMICMNG
+ if (!pData->bStopafterseek) /* can we really process this one ? */
+#endif
+ {
+ pData->pLastseek = pObject;
+
+ if (pData->fProcessseek) /* inform the app ? */
+ {
+ mng_bool bOke;
+ mng_pchar zName;
+
+ MNG_ALLOC (pData, zName, pSEEK->iSegmentnamesize + 1);
+
+ if (pSEEK->iSegmentnamesize)
+ MNG_COPY (zName, pSEEK->zSegmentname, pSEEK->iSegmentnamesize);
+
+ bOke = pData->fProcessseek ((mng_handle)pData, zName);
+
+ MNG_FREEX (pData, zName, pSEEK->iSegmentnamesize + 1);
+
+ if (!bOke)
+ MNG_ERROR (pData, MNG_APPMISCERROR);
+ }
+ }
+
+ iRetcode = mng_process_display_seek (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SEEK, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_NO_DELTA_PNG
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_dhdr (mng_datap pData,
+ mng_uint16 iObjectid,
+ mng_uint8 iImagetype,
+ mng_uint8 iDeltatype,
+ mng_uint32 iBlockwidth,
+ mng_uint32 iBlockheight,
+ mng_uint32 iBlockx,
+ mng_uint32 iBlocky)
+#else
+mng_retcode mng_create_ani_dhdr (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_dhdrp pDHDR;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_DHDR, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_dhdr),
+ mng_free_obj_general,
+ mng_process_ani_dhdr,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pDHDR = (mng_ani_dhdrp)pTemp;
+#else
+ MNG_ALLOC (pData, pDHDR, sizeof (mng_ani_dhdr));
+
+ pDHDR->sHeader.fCleanup = mng_free_ani_dhdr;
+ pDHDR->sHeader.fProcess = mng_process_ani_dhdr;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pDHDR);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pDHDR->iObjectid = iObjectid;
+ pDHDR->iImagetype = iImagetype;
+ pDHDR->iDeltatype = iDeltatype;
+ pDHDR->iBlockwidth = iBlockwidth;
+ pDHDR->iBlockheight = iBlockheight;
+ pDHDR->iBlockx = iBlockx;
+ pDHDR->iBlocky = iBlocky;
+#else
+ pDHDR->iObjectid = ((mng_dhdrp)pChunk)->iObjectid;
+ pDHDR->iImagetype = ((mng_dhdrp)pChunk)->iImagetype;
+ pDHDR->iDeltatype = ((mng_dhdrp)pChunk)->iDeltatype;
+ pDHDR->iBlockwidth = ((mng_dhdrp)pChunk)->iBlockwidth;
+ pDHDR->iBlockheight = ((mng_dhdrp)pChunk)->iBlockheight;
+ pDHDR->iBlockx = ((mng_dhdrp)pChunk)->iBlockx;
+ pDHDR->iBlocky = ((mng_dhdrp)pChunk)->iBlocky;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_dhdr (pData, iObjectid,
+ iImagetype, iDeltatype,
+ iBlockwidth, iBlockheight,
+ iBlockx, iBlocky);
+#else
+ iRetcode = mng_process_display_dhdr (pData,
+ ((mng_dhdrp)pChunk)->iObjectid,
+ ((mng_dhdrp)pChunk)->iImagetype,
+ ((mng_dhdrp)pChunk)->iDeltatype,
+ ((mng_dhdrp)pChunk)->iBlockwidth,
+ ((mng_dhdrp)pChunk)->iBlockheight,
+ ((mng_dhdrp)pChunk)->iBlockx,
+ ((mng_dhdrp)pChunk)->iBlocky);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iDHDRobjectid = iObjectid;
+ pData->iDHDRimagetype = iImagetype;
+ pData->iDHDRdeltatype = iDeltatype;
+ pData->iDHDRblockwidth = iBlockwidth;
+ pData->iDHDRblockheight = iBlockheight;
+ pData->iDHDRblockx = iBlockx;
+ pData->iDHDRblocky = iBlocky;
+#else
+ pData->iDHDRobjectid = ((mng_dhdrp)pChunk)->iObjectid;
+ pData->iDHDRimagetype = ((mng_dhdrp)pChunk)->iImagetype;
+ pData->iDHDRdeltatype = ((mng_dhdrp)pChunk)->iDeltatype;
+ pData->iDHDRblockwidth = ((mng_dhdrp)pChunk)->iBlockwidth;
+ pData->iDHDRblockheight = ((mng_dhdrp)pChunk)->iBlockheight;
+ pData->iDHDRblockx = ((mng_dhdrp)pChunk)->iBlockx;
+ pData->iDHDRblocky = ((mng_dhdrp)pChunk)->iBlocky;
+#endif
+
+ iRetcode = mng_process_display_dhdr (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_DHDR, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_dhdr (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_DHDR, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_dhdr));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_DHDR, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_dhdr (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_dhdrp pDHDR = (mng_ani_dhdrp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DHDR, MNG_LC_START);
+#endif
+
+ pData->bHasDHDR = MNG_TRUE; /* let everyone know we're inside a DHDR */
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_dhdr (pData, pDHDR->iObjectid,
+ pDHDR->iImagetype, pDHDR->iDeltatype,
+ pDHDR->iBlockwidth, pDHDR->iBlockheight,
+ pDHDR->iBlockx, pDHDR->iBlocky);
+#else
+ pData->iDHDRobjectid = pDHDR->iObjectid;
+ pData->iDHDRimagetype = pDHDR->iImagetype;
+ pData->iDHDRdeltatype = pDHDR->iDeltatype;
+ pData->iDHDRblockwidth = pDHDR->iBlockwidth;
+ pData->iDHDRblockheight = pDHDR->iBlockheight;
+ pData->iDHDRblockx = pDHDR->iBlockx;
+ pData->iDHDRblocky = pDHDR->iBlocky;
+
+ iRetcode = mng_process_display_dhdr (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DHDR, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_NO_DELTA_PNG
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_prom (mng_datap pData,
+ mng_uint8 iBitdepth,
+ mng_uint8 iColortype,
+ mng_uint8 iFilltype)
+#else
+mng_retcode mng_create_ani_prom (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_promp pPROM=NULL;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PROM, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_prom),
+ mng_free_obj_general,
+ mng_process_ani_prom,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pPROM = (mng_ani_promp)pTemp;
+#else
+ MNG_ALLOC (pData, pPROM, sizeof (mng_ani_prom));
+
+ pPROM->sHeader.fCleanup = mng_free_ani_prom;
+ pPROM->sHeader.fProcess = mng_process_ani_prom;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pPROM);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pPROM->iBitdepth = iBitdepth;
+ pPROM->iColortype = iColortype;
+ pPROM->iFilltype = iFilltype;
+#else
+ pPROM->iBitdepth = ((mng_promp)pChunk)->iSampledepth;
+ pPROM->iColortype = ((mng_promp)pChunk)->iColortype;
+ pPROM->iFilltype = ((mng_promp)pChunk)->iFilltype;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_prom (pData, iBitdepth,
+ iColortype, iFilltype);
+#else
+ iRetcode = mng_process_display_prom (pData,
+ ((mng_promp)pChunk)->iSampledepth,
+ ((mng_promp)pChunk)->iColortype,
+ ((mng_promp)pChunk)->iFilltype);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iPROMbitdepth = iBitdepth;
+ pData->iPROMcolortype = iColortype;
+ pData->iPROMfilltype = iFilltype;
+#else
+ pData->iPROMbitdepth = ((mng_promp)pChunk)->iSampledepth;
+ pData->iPROMcolortype = ((mng_promp)pChunk)->iColortype;
+ pData->iPROMfilltype = ((mng_promp)pChunk)->iFilltype;
+#endif
+
+ iRetcode = mng_process_display_prom (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PROM, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_prom (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PROM, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_prom));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PROM, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_prom (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_promp pPROM = (mng_ani_promp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PROM, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_prom (pData, pPROM->iBitdepth,
+ pPROM->iColortype, pPROM->iFilltype);
+#else
+ pData->iPROMbitdepth = pPROM->iBitdepth;
+ pData->iPROMcolortype = pPROM->iColortype;
+ pData->iPROMfilltype = pPROM->iFilltype;
+
+ iRetcode = mng_process_display_prom (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PROM, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_NO_DELTA_PNG
+mng_retcode mng_create_ani_ipng (mng_datap pData)
+{
+ mng_ani_ipngp pIPNG;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_IPNG, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_ipng),
+ mng_free_obj_general,
+ mng_process_ani_ipng,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pIPNG = (mng_ani_ipngp)pTemp;
+#else
+ MNG_ALLOC (pData, pIPNG, sizeof (mng_ani_ipng));
+
+ pIPNG->sHeader.fCleanup = mng_free_ani_ipng;
+ pIPNG->sHeader.fProcess = mng_process_ani_ipng;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pIPNG);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_IPNG, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_ipng (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_IPNG, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_ipng));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_IPNG, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_ipng (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IPNG, MNG_LC_START);
+#endif
+
+ iRetcode = mng_process_display_ipng (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IPNG, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_NO_DELTA_PNG
+#ifdef MNG_INCLUDE_JNG
+mng_retcode mng_create_ani_ijng (mng_datap pData)
+{
+ mng_ani_ijngp pIJNG;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_IJNG, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_ijng),
+ mng_free_obj_general,
+ mng_process_ani_ijng,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pIJNG = (mng_ani_ijngp)pTemp;
+#else
+ MNG_ALLOC (pData, pIJNG, sizeof (mng_ani_ijng));
+
+ pIJNG->sHeader.fCleanup = mng_free_ani_ijng;
+ pIJNG->sHeader.fProcess = mng_process_ani_ijng;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pIJNG);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_IJNG, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_ijng (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_IJNG, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_ijng));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_IJNG, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_ijng (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IJNG, MNG_LC_START);
+#endif
+
+ iRetcode = mng_process_display_ijng (pData);
+
+ if (iRetcode) /* on error bail out */
+ return iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IJNG, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_NO_DELTA_PNG
+mng_retcode mng_create_ani_pplt (mng_datap pData,
+ mng_uint8 iType,
+ mng_uint32 iCount,
+ mng_palette8ep paIndexentries,
+ mng_uint8p paAlphaentries,
+ mng_uint8p paUsedentries)
+{
+ mng_ani_ppltp pPPLT;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PPLT, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_pplt),
+ mng_free_obj_general,
+ mng_process_ani_pplt,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pPPLT = (mng_ani_ppltp)pTemp;
+#else
+ MNG_ALLOC (pData, pPPLT, sizeof (mng_ani_pplt));
+
+ pPPLT->sHeader.fCleanup = mng_free_ani_pplt;
+ pPPLT->sHeader.fProcess = mng_process_ani_pplt;
+#endif
+
+ pPPLT->iType = iType;
+ pPPLT->iCount = iCount;
+
+ MNG_COPY (pPPLT->aIndexentries, paIndexentries, sizeof (pPPLT->aIndexentries));
+ MNG_COPY (pPPLT->aAlphaentries, paAlphaentries, sizeof (pPPLT->aAlphaentries));
+ MNG_COPY (pPPLT->aUsedentries, paUsedentries, sizeof (pPPLT->aUsedentries ));
+
+ mng_add_ani_object (pData, (mng_object_headerp)pPPLT);
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_pplt (pData, iType, iCount,
+ paIndexentries, paAlphaentries, paUsedentries);
+#else
+ pData->iPPLTtype = iType;
+ pData->iPPLTcount = iCount;
+ pData->paPPLTindexentries = paIndexentries;
+ pData->paPPLTalphaentries = paAlphaentries;
+ pData->paPPLTusedentries = paUsedentries;
+
+ iRetcode = mng_process_display_pplt (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PPLT, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_pplt (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PPLT, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_pplt));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PPLT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_pplt (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_ppltp pPPLT = (mng_ani_ppltp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PPLT, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_pplt (pData, pPPLT->iType, pPPLT->iCount,
+ pPPLT->aIndexentries, pPPLT->aAlphaentries,
+ pPPLT->aUsedentries);
+#else
+ pData->iPPLTtype = pPPLT->iType;
+ pData->iPPLTcount = pPPLT->iCount;
+ pData->paPPLTindexentries = &pPPLT->aIndexentries;
+ pData->paPPLTalphaentries = &pPPLT->aAlphaentries;
+ pData->paPPLTusedentries = &pPPLT->aUsedentries;
+
+ iRetcode = mng_process_display_pplt (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PPLT, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_MAGN
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_magn (mng_datap pData,
+ mng_uint16 iFirstid,
+ mng_uint16 iLastid,
+ mng_uint8 iMethodX,
+ mng_uint16 iMX,
+ mng_uint16 iMY,
+ mng_uint16 iML,
+ mng_uint16 iMR,
+ mng_uint16 iMT,
+ mng_uint16 iMB,
+ mng_uint8 iMethodY)
+#else
+mng_retcode mng_create_ani_magn (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_magnp pMAGN=NULL;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_MAGN, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_magn),
+ mng_free_obj_general,
+ mng_process_ani_magn,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pMAGN = (mng_ani_magnp)pTemp;
+#else
+ MNG_ALLOC (pData, pMAGN, sizeof (mng_ani_magn));
+
+ pMAGN->sHeader.fCleanup = mng_free_ani_magn;
+ pMAGN->sHeader.fProcess = mng_process_ani_magn;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pMAGN);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pMAGN->iFirstid = iFirstid;
+ pMAGN->iLastid = iLastid;
+ pMAGN->iMethodX = iMethodX;
+ pMAGN->iMX = iMX;
+ pMAGN->iMY = iMY;
+ pMAGN->iML = iML;
+ pMAGN->iMR = iMR;
+ pMAGN->iMT = iMT;
+ pMAGN->iMB = iMB;
+ pMAGN->iMethodY = iMethodY;
+#else
+ pMAGN->iFirstid = ((mng_magnp)pChunk)->iFirstid;
+ pMAGN->iLastid = ((mng_magnp)pChunk)->iLastid;
+ pMAGN->iMethodX = ((mng_magnp)pChunk)->iMethodX;
+ pMAGN->iMX = ((mng_magnp)pChunk)->iMX;
+ pMAGN->iMY = ((mng_magnp)pChunk)->iMY;
+ pMAGN->iML = ((mng_magnp)pChunk)->iML;
+ pMAGN->iMR = ((mng_magnp)pChunk)->iMR;
+ pMAGN->iMT = ((mng_magnp)pChunk)->iMT;
+ pMAGN->iMB = ((mng_magnp)pChunk)->iMB;
+ pMAGN->iMethodY = ((mng_magnp)pChunk)->iMethodY;
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_magn (pData, pMAGN->iFirstid, pMAGN->iLastid,
+ pMAGN->iMethodX, pMAGN->iMX, pMAGN->iMY,
+ pMAGN->iML, pMAGN->iMR, pMAGN->iMT,
+ pMAGN->iMB, pMAGN->iMethodY);
+#else
+ iRetcode = mng_process_display_magn (pData,
+ ((mng_magnp)pChunk)->iFirstid,
+ ((mng_magnp)pChunk)->iLastid,
+ ((mng_magnp)pChunk)->iMethodX,
+ ((mng_magnp)pChunk)->iMX,
+ ((mng_magnp)pChunk)->iMY,
+ ((mng_magnp)pChunk)->iML,
+ ((mng_magnp)pChunk)->iMR,
+ ((mng_magnp)pChunk)->iMT,
+ ((mng_magnp)pChunk)->iMB,
+ ((mng_magnp)pChunk)->iMethodY);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iMAGNfirstid = iFirstid;
+ pData->iMAGNlastid = iLastid;
+ pData->iMAGNmethodX = iMethodX;
+ pData->iMAGNmX = iMX;
+ pData->iMAGNmY = iMY;
+ pData->iMAGNmL = iML;
+ pData->iMAGNmR = iMR;
+ pData->iMAGNmT = iMT;
+ pData->iMAGNmB = iMB;
+ pData->iMAGNmethodY = iMethodY;
+#else
+ pData->iMAGNfirstid = ((mng_magnp)pChunk)->iFirstid;
+ pData->iMAGNlastid = ((mng_magnp)pChunk)->iLastid;
+ pData->iMAGNmethodX = ((mng_magnp)pChunk)->iMethodX;
+ pData->iMAGNmX = ((mng_magnp)pChunk)->iMX;
+ pData->iMAGNmY = ((mng_magnp)pChunk)->iMY;
+ pData->iMAGNmL = ((mng_magnp)pChunk)->iML;
+ pData->iMAGNmR = ((mng_magnp)pChunk)->iMR;
+ pData->iMAGNmT = ((mng_magnp)pChunk)->iMT;
+ pData->iMAGNmB = ((mng_magnp)pChunk)->iMB;
+ pData->iMAGNmethodY = ((mng_magnp)pChunk)->iMethodY;
+#endif
+
+ iRetcode = mng_process_display_magn (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_MAGN, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+mng_retcode mng_free_ani_magn (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_MAGN, MNG_LC_START);
+#endif
+
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_magn));
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_MAGN, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+#endif
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_magn (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_magnp pMAGN = (mng_ani_magnp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MAGN, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_magn (pData, pMAGN->iFirstid, pMAGN->iLastid,
+ pMAGN->iMethodX, pMAGN->iMX, pMAGN->iMY,
+ pMAGN->iML, pMAGN->iMR, pMAGN->iMT,
+ pMAGN->iMB, pMAGN->iMethodY);
+#else
+ pData->iMAGNfirstid = pMAGN->iFirstid;
+ pData->iMAGNlastid = pMAGN->iLastid;
+ pData->iMAGNmethodX = pMAGN->iMethodX;
+ pData->iMAGNmX = pMAGN->iMX;
+ pData->iMAGNmY = pMAGN->iMY;
+ pData->iMAGNmL = pMAGN->iML;
+ pData->iMAGNmR = pMAGN->iMR;
+ pData->iMAGNmT = pMAGN->iMT;
+ pData->iMAGNmB = pMAGN->iMB;
+ pData->iMAGNmethodY = pMAGN->iMethodY;
+
+ iRetcode = mng_process_display_magn (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MAGN, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_PAST
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_past (mng_datap pData,
+ mng_uint16 iTargetid,
+ mng_uint8 iTargettype,
+ mng_int32 iTargetx,
+ mng_int32 iTargety,
+ mng_uint32 iCount,
+ mng_ptr pSources)
+#else
+mng_retcode mng_create_ani_past (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_pastp pPAST;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PAST, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_past),
+ mng_free_ani_past,
+ mng_process_ani_past,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pPAST = (mng_ani_pastp)pTemp;
+#else
+ MNG_ALLOC (pData, pPAST, sizeof (mng_ani_past));
+
+ pPAST->sHeader.fCleanup = mng_free_ani_past;
+ pPAST->sHeader.fProcess = mng_process_ani_past;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pPAST);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pPAST->iTargetid = iTargetid;
+ pPAST->iTargettype = iTargettype;
+ pPAST->iTargetx = iTargetx;
+ pPAST->iTargety = iTargety;
+ pPAST->iCount = iCount;
+
+ if (iCount)
+ {
+ MNG_ALLOC (pData, pPAST->pSources, (iCount * sizeof (mng_past_source)));
+ MNG_COPY (pPAST->pSources, pSources, (iCount * sizeof (mng_past_source)));
+ }
+#else
+ pPAST->iTargetid = ((mng_pastp)pChunk)->iDestid;
+ pPAST->iTargettype = ((mng_pastp)pChunk)->iTargettype;
+ pPAST->iTargetx = ((mng_pastp)pChunk)->iTargetx;
+ pPAST->iTargety = ((mng_pastp)pChunk)->iTargety;
+ pPAST->iCount = ((mng_pastp)pChunk)->iCount;
+
+ if (pPAST->iCount)
+ {
+ mng_size_t iSize = (mng_size_t)(pPAST->iCount * sizeof (mng_past_source));
+ MNG_ALLOC (pData, pPAST->pSources, iSize);
+ MNG_COPY (pPAST->pSources, ((mng_pastp)pChunk)->pSources, iSize);
+ }
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_past (pData, iTargetid, iTargettype,
+ iTargetx, iTargety,
+ iCount, pSources);
+#else
+ iRetcode = mng_process_display_past (pData,
+ ((mng_pastp)pChunk)->iDestid,
+ ((mng_pastp)pChunk)->iTargettype,
+ ((mng_pastp)pChunk)->iTargetx,
+ ((mng_pastp)pChunk)->iTargety,
+ ((mng_pastp)pChunk)->iCount,
+ ((mng_pastp)pChunk)->pSources);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iPASTtargetid = iTargetid;
+ pData->iPASTtargettype = iTargettype;
+ pData->iPASTtargetx = iTargetx;
+ pData->iPASTtargety = iTargety;
+ pData->iPASTcount = iCount;
+ pData->pPASTsources = pSources;
+#else
+ pData->iPASTtargetid = ((mng_pastp)pChunk)->iDestid;
+ pData->iPASTtargettype = ((mng_pastp)pChunk)->iTargettype;
+ pData->iPASTtargetx = ((mng_pastp)pChunk)->iTargetx;
+ pData->iPASTtargety = ((mng_pastp)pChunk)->iTargety;
+ pData->iPASTcount = ((mng_pastp)pChunk)->iCount;
+ pData->pPASTsources = ((mng_pastp)pChunk)->pSources;
+#endif
+
+ iRetcode = mng_process_display_past (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_PAST, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_PAST
+mng_retcode mng_free_ani_past (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_pastp pPAST = (mng_ani_pastp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PAST, MNG_LC_START);
+#endif
+
+ if (pPAST->iCount)
+ MNG_FREEX (pData, pPAST->pSources, (pPAST->iCount * sizeof (mng_past_source)));
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_past));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_PAST, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_PAST
+mng_retcode mng_process_ani_past (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_pastp pPAST = (mng_ani_pastp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PAST, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_past (pData, pPAST->iTargetid, pPAST->iTargettype,
+ pPAST->iTargetx, pPAST->iTargety,
+ pPAST->iCount, pPAST->pSources);
+#else
+ pData->iPASTtargetid = pPAST->iTargetid;
+ pData->iPASTtargettype = pPAST->iTargettype;
+ pData->iPASTtargetx = pPAST->iTargetx;
+ pData->iPASTtargety = pPAST->iTargety;
+ pData->iPASTcount = pPAST->iCount;
+ pData->pPASTsources = pPAST->pSources;
+
+ iRetcode = mng_process_display_past (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PAST, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+
+#ifndef MNG_SKIPCHUNK_DISC
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ani_disc (mng_datap pData,
+ mng_uint32 iCount,
+ mng_uint16p pIds)
+#else
+mng_retcode mng_create_ani_disc (mng_datap pData,
+ mng_chunkp pChunk)
+#endif
+{
+ mng_ani_discp pDISC;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_DISC, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_disc),
+ mng_free_ani_disc,
+ mng_process_ani_disc,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pDISC = (mng_ani_discp)pTemp;
+#else
+ MNG_ALLOC (pData, pDISC, sizeof (mng_ani_disc));
+
+ pDISC->sHeader.fCleanup = mng_free_ani_disc;
+ pDISC->sHeader.fProcess = mng_process_ani_disc;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pDISC);
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pDISC->iCount = iCount;
+
+ if (iCount)
+ {
+ MNG_ALLOC (pData, pDISC->pIds, (iCount << 1));
+ MNG_COPY (pDISC->pIds, pIds, (iCount << 1));
+ }
+#else
+ pDISC->iCount = ((mng_discp)pChunk)->iCount;
+
+ if (pDISC->iCount)
+ {
+ mng_size_t iSize = (mng_size_t)(pDISC->iCount << 1);
+ MNG_ALLOC (pData, pDISC->pIds, iSize);
+ MNG_COPY (pDISC->pIds, ((mng_discp)pChunk)->pObjectids, iSize);
+ }
+#endif
+ }
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ iRetcode = mng_process_display_disc (pData, iCount, pIds);
+#else
+ iRetcode = mng_process_display_disc (pData,
+ ((mng_discp)pChunk)->iCount,
+ ((mng_discp)pChunk)->pObjectids);
+#endif
+#else
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pData->iDISCcount = iCount;
+ pData->pDISCids = pIds;
+#else
+ pData->iDISCcount = ((mng_discp)pChunk)->iCount;
+ pData->pDISCids = ((mng_discp)pChunk)->pObjectids;
+#endif
+
+ iRetcode = mng_process_display_disc (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANI_DISC, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_ani_disc (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_discp pDISC = (mng_ani_discp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_DISC, MNG_LC_START);
+#endif
+
+ if (pDISC->iCount)
+ MNG_FREEX (pData, pDISC->pIds, (pDISC->iCount << 1));
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pObject, sizeof (mng_ani_disc));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANI_DISC, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ani_disc (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ani_discp pDISC = (mng_ani_discp)pObject;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DISC, MNG_LC_START);
+#endif
+
+#ifndef MNG_OPTIMIZE_DISPLAYCALLS
+ iRetcode = mng_process_display_disc (pData, pDISC->iCount, pDISC->pIds);
+#else
+ pData->iDISCcount = pDISC->iCount;
+ pData->pDISCids = pDISC->pIds;
+
+ iRetcode = mng_process_display_disc (pData);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DISC, MNG_LC_END);
+#endif
+
+ return iRetcode;
+}
+#endif
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifdef MNG_SUPPORT_DYNAMICMNG
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_event (mng_datap pData,
+ 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 iSegmentnamesize,
+ mng_pchar zSegmentname)
+#else
+mng_retcode mng_create_event (mng_datap pData,
+ mng_ptr pEntry)
+#endif
+{
+ mng_eventp pEvent;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_EVENT, MNG_LC_START);
+#endif
+
+ if (pData->bCacheplayback) /* caching playback info ? */
+ {
+ mng_object_headerp pLast;
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ mng_ptr pTemp;
+ mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_event),
+ mng_free_event,
+ mng_process_event,
+ &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pEvent = (mng_eventp)pTemp;
+#else
+ MNG_ALLOC (pData, pEvent, sizeof (mng_event));
+
+ pEvent->sHeader.fCleanup = mng_free_event;
+ pEvent->sHeader.fProcess = mng_process_event;
+#endif
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pEvent->iEventtype = iEventtype;
+ pEvent->iMasktype = iMasktype;
+ pEvent->iLeft = iLeft;
+ pEvent->iRight = iRight;
+ pEvent->iTop = iTop;
+ pEvent->iBottom = iBottom;
+ pEvent->iObjectid = iObjectid;
+ pEvent->iIndex = iIndex;
+ pEvent->iSegmentnamesize = iSegmentnamesize;
+
+ if (iSegmentnamesize)
+ {
+ MNG_ALLOC (pData, pEvent->zSegmentname, iSegmentnamesize+1);
+ MNG_COPY (pEvent->zSegmentname, zSegmentname, iSegmentnamesize);
+ }
+#else
+ pEvent->iEventtype = ((mng_evnt_entryp)pEntry)->iEventtype;
+ pEvent->iMasktype = ((mng_evnt_entryp)pEntry)->iMasktype;
+ pEvent->iLeft = ((mng_evnt_entryp)pEntry)->iLeft;
+ pEvent->iRight = ((mng_evnt_entryp)pEntry)->iRight;
+ pEvent->iTop = ((mng_evnt_entryp)pEntry)->iTop;
+ pEvent->iBottom = ((mng_evnt_entryp)pEntry)->iBottom;
+ pEvent->iObjectid = ((mng_evnt_entryp)pEntry)->iObjectid;
+ pEvent->iIndex = ((mng_evnt_entryp)pEntry)->iIndex;
+ pEvent->iSegmentnamesize = ((mng_evnt_entryp)pEntry)->iSegmentnamesize;
+
+ if (pEvent->iSegmentnamesize)
+ {
+ MNG_ALLOC (pData, pEvent->zSegmentname, pEvent->iSegmentnamesize+1);
+ MNG_COPY (pEvent->zSegmentname, ((mng_evnt_entryp)pEntry)->zSegmentname, pEvent->iSegmentnamesize);
+ }
+#endif
+ /* fixup the double-linked list */
+ pLast = (mng_object_headerp)pData->pLastevent;
+
+ if (pLast) /* link it as last in the chain */
+ {
+ pEvent->sHeader.pPrev = pLast;
+ pLast->pNext = pEvent;
+ }
+ else
+ {
+ pData->pFirstevent = pEvent;
+ }
+
+ pData->pLastevent = pEvent;
+ pData->bDynamic = MNG_TRUE;
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_EVENT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_event (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_eventp pEvent = (mng_eventp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_EVENT, MNG_LC_START);
+#endif
+
+ if (pEvent->iSegmentnamesize)
+ MNG_FREEX (pData, pEvent->zSegmentname, pEvent->iSegmentnamesize + 1);
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pEvent, sizeof (mng_event));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_EVENT, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_event (mng_datap pData,
+ mng_objectp pObject)
+{
+#ifndef MNG_SKIPCHUNK_SEEK
+ mng_eventp pEvent = (mng_eventp)pObject;
+ mng_object_headerp pAni;
+ mng_bool bFound = MNG_FALSE;
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_EVENT, MNG_LC_START);
+#endif
+
+#ifndef MNG_SKIPCHUNK_SEEK
+ if (!pEvent->pSEEK) /* need to find SEEK first ? */
+ {
+ pAni = (mng_object_headerp)pData->pFirstaniobj;
+
+ while ((pAni) && (!bFound))
+ {
+ if ((pAni->fCleanup == mng_free_ani_seek) &&
+ (strcmp(pEvent->zSegmentname, ((mng_ani_seekp)pAni)->zSegmentname) == 0))
+ bFound = MNG_TRUE;
+ else
+ pAni = (mng_object_headerp)pAni->pNext;
+ }
+
+ if (pAni)
+ pEvent->pSEEK = (mng_ani_seekp)pAni;
+ }
+
+ if (pEvent->pSEEK) /* anything to do ? */
+ {
+ pEvent->iLastx = pData->iEventx;
+ pEvent->iLasty = pData->iEventy;
+ /* let's start from this SEEK then */
+ pData->pCurraniobj = (mng_objectp)pEvent->pSEEK;
+ pData->bRunningevent = MNG_TRUE;
+ /* wake-up the app ! */
+ if (!pData->fSettimer ((mng_handle)pData, 5))
+ MNG_ERROR (pData, MNG_APPTIMERERROR);
+
+ }
+ else
+ MNG_ERROR (pData, MNG_SEEKNOTFOUND);
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_EVENT, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#endif /* MNG_SUPPORT_DYNAMICMNG */
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_MPNG_PROPOSAL
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_mpng_obj (mng_datap pData,
+ mng_uint32 iFramewidth,
+ mng_uint32 iFrameheight,
+ mng_uint16 iNumplays,
+ mng_uint16 iTickspersec,
+ mng_uint32 iFramessize,
+ mng_ptr pFrames)
+#else
+mng_retcode mng_create_mpng_obj (mng_datap pData,
+ mng_ptr pEntry)
+#endif
+{
+ mng_mpng_objp pMPNG;
+ mng_ptr pTemp;
+ mng_retcode iRetcode;
+ mng_uint8p pFrame;
+ mng_int32 iCnt, iMax;
+ mng_uint32 iX, iY, iWidth, iHeight;
+ mng_int32 iXoffset, iYoffset;
+ mng_uint16 iTicks;
+ mng_uint16 iDelay;
+ mng_bool bNewframe;
+ mng_ani_loopp pLOOP;
+ mng_ani_endlp pENDL;
+ mng_ani_framp pFRAM;
+ mng_ani_movep pMOVE;
+ mng_ani_clipp pCLIP;
+ mng_ani_showp pSHOW;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_MPNG_OBJ, MNG_LC_START);
+#endif
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_mpng_obj), mng_free_mpng_obj,
+ mng_process_mpng_obj, &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pMPNG = (mng_mpng_objp)pTemp;
+#else
+ MNG_ALLOC (pData, pMPNG, sizeof (mng_mpng_obj));
+
+ pMPNG->sHeader.fCleanup = mng_free_mpng_obj;
+ pMPNG->sHeader.fProcess = mng_process_mpng_obj;
+#endif
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pMPNG->iFramewidth = iFramewidth;
+ pMPNG->iFrameheight = iFrameheight;
+ pMPNG->iNumplays = iNumplays;
+ pMPNG->iTickspersec = iTickspersec;
+ pMPNG->iFramessize = iFramessize;
+
+ if (iFramessize)
+ {
+ MNG_ALLOC (pData, pMPNG->pFrames, iFramessize);
+ MNG_COPY (pMPNG->pFrames, pFrames, iFramessize);
+ }
+#else
+ pMPNG->iFramewidth = ((mng_mpngp)pEntry)->iFramewidth;
+ pMPNG->iFrameheight = ((mng_mpngp)pEntry)->iFrameheight;
+ pMPNG->iNumplays = ((mng_mpngp)pEntry)->iNumplays;
+ pMPNG->iTickspersec = ((mng_mpngp)pEntry)->iTickspersec;
+ pMPNG->iFramessize = ((mng_mpngp)pEntry)->iFramessize;
+
+ if (pMPNG->iFramessize)
+ {
+ MNG_ALLOC (pData, pMPNG->pFrames, pMPNG->iFramessize);
+ MNG_COPY (pMPNG->pFrames, ((mng_mpngp)pEntry)->pFrames, pMPNG->iFramessize);
+ }
+#endif
+
+ pData->pMPNG = pMPNG;
+ pData->eImagetype = mng_it_mpng;
+
+ iRetcode = mng_process_display_mpng (pData);
+ if (iRetcode)
+ return iRetcode;
+
+ /* now let's create the MNG animation directives from this */
+
+ pFrame = (mng_uint8p)pMPNG->pFrames;
+ iMax = pMPNG->iFramessize / 26;
+ /* set up MNG impersonation */
+ pData->iTicks = pMPNG->iTickspersec;
+ pData->iLayercount = iMax;
+
+ if (pMPNG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
+ mng_free_ani_loop, mng_process_ani_loop,
+ &((mng_ptr)pLOOP));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
+
+ pLOOP->sHeader.fCleanup = mng_free_ani_loop;
+ pLOOP->sHeader.fProcess = mng_process_ani_loop;
+#endif
+
+ pLOOP->iLevel = 1;
+ if (pMPNG->iNumplays)
+ pLOOP->iRepeatcount = pMPNG->iNumplays;
+ else
+ pLOOP->iRepeatcount = 0xFFFFFFFFl;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
+ }
+
+ bNewframe = MNG_TRUE; /* create the frame display objects */
+
+ for (iCnt = 0; iCnt < iMax; iCnt++)
+ {
+ iX = mng_get_uint32 (pFrame);
+ iY = mng_get_uint32 (pFrame+4);
+ iWidth = mng_get_uint32 (pFrame+8);
+ iHeight = mng_get_uint32 (pFrame+12);
+ iXoffset = mng_get_int32 (pFrame+16);
+ iYoffset = mng_get_int32 (pFrame+20);
+ iTicks = mng_get_uint16 (pFrame+24);
+
+ iDelay = iTicks;
+ if (!iDelay)
+ {
+ mng_uint8p pTemp = pFrame+26;
+ mng_int32 iTemp = iCnt+1;
+
+ while ((iTemp < iMax) && (!iDelay))
+ {
+ iDelay = mng_get_uint16 (pTemp+24);
+ pTemp += 26;
+ iTemp++;
+ }
+ }
+
+ if (bNewframe)
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
+ mng_free_obj_general, mng_process_ani_fram,
+ &((mng_ptr)pFRAM));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
+
+ pFRAM->sHeader.fCleanup = mng_free_ani_fram;
+ pFRAM->sHeader.fProcess = mng_process_ani_fram;
+#endif
+
+ pFRAM->iFramemode = 4;
+ pFRAM->iChangedelay = 1;
+ pFRAM->iDelay = iDelay;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
+ }
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
+ mng_free_obj_general,
+ mng_process_ani_move,
+ &((mng_ptr)pMOVE));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
+
+ pMOVE->sHeader.fCleanup = mng_free_ani_move;
+ pMOVE->sHeader.fProcess = mng_process_ani_move;
+#endif
+
+ pMOVE->iLocax = iXoffset - (mng_int32)iX;
+ pMOVE->iLocay = iYoffset - (mng_int32)iY;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_clip),
+ mng_free_obj_general,
+ mng_process_ani_clip,
+ &((mng_ptr)pCLIP));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pCLIP, sizeof (mng_ani_clip));
+
+ pCLIP->sHeader.fCleanup = mng_free_ani_clip;
+ pCLIP->sHeader.fProcess = mng_process_ani_clip;
+#endif
+
+ pCLIP->iClipl = iXoffset;
+ pCLIP->iClipr = iXoffset + (mng_int32)iWidth;
+ pCLIP->iClipt = iYoffset;
+ pCLIP->iClipb = iYoffset + (mng_int32)iHeight;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pCLIP);
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
+ mng_free_obj_general, mng_process_ani_show,
+ &((mng_ptr)pSHOW));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
+
+ pSHOW->sHeader.fCleanup = mng_free_ani_show;
+ pSHOW->sHeader.fProcess = mng_process_ani_show;
+#endif
+
+ mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
+
+ bNewframe = (mng_bool)iTicks;
+ pFrame += 26;
+ }
+
+ if (pMPNG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
+ mng_free_obj_general, mng_process_ani_endl,
+ &((mng_ptr)pENDL));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
+
+ pENDL->sHeader.fCleanup = mng_free_ani_endl;
+ pENDL->sHeader.fProcess = mng_process_ani_endl;
+#endif
+
+ pENDL->iLevel = 1;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pENDL);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_MPNG_OBJ, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_mpng_obj (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_mpng_objp pMPNG = (mng_mpng_objp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_MPNG_OBJ, MNG_LC_START);
+#endif
+
+ if (pMPNG->iFramessize)
+ MNG_FREEX (pData, pMPNG->pFrames, pMPNG->iFramessize);
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pMPNG, sizeof (mng_mpng_obj));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_MPNG_OBJ, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_mpng_obj (mng_datap pData,
+ mng_objectp pObject)
+{
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#endif /* MNG_INCLUDE_MPNG_PROPOSAL */
+
+/* ************************************************************************** */
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_ANG_PROPOSAL
+
+/* ************************************************************************** */
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+mng_retcode mng_create_ang_obj (mng_datap pData,
+ mng_uint32 iNumframes,
+ mng_uint32 iTickspersec,
+ mng_uint32 iNumplays,
+ mng_uint32 iTilewidth,
+ mng_uint32 iTileheight,
+ mng_uint8 iInterlace,
+ mng_uint8 iStillused)
+#else
+mng_retcode mng_create_ang_obj (mng_datap pData,
+ mng_ptr pEntry)
+#endif
+{
+ mng_ang_objp pANG;
+ mng_ptr pTemp;
+ mng_retcode iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANG_OBJ, MNG_LC_START);
+#endif
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ang_obj), mng_free_ang_obj,
+ mng_process_ang_obj, &pTemp);
+ if (iRetcode)
+ return iRetcode;
+ pANG = (mng_ang_objp)pTemp;
+#else
+ MNG_ALLOC (pData, pANG, sizeof (mng_ang_obj));
+
+ pANG->sHeader.fCleanup = mng_free_ang_obj;
+ pANG->sHeader.fProcess = mng_process_ang_obj;
+#endif
+
+#ifndef MNG_OPTIMIZE_CHUNKREADER
+ pANG->iNumframes = iNumframes;
+ pANG->iTickspersec = iTickspersec;
+ pANG->iNumplays = iNumplays;
+ pANG->iTilewidth = iTilewidth;
+ pANG->iTileheight = iTileheight;
+ pANG->iInterlace = iInterlace;
+ pANG->iStillused = iStillused;
+#else
+ pANG->iNumframes = ((mng_ahdrp)pEntry)->iNumframes;
+ pANG->iTickspersec = ((mng_ahdrp)pEntry)->iTickspersec;
+ pANG->iNumplays = ((mng_ahdrp)pEntry)->iNumplays;
+ pANG->iTilewidth = ((mng_ahdrp)pEntry)->iTilewidth;
+ pANG->iTileheight = ((mng_ahdrp)pEntry)->iTileheight;
+ pANG->iInterlace = ((mng_ahdrp)pEntry)->iInterlace;
+ pANG->iStillused = ((mng_ahdrp)pEntry)->iStillused;
+#endif
+
+ pData->pANG = pANG;
+ pData->eImagetype = mng_it_ang;
+
+ iRetcode = mng_process_display_ang (pData);
+ if (iRetcode)
+ return iRetcode;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_CREATE_ANG_OBJ, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_free_ang_obj (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ang_objp pANG = (mng_ang_objp)pObject;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANG_OBJ, MNG_LC_START);
+#endif
+
+ if (pANG->iTilessize)
+ MNG_FREEX (pData, pANG->pTiles, pANG->iTilessize);
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ MNG_FREEX (pData, pANG, sizeof (mng_ang_obj));
+#endif
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_FREE_ANG_OBJ, MNG_LC_END);
+#endif
+
+#ifndef MNG_OPTIMIZE_OBJCLEANUP
+ return MNG_NOERROR;
+#else
+ return mng_free_obj_general(pData, pObject);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mng_process_ang_obj (mng_datap pData,
+ mng_objectp pObject)
+{
+ mng_ang_objp pANG = (mng_ang_objp)pObject;
+ mng_uint8p pTile = (mng_uint8p)pANG->pTiles;
+ mng_retcode iRetcode;
+ mng_int32 iCnt, iMax;
+ mng_uint32 iTicks;
+ mng_int32 iXoffset, iYoffset;
+ mng_uint8 iSource;
+ mng_ani_loopp pLOOP;
+ mng_ani_endlp pENDL;
+ mng_ani_framp pFRAM;
+ mng_ani_movep pMOVE;
+ mng_ani_showp pSHOW;
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANG_OBJ, MNG_LC_START);
+#endif
+
+ /* let's create the MNG animation directives from this */
+
+ iMax = pANG->iNumframes;
+ /* set up MNG impersonation */
+ pData->iTicks = pANG->iTickspersec;
+ pData->iLayercount = iMax;
+
+ if (pANG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
+ mng_free_ani_loop, mng_process_ani_loop,
+ &((mng_ptr)pLOOP));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
+
+ pLOOP->sHeader.fCleanup = mng_free_ani_loop;
+ pLOOP->sHeader.fProcess = mng_process_ani_loop;
+#endif
+
+ pLOOP->iLevel = 1;
+ if (pANG->iNumplays)
+ pLOOP->iRepeatcount = pANG->iNumplays;
+ else
+ pLOOP->iRepeatcount = 0xFFFFFFFFl;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
+ }
+
+ for (iCnt = 0; iCnt < iMax; iCnt++)
+ {
+ iTicks = mng_get_uint32 (pTile);
+ iXoffset = mng_get_int32 (pTile+4);
+ iYoffset = mng_get_int32 (pTile+8);
+ iSource = *(pTile+12);
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
+ mng_free_obj_general, mng_process_ani_fram,
+ &((mng_ptr)pFRAM));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
+
+ pFRAM->sHeader.fCleanup = mng_free_ani_fram;
+ pFRAM->sHeader.fProcess = mng_process_ani_fram;
+#endif
+
+ pFRAM->iFramemode = 4;
+ pFRAM->iChangedelay = 1;
+ pFRAM->iDelay = iTicks;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
+
+ if (!iSource)
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
+ mng_free_obj_general,
+ mng_process_ani_move,
+ &((mng_ptr)pMOVE));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
+
+ pMOVE->sHeader.fCleanup = mng_free_ani_move;
+ pMOVE->sHeader.fProcess = mng_process_ani_move;
+#endif
+
+ pMOVE->iFirstid = 1;
+ pMOVE->iLastid = 1;
+ pMOVE->iLocax = -iXoffset;
+ pMOVE->iLocay = -iYoffset;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
+ }
+
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
+ mng_free_obj_general, mng_process_ani_show,
+ &((mng_ptr)pSHOW));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
+
+ pSHOW->sHeader.fCleanup = mng_free_ani_show;
+ pSHOW->sHeader.fProcess = mng_process_ani_show;
+#endif
+
+ if (iSource)
+ pSHOW->iFirstid = 0;
+ else
+ pSHOW->iFirstid = 1;
+ pSHOW->iLastid = pSHOW->iFirstid;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
+
+ pTile += sizeof(mng_adat_tile);
+ }
+
+ if (pANG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
+ {
+#ifdef MNG_OPTIMIZE_OBJCLEANUP
+ iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
+ mng_free_obj_general, mng_process_ani_endl,
+ &((mng_ptr)pENDL));
+ if (iRetcode)
+ return iRetcode;
+#else
+ MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
+
+ pENDL->sHeader.fCleanup = mng_free_ani_endl;
+ pENDL->sHeader.fProcess = mng_process_ani_endl;
+#endif
+
+ pENDL->iLevel = 1;
+
+ mng_add_ani_object (pData, (mng_object_headerp)pENDL);
+ }
+
+#ifdef MNG_SUPPORT_TRACE
+ MNG_TRACE (pData, MNG_FN_PROCESS_ANG_OBJ, MNG_LC_END);
+#endif
+
+ return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+#endif /* MNG_INCLUDE_ANG_PROPOSAL */
+
+/* ************************************************************************** */
+
+#endif /* MNG_INCLUDE_DISPLAY_PROCS */
+
+/* ************************************************************************** */
+/* * end of file * */
+/* ************************************************************************** */
+
generated by cgit v0.12 at 2024-12-01 09:40:13 (GMT)