summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/libmng/libmng_data.h
diff options
context:
space:
mode:
authorQt by Nokia <qt-info@nokia.com>2011-04-27 12:05:43 +0200
committeraxis <qt-info@nokia.com>2011-04-27 12:05:43 +0200
commit38be0d13830efd2d98281c645c3a60afe05ffece (patch)
tree6ea73f3ec77f7d153333779883e8120f82820abe /src/3rdparty/libmng/libmng_data.h
Initial import from the monolithic Qt.
This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
Diffstat (limited to 'src/3rdparty/libmng/libmng_data.h')
-rw-r--r--src/3rdparty/libmng/libmng_data.h1032
1 files changed, 1032 insertions, 0 deletions
diff --git a/src/3rdparty/libmng/libmng_data.h b/src/3rdparty/libmng/libmng_data.h
new file mode 100644
index 0000000000..6a007632d5
--- /dev/null
+++ b/src/3rdparty/libmng/libmng_data.h
@@ -0,0 +1,1032 @@
+/* ************************************************************************** */
+/* * For conditions of distribution and use, * */
+/* * see copyright notice in libmng.h * */
+/* ************************************************************************** */
+/* * * */
+/* * project : libmng * */
+/* * file : libmng_data.h copyright (c) 2000-2007 G.Juyn * */
+/* * version : 1.0.10 * */
+/* * * */
+/* * purpose : main data structure definition * */
+/* * * */
+/* * author : G.Juyn * */
+/* * * */
+/* * comment : Definition of the library main data structure * */
+/* * * */
+/* * changes : 0.5.1 - 05/04/2000 - G.Juyn * */
+/* * - added CRC table to main structure (for thread-safety) * */
+/* * 0.5.1 - 05/06/2000 - G.Juyn * */
+/* * - added iPLTEentries for checking hIST-length * */
+/* * 0.5.1 - 05/08/2000 - G.Juyn * */
+/* * - changed palette definition to exported palette-type * */
+/* * - removed frozen indicator * */
+/* * - added create/write indicators * */
+/* * - changed strict-ANSI stuff * */
+/* * 0.5.1 - 05/13/2000 - G.Juyn * */
+/* * - added eMNGma hack (will be removed in 1.0.0 !!!) * */
+/* * - added TERM animation object pointer (easier reference) * */
+/* * - added saved-data structure for SAVE/SEEK processing * */
+/* * * */
+/* * 0.5.2 - 05/18/2000 - G.Juyn * */
+/* * - added fields for JNG support (IJG-based) * */
+/* * 0.5.2 - 05/24/2000 - G.Juyn * */
+/* * - changed global tRNS definition * */
+/* * 0.5.2 - 05/30/2000 - G.Juyn * */
+/* * - added delta-image fields * */
+/* * 0.5.2 - 06/01/2000 - G.Juyn * */
+/* * - added internal delta-image processing callbacks * */
+/* * 0.5.2 - 06/02/2000 - G.Juyn * */
+/* * - changed SWAP_ENDIAN to BIGENDIAN_SUPPORTED * */
+/* * (contributed by Tim Rowley) * */
+/* * - added getalphaline callback for RGB8_A8 canvasstyle * */
+/* * 0.5.2 - 06/06/2000 - G.Juyn * */
+/* * - added parameter for delayed buffer-processing * */
+/* * * */
+/* * 0.5.3 - 06/16/2000 - G.Juyn * */
+/* * - added update-region parms for refresh calback * */
+/* * - added Needrefresh parameter * */
+/* * 0.5.3 - 06/17/2000 - G.Juyn * */
+/* * - added Deltaimmediate parm for faster delta-processing * */
+/* * 0.5.3 - 06/21/2000 - G.Juyn * */
+/* * - added Speed parameter to facilitate testing * */
+/* * - added Imagelevel parameter for processtext callback * */
+/* * 0.5.3 - 06/26/2000 - G.Juyn * */
+/* * - changed userdata variable to mng_ptr * */
+/* * * */
+/* * 0.9.1 - 07/07/2000 - G.Juyn * */
+/* * - added variables for go_xxxx processing * */
+/* * 0.9.1 - 07/08/2000 - G.Juyn * */
+/* * - added variables for improved timing support * */
+/* * 0.9.1 - 07/15/2000 - G.Juyn * */
+/* * - added callbacks for SAVE/SEEK processing * */
+/* * - added variable for NEEDSECTIONWAIT breaks * */
+/* * - added variable for freeze & reset processing * */
+/* * 0.9.1 - 07/17/2000 - G.Juyn * */
+/* * - fixed suspension-buffering for 32K+ chunks * */
+/* * * */
+/* * 0.9.2 - 07/29/2000 - G.Juyn * */
+/* * - removed Nextbackxxx fields (no longer used) * */
+/* * 0.9.2 - 07/31/2000 - G.Juyn * */
+/* * - fixed wrapping of suspension parameters * */
+/* * 0.9.2 - 08/04/2000 - G.Juyn * */
+/* * - B111096 - fixed large-buffer read-suspension * */
+/* * 0.9.2 - 08/05/2000 - G.Juyn * */
+/* * - changed file-prefixes * */
+/* * * */
+/* * 0.9.3 - 08/26/2000 - G.Juyn * */
+/* * - added MAGN chunk * */
+/* * 0.9.3 - 09/07/2000 - G.Juyn * */
+/* * - added support for new filter_types * */
+/* * 0.9.3 - 09/10/2000 - G.Juyn * */
+/* * - fixed DEFI behavior * */
+/* * 0.9.3 - 10/10/2000 - G.Juyn * */
+/* * - added support for alpha-depth prediction * */
+/* * 0.9.3 - 10/11/2000 - G.Juyn * */
+/* * - added support for nEED * */
+/* * 0.9.3 - 10/16/2000 - G.Juyn * */
+/* * - added optional support for bKGD for PNG images * */
+/* * - added support for JDAA * */
+/* * 0.9.3 - 10/17/2000 - G.Juyn * */
+/* * - added callback to process non-critical unknown chunks * */
+/* * - fixed support for bKGD * */
+/* * 0.9.3 - 10/19/2000 - G.Juyn * */
+/* * - implemented delayed delta-processing * */
+/* * 0.9.4 - 12/16/2000 - G.Juyn * */
+/* * - fixed mixup of data- & function-pointers (thanks Dimitri)* */
+/* * * */
+/* * 1.0.1 - 02/08/2001 - G.Juyn * */
+/* * - added MEND processing callback * */
+/* * 1.0.1 - 02/13/2001 - G.Juyn * */
+/* * - fixed first FRAM_MODE=4 timing problem * */
+/* * * */
+/* * 1.0.2 - 06/23/2001 - G.Juyn * */
+/* * - added optimization option for MNG-video playback * */
+/* * - added processterm callback * */
+/* * 1.0.2 - 06/25/2001 - G.Juyn * */
+/* * - added option to turn off progressive refresh * */
+/* * * */
+/* * 1.0.5 - 07/08/2002 - G.Juyn * */
+/* * - B578572 - removed eMNGma hack (thanks Dimitri!) * */
+/* * 1.0.5 - 07/16/2002 - G.Juyn * */
+/* * - B581625 - large chunks fail with suspension reads * */
+/* * 1.0.5 - 08/15/2002 - G.Juyn * */
+/* * - completed PROM support * */
+/* * 1.0.5 - 09/15/2002 - G.Juyn * */
+/* * - fixed LOOP iteration=0 special case * */
+/* * 1.0.5 - 09/20/2002 - G.Juyn * */
+/* * - finished support for BACK image & tiling * */
+/* * 1.0.5 - 10/07/2002 - G.Juyn * */
+/* * - added another fix for misplaced TERM chunk * */
+/* * - completed support for condition=2 in TERM chunk * */
+/* * 1.0.5 - 10/20/2002 - G.Juyn * */
+/* * - fixed processing for multiple objects in MAGN * */
+/* * - fixed display of visible target of PAST operation * */
+/* * 1.0.5 - 11/07/2002 - G.Juyn * */
+/* * - added support to get totals after mng_read() * */
+/* * 1.0.5 - 24/02/2003 - G.Juyn * */
+/* * - B683152 - libjpeg suspension not always honored correctly* */
+/* * * */
+/* * 1.0.6 - 04/11/2003 - G.Juyn * */
+/* * - B719420 - fixed several MNG_APP_CMS problems * */
+/* * 1.0.6 - 07/05/2003 - G. R-P * */
+/* * - optionally use zlib's crc32() function * */
+/* * 1.0.6 - 07/29/2003 - G.R-P * */
+/* * - added SKIPCHUNK conditionals around PAST chunk support * */
+/* * 1.0.6 - 08/17/2003 - G.R-P * */
+/* * - added iPNGdepth member to pData structure * */
+/* * * */
+/* * 1.0.7 - 03/10/2004 - G.R-P * */
+/* * - added conditionals around openstream/closestream * */
+/* * 1.0.7 - 03/24/2004 - G.R-P * */
+/* * - added more SKIPCHUNK conditionals * */
+/* * * */
+/* * 1.0.8 - 04/02/2004 - G.Juyn * */
+/* * - added CRC existence & checking flags * */
+/* * 1.0.8 - 04/10/2004 - G.Juyn * */
+/* * - added data-push mechanisms for specialized decoders * */
+/* * * */
+/* * 1.0.9 - 12/11/2004 - G.Juyn * */
+/* * - added conditional MNG_OPTIMIZE_DISPLAYCALLS * */
+/* * * */
+/* * 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 * */
+/* * * */
+/* ************************************************************************** */
+
+#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
+#pragma option -A /* force ANSI-C */
+#endif
+
+#ifndef _libmng_data_h_
+#define _libmng_data_h_
+
+/* ************************************************************************** */
+
+#define MNG_MAGIC 0x52530a0aL
+
+/* ************************************************************************** */
+/* * * */
+/* * Internal structures * */
+/* * * */
+/* ************************************************************************** */
+
+typedef mng_palette8 mng_rgbpaltab;
+
+/* ************************************************************************** */
+/* * * */
+/* * The saved_data structure * */
+/* * * */
+/* * This contains the saved data after a SAVE chunk has been processed. * */
+/* * The data is saved from the main data structure during SAVE processing, * */
+/* * and restored to the main data structure during SEEK processing. * */
+/* * * */
+/* ************************************************************************** */
+
+typedef struct mng_savedata_struct {
+
+#if defined(MNG_SUPPORT_READ) || defined(MNG_SUPPORT_WRITE)
+ mng_bool bHasglobalPLTE; /* global PLTE chunk processed */
+ mng_bool bHasglobalTRNS; /* global tRNS chunk processed */
+ mng_bool bHasglobalGAMA; /* global gAMA chunk processed */
+ mng_bool bHasglobalCHRM; /* global cHRM chunk processed */
+ mng_bool bHasglobalSRGB; /* global sRGB chunk processed */
+ mng_bool bHasglobalICCP; /* global iCCP chunk processed */
+ mng_bool bHasglobalBKGD; /* global bKGD chunk processed */
+#endif /* MNG_SUPPORT_READ || MNG_SUPPORT_WRITE */
+
+#ifdef MNG_SUPPORT_DISPLAY
+ mng_uint16 iBACKred; /* BACK fields */
+ mng_uint16 iBACKgreen;
+ mng_uint16 iBACKblue;
+ mng_uint8 iBACKmandatory;
+ mng_uint16 iBACKimageid;
+ mng_uint8 iBACKtile;
+
+ mng_uint8 iFRAMmode; /* FRAM fields (global) */
+ mng_uint32 iFRAMdelay;
+ mng_uint32 iFRAMtimeout;
+ mng_bool bFRAMclipping;
+ mng_int32 iFRAMclipl;
+ mng_int32 iFRAMclipr;
+ mng_int32 iFRAMclipt;
+ mng_int32 iFRAMclipb;
+
+ mng_uint32 iGlobalPLTEcount; /* global PLTE fields */
+ mng_rgbpaltab aGlobalPLTEentries;
+
+ mng_uint32 iGlobalTRNSrawlen; /* global tRNS fields */
+ mng_uint8arr aGlobalTRNSrawdata;
+
+ mng_uint32 iGlobalGamma; /* global gAMA fields */
+
+#ifndef MNG_SKIPCHUNK_cHRM
+ mng_uint32 iGlobalWhitepointx; /* global cHRM fields */
+ mng_uint32 iGlobalWhitepointy;
+ mng_uint32 iGlobalPrimaryredx;
+ mng_uint32 iGlobalPrimaryredy;
+ mng_uint32 iGlobalPrimarygreenx;
+ mng_uint32 iGlobalPrimarygreeny;
+ mng_uint32 iGlobalPrimarybluex;
+ mng_uint32 iGlobalPrimarybluey;
+#endif
+
+ mng_uint8 iGlobalRendintent; /* global sRGB fields */
+
+ mng_uint32 iGlobalProfilesize; /* global iCCP fields */
+ mng_ptr pGlobalProfile;
+
+ mng_uint16 iGlobalBKGDred; /* global bKGD fields */
+ mng_uint16 iGlobalBKGDgreen;
+ mng_uint16 iGlobalBKGDblue;
+#endif /* MNG_SUPPORT_DISPLAY */
+
+ } mng_savedata;
+
+typedef mng_savedata * mng_savedatap;
+
+/* ************************************************************************** */
+/* * * */
+/* * Internal buffer structure for data push mechanisms * */
+/* * * */
+/* ************************************************************************** */
+
+typedef struct {
+ mng_ptr pNext; /* for linked list */
+ mng_ptr pData; /* used for chunks & data */
+ mng_uint32 iLength;
+ mng_bool bOwned;
+ mng_uint8p pDatanext; /* only used for data */
+ mng_uint32 iRemaining;
+ } mng_pushdata;
+typedef mng_pushdata * mng_pushdatap;
+
+/* ************************************************************************** */
+/* * * */
+/* * The main libmng data structure * */
+/* * * */
+/* * The handle used in all functions points to this structure which * */
+/* * contains all volatile data necessary to process the network graphic. * */
+/* * * */
+/* ************************************************************************** */
+
+typedef struct mng_data_struct {
+
+ mng_uint32 iMagic; /* magic number to validate
+ a given handle */
+ mng_ptr pUserdata; /* application workdata */
+
+ mng_imgtype eSigtype; /* image information */
+ mng_imgtype eImagetype; /* initially zeroed */
+ mng_uint32 iWidth; /* filled after header is processed */
+ mng_uint32 iHeight;
+ mng_uint32 iTicks; /* these only after MHDR */
+ mng_uint32 iLayercount;
+ mng_uint32 iFramecount;
+ mng_uint32 iPlaytime;
+ mng_uint32 iSimplicity;
+ mng_uint8 iAlphadepth; /* indicates expected alpha-depth */
+
+ mng_uint32 iImagelevel; /* level of image inside a stream */
+
+ mng_uint32 iCanvasstyle; /* layout of the drawing-canvas */
+ mng_uint32 iBkgdstyle; /* layout of the background-canvas */
+
+ mng_int8 iMagnify; /* magnification factor (not used yet) */
+ mng_uint32 iOffsetx; /* x-offset for extremely large image */
+ mng_uint32 iOffsety; /* y-offset for extremely large image */
+ mng_uint32 iCanvaswidth; /* real canvas size */
+ mng_uint32 iCanvasheight; /* must be set by processheader callback */
+
+ mng_uint16 iBGred; /* default background color */
+ mng_uint16 iBGgreen; /* initially "black" */
+ mng_uint16 iBGblue;
+ mng_bool bUseBKGD; /* preferred use of bKGD for PNG */
+
+ mng_bool bIssRGB; /* indicates sRGB system */
+
+#ifdef MNG_FULL_CMS /* little CMS variables */
+ mng_cmsprof hProf1; /* image input profile */
+ mng_cmsprof hProf2; /* default output profile */
+ mng_cmsprof hProf3; /* default sRGB profile */
+ mng_cmstrans hTrans; /* current transformation handle */
+#endif
+
+ mng_float dViewgamma; /* gamma calculation variables */
+ mng_float dDisplaygamma; /* initially set for sRGB conditions */
+ mng_float dDfltimggamma;
+
+ mng_bool bStorechunks; /* switch for storing chunkdata */
+ mng_bool bSectionbreaks; /* indicate NEEDSECTIONWAIT breaks */
+ mng_bool bCacheplayback; /* switch to cache playback info */
+ mng_bool bDoProgressive; /* progressive refresh for large images */
+ mng_uint32 iCrcmode; /* CRC existence & checking flags */
+
+ mng_speedtype iSpeed; /* speed-modifier for animations */
+
+ mng_uint32 iMaxwidth; /* maximum canvas size */
+ mng_uint32 iMaxheight; /* initially set to 1024 x 1024 */
+
+ mng_int32 iErrorcode; /* error reporting fields */
+ mng_int8 iSeverity;
+ mng_int32 iErrorx1;
+ mng_int32 iErrorx2;
+ mng_pchar zErrortext;
+
+ mng_memalloc fMemalloc; /* callback pointers */
+ mng_memfree fMemfree; /* initially nulled */
+ mng_releasedata fReleasedata;
+#ifndef MNG_NO_OPEN_CLOSE_STREAM
+ mng_openstream fOpenstream;
+ mng_closestream fClosestream;
+#endif
+ mng_readdata fReaddata;
+ mng_writedata fWritedata;
+ mng_errorproc fErrorproc;
+ mng_traceproc fTraceproc;
+ mng_processheader fProcessheader;
+ mng_processtext fProcesstext;
+ mng_processsave fProcesssave;
+ mng_processseek fProcessseek;
+ mng_processneed fProcessneed;
+ mng_processmend fProcessmend;
+ mng_processunknown fProcessunknown;
+ mng_processterm fProcessterm;
+ mng_getcanvasline fGetcanvasline;
+ mng_getbkgdline fGetbkgdline;
+ mng_getalphaline fGetalphaline;
+ mng_refresh fRefresh;
+ mng_gettickcount fGettickcount;
+ mng_settimer fSettimer;
+ mng_processgamma fProcessgamma;
+ mng_processchroma fProcesschroma;
+ mng_processsrgb fProcesssrgb;
+ mng_processiccp fProcessiccp;
+ mng_processarow fProcessarow;
+
+#if defined(MNG_SUPPORT_READ) || defined(MNG_SUPPORT_WRITE)
+#ifndef MNG_NO_OLD_VERSIONS
+ mng_bool bPreDraft48; /* flags ancient style draft */
+#endif
+
+ mng_chunkid iChunkname; /* read/write-state variables */
+ mng_uint32 iChunkseq;
+ mng_chunkp pFirstchunk; /* double-linked list of */
+ mng_chunkp pLastchunk; /* stored chunk-structures */
+
+ mng_bool bHasheader; /* first header chunk processed */
+ mng_bool bHasMHDR; /* inside a MHDR-MEND sequence */
+ mng_bool bHasIHDR; /* inside a IHDR-IEND sequence */
+ mng_bool bHasBASI; /* inside a BASI-IEND sequence */
+ mng_bool bHasDHDR; /* inside a DHDR-IEND sequence */
+#ifdef MNG_INCLUDE_JNG
+ mng_bool bHasJHDR; /* inside a JHDR-IEND sequence */
+ mng_bool bHasJSEP; /* passed the JSEP separator */
+ mng_bool bHasJDAA; /* at least 1 JDAA processed */
+ mng_bool bHasJDAT; /* at least 1 JDAT processed */
+#endif
+ mng_bool bHasPLTE; /* PLTE chunk processed */
+ mng_bool bHasTRNS; /* tRNS chunk processed */
+ mng_bool bHasGAMA; /* gAMA chunk processed */
+ mng_bool bHasCHRM; /* cHRM chunk processed */
+ mng_bool bHasSRGB; /* sRGB chunk processed */
+ mng_bool bHasICCP; /* iCCP chunk processed */
+ mng_bool bHasBKGD; /* bKGD chunk processed */
+ mng_bool bHasIDAT; /* at least 1 IDAT processed */
+
+ mng_bool bHasSAVE; /* SAVE chunk processed */
+ mng_bool bHasBACK; /* BACK chunk processed */
+ mng_bool bHasFRAM; /* FRAM chunk processed */
+ mng_bool bHasTERM; /* TERM chunk processed */
+ mng_bool bHasLOOP; /* at least 1 LOOP open */
+
+ mng_bool bHasglobalPLTE; /* global PLTE chunk processed */
+ mng_bool bHasglobalTRNS; /* global tRNS chunk processed */
+ mng_bool bHasglobalGAMA; /* global gAMA chunk processed */
+ mng_bool bHasglobalCHRM; /* global cHRM chunk processed */
+ mng_bool bHasglobalSRGB; /* global sRGB chunk processed */
+ mng_bool bHasglobalICCP; /* global iCCP chunk processed */
+ mng_bool bHasglobalBKGD; /* global bKGD chunk processed */
+
+ mng_uint32 iDatawidth; /* IHDR/BASI/DHDR fields */
+ mng_uint32 iDataheight; /* valid if inside IHDR-IEND, */
+ mng_uint8 iBitdepth; /* BASI-IEND or DHDR-IEND */
+ mng_uint8 iColortype;
+ mng_uint8 iCompression;
+ mng_uint8 iFilter;
+ mng_uint8 iInterlace;
+
+ mng_uint32 iPLTEcount; /* PLTE fields */
+
+#ifdef MNG_INCLUDE_JNG
+ mng_uint8 iJHDRcolortype; /* JHDR fields */
+ mng_uint8 iJHDRimgbitdepth; /* valid if inside JHDR-IEND */
+ mng_uint8 iJHDRimgcompression;
+ mng_uint8 iJHDRimginterlace;
+ mng_uint8 iJHDRalphabitdepth;
+ mng_uint8 iJHDRalphacompression;
+ mng_uint8 iJHDRalphafilter;
+ mng_uint8 iJHDRalphainterlace;
+#endif
+
+#endif /* MNG_SUPPORT_READ || MNG_SUPPORT_WRITE */
+
+#ifdef MNG_SUPPORT_READ
+ mng_bool bReading; /* read processing variables */
+ mng_bool bHavesig;
+ mng_bool bEOF;
+ mng_uint32 iReadbufsize;
+ mng_uint8p pReadbuf;
+
+ mng_uint32 iLargebufsize; /* temp for very large chunks */
+ mng_uint8p pLargebuf;
+
+ mng_uint32 iSuspendtime; /* tickcount at last suspension */
+ mng_bool bSuspended; /* input-reading has been suspended;
+ we're expecting a call to
+ mng_read_resume! */
+ mng_uint8 iSuspendpoint; /* indicates at which point the flow
+ was broken to suspend input-reading */
+
+ mng_bool bSuspensionmode; /* I/O-suspension variables */
+ mng_uint32 iSuspendbufsize;
+ mng_uint8p pSuspendbuf;
+ mng_uint8p pSuspendbufnext;
+ mng_uint32 iSuspendbufleft;
+ mng_uint32 iChunklen; /* chunk length */
+ mng_uint8p pReadbufnext; /* 32K+ suspension-processing */
+ mng_uint8p pLargebufnext;
+
+ mng_pushdatap pFirstpushchunk; /* variables for push mechanisms */
+ mng_pushdatap pLastpushchunk;
+ mng_pushdatap pFirstpushdata;
+ mng_pushdatap pLastpushdata;
+#endif /* MNG_SUPPORT_READ */
+
+#ifdef MNG_SUPPORT_WRITE
+ mng_bool bCreating; /* create/write processing variables */
+ mng_bool bWriting;
+ mng_chunkid iFirstchunkadded;
+ mng_uint32 iWritebufsize;
+ mng_uint8p pWritebuf;
+#endif
+
+#ifdef MNG_SUPPORT_DISPLAY
+ mng_bool bDisplaying; /* display-state variables */
+ mng_bool bFramedone;
+ mng_uint32 iFrameseq;
+ mng_uint32 iLayerseq;
+ mng_uint32 iFrametime; /* millisecs */
+
+ mng_uint32 iTotalframes; /* end-totals after mng_read() */
+ mng_uint32 iTotallayers;
+ mng_uint32 iTotalplaytime; /* millisecs */
+
+ mng_bool bSkipping; /* LOOP iteration=0 */
+
+#ifdef MNG_SUPPORT_DYNAMICMNG
+ mng_bool bDynamic; /* MNG is dynamic (eg. has events) */
+ mng_bool bRunningevent; /* currently processing an event */
+ mng_bool bStopafterseek; /* stop after next SEEK */
+ mng_int32 iEventx; /* X/Y of current event */
+ mng_int32 iEventy;
+ mng_objectp pLastmousemove; /* last event triggered */
+#endif
+
+ mng_uint32 iRequestframe; /* go_xxxx variables */
+ mng_uint32 iRequestlayer;
+ mng_uint32 iRequesttime;
+ mng_bool bSearching;
+
+ mng_bool bRestorebkgd; /* flags restore required before IDAT/JDAT */
+
+ mng_uint32 iRuntime; /* millisecs since start */
+ mng_uint32 iSynctime; /* tickcount at last framesync */
+ mng_uint32 iStarttime; /* tickcount at start */
+ mng_uint32 iEndtime; /* tickcount at end */
+ mng_bool bRunning; /* animation is active */
+ mng_bool bTimerset; /* the timer has been set;
+ we're expecting a call to
+ mng_display_resume! */
+ mng_uint8 iBreakpoint; /* indicates at which point the
+ flow was broken to run the timer */
+ mng_bool bSectionwait; /* indicates a section break */
+ mng_bool bFreezing; /* indicates app requested a freeze */
+ mng_bool bResetting; /* indicates app requested a reset */
+ mng_bool bNeedrefresh; /* indicates screen-refresh is needed */
+ mng_bool bMisplacedTERM; /* indicates TERM is out of place */
+ mng_bool bOnlyfirstframe; /* show first frame after TERM and stop */
+ mng_uint32 iFramesafterTERM; /* determines frame-count after TERM */
+ mng_objectp pCurrentobj; /* current "object" */
+ mng_objectp pCurraniobj; /* current animation object
+ "to be"/"being" processed */
+ mng_objectp pTermaniobj; /* TERM animation object */
+ mng_uint32 iIterations; /* TERM/MEND iteration count */
+ mng_objectp pObjzero; /* "on-the-fly" image (object = 0) */
+ mng_objectp pLastclone; /* last clone */
+ mng_objectp pStoreobj; /* current store object for row routines */
+ mng_objectp pStorebuf; /* current store object-buffer for row routines */
+ mng_objectp pRetrieveobj; /* current retrieve object for row routines */
+ mng_savedatap pSavedata; /* pointer to saved data (after SAVE) */
+
+ mng_uint32 iUpdateleft; /* update region for refresh */
+ mng_uint32 iUpdateright;
+ mng_uint32 iUpdatetop;
+ mng_uint32 iUpdatebottom;
+
+ mng_int8 iPass; /* current interlacing pass;
+ negative value means no interlace */
+ mng_int32 iRow; /* current row counter */
+ mng_int32 iRowinc; /* row increment for this pass */
+ mng_int32 iCol; /* current starting column */
+ mng_int32 iColinc; /* column increment for this pass */
+ mng_int32 iRowsamples; /* nr. of samples in current workrow */
+ mng_int32 iSamplemul; /* needed to calculate rowsize */
+ mng_int32 iSampleofs; /* from rowsamples */
+ mng_int32 iSamplediv;
+ mng_int32 iRowsize; /* size of actual data in work row */
+ mng_int32 iRowmax; /* maximum size of data in work row */
+ mng_int32 iFilterofs; /* offset to filter-byte in work row */
+ mng_int32 iPixelofs; /* offset to pixel-bytes in work row */
+ mng_uint32 iLevel0; /* leveling variables */
+ mng_uint32 iLevel1;
+ mng_uint32 iLevel2;
+ mng_uint32 iLevel3;
+ mng_uint8p pWorkrow; /* working row of pixel-data */
+ mng_uint8p pPrevrow; /* previous row of pixel-data */
+ mng_uint8p pRGBArow; /* intermediate row of RGBA8 or RGBA16 data */
+ mng_bool bIsRGBA16; /* indicates intermediate row is RGBA16 */
+ mng_bool bIsOpaque; /* indicates intermediate row is fully opaque */
+ mng_int32 iFilterbpp; /* bpp index for filtering routines */
+
+ mng_int32 iSourcel; /* variables for showing objects */
+ mng_int32 iSourcer;
+ mng_int32 iSourcet;
+ mng_int32 iSourceb;
+ mng_int32 iDestl;
+ mng_int32 iDestr;
+ mng_int32 iDestt;
+ mng_int32 iDestb;
+
+ mng_objectp pFirstimgobj; /* double-linked list of */
+ mng_objectp pLastimgobj; /* image-object structures */
+ mng_objectp pFirstaniobj; /* double-linked list of */
+ mng_objectp pLastaniobj; /* animation-object structures */
+#ifdef MNG_SUPPORT_DYNAMICMNG
+ mng_objectp pFirstevent; /* double-linked list of */
+ mng_objectp pLastevent; /* event-object structures */
+#endif
+
+#if defined(MNG_GAMMA_ONLY) || defined(MNG_FULL_CMS) || defined(MNG_APP_CMS)
+ mng_uint8 aGammatab[256]; /* precomputed gamma lookup table */
+ mng_float dLastgamma; /* last gamma used to compute table */
+#endif
+
+ mng_fptr fDisplayrow; /* internal callback to display an
+ uncompressed/unfiltered/
+ color-corrected row */
+ mng_fptr fRestbkgdrow; /* internal callback for restore-
+ background processing of a row */
+ mng_fptr fCorrectrow; /* internal callback to color-correct an
+ uncompressed/unfiltered row */
+ mng_fptr fRetrieverow; /* internal callback to retrieve an
+ uncompressed/unfiltered row of data */
+ mng_fptr fStorerow; /* internal callback to store an
+ uncompressed/unfiltered row of data */
+ mng_fptr fProcessrow; /* internal callback to process an
+ uncompressed row of data */
+ mng_fptr fDifferrow; /* internal callback to perform
+ added filter leveling and
+ differing on an unfiltered row */
+ mng_fptr fScalerow; /* internal callback to scale a
+ delta-row to the bitdepth of its target */
+ mng_fptr fDeltarow; /* internal callback to execute a
+ delta-row onto a target */
+#ifndef MNG_SKIPCHUNK_PAST
+ mng_fptr fFliprow; /* internal callback to flip a row of pixels
+ left<->right for a PAST operation */
+ mng_fptr fTilerow; /* internal callback to tile a row of pixels
+ during a PAST operation */
+#endif
+ mng_fptr fInitrowproc; /* internal callback to initialize
+ the row processing */
+
+ mng_uint16 iDEFIobjectid; /* DEFI fields */
+ mng_bool bDEFIhasdonotshow;
+ mng_uint8 iDEFIdonotshow;
+ mng_bool bDEFIhasconcrete;
+ mng_uint8 iDEFIconcrete;
+ mng_bool bDEFIhasloca;
+ mng_int32 iDEFIlocax;
+ mng_int32 iDEFIlocay;
+ mng_bool bDEFIhasclip;
+ mng_int32 iDEFIclipl;
+ mng_int32 iDEFIclipr;
+ mng_int32 iDEFIclipt;
+ mng_int32 iDEFIclipb;
+
+ mng_uint16 iBACKred; /* BACK fields */
+ mng_uint16 iBACKgreen;
+ mng_uint16 iBACKblue;
+ mng_uint8 iBACKmandatory;
+ mng_uint16 iBACKimageid;
+ mng_uint8 iBACKtile;
+
+ mng_int32 iBackimgoffsx; /* temp variables for restore_bkgd */
+ mng_int32 iBackimgoffsy;
+ mng_uint32 iBackimgwidth;
+ mng_uint32 iBackimgheight;
+
+#ifndef MNG_SKIPCHUNK_FRAM
+ mng_uint8 iFRAMmode; /* FRAM fields (global) */
+ mng_uint32 iFRAMdelay;
+ mng_uint32 iFRAMtimeout;
+ mng_bool bFRAMclipping;
+ mng_int32 iFRAMclipl;
+ mng_int32 iFRAMclipr;
+ mng_int32 iFRAMclipt;
+ mng_int32 iFRAMclipb;
+
+ mng_uint8 iFramemode; /* current subframe variables */
+ mng_uint32 iFramedelay;
+ mng_uint32 iFrametimeout;
+ mng_bool bFrameclipping;
+ mng_int32 iFrameclipl;
+ mng_int32 iFrameclipr;
+ mng_int32 iFrameclipt;
+ mng_int32 iFrameclipb;
+
+ mng_uint32 iNextdelay; /* delay *after* next image */
+
+ mng_bool bForcedelay;
+ mng_uint32 iAccumdelay;
+#endif
+
+#ifndef MNG_SKIPCHUNK_SHOW
+ mng_uint8 iSHOWmode; /* SHOW fields */
+ mng_uint16 iSHOWfromid;
+ mng_uint16 iSHOWtoid;
+ mng_uint16 iSHOWnextid;
+ mng_int16 iSHOWskip;
+#endif
+
+ mng_uint32 iGlobalPLTEcount; /* global PLTE fields */
+ mng_rgbpaltab aGlobalPLTEentries;
+
+ mng_uint32 iGlobalTRNSrawlen; /* global tRNS fields */
+ mng_uint8arr aGlobalTRNSrawdata;
+
+ mng_uint32 iGlobalGamma; /* global gAMA fields */
+
+#ifndef MNG_SKIPCHUNK_cHRM
+ mng_uint32 iGlobalWhitepointx; /* global cHRM fields */
+ mng_uint32 iGlobalWhitepointy;
+ mng_uint32 iGlobalPrimaryredx;
+ mng_uint32 iGlobalPrimaryredy;
+ mng_uint32 iGlobalPrimarygreenx;
+ mng_uint32 iGlobalPrimarygreeny;
+ mng_uint32 iGlobalPrimarybluex;
+ mng_uint32 iGlobalPrimarybluey;
+#endif
+
+ mng_uint8 iGlobalRendintent; /* global sRGB fields */
+
+#ifndef MNG_SKIPCHUNK_iCCP
+ mng_uint32 iGlobalProfilesize; /* global iCCP fields */
+ mng_ptr pGlobalProfile;
+#endif
+
+ mng_uint16 iGlobalBKGDred; /* global bKGD fields */
+ mng_uint16 iGlobalBKGDgreen;
+ mng_uint16 iGlobalBKGDblue;
+
+ mng_ptr pDeltaImage; /* delta-image fields */
+ mng_uint8 iDeltaImagetype;
+#endif /* MNG_SUPPORT_DISPLAY */
+ mng_uint8 iDeltatype; /* need this one in read processing !! */
+#ifdef MNG_SUPPORT_DISPLAY
+ mng_uint32 iDeltaBlockwidth;
+ mng_uint32 iDeltaBlockheight;
+ mng_uint32 iDeltaBlockx;
+ mng_uint32 iDeltaBlocky;
+ mng_bool bDeltaimmediate;
+
+ mng_fptr fDeltagetrow; /* internal delta-proc callbacks */
+ mng_fptr fDeltaaddrow;
+ mng_fptr fDeltareplacerow;
+ mng_fptr fDeltaputrow;
+
+#ifndef MNG_SKIPCHUNK_PROM
+ mng_fptr fPromoterow; /* internal PROM fields */
+ mng_fptr fPromBitdepth;
+ mng_ptr pPromBuf;
+ mng_uint8 iPromColortype;
+ mng_uint8 iPromBitdepth;
+ mng_uint8 iPromFilltype;
+ mng_uint32 iPromWidth;
+ mng_ptr pPromSrc;
+ mng_ptr pPromDst;
+#endif
+
+#ifndef MNG_SKIPCHUNK_MAGN
+ mng_uint16 iMAGNfromid;
+ mng_uint16 iMAGNcurrentid;
+ mng_uint16 iMAGNtoid;
+#endif
+
+#ifndef MNG_SKIPCHUNK_PAST
+ mng_uint16 iPASTid;
+ mng_int32 iPastx; /* target x/y of last PAST */
+ mng_int32 iPasty;
+#endif
+
+ mng_objectp pLastseek; /* last processed ani_seek object */
+
+#ifdef MNG_INCLUDE_MPNG_PROPOSAL
+ mng_objectp pMPNG; /* mpNG object if available */
+#endif
+#ifdef MNG_INCLUDE_ANG_PROPOSAL
+ mng_objectp pANG; /* ANG object if available */
+#endif
+
+#endif /* MNG_SUPPORT_DISPLAY */
+
+#ifdef MNG_INCLUDE_ZLIB
+ z_stream sZlib; /* zlib (de)compression variables */
+
+ mng_int32 iZlevel; /* zlib compression parameters */
+ mng_int32 iZmethod;
+ mng_int32 iZwindowbits;
+ mng_int32 iZmemlevel;
+ mng_int32 iZstrategy;
+
+ mng_uint32 iMaxIDAT; /* maximum size of IDAT data */
+
+ mng_bool bInflating; /* indicates "inflate" in progress */
+ mng_bool bDeflating; /* indicates "deflate" in progress */
+#endif /* MNG_INCLUDE_ZLIB */
+
+#ifdef MNG_INCLUDE_JNG
+ mngjpeg_dctmethod eJPEGdctmethod; /* IJG compression variables */
+ mng_int32 iJPEGquality;
+ mng_int32 iJPEGsmoothing;
+ mng_bool bJPEGcompressprogr;
+ mng_bool bJPEGcompressopt;
+
+ mng_uint32 iMaxJDAT; /* maximum size of JDAT/JDAA data */
+
+ mngjpeg_compp pJPEGcinfo; /* compression structure */
+ mngjpeg_errorp pJPEGcerr; /* error-manager compress */
+
+ mngjpeg_decompp pJPEGdinfo; /* decompression structure (JDAT) */
+ mngjpeg_errorp pJPEGderr; /* error-manager decompress (JDAT) */
+ mngjpeg_sourcep pJPEGdsrc; /* source-manager decompress (JDAT) */
+
+ mngjpeg_decompp pJPEGdinfo2; /* decompression structure (JDAA) */
+ mngjpeg_errorp pJPEGderr2; /* error-manager decompress (JDAA) */
+ mngjpeg_sourcep pJPEGdsrc2; /* source-manager decompress (JDAA) */
+
+ mng_uint8p pJPEGbuf; /* buffer for JPEG (de)compression (JDAT) */
+ mng_uint32 iJPEGbufmax; /* allocated space for buffer (JDAT) */
+ mng_uint8p pJPEGcurrent; /* current pointer into buffer (JDAT) */
+ mng_uint32 iJPEGbufremain; /* remaining bytes in buffer (JDAT) */
+ mng_uint32 iJPEGtoskip; /* bytes to skip on next input-block (JDAT) */
+
+ mng_uint8p pJPEGbuf2; /* buffer for JPEG (de)compression (JDAA) */
+ mng_uint32 iJPEGbufmax2; /* allocated space for buffer (JDAA) */
+ mng_uint8p pJPEGcurrent2; /* current pointer into buffer (JDAA) */
+ mng_uint32 iJPEGbufremain2; /* remaining bytes in buffer (JDAA) */
+ mng_uint32 iJPEGtoskip2; /* bytes to skip on next input-block (JDAA) */
+
+ mng_uint8p pJPEGrow; /* buffer for a JPEG row of samples (JDAT) */
+ mng_uint32 iJPEGrowlen;
+
+ mng_uint8p pJPEGrow2; /* buffer for a JPEG row of samples (JDAA) */
+ mng_uint32 iJPEGrowlen2;
+
+ mng_bool bJPEGcompress; /* indicates "compress" initialized */
+
+ mng_bool bJPEGdecompress; /* indicates "decompress" initialized (JDAT) */
+ mng_bool bJPEGhasheader; /* indicates "readheader" succeeded (JDAT) */
+ mng_bool bJPEGdecostarted; /* indicates "decompress" started (JDAT) */
+ mng_bool bJPEGscanstarted; /* indicates "first scan" started (JDAT) */
+ mng_bool bJPEGscanending; /* indicates "finish_output" suspended (JDAT) */
+ mng_bool bJPEGprogressive; /* indicates a progressive image (JDAT) */
+
+ mng_bool bJPEGdecompress2; /* indicates "decompress" initialized (JDAA) */
+ mng_bool bJPEGhasheader2; /* indicates "readheader" succeeded (JDAA) */
+ mng_bool bJPEGdecostarted2; /* indicates "decompress" started (JDAA) */
+ mng_bool bJPEGscanstarted2; /* indicates "first scan" started (JDAA) */
+ mng_bool bJPEGprogressive2; /* indicates a progressive image (JDAA) */
+
+ mng_fptr fStorerow2; /* internal callback to store an
+ uncompressed/unfiltered row of JPEG-data (JDAT) */
+
+ mng_fptr fStorerow3; /* internal callback to store an
+ uncompressed/unfiltered row of JPEG-data (JDAA) */
+
+ mng_uint32 iJPEGrow; /* row-number for current JPEG row */
+ mng_uint32 iJPEGalpharow; /* nr. of rows filled with alpha */
+ mng_uint32 iJPEGrgbrow; /* nr. of rows filled with 'color'-info */
+ mng_uint32 iJPEGdisprow; /* nr. of rows already displayed "on-the-fly" */
+
+#if defined(MNG_USE_SETJMP) && defined (MNG_INCLUDE_IJG6B)
+ jmp_buf sErrorbuf; /* setjmp/longjmp buffer (error-recovery) */
+#endif
+
+#endif /* MNG_INCLUDE_JNG */
+
+#ifndef MNG_USE_ZLIB_CRC
+ mng_uint32 aCRCtable [256]; /* CRC prefab table */
+ mng_bool bCRCcomputed; /* "has been built" indicator */
+#endif
+
+#ifdef MNG_OPTIMIZE_FOOTPRINT_INIT
+ png_imgtype ePng_imgtype;
+#endif
+
+#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
+ mng_uint8 iPNGdepth; /* Real input depth */
+ mng_uint8 iPNGmult;
+#endif
+
+#ifdef MNG_OPTIMIZE_DISPLAYCALLS
+ mng_uint32 iRawlen; /* temp vars for display processing */
+ mng_uint8p pRawdata;
+#ifndef MNG_SKIPCHUNK_BASI
+ mng_uint16 iBASIred;
+ mng_uint16 iBASIgreen;
+ mng_uint16 iBASIblue;
+ mng_bool bBASIhasalpha;
+ mng_uint16 iBASIalpha;
+ mng_uint8 iBASIviewable;
+#endif
+#ifndef MNG_SKIPCHUNK_CLON
+ mng_uint16 iCLONsourceid;
+ mng_uint16 iCLONcloneid;
+ mng_uint8 iCLONclonetype;
+ mng_bool bCLONhasdonotshow;
+ mng_uint8 iCLONdonotshow;
+ mng_uint8 iCLONconcrete;
+ mng_bool bCLONhasloca;
+ mng_uint8 iCLONlocationtype;
+ mng_int32 iCLONlocationx;
+ mng_int32 iCLONlocationy;
+#endif
+#ifndef MNG_SKIPCHUNK_DISC
+ mng_uint32 iDISCcount;
+ mng_uint16p pDISCids;
+#endif
+#ifndef MNG_SKIPCHUNK_FRAM
+ mng_uint8 iTempFramemode;
+ mng_uint8 iTempChangedelay;
+ mng_uint32 iTempDelay;
+ mng_uint8 iTempChangetimeout;
+ mng_uint32 iTempTimeout;
+ mng_uint8 iTempChangeclipping;
+ mng_uint8 iTempCliptype;
+ mng_int32 iTempClipl;
+ mng_int32 iTempClipr;
+ mng_int32 iTempClipt;
+ mng_int32 iTempClipb;
+#endif
+#ifndef MNG_SKIPCHUNK_MOVE
+ mng_uint16 iMOVEfromid;
+ mng_uint16 iMOVEtoid;
+ mng_uint8 iMOVEmovetype;
+ mng_int32 iMOVEmovex;
+ mng_int32 iMOVEmovey;
+#endif
+#ifndef MNG_SKIPCHUNK_CLIP
+ mng_uint16 iCLIPfromid;
+ mng_uint16 iCLIPtoid;
+ mng_uint8 iCLIPcliptype;
+ mng_int32 iCLIPclipl;
+ mng_int32 iCLIPclipr;
+ mng_int32 iCLIPclipt;
+ mng_int32 iCLIPclipb;
+#endif
+#ifndef MNG_NO_DELTA_PNG
+ mng_uint16 iDHDRobjectid;
+ mng_uint8 iDHDRimagetype;
+ mng_uint8 iDHDRdeltatype;
+ mng_uint32 iDHDRblockwidth;
+ mng_uint32 iDHDRblockheight;
+ mng_uint32 iDHDRblockx;
+ mng_uint32 iDHDRblocky;
+ mng_uint8 iPROMbitdepth;
+ mng_uint8 iPROMcolortype;
+ mng_uint8 iPROMfilltype;
+ mng_uint8 iPPLTtype;
+ mng_uint32 iPPLTcount;
+ mng_palette8ep paPPLTindexentries;
+ mng_uint8p paPPLTalphaentries;
+ mng_uint8p paPPLTusedentries;
+#endif
+#ifndef MNG_SKIPCHUNK_MAGN
+ mng_uint16 iMAGNfirstid;
+ mng_uint16 iMAGNlastid;
+ mng_uint8 iMAGNmethodX;
+ mng_uint16 iMAGNmX;
+ mng_uint16 iMAGNmY;
+ mng_uint16 iMAGNmL;
+ mng_uint16 iMAGNmR;
+ mng_uint16 iMAGNmT;
+ mng_uint16 iMAGNmB;
+ mng_uint8 iMAGNmethodY;
+#endif
+#ifndef MNG_SKIPCHUNK_PAST
+ mng_uint16 iPASTtargetid;
+ mng_uint8 iPASTtargettype;
+ mng_int32 iPASTtargetx;
+ mng_int32 iPASTtargety;
+ mng_uint32 iPASTcount;
+ mng_ptr pPASTsources;
+#endif
+#endif /* MNG_OPTIMIZE_DISPLAYCALLS */
+
+ } mng_data;
+
+typedef mng_data * mng_datap;
+
+/* ************************************************************************** */
+/* * * */
+/* * Internal Callback-Function prototypes * */
+/* * * */
+/* ************************************************************************** */
+
+typedef mng_retcode(*mng_displayrow) (mng_datap pData);
+typedef mng_retcode(*mng_restbkgdrow) (mng_datap pData);
+typedef mng_retcode(*mng_correctrow) (mng_datap pData);
+typedef mng_retcode(*mng_retrieverow) (mng_datap pData);
+typedef mng_retcode(*mng_storerow) (mng_datap pData);
+typedef mng_retcode(*mng_processrow) (mng_datap pData);
+typedef mng_retcode(*mng_initrowproc) (mng_datap pData);
+typedef mng_retcode(*mng_differrow) (mng_datap pData);
+typedef mng_retcode(*mng_scalerow) (mng_datap pData);
+typedef mng_retcode(*mng_deltarow) (mng_datap pData);
+typedef mng_retcode(*mng_promoterow) (mng_datap pData);
+typedef mng_retcode(*mng_fliprow) (mng_datap pData);
+typedef mng_retcode(*mng_tilerow) (mng_datap pData);
+
+typedef mng_uint8 (*mng_bitdepth_8) (mng_uint8 iB);
+typedef mng_uint16 (*mng_bitdepth_16) (mng_uint8 iB);
+
+typedef mng_retcode(*mng_magnify_x) (mng_datap pData,
+ mng_uint16 iMX,
+ mng_uint16 iML,
+ mng_uint16 iMR,
+ mng_uint32 iWidth,
+ mng_uint8p iSrcline,
+ mng_uint8p iDstline);
+typedef mng_retcode(*mng_magnify_y) (mng_datap pData,
+ mng_int32 iM,
+ mng_int32 iS,
+ mng_uint32 iWidth,
+ mng_uint8p iSrcline1,
+ mng_uint8p iSrcline2,
+ mng_uint8p iDstline);
+
+/* ************************************************************************** */
+/* * * */
+/* * Routines for swapping byte-order from and to graphic files * */
+/* * (This code is adapted from the libpng package) * */
+/* * * */
+/* ************************************************************************** */
+
+#ifndef MNG_BIGENDIAN_SUPPORTED
+mng_uint32 mng_get_uint32 (mng_uint8p pBuf);
+mng_int32 mng_get_int32 (mng_uint8p pBuf);
+mng_uint16 mng_get_uint16 (mng_uint8p pBuf);
+void mng_put_uint32 (mng_uint8p pBuf,
+ mng_uint32 i);
+void mng_put_int32 (mng_uint8p pBuf,
+ mng_int32 i);
+void mng_put_uint16 (mng_uint8p pBuf,
+ mng_uint16 i);
+#else /* MNG_BIGENDIAN_SUPPORTED */
+#define mng_get_uint32(P) *(mng_uint32p)(P)
+#define mng_get_int32(P) *(mng_int32p)(P)
+#define mng_get_uint16(P) *(mng_uint16p)(P)
+#define mng_put_uint32(P,I) *(mng_uint32p)(P) = (I)
+#define mng_put_int32(P,I) *(mng_int32p)(P) = (I)
+#define mng_put_uint16(P,I) *(mng_uint16p)(P) = (I)
+#endif /* MNG_BIGENDIAN_SUPPORTED */
+
+/* ************************************************************************** */
+/* * * */
+/* * Some handy(?) macro definitions * */
+/* * * */
+/* ************************************************************************** */
+
+#define MAX_COORD(a, b) (((a) > (b)) ? (a) : (b))
+#define MIN_COORD(a, b) (((a) < (b)) ? (a) : (b))
+
+/* ************************************************************************** */
+
+#endif /* _libmng_data_h_ */
+
+/* ************************************************************************** */
+/* * end of file * */
+/* ************************************************************************** */
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-25 05:48:36 +0000