#include "config.h"
/* ************************************************************************** */
/* *             For conditions of distribution and use,                    * */
/* *                see copyright notice in libmng.h                        * */
/* ************************************************************************** */
/* *                                                                        * */
/* * project   : libmng                                                     * */
/* * file      : libmng_chunk_xs.c         copyright (c) 2000-2007 G.Juyn   * */
/* * version   : 1.0.10                                                     * */
/* *                                                                        * */
/* * purpose   : chunk access functions (implementation)                    * */
/* *                                                                        * */
/* * author    : G.Juyn                                                     * */
/* *                                                                        * */
/* * comment   : implementation of the chunk access functions               * */
/* *                                                                        * */
/* * changes   : 0.5.1 - 05/06/2000 - G.Juyn                                * */
/* *             - changed and filled iterate-chunk function                * */
/* *             0.5.1 - 05/08/2000 - G.Juyn                                * */
/* *             - fixed calling convention                                 * */
/* *             - added getchunk functions                                 * */
/* *             - added putchunk functions                                 * */
/* *             - changed strict-ANSI stuff                                * */
/* *             0.5.1 - 05/11/2000 - G.Juyn                                * */
/* *             - added empty-chunk put-routines                           * */
/* *             0.5.1 - 05/12/2000 - G.Juyn                                * */
/* *             - changed trace to macro for callback error-reporting      * */
/* *             0.5.1 - 05/15/2000 - G.Juyn                                * */
/* *             - added getimgdata & putimgdata functions                  * */
/* *                                                                        * */
/* *             0.5.2 - 05/19/2000 - G.Juyn                                * */
/* *             - B004 - fixed problem with MNG_SUPPORT_WRITE not defined  * */
/* *               also for MNG_SUPPORT_WRITE without MNG_INCLUDE_JNG       * */
/* *             - Cleaned up some code regarding mixed support             * */
/* *                                                                        * */
/* *             0.9.1 - 07/19/2000 - G.Juyn                                * */
/* *             - fixed creation-code                                      * */
/* *                                                                        * */
/* *             0.9.2 - 08/05/2000 - G.Juyn                                * */
/* *             - changed file-prefixes                                    * */
/* *             - added function to set simplicity field                   * */
/* *             - fixed putchunk_unknown() function                        * */
/* *                                                                        * */
/* *             0.9.3 - 08/07/2000 - G.Juyn                                * */
/* *             - B111300 - fixup for improved portability                 * */
/* *             0.9.3 - 08/26/2000 - G.Juyn                                * */
/* *             - added MAGN chunk                                         * */
/* *             0.9.3 - 10/20/2000 - G.Juyn                                * */
/* *             - fixed putchunk_plte() to set bEmpty parameter            * */
/* *                                                                        * */
/* *             0.9.5 - 01/25/2001 - G.Juyn                                * */
/* *             - fixed some small compiler warnings (thanks Nikki)        * */
/* *                                                                        * */
/* *             1.0.5 - 09/07/2002 - G.Juyn                                * */
/* *             - B578940 - unimplemented functions return errorcode       * */
/* *             1.0.5 - 08/19/2002 - G.Juyn                                * */
/* *             - B597134 - libmng pollutes the linker namespace           * */
/* *             - added HLAPI function to copy chunks                      * */
/* *             1.0.5 - 09/14/2002 - G.Juyn                                * */
/* *             - added event handling for dynamic MNG                     * */
/* *             1.0.5 - 10/07/2002 - G.Juyn                                * */
/* *             - added check for TERM placement during create/write       * */
/* *             1.0.5 - 11/28/2002 - G.Juyn                                * */
/* *             - fixed definition of iMethodX/Y for MAGN chunk            * */
/* *                                                                        * */
/* *             1.0.6 - 05/25/2003 - G.R-P                                 * */
/* *             - added MNG_SKIPCHUNK_cHNK footprint optimizations         * */
/* *             1.0.6 - 07/07/2003 - G.R-P                                 * */
/* *             - added MNG_NO_DELTA_PNG reduction and more SKIPCHUNK      * */
/* *               optimizations                                            * */
/* *             1.0.6 - 07/29/2003 - G.R-P                                 * */
/* *             - added conditionals around PAST chunk support             * */
/* *             1.0.6 - 08/17/2003 - G.R-P                                 * */
/* *             - added conditionals around non-VLC chunk support          * */
/* *                                                                        * */
/* *             1.0.8 - 04/01/2004 - G.Juyn                                * */
/* *             - added missing get-/put-chunk-jdaa                        * */
/* *             1.0.8 - 08/02/2004 - G.Juyn                                * */
/* *             - added conditional to allow easier writing of large MNG's * */
/* *                                                                        * */
/* *             1.0.9 - 09/17/2004 - G.R-P                                 * */
/* *             - added two more conditionals                              * */
/* *             1.0.9 - 09/25/2004 - G.Juyn                                * */
/* *             - replaced MNG_TWEAK_LARGE_FILES with permanent solution   * */
/* *             1.0.9 - 17/14/2004 - G.Juyn                                * */
/* *             - fixed PPLT getchunk/putchunk routines                    * */
/* *             1.0.9 - 12/05/2004 - G.Juyn                                * */
/* *             - added conditional MNG_OPTIMIZE_CHUNKINITFREE             * */
/* *             1.0.9 - 12/20/2004 - G.Juyn                                * */
/* *             - cleaned up macro-invocations (thanks to D. Airlie)       * */
/* *                                                                        * */
/* *             1.0.10 - 04/08/2007 - G.Juyn                               * */
/* *             - added support for mPNG proposal                          * */
/* *                                                                        * */
/* ************************************************************************** */

#include "libmng.h"
#include "libmng_data.h"
#include "libmng_error.h"
#include "libmng_trace.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "libmng_memory.h"
#include "libmng_chunks.h"
#ifdef MNG_OPTIMIZE_CHUNKREADER
#include "libmng_chunk_descr.h"
#endif
#include "libmng_chunk_prc.h"
#include "libmng_chunk_io.h"

#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
#pragma option -A                      /* force ANSI-C */
#endif

/* ************************************************************************** */

#ifdef MNG_ACCESS_CHUNKS

/* ************************************************************************** */

