diff options
Diffstat (limited to 'plugins/AdvaImg/src/LibMNG/libmng_chunk_xs.c')
| -rw-r--r-- | plugins/AdvaImg/src/LibMNG/libmng_chunk_xs.c | 7016 |
1 files changed, 0 insertions, 7016 deletions
diff --git a/plugins/AdvaImg/src/LibMNG/libmng_chunk_xs.c b/plugins/AdvaImg/src/LibMNG/libmng_chunk_xs.c deleted file mode 100644 index 1c4ec2e50d..0000000000 --- a/plugins/AdvaImg/src/LibMNG/libmng_chunk_xs.c +++ /dev/null @@ -1,7016 +0,0 @@ -/* ************************************************************************** */
-/* * For conditions of distribution and use, * */
-/* * see copyright notice in libmng.h * */
-/* ************************************************************************** */
-/* * * */
-/* * project : libmng * */
-/* * file : libmng_chunk_xs.c copyright (c) 2000-2007 G.Juyn * */
-/* * version : 1.0.10 * */
-/* * * */
-/* * purpose : chunk access functions (implementation) * */
-/* * * */
-/* * author : G.Juyn * */
-/* * * */
-/* * comment : implementation of the chunk access functions * */
-/* * * */
-/* * changes : 0.5.1 - 05/06/2000 - G.Juyn * */
-/* * - changed and filled iterate-chunk function * */
-/* * 0.5.1 - 05/08/2000 - G.Juyn * */
-/* * - fixed calling convention * */
-/* * - added getchunk functions * */
-/* * - added putchunk functions * */
-/* * - changed strict-ANSI stuff * */
-/* * 0.5.1 - 05/11/2000 - G.Juyn * */
-/* * - added empty-chunk put-routines * */
-/* * 0.5.1 - 05/12/2000 - G.Juyn * */
-/* * - changed trace to macro for callback error-reporting * */
-/* * 0.5.1 - 05/15/2000 - G.Juyn * */
-/* * - added getimgdata & putimgdata functions * */
-/* * * */
-/* * 0.5.2 - 05/19/2000 - G.Juyn * */
-/* * - B004 - fixed problem with MNG_SUPPORT_WRITE not defined * */
-/* * also for MNG_SUPPORT_WRITE without MNG_INCLUDE_JNG * */
-/* * - Cleaned up some code regarding mixed support * */
-/* * * */
-/* * 0.9.1 - 07/19/2000 - G.Juyn * */
-/* * - fixed creation-code * */
-/* * * */
-/* * 0.9.2 - 08/05/2000 - G.Juyn * */
-/* * - changed file-prefixes * */
-/* * - added function to set simplicity field * */
-/* * - fixed putchunk_unknown() function * */
-/* * * */
-/* * 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 - 10/20/2000 - G.Juyn * */
-/* * - fixed putchunk_plte() to set bEmpty parameter * */
-/* * * */
-/* * 0.9.5 - 01/25/2001 - G.Juyn * */
-/* * - fixed some small compiler warnings (thanks Nikki) * */
-/* * * */
-/* * 1.0.5 - 09/07/2002 - G.Juyn * */
-/* * - B578940 - unimplemented functions return errorcode * */
-/* * 1.0.5 - 08/19/2002 - G.Juyn * */
-/* * - B597134 - libmng pollutes the linker namespace * */
-/* * - added HLAPI function to copy chunks * */
-/* * 1.0.5 - 09/14/2002 - G.Juyn * */
-/* * - added event handling for dynamic MNG * */
-/* * 1.0.5 - 10/07/2002 - G.Juyn * */
-/* * - added check for TERM placement during create/write * */
-/* * 1.0.5 - 11/28/2002 - G.Juyn * */
-/* * - fixed definition of iMethodX/Y for MAGN chunk * */
-/* * * */
-/* * 1.0.6 - 05/25/2003 - G.R-P * */
-/* * - added MNG_SKIPCHUNK_cHNK footprint optimizations * */
-/* * 1.0.6 - 07/07/2003 - G.R-P * */
-/* * - added MNG_NO_DELTA_PNG reduction and more SKIPCHUNK * */
-/* * optimizations * */
-/* * 1.0.6 - 07/29/2003 - G.R-P * */
-/* * - added conditionals around PAST chunk support * */
-/* * 1.0.6 - 08/17/2003 - G.R-P * */
-/* * - added conditionals around non-VLC chunk support * */
-/* * * */
-/* * 1.0.8 - 04/01/2004 - G.Juyn * */
-/* * - added missing get-/put-chunk-jdaa * */
-/* * 1.0.8 - 08/02/2004 - G.Juyn * */
-/* * - added conditional to allow easier writing of large MNG's * */
-/* * * */
-/* * 1.0.9 - 09/17/2004 - G.R-P * */
-/* * - added two more conditionals * */
-/* * 1.0.9 - 09/25/2004 - G.Juyn * */
-/* * - replaced MNG_TWEAK_LARGE_FILES with permanent solution * */
-/* * 1.0.9 - 17/14/2004 - G.Juyn * */
-/* * - fixed PPLT getchunk/putchunk routines * */
-/* * 1.0.9 - 12/05/2004 - G.Juyn * */
-/* * - added conditional MNG_OPTIMIZE_CHUNKINITFREE * */
-/* * 1.0.9 - 12/20/2004 - G.Juyn * */
-/* * - cleaned up macro-invocations (thanks to D. Airlie) * */
-/* * * */
-/* * 1.0.10 - 04/08/2007 - G.Juyn * */
-/* * - added support for mPNG 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"
-#ifdef MNG_OPTIMIZE_CHUNKREADER
-#include "libmng_chunk_descr.h"
-#endif
-#include "libmng_chunk_prc.h"
-#include "libmng_chunk_io.h"
-
-#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
-#pragma option -A /* force ANSI-C */
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_ACCESS_CHUNKS
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_iterate_chunks (mng_handle hHandle,
- mng_uint32 iChunkseq,
- mng_iteratechunk fProc)
-{
- mng_uint32 iSeq;
- mng_chunkid iChunkname;
- mng_datap pData;
- mng_chunkp pChunk;
- mng_bool bCont;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_ITERATE_CHUNKS, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = ((mng_datap)hHandle); /* and make it addressable */
-
- iSeq = 0;
- bCont = MNG_TRUE;
- pChunk = pData->pFirstchunk; /* get the first chunk */
- /* as long as there are some more */
- while ((pChunk) && (bCont)) /* and the app didn't signal a stop */
- {
- if (iSeq >= iChunkseq) /* reached the first target ? */
- { /* then call this and next ones back in... */
- iChunkname = ((mng_chunk_headerp)pChunk)->iChunkname;
- bCont = fProc (hHandle, (mng_handle)pChunk, iChunkname, iSeq);
- }
-
- iSeq++; /* next one */
- pChunk = ((mng_chunk_headerp)pChunk)->pNext;
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_ITERATE_CHUNKS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#ifdef MNG_SUPPORT_WRITE
-mng_retcode MNG_DECL mng_copy_chunk (mng_handle hHandle,
- mng_handle hChunk,
- mng_handle hHandleOut)
-{
- mng_datap pDataOut;
- mng_chunkp pChunk;
- mng_chunkp pChunkOut;
- mng_retcode iRetcode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_COPY_CHUNK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handles */
- MNG_VALIDHANDLE (hHandleOut)
-
- pDataOut = (mng_datap)hHandleOut; /* make outhandle addressable */
- pChunk = (mng_chunkp)hChunk; /* address the chunk */
-
- if (!pDataOut->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pDataOut, MNG_FUNCTIONINVALID)
- /* create a new chunk */
- iRetcode = ((mng_createchunk)((mng_chunk_headerp)pChunk)->fCreate)
- (pDataOut, ((mng_chunk_headerp)pChunk), &pChunkOut);
- if (!iRetcode) /* assign the chunk-specific data */
- iRetcode = ((mng_assignchunk)((mng_chunk_headerp)pChunk)->fAssign)
- (pDataOut, pChunkOut, pChunk);
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- mng_add_chunk (pDataOut, pChunkOut); /* and put it in the output-stream */
-
- /* could it be the end of the chain ? */
- if (((mng_chunk_headerp)pChunkOut)->iChunkname == MNG_UINT_IEND)
- {
-#ifdef MNG_INCLUDE_JNG
- if ((pDataOut->iFirstchunkadded == MNG_UINT_IHDR) ||
- (pDataOut->iFirstchunkadded == MNG_UINT_JHDR) )
-#else
- if (pDataOut->iFirstchunkadded == MNG_UINT_IHDR)
-#endif
- pDataOut->bCreating = MNG_FALSE; /* right; this should be the last chunk !!! */
- }
-
- if (((mng_chunk_headerp)pChunkOut)->iChunkname == MNG_UINT_MEND)
- pDataOut->bCreating = MNG_FALSE; /* definitely this should be the last !!! */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_COPY_CHUNK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif /* MNG_SUPPORT_WRITE */
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_ihdr (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iWidth,
- mng_uint32 *iHeight,
- mng_uint8 *iBitdepth,
- mng_uint8 *iColortype,
- mng_uint8 *iCompression,
- mng_uint8 *iFilter,
- mng_uint8 *iInterlace)
-{
- mng_datap pData;
- mng_ihdrp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_ihdrp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_IHDR)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iWidth = pChunk->iWidth; /* fill the fields */
- *iHeight = pChunk->iHeight;
- *iBitdepth = pChunk->iBitdepth;
- *iColortype = pChunk->iColortype;
- *iCompression = pChunk->iCompression;
- *iFilter = pChunk->iFilter;
- *iInterlace = pChunk->iInterlace;
-
- /* fill the chunk */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_plte (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iCount,
- mng_palette8 *aPalette)
-{
- mng_datap pData;
- mng_pltep pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PLTE, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_pltep)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_PLTE)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iCount = pChunk->iEntrycount; /* fill the fields */
-
- MNG_COPY (*aPalette, pChunk->aEntries, sizeof (mng_palette8));
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PLTE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_idat (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iRawlen,
- mng_ptr *pRawdata)
-{
- mng_datap pData;
- mng_idatp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IDAT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_idatp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_IDAT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iRawlen = pChunk->iDatasize; /* fill the fields */
- *pRawdata = pChunk->pData;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IDAT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_trns (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_bool *bGlobal,
- mng_uint8 *iType,
- mng_uint32 *iCount,
- mng_uint8arr *aAlphas,
- mng_uint16 *iGray,
- mng_uint16 *iRed,
- mng_uint16 *iGreen,
- mng_uint16 *iBlue,
- mng_uint32 *iRawlen,
- mng_uint8arr *aRawdata)
-{
- mng_datap pData;
- mng_trnsp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TRNS, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_trnsp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_tRNS)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *bGlobal = pChunk->bGlobal;
- *iType = pChunk->iType;
- *iCount = pChunk->iCount;
- *iGray = pChunk->iGray;
- *iRed = pChunk->iRed;
- *iGreen = pChunk->iGreen;
- *iBlue = pChunk->iBlue;
- *iRawlen = pChunk->iRawlen;
-
- MNG_COPY (*aAlphas, pChunk->aEntries, sizeof (mng_uint8arr));
- MNG_COPY (*aRawdata, pChunk->aRawdata, sizeof (mng_uint8arr));
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TRNS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_gAMA
-mng_retcode MNG_DECL mng_getchunk_gama (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint32 *iGamma)
-{
- mng_datap pData;
- mng_gamap pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_GAMA, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_gamap)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_gAMA)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iGamma = pChunk->iGamma;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_GAMA, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_cHRM
-mng_retcode MNG_DECL mng_getchunk_chrm (mng_handle hHandle,
- mng_handle hChunk,
- 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)
-{
- mng_datap pData;
- mng_chrmp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CHRM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_chrmp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_cHRM)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iWhitepointx = pChunk->iWhitepointx;
- *iWhitepointy = pChunk->iWhitepointy;
- *iRedx = pChunk->iRedx;
- *iRedy = pChunk->iRedy;
- *iGreenx = pChunk->iGreenx;
- *iGreeny = pChunk->iGreeny;
- *iBluex = pChunk->iBluex;
- *iBluey = pChunk->iBluey;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CHRM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sRGB
-mng_retcode MNG_DECL mng_getchunk_srgb (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint8 *iRenderingintent)
-{
- mng_datap pData;
- mng_srgbp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SRGB, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_srgbp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_sRGB)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iRenderingintent = pChunk->iRenderingintent;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SRGB, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_iCCP
-mng_retcode MNG_DECL mng_getchunk_iccp (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint32 *iNamesize,
- mng_pchar *zName,
- mng_uint8 *iCompression,
- mng_uint32 *iProfilesize,
- mng_ptr *pProfile)
-{
- mng_datap pData;
- mng_iccpp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ICCP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_iccpp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_iCCP)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iNamesize = pChunk->iNamesize;
- *zName = pChunk->zName;
- *iCompression = pChunk->iCompression;
- *iProfilesize = pChunk->iProfilesize;
- *pProfile = pChunk->pProfile;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ICCP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_tEXt
-mng_retcode MNG_DECL mng_getchunk_text (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iKeywordsize,
- mng_pchar *zKeyword,
- mng_uint32 *iTextsize,
- mng_pchar *zText)
-{
- mng_datap pData;
- mng_textp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TEXT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_textp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_tEXt)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* fill the fields */
- *iKeywordsize = pChunk->iKeywordsize;
- *zKeyword = pChunk->zKeyword;
- *iTextsize = pChunk->iTextsize;
- *zText = pChunk->zText;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TEXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_zTXt
-mng_retcode MNG_DECL mng_getchunk_ztxt (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iKeywordsize,
- mng_pchar *zKeyword,
- mng_uint8 *iCompression,
- mng_uint32 *iTextsize,
- mng_pchar *zText)
-{
- mng_datap pData;
- mng_ztxtp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ZTXT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_ztxtp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_zTXt)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* fill the fields */
- *iKeywordsize = pChunk->iKeywordsize;
- *zKeyword = pChunk->zKeyword;
- *iCompression = pChunk->iCompression;
- *iTextsize = pChunk->iTextsize;
- *zText = pChunk->zText;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ZTXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_iTXt
-mng_retcode MNG_DECL mng_getchunk_itxt (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iKeywordsize,
- mng_pchar *zKeyword,
- mng_uint8 *iCompressionflag,
- mng_uint8 *iCompressionmethod,
- mng_uint32 *iLanguagesize,
- mng_pchar *zLanguage,
- mng_uint32 *iTranslationsize,
- mng_pchar *zTranslation,
- mng_uint32 *iTextsize,
- mng_pchar *zText)
-{
- mng_datap pData;
- mng_itxtp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ITXT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_itxtp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_iTXt)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* fill the fields */
- *iKeywordsize = pChunk->iKeywordsize;
- *zKeyword = pChunk->zKeyword;
- *iCompressionflag = pChunk->iCompressionflag;
- *iCompressionmethod = pChunk->iCompressionmethod;
- *iLanguagesize = pChunk->iLanguagesize;
- *zLanguage = pChunk->zLanguage;
- *iTranslationsize = pChunk->iTranslationsize;
- *zTranslation = pChunk->zTranslation;
- *iTextsize = pChunk->iTextsize;
- *zText = pChunk->zText;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ITXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_bKGD
-mng_retcode MNG_DECL mng_getchunk_bkgd (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint8 *iType,
- mng_uint8 *iIndex,
- mng_uint16 *iGray,
- mng_uint16 *iRed,
- mng_uint16 *iGreen,
- mng_uint16 *iBlue)
-{
- mng_datap pData;
- mng_bkgdp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BKGD, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_bkgdp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_bKGD)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iType = pChunk->iType;
- *iIndex = pChunk->iIndex;
- *iGray = pChunk->iGray;
- *iRed = pChunk->iRed;
- *iGreen = pChunk->iGreen;
- *iBlue = pChunk->iBlue;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BKGD, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_pHYs
-mng_retcode MNG_DECL mng_getchunk_phys (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint32 *iSizex,
- mng_uint32 *iSizey,
- mng_uint8 *iUnit)
-{
- mng_datap pData;
- mng_physp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYS, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_physp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_pHYs)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iSizex = pChunk->iSizex;
- *iSizey = pChunk->iSizey;
- *iUnit = pChunk->iUnit;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sBIT
-mng_retcode MNG_DECL mng_getchunk_sbit (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint8 *iType,
- mng_uint8arr4 *aBits)
-{
- mng_datap pData;
- mng_sbitp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SBIT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_sbitp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_sBIT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty;
- *iType = pChunk->iType;
- (*aBits)[0] = pChunk->aBits[0];
- (*aBits)[1] = pChunk->aBits[1];
- (*aBits)[2] = pChunk->aBits[2];
- (*aBits)[3] = pChunk->aBits[3];
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SBIT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sPLT
-mng_retcode MNG_DECL mng_getchunk_splt (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint32 *iNamesize,
- mng_pchar *zName,
- mng_uint8 *iSampledepth,
- mng_uint32 *iEntrycount,
- mng_ptr *pEntries)
-{
- mng_datap pData;
- mng_spltp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SPLT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_spltp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_sPLT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iNamesize = pChunk->iNamesize;
- *zName = pChunk->zName;
- *iSampledepth = pChunk->iSampledepth;
- *iEntrycount = pChunk->iEntrycount;
- *pEntries = pChunk->pEntries;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SPLT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_hIST
-mng_retcode MNG_DECL mng_getchunk_hist (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iEntrycount,
- mng_uint16arr *aEntries)
-{
- mng_datap pData;
- mng_histp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_HIST, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_histp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_hIST)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iEntrycount = pChunk->iEntrycount; /* fill the fields */
-
- MNG_COPY (*aEntries, pChunk->aEntries, sizeof (mng_uint16arr));
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_HIST, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_tIME
-mng_retcode MNG_DECL mng_getchunk_time (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iYear,
- mng_uint8 *iMonth,
- mng_uint8 *iDay,
- mng_uint8 *iHour,
- mng_uint8 *iMinute,
- mng_uint8 *iSecond)
-{
- mng_datap pData;
- mng_timep pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TIME, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_timep)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_tIME)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iYear = pChunk->iYear; /* fill the fields */
- *iMonth = pChunk->iMonth;
- *iDay = pChunk->iDay;
- *iHour = pChunk->iHour;
- *iMinute = pChunk->iMinute;
- *iSecond = pChunk->iSecond;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TIME, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_mhdr (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iWidth,
- mng_uint32 *iHeight,
- mng_uint32 *iTicks,
- mng_uint32 *iLayercount,
- mng_uint32 *iFramecount,
- mng_uint32 *iPlaytime,
- mng_uint32 *iSimplicity)
-{
- mng_datap pData;
- mng_mhdrp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_mhdrp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iWidth = pChunk->iWidth; /* fill the fields */
- *iHeight = pChunk->iHeight;
- *iTicks = pChunk->iTicks;
- *iLayercount = pChunk->iLayercount;
- *iFramecount = pChunk->iFramecount;
- *iPlaytime = pChunk->iPlaytime;
- *iSimplicity = pChunk->iSimplicity;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_LOOP
-mng_retcode MNG_DECL mng_getchunk_loop (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint8 *iLevel,
- mng_uint32 *iRepeat,
- mng_uint8 *iTermination,
- mng_uint32 *iItermin,
- mng_uint32 *iItermax,
- mng_uint32 *iCount,
- mng_uint32p *pSignals)
-{
- mng_datap pData;
- mng_loopp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_LOOP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_loopp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_LOOP)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iLevel = pChunk->iLevel; /* fill teh fields */
- *iRepeat = pChunk->iRepeat;
- *iTermination = pChunk->iTermination;
- *iItermin = pChunk->iItermin;
- *iItermax = pChunk->iItermax;
- *iCount = pChunk->iCount;
- *pSignals = pChunk->pSignals;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_LOOP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_endl (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint8 *iLevel)
-{
- mng_datap pData;
- mng_endlp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ENDL, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_endlp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_ENDL)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iLevel = pChunk->iLevel; /* fill the field */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ENDL, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_DEFI
-mng_retcode MNG_DECL mng_getchunk_defi (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iObjectid,
- mng_uint8 *iDonotshow,
- mng_uint8 *iConcrete,
- mng_bool *bHasloca,
- mng_int32 *iXlocation,
- mng_int32 *iYlocation,
- mng_bool *bHasclip,
- mng_int32 *iLeftcb,
- mng_int32 *iRightcb,
- mng_int32 *iTopcb,
- mng_int32 *iBottomcb)
-{
- mng_datap pData;
- mng_defip pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DEFI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_defip)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_DEFI)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iObjectid = pChunk->iObjectid; /* fill the fields */
- *iDonotshow = pChunk->iDonotshow;
- *iConcrete = pChunk->iConcrete;
- *bHasloca = pChunk->bHasloca;
- *iXlocation = pChunk->iXlocation;
- *iYlocation = pChunk->iYlocation;
- *bHasclip = pChunk->bHasclip;
- *iLeftcb = pChunk->iLeftcb;
- *iRightcb = pChunk->iRightcb;
- *iTopcb = pChunk->iTopcb;
- *iBottomcb = pChunk->iBottomcb;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DEFI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_BASI
-mng_retcode MNG_DECL mng_getchunk_basi (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iWidth,
- mng_uint32 *iHeight,
- mng_uint8 *iBitdepth,
- mng_uint8 *iColortype,
- mng_uint8 *iCompression,
- mng_uint8 *iFilter,
- mng_uint8 *iInterlace,
- mng_uint16 *iRed,
- mng_uint16 *iGreen,
- mng_uint16 *iBlue,
- mng_uint16 *iAlpha,
- mng_uint8 *iViewable)
-{
- mng_datap pData;
- mng_basip pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BASI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_basip)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_BASI)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iWidth = pChunk->iWidth; /* fill the fields */
- *iHeight = pChunk->iHeight;
- *iBitdepth = pChunk->iBitdepth;
- *iColortype = pChunk->iColortype;
- *iCompression = pChunk->iCompression;
- *iFilter = pChunk->iFilter;
- *iInterlace = pChunk->iInterlace;
- *iRed = pChunk->iRed;
- *iGreen = pChunk->iGreen;
- *iBlue = pChunk->iBlue;
- *iAlpha = pChunk->iAlpha;
- *iViewable = pChunk->iViewable;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BASI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_CLON
-mng_retcode MNG_DECL mng_getchunk_clon (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iSourceid,
- mng_uint16 *iCloneid,
- mng_uint8 *iClonetype,
- mng_uint8 *iDonotshow,
- mng_uint8 *iConcrete,
- mng_bool *bHasloca,
- mng_uint8 *iLocationtype,
- mng_int32 *iLocationx,
- mng_int32 *iLocationy)
-{
- mng_datap pData;
- mng_clonp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLON, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_clonp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_CLON)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iSourceid = pChunk->iSourceid; /* fill the fields */
- *iCloneid = pChunk->iCloneid;
- *iClonetype = pChunk->iClonetype;
- *iDonotshow = pChunk->iDonotshow;
- *iConcrete = pChunk->iConcrete;
- *bHasloca = pChunk->bHasloca;
- *iLocationtype = pChunk->iLocationtype;
- *iLocationx = pChunk->iLocationx;
- *iLocationy = pChunk->iLocationy;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLON, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_PAST
-mng_retcode MNG_DECL mng_getchunk_past (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iDestid,
- mng_uint8 *iTargettype,
- mng_int32 *iTargetx,
- mng_int32 *iTargety,
- mng_uint32 *iCount)
-{
- mng_datap pData;
- mng_pastp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_pastp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_PAST)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iDestid = pChunk->iDestid; /* fill the fields */
- *iTargettype = pChunk->iTargettype;
- *iTargetx = pChunk->iTargetx;
- *iTargety = pChunk->iTargety;
- *iCount = pChunk->iCount;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_PAST
-mng_retcode MNG_DECL mng_getchunk_past_src (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iEntry,
- mng_uint16 *iSourceid,
- mng_uint8 *iComposition,
- mng_uint8 *iOrientation,
- mng_uint8 *iOffsettype,
- mng_int32 *iOffsetx,
- mng_int32 *iOffsety,
- mng_uint8 *iBoundarytype,
- mng_int32 *iBoundaryl,
- mng_int32 *iBoundaryr,
- mng_int32 *iBoundaryt,
- mng_int32 *iBoundaryb)
-{
- mng_datap pData;
- mng_pastp pChunk;
- mng_past_sourcep pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST_SRC, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_pastp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_PAST)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- if (iEntry >= pChunk->iCount) /* valid index ? */
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address the entry */
- pEntry = pChunk->pSources + iEntry;
-
- *iSourceid = pEntry->iSourceid; /* fill the fields */
- *iComposition = pEntry->iComposition;
- *iOrientation = pEntry->iOrientation;
- *iOffsettype = pEntry->iOffsettype;
- *iOffsetx = pEntry->iOffsetx;
- *iOffsety = pEntry->iOffsety;
- *iBoundarytype = pEntry->iBoundarytype;
- *iBoundaryl = pEntry->iBoundaryl;
- *iBoundaryr = pEntry->iBoundaryr;
- *iBoundaryt = pEntry->iBoundaryt;
- *iBoundaryb = pEntry->iBoundaryb;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST_SRC, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_DISC
-mng_retcode MNG_DECL mng_getchunk_disc (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iCount,
- mng_uint16p *pObjectids)
-{
- mng_datap pData;
- mng_discp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DISC, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_discp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_DISC)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iCount = pChunk->iCount; /* fill the fields */
- *pObjectids = pChunk->pObjectids;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DISC, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_BACK
-mng_retcode MNG_DECL mng_getchunk_back (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iRed,
- mng_uint16 *iGreen,
- mng_uint16 *iBlue,
- mng_uint8 *iMandatory,
- mng_uint16 *iImageid,
- mng_uint8 *iTile)
-{
- mng_datap pData;
- mng_backp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BACK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_backp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_BACK)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iRed = pChunk->iRed; /* fill the fields */
- *iGreen = pChunk->iGreen;
- *iBlue = pChunk->iBlue;
- *iMandatory = pChunk->iMandatory;
- *iImageid = pChunk->iImageid;
- *iTile = pChunk->iTile;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BACK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_FRAM
-mng_retcode MNG_DECL mng_getchunk_fram (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint8 *iMode,
- mng_uint32 *iNamesize,
- mng_pchar *zName,
- mng_uint8 *iChangedelay,
- mng_uint8 *iChangetimeout,
- mng_uint8 *iChangeclipping,
- mng_uint8 *iChangesyncid,
- mng_uint32 *iDelay,
- mng_uint32 *iTimeout,
- mng_uint8 *iBoundarytype,
- mng_int32 *iBoundaryl,
- mng_int32 *iBoundaryr,
- mng_int32 *iBoundaryt,
- mng_int32 *iBoundaryb,
- mng_uint32 *iCount,
- mng_uint32p *pSyncids)
-{
- mng_datap pData;
- mng_framp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FRAM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_framp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_FRAM)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iMode = pChunk->iMode;
- *iNamesize = pChunk->iNamesize;
- *zName = pChunk->zName;
- *iChangedelay = pChunk->iChangedelay;
- *iChangetimeout = pChunk->iChangetimeout;
- *iChangeclipping = pChunk->iChangeclipping;
- *iChangesyncid = pChunk->iChangesyncid;
- *iDelay = pChunk->iDelay;
- *iTimeout = pChunk->iTimeout;
- *iBoundarytype = pChunk->iBoundarytype;
- *iBoundaryl = pChunk->iBoundaryl;
- *iBoundaryr = pChunk->iBoundaryr;
- *iBoundaryt = pChunk->iBoundaryt;
- *iBoundaryb = pChunk->iBoundaryb;
- *iCount = pChunk->iCount;
- *pSyncids = pChunk->pSyncids;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FRAM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_MOVE
-mng_retcode MNG_DECL mng_getchunk_move (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iFirstid,
- mng_uint16 *iLastid,
- mng_uint8 *iMovetype,
- mng_int32 *iMovex,
- mng_int32 *iMovey)
-{
- mng_datap pData;
- mng_movep pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MOVE, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_movep)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_MOVE)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iFirstid = pChunk->iFirstid; /* fill the fields */
- *iLastid = pChunk->iLastid;
- *iMovetype = pChunk->iMovetype;
- *iMovex = pChunk->iMovex;
- *iMovey = pChunk->iMovey;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MOVE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_CLIP
-mng_retcode MNG_DECL mng_getchunk_clip (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iFirstid,
- mng_uint16 *iLastid,
- mng_uint8 *iCliptype,
- mng_int32 *iClipl,
- mng_int32 *iClipr,
- mng_int32 *iClipt,
- mng_int32 *iClipb)
-{
- mng_datap pData;
- mng_clipp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLIP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_clipp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_CLIP)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iFirstid = pChunk->iFirstid; /* fill the fields */
- *iLastid = pChunk->iLastid;
- *iCliptype = pChunk->iCliptype;
- *iClipl = pChunk->iClipl;
- *iClipr = pChunk->iClipr;
- *iClipt = pChunk->iClipt;
- *iClipb = pChunk->iClipb;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLIP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SHOW
-mng_retcode MNG_DECL mng_getchunk_show (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint16 *iFirstid,
- mng_uint16 *iLastid,
- mng_uint8 *iMode)
-{
- mng_datap pData;
- mng_showp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SHOW, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_showp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_SHOW)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iFirstid = pChunk->iFirstid;
- *iLastid = pChunk->iLastid;
- *iMode = pChunk->iMode;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SHOW, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_TERM
-mng_retcode MNG_DECL mng_getchunk_term (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint8 *iTermaction,
- mng_uint8 *iIteraction,
- mng_uint32 *iDelay,
- mng_uint32 *iItermax)
-{
- mng_datap pData;
- mng_termp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TERM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_termp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_TERM)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iTermaction = pChunk->iTermaction; /* fill the fields */
- *iIteraction = pChunk->iIteraction;
- *iDelay = pChunk->iDelay;
- *iItermax = pChunk->iItermax;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TERM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SAVE
-mng_retcode MNG_DECL mng_getchunk_save (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint8 *iOffsettype,
- mng_uint32 *iCount)
-{
- mng_datap pData;
- mng_savep pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_savep)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_SAVE)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iOffsettype = pChunk->iOffsettype;
- *iCount = pChunk->iCount;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_save_entry (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iEntry,
- mng_uint8 *iEntrytype,
- mng_uint32arr2 *iOffset,
- mng_uint32arr2 *iStarttime,
- mng_uint32 *iLayernr,
- mng_uint32 *iFramenr,
- mng_uint32 *iNamesize,
- mng_pchar *zName)
-{
- mng_datap pData;
- mng_savep pChunk;
- mng_save_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_savep)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_SAVE)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- if (iEntry >= pChunk->iCount) /* valid index ? */
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
-
- pEntry = pChunk->pEntries + iEntry; /* address the entry */
- /* fill the fields */
- *iEntrytype = pEntry->iEntrytype;
- (*iOffset)[0] = pEntry->iOffset[0];
- (*iOffset)[1] = pEntry->iOffset[1];
- (*iStarttime)[0] = pEntry->iStarttime[0];
- (*iStarttime)[1] = pEntry->iStarttime[1];
- *iLayernr = pEntry->iLayernr;
- *iFramenr = pEntry->iFramenr;
- *iNamesize = pEntry->iNamesize;
- *zName = pEntry->zName;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SEEK
-mng_retcode MNG_DECL mng_getchunk_seek (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iNamesize,
- mng_pchar *zName)
-{
- mng_datap pData;
- mng_seekp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SEEK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_seekp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_SEEK)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iNamesize = pChunk->iNamesize; /* fill the fields */
- *zName = pChunk->zName;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SEEK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_eXPI
-mng_retcode MNG_DECL mng_getchunk_expi (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iSnapshotid,
- mng_uint32 *iNamesize,
- mng_pchar *zName)
-{
- mng_datap pData;
- mng_expip pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EXPI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_expip)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_eXPI)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iSnapshotid = pChunk->iSnapshotid; /* fill the fields */
- *iNamesize = pChunk->iNamesize;
- *zName = pChunk->zName;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EXPI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_fPRI
-mng_retcode MNG_DECL mng_getchunk_fpri (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint8 *iDeltatype,
- mng_uint8 *iPriority)
-{
- mng_datap pData;
- mng_fprip pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FPRI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_fprip)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_fPRI)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iDeltatype = pChunk->iDeltatype; /* fill the fields */
- *iPriority = pChunk->iPriority;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FPRI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_nEED
-mng_retcode MNG_DECL mng_getchunk_need (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iKeywordssize,
- mng_pchar *zKeywords)
-{
- mng_datap pData;
- mng_needp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_NEED, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_needp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_nEED)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* fill the fields */
- *iKeywordssize = pChunk->iKeywordssize;
- *zKeywords = pChunk->zKeywords;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_NEED, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_pHYg
-mng_retcode MNG_DECL mng_getchunk_phyg (mng_handle hHandle,
- mng_handle hChunk,
- mng_bool *bEmpty,
- mng_uint32 *iSizex,
- mng_uint32 *iSizey,
- mng_uint8 *iUnit)
-{
- mng_datap pData;
- mng_phygp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYG, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_phygp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_pHYg)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *bEmpty = pChunk->bEmpty; /* fill the fields */
- *iSizex = pChunk->iSizex;
- *iSizey = pChunk->iSizey;
- *iUnit = pChunk->iUnit;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_getchunk_jhdr (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iWidth,
- mng_uint32 *iHeight,
- mng_uint8 *iColortype,
- mng_uint8 *iImagesampledepth,
- mng_uint8 *iImagecompression,
- mng_uint8 *iImageinterlace,
- mng_uint8 *iAlphasampledepth,
- mng_uint8 *iAlphacompression,
- mng_uint8 *iAlphafilter,
- mng_uint8 *iAlphainterlace)
-{
- mng_datap pData;
- mng_jhdrp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_jhdrp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_JHDR)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iWidth = pChunk->iWidth; /* fill the fields */
- *iHeight = pChunk->iHeight;
- *iColortype = pChunk->iColortype;
- *iImagesampledepth = pChunk->iImagesampledepth;
- *iImagecompression = pChunk->iImagecompression;
- *iImageinterlace = pChunk->iImageinterlace;
- *iAlphasampledepth = pChunk->iAlphasampledepth;
- *iAlphacompression = pChunk->iAlphacompression;
- *iAlphafilter = pChunk->iAlphafilter;
- *iAlphainterlace = pChunk->iAlphainterlace;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_getchunk_jdat (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iRawlen,
- mng_ptr *pRawdata)
-{
- mng_datap pData;
- mng_jdatp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_jdatp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_JDAT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iRawlen = pChunk->iDatasize; /* fill the fields */
- *pRawdata = pChunk->pData;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_getchunk_jdaa (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iRawlen,
- mng_ptr *pRawdata)
-{
- mng_datap pData;
- mng_jdaap pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAA, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_jdaap)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_JDAA)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iRawlen = pChunk->iDatasize; /* fill the fields */
- *pRawdata = pChunk->pData;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAA, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_getchunk_dhdr (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iObjectid,
- mng_uint8 *iImagetype,
- mng_uint8 *iDeltatype,
- mng_uint32 *iBlockwidth,
- mng_uint32 *iBlockheight,
- mng_uint32 *iBlockx,
- mng_uint32 *iBlocky)
-{
- mng_datap pData;
- mng_dhdrp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_dhdrp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_DHDR)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iObjectid = pChunk->iObjectid; /* fill the fields */
- *iImagetype = pChunk->iImagetype;
- *iDeltatype = pChunk->iDeltatype;
- *iBlockwidth = pChunk->iBlockwidth;
- *iBlockheight = pChunk->iBlockheight;
- *iBlockx = pChunk->iBlockx;
- *iBlocky = pChunk->iBlocky;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_getchunk_prom (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint8 *iColortype,
- mng_uint8 *iSampledepth,
- mng_uint8 *iFilltype)
-{
- mng_datap pData;
- mng_promp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PROM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_promp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_PROM)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iColortype = pChunk->iColortype; /* fill the fields */
- *iSampledepth = pChunk->iSampledepth;
- *iFilltype = pChunk->iFilltype;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PROM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_getchunk_pplt (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint8 *iDeltatype,
- mng_uint32 *iCount)
-{
- mng_datap pData;
- mng_ppltp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_ppltp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_PPLT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iDeltatype = pChunk->iDeltatype; /* fill the fields */
- *iCount = pChunk->iCount;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_getchunk_pplt_entry (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iEntry,
- mng_uint16 *iRed,
- mng_uint16 *iGreen,
- mng_uint16 *iBlue,
- mng_uint16 *iAlpha,
- mng_bool *bUsed)
-{
- mng_datap pData;
- mng_ppltp pChunk;
- mng_pplt_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_ppltp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_PPLT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- if (iEntry >= pChunk->iCount) /* valid index ? */
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
-
- pEntry = &pChunk->aEntries[iEntry]; /* address the entry */
-
- *iRed = pEntry->iRed; /* fill the fields */
- *iGreen = pEntry->iGreen;
- *iBlue = pEntry->iBlue;
- *iAlpha = pEntry->iAlpha;
- *bUsed = pEntry->bUsed;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_getchunk_drop (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iCount,
- mng_chunkidp *pChunknames)
-{
- mng_datap pData;
- mng_dropp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DROP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_dropp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_DROP)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iCount = pChunk->iCount; /* fill the fields */
- *pChunknames = pChunk->pChunknames;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DROP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_DBYK
-mng_retcode MNG_DECL mng_getchunk_dbyk (mng_handle hHandle,
- mng_handle hChunk,
- mng_chunkid *iChunkname,
- mng_uint8 *iPolarity,
- mng_uint32 *iKeywordssize,
- mng_pchar *zKeywords)
-{
- mng_datap pData;
- mng_dbykp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DBYK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_dbykp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_DBYK)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iChunkname = pChunk->iChunkname; /* fill the fields */
- *iPolarity = pChunk->iPolarity;
- *iKeywordssize = pChunk->iKeywordssize;
- *zKeywords = pChunk->zKeywords;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DBYK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_ORDR
-mng_retcode MNG_DECL mng_getchunk_ordr (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iCount)
-{
- mng_datap pData;
- mng_ordrp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_ordrp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_ORDR)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iCount = pChunk->iCount; /* fill the field */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_ORDR
-mng_retcode MNG_DECL mng_getchunk_ordr_entry (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iEntry,
- mng_chunkid *iChunkname,
- mng_uint8 *iOrdertype)
-{
- mng_datap pData;
- mng_ordrp pChunk;
- mng_ordr_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_ordrp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_ORDR)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- if (iEntry >= pChunk->iCount) /* valid index ? */
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
-
- pEntry = pChunk->pEntries + iEntry; /* address the proper entry */
-
- *iChunkname = pEntry->iChunkname; /* fill the fields */
- *iOrdertype = pEntry->iOrdertype;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_MAGN
-mng_retcode MNG_DECL mng_getchunk_magn (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint16 *iFirstid,
- mng_uint16 *iLastid,
- mng_uint16 *iMethodX,
- mng_uint16 *iMX,
- mng_uint16 *iMY,
- mng_uint16 *iML,
- mng_uint16 *iMR,
- mng_uint16 *iMT,
- mng_uint16 *iMB,
- mng_uint16 *iMethodY)
-{
- mng_datap pData;
- mng_magnp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MAGN, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_magnp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_MAGN)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iFirstid = pChunk->iFirstid; /* fill the fields */
- *iLastid = pChunk->iLastid;
- *iMethodX = (mng_uint16)pChunk->iMethodX;
- *iMX = pChunk->iMX;
- *iMY = pChunk->iMY;
- *iML = pChunk->iML;
- *iMR = pChunk->iMR;
- *iMT = pChunk->iMT;
- *iMB = pChunk->iMB;
- *iMethodY = (mng_uint16)pChunk->iMethodY;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MAGN, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
-MNG_EXT mng_retcode MNG_DECL mng_getchunk_mpng (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iFramewidth,
- mng_uint32 *iFrameheight,
- mng_uint16 *iNumplays,
- mng_uint16 *iTickspersec,
- mng_uint8 *iCompressionmethod,
- mng_uint32 *iCount)
-{
- mng_datap pData;
- mng_mpngp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_mpngp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_mpNG)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* fill the fields */
- *iFramewidth = pChunk->iFramewidth;
- *iFrameheight = pChunk->iFrameheight;
- *iNumplays = pChunk->iNumplays;
- *iTickspersec = pChunk->iTickspersec;
- *iCompressionmethod = pChunk->iCompressionmethod;
- *iCount = pChunk->iFramessize / sizeof (mng_mpng_frame);
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
-MNG_EXT mng_retcode MNG_DECL mng_getchunk_mpng_frame (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iEntry,
- mng_uint32 *iX,
- mng_uint32 *iY,
- mng_uint32 *iWidth,
- mng_uint32 *iHeight,
- mng_int32 *iXoffset,
- mng_int32 *iYoffset,
- mng_uint16 *iTicks)
-{
- mng_datap pData;
- mng_mpngp pChunk;
- mng_mpng_framep pFrame;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG_FRAME, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_mpngp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_mpNG)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* valid index ? */
- if (iEntry >= (pChunk->iFramessize / sizeof (mng_mpng_frame)))
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
-
- pFrame = pChunk->pFrames + iEntry; /* address the entry */
- /* fill the fields */
- *iX = pFrame->iX;
- *iY = pFrame->iY;
- *iWidth = pFrame->iWidth;
- *iHeight = pFrame->iHeight;
- *iXoffset = pFrame->iXoffset;
- *iYoffset = pFrame->iYoffset;
- *iTicks = pFrame->iTicks;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG_FRAME, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_evNT
-mng_retcode MNG_DECL mng_getchunk_evnt (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 *iCount)
-{
- mng_datap pData;
- mng_evntp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_evntp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_evNT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- *iCount = pChunk->iCount; /* fill the fields */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_evnt_entry (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iEntry,
- 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)
-{
- mng_datap pData;
- mng_evntp pChunk;
- mng_evnt_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_evntp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.iChunkname != MNG_UINT_evNT)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
-
- if (iEntry >= pChunk->iCount) /* valid index ? */
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
-
- pEntry = pChunk->pEntries + iEntry; /* address the entry */
- /* fill the fields */
- *iEventtype = pEntry->iEventtype;
- *iMasktype = pEntry->iMasktype;
- *iLeft = pEntry->iLeft;
- *iRight = pEntry->iRight;
- *iTop = pEntry->iTop;
- *iBottom = pEntry->iBottom;
- *iObjectid = pEntry->iObjectid;
- *iIndex = pEntry->iIndex;
- *iSegmentnamesize = pEntry->iSegmentnamesize;
- *zSegmentname = pEntry->zSegmentname;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getchunk_unknown (mng_handle hHandle,
- mng_handle hChunk,
- mng_chunkid *iChunkname,
- mng_uint32 *iRawlen,
- mng_ptr *pRawdata)
-{
- mng_datap pData;
- mng_unknown_chunkp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_UNKNOWN, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
- pChunk = (mng_unknown_chunkp)hChunk; /* address the chunk */
-
- if (pChunk->sHeader.fCleanup != mng_free_unknown)
- MNG_ERROR (pData, MNG_WRONGCHUNK) /* ouch */
- /* fill the fields */
- *iChunkname = pChunk->sHeader.iChunkname;
- *iRawlen = pChunk->iDatasize;
- *pRawdata = pChunk->pData;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_UNKNOWN, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_WRITE_PROCS
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_TERM
-MNG_LOCAL mng_bool check_term (mng_datap pData,
- mng_chunkid iChunkname)
-{
- mng_chunk_headerp pChunk = (mng_chunk_headerp)pData->pLastchunk;
-
- if (!pChunk) /* nothing added yet ? */
- return MNG_TRUE;
- /* last added chunk is TERM ? */
- if (pChunk->iChunkname != MNG_UINT_TERM)
- return MNG_TRUE;
- /* previous to last is MHDR ? */
- if ((pChunk->pPrev) && (((mng_chunk_headerp)pChunk->pPrev)->iChunkname == MNG_UINT_MHDR))
- return MNG_TRUE;
-
- if (iChunkname == MNG_UINT_SEEK) /* new chunk to be added is SEEK ? */
- return MNG_TRUE;
-
- return MNG_FALSE;
-}
-#endif
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_ihdr (mng_handle hHandle,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_uint8 iBitdepth,
- mng_uint8 iColortype,
- mng_uint8 iCompression,
- mng_uint8 iFilter,
- mng_uint8 iInterlace)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_IHDR, mng_init_general, mng_free_general, mng_read_ihdr, mng_write_ihdr, mng_assign_general, 0, 0, sizeof(mng_ihdr)};
-#else
- {MNG_UINT_IHDR, mng_init_ihdr, mng_free_ihdr, mng_read_ihdr, mng_write_ihdr, mng_assign_ihdr, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_IHDR))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_ihdr (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_IHDR, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- ((mng_ihdrp)pChunk)->iWidth = iWidth;
- ((mng_ihdrp)pChunk)->iHeight = iHeight;
- ((mng_ihdrp)pChunk)->iBitdepth = iBitdepth;
- ((mng_ihdrp)pChunk)->iColortype = iColortype;
- ((mng_ihdrp)pChunk)->iCompression = iCompression;
- ((mng_ihdrp)pChunk)->iFilter = iFilter;
- ((mng_ihdrp)pChunk)->iInterlace = iInterlace;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_plte (mng_handle hHandle,
- mng_uint32 iCount,
- mng_palette8 aPalette)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_PLTE, mng_init_general, mng_free_general, mng_read_plte, mng_write_plte, mng_assign_general, 0, 0, sizeof(mng_plte)};
-#else
- {MNG_UINT_PLTE, mng_init_plte, mng_free_plte, mng_read_plte, mng_write_plte, mng_assign_plte, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PLTE, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_PLTE))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_plte (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_PLTE, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_pltep)pChunk)->iEntrycount = iCount;
- ((mng_pltep)pChunk)->bEmpty = (mng_bool)(iCount == 0);
-
- MNG_COPY (((mng_pltep)pChunk)->aEntries, aPalette, sizeof (mng_palette8));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PLTE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_idat (mng_handle hHandle,
- mng_uint32 iRawlen,
- mng_ptr pRawdata)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_IDAT, mng_init_general, mng_free_idat, mng_read_idat, mng_write_idat, mng_assign_idat, 0, 0, sizeof(mng_idat)};
-#else
- {MNG_UINT_IDAT, mng_init_idat, mng_free_idat, mng_read_idat, mng_write_idat, mng_assign_idat, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IDAT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_IDAT))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_idat (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_IDAT, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_idatp)pChunk)->bEmpty = (mng_bool)(iRawlen == 0);
- ((mng_idatp)pChunk)->iDatasize = iRawlen;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_idatp)pChunk)->pData, iRawlen);
- MNG_COPY (((mng_idatp)pChunk)->pData, pRawdata, iRawlen);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IDAT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_iend (mng_handle hHandle)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_IEND, mng_init_general, mng_free_general, mng_read_iend, mng_write_iend, mng_assign_general, 0, 0, sizeof(mng_iend)};
-#else
- {MNG_UINT_IEND, mng_init_iend, mng_free_iend, mng_read_iend, mng_write_iend, mng_assign_iend, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IEND, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_IEND))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_iend (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_IEND, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_INCLUDE_JNG
- if ((pData->iFirstchunkadded == MNG_UINT_IHDR) ||
- (pData->iFirstchunkadded == MNG_UINT_JHDR) )
-#else
- if (pData->iFirstchunkadded == MNG_UINT_IHDR)
-#endif
- pData->bCreating = MNG_FALSE; /* should be last chunk !!! */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IEND, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_trns (mng_handle hHandle,
- mng_bool bEmpty,
- mng_bool bGlobal,
- mng_uint8 iType,
- mng_uint32 iCount,
- mng_uint8arr aAlphas,
- mng_uint16 iGray,
- mng_uint16 iRed,
- mng_uint16 iGreen,
- mng_uint16 iBlue,
- mng_uint32 iRawlen,
- mng_uint8arr aRawdata)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_tRNS, mng_init_general, mng_free_general, mng_read_trns, mng_write_trns, mng_assign_general, 0, 0, sizeof(mng_trns)};
-#else
- {MNG_UINT_tRNS, mng_init_trns, mng_free_trns, mng_read_trns, mng_write_trns, mng_assign_trns, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TRNS, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_tRNS))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_trns (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_tRNS, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_trnsp)pChunk)->bEmpty = bEmpty;
- ((mng_trnsp)pChunk)->bGlobal = bGlobal;
- ((mng_trnsp)pChunk)->iType = iType;
- ((mng_trnsp)pChunk)->iCount = iCount;
- ((mng_trnsp)pChunk)->iGray = iGray;
- ((mng_trnsp)pChunk)->iRed = iRed;
- ((mng_trnsp)pChunk)->iGreen = iGreen;
- ((mng_trnsp)pChunk)->iBlue = iBlue;
- ((mng_trnsp)pChunk)->iRawlen = iRawlen;
-
- MNG_COPY (((mng_trnsp)pChunk)->aEntries, aAlphas, sizeof (mng_uint8arr));
- MNG_COPY (((mng_trnsp)pChunk)->aRawdata, aRawdata, sizeof (mng_uint8arr));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TRNS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_gAMA
-mng_retcode MNG_DECL mng_putchunk_gama (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint32 iGamma)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_gAMA, mng_init_general, mng_free_general, mng_read_gama, mng_write_gama, mng_assign_general, 0, 0, sizeof(mng_gama)};
-#else
- {MNG_UINT_gAMA, mng_init_gama, mng_free_gama, mng_read_gama, mng_write_gama, mng_assign_gama, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_GAMA, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_gAMA))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_gama (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_gAMA, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_gamap)pChunk)->bEmpty = bEmpty;
- ((mng_gamap)pChunk)->iGamma = iGamma;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_GAMA, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_cHRM
-mng_retcode MNG_DECL mng_putchunk_chrm (mng_handle hHandle,
- 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)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_cHRM, mng_init_general, mng_free_general, mng_read_chrm, mng_write_chrm, mng_assign_general, 0, 0, sizeof(mng_chrm)};
-#else
- {MNG_UINT_cHRM, mng_init_chrm, mng_free_chrm, mng_read_chrm, mng_write_chrm, mng_assign_chrm, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CHRM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_cHRM))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_chrm (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_cHRM, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_chrmp)pChunk)->bEmpty = bEmpty;
- ((mng_chrmp)pChunk)->iWhitepointx = iWhitepointx;
- ((mng_chrmp)pChunk)->iWhitepointy = iWhitepointy;
- ((mng_chrmp)pChunk)->iRedx = iRedx;
- ((mng_chrmp)pChunk)->iRedy = iRedy;
- ((mng_chrmp)pChunk)->iGreenx = iGreenx;
- ((mng_chrmp)pChunk)->iGreeny = iGreeny;
- ((mng_chrmp)pChunk)->iBluex = iBluex;
- ((mng_chrmp)pChunk)->iBluey = iBluey;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CHRM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sRGB
-mng_retcode MNG_DECL mng_putchunk_srgb (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint8 iRenderingintent)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_sRGB, mng_init_general, mng_free_general, mng_read_srgb, mng_write_srgb, mng_assign_general, 0, 0, sizeof(mng_srgb)};
-#else
- {MNG_UINT_sRGB, mng_init_srgb, mng_free_srgb, mng_read_srgb, mng_write_srgb, mng_assign_srgb, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SRGB, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_sRGB))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_srgb (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_sRGB, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_srgbp)pChunk)->bEmpty = bEmpty;
- ((mng_srgbp)pChunk)->iRenderingintent = iRenderingintent;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SRGB, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_iCCP
-mng_retcode MNG_DECL mng_putchunk_iccp (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint32 iNamesize,
- mng_pchar zName,
- mng_uint8 iCompression,
- mng_uint32 iProfilesize,
- mng_ptr pProfile)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_iCCP, mng_init_general, mng_free_iccp, mng_read_iccp, mng_write_iccp, mng_assign_iccp, 0, 0, sizeof(mng_iccp)};
-#else
- {MNG_UINT_iCCP, mng_init_iccp, mng_free_iccp, mng_read_iccp, mng_write_iccp, mng_assign_iccp, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ICCP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_iCCP))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_iccp (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_iCCP, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_iccpp)pChunk)->bEmpty = bEmpty;
- ((mng_iccpp)pChunk)->iNamesize = iNamesize;
- ((mng_iccpp)pChunk)->iCompression = iCompression;
- ((mng_iccpp)pChunk)->iProfilesize = iProfilesize;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, ((mng_iccpp)pChunk)->zName, iNamesize + 1);
- MNG_COPY (((mng_iccpp)pChunk)->zName, zName, iNamesize);
- }
-
- if (iProfilesize)
- {
- MNG_ALLOC (pData, ((mng_iccpp)pChunk)->pProfile, iProfilesize);
- MNG_COPY (((mng_iccpp)pChunk)->pProfile, pProfile, iProfilesize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ICCP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_tEXt
-mng_retcode MNG_DECL mng_putchunk_text (mng_handle hHandle,
- mng_uint32 iKeywordsize,
- mng_pchar zKeyword,
- mng_uint32 iTextsize,
- mng_pchar zText)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_tEXt, mng_init_general, mng_free_text, mng_read_text, mng_write_text, mng_assign_text, 0, 0, sizeof(mng_text)};
-#else
- {MNG_UINT_tEXt, mng_init_text, mng_free_text, mng_read_text, mng_write_text, mng_assign_text, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TEXT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_tEXt))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_text (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_tEXt, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_textp)pChunk)->iKeywordsize = iKeywordsize;
- ((mng_textp)pChunk)->iTextsize = iTextsize;
-
- if (iKeywordsize)
- {
- MNG_ALLOC (pData, ((mng_textp)pChunk)->zKeyword, iKeywordsize + 1);
- MNG_COPY (((mng_textp)pChunk)->zKeyword, zKeyword, iKeywordsize);
- }
-
- if (iTextsize)
- {
- MNG_ALLOC (pData, ((mng_textp)pChunk)->zText, iTextsize + 1);
- MNG_COPY (((mng_textp)pChunk)->zText, zText, iTextsize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TEXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_zTXt
-mng_retcode MNG_DECL mng_putchunk_ztxt (mng_handle hHandle,
- mng_uint32 iKeywordsize,
- mng_pchar zKeyword,
- mng_uint8 iCompression,
- mng_uint32 iTextsize,
- mng_pchar zText)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_zTXt, mng_init_general, mng_free_ztxt, mng_read_ztxt, mng_write_ztxt, mng_assign_ztxt, 0, 0, sizeof(mng_ztxt)};
-#else
- {MNG_UINT_zTXt, mng_init_ztxt, mng_free_ztxt, mng_read_ztxt, mng_write_ztxt, mng_assign_ztxt, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ZTXT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_zTXt))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_ztxt (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_zTXt, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_ztxtp)pChunk)->iKeywordsize = iKeywordsize;
- ((mng_ztxtp)pChunk)->iCompression = iCompression;
- ((mng_ztxtp)pChunk)->iTextsize = iTextsize;
-
- if (iKeywordsize)
- {
- MNG_ALLOC (pData, ((mng_ztxtp)pChunk)->zKeyword, iKeywordsize + 1);
- MNG_COPY (((mng_ztxtp)pChunk)->zKeyword, zKeyword, iKeywordsize);
- }
-
- if (iTextsize)
- {
- MNG_ALLOC (pData, ((mng_ztxtp)pChunk)->zText, iTextsize + 1);
- MNG_COPY (((mng_ztxtp)pChunk)->zText, zText, iTextsize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ZTXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_iTXt
-mng_retcode MNG_DECL mng_putchunk_itxt (mng_handle hHandle,
- mng_uint32 iKeywordsize,
- mng_pchar zKeyword,
- mng_uint8 iCompressionflag,
- mng_uint8 iCompressionmethod,
- mng_uint32 iLanguagesize,
- mng_pchar zLanguage,
- mng_uint32 iTranslationsize,
- mng_pchar zTranslation,
- mng_uint32 iTextsize,
- mng_pchar zText)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_iTXt, mng_init_general, mng_free_itxt, mng_read_itxt, mng_write_itxt, mng_assign_itxt, 0, 0, sizeof(mng_itxt)};
-#else
- {MNG_UINT_iTXt, mng_init_itxt, mng_free_itxt, mng_read_itxt, mng_write_itxt, mng_assign_itxt, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ITXT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_iTXt))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_itxt (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_iTXt, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_itxtp)pChunk)->iKeywordsize = iKeywordsize;
- ((mng_itxtp)pChunk)->iCompressionflag = iCompressionflag;
- ((mng_itxtp)pChunk)->iCompressionmethod = iCompressionmethod;
- ((mng_itxtp)pChunk)->iLanguagesize = iLanguagesize;
- ((mng_itxtp)pChunk)->iTranslationsize = iTranslationsize;
- ((mng_itxtp)pChunk)->iTextsize = iTextsize;
-
- if (iKeywordsize)
- {
- MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zKeyword, iKeywordsize + 1);
- MNG_COPY (((mng_itxtp)pChunk)->zKeyword, zKeyword, iKeywordsize);
- }
-
- if (iLanguagesize)
- {
- MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zLanguage, iLanguagesize + 1);
- MNG_COPY (((mng_itxtp)pChunk)->zLanguage, zLanguage, iLanguagesize);
- }
-
- if (iTranslationsize)
- {
- MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zTranslation, iTranslationsize + 1);
- MNG_COPY (((mng_itxtp)pChunk)->zTranslation, zTranslation, iTranslationsize);
- }
-
- if (iTextsize)
- {
- MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zText, iTextsize + 1);
- MNG_COPY (((mng_itxtp)pChunk)->zText, zText, iTextsize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ITXT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_bKGD
-mng_retcode MNG_DECL mng_putchunk_bkgd (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint8 iType,
- mng_uint8 iIndex,
- mng_uint16 iGray,
- mng_uint16 iRed,
- mng_uint16 iGreen,
- mng_uint16 iBlue)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_bKGD, mng_init_general, mng_free_general, mng_read_bkgd, mng_write_bkgd, mng_assign_general, 0, 0, sizeof(mng_bkgd)};
-#else
- {MNG_UINT_bKGD, mng_init_bkgd, mng_free_bkgd, mng_read_bkgd, mng_write_bkgd, mng_assign_bkgd, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BKGD, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_bKGD))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_bkgd (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_bKGD, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_bkgdp)pChunk)->bEmpty = bEmpty;
- ((mng_bkgdp)pChunk)->iType = iType;
- ((mng_bkgdp)pChunk)->iIndex = iIndex;
- ((mng_bkgdp)pChunk)->iGray = iGray;
- ((mng_bkgdp)pChunk)->iRed = iRed;
- ((mng_bkgdp)pChunk)->iGreen = iGreen;
- ((mng_bkgdp)pChunk)->iBlue = iBlue;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BKGD, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_pHYs
-mng_retcode MNG_DECL mng_putchunk_phys (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint32 iSizex,
- mng_uint32 iSizey,
- mng_uint8 iUnit)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_pHYs, mng_init_general, mng_free_general, mng_read_phys, mng_write_phys, mng_assign_general, 0, 0, sizeof(mng_phys)};
-#else
- {MNG_UINT_pHYs, mng_init_phys, mng_free_phys, mng_read_phys, mng_write_phys, mng_assign_phys, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYS, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_pHYs))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_phys (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_pHYs, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_physp)pChunk)->bEmpty = bEmpty;
- ((mng_physp)pChunk)->iSizex = iSizex;
- ((mng_physp)pChunk)->iSizey = iSizey;
- ((mng_physp)pChunk)->iUnit = iUnit;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYS, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sBIT
-mng_retcode MNG_DECL mng_putchunk_sbit (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint8 iType,
- mng_uint8arr4 aBits)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_sBIT, mng_init_general, mng_free_general, mng_read_sbit, mng_write_sbit, mng_assign_general, 0, 0, sizeof(mng_sbit)};
-#else
- {MNG_UINT_sBIT, mng_init_sbit, mng_free_sbit, mng_read_sbit, mng_write_sbit, mng_assign_sbit, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SBIT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_sBIT))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_sbit (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_sBIT, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_sbitp)pChunk)->bEmpty = bEmpty;
- ((mng_sbitp)pChunk)->iType = iType;
- ((mng_sbitp)pChunk)->aBits[0] = aBits[0];
- ((mng_sbitp)pChunk)->aBits[1] = aBits[1];
- ((mng_sbitp)pChunk)->aBits[2] = aBits[2];
- ((mng_sbitp)pChunk)->aBits[3] = aBits[3];
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SBIT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_sPLT
-mng_retcode MNG_DECL mng_putchunk_splt (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint32 iNamesize,
- mng_pchar zName,
- mng_uint8 iSampledepth,
- mng_uint32 iEntrycount,
- mng_ptr pEntries)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_sPLT, mng_init_general, mng_free_splt, mng_read_splt, mng_write_splt, mng_assign_splt, 0, 0, sizeof(mng_splt)};
-#else
- {MNG_UINT_sPLT, mng_init_splt, mng_free_splt, mng_read_splt, mng_write_splt, mng_assign_splt, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SPLT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_sPLT))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_splt (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_sPLT, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_spltp)pChunk)->bEmpty = bEmpty;
- ((mng_spltp)pChunk)->iNamesize = iNamesize;
- ((mng_spltp)pChunk)->iSampledepth = iSampledepth;
- ((mng_spltp)pChunk)->iEntrycount = iEntrycount;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, ((mng_spltp)pChunk)->zName, iNamesize + 1);
- MNG_COPY (((mng_spltp)pChunk)->zName, zName, iNamesize);
- }
-
- if (iEntrycount)
- {
- mng_uint32 iSize = iEntrycount * ((iSampledepth >> 1) + 2);
-
- MNG_ALLOC (pData, ((mng_spltp)pChunk)->pEntries, iSize);
- MNG_COPY (((mng_spltp)pChunk)->pEntries, pEntries, iSize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SPLT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_hIST
-mng_retcode MNG_DECL mng_putchunk_hist (mng_handle hHandle,
- mng_uint32 iEntrycount,
- mng_uint16arr aEntries)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_hIST, mng_init_general, mng_free_general, mng_read_hist, mng_write_hist, mng_assign_general, 0, 0, sizeof(mng_hist)};
-#else
- {MNG_UINT_hIST, mng_init_hist, mng_free_hist, mng_read_hist, mng_write_hist, mng_assign_hist, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_HIST, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_hIST))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_hist (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_hIST, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_histp)pChunk)->iEntrycount = iEntrycount;
-
- MNG_COPY (((mng_histp)pChunk)->aEntries, aEntries, sizeof (mng_uint16arr));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_HIST, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_tIME
-mng_retcode MNG_DECL mng_putchunk_time (mng_handle hHandle,
- mng_uint16 iYear,
- mng_uint8 iMonth,
- mng_uint8 iDay,
- mng_uint8 iHour,
- mng_uint8 iMinute,
- mng_uint8 iSecond)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_tIME, mng_init_general, mng_free_general, mng_read_time, mng_write_time, mng_assign_general, 0, 0, sizeof(mng_time)};
-#else
- {MNG_UINT_tIME, mng_init_time, mng_free_time, mng_read_time, mng_write_time, mng_assign_time, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TIME, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_tIME))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_time (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_tIME, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_timep)pChunk)->iYear = iYear;
- ((mng_timep)pChunk)->iMonth = iMonth;
- ((mng_timep)pChunk)->iDay = iDay;
- ((mng_timep)pChunk)->iHour = iHour;
- ((mng_timep)pChunk)->iMinute = iMinute;
- ((mng_timep)pChunk)->iSecond = iSecond;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TIME, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_mhdr (mng_handle hHandle,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_uint32 iTicks,
- mng_uint32 iLayercount,
- mng_uint32 iFramecount,
- mng_uint32 iPlaytime,
- mng_uint32 iSimplicity)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_MHDR, mng_init_general, mng_free_general, mng_read_mhdr, mng_write_mhdr, mng_assign_general, 0, 0, sizeof(mng_mhdr)};
-#else
- {MNG_UINT_MHDR, mng_init_mhdr, mng_free_mhdr, mng_read_mhdr, mng_write_mhdr, mng_assign_mhdr, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must be very first! */
- if (pData->iFirstchunkadded != 0)
- MNG_ERROR (pData, MNG_SEQUENCEERROR)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_MHDR))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_mhdr (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_MHDR, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_mhdrp)pChunk)->iWidth = iWidth;
- ((mng_mhdrp)pChunk)->iHeight = iHeight;
- ((mng_mhdrp)pChunk)->iTicks = iTicks;
- ((mng_mhdrp)pChunk)->iLayercount = iLayercount;
- ((mng_mhdrp)pChunk)->iFramecount = iFramecount;
- ((mng_mhdrp)pChunk)->iPlaytime = iPlaytime;
- ((mng_mhdrp)pChunk)->iSimplicity = iSimplicity;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_mend (mng_handle hHandle)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_MEND, mng_init_general, mng_free_general, mng_read_mend, mng_write_mend, mng_assign_general, 0, 0, sizeof(mng_mend)};
-#else
- {MNG_UINT_MEND, mng_init_mend, mng_free_mend, mng_read_mend, mng_write_mend, mng_assign_mend, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MEND, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_MEND))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_mend (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_MEND, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
- pData->bCreating = MNG_FALSE; /* should be last chunk !!! */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MEND, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_LOOP
-mng_retcode MNG_DECL mng_putchunk_loop (mng_handle hHandle,
- mng_uint8 iLevel,
- mng_uint32 iRepeat,
- mng_uint8 iTermination,
- mng_uint32 iItermin,
- mng_uint32 iItermax,
- mng_uint32 iCount,
- mng_uint32p pSignals)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_LOOP, mng_init_general, mng_free_loop, mng_read_loop, mng_write_loop, mng_assign_loop, 0, 0, sizeof(mng_loop)};
-#else
- {MNG_UINT_LOOP, mng_init_loop, mng_free_loop, mng_read_loop, mng_write_loop, mng_assign_loop, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_LOOP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_LOOP))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_loop (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_LOOP, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_loopp)pChunk)->iLevel = iLevel;
- ((mng_loopp)pChunk)->iRepeat = iRepeat;
- ((mng_loopp)pChunk)->iTermination = iTermination;
- ((mng_loopp)pChunk)->iItermin = iItermin;
- ((mng_loopp)pChunk)->iItermax = iItermax;
- ((mng_loopp)pChunk)->iCount = iCount;
- ((mng_loopp)pChunk)->pSignals = pSignals;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_LOOP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_endl (mng_handle hHandle,
- mng_uint8 iLevel)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_ENDL, mng_init_general, mng_free_general, mng_read_endl, mng_write_endl, mng_assign_general, 0, 0, sizeof(mng_endl)};
-#else
- {MNG_UINT_ENDL, mng_init_endl, mng_free_endl, mng_read_endl, mng_write_endl, mng_assign_endl, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ENDL, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_ENDL))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_endl (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_ENDL, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_endlp)pChunk)->iLevel = iLevel;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ENDL, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_DEFI
-mng_retcode MNG_DECL mng_putchunk_defi (mng_handle hHandle,
- mng_uint16 iObjectid,
- mng_uint8 iDonotshow,
- mng_uint8 iConcrete,
- mng_bool bHasloca,
- mng_int32 iXlocation,
- mng_int32 iYlocation,
- mng_bool bHasclip,
- mng_int32 iLeftcb,
- mng_int32 iRightcb,
- mng_int32 iTopcb,
- mng_int32 iBottomcb)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_DEFI, mng_init_general, mng_free_general, mng_read_defi, mng_write_defi, mng_assign_general, 0, 0, sizeof(mng_defi)};
-#else
- {MNG_UINT_DEFI, mng_init_defi, mng_free_defi, mng_read_defi, mng_write_defi, mng_assign_defi, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DEFI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_DEFI))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_defi (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_DEFI, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_defip)pChunk)->iObjectid = iObjectid;
- ((mng_defip)pChunk)->iDonotshow = iDonotshow;
- ((mng_defip)pChunk)->iConcrete = iConcrete;
- ((mng_defip)pChunk)->bHasloca = bHasloca;
- ((mng_defip)pChunk)->iXlocation = iXlocation;
- ((mng_defip)pChunk)->iYlocation = iYlocation;
- ((mng_defip)pChunk)->bHasclip = bHasclip;
- ((mng_defip)pChunk)->iLeftcb = iLeftcb;
- ((mng_defip)pChunk)->iRightcb = iRightcb;
- ((mng_defip)pChunk)->iTopcb = iTopcb;
- ((mng_defip)pChunk)->iBottomcb = iBottomcb;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DEFI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_BASI
-mng_retcode MNG_DECL mng_putchunk_basi (mng_handle hHandle,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_uint8 iBitdepth,
- mng_uint8 iColortype,
- mng_uint8 iCompression,
- mng_uint8 iFilter,
- mng_uint8 iInterlace,
- mng_uint16 iRed,
- mng_uint16 iGreen,
- mng_uint16 iBlue,
- mng_uint16 iAlpha,
- mng_uint8 iViewable)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_BASI, mng_init_general, mng_free_general, mng_read_basi, mng_write_basi, mng_assign_general, 0, 0, sizeof(mng_basi)};
-#else
- {MNG_UINT_BASI, mng_init_basi, mng_free_basi, mng_read_basi, mng_write_basi, mng_assign_basi, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BASI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_BASI))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_basi (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_BASI, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_basip)pChunk)->iWidth = iWidth;
- ((mng_basip)pChunk)->iHeight = iHeight;
- ((mng_basip)pChunk)->iBitdepth = iBitdepth;
- ((mng_basip)pChunk)->iColortype = iColortype;
- ((mng_basip)pChunk)->iCompression = iCompression;
- ((mng_basip)pChunk)->iFilter = iFilter;
- ((mng_basip)pChunk)->iInterlace = iInterlace;
- ((mng_basip)pChunk)->iRed = iRed;
- ((mng_basip)pChunk)->iGreen = iGreen;
- ((mng_basip)pChunk)->iBlue = iBlue;
- ((mng_basip)pChunk)->iAlpha = iAlpha;
- ((mng_basip)pChunk)->iViewable = iViewable;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BASI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_CLON
-mng_retcode MNG_DECL mng_putchunk_clon (mng_handle hHandle,
- mng_uint16 iSourceid,
- mng_uint16 iCloneid,
- mng_uint8 iClonetype,
- mng_uint8 iDonotshow,
- mng_uint8 iConcrete,
- mng_bool bHasloca,
- mng_uint8 iLocationtype,
- mng_int32 iLocationx,
- mng_int32 iLocationy)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_CLON, mng_init_general, mng_free_general, mng_read_clon, mng_write_clon, mng_assign_general, 0, 0, sizeof(mng_clon)};
-#else
- {MNG_UINT_CLON, mng_init_clon, mng_free_clon, mng_read_clon, mng_write_clon, mng_assign_clon, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLON, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_CLON))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_clon (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_CLON, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_clonp)pChunk)->iSourceid = iSourceid;
- ((mng_clonp)pChunk)->iCloneid = iCloneid;
- ((mng_clonp)pChunk)->iClonetype = iClonetype;
- ((mng_clonp)pChunk)->iDonotshow = iDonotshow;
- ((mng_clonp)pChunk)->iConcrete = iConcrete;
- ((mng_clonp)pChunk)->bHasloca = bHasloca;
- ((mng_clonp)pChunk)->iLocationtype = iLocationtype;
- ((mng_clonp)pChunk)->iLocationx = iLocationx;
- ((mng_clonp)pChunk)->iLocationy = iLocationy;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLON, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_PAST
-mng_retcode MNG_DECL mng_putchunk_past (mng_handle hHandle,
- mng_uint16 iDestid,
- mng_uint8 iTargettype,
- mng_int32 iTargetx,
- mng_int32 iTargety,
- mng_uint32 iCount)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_PAST, mng_init_general, mng_free_past, mng_read_past, mng_write_past, mng_assign_past, 0, 0, sizeof(mng_past)};
-#else
- {MNG_UINT_PAST, mng_init_past, mng_free_past, mng_read_past, mng_write_past, mng_assign_past, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_PAST))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_past (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_PAST, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_pastp)pChunk)->iDestid = iDestid;
- ((mng_pastp)pChunk)->iTargettype = iTargettype;
- ((mng_pastp)pChunk)->iTargetx = iTargetx;
- ((mng_pastp)pChunk)->iTargety = iTargety;
- ((mng_pastp)pChunk)->iCount = iCount;
-
- if (iCount)
- MNG_ALLOC (pData, ((mng_pastp)pChunk)->pSources, iCount * sizeof (mng_past_source));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_PAST
-mng_retcode MNG_DECL mng_putchunk_past_src (mng_handle hHandle,
- mng_uint32 iEntry,
- mng_uint16 iSourceid,
- mng_uint8 iComposition,
- mng_uint8 iOrientation,
- mng_uint8 iOffsettype,
- mng_int32 iOffsetx,
- mng_int32 iOffsety,
- mng_uint8 iBoundarytype,
- mng_int32 iBoundaryl,
- mng_int32 iBoundaryr,
- mng_int32 iBoundaryt,
- mng_int32 iBoundaryb)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_past_sourcep pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST_SRC, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
-
- pChunk = pData->pLastchunk; /* last one must have been PAST ! */
-
- if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_PAST)
- MNG_ERROR (pData, MNG_NOCORRCHUNK)
- /* index out of bounds ? */
- if (iEntry >= ((mng_pastp)pChunk)->iCount)
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address proper entry */
- pEntry = ((mng_pastp)pChunk)->pSources + iEntry;
-
- pEntry->iSourceid = iSourceid; /* fill entry */
- pEntry->iComposition = iComposition;
- pEntry->iOrientation = iOrientation;
- pEntry->iOffsettype = iOffsettype;
- pEntry->iOffsetx = iOffsetx;
- pEntry->iOffsety = iOffsety;
- pEntry->iBoundarytype = iBoundarytype;
- pEntry->iBoundaryl = iBoundaryl;
- pEntry->iBoundaryr = iBoundaryr;
- pEntry->iBoundaryt = iBoundaryt;
- pEntry->iBoundaryb = iBoundaryb;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST_SRC, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_DISC
-mng_retcode MNG_DECL mng_putchunk_disc (mng_handle hHandle,
- mng_uint32 iCount,
- mng_uint16p pObjectids)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_DISC, mng_init_general, mng_free_disc, mng_read_disc, mng_write_disc, mng_assign_disc, 0, 0, sizeof(mng_disc)};
-#else
- {MNG_UINT_DISC, mng_init_disc, mng_free_disc, mng_read_disc, mng_write_disc, mng_assign_disc, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DISC, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_DISC))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_disc (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_DISC, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_discp)pChunk)->iCount = iCount;
-
- if (iCount)
- {
- mng_uint32 iSize = iCount * sizeof (mng_uint32);
-
- MNG_ALLOC (pData, ((mng_discp)pChunk)->pObjectids, iSize);
- MNG_COPY (((mng_discp)pChunk)->pObjectids, pObjectids, iSize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DISC, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_BACK
-mng_retcode MNG_DECL mng_putchunk_back (mng_handle hHandle,
- mng_uint16 iRed,
- mng_uint16 iGreen,
- mng_uint16 iBlue,
- mng_uint8 iMandatory,
- mng_uint16 iImageid,
- mng_uint8 iTile)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_BACK, mng_init_general, mng_free_general, mng_read_back, mng_write_back, mng_assign_general, 0, 0, sizeof(mng_back)};
-#else
- {MNG_UINT_BACK, mng_init_back, mng_free_back, mng_read_back, mng_write_back, mng_assign_back, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BACK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_BACK))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_back (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_BACK, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_backp)pChunk)->iRed = iRed;
- ((mng_backp)pChunk)->iGreen = iGreen;
- ((mng_backp)pChunk)->iBlue = iBlue;
- ((mng_backp)pChunk)->iMandatory = iMandatory;
- ((mng_backp)pChunk)->iImageid = iImageid;
- ((mng_backp)pChunk)->iTile = iTile;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BACK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_FRAM
-mng_retcode MNG_DECL mng_putchunk_fram (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint8 iMode,
- mng_uint32 iNamesize,
- mng_pchar zName,
- mng_uint8 iChangedelay,
- mng_uint8 iChangetimeout,
- mng_uint8 iChangeclipping,
- mng_uint8 iChangesyncid,
- mng_uint32 iDelay,
- mng_uint32 iTimeout,
- mng_uint8 iBoundarytype,
- mng_int32 iBoundaryl,
- mng_int32 iBoundaryr,
- mng_int32 iBoundaryt,
- mng_int32 iBoundaryb,
- mng_uint32 iCount,
- mng_uint32p pSyncids)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_FRAM, mng_init_general, mng_free_fram, mng_read_fram, mng_write_fram, mng_assign_fram, 0, 0, sizeof(mng_fram)};
-#else
- {MNG_UINT_FRAM, mng_init_fram, mng_free_fram, mng_read_fram, mng_write_fram, mng_assign_fram, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FRAM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_FRAM))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_fram (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_FRAM, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_framp)pChunk)->bEmpty = bEmpty;
- ((mng_framp)pChunk)->iMode = iMode;
- ((mng_framp)pChunk)->iNamesize = iNamesize;
- ((mng_framp)pChunk)->iChangedelay = iChangedelay;
- ((mng_framp)pChunk)->iChangetimeout = iChangetimeout;
- ((mng_framp)pChunk)->iChangeclipping = iChangeclipping;
- ((mng_framp)pChunk)->iChangesyncid = iChangesyncid;
- ((mng_framp)pChunk)->iDelay = iDelay;
- ((mng_framp)pChunk)->iTimeout = iTimeout;
- ((mng_framp)pChunk)->iBoundarytype = iBoundarytype;
- ((mng_framp)pChunk)->iBoundaryl = iBoundaryl;
- ((mng_framp)pChunk)->iBoundaryr = iBoundaryr;
- ((mng_framp)pChunk)->iBoundaryt = iBoundaryt;
- ((mng_framp)pChunk)->iBoundaryb = iBoundaryb;
- ((mng_framp)pChunk)->iCount = iCount;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, ((mng_framp)pChunk)->zName, iNamesize + 1);
- MNG_COPY (((mng_framp)pChunk)->zName, zName, iNamesize);
- }
-
- if (iCount)
- {
- mng_uint32 iSize = iCount * sizeof (mng_uint32);
-
- MNG_ALLOC (pData, ((mng_framp)pChunk)->pSyncids, iSize);
- MNG_COPY (((mng_framp)pChunk)->pSyncids, pSyncids, iSize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FRAM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_MOVE
-mng_retcode MNG_DECL mng_putchunk_move (mng_handle hHandle,
- mng_uint16 iFirstid,
- mng_uint16 iLastid,
- mng_uint8 iMovetype,
- mng_int32 iMovex,
- mng_int32 iMovey)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_MOVE, mng_init_general, mng_free_general, mng_read_move, mng_write_move, mng_assign_general, 0, 0, sizeof(mng_move)};
-#else
- {MNG_UINT_MOVE, mng_init_move, mng_free_move, mng_read_move, mng_write_move, mng_assign_move, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MOVE, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_MOVE))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_move (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_MOVE, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_movep)pChunk)->iFirstid = iFirstid;
- ((mng_movep)pChunk)->iLastid = iLastid;
- ((mng_movep)pChunk)->iMovetype = iMovetype;
- ((mng_movep)pChunk)->iMovex = iMovex;
- ((mng_movep)pChunk)->iMovey = iMovey;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MOVE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_CLIP
-mng_retcode MNG_DECL mng_putchunk_clip (mng_handle hHandle,
- mng_uint16 iFirstid,
- mng_uint16 iLastid,
- mng_uint8 iCliptype,
- mng_int32 iClipl,
- mng_int32 iClipr,
- mng_int32 iClipt,
- mng_int32 iClipb)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_CLIP, mng_init_general, mng_free_general, mng_read_clip, mng_write_clip, mng_assign_general, 0, 0, sizeof(mng_clip)};
-#else
- {MNG_UINT_CLIP, mng_init_clip, mng_free_clip, mng_read_clip, mng_write_clip, mng_assign_clip, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLIP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_CLIP))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_clip (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_CLIP, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_clipp)pChunk)->iFirstid = iFirstid;
- ((mng_clipp)pChunk)->iLastid = iLastid;
- ((mng_clipp)pChunk)->iCliptype = iCliptype;
- ((mng_clipp)pChunk)->iClipl = iClipl;
- ((mng_clipp)pChunk)->iClipr = iClipr;
- ((mng_clipp)pChunk)->iClipt = iClipt;
- ((mng_clipp)pChunk)->iClipb = iClipb;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLIP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SHOW
-mng_retcode MNG_DECL mng_putchunk_show (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint16 iFirstid,
- mng_uint16 iLastid,
- mng_uint8 iMode)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_SHOW, mng_init_general, mng_free_general, mng_read_show, mng_write_show, mng_assign_general, 0, 0, sizeof(mng_show)};
-#else
- {MNG_UINT_SHOW, mng_init_show, mng_free_show, mng_read_show, mng_write_show, mng_assign_show, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SHOW, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_SHOW))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_show (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_SHOW, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_showp)pChunk)->bEmpty = bEmpty;
- ((mng_showp)pChunk)->iFirstid = iFirstid;
- ((mng_showp)pChunk)->iLastid = iLastid;
- ((mng_showp)pChunk)->iMode = iMode;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SHOW, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_TERM
-mng_retcode MNG_DECL mng_putchunk_term (mng_handle hHandle,
- mng_uint8 iTermaction,
- mng_uint8 iIteraction,
- mng_uint32 iDelay,
- mng_uint32 iItermax)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_TERM, mng_init_general, mng_free_general, mng_read_term, mng_write_term, mng_assign_general, 0, 0, sizeof(mng_term)};
-#else
- {MNG_UINT_TERM, mng_init_term, mng_free_term, mng_read_term, mng_write_term, mng_assign_term, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TERM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_term (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_TERM, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_termp)pChunk)->iTermaction = iTermaction;
- ((mng_termp)pChunk)->iIteraction = iIteraction;
- ((mng_termp)pChunk)->iDelay = iDelay;
- ((mng_termp)pChunk)->iItermax = iItermax;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TERM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SAVE
-mng_retcode MNG_DECL mng_putchunk_save (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint8 iOffsettype,
- mng_uint32 iCount)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_SAVE, mng_init_general, mng_free_save, mng_read_save, mng_write_save, mng_assign_save, 0, 0, sizeof(mng_save)};
-#else
- {MNG_UINT_SAVE, mng_init_save, mng_free_save, mng_read_save, mng_write_save, mng_assign_save, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_SAVE))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_save (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_SAVE, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_savep)pChunk)->bEmpty = bEmpty;
- ((mng_savep)pChunk)->iOffsettype = iOffsettype;
- ((mng_savep)pChunk)->iCount = iCount;
-
- if (iCount)
- MNG_ALLOC (pData, ((mng_savep)pChunk)->pEntries, iCount * sizeof (mng_save_entry));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_save_entry (mng_handle hHandle,
- mng_uint32 iEntry,
- mng_uint8 iEntrytype,
- mng_uint32arr2 iOffset,
- mng_uint32arr2 iStarttime,
- mng_uint32 iLayernr,
- mng_uint32 iFramenr,
- mng_uint32 iNamesize,
- mng_pchar zName)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_save_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
-
- pChunk = pData->pLastchunk; /* last one must have been SAVE ! */
-
- if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_SAVE)
- MNG_ERROR (pData, MNG_NOCORRCHUNK)
- /* index out of bounds ? */
- if (iEntry >= ((mng_savep)pChunk)->iCount)
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address proper entry */
- pEntry = ((mng_savep)pChunk)->pEntries + iEntry;
-
- pEntry->iEntrytype = iEntrytype; /* fill entry */
- pEntry->iOffset[0] = iOffset[0];
- pEntry->iOffset[1] = iOffset[1];
- pEntry->iStarttime[0] = iStarttime[0];
- pEntry->iStarttime[1] = iStarttime[1];
- pEntry->iLayernr = iLayernr;
- pEntry->iFramenr = iFramenr;
- pEntry->iNamesize = iNamesize;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, pEntry->zName, iNamesize + 1);
- MNG_COPY (pEntry->zName, zName, iNamesize);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_SEEK
-mng_retcode MNG_DECL mng_putchunk_seek (mng_handle hHandle,
- mng_uint32 iNamesize,
- mng_pchar zName)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_SEEK, mng_init_general, mng_free_seek, mng_read_seek, mng_write_seek, mng_assign_seek, 0, 0, sizeof(mng_seek)};
-#else
- {MNG_UINT_SEEK, mng_init_seek, mng_free_seek, mng_read_seek, mng_write_seek, mng_assign_seek, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SEEK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_SEEK))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_seek (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_SEEK, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_seekp)pChunk)->iNamesize = iNamesize;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, ((mng_seekp)pChunk)->zName, iNamesize + 1);
- MNG_COPY (((mng_seekp)pChunk)->zName, zName, iNamesize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SEEK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_eXPI
-mng_retcode MNG_DECL mng_putchunk_expi (mng_handle hHandle,
- mng_uint16 iSnapshotid,
- mng_uint32 iNamesize,
- mng_pchar zName)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_eXPI, mng_init_general, mng_free_expi, mng_read_expi, mng_write_expi, mng_assign_general, 0, 0, sizeof(mng_expi)};
-#else
- {MNG_UINT_eXPI, mng_init_expi, mng_free_expi, mng_read_expi, mng_write_expi, mng_assign_expi, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EXPI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_eXPI))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_expi (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_eXPI, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_expip)pChunk)->iSnapshotid = iSnapshotid;
- ((mng_expip)pChunk)->iNamesize = iNamesize;
-
- if (iNamesize)
- {
- MNG_ALLOC (pData, ((mng_expip)pChunk)->zName, iNamesize + 1);
- MNG_COPY (((mng_expip)pChunk)->zName, zName, iNamesize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EXPI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_fPRI
-mng_retcode MNG_DECL mng_putchunk_fpri (mng_handle hHandle,
- mng_uint8 iDeltatype,
- mng_uint8 iPriority)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_fPRI, mng_init_general, mng_free_general, mng_read_fpri, mng_write_fpri, mng_assign_general, 0, 0, sizeof(mng_fpri)};
-#else
- {MNG_UINT_fPRI, mng_init_fpri, mng_free_fpri, mng_read_fpri, mng_write_fpri, mng_assign_fpri, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FPRI, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_fPRI))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_fpri (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_fPRI, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_fprip)pChunk)->iDeltatype = iDeltatype;
- ((mng_fprip)pChunk)->iPriority = iPriority;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FPRI, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_nEED
-mng_retcode MNG_DECL mng_putchunk_need (mng_handle hHandle,
- mng_uint32 iKeywordssize,
- mng_pchar zKeywords)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_nEED, mng_init_general, mng_free_need, mng_read_need, mng_write_need, mng_assign_need, 0, 0, sizeof(mng_need)};
-#else
- {MNG_UINT_nEED, mng_init_need, mng_free_need, mng_read_need, mng_write_need, mng_assign_need, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_NEED, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_nEED))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_need (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_nEED, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_needp)pChunk)->iKeywordssize = iKeywordssize;
-
- if (iKeywordssize)
- {
- MNG_ALLOC (pData, ((mng_needp)pChunk)->zKeywords, iKeywordssize + 1);
- MNG_COPY (((mng_needp)pChunk)->zKeywords, zKeywords, iKeywordssize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_NEED, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_pHYg
-mng_retcode MNG_DECL mng_putchunk_phyg (mng_handle hHandle,
- mng_bool bEmpty,
- mng_uint32 iSizex,
- mng_uint32 iSizey,
- mng_uint8 iUnit)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_pHYg, mng_init_general, mng_free_general, mng_read_phyg, mng_write_phyg, mng_assign_general, 0, 0, sizeof(mng_phyg)};
-#else
- {MNG_UINT_pHYg, mng_init_phyg, mng_free_phyg, mng_read_phyg, mng_write_phyg, mng_assign_phyg, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYG, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_pHYg))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_phyg (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_pHYg, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_phygp)pChunk)->bEmpty = bEmpty;
- ((mng_phygp)pChunk)->iSizex = iSizex;
- ((mng_phygp)pChunk)->iSizey = iSizey;
- ((mng_phygp)pChunk)->iUnit = iUnit;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_putchunk_jhdr (mng_handle hHandle,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_uint8 iColortype,
- mng_uint8 iImagesampledepth,
- mng_uint8 iImagecompression,
- mng_uint8 iImageinterlace,
- mng_uint8 iAlphasampledepth,
- mng_uint8 iAlphacompression,
- mng_uint8 iAlphafilter,
- mng_uint8 iAlphainterlace)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_JHDR, mng_init_general, mng_free_general, mng_read_jhdr, mng_write_jhdr, mng_assign_general, 0, 0, sizeof(mng_jhdr)};
-#else
- {MNG_UINT_JHDR, mng_init_jhdr, mng_free_jhdr, mng_read_jhdr, mng_write_jhdr, mng_assign_jhdr, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_JHDR))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_jhdr (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_JHDR, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_jhdrp)pChunk)->iWidth = iWidth;
- ((mng_jhdrp)pChunk)->iHeight = iHeight;
- ((mng_jhdrp)pChunk)->iColortype = iColortype;
- ((mng_jhdrp)pChunk)->iImagesampledepth = iImagesampledepth;
- ((mng_jhdrp)pChunk)->iImagecompression = iImagecompression;
- ((mng_jhdrp)pChunk)->iImageinterlace = iImageinterlace;
- ((mng_jhdrp)pChunk)->iAlphasampledepth = iAlphasampledepth;
- ((mng_jhdrp)pChunk)->iAlphacompression = iAlphacompression;
- ((mng_jhdrp)pChunk)->iAlphafilter = iAlphafilter;
- ((mng_jhdrp)pChunk)->iAlphainterlace = iAlphainterlace;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_putchunk_jdat (mng_handle hHandle,
- mng_uint32 iRawlen,
- mng_ptr pRawdata)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_JDAT, mng_init_general, mng_free_jdat, mng_read_jdat, mng_write_jdat, mng_assign_jdat, 0, 0, sizeof(mng_jdat)};
-#else
- {MNG_UINT_JDAT, mng_init_jdat, mng_free_jdat, mng_read_jdat, mng_write_jdat, mng_assign_jdat, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR or JHDR first! */
- if ((pData->iFirstchunkadded != MNG_UINT_MHDR) &&
- (pData->iFirstchunkadded != MNG_UINT_JHDR) )
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_JDAT))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_jdat (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_JDAT, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_jdatp)pChunk)->iDatasize = iRawlen;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_jdatp)pChunk)->pData, iRawlen);
- MNG_COPY (((mng_jdatp)pChunk)->pData, pRawdata, iRawlen);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_putchunk_jdaa (mng_handle hHandle,
- mng_uint32 iRawlen,
- mng_ptr pRawdata)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_JDAA, mng_init_general, mng_free_jdaa, mng_read_jdaa, mng_write_jdaa, mng_assign_jdaa, 0, 0, sizeof(mng_jdaa)};
-#else
- {MNG_UINT_JDAA, mng_init_jdaa, mng_free_jdaa, mng_read_jdaa, mng_write_jdaa, mng_assign_jdaa, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAA, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR or JHDR first! */
- if ((pData->iFirstchunkadded != MNG_UINT_MHDR) &&
- (pData->iFirstchunkadded != MNG_UINT_JHDR) )
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_JDAA))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_jdaa (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_JDAA, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_jdaap)pChunk)->iDatasize = iRawlen;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_jdaap)pChunk)->pData, iRawlen);
- MNG_COPY (((mng_jdaap)pChunk)->pData, pRawdata, iRawlen);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAA, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-
-mng_retcode MNG_DECL mng_putchunk_jsep (mng_handle hHandle)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_JSEP, mng_init_general, mng_free_general, mng_read_jsep, mng_write_jsep, mng_assign_general, 0, 0, sizeof(mng_jsep)};
-#else
- {MNG_UINT_JSEP, mng_init_jsep, mng_free_jsep, mng_read_jsep, mng_write_jsep, mng_assign_jsep, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JSEP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR or JHDR first! */
- if ((pData->iFirstchunkadded != MNG_UINT_MHDR) &&
- (pData->iFirstchunkadded != MNG_UINT_JHDR) )
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_JSEP))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_jsep (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_JSEP, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JSEP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-#endif /* MNG_INCLUDE_JNG */
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_putchunk_dhdr (mng_handle hHandle,
- mng_uint16 iObjectid,
- mng_uint8 iImagetype,
- mng_uint8 iDeltatype,
- mng_uint32 iBlockwidth,
- mng_uint32 iBlockheight,
- mng_uint32 iBlockx,
- mng_uint32 iBlocky)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_DHDR, mng_init_general, mng_free_general, mng_read_dhdr, mng_write_dhdr, mng_assign_general, 0, 0, sizeof(mng_dhdr)};
-#else
- {MNG_UINT_DHDR, mng_init_dhdr, mng_free_dhdr, mng_read_dhdr, mng_write_dhdr, mng_assign_dhdr, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DHDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_DHDR))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_dhdr (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_DHDR, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_dhdrp)pChunk)->iObjectid = iObjectid;
- ((mng_dhdrp)pChunk)->iImagetype = iImagetype;
- ((mng_dhdrp)pChunk)->iDeltatype = iDeltatype;
- ((mng_dhdrp)pChunk)->iBlockwidth = iBlockwidth;
- ((mng_dhdrp)pChunk)->iBlockheight = iBlockheight;
- ((mng_dhdrp)pChunk)->iBlockx = iBlockx;
- ((mng_dhdrp)pChunk)->iBlocky = iBlocky;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DHDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_putchunk_prom (mng_handle hHandle,
- mng_uint8 iColortype,
- mng_uint8 iSampledepth,
- mng_uint8 iFilltype)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_PROM, mng_init_general, mng_free_general, mng_read_prom, mng_write_prom, mng_assign_general, 0, 0, sizeof(mng_prom)};
-#else
- {MNG_UINT_PROM, mng_init_prom, mng_free_prom, mng_read_prom, mng_write_prom, mng_assign_prom, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PROM, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_PROM))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_prom (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_PROM, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_promp)pChunk)->iColortype = iColortype;
- ((mng_promp)pChunk)->iSampledepth = iSampledepth;
- ((mng_promp)pChunk)->iFilltype = iFilltype;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PROM, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_putchunk_ipng (mng_handle hHandle)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_IPNG, mng_init_general, mng_free_general, mng_read_ipng, mng_write_ipng, mng_assign_general, 0, 0, sizeof(mng_ipng)};
-#else
- {MNG_UINT_IPNG, mng_init_ipng, mng_free_ipng, mng_read_ipng, mng_write_ipng, mng_assign_ipng, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IPNG, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_IPNG))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_ipng (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_IPNG, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IPNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_putchunk_pplt (mng_handle hHandle,
- mng_uint8 iDeltatype,
- mng_uint32 iCount)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_PPLT, mng_init_general, mng_free_general, mng_read_pplt, mng_write_pplt, mng_assign_general, 0, 0, sizeof(mng_pplt)};
-#else
- {MNG_UINT_PPLT, mng_init_pplt, mng_free_pplt, mng_read_pplt, mng_write_pplt, mng_assign_pplt, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_PPLT))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_pplt (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_PPLT, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_ppltp)pChunk)->iDeltatype = iDeltatype;
- ((mng_ppltp)pChunk)->iCount = iCount;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_putchunk_pplt_entry (mng_handle hHandle,
- mng_uint32 iEntry,
- mng_uint16 iRed,
- mng_uint16 iGreen,
- mng_uint16 iBlue,
- mng_uint16 iAlpha)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_pplt_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
-
- pChunk = pData->pLastchunk; /* last one must have been PPLT ! */
-
- if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_PPLT)
- MNG_ERROR (pData, MNG_NOCORRCHUNK)
-
- /* index out of bounds ? */
- if (iEntry >= ((mng_ppltp)pChunk)->iCount)
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address proper entry */
- pEntry = (mng_pplt_entryp)(((mng_ppltp)pChunk)->aEntries) + iEntry;
-
- pEntry->iRed = (mng_uint8)iRed; /* fill the entry */
- pEntry->iGreen = (mng_uint8)iGreen;
- pEntry->iBlue = (mng_uint8)iBlue;
- pEntry->iAlpha = (mng_uint8)iAlpha;
- pEntry->bUsed = MNG_TRUE;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifdef MNG_INCLUDE_JNG
-mng_retcode MNG_DECL mng_putchunk_ijng (mng_handle hHandle)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_IJNG, mng_init_general, mng_free_general, mng_read_ijng, mng_write_ijng, mng_assign_general, 0, 0, sizeof(mng_ijng)};
-#else
- {MNG_UINT_IJNG, mng_init_ijng, mng_free_ijng, mng_read_ijng, mng_write_ijng, mng_assign_ijng, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IJNG, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_IJNG))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_ijng (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_IJNG, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IJNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-mng_retcode MNG_DECL mng_putchunk_drop (mng_handle hHandle,
- mng_uint32 iCount,
- mng_chunkidp pChunknames)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_DROP, mng_init_general, mng_free_drop, mng_read_drop, mng_write_drop, mng_assign_drop, 0, 0, sizeof(mng_drop)};
-#else
- {MNG_UINT_DROP, mng_init_drop, mng_free_drop, mng_read_drop, mng_write_drop, mng_assign_drop, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DROP, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_DROP))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_drop (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_DROP, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_dropp)pChunk)->iCount = iCount;
-
- if (iCount)
- {
- mng_uint32 iSize = iCount * sizeof (mng_chunkid);
-
- MNG_ALLOC (pData, ((mng_dropp)pChunk)->pChunknames, iSize);
- MNG_COPY (((mng_dropp)pChunk)->pChunknames, pChunknames, iSize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DROP, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_DBYK
-mng_retcode MNG_DECL mng_putchunk_dbyk (mng_handle hHandle,
- mng_chunkid iChunkname,
- mng_uint8 iPolarity,
- mng_uint32 iKeywordssize,
- mng_pchar zKeywords)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_DBYK, mng_init_general, mng_free_dbyk, mng_read_dbyk, mng_write_dbyk, mng_assign_dbyk, 0, 0, sizeof(mng_dbyk)};
-#else
- {MNG_UINT_DBYK, mng_init_dbyk, mng_free_dbyk, mng_read_dbyk, mng_write_dbyk, mng_assign_dbyk, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DBYK, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_DBYK))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_dbyk (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_DBYK, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_dbykp)pChunk)->iChunkname = iChunkname;
- ((mng_dbykp)pChunk)->iPolarity = iPolarity;
- ((mng_dbykp)pChunk)->iKeywordssize = iKeywordssize;
-
- if (iKeywordssize)
- {
- MNG_ALLOC (pData, ((mng_dbykp)pChunk)->zKeywords, iKeywordssize + 1);
- MNG_COPY (((mng_dbykp)pChunk)->zKeywords, zKeywords, iKeywordssize);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DBYK, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_ORDR
-mng_retcode MNG_DECL mng_putchunk_ordr (mng_handle hHandle,
- mng_uint32 iCount)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_ORDR, mng_init_general, mng_free_ordr, mng_read_ordr, mng_write_ordr, mng_assign_ordr, 0, 0, sizeof(mng_ordr)};
-#else
- {MNG_UINT_ORDR, mng_init_ordr, mng_free_ordr, mng_read_ordr, mng_write_ordr, mng_assign_ordr, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_ORDR))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_ordr (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_ORDR, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_ordrp)pChunk)->iCount = iCount;
-
- if (iCount)
- MNG_ALLOC (pData, ((mng_ordrp)pChunk)->pEntries, iCount * sizeof (mng_ordr_entry));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_NO_DELTA_PNG
-#ifndef MNG_SKIPCHUNK_ORDR
-mng_retcode MNG_DECL mng_putchunk_ordr_entry (mng_handle hHandle,
- mng_uint32 iEntry,
- mng_chunkid iChunkname,
- mng_uint8 iOrdertype)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_ordr_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
-
- pChunk = pData->pLastchunk; /* last one must have been ORDR ! */
-
- if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_ORDR)
- MNG_ERROR (pData, MNG_NOCORRCHUNK)
- /* index out of bounds ? */
- if (iEntry >= ((mng_ordrp)pChunk)->iCount)
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address proper entry */
- pEntry = ((mng_ordrp)pChunk)->pEntries + iEntry;
-
- pEntry->iChunkname = iChunkname; /* fill the entry */
- pEntry->iOrdertype = iOrdertype;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_MAGN
-mng_retcode MNG_DECL mng_putchunk_magn (mng_handle hHandle,
- mng_uint16 iFirstid,
- mng_uint16 iLastid,
- mng_uint16 iMethodX,
- mng_uint16 iMX,
- mng_uint16 iMY,
- mng_uint16 iML,
- mng_uint16 iMR,
- mng_uint16 iMT,
- mng_uint16 iMB,
- mng_uint16 iMethodY)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_MAGN, mng_init_general, mng_free_general, mng_read_magn, mng_write_magn, mng_assign_general, 0, 0, sizeof(mng_magn)};
-#else
- {MNG_UINT_MAGN, mng_init_magn, mng_free_magn, mng_read_magn, mng_write_magn, mng_assign_magn, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MAGN, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_MAGN))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_magn (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_MAGN, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_magnp)pChunk)->iFirstid = iFirstid;
- ((mng_magnp)pChunk)->iLastid = iLastid;
- ((mng_magnp)pChunk)->iMethodX = (mng_uint8)iMethodX;
- ((mng_magnp)pChunk)->iMX = iMX;
- ((mng_magnp)pChunk)->iMY = iMY;
- ((mng_magnp)pChunk)->iML = iML;
- ((mng_magnp)pChunk)->iMR = iMR;
- ((mng_magnp)pChunk)->iMT = iMT;
- ((mng_magnp)pChunk)->iMB = iMB;
- ((mng_magnp)pChunk)->iMethodY = (mng_uint8)iMethodY;
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MAGN, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
-MNG_EXT mng_retcode MNG_DECL mng_putchunk_mpng (mng_handle hHandle,
- mng_uint32 iFramewidth,
- mng_uint32 iFrameheight,
- mng_uint16 iNumplays,
- mng_uint16 iTickspersec,
- mng_uint8 iCompressionmethod,
- mng_uint32 iCount)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_mpNG, mng_init_general, mng_free_mpng, mng_read_mpng, mng_write_mpng, mng_assign_mpng, 0, 0, sizeof(mng_mpng)};
-#else
- {MNG_UINT_mpNG, mng_init_mpng, mng_free_mpng, mng_read_mpng, mng_write_mpng, mng_assign_mpng, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a IHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_IHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_mpng (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_mpNG, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_mpngp)pChunk)->iFramewidth = iFramewidth;
- ((mng_mpngp)pChunk)->iFrameheight = iFrameheight;
- ((mng_mpngp)pChunk)->iNumplays = iNumplays;
- ((mng_mpngp)pChunk)->iTickspersec = iTickspersec;
- ((mng_mpngp)pChunk)->iCompressionmethod = iCompressionmethod;
- ((mng_mpngp)pChunk)->iFramessize = iCount * sizeof (mng_mpng_frame);
-
- if (iCount)
- MNG_ALLOC (pData, ((mng_mpngp)pChunk)->pFrames, ((mng_mpngp)pChunk)->iFramessize);
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_MPNG_PROPOSAL
-MNG_EXT mng_retcode MNG_DECL mng_putchunk_mpng_frame (mng_handle hHandle,
- mng_uint32 iEntry,
- mng_uint32 iX,
- mng_uint32 iY,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_int32 iXoffset,
- mng_int32 iYoffset,
- mng_uint16 iTicks)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_mpng_framep pFrame;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG_FRAME, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a IHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_IHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
-
- pChunk = pData->pLastchunk; /* last one must have been mpNG ! */
-
- if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_mpNG)
- MNG_ERROR (pData, MNG_NOCORRCHUNK)
- /* index out of bounds ? */
- if (iEntry >= (((mng_mpngp)pChunk)->iFramessize / sizeof (mng_mpng_frame)))
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address proper entry */
- pFrame = ((mng_mpngp)pChunk)->pFrames + iEntry;
- /* fill entry */
- pFrame->iX = iX;
- pFrame->iY = iY;
- pFrame->iWidth = iWidth;
- pFrame->iHeight = iHeight;
- pFrame->iXoffset = iXoffset;
- pFrame->iYoffset = iYoffset;
- pFrame->iTicks = iTicks;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG_FRAME, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-#ifndef MNG_SKIPCHUNK_evNT
-mng_retcode MNG_DECL mng_putchunk_evnt (mng_handle hHandle,
- mng_uint32 iCount)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_evNT, mng_init_general, mng_free_evnt, mng_read_evnt, mng_write_evnt, mng_assign_evnt, 0, 0, sizeof(mng_evnt)};
-#else
- {MNG_UINT_evNT, mng_init_evnt, mng_free_evnt, mng_read_evnt, mng_write_evnt, mng_assign_evnt, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, MNG_UINT_evNT))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_evnt (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_evNT, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_evntp)pChunk)->iCount = iCount;
-
- if (iCount)
- MNG_ALLOC (pData, ((mng_evntp)pChunk)->pEntries, iCount * sizeof (mng_evnt_entry));
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_evnt_entry (mng_handle hHandle,
- mng_uint32 iEntry,
- 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)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_evnt_entryp pEntry;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT_ENTRY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a MHDR first! */
- if (pData->iFirstchunkadded != MNG_UINT_MHDR)
- MNG_ERROR (pData, MNG_NOHEADER)
-
- pChunk = pData->pLastchunk; /* last one must have been evNT ! */
-
- if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_evNT)
- MNG_ERROR (pData, MNG_NOCORRCHUNK)
- /* index out of bounds ? */
- if (iEntry >= ((mng_evntp)pChunk)->iCount)
- MNG_ERROR (pData, MNG_INVALIDENTRYIX)
- /* address proper entry */
- pEntry = ((mng_evntp)pChunk)->pEntries + iEntry;
- /* fill entry */
- pEntry->iEventtype = iEventtype;
- pEntry->iMasktype = iMasktype;
- pEntry->iLeft = iLeft;
- pEntry->iRight = iRight;
- pEntry->iTop = iTop;
- pEntry->iBottom = iBottom;
- pEntry->iObjectid = iObjectid;
- pEntry->iIndex = iIndex;
- pEntry->iSegmentnamesize = iSegmentnamesize;
-
- if (iSegmentnamesize)
- {
- MNG_ALLOC (pData, pEntry->zSegmentname, iSegmentnamesize + 1);
- MNG_COPY (pEntry->zSegmentname, zSegmentname, iSegmentnamesize);
- }
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT_ENTRY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-#endif
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putchunk_unknown (mng_handle hHandle,
- mng_chunkid iChunkname,
- mng_uint32 iRawlen,
- mng_ptr pRawdata)
-{
- mng_datap pData;
- mng_chunkp pChunk;
- mng_retcode iRetcode;
-#ifndef MNG_OPTIMIZE_CHUNKREADER
- mng_chunk_header sChunkheader =
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- {MNG_UINT_HUH, mng_init_general, mng_free_unknown, mng_read_unknown, mng_write_unknown, mng_assign_unknown, 0, 0, sizeof(mng_unknown_chunk)};
-#else
- {MNG_UINT_HUH, mng_init_unknown, mng_free_unknown, mng_read_unknown, mng_write_unknown, mng_assign_unknown, 0, 0};
-#endif
-#else
- mng_chunk_header sChunkheader;
-#endif
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_UNKNOWN, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must have had a header first! */
- if (pData->iFirstchunkadded == 0)
- MNG_ERROR (pData, MNG_NOHEADER)
- /* prevent misplaced TERM ! */
- if (!check_term (pData, iChunkname))
- MNG_ERROR (pData, MNG_TERMSEQERROR)
- /* create the chunk */
-#ifndef MNG_OPTIMIZE_CHUNKREADER
-#ifdef MNG_OPTIMIZE_CHUNKINITFREE
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#else
- iRetcode = mng_init_unknown (pData, &sChunkheader, &pChunk);
-#endif
-#else
- mng_get_chunkheader(MNG_UINT_HUH, &sChunkheader);
- iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
-#endif
-
- if (iRetcode) /* on error bail out */
- return iRetcode;
- /* fill the chunk */
- ((mng_unknown_chunkp)pChunk)->sHeader.iChunkname = iChunkname;
- ((mng_unknown_chunkp)pChunk)->iDatasize = iRawlen;
-
- if (iRawlen)
- {
- MNG_ALLOC (pData, ((mng_unknown_chunkp)pChunk)->pData, iRawlen);
- MNG_COPY (((mng_unknown_chunkp)pChunk)->pData, pRawdata, iRawlen);
- }
-
- mng_add_chunk (pData, pChunk); /* add it to the list */
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_UNKNOWN, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#endif /* MNG_INCLUDE_WRITE_PROCS */
-
-/* ************************************************************************** */
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getimgdata_seq (mng_handle hHandle,
- mng_uint32 iSeqnr,
- mng_uint32 iCanvasstyle,
- mng_getcanvasline fGetcanvasline)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_SEQ, MNG_LC_START);
-#endif
-
-
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_SEQ, MNG_LC_END);
-#endif
-
- return MNG_FNNOTIMPLEMENTED;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getimgdata_chunkseq (mng_handle hHandle,
- mng_uint32 iSeqnr,
- mng_uint32 iCanvasstyle,
- mng_getcanvasline fGetcanvasline)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNKSEQ, MNG_LC_START);
-#endif
-
-
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNKSEQ, MNG_LC_END);
-#endif
-
- return MNG_FNNOTIMPLEMENTED;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_getimgdata_chunk (mng_handle hHandle,
- mng_handle hChunk,
- mng_uint32 iCanvasstyle,
- mng_getcanvasline fGetcanvasline)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNK, MNG_LC_START);
-#endif
-
-
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNK, MNG_LC_END);
-#endif
-
- return MNG_FNNOTIMPLEMENTED;
-}
-
-/* ************************************************************************** */
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_WRITE_PROCS
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_putimgdata_ihdr (mng_handle hHandle,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_uint8 iColortype,
- mng_uint8 iBitdepth,
- mng_uint8 iCompression,
- mng_uint8 iFilter,
- mng_uint8 iInterlace,
- mng_uint32 iCanvasstyle,
- mng_getcanvasline fGetcanvasline)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_IHDR, MNG_LC_START);
-#endif
-
-
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_IHDR, MNG_LC_END);
-#endif
-
- return MNG_FNNOTIMPLEMENTED;
-}
-
-/* ************************************************************************** */
-
-#ifdef MNG_INCLUDE_JNG
-mng_retcode MNG_DECL mng_putimgdata_jhdr (mng_handle hHandle,
- mng_uint32 iWidth,
- mng_uint32 iHeight,
- mng_uint8 iColortype,
- mng_uint8 iBitdepth,
- mng_uint8 iCompression,
- mng_uint8 iInterlace,
- mng_uint8 iAlphaBitdepth,
- mng_uint8 iAlphaCompression,
- mng_uint8 iAlphaFilter,
- mng_uint8 iAlphaInterlace,
- mng_uint32 iCanvasstyle,
- mng_getcanvasline fGetcanvasline)
-{
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_JHDR, MNG_LC_START);
-#endif
-
-
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_JHDR, MNG_LC_END);
-#endif
-
- return MNG_FNNOTIMPLEMENTED;
-}
-#endif
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_updatemngheader (mng_handle hHandle,
- mng_uint32 iFramecount,
- mng_uint32 iLayercount,
- mng_uint32 iPlaytime)
-{
- mng_datap pData;
- mng_chunkp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGHEADER, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must be a MNG animation! */
- if ((pData->eImagetype != mng_it_mng) || (pData->iFirstchunkadded != MNG_UINT_MHDR))
- MNG_ERROR (pData, MNG_NOMHDR)
-
- pChunk = pData->pFirstchunk; /* get the first chunk */
- /* and update the variables */
- ((mng_mhdrp)pChunk)->iFramecount = iFramecount;
- ((mng_mhdrp)pChunk)->iLayercount = iLayercount;
- ((mng_mhdrp)pChunk)->iPlaytime = iPlaytime;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGHEADER, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-mng_retcode MNG_DECL mng_updatemngsimplicity (mng_handle hHandle,
- mng_uint32 iSimplicity)
-{
- mng_datap pData;
- mng_chunkp pChunk;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGSIMPLICITY, MNG_LC_START);
-#endif
-
- MNG_VALIDHANDLE (hHandle) /* check validity handle */
- pData = (mng_datap)hHandle; /* and make it addressable */
-
- if (!pData->bCreating) /* aren't we creating a new file ? */
- MNG_ERROR (pData, MNG_FUNCTIONINVALID)
- /* must be a MNG animation! */
- if ((pData->eImagetype != mng_it_mng) || (pData->iFirstchunkadded != MNG_UINT_MHDR))
- MNG_ERROR (pData, MNG_NOMHDR)
-
- pChunk = pData->pFirstchunk; /* get the first chunk */
- /* and update the variable */
- ((mng_mhdrp)pChunk)->iSimplicity = iSimplicity;
-
-#ifdef MNG_SUPPORT_TRACE
- MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGSIMPLICITY, MNG_LC_END);
-#endif
-
- return MNG_NOERROR;
-}
-
-/* ************************************************************************** */
-
-#endif /* MNG_INCLUDE_WRITE_PROCS */
-
-/* ************************************************************************** */
-
-#endif /* MNG_ACCESS_CHUNKS */
-
-/* ************************************************************************** */
-/* * end of file * */
-/* ************************************************************************** */
-
-
-
|