| /* ************************************************************************** */ |
| /* * 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 * */ |
| /* ************************************************************************** */ |
| |
| |
| |