mng_retcode MNG_DECL mng_iterate_chunks (mng_handle       hHandle,
                                         mng_uint32       iChunkseq,
                                         mng_iteratechunk fProc)
{
  mng_uint32  iSeq;
  mng_chunkid iChunkname;
  mng_datap   pData;
  mng_chunkp  pChunk;
  mng_bool    bCont;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_ITERATE_CHUNKS, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = ((mng_datap)hHandle);        /* and make it addressable */

  iSeq   = 0;
  bCont  = MNG_TRUE;
  pChunk = pData->pFirstchunk;         /* get the first chunk */
                                       /* as long as there are some more */
  while ((pChunk) && (bCont))          /* and the app didn't signal a stop */
  {
    if (iSeq >= iChunkseq)             /* reached the first target ? */
    {                                  /* then call this and next ones back in... */
      iChunkname = ((mng_chunk_headerp)pChunk)->iChunkname;
      bCont      = fProc (hHandle, (mng_handle)pChunk, iChunkname, iSeq);
    }

    iSeq++;                            /* next one */
    pChunk = ((mng_chunk_headerp)pChunk)->pNext;
  }

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_ITERATE_CHUNKS, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#ifdef MNG_SUPPORT_WRITE
mng_retcode MNG_DECL mng_copy_chunk (mng_handle hHandle,
                                     mng_handle hChunk,
                                     mng_handle hHandleOut)
{
  mng_datap   pDataOut;
  mng_chunkp  pChunk;
  mng_chunkp  pChunkOut;
  mng_retcode iRetcode;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_COPY_CHUNK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handles */
  MNG_VALIDHANDLE (hHandleOut)

  pDataOut = (mng_datap)hHandleOut;    /* make outhandle addressable */
  pChunk   = (mng_chunkp)hChunk;       /* address the chunk */

  if (!pDataOut->bCreating)            /* aren't we creating a new file ? */
    MNG_ERROR (pDataOut, MNG_FUNCTIONINVALID)
                                       /* create a new chunk */
  iRetcode = ((mng_createchunk)((mng_chunk_headerp)pChunk)->fCreate)
                        (pDataOut, ((mng_chunk_headerp)pChunk), &pChunkOut);
  if (!iRetcode)                       /* assign the chunk-specific data */
    iRetcode = ((mng_assignchunk)((mng_chunk_headerp)pChunk)->fAssign)
                          (pDataOut, pChunkOut, pChunk);

  if (iRetcode)                        /* on error bail out */
    return iRetcode; 

  mng_add_chunk (pDataOut, pChunkOut); /* and put it in the output-stream */

                                       /* could it be the end of the chain ? */
  if (((mng_chunk_headerp)pChunkOut)->iChunkname == MNG_UINT_IEND)
  {
#ifdef MNG_INCLUDE_JNG
    if ((pDataOut->iFirstchunkadded == MNG_UINT_IHDR) ||
        (pDataOut->iFirstchunkadded == MNG_UINT_JHDR)    )
#else
    if (pDataOut->iFirstchunkadded == MNG_UINT_IHDR)
#endif
      pDataOut->bCreating = MNG_FALSE; /* right; this should be the last chunk !!! */
  }

  if (((mng_chunk_headerp)pChunkOut)->iChunkname == MNG_UINT_MEND)
    pDataOut->bCreating = MNG_FALSE;   /* definitely this should be the last !!! */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_COPY_CHUNK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif /* MNG_SUPPORT_WRITE */

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_ihdr (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iWidth,
                                        mng_uint32 *iHeight,
                                        mng_uint8  *iBitdepth,
                                        mng_uint8  *iColortype,
                                        mng_uint8  *iCompression,
                                        mng_uint8  *iFilter,
                                        mng_uint8  *iInterlace)
{
  mng_datap pData;
  mng_ihdrp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_ihdrp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_IHDR)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iWidth       = pChunk->iWidth;      /* fill the fields */
  *iHeight      = pChunk->iHeight;
  *iBitdepth    = pChunk->iBitdepth;
  *iColortype   = pChunk->iColortype;
  *iCompression = pChunk->iCompression;
  *iFilter      = pChunk->iFilter;
  *iInterlace   = pChunk->iInterlace;

                                       /* fill the chunk */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_plte (mng_handle   hHandle,
                                        mng_handle   hChunk,
                                        mng_uint32   *iCount,
                                        mng_palette8 *aPalette)
{
  mng_datap pData;
  mng_pltep pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PLTE, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_pltep)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_PLTE)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iCount = pChunk->iEntrycount;       /* fill the fields */

  MNG_COPY (*aPalette, pChunk->aEntries, sizeof (mng_palette8));

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PLTE, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_idat (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iRawlen,
                                        mng_ptr    *pRawdata)
{
  mng_datap pData;
  mng_idatp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IDAT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_idatp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_IDAT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iRawlen  = pChunk->iDatasize;       /* fill the fields */
  *pRawdata = pChunk->pData;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_IDAT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_trns (mng_handle   hHandle,
                                        mng_handle   hChunk,
                                        mng_bool     *bEmpty,
                                        mng_bool     *bGlobal,
                                        mng_uint8    *iType,
                                        mng_uint32   *iCount,
                                        mng_uint8arr *aAlphas,
                                        mng_uint16   *iGray,
                                        mng_uint16   *iRed,
                                        mng_uint16   *iGreen,
                                        mng_uint16   *iBlue,
                                        mng_uint32   *iRawlen,
                                        mng_uint8arr *aRawdata)
{
  mng_datap pData;
  mng_trnsp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TRNS, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_trnsp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_tRNS)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty   = pChunk->bEmpty;          /* fill the fields */
  *bGlobal  = pChunk->bGlobal;
  *iType    = pChunk->iType;
  *iCount   = pChunk->iCount;
  *iGray    = pChunk->iGray;
  *iRed     = pChunk->iRed;
  *iGreen   = pChunk->iGreen;
  *iBlue    = pChunk->iBlue;
  *iRawlen  = pChunk->iRawlen;

  MNG_COPY (*aAlphas,  pChunk->aEntries, sizeof (mng_uint8arr));
  MNG_COPY (*aRawdata, pChunk->aRawdata, sizeof (mng_uint8arr));

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TRNS, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_gAMA
mng_retcode MNG_DECL mng_getchunk_gama (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint32 *iGamma)
{
  mng_datap pData;
  mng_gamap pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_GAMA, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_gamap)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_gAMA)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty = pChunk->bEmpty;            /* fill the fields */
  *iGamma = pChunk->iGamma;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_GAMA, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_cHRM
mng_retcode MNG_DECL mng_getchunk_chrm (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint32 *iWhitepointx,
                                        mng_uint32 *iWhitepointy,
                                        mng_uint32 *iRedx,
                                        mng_uint32 *iRedy,
                                        mng_uint32 *iGreenx,
                                        mng_uint32 *iGreeny,
                                        mng_uint32 *iBluex,
                                        mng_uint32 *iBluey)
{
  mng_datap pData;
  mng_chrmp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CHRM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_chrmp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_cHRM)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty       = pChunk->bEmpty;      /* fill the fields */     
  *iWhitepointx = pChunk->iWhitepointx;
  *iWhitepointy = pChunk->iWhitepointy;
  *iRedx        = pChunk->iRedx;
  *iRedy        = pChunk->iRedy;
  *iGreenx      = pChunk->iGreenx;
  *iGreeny      = pChunk->iGreeny;
  *iBluex       = pChunk->iBluex;
  *iBluey       = pChunk->iBluey;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CHRM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_sRGB
mng_retcode MNG_DECL mng_getchunk_srgb (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint8  *iRenderingintent)
{
  mng_datap pData;
  mng_srgbp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SRGB, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_srgbp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_sRGB)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty           = pChunk->bEmpty;  /* fill the fields */        
  *iRenderingintent = pChunk->iRenderingintent;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SRGB, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_iCCP
mng_retcode MNG_DECL mng_getchunk_iccp (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint32 *iNamesize,
                                        mng_pchar  *zName,
                                        mng_uint8  *iCompression,
                                        mng_uint32 *iProfilesize,
                                        mng_ptr    *pProfile)
{
  mng_datap pData;
  mng_iccpp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ICCP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_iccpp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_iCCP)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty       = pChunk->bEmpty;      /* fill the fields */     
  *iNamesize    = pChunk->iNamesize;
  *zName        = pChunk->zName;
  *iCompression = pChunk->iCompression;
  *iProfilesize = pChunk->iProfilesize;
  *pProfile     = pChunk->pProfile;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ICCP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_tEXt
mng_retcode MNG_DECL mng_getchunk_text (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iKeywordsize,
                                        mng_pchar  *zKeyword,
                                        mng_uint32 *iTextsize,
                                        mng_pchar  *zText)
{
  mng_datap pData;
  mng_textp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TEXT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_textp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_tEXt)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* fill the fields */
  *iKeywordsize = pChunk->iKeywordsize;
  *zKeyword     = pChunk->zKeyword;
  *iTextsize    = pChunk->iTextsize;
  *zText        = pChunk->zText;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TEXT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_zTXt
mng_retcode MNG_DECL mng_getchunk_ztxt (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iKeywordsize,
                                        mng_pchar  *zKeyword,
                                        mng_uint8  *iCompression,
                                        mng_uint32 *iTextsize,
                                        mng_pchar  *zText)
{
  mng_datap pData;
  mng_ztxtp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ZTXT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_ztxtp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_zTXt)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* fill the fields */
  *iKeywordsize = pChunk->iKeywordsize;
  *zKeyword     = pChunk->zKeyword;
  *iCompression = pChunk->iCompression;
  *iTextsize    = pChunk->iTextsize;
  *zText        = pChunk->zText;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ZTXT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_iTXt
mng_retcode MNG_DECL mng_getchunk_itxt (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iKeywordsize,
                                        mng_pchar  *zKeyword,
                                        mng_uint8  *iCompressionflag,
                                        mng_uint8  *iCompressionmethod,
                                        mng_uint32 *iLanguagesize,
                                        mng_pchar  *zLanguage,
                                        mng_uint32 *iTranslationsize,
                                        mng_pchar  *zTranslation,
                                        mng_uint32 *iTextsize,
                                        mng_pchar  *zText)
{
  mng_datap pData;
  mng_itxtp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ITXT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_itxtp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_iTXt)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* fill the fields */
  *iKeywordsize       = pChunk->iKeywordsize;
  *zKeyword           = pChunk->zKeyword;
  *iCompressionflag   = pChunk->iCompressionflag;
  *iCompressionmethod = pChunk->iCompressionmethod;
  *iLanguagesize      = pChunk->iLanguagesize;
  *zLanguage          = pChunk->zLanguage;
  *iTranslationsize   = pChunk->iTranslationsize;
  *zTranslation       = pChunk->zTranslation;
  *iTextsize          = pChunk->iTextsize;
  *zText              = pChunk->zText;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ITXT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_bKGD
mng_retcode MNG_DECL mng_getchunk_bkgd (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint8  *iType,
                                        mng_uint8  *iIndex,
                                        mng_uint16 *iGray,
                                        mng_uint16 *iRed,
                                        mng_uint16 *iGreen,
                                        mng_uint16 *iBlue)
{
  mng_datap pData;
  mng_bkgdp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BKGD, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_bkgdp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_bKGD)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty = pChunk->bEmpty;            /* fill the fields */
  *iType  = pChunk->iType;
  *iIndex = pChunk->iIndex;
  *iGray  = pChunk->iGray;
  *iRed   = pChunk->iRed;
  *iGreen = pChunk->iGreen;
  *iBlue  = pChunk->iBlue;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BKGD, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_pHYs
mng_retcode MNG_DECL mng_getchunk_phys (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint32 *iSizex,
                                        mng_uint32 *iSizey,
                                        mng_uint8  *iUnit)
{
  mng_datap pData;
  mng_physp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYS, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_physp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_pHYs)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty = pChunk->bEmpty;            /* fill the fields */
  *iSizex = pChunk->iSizex;
  *iSizey = pChunk->iSizey;
  *iUnit  = pChunk->iUnit;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYS, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_sBIT
mng_retcode MNG_DECL mng_getchunk_sbit (mng_handle    hHandle,
                                        mng_handle    hChunk,
                                        mng_bool      *bEmpty,
                                        mng_uint8     *iType,
                                        mng_uint8arr4 *aBits)
{
  mng_datap pData;
  mng_sbitp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SBIT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_sbitp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_sBIT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty     = pChunk->bEmpty;
  *iType      = pChunk->iType;
  (*aBits)[0] = pChunk->aBits[0];
  (*aBits)[1] = pChunk->aBits[1];
  (*aBits)[2] = pChunk->aBits[2];
  (*aBits)[3] = pChunk->aBits[3];

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SBIT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_sPLT
mng_retcode MNG_DECL mng_getchunk_splt (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint32 *iNamesize,
                                        mng_pchar  *zName,
                                        mng_uint8  *iSampledepth,
                                        mng_uint32 *iEntrycount,
                                        mng_ptr    *pEntries)
{
  mng_datap pData;
  mng_spltp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SPLT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_spltp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_sPLT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty       = pChunk->bEmpty;      /* fill the fields */      
  *iNamesize    = pChunk->iNamesize;
  *zName        = pChunk->zName;
  *iSampledepth = pChunk->iSampledepth;
  *iEntrycount  = pChunk->iEntrycount;
  *pEntries     = pChunk->pEntries;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SPLT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_hIST
mng_retcode MNG_DECL mng_getchunk_hist (mng_handle    hHandle,
                                        mng_handle    hChunk,
                                        mng_uint32    *iEntrycount,
                                        mng_uint16arr *aEntries)
{
  mng_datap pData;
  mng_histp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_HIST, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_histp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_hIST)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iEntrycount = pChunk->iEntrycount;  /* fill the fields */

  MNG_COPY (*aEntries, pChunk->aEntries, sizeof (mng_uint16arr));

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_HIST, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_tIME
mng_retcode MNG_DECL mng_getchunk_time (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iYear,
                                        mng_uint8  *iMonth,
                                        mng_uint8  *iDay,
                                        mng_uint8  *iHour,
                                        mng_uint8  *iMinute,
                                        mng_uint8  *iSecond)
{
  mng_datap pData;
  mng_timep pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TIME, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_timep)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_tIME)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iYear   = pChunk->iYear;            /* fill the fields */ 
  *iMonth  = pChunk->iMonth;
  *iDay    = pChunk->iDay;
  *iHour   = pChunk->iHour;
  *iMinute = pChunk->iMinute;
  *iSecond = pChunk->iSecond;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TIME, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_mhdr (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iWidth,
                                        mng_uint32 *iHeight,
                                        mng_uint32 *iTicks,
                                        mng_uint32 *iLayercount,
                                        mng_uint32 *iFramecount,
                                        mng_uint32 *iPlaytime,
                                        mng_uint32 *iSimplicity)
{
  mng_datap pData;
  mng_mhdrp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_mhdrp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iWidth      = pChunk->iWidth;       /* fill the fields */   
  *iHeight     = pChunk->iHeight;
  *iTicks      = pChunk->iTicks;
  *iLayercount = pChunk->iLayercount;
  *iFramecount = pChunk->iFramecount;
  *iPlaytime   = pChunk->iPlaytime;
  *iSimplicity = pChunk->iSimplicity;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_LOOP
mng_retcode MNG_DECL mng_getchunk_loop (mng_handle  hHandle,
                                        mng_handle  hChunk,
                                        mng_uint8   *iLevel,
                                        mng_uint32  *iRepeat,
                                        mng_uint8   *iTermination,
                                        mng_uint32  *iItermin,
                                        mng_uint32  *iItermax,
                                        mng_uint32  *iCount,
                                        mng_uint32p *pSignals)
{
  mng_datap pData;
  mng_loopp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_LOOP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_loopp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_LOOP)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iLevel       = pChunk->iLevel;      /* fill teh fields */
  *iRepeat      = pChunk->iRepeat;
  *iTermination = pChunk->iTermination;
  *iItermin     = pChunk->iItermin;
  *iItermax     = pChunk->iItermax;
  *iCount       = pChunk->iCount;
  *pSignals     = pChunk->pSignals;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_LOOP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_endl (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint8  *iLevel)
{
  mng_datap pData;
  mng_endlp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ENDL, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_endlp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_ENDL)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iLevel = pChunk->iLevel;            /* fill the field */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ENDL, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_DEFI
mng_retcode MNG_DECL mng_getchunk_defi (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iObjectid,
                                        mng_uint8  *iDonotshow,
                                        mng_uint8  *iConcrete,
                                        mng_bool   *bHasloca,
                                        mng_int32  *iXlocation,
                                        mng_int32  *iYlocation,
                                        mng_bool   *bHasclip,
                                        mng_int32  *iLeftcb,
                                        mng_int32  *iRightcb,
                                        mng_int32  *iTopcb,
                                        mng_int32  *iBottomcb)
{
  mng_datap pData;
  mng_defip pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DEFI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_defip)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_DEFI)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iObjectid  = pChunk->iObjectid;     /* fill the fields */
  *iDonotshow = pChunk->iDonotshow;
  *iConcrete  = pChunk->iConcrete;
  *bHasloca   = pChunk->bHasloca;
  *iXlocation = pChunk->iXlocation;
  *iYlocation = pChunk->iYlocation;
  *bHasclip   = pChunk->bHasclip;
  *iLeftcb    = pChunk->iLeftcb;
  *iRightcb   = pChunk->iRightcb;
  *iTopcb     = pChunk->iTopcb;
  *iBottomcb  = pChunk->iBottomcb;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DEFI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_BASI
mng_retcode MNG_DECL mng_getchunk_basi (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iWidth,
                                        mng_uint32 *iHeight,
                                        mng_uint8  *iBitdepth,
                                        mng_uint8  *iColortype,
                                        mng_uint8  *iCompression,
                                        mng_uint8  *iFilter,
                                        mng_uint8  *iInterlace,
                                        mng_uint16 *iRed,
                                        mng_uint16 *iGreen,
                                        mng_uint16 *iBlue,
                                        mng_uint16 *iAlpha,
                                        mng_uint8  *iViewable)
{
  mng_datap pData;
  mng_basip pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BASI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_basip)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_BASI)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iWidth       = pChunk->iWidth;      /* fill the fields */
  *iHeight      = pChunk->iHeight;
  *iBitdepth    = pChunk->iBitdepth;
  *iColortype   = pChunk->iColortype;
  *iCompression = pChunk->iCompression;
  *iFilter      = pChunk->iFilter;
  *iInterlace   = pChunk->iInterlace;
  *iRed         = pChunk->iRed;
  *iGreen       = pChunk->iGreen;
  *iBlue        = pChunk->iBlue;
  *iAlpha       = pChunk->iAlpha;
  *iViewable    = pChunk->iViewable;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BASI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_CLON
mng_retcode MNG_DECL mng_getchunk_clon (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iSourceid,
                                        mng_uint16 *iCloneid,
                                        mng_uint8  *iClonetype,
                                        mng_uint8  *iDonotshow,
                                        mng_uint8  *iConcrete,
                                        mng_bool   *bHasloca,
                                        mng_uint8  *iLocationtype,
                                        mng_int32  *iLocationx,
                                        mng_int32  *iLocationy)
{
  mng_datap pData;
  mng_clonp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLON, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_clonp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_CLON)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iSourceid     = pChunk->iSourceid;  /* fill the fields */  
  *iCloneid      = pChunk->iCloneid;
  *iClonetype    = pChunk->iClonetype;
  *iDonotshow    = pChunk->iDonotshow;
  *iConcrete     = pChunk->iConcrete;
  *bHasloca      = pChunk->bHasloca;
  *iLocationtype = pChunk->iLocationtype;
  *iLocationx    = pChunk->iLocationx;
  *iLocationy    = pChunk->iLocationy;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLON, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_PAST
mng_retcode MNG_DECL mng_getchunk_past (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iDestid,
                                        mng_uint8  *iTargettype,
                                        mng_int32  *iTargetx,
                                        mng_int32  *iTargety,
                                        mng_uint32 *iCount)
{
  mng_datap pData;
  mng_pastp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_pastp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_PAST)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iDestid     = pChunk->iDestid;       /* fill the fields */
  *iTargettype = pChunk->iTargettype;
  *iTargetx    = pChunk->iTargetx;
  *iTargety    = pChunk->iTargety;
  *iCount      = pChunk->iCount;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_PAST
mng_retcode MNG_DECL mng_getchunk_past_src (mng_handle hHandle,
                                            mng_handle hChunk,
                                            mng_uint32 iEntry,
                                            mng_uint16 *iSourceid,
                                            mng_uint8  *iComposition,
                                            mng_uint8  *iOrientation,
                                            mng_uint8  *iOffsettype,
                                            mng_int32  *iOffsetx,
                                            mng_int32  *iOffsety,
                                            mng_uint8  *iBoundarytype,
                                            mng_int32  *iBoundaryl,
                                            mng_int32  *iBoundaryr,
                                            mng_int32  *iBoundaryt,
                                            mng_int32  *iBoundaryb)
{
  mng_datap        pData;
  mng_pastp        pChunk;
  mng_past_sourcep pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST_SRC, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_pastp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_PAST)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  if (iEntry >= pChunk->iCount)        /* valid index ? */
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address the entry */
  pEntry         = pChunk->pSources + iEntry;

  *iSourceid     = pEntry->iSourceid;  /* fill the fields */
  *iComposition  = pEntry->iComposition;
  *iOrientation  = pEntry->iOrientation;
  *iOffsettype   = pEntry->iOffsettype;
  *iOffsetx      = pEntry->iOffsetx;
  *iOffsety      = pEntry->iOffsety;
  *iBoundarytype = pEntry->iBoundarytype;
  *iBoundaryl    = pEntry->iBoundaryl;
  *iBoundaryr    = pEntry->iBoundaryr;
  *iBoundaryt    = pEntry->iBoundaryt;
  *iBoundaryb    = pEntry->iBoundaryb;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PAST_SRC, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_DISC
mng_retcode MNG_DECL mng_getchunk_disc (mng_handle  hHandle,
                                        mng_handle  hChunk,
                                        mng_uint32  *iCount,
                                        mng_uint16p *pObjectids)
{
  mng_datap pData;
  mng_discp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DISC, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_discp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_DISC)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iCount     = pChunk->iCount;        /* fill the fields */
  *pObjectids = pChunk->pObjectids;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DISC, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_BACK
mng_retcode MNG_DECL mng_getchunk_back (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iRed,
                                        mng_uint16 *iGreen,
                                        mng_uint16 *iBlue,
                                        mng_uint8  *iMandatory,
                                        mng_uint16 *iImageid,
                                        mng_uint8  *iTile)
{
  mng_datap pData;
  mng_backp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BACK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_backp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_BACK)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iRed       = pChunk->iRed;          /* fill the fields */
  *iGreen     = pChunk->iGreen;
  *iBlue      = pChunk->iBlue;
  *iMandatory = pChunk->iMandatory;
  *iImageid   = pChunk->iImageid;
  *iTile      = pChunk->iTile;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_BACK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_FRAM
mng_retcode MNG_DECL mng_getchunk_fram (mng_handle  hHandle,
                                        mng_handle  hChunk,
                                        mng_bool    *bEmpty,
                                        mng_uint8   *iMode,
                                        mng_uint32  *iNamesize,
                                        mng_pchar   *zName,
                                        mng_uint8   *iChangedelay,
                                        mng_uint8   *iChangetimeout,
                                        mng_uint8   *iChangeclipping,
                                        mng_uint8   *iChangesyncid,
                                        mng_uint32  *iDelay,
                                        mng_uint32  *iTimeout,
                                        mng_uint8   *iBoundarytype,
                                        mng_int32   *iBoundaryl,
                                        mng_int32   *iBoundaryr,
                                        mng_int32   *iBoundaryt,
                                        mng_int32   *iBoundaryb,
                                        mng_uint32  *iCount,
                                        mng_uint32p *pSyncids)
{
  mng_datap pData;
  mng_framp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FRAM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_framp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_FRAM)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty          = pChunk->bEmpty;   /* fill the fields */      
  *iMode           = pChunk->iMode;
  *iNamesize       = pChunk->iNamesize;
  *zName           = pChunk->zName;
  *iChangedelay    = pChunk->iChangedelay;
  *iChangetimeout  = pChunk->iChangetimeout;
  *iChangeclipping = pChunk->iChangeclipping;
  *iChangesyncid   = pChunk->iChangesyncid;
  *iDelay          = pChunk->iDelay;
  *iTimeout        = pChunk->iTimeout;
  *iBoundarytype   = pChunk->iBoundarytype;
  *iBoundaryl      = pChunk->iBoundaryl;
  *iBoundaryr      = pChunk->iBoundaryr;
  *iBoundaryt      = pChunk->iBoundaryt;
  *iBoundaryb      = pChunk->iBoundaryb;
  *iCount          = pChunk->iCount;
  *pSyncids        = pChunk->pSyncids;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FRAM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_MOVE
mng_retcode MNG_DECL mng_getchunk_move (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iFirstid,
                                        mng_uint16 *iLastid,
                                        mng_uint8  *iMovetype,
                                        mng_int32  *iMovex,
                                        mng_int32  *iMovey)
{
  mng_datap pData;
  mng_movep pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MOVE, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_movep)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_MOVE)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iFirstid  = pChunk->iFirstid;       /* fill the fields */
  *iLastid   = pChunk->iLastid;
  *iMovetype = pChunk->iMovetype;
  *iMovex    = pChunk->iMovex;
  *iMovey    = pChunk->iMovey;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MOVE, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_CLIP
