TDE
/
tqt3
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tqt3
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '250e6baa4c'
${ noResults }
tqt3/src/3rdparty/libmng/libmng_chunk_xs.c

5120 lines
186 KiB
Raw Blame History

/* ************************************************************************** */
/* * For conditions of distribution and use, * */
/* * see copyright notice in libmng.h * */
/* ************************************************************************** */
/* * * */
/* * project : libmng * */
/* * file : libmng_chunk_xs.c copyright (c) 2000 G. Juyn * */
/* * version : 1.0.0 * */
/* * * */
/* * purpose : chunk access functions (implementation) * */
/* * * */
/* * author : G.Juyn * */
/* * web : http://www.3-t.com * */
/* * email : mailto:info@3-t.com * */
/* * * */
/* * 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 - 1/25/2001 - G.Juyn * */
/* * - fixed some small compiler warnings (thanks Nikki) * */
/* * * */
/* ************************************************************************** */
#include "libmng.h"
#include "libmng_data.h"
#include "libmng_error.h"
#include "libmng_trace.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "libmng_memory.h"
#include "libmng_chunks.h"
#include "libmng_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;
}
/* ************************************************************************** */
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;
#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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_JNG
/* B004 */
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;
}
/* B004 */
#endif /* MNG_INCLUDE_JNG */
/* B004 */
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_JNG
/* B004 */
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;
}
/* B004 */
#endif /* MNG_INCLUDE_JNG */
/* B004 */
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
mng_retcode MNG_DECL mng_getchunk_pplt (mng_handle hHandle,
mng_handle hChunk,
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 */
*iCount = pChunk->iCount; /* fill the field */
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT, MNG_LC_END)
#endif
return MNG_NOERROR;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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 = pChunk->iMethodX;
*iMX = pChunk->iMX;
*iMY = pChunk->iMY;
*iML = pChunk->iML;
*iMR = pChunk->iMR;
*iMT = pChunk->iMT;
*iMB = pChunk->iMB;
*iMethodY = pChunk->iMethodY;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MAGN, MNG_LC_END)
#endif
return MNG_NOERROR;
}
/* ************************************************************************** */
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.fCreate != init_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;
}
/* ************************************************************************** */
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_WRITE_PROCS
/* B004 */
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_IHDR, init_ihdr, free_ihdr, read_ihdr, write_ihdr, 0, 0};
#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)
/* create the chunk */
iRetcode = init_ihdr (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
/* fill the chunk */
((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;
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;
mng_chunk_header sChunkheader =
{MNG_UINT_PLTE, init_plte, free_plte, read_plte, write_plte, 0, 0};
#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)
/* create the chunk */
iRetcode = init_plte (pData, &sChunkheader, &pChunk);
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))
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;
mng_chunk_header sChunkheader =
{MNG_UINT_IDAT, init_idat, free_idat, read_idat, write_idat, 0, 0};
#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)
/* create the chunk */
iRetcode = init_idat (pData, &sChunkheader, &pChunk);
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)
}
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;
mng_chunk_header sChunkheader =
{MNG_UINT_IEND, init_iend, free_iend, read_iend, write_iend, 0, 0};
#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)
/* create the chunk */
iRetcode = init_iend (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
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;
mng_chunk_header sChunkheader =
{MNG_UINT_tRNS, init_trns, free_trns, read_trns, write_trns, 0, 0};
#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)
/* create the chunk */
iRetcode = init_trns (pData, &sChunkheader, &pChunk);
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))
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_gAMA, init_gama, free_gama, read_gama, write_gama, 0, 0};
#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)
/* create the chunk */
iRetcode = init_gama (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
/* fill the chunk */
((mng_gamap)pChunk)->bEmpty = bEmpty;
((mng_gamap)pChunk)->iGamma = iGamma;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_cHRM, init_chrm, free_chrm, read_chrm, write_chrm, 0, 0};
#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)
/* create the chunk */
iRetcode = init_chrm (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_sRGB, init_srgb, free_srgb, read_srgb, write_srgb, 0, 0};
#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)
/* create the chunk */
iRetcode = init_srgb (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
/* fill the chunk */
((mng_srgbp)pChunk)->bEmpty = bEmpty;
((mng_srgbp)pChunk)->iRenderingintent = iRenderingintent;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_iCCP, init_iccp, free_iccp, read_iccp, write_iccp, 0, 0};
#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)
/* create the chunk */
iRetcode = init_iccp (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_tEXt, init_text, free_text, read_text, write_text, 0, 0};
#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)
/* create the chunk */
iRetcode = init_text (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_zTXt, init_ztxt, free_ztxt, read_ztxt, write_ztxt, 0, 0};
#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)
/* create the chunk */
iRetcode = init_ztxt (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_iTXt, init_itxt, free_itxt, read_itxt, write_itxt, 0, 0};
#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)
/* create the chunk */
iRetcode = init_itxt (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_bKGD, init_bkgd, free_bkgd, read_bkgd, write_bkgd, 0, 0};
#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)
/* create the chunk */
iRetcode = init_bkgd (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_pHYs, init_phys, free_phys, read_phys, write_phys, 0, 0};
#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)
/* create the chunk */
iRetcode = init_phys (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_sBIT, init_sbit, free_sbit, read_sbit, write_sbit, 0, 0};
#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)
/* create the chunk */
iRetcode = init_sbit (pData, &sChunkheader, &pChunk);
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];
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_sPLT, init_splt, free_splt, read_splt, write_splt, 0, 0};
#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)
/* create the chunk */
iRetcode = init_splt (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_hIST, init_hist, free_hist, read_hist, write_hist, 0, 0};
#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)
/* create the chunk */
iRetcode = init_hist (pData, &sChunkheader, &pChunk);
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))
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_tIME, init_time, free_time, read_time, write_time, 0, 0};
#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)
/* must have had a header first! */
if (pData->iFirstchunkadded == 0)
MNG_ERROR (pData, MNG_NOHEADER)
/* create the chunk */
iRetcode = init_time (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_MHDR, init_mhdr, free_mhdr, read_mhdr, write_mhdr, 0, 0};
#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)
/* create the chunk */
iRetcode = init_mhdr (pData, &sChunkheader, &pChunk);
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;
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;
mng_chunk_header sChunkheader =
{MNG_UINT_MEND, init_mend, free_mend, read_mend, write_mend, 0, 0};
#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)
/* create the chunk */
iRetcode = init_mend (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_LOOP, init_loop, free_loop, read_loop, write_loop, 0, 0};
#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)
/* create the chunk */
iRetcode = init_loop (pData, &sChunkheader, &pChunk);
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;
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;
mng_chunk_header sChunkheader =
{MNG_UINT_ENDL, init_endl, free_endl, read_endl, write_endl, 0, 0};
#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)
/* create the chunk */
iRetcode = init_endl (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
/* fill the chunk */
((mng_endlp)pChunk)->iLevel = iLevel;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_DEFI, init_defi, free_defi, read_defi, write_defi, 0, 0};
#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)
/* create the chunk */
iRetcode = init_defi (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_BASI, init_basi, free_basi, read_basi, write_basi, 0, 0};
#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)
/* create the chunk */
iRetcode = init_basi (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_CLON, init_clon, free_clon, read_clon, write_clon, 0, 0};
#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)
/* create the chunk */
iRetcode = init_clon (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_PAST, init_past, free_past, read_past, write_past, 0, 0};
#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)
/* create the chunk */
iRetcode = init_past (pData, &sChunkheader, &pChunk);
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))
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_DISC, init_disc, free_disc, read_disc, write_disc, 0, 0};
#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)
/* create the chunk */
iRetcode = init_disc (pData, &sChunkheader, &pChunk);
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);
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_BACK, init_back, free_back, read_back, write_back, 0, 0};
#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)
/* create the chunk */
iRetcode = init_back (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_FRAM, init_fram, free_fram, read_fram, write_fram, 0, 0};
#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)
/* create the chunk */
iRetcode = init_fram (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_MOVE, init_move, free_move, read_move, write_move, 0, 0};
#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)
/* create the chunk */
iRetcode = init_move (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_CLIP, init_clip, free_clip, read_clip, write_clip, 0, 0};
#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)
/* create the chunk */
iRetcode = init_clip (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_SHOW, init_show, free_show, read_show, write_show, 0, 0};
#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)
/* create the chunk */
iRetcode = init_show (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_TERM, init_term, free_term, read_term, write_term, 0, 0};
#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 */
iRetcode = init_term (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_SAVE, init_save, free_save, read_save, write_save, 0, 0};
#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)
/* create the chunk */
iRetcode = init_save (pData, &sChunkheader, &pChunk);
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))
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_SEEK, init_seek, free_seek, read_seek, write_seek, 0, 0};
#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)
/* create the chunk */
iRetcode = init_seek (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_eXPI, init_expi, free_expi, read_expi, write_expi, 0, 0};
#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)
/* create the chunk */
iRetcode = init_expi (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_fPRI, init_fpri, free_fpri, read_fpri, write_fpri, 0, 0};
#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)
/* create the chunk */
iRetcode = init_fpri (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
/* fill the chunk */
((mng_fprip)pChunk)->iDeltatype = iDeltatype;
((mng_fprip)pChunk)->iPriority = iPriority;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_nEED, init_need, free_need, read_need, write_need, 0, 0};
#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)
/* create the chunk */
iRetcode = init_need (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_pHYg, init_phyg, free_phyg, read_phyg, write_phyg, 0, 0};
#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)
/* create the chunk */
iRetcode = init_phyg (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_JNG
/* B004 */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_JHDR, init_jhdr, free_jhdr, read_jhdr, write_jhdr, 0, 0};
#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)
/* create the chunk */
iRetcode = init_jhdr (pData, &sChunkheader, &pChunk);
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;
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;
}
/* B004 */
#endif /* MNG_INCLUDE_JNG */
/* B004 */
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_JNG
/* B004 */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_JDAT, init_jdat, free_jdat, read_jdat, write_jdat, 0, 0};
#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)
/* create the chunk */
iRetcode = init_jdat (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* B004 */
#endif /* MNG_INCLUDE_JNG */
/* B004 */
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_JNG
/* B004 */
mng_retcode MNG_DECL mng_putchunk_jsep (mng_handle hHandle)
{
mng_datap pData;
mng_chunkp pChunk;
mng_retcode iRetcode;
mng_chunk_header sChunkheader =
{MNG_UINT_JSEP, init_jsep, free_jsep, read_jsep, write_jsep, 0, 0};
#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)
/* create the chunk */
iRetcode = init_jsep (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
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;
}
/* B004 */
#endif /* MNG_INCLUDE_JNG */
/* B004 */
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_DHDR, init_dhdr, free_dhdr, read_dhdr, write_dhdr, 0, 0};
#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)
/* create the chunk */
iRetcode = init_dhdr (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_PROM, init_prom, free_prom, read_prom, write_prom, 0, 0};
#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)
/* create the chunk */
iRetcode = init_prom (pData, &sChunkheader, &pChunk);
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;
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;
}
/* ************************************************************************** */
mng_retcode MNG_DECL mng_putchunk_ipng (mng_handle hHandle)
{
mng_datap pData;
mng_chunkp pChunk;
mng_retcode iRetcode;
mng_chunk_header sChunkheader =
{MNG_UINT_IPNG, init_ipng, free_ipng, read_ipng, write_ipng, 0, 0};
#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)
/* create the chunk */
iRetcode = init_ipng (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
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;
}
/* ************************************************************************** */
mng_retcode MNG_DECL mng_putchunk_pplt (mng_handle hHandle,
mng_uint32 iCount)
{
mng_datap pData;
mng_chunkp pChunk;
mng_retcode iRetcode;
mng_chunk_header sChunkheader =
{MNG_UINT_PPLT, init_pplt, free_pplt, read_pplt, write_pplt, 0, 0};
#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)
/* create the chunk */
iRetcode = init_pplt (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
/* fill the chunk */
((mng_ppltp)pChunk)->iCount = iCount;
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;
}
/* ************************************************************************** */
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_bool bUsed)
{
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 = bUsed;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT_ENTRY, MNG_LC_END)
#endif
return MNG_NOERROR;
}
/* ************************************************************************** */
mng_retcode MNG_DECL mng_putchunk_ijng (mng_handle hHandle)
{
mng_datap pData;
mng_chunkp pChunk;
mng_retcode iRetcode;
mng_chunk_header sChunkheader =
{MNG_UINT_IJNG, init_ijng, free_ijng, read_ijng, write_ijng, 0, 0};
#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)
/* create the chunk */
iRetcode = init_ijng (pData, &sChunkheader, &pChunk);
if (iRetcode) /* on error bail out */
return iRetcode;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_DROP, init_drop, free_drop, read_drop, write_drop, 0, 0};
#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)
/* create the chunk */
iRetcode = init_drop (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_DBYK, init_dbyk, free_dbyk, read_dbyk, write_dbyk, 0, 0};
#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)
/* create the chunk */
iRetcode = init_dbyk (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
mng_retcode MNG_DECL mng_putchunk_ordr (mng_handle hHandle,
mng_uint32 iCount)
{
mng_datap pData;
mng_chunkp pChunk;
mng_retcode iRetcode;
mng_chunk_header sChunkheader =
{MNG_UINT_ORDR, init_ordr, free_ordr, read_ordr, write_ordr, 0, 0};
#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)
/* create the chunk */
iRetcode = init_ordr (pData, &sChunkheader, &pChunk);
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))
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;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_MAGN, init_magn, free_magn, read_magn, write_magn, 0, 0};
#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)
/* create the chunk */
iRetcode = init_magn (pData, &sChunkheader, &pChunk);
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 = 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 = iMethodY;
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;
}
/* ************************************************************************** */
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;
mng_chunk_header sChunkheader =
{MNG_UINT_HUH, init_unknown, free_unknown, read_unknown, write_unknown, 0, 0};
#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)
/* create the chunk */
iRetcode = init_unknown (pData, &sChunkheader, &pChunk);
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)
}
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;
}
/* ************************************************************************** */
/* B004 */
#endif /* MNG_INCLUDE_WRITE_PROCS */
/* B004 */
/* ************************************************************************** */
/* ************************************************************************** */
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_NOERROR;
}
/* ************************************************************************** */
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_NOERROR;
}
/* ************************************************************************** */
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_NOERROR;
}
/* ************************************************************************** */
/* ************************************************************************** */
/* B004 */
#ifdef MNG_INCLUDE_WRITE_PROCS
/* B004 */
/* ************************************************************************** */
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_NOERROR;
}
/* ************************************************************************** */
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_NOERROR;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
/* B004 */
#endif /* MNG_INCLUDE_WRITE_PROCS */
/* B004 */
/* ************************************************************************** */
#endif /* MNG_ACCESS_CHUNKS */
/* ************************************************************************** */
/* * end of file * */
/* ************************************************************************** */
View Git Blame Copy Permalink