mng_retcode MNG_DECL mng_getchunk_clip (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iFirstid,
                                        mng_uint16 *iLastid,
                                        mng_uint8  *iCliptype,
                                        mng_int32  *iClipl,
                                        mng_int32  *iClipr,
                                        mng_int32  *iClipt,
                                        mng_int32  *iClipb)
{
  mng_datap pData;
  mng_clipp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLIP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_clipp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_CLIP)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iFirstid  = pChunk->iFirstid;       /* fill the fields */
  *iLastid   = pChunk->iLastid;
  *iCliptype = pChunk->iCliptype;
  *iClipl    = pChunk->iClipl;
  *iClipr    = pChunk->iClipr;
  *iClipt    = pChunk->iClipt;
  *iClipb    = pChunk->iClipb;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_CLIP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_SHOW
mng_retcode MNG_DECL mng_getchunk_show (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint16 *iFirstid,
                                        mng_uint16 *iLastid,
                                        mng_uint8  *iMode)
{
  mng_datap pData;
  mng_showp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SHOW, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_showp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_SHOW)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty   = pChunk->bEmpty;          /* fill the fields */
  *iFirstid = pChunk->iFirstid;
  *iLastid  = pChunk->iLastid;
  *iMode    = pChunk->iMode;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SHOW, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_TERM
mng_retcode MNG_DECL mng_getchunk_term (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint8  *iTermaction,
                                        mng_uint8  *iIteraction,
                                        mng_uint32 *iDelay,
                                        mng_uint32 *iItermax)
{
  mng_datap pData;
  mng_termp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TERM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_termp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_TERM)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iTermaction = pChunk->iTermaction;  /* fill the fields */
  *iIteraction = pChunk->iIteraction;
  *iDelay      = pChunk->iDelay;
  *iItermax    = pChunk->iItermax;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_TERM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_SAVE
mng_retcode MNG_DECL mng_getchunk_save (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint8  *iOffsettype,
                                        mng_uint32 *iCount)
{
  mng_datap pData;
  mng_savep pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_savep)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_SAVE)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty      = pChunk->bEmpty;       /* fill the fields */
  *iOffsettype = pChunk->iOffsettype;
  *iCount      = pChunk->iCount;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_save_entry (mng_handle     hHandle,
                                              mng_handle     hChunk,
                                              mng_uint32     iEntry,
                                              mng_uint8      *iEntrytype,
                                              mng_uint32arr2 *iOffset,
                                              mng_uint32arr2 *iStarttime,
                                              mng_uint32     *iLayernr,
                                              mng_uint32     *iFramenr,
                                              mng_uint32     *iNamesize,
                                              mng_pchar      *zName)
{
  mng_datap       pData;
  mng_savep       pChunk;
  mng_save_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_savep)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_SAVE)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  if (iEntry >= pChunk->iCount)        /* valid index ? */
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)

  pEntry  = pChunk->pEntries + iEntry; /* address the entry */
                                       /* fill the fields */
  *iEntrytype      = pEntry->iEntrytype;
  (*iOffset)[0]    = pEntry->iOffset[0];
  (*iOffset)[1]    = pEntry->iOffset[1];
  (*iStarttime)[0] = pEntry->iStarttime[0];
  (*iStarttime)[1] = pEntry->iStarttime[1];
  *iLayernr        = pEntry->iLayernr;
  *iFramenr        = pEntry->iFramenr;
  *iNamesize       = pEntry->iNamesize;
  *zName           = pEntry->zName;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SAVE_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_SEEK
mng_retcode MNG_DECL mng_getchunk_seek (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iNamesize,
                                        mng_pchar  *zName)
{
  mng_datap pData;
  mng_seekp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SEEK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_seekp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_SEEK)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iNamesize = pChunk->iNamesize;      /* fill the fields */
  *zName     = pChunk->zName;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_SEEK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_eXPI
mng_retcode MNG_DECL mng_getchunk_expi (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iSnapshotid,
                                        mng_uint32 *iNamesize,
                                        mng_pchar  *zName)
{
  mng_datap pData;
  mng_expip pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EXPI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_expip)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_eXPI)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iSnapshotid = pChunk->iSnapshotid;  /* fill the fields */
  *iNamesize   = pChunk->iNamesize;
  *zName       = pChunk->zName;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EXPI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_fPRI
mng_retcode MNG_DECL mng_getchunk_fpri (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint8  *iDeltatype,
                                        mng_uint8  *iPriority)
{
  mng_datap pData;
  mng_fprip pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FPRI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_fprip)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_fPRI)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iDeltatype = pChunk->iDeltatype;    /* fill the fields */
  *iPriority  = pChunk->iPriority;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_FPRI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_nEED
mng_retcode MNG_DECL mng_getchunk_need (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iKeywordssize,
                                        mng_pchar  *zKeywords)
{
  mng_datap pData;
  mng_needp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_NEED, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_needp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_nEED)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* fill the fields */
  *iKeywordssize = pChunk->iKeywordssize;
  *zKeywords     = pChunk->zKeywords;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_NEED, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_pHYg
mng_retcode MNG_DECL mng_getchunk_phyg (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_bool   *bEmpty,
                                        mng_uint32 *iSizex,
                                        mng_uint32 *iSizey,
                                        mng_uint8  *iUnit)
{
  mng_datap pData;
  mng_phygp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYG, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_phygp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_pHYg)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *bEmpty = pChunk->bEmpty;            /* fill the fields */
  *iSizex = pChunk->iSizex;
  *iSizey = pChunk->iSizey;
  *iUnit  = pChunk->iUnit;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PHYG, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_getchunk_jhdr (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iWidth,
                                        mng_uint32 *iHeight,
                                        mng_uint8  *iColortype,
                                        mng_uint8  *iImagesampledepth,
                                        mng_uint8  *iImagecompression,
                                        mng_uint8  *iImageinterlace,
                                        mng_uint8  *iAlphasampledepth,
                                        mng_uint8  *iAlphacompression,
                                        mng_uint8  *iAlphafilter,
                                        mng_uint8  *iAlphainterlace)
{
  mng_datap pData;
  mng_jhdrp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_jhdrp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_JHDR)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iWidth            = pChunk->iWidth; /* fill the fields */          
  *iHeight           = pChunk->iHeight;
  *iColortype        = pChunk->iColortype;
  *iImagesampledepth = pChunk->iImagesampledepth;
  *iImagecompression = pChunk->iImagecompression;
  *iImageinterlace   = pChunk->iImageinterlace;
  *iAlphasampledepth = pChunk->iAlphasampledepth;
  *iAlphacompression = pChunk->iAlphacompression;
  *iAlphafilter      = pChunk->iAlphafilter;
  *iAlphainterlace   = pChunk->iAlphainterlace;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /* MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_getchunk_jdat (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iRawlen,
                                        mng_ptr    *pRawdata)
{
  mng_datap pData;
  mng_jdatp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_jdatp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_JDAT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iRawlen  = pChunk->iDatasize;       /* fill the fields */
  *pRawdata = pChunk->pData;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /* MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_getchunk_jdaa (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iRawlen,
                                        mng_ptr    *pRawdata)
{
  mng_datap pData;
  mng_jdaap pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAA, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_jdaap)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_JDAA)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iRawlen  = pChunk->iDatasize;       /* fill the fields */
  *pRawdata = pChunk->pData;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_JDAA, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /* MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_getchunk_dhdr (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iObjectid,
                                        mng_uint8  *iImagetype,
                                        mng_uint8  *iDeltatype,
                                        mng_uint32 *iBlockwidth,
                                        mng_uint32 *iBlockheight,
                                        mng_uint32 *iBlockx,
                                        mng_uint32 *iBlocky)
{
  mng_datap pData;
  mng_dhdrp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_dhdrp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_DHDR)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iObjectid    = pChunk->iObjectid;   /* fill the fields */
  *iImagetype   = pChunk->iImagetype;
  *iDeltatype   = pChunk->iDeltatype;
  *iBlockwidth  = pChunk->iBlockwidth;
  *iBlockheight = pChunk->iBlockheight;
  *iBlockx      = pChunk->iBlockx;
  *iBlocky      = pChunk->iBlocky;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_getchunk_prom (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint8  *iColortype,
                                        mng_uint8  *iSampledepth,
                                        mng_uint8  *iFilltype)
{
  mng_datap pData;
  mng_promp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PROM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_promp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_PROM)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iColortype   = pChunk->iColortype;  /* fill the fields */
  *iSampledepth = pChunk->iSampledepth;
  *iFilltype    = pChunk->iFilltype;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PROM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_getchunk_pplt (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint8  *iDeltatype,
                                        mng_uint32 *iCount)
{
  mng_datap pData;
  mng_ppltp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_ppltp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_PPLT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iDeltatype = pChunk->iDeltatype;    /* fill the fields */
  *iCount     = pChunk->iCount;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_getchunk_pplt_entry (mng_handle hHandle,
                                              mng_handle hChunk,
                                              mng_uint32 iEntry,
                                              mng_uint16 *iRed,
                                              mng_uint16 *iGreen,
                                              mng_uint16 *iBlue,
                                              mng_uint16 *iAlpha,
                                              mng_bool   *bUsed)
{
  mng_datap       pData;
  mng_ppltp       pChunk;
  mng_pplt_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_ppltp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_PPLT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  if (iEntry >= pChunk->iCount)        /* valid index ? */
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)

  pEntry  = &pChunk->aEntries[iEntry]; /* address the entry */

  *iRed   = pEntry->iRed;              /* fill the fields */
  *iGreen = pEntry->iGreen;
  *iBlue  = pEntry->iBlue;
  *iAlpha = pEntry->iAlpha;
  *bUsed  = pEntry->bUsed;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_PPLT_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_getchunk_drop (mng_handle   hHandle,
                                        mng_handle   hChunk,
                                        mng_uint32   *iCount,
                                        mng_chunkidp *pChunknames)
{
  mng_datap pData;
  mng_dropp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DROP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_dropp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_DROP)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iCount      = pChunk->iCount;       /* fill the fields */
  *pChunknames = pChunk->pChunknames;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DROP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DBYK
mng_retcode MNG_DECL mng_getchunk_dbyk (mng_handle  hHandle,
                                        mng_handle  hChunk,
                                        mng_chunkid *iChunkname,
                                        mng_uint8   *iPolarity,
                                        mng_uint32  *iKeywordssize,
                                        mng_pchar   *zKeywords)
{
  mng_datap pData;
  mng_dbykp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DBYK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_dbykp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_DBYK)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iChunkname    = pChunk->iChunkname; /* fill the fields */  
  *iPolarity     = pChunk->iPolarity;
  *iKeywordssize = pChunk->iKeywordssize;
  *zKeywords     = pChunk->zKeywords;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_DBYK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
mng_retcode MNG_DECL mng_getchunk_ordr (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iCount)
{
  mng_datap pData;
  mng_ordrp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_ordrp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_ORDR)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iCount = pChunk->iCount;            /* fill the field */ 

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
mng_retcode MNG_DECL mng_getchunk_ordr_entry (mng_handle  hHandle,
                                              mng_handle  hChunk,
                                              mng_uint32  iEntry,
                                              mng_chunkid *iChunkname,
                                              mng_uint8   *iOrdertype)
{
  mng_datap       pData;
  mng_ordrp       pChunk;
  mng_ordr_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_ordrp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_ORDR)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  if (iEntry >= pChunk->iCount)        /* valid index ? */
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)

  pEntry = pChunk->pEntries + iEntry;  /* address the proper entry */

  *iChunkname = pEntry->iChunkname;    /* fill the fields */
  *iOrdertype = pEntry->iOrdertype;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_ORDR_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_MAGN
mng_retcode MNG_DECL mng_getchunk_magn (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint16 *iFirstid,
                                        mng_uint16 *iLastid,
                                        mng_uint16 *iMethodX,
                                        mng_uint16 *iMX,
                                        mng_uint16 *iMY,
                                        mng_uint16 *iML,
                                        mng_uint16 *iMR,
                                        mng_uint16 *iMT,
                                        mng_uint16 *iMB,
                                        mng_uint16 *iMethodY)
{
  mng_datap pData;
  mng_magnp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MAGN, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_magnp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_MAGN)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iFirstid = pChunk->iFirstid;        /* fill the fields */
  *iLastid  = pChunk->iLastid;
  *iMethodX = (mng_uint16)pChunk->iMethodX;
  *iMX      = pChunk->iMX;
  *iMY      = pChunk->iMY;
  *iML      = pChunk->iML;
  *iMR      = pChunk->iMR;
  *iMT      = pChunk->iMT;
  *iMB      = pChunk->iMB;
  *iMethodY = (mng_uint16)pChunk->iMethodY;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MAGN, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_EXT mng_retcode MNG_DECL mng_getchunk_mpng (mng_handle hHandle,
                                                mng_handle hChunk,
                                                mng_uint32 *iFramewidth,
                                                mng_uint32 *iFrameheight,
                                                mng_uint16 *iNumplays,
                                                mng_uint16 *iTickspersec,
                                                mng_uint8  *iCompressionmethod,
                                                mng_uint32 *iCount)
{
  mng_datap pData;
  mng_mpngp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_mpngp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_mpNG)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* fill the fields */
  *iFramewidth        = pChunk->iFramewidth;
  *iFrameheight       = pChunk->iFrameheight;
  *iNumplays          = pChunk->iNumplays;
  *iTickspersec       = pChunk->iTickspersec;
  *iCompressionmethod = pChunk->iCompressionmethod;
  *iCount             = pChunk->iFramessize / sizeof (mng_mpng_frame);

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_EXT mng_retcode MNG_DECL mng_getchunk_mpng_frame (mng_handle hHandle,
                                                      mng_handle hChunk,
                                                      mng_uint32 iEntry,
                                                      mng_uint32 *iX,
                                                      mng_uint32 *iY,
                                                      mng_uint32 *iWidth,
                                                      mng_uint32 *iHeight,
                                                      mng_int32  *iXoffset,
                                                      mng_int32  *iYoffset,
                                                      mng_uint16 *iTicks)
{
  mng_datap       pData;
  mng_mpngp       pChunk;
  mng_mpng_framep pFrame;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG_FRAME, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_mpngp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_mpNG)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* valid index ? */
  if (iEntry >= (pChunk->iFramessize / sizeof (mng_mpng_frame)))
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)

  pFrame  = pChunk->pFrames + iEntry;  /* address the entry */
                                       /* fill the fields */
  *iX        = pFrame->iX;
  *iY        = pFrame->iY;
  *iWidth    = pFrame->iWidth;
  *iHeight   = pFrame->iHeight;
  *iXoffset  = pFrame->iXoffset;
  *iYoffset  = pFrame->iYoffset;
  *iTicks    = pFrame->iTicks;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_MPNG_FRAME, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_evNT
mng_retcode MNG_DECL mng_getchunk_evnt (mng_handle hHandle,
                                        mng_handle hChunk,
                                        mng_uint32 *iCount)
{
  mng_datap pData;
  mng_evntp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_evntp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_evNT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  *iCount = pChunk->iCount;            /* fill the fields */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_evnt_entry (mng_handle hHandle,
                                              mng_handle hChunk,
                                              mng_uint32 iEntry,
                                              mng_uint8  *iEventtype,
                                              mng_uint8  *iMasktype,
                                              mng_int32  *iLeft,
                                              mng_int32  *iRight,
                                              mng_int32  *iTop,
                                              mng_int32  *iBottom,
                                              mng_uint16 *iObjectid,
                                              mng_uint8  *iIndex,
                                              mng_uint32 *iSegmentnamesize,
                                              mng_pchar  *zSegmentname)
{
  mng_datap       pData;
  mng_evntp       pChunk;
  mng_evnt_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_evntp)hChunk;          /* address the chunk */

  if (pChunk->sHeader.iChunkname != MNG_UINT_evNT)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */

  if (iEntry >= pChunk->iCount)        /* valid index ? */
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)

  pEntry  = pChunk->pEntries + iEntry; /* address the entry */
                                       /* fill the fields */
  *iEventtype       = pEntry->iEventtype;
  *iMasktype        = pEntry->iMasktype;
  *iLeft            = pEntry->iLeft;    
  *iRight           = pEntry->iRight;
  *iTop             = pEntry->iTop;
  *iBottom          = pEntry->iBottom;
  *iObjectid        = pEntry->iObjectid;
  *iIndex           = pEntry->iIndex;
  *iSegmentnamesize = pEntry->iSegmentnamesize;
  *zSegmentname     = pEntry->zSegmentname;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_EVNT_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getchunk_unknown (mng_handle  hHandle,
                                           mng_handle  hChunk,
                                           mng_chunkid *iChunkname,
                                           mng_uint32  *iRawlen,
                                           mng_ptr     *pRawdata)
{
  mng_datap          pData;
  mng_unknown_chunkp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_UNKNOWN, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData  = (mng_datap)hHandle;         /* and make it addressable */
  pChunk = (mng_unknown_chunkp)hChunk; /* address the chunk */

  if (pChunk->sHeader.fCleanup != mng_free_unknown)
    MNG_ERROR (pData, MNG_WRONGCHUNK)  /* ouch */
                                       /* fill the fields */
  *iChunkname = pChunk->sHeader.iChunkname;
  *iRawlen    = pChunk->iDatasize;
  *pRawdata   = pChunk->pData;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETCHUNK_UNKNOWN, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */
/* ************************************************************************** */

#ifdef MNG_INCLUDE_WRITE_PROCS

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_TERM
MNG_LOCAL mng_bool check_term (mng_datap   pData,
                               mng_chunkid iChunkname)
{
  mng_chunk_headerp pChunk = (mng_chunk_headerp)pData->pLastchunk;

  if (!pChunk)                         /* nothing added yet ? */
    return MNG_TRUE;
                                       /* last added chunk is TERM ? */
  if (pChunk->iChunkname != MNG_UINT_TERM)
    return MNG_TRUE;
                                       /* previous to last is MHDR ? */
  if ((pChunk->pPrev) && (((mng_chunk_headerp)pChunk->pPrev)->iChunkname == MNG_UINT_MHDR))
    return MNG_TRUE;

  if (iChunkname == MNG_UINT_SEEK)     /* new chunk to be added is SEEK ? */
    return MNG_TRUE;

  return MNG_FALSE;
}
#endif

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_ihdr (mng_handle hHandle,
                                        mng_uint32 iWidth,
                                        mng_uint32 iHeight,
                                        mng_uint8  iBitdepth,
                                        mng_uint8  iColortype,
                                        mng_uint8  iCompression,
                                        mng_uint8  iFilter,
                                        mng_uint8  iInterlace)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_IHDR, mng_init_general, mng_free_general, mng_read_ihdr, mng_write_ihdr, mng_assign_general, 0, 0, sizeof(mng_ihdr)};
#else
          {MNG_UINT_IHDR, mng_init_ihdr, mng_free_ihdr, mng_read_ihdr, mng_write_ihdr, mng_assign_ihdr, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_IHDR))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_ihdr (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_IHDR, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
  ((mng_ihdrp)pChunk)->iWidth       = iWidth;
  ((mng_ihdrp)pChunk)->iHeight      = iHeight;
  ((mng_ihdrp)pChunk)->iBitdepth    = iBitdepth;
  ((mng_ihdrp)pChunk)->iColortype   = iColortype;
  ((mng_ihdrp)pChunk)->iCompression = iCompression;
  ((mng_ihdrp)pChunk)->iFilter      = iFilter;
  ((mng_ihdrp)pChunk)->iInterlace   = iInterlace;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_plte (mng_handle   hHandle,
                                        mng_uint32   iCount,
                                        mng_palette8 aPalette)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_PLTE, mng_init_general, mng_free_general, mng_read_plte, mng_write_plte, mng_assign_general, 0, 0, sizeof(mng_plte)};
#else
          {MNG_UINT_PLTE, mng_init_plte, mng_free_plte, mng_read_plte, mng_write_plte, mng_assign_plte, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PLTE, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_PLTE))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_plte (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_PLTE, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_pltep)pChunk)->iEntrycount = iCount;
  ((mng_pltep)pChunk)->bEmpty      = (mng_bool)(iCount == 0);

  MNG_COPY (((mng_pltep)pChunk)->aEntries, aPalette, sizeof (mng_palette8));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PLTE, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_idat (mng_handle hHandle,
                                        mng_uint32 iRawlen,
                                        mng_ptr    pRawdata)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_IDAT, mng_init_general, mng_free_idat, mng_read_idat, mng_write_idat, mng_assign_idat, 0, 0, sizeof(mng_idat)};
#else
          {MNG_UINT_IDAT, mng_init_idat, mng_free_idat, mng_read_idat, mng_write_idat, mng_assign_idat, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IDAT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_IDAT))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_idat (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_IDAT, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_idatp)pChunk)->bEmpty    = (mng_bool)(iRawlen == 0);
  ((mng_idatp)pChunk)->iDatasize = iRawlen;

  if (iRawlen)
  {
    MNG_ALLOC (pData, ((mng_idatp)pChunk)->pData, iRawlen);
    MNG_COPY (((mng_idatp)pChunk)->pData, pRawdata, iRawlen);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IDAT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_iend (mng_handle hHandle)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_IEND, mng_init_general, mng_free_general, mng_read_iend, mng_write_iend, mng_assign_general, 0, 0, sizeof(mng_iend)};
#else
          {MNG_UINT_IEND, mng_init_iend, mng_free_iend, mng_read_iend, mng_write_iend, mng_assign_iend, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IEND, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_IEND))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_iend (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_IEND, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_INCLUDE_JNG
  if ((pData->iFirstchunkadded == MNG_UINT_IHDR) ||
      (pData->iFirstchunkadded == MNG_UINT_JHDR)    )
#else
  if (pData->iFirstchunkadded == MNG_UINT_IHDR)
#endif
    pData->bCreating = MNG_FALSE;      /* should be last chunk !!! */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IEND, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_trns (mng_handle   hHandle,
                                        mng_bool     bEmpty,
                                        mng_bool     bGlobal,
                                        mng_uint8    iType,
                                        mng_uint32   iCount,
                                        mng_uint8arr aAlphas,
                                        mng_uint16   iGray,
                                        mng_uint16   iRed,
                                        mng_uint16   iGreen,
                                        mng_uint16   iBlue,
                                        mng_uint32   iRawlen,
                                        mng_uint8arr aRawdata)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_tRNS, mng_init_general, mng_free_general, mng_read_trns, mng_write_trns, mng_assign_general, 0, 0, sizeof(mng_trns)};
#else
          {MNG_UINT_tRNS, mng_init_trns, mng_free_trns, mng_read_trns, mng_write_trns, mng_assign_trns, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TRNS, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_tRNS))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_trns (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_tRNS, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_trnsp)pChunk)->bEmpty   = bEmpty;
  ((mng_trnsp)pChunk)->bGlobal  = bGlobal;
  ((mng_trnsp)pChunk)->iType    = iType;
  ((mng_trnsp)pChunk)->iCount   = iCount;
  ((mng_trnsp)pChunk)->iGray    = iGray;
  ((mng_trnsp)pChunk)->iRed     = iRed;
  ((mng_trnsp)pChunk)->iGreen   = iGreen;
  ((mng_trnsp)pChunk)->iBlue    = iBlue;
  ((mng_trnsp)pChunk)->iRawlen  = iRawlen;

  MNG_COPY (((mng_trnsp)pChunk)->aEntries, aAlphas,  sizeof (mng_uint8arr));
  MNG_COPY (((mng_trnsp)pChunk)->aRawdata, aRawdata, sizeof (mng_uint8arr));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TRNS, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_gAMA
mng_retcode MNG_DECL mng_putchunk_gama (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint32 iGamma)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_gAMA, mng_init_general, mng_free_general, mng_read_gama, mng_write_gama, mng_assign_general, 0, 0, sizeof(mng_gama)};
#else
          {MNG_UINT_gAMA, mng_init_gama, mng_free_gama, mng_read_gama, mng_write_gama, mng_assign_gama, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_GAMA, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_gAMA))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_gama (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_gAMA, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_gamap)pChunk)->bEmpty = bEmpty;
  ((mng_gamap)pChunk)->iGamma = iGamma;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_GAMA, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_cHRM
mng_retcode MNG_DECL mng_putchunk_chrm (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint32 iWhitepointx,
                                        mng_uint32 iWhitepointy,
                                        mng_uint32 iRedx,
                                        mng_uint32 iRedy,
                                        mng_uint32 iGreenx,
                                        mng_uint32 iGreeny,
                                        mng_uint32 iBluex,
                                        mng_uint32 iBluey)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_cHRM, mng_init_general, mng_free_general, mng_read_chrm, mng_write_chrm, mng_assign_general, 0, 0, sizeof(mng_chrm)};
#else
          {MNG_UINT_cHRM, mng_init_chrm, mng_free_chrm, mng_read_chrm, mng_write_chrm, mng_assign_chrm, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CHRM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_cHRM))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_chrm (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_cHRM, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_chrmp)pChunk)->bEmpty       = bEmpty;
  ((mng_chrmp)pChunk)->iWhitepointx = iWhitepointx;
  ((mng_chrmp)pChunk)->iWhitepointy = iWhitepointy;
  ((mng_chrmp)pChunk)->iRedx        = iRedx;
  ((mng_chrmp)pChunk)->iRedy        = iRedy;
  ((mng_chrmp)pChunk)->iGreenx      = iGreenx;
  ((mng_chrmp)pChunk)->iGreeny      = iGreeny;
  ((mng_chrmp)pChunk)->iBluex       = iBluex;
  ((mng_chrmp)pChunk)->iBluey       = iBluey;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CHRM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_sRGB
mng_retcode MNG_DECL mng_putchunk_srgb (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint8  iRenderingintent)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_sRGB, mng_init_general, mng_free_general, mng_read_srgb, mng_write_srgb, mng_assign_general, 0, 0, sizeof(mng_srgb)};
#else
          {MNG_UINT_sRGB, mng_init_srgb, mng_free_srgb, mng_read_srgb, mng_write_srgb, mng_assign_srgb, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SRGB, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_sRGB))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_srgb (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_sRGB, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_srgbp)pChunk)->bEmpty           = bEmpty;
  ((mng_srgbp)pChunk)->iRenderingintent = iRenderingintent;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SRGB, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_iCCP
mng_retcode MNG_DECL mng_putchunk_iccp (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint32 iNamesize,
                                        mng_pchar  zName,
                                        mng_uint8  iCompression,
                                        mng_uint32 iProfilesize,
                                        mng_ptr    pProfile)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_iCCP, mng_init_general, mng_free_iccp, mng_read_iccp, mng_write_iccp, mng_assign_iccp, 0, 0, sizeof(mng_iccp)};
#else
          {MNG_UINT_iCCP, mng_init_iccp, mng_free_iccp, mng_read_iccp, mng_write_iccp, mng_assign_iccp, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ICCP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_iCCP))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_iccp (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_iCCP, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_iccpp)pChunk)->bEmpty       = bEmpty;
  ((mng_iccpp)pChunk)->iNamesize    = iNamesize;
  ((mng_iccpp)pChunk)->iCompression = iCompression;
  ((mng_iccpp)pChunk)->iProfilesize = iProfilesize;

  if (iNamesize)
  {
    MNG_ALLOC (pData, ((mng_iccpp)pChunk)->zName, iNamesize + 1);
    MNG_COPY (((mng_iccpp)pChunk)->zName, zName, iNamesize);
  }

  if (iProfilesize)
  {
    MNG_ALLOC (pData, ((mng_iccpp)pChunk)->pProfile, iProfilesize);
    MNG_COPY (((mng_iccpp)pChunk)->pProfile, pProfile, iProfilesize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ICCP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_tEXt
mng_retcode MNG_DECL mng_putchunk_text (mng_handle hHandle,
                                        mng_uint32 iKeywordsize,
                                        mng_pchar  zKeyword,
                                        mng_uint32 iTextsize,
                                        mng_pchar  zText)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_tEXt, mng_init_general, mng_free_text, mng_read_text, mng_write_text, mng_assign_text, 0, 0, sizeof(mng_text)};
#else
          {MNG_UINT_tEXt, mng_init_text, mng_free_text, mng_read_text, mng_write_text, mng_assign_text, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TEXT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_tEXt))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_text (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_tEXt, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_textp)pChunk)->iKeywordsize = iKeywordsize;
  ((mng_textp)pChunk)->iTextsize    = iTextsize;

  if (iKeywordsize)
  {
    MNG_ALLOC (pData, ((mng_textp)pChunk)->zKeyword, iKeywordsize + 1);
    MNG_COPY (((mng_textp)pChunk)->zKeyword, zKeyword, iKeywordsize);
  }

  if (iTextsize)
  {
    MNG_ALLOC (pData, ((mng_textp)pChunk)->zText, iTextsize + 1);
    MNG_COPY (((mng_textp)pChunk)->zText, zText, iTextsize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TEXT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_zTXt
mng_retcode MNG_DECL mng_putchunk_ztxt (mng_handle hHandle,
                                        mng_uint32 iKeywordsize,
                                        mng_pchar  zKeyword,
                                        mng_uint8  iCompression,
                                        mng_uint32 iTextsize,
                                        mng_pchar  zText)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_zTXt, mng_init_general, mng_free_ztxt, mng_read_ztxt, mng_write_ztxt, mng_assign_ztxt, 0, 0, sizeof(mng_ztxt)};
#else
          {MNG_UINT_zTXt, mng_init_ztxt, mng_free_ztxt, mng_read_ztxt, mng_write_ztxt, mng_assign_ztxt, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ZTXT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_zTXt))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_ztxt (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_zTXt, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_ztxtp)pChunk)->iKeywordsize = iKeywordsize;
  ((mng_ztxtp)pChunk)->iCompression = iCompression;
  ((mng_ztxtp)pChunk)->iTextsize    = iTextsize;

  if (iKeywordsize)
  {
    MNG_ALLOC (pData, ((mng_ztxtp)pChunk)->zKeyword, iKeywordsize + 1);
    MNG_COPY (((mng_ztxtp)pChunk)->zKeyword, zKeyword, iKeywordsize);
  }

  if (iTextsize)
  {
    MNG_ALLOC (pData, ((mng_ztxtp)pChunk)->zText, iTextsize + 1);
    MNG_COPY  (((mng_ztxtp)pChunk)->zText, zText, iTextsize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ZTXT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_iTXt
mng_retcode MNG_DECL mng_putchunk_itxt (mng_handle hHandle,
                                        mng_uint32 iKeywordsize,
                                        mng_pchar  zKeyword,
                                        mng_uint8  iCompressionflag,
                                        mng_uint8  iCompressionmethod,
                                        mng_uint32 iLanguagesize,
                                        mng_pchar  zLanguage,
                                        mng_uint32 iTranslationsize,
                                        mng_pchar  zTranslation,
                                        mng_uint32 iTextsize,
                                        mng_pchar  zText)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_iTXt, mng_init_general, mng_free_itxt, mng_read_itxt, mng_write_itxt, mng_assign_itxt, 0, 0, sizeof(mng_itxt)};
#else
          {MNG_UINT_iTXt, mng_init_itxt, mng_free_itxt, mng_read_itxt, mng_write_itxt, mng_assign_itxt, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ITXT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_iTXt))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_itxt (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_iTXt, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_itxtp)pChunk)->iKeywordsize       = iKeywordsize;
  ((mng_itxtp)pChunk)->iCompressionflag   = iCompressionflag;
  ((mng_itxtp)pChunk)->iCompressionmethod = iCompressionmethod;
  ((mng_itxtp)pChunk)->iLanguagesize      = iLanguagesize;
  ((mng_itxtp)pChunk)->iTranslationsize   = iTranslationsize;
  ((mng_itxtp)pChunk)->iTextsize          = iTextsize;

  if (iKeywordsize)
  {
    MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zKeyword, iKeywordsize + 1);
    MNG_COPY (((mng_itxtp)pChunk)->zKeyword, zKeyword, iKeywordsize);
  }

  if (iLanguagesize)
  {
    MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zLanguage, iLanguagesize + 1);
    MNG_COPY (((mng_itxtp)pChunk)->zLanguage, zLanguage, iLanguagesize);
  }

  if (iTranslationsize)
  {
    MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zTranslation, iTranslationsize + 1);
    MNG_COPY (((mng_itxtp)pChunk)->zTranslation, zTranslation, iTranslationsize);
  }

  if (iTextsize)
  {
    MNG_ALLOC (pData, ((mng_itxtp)pChunk)->zText, iTextsize + 1);
    MNG_COPY (((mng_itxtp)pChunk)->zText, zText, iTextsize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ITXT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_bKGD
mng_retcode MNG_DECL mng_putchunk_bkgd (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint8  iType,
                                        mng_uint8  iIndex,
                                        mng_uint16 iGray,
                                        mng_uint16 iRed,
                                        mng_uint16 iGreen,
                                        mng_uint16 iBlue)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_bKGD, mng_init_general, mng_free_general, mng_read_bkgd, mng_write_bkgd, mng_assign_general, 0, 0, sizeof(mng_bkgd)};
#else
          {MNG_UINT_bKGD, mng_init_bkgd, mng_free_bkgd, mng_read_bkgd, mng_write_bkgd, mng_assign_bkgd, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BKGD, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_bKGD))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_bkgd (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_bKGD, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_bkgdp)pChunk)->bEmpty = bEmpty;
  ((mng_bkgdp)pChunk)->iType  = iType;
  ((mng_bkgdp)pChunk)->iIndex = iIndex;
  ((mng_bkgdp)pChunk)->iGray  = iGray;
  ((mng_bkgdp)pChunk)->iRed   = iRed;
  ((mng_bkgdp)pChunk)->iGreen = iGreen;
  ((mng_bkgdp)pChunk)->iBlue  = iBlue;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BKGD, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_pHYs
mng_retcode MNG_DECL mng_putchunk_phys (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint32 iSizex,
                                        mng_uint32 iSizey,
                                        mng_uint8  iUnit)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_pHYs, mng_init_general, mng_free_general, mng_read_phys, mng_write_phys, mng_assign_general, 0, 0, sizeof(mng_phys)};
#else
          {MNG_UINT_pHYs, mng_init_phys, mng_free_phys, mng_read_phys, mng_write_phys, mng_assign_phys, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYS, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_pHYs))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_phys (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_pHYs, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_physp)pChunk)->bEmpty = bEmpty;
  ((mng_physp)pChunk)->iSizex = iSizex;
  ((mng_physp)pChunk)->iSizey = iSizey;
  ((mng_physp)pChunk)->iUnit  = iUnit;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYS, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_sBIT
mng_retcode MNG_DECL mng_putchunk_sbit (mng_handle    hHandle,
                                        mng_bool      bEmpty,
                                        mng_uint8     iType,
                                        mng_uint8arr4 aBits)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_sBIT, mng_init_general, mng_free_general, mng_read_sbit, mng_write_sbit, mng_assign_general, 0, 0, sizeof(mng_sbit)};
#else
          {MNG_UINT_sBIT, mng_init_sbit, mng_free_sbit, mng_read_sbit, mng_write_sbit, mng_assign_sbit, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SBIT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_sBIT))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_sbit (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_sBIT, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_sbitp)pChunk)->bEmpty   = bEmpty;
  ((mng_sbitp)pChunk)->iType    = iType;
  ((mng_sbitp)pChunk)->aBits[0] = aBits[0];
  ((mng_sbitp)pChunk)->aBits[1] = aBits[1];
  ((mng_sbitp)pChunk)->aBits[2] = aBits[2];
  ((mng_sbitp)pChunk)->aBits[3] = aBits[3];

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SBIT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_sPLT
mng_retcode MNG_DECL mng_putchunk_splt (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint32 iNamesize,
                                        mng_pchar  zName,
                                        mng_uint8  iSampledepth,
                                        mng_uint32 iEntrycount,
                                        mng_ptr    pEntries)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_sPLT, mng_init_general, mng_free_splt, mng_read_splt, mng_write_splt, mng_assign_splt, 0, 0, sizeof(mng_splt)};
#else
          {MNG_UINT_sPLT, mng_init_splt, mng_free_splt, mng_read_splt, mng_write_splt, mng_assign_splt, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SPLT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_sPLT))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_splt (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_sPLT, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_spltp)pChunk)->bEmpty       = bEmpty;
  ((mng_spltp)pChunk)->iNamesize    = iNamesize;
  ((mng_spltp)pChunk)->iSampledepth = iSampledepth;
  ((mng_spltp)pChunk)->iEntrycount  = iEntrycount;

  if (iNamesize)
  {
    MNG_ALLOC (pData, ((mng_spltp)pChunk)->zName, iNamesize + 1);
    MNG_COPY (((mng_spltp)pChunk)->zName, zName, iNamesize);
  }

  if (iEntrycount)
  {
    mng_uint32 iSize = iEntrycount * ((iSampledepth >> 1) + 2);

    MNG_ALLOC (pData, ((mng_spltp)pChunk)->pEntries, iSize);
    MNG_COPY  (((mng_spltp)pChunk)->pEntries, pEntries, iSize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SPLT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_hIST
mng_retcode MNG_DECL mng_putchunk_hist (mng_handle    hHandle,
                                        mng_uint32    iEntrycount,
                                        mng_uint16arr aEntries)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_hIST, mng_init_general, mng_free_general, mng_read_hist, mng_write_hist, mng_assign_general, 0, 0, sizeof(mng_hist)};
#else
          {MNG_UINT_hIST, mng_init_hist, mng_free_hist, mng_read_hist, mng_write_hist, mng_assign_hist, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_HIST, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_hIST))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_hist (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_hIST, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_histp)pChunk)->iEntrycount = iEntrycount;

  MNG_COPY (((mng_histp)pChunk)->aEntries, aEntries, sizeof (mng_uint16arr));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_HIST, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_tIME
mng_retcode MNG_DECL mng_putchunk_time (mng_handle hHandle,
                                        mng_uint16 iYear,
                                        mng_uint8  iMonth,
                                        mng_uint8  iDay,
                                        mng_uint8  iHour,
                                        mng_uint8  iMinute,
                                        mng_uint8  iSecond)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_tIME, mng_init_general, mng_free_general, mng_read_time, mng_write_time, mng_assign_general, 0, 0, sizeof(mng_time)};
#else
          {MNG_UINT_tIME, mng_init_time, mng_free_time, mng_read_time, mng_write_time, mng_assign_time, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TIME, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_tIME))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_time (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_tIME, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_timep)pChunk)->iYear   = iYear;
  ((mng_timep)pChunk)->iMonth  = iMonth;
  ((mng_timep)pChunk)->iDay    = iDay;
  ((mng_timep)pChunk)->iHour   = iHour;
  ((mng_timep)pChunk)->iMinute = iMinute;
  ((mng_timep)pChunk)->iSecond = iSecond;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TIME, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_mhdr (mng_handle hHandle,
                                        mng_uint32 iWidth,
                                        mng_uint32 iHeight,
                                        mng_uint32 iTicks,
                                        mng_uint32 iLayercount,
                                        mng_uint32 iFramecount,
                                        mng_uint32 iPlaytime,
                                        mng_uint32 iSimplicity)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_MHDR, mng_init_general, mng_free_general, mng_read_mhdr, mng_write_mhdr, mng_assign_general, 0, 0, sizeof(mng_mhdr)};
#else
          {MNG_UINT_MHDR, mng_init_mhdr, mng_free_mhdr, mng_read_mhdr, mng_write_mhdr, mng_assign_mhdr, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must be very first! */
  if (pData->iFirstchunkadded != 0)
    MNG_ERROR (pData, MNG_SEQUENCEERROR)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_MHDR))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_mhdr (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_MHDR, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_mhdrp)pChunk)->iWidth      = iWidth;
  ((mng_mhdrp)pChunk)->iHeight     = iHeight;
  ((mng_mhdrp)pChunk)->iTicks      = iTicks;
  ((mng_mhdrp)pChunk)->iLayercount = iLayercount;
  ((mng_mhdrp)pChunk)->iFramecount = iFramecount;
  ((mng_mhdrp)pChunk)->iPlaytime   = iPlaytime;
  ((mng_mhdrp)pChunk)->iSimplicity = iSimplicity;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_mend (mng_handle hHandle)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_MEND, mng_init_general, mng_free_general, mng_read_mend, mng_write_mend, mng_assign_general, 0, 0, sizeof(mng_mend)};
#else
          {MNG_UINT_MEND, mng_init_mend, mng_free_mend, mng_read_mend, mng_write_mend, mng_assign_mend, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MEND, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_MEND))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_mend (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_MEND, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

  pData->bCreating = MNG_FALSE;        /* should be last chunk !!! */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MEND, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_LOOP
mng_retcode MNG_DECL mng_putchunk_loop (mng_handle  hHandle,
                                        mng_uint8   iLevel,
                                        mng_uint32  iRepeat,
                                        mng_uint8   iTermination,
                                        mng_uint32  iItermin,
                                        mng_uint32  iItermax,
                                        mng_uint32  iCount,
                                        mng_uint32p pSignals)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_LOOP, mng_init_general, mng_free_loop, mng_read_loop, mng_write_loop, mng_assign_loop, 0, 0, sizeof(mng_loop)};
#else
          {MNG_UINT_LOOP, mng_init_loop, mng_free_loop, mng_read_loop, mng_write_loop, mng_assign_loop, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_LOOP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_LOOP))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_loop (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_LOOP, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_loopp)pChunk)->iLevel       = iLevel;
  ((mng_loopp)pChunk)->iRepeat      = iRepeat;
  ((mng_loopp)pChunk)->iTermination = iTermination;
  ((mng_loopp)pChunk)->iItermin     = iItermin;
  ((mng_loopp)pChunk)->iItermax     = iItermax;
  ((mng_loopp)pChunk)->iCount       = iCount;
  ((mng_loopp)pChunk)->pSignals     = pSignals;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_LOOP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_endl (mng_handle hHandle,
                                        mng_uint8  iLevel)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_ENDL, mng_init_general, mng_free_general, mng_read_endl, mng_write_endl, mng_assign_general, 0, 0, sizeof(mng_endl)};
#else
          {MNG_UINT_ENDL, mng_init_endl, mng_free_endl, mng_read_endl, mng_write_endl, mng_assign_endl, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ENDL, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_ENDL))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_endl (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_ENDL, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_endlp)pChunk)->iLevel = iLevel;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ENDL, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_DEFI
mng_retcode MNG_DECL mng_putchunk_defi (mng_handle hHandle,
                                        mng_uint16 iObjectid,
                                        mng_uint8  iDonotshow,
                                        mng_uint8  iConcrete,
                                        mng_bool   bHasloca,
                                        mng_int32  iXlocation,
                                        mng_int32  iYlocation,
                                        mng_bool   bHasclip,
                                        mng_int32  iLeftcb,
                                        mng_int32  iRightcb,
                                        mng_int32  iTopcb,
                                        mng_int32  iBottomcb)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_DEFI, mng_init_general, mng_free_general, mng_read_defi, mng_write_defi, mng_assign_general, 0, 0, sizeof(mng_defi)};
#else
          {MNG_UINT_DEFI, mng_init_defi, mng_free_defi, mng_read_defi, mng_write_defi, mng_assign_defi, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DEFI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_DEFI))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_defi (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_DEFI, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_defip)pChunk)->iObjectid  = iObjectid;
  ((mng_defip)pChunk)->iDonotshow = iDonotshow;
  ((mng_defip)pChunk)->iConcrete  = iConcrete;
  ((mng_defip)pChunk)->bHasloca   = bHasloca;
  ((mng_defip)pChunk)->iXlocation = iXlocation;
  ((mng_defip)pChunk)->iYlocation = iYlocation;
  ((mng_defip)pChunk)->bHasclip   = bHasclip;
  ((mng_defip)pChunk)->iLeftcb    = iLeftcb;
  ((mng_defip)pChunk)->iRightcb   = iRightcb;
  ((mng_defip)pChunk)->iTopcb     = iTopcb;
  ((mng_defip)pChunk)->iBottomcb  = iBottomcb;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DEFI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_BASI
mng_retcode MNG_DECL mng_putchunk_basi (mng_handle hHandle,
                                        mng_uint32 iWidth,
                                        mng_uint32 iHeight,
                                        mng_uint8  iBitdepth,
                                        mng_uint8  iColortype,
                                        mng_uint8  iCompression,
                                        mng_uint8  iFilter,
                                        mng_uint8  iInterlace,
                                        mng_uint16 iRed,
                                        mng_uint16 iGreen,
                                        mng_uint16 iBlue,
                                        mng_uint16 iAlpha,
                                        mng_uint8  iViewable)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_BASI, mng_init_general, mng_free_general, mng_read_basi, mng_write_basi, mng_assign_general, 0, 0, sizeof(mng_basi)};
#else
          {MNG_UINT_BASI, mng_init_basi, mng_free_basi, mng_read_basi, mng_write_basi, mng_assign_basi, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BASI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_BASI))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_basi (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_BASI, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_basip)pChunk)->iWidth       = iWidth;
  ((mng_basip)pChunk)->iHeight      = iHeight;
  ((mng_basip)pChunk)->iBitdepth    = iBitdepth;
  ((mng_basip)pChunk)->iColortype   = iColortype;
  ((mng_basip)pChunk)->iCompression = iCompression;
  ((mng_basip)pChunk)->iFilter      = iFilter;
  ((mng_basip)pChunk)->iInterlace   = iInterlace;
  ((mng_basip)pChunk)->iRed         = iRed;
  ((mng_basip)pChunk)->iGreen       = iGreen;
  ((mng_basip)pChunk)->iBlue        = iBlue;
  ((mng_basip)pChunk)->iAlpha       = iAlpha;
  ((mng_basip)pChunk)->iViewable    = iViewable;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BASI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_CLON
mng_retcode MNG_DECL mng_putchunk_clon (mng_handle hHandle,
                                        mng_uint16 iSourceid,
                                        mng_uint16 iCloneid,
                                        mng_uint8  iClonetype,
                                        mng_uint8  iDonotshow,
                                        mng_uint8  iConcrete,
                                        mng_bool   bHasloca,
                                        mng_uint8  iLocationtype,
                                        mng_int32  iLocationx,
                                        mng_int32  iLocationy)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_CLON, mng_init_general, mng_free_general, mng_read_clon, mng_write_clon, mng_assign_general, 0, 0, sizeof(mng_clon)};
#else
          {MNG_UINT_CLON, mng_init_clon, mng_free_clon, mng_read_clon, mng_write_clon, mng_assign_clon, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLON, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_CLON))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_clon (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_CLON, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_clonp)pChunk)->iSourceid     = iSourceid;
  ((mng_clonp)pChunk)->iCloneid      = iCloneid;
  ((mng_clonp)pChunk)->iClonetype    = iClonetype;
  ((mng_clonp)pChunk)->iDonotshow    = iDonotshow;
  ((mng_clonp)pChunk)->iConcrete     = iConcrete;
  ((mng_clonp)pChunk)->bHasloca      = bHasloca;
  ((mng_clonp)pChunk)->iLocationtype = iLocationtype;
  ((mng_clonp)pChunk)->iLocationx    = iLocationx;
  ((mng_clonp)pChunk)->iLocationy    = iLocationy;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLON, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_PAST
mng_retcode MNG_DECL mng_putchunk_past (mng_handle hHandle,
                                        mng_uint16 iDestid,
                                        mng_uint8  iTargettype,
                                        mng_int32  iTargetx,
                                        mng_int32  iTargety,
                                        mng_uint32 iCount)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_PAST, mng_init_general, mng_free_past, mng_read_past, mng_write_past, mng_assign_past, 0, 0, sizeof(mng_past)};
#else
          {MNG_UINT_PAST, mng_init_past, mng_free_past, mng_read_past, mng_write_past, mng_assign_past, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_PAST))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_past (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_PAST, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_pastp)pChunk)->iDestid     = iDestid;
  ((mng_pastp)pChunk)->iTargettype = iTargettype;
  ((mng_pastp)pChunk)->iTargetx    = iTargetx;
  ((mng_pastp)pChunk)->iTargety    = iTargety;
  ((mng_pastp)pChunk)->iCount      = iCount;

  if (iCount)
    MNG_ALLOC (pData, ((mng_pastp)pChunk)->pSources, iCount * sizeof (mng_past_source));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_PAST
mng_retcode MNG_DECL mng_putchunk_past_src (mng_handle hHandle,
                                            mng_uint32 iEntry,
                                            mng_uint16 iSourceid,
                                            mng_uint8  iComposition,
                                            mng_uint8  iOrientation,
                                            mng_uint8  iOffsettype,
                                            mng_int32  iOffsetx,
                                            mng_int32  iOffsety,
                                            mng_uint8  iBoundarytype,
                                            mng_int32  iBoundaryl,
                                            mng_int32  iBoundaryr,
                                            mng_int32  iBoundaryt,
                                            mng_int32  iBoundaryb)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_past_sourcep pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST_SRC, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)

  pChunk = pData->pLastchunk;          /* last one must have been PAST ! */

  if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_PAST)
    MNG_ERROR (pData, MNG_NOCORRCHUNK)
                                       /* index out of bounds ? */
  if (iEntry >= ((mng_pastp)pChunk)->iCount)
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address proper entry */
  pEntry = ((mng_pastp)pChunk)->pSources + iEntry;

  pEntry->iSourceid     = iSourceid;   /* fill entry */
  pEntry->iComposition  = iComposition;
  pEntry->iOrientation  = iOrientation;
  pEntry->iOffsettype   = iOffsettype;
  pEntry->iOffsetx      = iOffsetx;
  pEntry->iOffsety      = iOffsety;
  pEntry->iBoundarytype = iBoundarytype;
  pEntry->iBoundaryl    = iBoundaryl;
  pEntry->iBoundaryr    = iBoundaryr;
  pEntry->iBoundaryt    = iBoundaryt;
  pEntry->iBoundaryb    = iBoundaryb;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PAST_SRC, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_DISC
mng_retcode MNG_DECL mng_putchunk_disc (mng_handle  hHandle,
                                        mng_uint32  iCount,
                                        mng_uint16p pObjectids)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_DISC, mng_init_general, mng_free_disc, mng_read_disc, mng_write_disc, mng_assign_disc, 0, 0, sizeof(mng_disc)};
#else
          {MNG_UINT_DISC, mng_init_disc, mng_free_disc, mng_read_disc, mng_write_disc, mng_assign_disc, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DISC, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_DISC))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_disc (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_DISC, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_discp)pChunk)->iCount = iCount;

  if (iCount)
  {
    mng_uint32 iSize = iCount * sizeof (mng_uint32);

    MNG_ALLOC (pData, ((mng_discp)pChunk)->pObjectids, iSize);
    MNG_COPY (((mng_discp)pChunk)->pObjectids, pObjectids, iSize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DISC, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_BACK
mng_retcode MNG_DECL mng_putchunk_back (mng_handle hHandle,
                                        mng_uint16 iRed,
                                        mng_uint16 iGreen,
                                        mng_uint16 iBlue,
                                        mng_uint8  iMandatory,
                                        mng_uint16 iImageid,
                                        mng_uint8  iTile)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_BACK, mng_init_general, mng_free_general, mng_read_back, mng_write_back, mng_assign_general, 0, 0, sizeof(mng_back)};
#else
          {MNG_UINT_BACK, mng_init_back, mng_free_back, mng_read_back, mng_write_back, mng_assign_back, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BACK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_BACK))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_back (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_BACK, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_backp)pChunk)->iRed       = iRed;
  ((mng_backp)pChunk)->iGreen     = iGreen;
  ((mng_backp)pChunk)->iBlue      = iBlue;
  ((mng_backp)pChunk)->iMandatory = iMandatory;
  ((mng_backp)pChunk)->iImageid   = iImageid;
  ((mng_backp)pChunk)->iTile      = iTile;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_BACK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_FRAM
mng_retcode MNG_DECL mng_putchunk_fram (mng_handle  hHandle,
                                        mng_bool    bEmpty,
                                        mng_uint8   iMode,
                                        mng_uint32  iNamesize,
                                        mng_pchar   zName,
                                        mng_uint8   iChangedelay,
                                        mng_uint8   iChangetimeout,
                                        mng_uint8   iChangeclipping,
                                        mng_uint8   iChangesyncid,
                                        mng_uint32  iDelay,
                                        mng_uint32  iTimeout,
                                        mng_uint8   iBoundarytype,
                                        mng_int32   iBoundaryl,
                                        mng_int32   iBoundaryr,
                                        mng_int32   iBoundaryt,
                                        mng_int32   iBoundaryb,
                                        mng_uint32  iCount,
                                        mng_uint32p pSyncids)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_FRAM, mng_init_general, mng_free_fram, mng_read_fram, mng_write_fram, mng_assign_fram, 0, 0, sizeof(mng_fram)};
#else
          {MNG_UINT_FRAM, mng_init_fram, mng_free_fram, mng_read_fram, mng_write_fram, mng_assign_fram, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FRAM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_FRAM))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_fram (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_FRAM, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_framp)pChunk)->bEmpty          = bEmpty;
  ((mng_framp)pChunk)->iMode           = iMode;
  ((mng_framp)pChunk)->iNamesize       = iNamesize;
  ((mng_framp)pChunk)->iChangedelay    = iChangedelay;
  ((mng_framp)pChunk)->iChangetimeout  = iChangetimeout;
  ((mng_framp)pChunk)->iChangeclipping = iChangeclipping;
  ((mng_framp)pChunk)->iChangesyncid   = iChangesyncid;
  ((mng_framp)pChunk)->iDelay          = iDelay;
  ((mng_framp)pChunk)->iTimeout        = iTimeout;
  ((mng_framp)pChunk)->iBoundarytype   = iBoundarytype;
  ((mng_framp)pChunk)->iBoundaryl      = iBoundaryl;
  ((mng_framp)pChunk)->iBoundaryr      = iBoundaryr;
  ((mng_framp)pChunk)->iBoundaryt      = iBoundaryt;
  ((mng_framp)pChunk)->iBoundaryb      = iBoundaryb;
  ((mng_framp)pChunk)->iCount          = iCount;

  if (iNamesize)
  {
    MNG_ALLOC (pData, ((mng_framp)pChunk)->zName, iNamesize + 1);
    MNG_COPY (((mng_framp)pChunk)->zName, zName, iNamesize);
  }

  if (iCount)
  {
    mng_uint32 iSize = iCount * sizeof (mng_uint32);

    MNG_ALLOC (pData, ((mng_framp)pChunk)->pSyncids, iSize);
    MNG_COPY (((mng_framp)pChunk)->pSyncids, pSyncids, iSize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FRAM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_MOVE
mng_retcode MNG_DECL mng_putchunk_move (mng_handle hHandle,
                                        mng_uint16 iFirstid,
                                        mng_uint16 iLastid,
                                        mng_uint8  iMovetype,
                                        mng_int32  iMovex,
                                        mng_int32  iMovey)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_MOVE, mng_init_general, mng_free_general, mng_read_move, mng_write_move, mng_assign_general, 0, 0, sizeof(mng_move)};
#else
          {MNG_UINT_MOVE, mng_init_move, mng_free_move, mng_read_move, mng_write_move, mng_assign_move, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MOVE, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_MOVE))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_move (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_MOVE, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_movep)pChunk)->iFirstid  = iFirstid;
  ((mng_movep)pChunk)->iLastid   = iLastid;
  ((mng_movep)pChunk)->iMovetype = iMovetype;
  ((mng_movep)pChunk)->iMovex    = iMovex;
  ((mng_movep)pChunk)->iMovey    = iMovey;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MOVE, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_CLIP
mng_retcode MNG_DECL mng_putchunk_clip (mng_handle hHandle,
                                        mng_uint16 iFirstid,
                                        mng_uint16 iLastid,
                                        mng_uint8  iCliptype,
                                        mng_int32  iClipl,
                                        mng_int32  iClipr,
                                        mng_int32  iClipt,
                                        mng_int32  iClipb)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_CLIP, mng_init_general, mng_free_general, mng_read_clip, mng_write_clip, mng_assign_general, 0, 0, sizeof(mng_clip)};
#else
          {MNG_UINT_CLIP, mng_init_clip, mng_free_clip, mng_read_clip, mng_write_clip, mng_assign_clip, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLIP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_CLIP))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_clip (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_CLIP, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_clipp)pChunk)->iFirstid  = iFirstid;
  ((mng_clipp)pChunk)->iLastid   = iLastid;
  ((mng_clipp)pChunk)->iCliptype = iCliptype;
  ((mng_clipp)pChunk)->iClipl    = iClipl;
  ((mng_clipp)pChunk)->iClipr    = iClipr;
  ((mng_clipp)pChunk)->iClipt    = iClipt;
  ((mng_clipp)pChunk)->iClipb    = iClipb;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_CLIP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif


/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_SHOW
mng_retcode MNG_DECL mng_putchunk_show (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint16 iFirstid,
                                        mng_uint16 iLastid,
                                        mng_uint8  iMode)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_SHOW, mng_init_general, mng_free_general, mng_read_show, mng_write_show, mng_assign_general, 0, 0, sizeof(mng_show)};
#else
          {MNG_UINT_SHOW, mng_init_show, mng_free_show, mng_read_show, mng_write_show, mng_assign_show, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SHOW, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_SHOW))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_show (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_SHOW, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_showp)pChunk)->bEmpty   = bEmpty;
  ((mng_showp)pChunk)->iFirstid = iFirstid;
  ((mng_showp)pChunk)->iLastid  = iLastid;
  ((mng_showp)pChunk)->iMode    = iMode;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SHOW, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_TERM
mng_retcode MNG_DECL mng_putchunk_term (mng_handle hHandle,
                                        mng_uint8  iTermaction,
                                        mng_uint8  iIteraction,
                                        mng_uint32 iDelay,
                                        mng_uint32 iItermax)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_TERM, mng_init_general, mng_free_general, mng_read_term, mng_write_term, mng_assign_general, 0, 0, sizeof(mng_term)};
#else
          {MNG_UINT_TERM, mng_init_term, mng_free_term, mng_read_term, mng_write_term, mng_assign_term, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TERM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_term (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_TERM, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_termp)pChunk)->iTermaction = iTermaction;
  ((mng_termp)pChunk)->iIteraction = iIteraction;
  ((mng_termp)pChunk)->iDelay      = iDelay;
  ((mng_termp)pChunk)->iItermax    = iItermax;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_TERM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_SAVE
mng_retcode MNG_DECL mng_putchunk_save (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint8  iOffsettype,
                                        mng_uint32 iCount)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_SAVE, mng_init_general, mng_free_save, mng_read_save, mng_write_save, mng_assign_save, 0, 0, sizeof(mng_save)};
#else
          {MNG_UINT_SAVE, mng_init_save, mng_free_save, mng_read_save, mng_write_save, mng_assign_save, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_SAVE))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_save (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_SAVE, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_savep)pChunk)->bEmpty      = bEmpty;
  ((mng_savep)pChunk)->iOffsettype = iOffsettype;
  ((mng_savep)pChunk)->iCount      = iCount;

  if (iCount)
    MNG_ALLOC (pData, ((mng_savep)pChunk)->pEntries, iCount * sizeof (mng_save_entry));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_save_entry (mng_handle     hHandle,
                                              mng_uint32     iEntry,
                                              mng_uint8      iEntrytype,
                                              mng_uint32arr2 iOffset,
                                              mng_uint32arr2 iStarttime,
                                              mng_uint32     iLayernr,
                                              mng_uint32     iFramenr,
                                              mng_uint32     iNamesize,
                                              mng_pchar      zName)
{
  mng_datap       pData;
  mng_chunkp      pChunk;
  mng_save_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)

  pChunk = pData->pLastchunk;          /* last one must have been SAVE ! */

  if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_SAVE)
    MNG_ERROR (pData, MNG_NOCORRCHUNK)
                                       /* index out of bounds ? */
  if (iEntry >= ((mng_savep)pChunk)->iCount)
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address proper entry */
  pEntry = ((mng_savep)pChunk)->pEntries + iEntry;

  pEntry->iEntrytype    = iEntrytype;  /* fill entry */
  pEntry->iOffset[0]    = iOffset[0];
  pEntry->iOffset[1]    = iOffset[1];
  pEntry->iStarttime[0] = iStarttime[0];
  pEntry->iStarttime[1] = iStarttime[1];
  pEntry->iLayernr      = iLayernr;
  pEntry->iFramenr      = iFramenr;
  pEntry->iNamesize     = iNamesize;

  if (iNamesize)
  {
    MNG_ALLOC (pData, pEntry->zName, iNamesize + 1);
    MNG_COPY (pEntry->zName, zName, iNamesize);
  }

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SAVE_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_SEEK
mng_retcode MNG_DECL mng_putchunk_seek (mng_handle hHandle,
                                        mng_uint32 iNamesize,
                                        mng_pchar  zName)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_SEEK, mng_init_general, mng_free_seek, mng_read_seek, mng_write_seek, mng_assign_seek, 0, 0, sizeof(mng_seek)};
#else
          {MNG_UINT_SEEK, mng_init_seek, mng_free_seek, mng_read_seek, mng_write_seek, mng_assign_seek, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SEEK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_SEEK))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_seek (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_SEEK, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_seekp)pChunk)->iNamesize = iNamesize;

  if (iNamesize)
  {
    MNG_ALLOC (pData, ((mng_seekp)pChunk)->zName, iNamesize + 1);
    MNG_COPY (((mng_seekp)pChunk)->zName, zName, iNamesize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_SEEK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_eXPI
mng_retcode MNG_DECL mng_putchunk_expi (mng_handle hHandle,
                                        mng_uint16 iSnapshotid,
                                        mng_uint32 iNamesize,
                                        mng_pchar  zName)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_eXPI, mng_init_general, mng_free_expi, mng_read_expi, mng_write_expi, mng_assign_general, 0, 0, sizeof(mng_expi)};
#else
          {MNG_UINT_eXPI, mng_init_expi, mng_free_expi, mng_read_expi, mng_write_expi, mng_assign_expi, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EXPI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_eXPI))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_expi (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_eXPI, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_expip)pChunk)->iSnapshotid = iSnapshotid;
  ((mng_expip)pChunk)->iNamesize   = iNamesize;

  if (iNamesize)
  {
    MNG_ALLOC (pData, ((mng_expip)pChunk)->zName, iNamesize + 1);
    MNG_COPY (((mng_expip)pChunk)->zName, zName, iNamesize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EXPI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_fPRI
mng_retcode MNG_DECL mng_putchunk_fpri (mng_handle hHandle,
                                        mng_uint8  iDeltatype,
                                        mng_uint8  iPriority)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_fPRI, mng_init_general, mng_free_general, mng_read_fpri, mng_write_fpri, mng_assign_general, 0, 0, sizeof(mng_fpri)};
#else
          {MNG_UINT_fPRI, mng_init_fpri, mng_free_fpri, mng_read_fpri, mng_write_fpri, mng_assign_fpri, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FPRI, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_fPRI))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_fpri (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_fPRI, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_fprip)pChunk)->iDeltatype = iDeltatype;
  ((mng_fprip)pChunk)->iPriority  = iPriority;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_FPRI, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_nEED
mng_retcode MNG_DECL mng_putchunk_need (mng_handle hHandle,
                                        mng_uint32 iKeywordssize,
                                        mng_pchar  zKeywords)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_nEED, mng_init_general, mng_free_need, mng_read_need, mng_write_need, mng_assign_need, 0, 0, sizeof(mng_need)};
#else
          {MNG_UINT_nEED, mng_init_need, mng_free_need, mng_read_need, mng_write_need, mng_assign_need, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_NEED, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_nEED))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_need (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_nEED, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_needp)pChunk)->iKeywordssize = iKeywordssize;

  if (iKeywordssize)
  {
    MNG_ALLOC (pData, ((mng_needp)pChunk)->zKeywords, iKeywordssize + 1);
    MNG_COPY (((mng_needp)pChunk)->zKeywords, zKeywords, iKeywordssize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_NEED, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_pHYg
mng_retcode MNG_DECL mng_putchunk_phyg (mng_handle hHandle,
                                        mng_bool   bEmpty,
                                        mng_uint32 iSizex,
                                        mng_uint32 iSizey,
                                        mng_uint8  iUnit)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_pHYg, mng_init_general, mng_free_general, mng_read_phyg, mng_write_phyg, mng_assign_general, 0, 0, sizeof(mng_phyg)};
#else
          {MNG_UINT_pHYg, mng_init_phyg, mng_free_phyg, mng_read_phyg, mng_write_phyg, mng_assign_phyg, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYG, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_pHYg))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_phyg (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_pHYg, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_phygp)pChunk)->bEmpty = bEmpty;
  ((mng_phygp)pChunk)->iSizex = iSizex;
  ((mng_phygp)pChunk)->iSizey = iSizey;
  ((mng_phygp)pChunk)->iUnit  = iUnit;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PHYG, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_putchunk_jhdr (mng_handle hHandle,
                                        mng_uint32 iWidth,
                                        mng_uint32 iHeight,
                                        mng_uint8  iColortype,
                                        mng_uint8  iImagesampledepth,
                                        mng_uint8  iImagecompression,
                                        mng_uint8  iImageinterlace,
                                        mng_uint8  iAlphasampledepth,
                                        mng_uint8  iAlphacompression,
                                        mng_uint8  iAlphafilter,
                                        mng_uint8  iAlphainterlace)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_JHDR, mng_init_general, mng_free_general, mng_read_jhdr, mng_write_jhdr, mng_assign_general, 0, 0, sizeof(mng_jhdr)};
#else
          {MNG_UINT_JHDR, mng_init_jhdr, mng_free_jhdr, mng_read_jhdr, mng_write_jhdr, mng_assign_jhdr, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_JHDR))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_jhdr (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_JHDR, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_jhdrp)pChunk)->iWidth            = iWidth;
  ((mng_jhdrp)pChunk)->iHeight           = iHeight;
  ((mng_jhdrp)pChunk)->iColortype        = iColortype;
  ((mng_jhdrp)pChunk)->iImagesampledepth = iImagesampledepth;
  ((mng_jhdrp)pChunk)->iImagecompression = iImagecompression;
  ((mng_jhdrp)pChunk)->iImageinterlace   = iImageinterlace;
  ((mng_jhdrp)pChunk)->iAlphasampledepth = iAlphasampledepth;
  ((mng_jhdrp)pChunk)->iAlphacompression = iAlphacompression;
  ((mng_jhdrp)pChunk)->iAlphafilter      = iAlphafilter;
  ((mng_jhdrp)pChunk)->iAlphainterlace   = iAlphainterlace;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /* MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_putchunk_jdat (mng_handle hHandle,
                                        mng_uint32 iRawlen,
                                        mng_ptr    pRawdata)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_JDAT, mng_init_general, mng_free_jdat, mng_read_jdat, mng_write_jdat, mng_assign_jdat, 0, 0, sizeof(mng_jdat)};
#else
          {MNG_UINT_JDAT, mng_init_jdat, mng_free_jdat, mng_read_jdat, mng_write_jdat, mng_assign_jdat, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR or JHDR first! */
  if ((pData->iFirstchunkadded != MNG_UINT_MHDR) &&
      (pData->iFirstchunkadded != MNG_UINT_JHDR)    )
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_JDAT))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_jdat (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_JDAT, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_jdatp)pChunk)->iDatasize = iRawlen;

  if (iRawlen)
  {
    MNG_ALLOC (pData, ((mng_jdatp)pChunk)->pData, iRawlen);
    MNG_COPY (((mng_jdatp)pChunk)->pData, pRawdata, iRawlen);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /*  MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_putchunk_jdaa (mng_handle hHandle,
                                        mng_uint32 iRawlen,
                                        mng_ptr    pRawdata)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_JDAA, mng_init_general, mng_free_jdaa, mng_read_jdaa, mng_write_jdaa, mng_assign_jdaa, 0, 0, sizeof(mng_jdaa)};
#else
          {MNG_UINT_JDAA, mng_init_jdaa, mng_free_jdaa, mng_read_jdaa, mng_write_jdaa, mng_assign_jdaa, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAA, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR or JHDR first! */
  if ((pData->iFirstchunkadded != MNG_UINT_MHDR) &&
      (pData->iFirstchunkadded != MNG_UINT_JHDR)    )
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_JDAA))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_jdaa (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_JDAA, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_jdaap)pChunk)->iDatasize = iRawlen;

  if (iRawlen)
  {
    MNG_ALLOC (pData, ((mng_jdaap)pChunk)->pData, iRawlen);
    MNG_COPY (((mng_jdaap)pChunk)->pData, pRawdata, iRawlen);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JDAA, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /*  MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG

mng_retcode MNG_DECL mng_putchunk_jsep (mng_handle hHandle)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_JSEP, mng_init_general, mng_free_general, mng_read_jsep, mng_write_jsep, mng_assign_general, 0, 0, sizeof(mng_jsep)};
#else
          {MNG_UINT_JSEP, mng_init_jsep, mng_free_jsep, mng_read_jsep, mng_write_jsep, mng_assign_jsep, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JSEP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR or JHDR first! */
  if ((pData->iFirstchunkadded != MNG_UINT_MHDR) &&
      (pData->iFirstchunkadded != MNG_UINT_JHDR)    )
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_JSEP))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_jsep (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_JSEP, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_JSEP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

#endif /* MNG_INCLUDE_JNG */

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_putchunk_dhdr (mng_handle hHandle,
                                        mng_uint16 iObjectid,
                                        mng_uint8  iImagetype,
                                        mng_uint8  iDeltatype,
                                        mng_uint32 iBlockwidth,
                                        mng_uint32 iBlockheight,
                                        mng_uint32 iBlockx,
                                        mng_uint32 iBlocky)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_DHDR, mng_init_general, mng_free_general, mng_read_dhdr, mng_write_dhdr, mng_assign_general, 0, 0, sizeof(mng_dhdr)};
#else
          {MNG_UINT_DHDR, mng_init_dhdr, mng_free_dhdr, mng_read_dhdr, mng_write_dhdr, mng_assign_dhdr, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DHDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_DHDR))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_dhdr (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_DHDR, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_dhdrp)pChunk)->iObjectid    = iObjectid;
  ((mng_dhdrp)pChunk)->iImagetype   = iImagetype;
  ((mng_dhdrp)pChunk)->iDeltatype   = iDeltatype;
  ((mng_dhdrp)pChunk)->iBlockwidth  = iBlockwidth;
  ((mng_dhdrp)pChunk)->iBlockheight = iBlockheight;
  ((mng_dhdrp)pChunk)->iBlockx      = iBlockx;
  ((mng_dhdrp)pChunk)->iBlocky      = iBlocky;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DHDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_putchunk_prom (mng_handle hHandle,
                                        mng_uint8  iColortype,
                                        mng_uint8  iSampledepth,
                                        mng_uint8  iFilltype)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_PROM, mng_init_general, mng_free_general, mng_read_prom, mng_write_prom, mng_assign_general, 0, 0, sizeof(mng_prom)};
#else
          {MNG_UINT_PROM, mng_init_prom, mng_free_prom, mng_read_prom, mng_write_prom, mng_assign_prom, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PROM, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_PROM))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_prom (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_PROM, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_promp)pChunk)->iColortype   = iColortype;
  ((mng_promp)pChunk)->iSampledepth = iSampledepth;
  ((mng_promp)pChunk)->iFilltype    = iFilltype;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PROM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_putchunk_ipng (mng_handle hHandle)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_IPNG, mng_init_general, mng_free_general, mng_read_ipng, mng_write_ipng, mng_assign_general, 0, 0, sizeof(mng_ipng)};
#else
          {MNG_UINT_IPNG, mng_init_ipng, mng_free_ipng, mng_read_ipng, mng_write_ipng, mng_assign_ipng, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IPNG, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_IPNG))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_ipng (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_IPNG, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IPNG, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_putchunk_pplt (mng_handle hHandle,
                                        mng_uint8  iDeltatype,
                                        mng_uint32 iCount)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_PPLT, mng_init_general, mng_free_general, mng_read_pplt, mng_write_pplt, mng_assign_general, 0, 0, sizeof(mng_pplt)};
#else
          {MNG_UINT_PPLT, mng_init_pplt, mng_free_pplt, mng_read_pplt, mng_write_pplt, mng_assign_pplt, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_PPLT))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_pplt (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_PPLT, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_ppltp)pChunk)->iDeltatype = iDeltatype;
  ((mng_ppltp)pChunk)->iCount     = iCount;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_putchunk_pplt_entry (mng_handle hHandle,
                                              mng_uint32 iEntry,
                                              mng_uint16 iRed,
                                              mng_uint16 iGreen,
                                              mng_uint16 iBlue,
                                              mng_uint16 iAlpha)
{
  mng_datap       pData;
  mng_chunkp      pChunk;
  mng_pplt_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)

  pChunk = pData->pLastchunk;          /* last one must have been PPLT ! */

  if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_PPLT)
    MNG_ERROR (pData, MNG_NOCORRCHUNK)

                                       /* index out of bounds ? */
  if (iEntry >= ((mng_ppltp)pChunk)->iCount)
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address proper entry */
  pEntry = (mng_pplt_entryp)(((mng_ppltp)pChunk)->aEntries) + iEntry;

  pEntry->iRed   = (mng_uint8)iRed;    /* fill the entry */
  pEntry->iGreen = (mng_uint8)iGreen;
  pEntry->iBlue  = (mng_uint8)iBlue;
  pEntry->iAlpha = (mng_uint8)iAlpha;
  pEntry->bUsed  = MNG_TRUE;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_PPLT_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifdef MNG_INCLUDE_JNG
mng_retcode MNG_DECL mng_putchunk_ijng (mng_handle hHandle)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_IJNG, mng_init_general, mng_free_general, mng_read_ijng, mng_write_ijng, mng_assign_general, 0, 0, sizeof(mng_ijng)};
#else
          {MNG_UINT_IJNG, mng_init_ijng, mng_free_ijng, mng_read_ijng, mng_write_ijng, mng_assign_ijng, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IJNG, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_IJNG))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_ijng (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_IJNG, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_IJNG, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
mng_retcode MNG_DECL mng_putchunk_drop (mng_handle   hHandle,
                                        mng_uint32   iCount,
                                        mng_chunkidp pChunknames)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_DROP, mng_init_general, mng_free_drop, mng_read_drop, mng_write_drop, mng_assign_drop, 0, 0, sizeof(mng_drop)};
#else
          {MNG_UINT_DROP, mng_init_drop, mng_free_drop, mng_read_drop, mng_write_drop, mng_assign_drop, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DROP, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_DROP))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_drop (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_DROP, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_dropp)pChunk)->iCount = iCount;

  if (iCount)
  {
    mng_uint32 iSize = iCount * sizeof (mng_chunkid);

    MNG_ALLOC (pData, ((mng_dropp)pChunk)->pChunknames, iSize);
    MNG_COPY (((mng_dropp)pChunk)->pChunknames, pChunknames, iSize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DROP, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DBYK
mng_retcode MNG_DECL mng_putchunk_dbyk (mng_handle  hHandle,
                                        mng_chunkid iChunkname,
                                        mng_uint8   iPolarity,
                                        mng_uint32  iKeywordssize,
                                        mng_pchar   zKeywords)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_DBYK, mng_init_general, mng_free_dbyk, mng_read_dbyk, mng_write_dbyk, mng_assign_dbyk, 0, 0, sizeof(mng_dbyk)};
#else
          {MNG_UINT_DBYK, mng_init_dbyk, mng_free_dbyk, mng_read_dbyk, mng_write_dbyk, mng_assign_dbyk, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DBYK, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_DBYK))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_dbyk (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_DBYK, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_dbykp)pChunk)->iChunkname    = iChunkname;
  ((mng_dbykp)pChunk)->iPolarity     = iPolarity;
  ((mng_dbykp)pChunk)->iKeywordssize = iKeywordssize;

  if (iKeywordssize)
  {
    MNG_ALLOC (pData, ((mng_dbykp)pChunk)->zKeywords, iKeywordssize + 1);
    MNG_COPY (((mng_dbykp)pChunk)->zKeywords, zKeywords, iKeywordssize);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_DBYK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
mng_retcode MNG_DECL mng_putchunk_ordr (mng_handle hHandle,
                                        mng_uint32 iCount)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_ORDR, mng_init_general, mng_free_ordr, mng_read_ordr, mng_write_ordr, mng_assign_ordr, 0, 0, sizeof(mng_ordr)};
#else
          {MNG_UINT_ORDR, mng_init_ordr, mng_free_ordr, mng_read_ordr, mng_write_ordr, mng_assign_ordr, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_ORDR))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_ordr (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_ORDR, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_ordrp)pChunk)->iCount = iCount;

  if (iCount)
    MNG_ALLOC (pData, ((mng_ordrp)pChunk)->pEntries, iCount * sizeof (mng_ordr_entry));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
mng_retcode MNG_DECL mng_putchunk_ordr_entry (mng_handle  hHandle,
                                              mng_uint32  iEntry,
                                              mng_chunkid iChunkname,
                                              mng_uint8   iOrdertype)
{
  mng_datap       pData;
  mng_chunkp      pChunk;
  mng_ordr_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)

  pChunk = pData->pLastchunk;          /* last one must have been ORDR ! */

  if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_ORDR)
    MNG_ERROR (pData, MNG_NOCORRCHUNK)
                                       /* index out of bounds ? */
  if (iEntry >= ((mng_ordrp)pChunk)->iCount)
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address proper entry */
  pEntry = ((mng_ordrp)pChunk)->pEntries + iEntry;

  pEntry->iChunkname = iChunkname;     /* fill the entry */
  pEntry->iOrdertype = iOrdertype;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_ORDR_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_MAGN
mng_retcode MNG_DECL mng_putchunk_magn (mng_handle hHandle,
                                        mng_uint16 iFirstid,
                                        mng_uint16 iLastid,
                                        mng_uint16 iMethodX,
                                        mng_uint16 iMX,
                                        mng_uint16 iMY,
                                        mng_uint16 iML,
                                        mng_uint16 iMR,
                                        mng_uint16 iMT,
                                        mng_uint16 iMB,
                                        mng_uint16 iMethodY)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_MAGN, mng_init_general, mng_free_general, mng_read_magn, mng_write_magn, mng_assign_general, 0, 0, sizeof(mng_magn)};
#else
          {MNG_UINT_MAGN, mng_init_magn, mng_free_magn, mng_read_magn, mng_write_magn, mng_assign_magn, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MAGN, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_MAGN))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_magn (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_MAGN, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_magnp)pChunk)->iFirstid = iFirstid;
  ((mng_magnp)pChunk)->iLastid  = iLastid;
  ((mng_magnp)pChunk)->iMethodX = (mng_uint8)iMethodX;
  ((mng_magnp)pChunk)->iMX      = iMX;
  ((mng_magnp)pChunk)->iMY      = iMY;
  ((mng_magnp)pChunk)->iML      = iML;
  ((mng_magnp)pChunk)->iMR      = iMR;
  ((mng_magnp)pChunk)->iMT      = iMT;
  ((mng_magnp)pChunk)->iMB      = iMB;
  ((mng_magnp)pChunk)->iMethodY = (mng_uint8)iMethodY;

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MAGN, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_EXT mng_retcode MNG_DECL mng_putchunk_mpng (mng_handle hHandle,
                                                mng_uint32 iFramewidth,
                                                mng_uint32 iFrameheight,
                                                mng_uint16 iNumplays,
                                                mng_uint16 iTickspersec,
                                                mng_uint8  iCompressionmethod,
                                                mng_uint32 iCount)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_mpNG, mng_init_general, mng_free_mpng, mng_read_mpng, mng_write_mpng, mng_assign_mpng, 0, 0, sizeof(mng_mpng)};
#else
          {MNG_UINT_mpNG, mng_init_mpng, mng_free_mpng, mng_read_mpng, mng_write_mpng, mng_assign_mpng, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a IHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_IHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_mpng (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_mpNG, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_mpngp)pChunk)->iFramewidth        = iFramewidth;
  ((mng_mpngp)pChunk)->iFrameheight       = iFrameheight;
  ((mng_mpngp)pChunk)->iNumplays          = iNumplays;
  ((mng_mpngp)pChunk)->iTickspersec       = iTickspersec;
  ((mng_mpngp)pChunk)->iCompressionmethod = iCompressionmethod;
  ((mng_mpngp)pChunk)->iFramessize        = iCount * sizeof (mng_mpng_frame);

  if (iCount)
    MNG_ALLOC (pData, ((mng_mpngp)pChunk)->pFrames, ((mng_mpngp)pChunk)->iFramessize);

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_EXT mng_retcode MNG_DECL mng_putchunk_mpng_frame (mng_handle hHandle,
                                                      mng_uint32 iEntry,
                                                      mng_uint32 iX,
                                                      mng_uint32 iY,
                                                      mng_uint32 iWidth,
                                                      mng_uint32 iHeight,
                                                      mng_int32  iXoffset,
                                                      mng_int32  iYoffset,
                                                      mng_uint16 iTicks)
{
  mng_datap       pData;
  mng_chunkp      pChunk;
  mng_mpng_framep pFrame;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG_FRAME, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a IHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_IHDR)
    MNG_ERROR (pData, MNG_NOHEADER)

  pChunk = pData->pLastchunk;          /* last one must have been mpNG ! */

  if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_mpNG)
    MNG_ERROR (pData, MNG_NOCORRCHUNK)
                                       /* index out of bounds ? */
  if (iEntry >= (((mng_mpngp)pChunk)->iFramessize / sizeof (mng_mpng_frame)))
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address proper entry */
  pFrame = ((mng_mpngp)pChunk)->pFrames + iEntry;
                                       /* fill entry */
  pFrame->iX        = iX;
  pFrame->iY        = iY;
  pFrame->iWidth    = iWidth;
  pFrame->iHeight   = iHeight;
  pFrame->iXoffset  = iXoffset;
  pFrame->iYoffset  = iYoffset;
  pFrame->iTicks    = iTicks;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_MPNG_FRAME, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

#ifndef MNG_SKIPCHUNK_evNT
mng_retcode MNG_DECL mng_putchunk_evnt (mng_handle hHandle,
                                        mng_uint32 iCount)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_evNT, mng_init_general, mng_free_evnt, mng_read_evnt, mng_write_evnt, mng_assign_evnt, 0, 0, sizeof(mng_evnt)};
#else
          {MNG_UINT_evNT, mng_init_evnt, mng_free_evnt, mng_read_evnt, mng_write_evnt, mng_assign_evnt, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, MNG_UINT_evNT))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_evnt (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_evNT, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_evntp)pChunk)->iCount = iCount;

  if (iCount)
    MNG_ALLOC (pData, ((mng_evntp)pChunk)->pEntries, iCount * sizeof (mng_evnt_entry));

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_evnt_entry (mng_handle hHandle,
                                              mng_uint32 iEntry,
                                              mng_uint8  iEventtype,
                                              mng_uint8  iMasktype,
                                              mng_int32  iLeft,
                                              mng_int32  iRight,
                                              mng_int32  iTop,
                                              mng_int32  iBottom,
                                              mng_uint16 iObjectid,
                                              mng_uint8  iIndex,
                                              mng_uint32 iSegmentnamesize,
                                              mng_pchar  zSegmentname)
{
  mng_datap       pData;
  mng_chunkp      pChunk;
  mng_evnt_entryp pEntry;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT_ENTRY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a MHDR first! */
  if (pData->iFirstchunkadded != MNG_UINT_MHDR)
    MNG_ERROR (pData, MNG_NOHEADER)

  pChunk = pData->pLastchunk;          /* last one must have been evNT ! */

  if (((mng_chunk_headerp)pChunk)->iChunkname != MNG_UINT_evNT)
    MNG_ERROR (pData, MNG_NOCORRCHUNK)
                                       /* index out of bounds ? */
  if (iEntry >= ((mng_evntp)pChunk)->iCount)
    MNG_ERROR (pData, MNG_INVALIDENTRYIX)
                                       /* address proper entry */
  pEntry = ((mng_evntp)pChunk)->pEntries + iEntry;
                                       /* fill entry */
  pEntry->iEventtype       = iEventtype;
  pEntry->iMasktype        = iMasktype;
  pEntry->iLeft            = iLeft;
  pEntry->iRight           = iRight;
  pEntry->iTop             = iTop;
  pEntry->iBottom          = iBottom;
  pEntry->iObjectid        = iObjectid;
  pEntry->iIndex           = iIndex;
  pEntry->iSegmentnamesize = iSegmentnamesize;

  if (iSegmentnamesize)
  {
    MNG_ALLOC (pData, pEntry->zSegmentname, iSegmentnamesize + 1);
    MNG_COPY (pEntry->zSegmentname, zSegmentname, iSegmentnamesize);
  }

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_EVNT_ENTRY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putchunk_unknown (mng_handle  hHandle,
                                           mng_chunkid iChunkname,
                                           mng_uint32  iRawlen,
                                           mng_ptr     pRawdata)
{
  mng_datap        pData;
  mng_chunkp       pChunk;
  mng_retcode      iRetcode;
#ifndef MNG_OPTIMIZE_CHUNKREADER
  mng_chunk_header sChunkheader =
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
          {MNG_UINT_HUH, mng_init_general, mng_free_unknown, mng_read_unknown, mng_write_unknown, mng_assign_unknown, 0, 0, sizeof(mng_unknown_chunk)};
#else
          {MNG_UINT_HUH, mng_init_unknown, mng_free_unknown, mng_read_unknown, mng_write_unknown, mng_assign_unknown, 0, 0};
#endif
#else
  mng_chunk_header sChunkheader;
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_UNKNOWN, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must have had a header first! */
  if (pData->iFirstchunkadded == 0)
    MNG_ERROR (pData, MNG_NOHEADER)
                                       /* prevent misplaced TERM ! */
  if (!check_term (pData, iChunkname))
    MNG_ERROR (pData, MNG_TERMSEQERROR)
                                       /* create the chunk */
#ifndef MNG_OPTIMIZE_CHUNKREADER
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#else
  iRetcode = mng_init_unknown (pData, &sChunkheader, &pChunk);
#endif
#else
  mng_get_chunkheader(MNG_UINT_HUH, &sChunkheader);
  iRetcode = mng_init_general (pData, &sChunkheader, &pChunk);
#endif

  if (iRetcode)                        /* on error bail out */
    return iRetcode;
                                       /* fill the chunk */
  ((mng_unknown_chunkp)pChunk)->sHeader.iChunkname = iChunkname;
  ((mng_unknown_chunkp)pChunk)->iDatasize          = iRawlen;

  if (iRawlen)
  {
    MNG_ALLOC (pData, ((mng_unknown_chunkp)pChunk)->pData, iRawlen);
    MNG_COPY (((mng_unknown_chunkp)pChunk)->pData, pRawdata, iRawlen);
  }

  mng_add_chunk (pData, pChunk);       /* add it to the list */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTCHUNK_UNKNOWN, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#endif /* MNG_INCLUDE_WRITE_PROCS */

/* ************************************************************************** */
/* ************************************************************************** */

mng_retcode MNG_DECL mng_getimgdata_seq (mng_handle        hHandle,
                                         mng_uint32        iSeqnr,
                                         mng_uint32        iCanvasstyle,
                                         mng_getcanvasline fGetcanvasline)
{
#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_SEQ, MNG_LC_START);
#endif



#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_SEQ, MNG_LC_END);
#endif

  return MNG_FNNOTIMPLEMENTED;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getimgdata_chunkseq (mng_handle        hHandle,
                                              mng_uint32        iSeqnr,
                                              mng_uint32        iCanvasstyle,
                                              mng_getcanvasline fGetcanvasline)
{
#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNKSEQ, MNG_LC_START);
#endif



#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNKSEQ, MNG_LC_END);
#endif

  return MNG_FNNOTIMPLEMENTED;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_getimgdata_chunk (mng_handle        hHandle,
                                           mng_handle        hChunk,
                                           mng_uint32        iCanvasstyle,
                                           mng_getcanvasline fGetcanvasline)
{
#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNK, MNG_LC_START);
#endif



#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_GETIMGDATA_CHUNK, MNG_LC_END);
#endif

  return MNG_FNNOTIMPLEMENTED;
}

/* ************************************************************************** */
/* ************************************************************************** */

#ifdef MNG_INCLUDE_WRITE_PROCS

/* ************************************************************************** */

mng_retcode MNG_DECL mng_putimgdata_ihdr (mng_handle        hHandle,
                                          mng_uint32        iWidth,
                                          mng_uint32        iHeight,
                                          mng_uint8         iColortype,
                                          mng_uint8         iBitdepth,
                                          mng_uint8         iCompression,
                                          mng_uint8         iFilter,
                                          mng_uint8         iInterlace,
                                          mng_uint32        iCanvasstyle,
                                          mng_getcanvasline fGetcanvasline)
{
#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_IHDR, MNG_LC_START);
#endif



#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_IHDR, MNG_LC_END);
#endif

  return MNG_FNNOTIMPLEMENTED;
}

/* ************************************************************************** */

#ifdef MNG_INCLUDE_JNG
mng_retcode MNG_DECL mng_putimgdata_jhdr (mng_handle        hHandle,
                                          mng_uint32        iWidth,
                                          mng_uint32        iHeight,
                                          mng_uint8         iColortype,
                                          mng_uint8         iBitdepth,
                                          mng_uint8         iCompression,
                                          mng_uint8         iInterlace,
                                          mng_uint8         iAlphaBitdepth,
                                          mng_uint8         iAlphaCompression,
                                          mng_uint8         iAlphaFilter,
                                          mng_uint8         iAlphaInterlace,
                                          mng_uint32        iCanvasstyle,
                                          mng_getcanvasline fGetcanvasline)
{
#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_JHDR, MNG_LC_START);
#endif



#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_PUTIMGDATA_JHDR, MNG_LC_END);
#endif

  return MNG_FNNOTIMPLEMENTED;
}
#endif

/* ************************************************************************** */

mng_retcode MNG_DECL mng_updatemngheader (mng_handle hHandle,
                                          mng_uint32 iFramecount,
                                          mng_uint32 iLayercount,
                                          mng_uint32 iPlaytime)
{
  mng_datap  pData;
  mng_chunkp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGHEADER, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must be a MNG animation! */
  if ((pData->eImagetype != mng_it_mng) || (pData->iFirstchunkadded != MNG_UINT_MHDR))
    MNG_ERROR (pData, MNG_NOMHDR)

  pChunk = pData->pFirstchunk;         /* get the first chunk */
                                       /* and update the variables */
  ((mng_mhdrp)pChunk)->iFramecount = iFramecount;
  ((mng_mhdrp)pChunk)->iLayercount = iLayercount;
  ((mng_mhdrp)pChunk)->iPlaytime   = iPlaytime;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGHEADER, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

mng_retcode MNG_DECL mng_updatemngsimplicity (mng_handle hHandle,
                                              mng_uint32 iSimplicity)
{
  mng_datap  pData;
  mng_chunkp pChunk;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGSIMPLICITY, MNG_LC_START);
#endif

  MNG_VALIDHANDLE (hHandle)            /* check validity handle */
  pData = (mng_datap)hHandle;          /* and make it addressable */

  if (!pData->bCreating)               /* aren't we creating a new file ? */
    MNG_ERROR (pData, MNG_FUNCTIONINVALID)
                                       /* must be a MNG animation! */
  if ((pData->eImagetype != mng_it_mng) || (pData->iFirstchunkadded != MNG_UINT_MHDR))
    MNG_ERROR (pData, MNG_NOMHDR)

  pChunk = pData->pFirstchunk;         /* get the first chunk */
                                       /* and update the variable */
  ((mng_mhdrp)pChunk)->iSimplicity = iSimplicity;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (((mng_datap)hHandle), MNG_FN_UPDATEMNGSIMPLICITY, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#endif /* MNG_INCLUDE_WRITE_PROCS */

/* ************************************************************************** */

#endif /* MNG_ACCESS_CHUNKS */

/* ************************************************************************** */
/* * end of file                                                            * */
/* ************************************************************************** */



