Torque3D/Engine/lib/lmng/libmng_chunk_descr.c

/* ************************************************************************** */
/* *             For conditions of distribution and use,                    * */
/* *                see copyright notice in libmng.h                        * */
/* ************************************************************************** */
/* *                                                                        * */
/* * project   : libmng                                                     * */
/* * file      : libmng_chunk_descr.c      copyright (c) 2005-2007 G.Juyn   * */
/* * version   : 1.0.10                                                     * */
/* *                                                                        * */
/* * purpose   : Chunk descriptor functions (implementation)                * */
/* *                                                                        * */
/* * author    : G.Juyn                                                     * */
/* *                                                                        * */
/* * comment   : implementation of the chunk- anf field-descriptor          * */
/* *             routines                                                   * */
/* *                                                                        * */
/* * changes   : 1.0.9 - 12/06/2004 - G.Juyn                                * */
/* *             - added conditional MNG_OPTIMIZE_CHUNKREADER               * */
/* *             1.0.9 - 12/11/2004 - G.Juyn                                * */
/* *             - made all constants 'static'                              * */
/* *             1.0.9 - 12/20/2004 - G.Juyn                                * */
/* *             - cleaned up macro-invocations (thanks to D. Airlie)       * */
/* *             1.0.9 - 01/17/2005 - G.Juyn                                * */
/* *             - fixed problem with global PLTE/tRNS                      * */
/* *                                                                        * */
/* *             1.0.10 - 01/17/2005 - G.R-P.                               * */
/* *             - added typecast to appease the compiler                   * */
/* *             1.0.10 - 04/08/2007 - G.Juyn                               * */
/* *             - added support for mPNG proposal                          * */
/* *             1.0.10 - 04/12/2007 - G.Juyn                               * */
/* *             - added support for ANG proposal                           * */
/* *                                                                        * */
/* ************************************************************************** */

#include <stddef.h>                    /* needed for offsetof() */

#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_objects.h"
#include "libmng_chunks.h"
#include "libmng_chunk_descr.h"
#include "libmng_object_prc.h"
#include "libmng_chunk_prc.h"
#include "libmng_chunk_io.h"
#include "libmng_display.h"

#ifdef MNG_INCLUDE_ANG_PROPOSAL
#include "libmng_pixels.h"
#include "libmng_filter.h"
#endif

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

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

#ifdef MNG_OPTIMIZE_CHUNKREADER
#if defined(MNG_INCLUDE_READ_PROCS) || defined(MNG_INCLUDE_WRITE_PROCS)

/* ************************************************************************** */
/* ************************************************************************** */
/* PNG chunks */

MNG_LOCAL mng_field_descriptor mng_fields_ihdr [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT,
     1, 0, 4, 4,
     offsetof(mng_ihdr, iWidth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT,
     1, 0, 4, 4,
     offsetof(mng_ihdr, iHeight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 16, 1, 1,
     offsetof(mng_ihdr, iBitdepth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 6, 1, 1,
     offsetof(mng_ihdr, iColortype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_ihdr, iCompression), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_ihdr, iFilter), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_ihdr, iInterlace), MNG_NULL, MNG_NULL}
  };

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

MNG_LOCAL mng_field_descriptor mng_fields_plte [] =
  {
    {mng_debunk_plte,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };

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

MNG_LOCAL mng_field_descriptor mng_fields_idat [] =
  {
    {MNG_NULL,
     MNG_NULL,
     0, 0, 0, 0,
     offsetof(mng_idat, pData), MNG_NULL, offsetof(mng_idat, iDatasize)}
  };

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

MNG_LOCAL mng_field_descriptor mng_fields_trns [] =
  {
    {mng_debunk_trns,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };

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

#ifndef MNG_SKIPCHUNK_gAMA
MNG_LOCAL mng_field_descriptor mng_fields_gama [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_gama, iGamma), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_cHRM
MNG_LOCAL mng_field_descriptor mng_fields_chrm [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iWhitepointx), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iWhitepointy), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iRedx), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iRedy), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iGreeny), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iGreeny), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iBluex), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_chrm, iBluey), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_sRGB
MNG_LOCAL mng_field_descriptor mng_fields_srgb [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 4, 1, 1,
     offsetof(mng_srgb, iRenderingintent), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_iCCP
MNG_LOCAL mng_field_descriptor mng_fields_iccp [] =
  {
    {MNG_NULL,
     MNG_FIELD_TERMINATOR,
     0, 0, 1, 79,
     offsetof(mng_iccp, zName), MNG_NULL, offsetof(mng_iccp, iNamesize)},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_iccp, iCompression), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_DEFLATED,
     0, 0, 0, 0,
     offsetof(mng_iccp, pProfile), MNG_NULL, offsetof(mng_iccp, iProfilesize)}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_tEXt
MNG_LOCAL mng_field_descriptor mng_fields_text [] =
  {
    {MNG_NULL,
     MNG_FIELD_TERMINATOR,
     0, 0, 1, 79,
     offsetof(mng_text, zKeyword), MNG_NULL, offsetof(mng_text, iKeywordsize)},
    {MNG_NULL,
     MNG_NULL,
     0, 0, 0, 0,
     offsetof(mng_text, zText), MNG_NULL, offsetof(mng_text, iTextsize)}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_zTXt
MNG_LOCAL mng_field_descriptor mng_fields_ztxt [] =
  {
    {MNG_NULL,
     MNG_FIELD_TERMINATOR,
     0, 0, 1, 79,
     offsetof(mng_ztxt, zKeyword), MNG_NULL, offsetof(mng_ztxt, iKeywordsize)},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_ztxt, iCompression), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_DEFLATED,
     0, 0, 0, 0,
     offsetof(mng_ztxt, zText), MNG_NULL, offsetof(mng_ztxt, iTextsize)}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_iTXt
MNG_LOCAL mng_field_descriptor mng_fields_itxt [] =
  {
    {MNG_NULL,
     MNG_FIELD_TERMINATOR,
     0, 0, 1, 79,
     offsetof(mng_itxt, zKeyword), MNG_NULL, offsetof(mng_itxt, iKeywordsize)},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_itxt, iCompressionflag), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_itxt, iCompressionmethod), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_TERMINATOR,
     0, 0, 0, 0,
     offsetof(mng_itxt, zLanguage), MNG_NULL, offsetof(mng_itxt, iLanguagesize)},
    {MNG_NULL,
     MNG_FIELD_TERMINATOR,
     0, 0, 0, 0,
     offsetof(mng_itxt, zTranslation), MNG_NULL, offsetof(mng_itxt, iTranslationsize)},
    {mng_deflate_itxt,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_bKGD
MNG_LOCAL mng_field_descriptor mng_fields_bkgd [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_PUTIMGTYPE,
     0, 0, 0, 0,
     offsetof(mng_bkgd, iType), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE3,
     0, 0xFF, 1, 1,
     offsetof(mng_bkgd, iIndex), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE0 | MNG_FIELD_IFIMGTYPE4,
     0, 0xFFFF, 2, 2,
     offsetof(mng_bkgd, iGray), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE6,
     0, 0xFFFF, 2, 2,
     offsetof(mng_bkgd, iRed), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE6,
     0, 0xFFFF, 2, 2,
     offsetof(mng_bkgd, iGreen), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE6,
     0, 0xFFFF, 2, 2,
     offsetof(mng_bkgd, iBlue), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_pHYs
MNG_LOCAL mng_field_descriptor mng_fields_phys [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_phys, iSizex), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_phys, iSizey), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_phys, iUnit), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_sBIT
MNG_LOCAL mng_field_descriptor mng_fields_sbit [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_PUTIMGTYPE,
     0, 0, 0, 0,
     offsetof(mng_sbit, iType), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPES,
     0, 0xFF, 1, 1,
     offsetof(mng_sbit, aBits[0]), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE3 | MNG_FIELD_IFIMGTYPE4 | MNG_FIELD_IFIMGTYPE6,
     0, 0xFF, 1, 1,
     offsetof(mng_sbit, aBits[1]), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE2 | MNG_FIELD_IFIMGTYPE3 | MNG_FIELD_IFIMGTYPE6,
     0, 0xFF, 1, 1,
     offsetof(mng_sbit, aBits[2]), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_IFIMGTYPE6,
     0, 0xFF, 1, 1,
     offsetof(mng_sbit, aBits[3]), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_sPLT
MNG_LOCAL mng_field_descriptor mng_fields_splt [] =
  {
    {MNG_NULL,
     MNG_NULL,
     0, 0, 1, 79,
     offsetof(mng_splt, zName), MNG_NULL, offsetof(mng_splt, iNamesize)},
    {MNG_NULL,
     MNG_FIELD_INT,
     8, 16, 1, 1,
     offsetof(mng_splt, iSampledepth), MNG_NULL, MNG_NULL},
    {mng_splt_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_hIST
MNG_LOCAL mng_field_descriptor mng_fields_hist [] =
  {
    {mng_hist_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_tIME
MNG_LOCAL mng_field_descriptor mng_fields_time [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_time, iYear), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 12, 1, 1,
     offsetof(mng_time, iMonth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 31, 1, 1,
     offsetof(mng_time, iDay), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 24, 1, 1,
     offsetof(mng_time, iHour), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 60, 1, 1,
     offsetof(mng_time, iMinute), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 60, 1, 1,
     offsetof(mng_time, iSecond), MNG_NULL, MNG_NULL}
  };
#endif

/* ************************************************************************** */
/* ************************************************************************** */
/* JNG chunks */

#ifdef MNG_INCLUDE_JNG
MNG_LOCAL mng_field_descriptor mng_fields_jhdr [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT,
     1, 0, 4, 4,
     offsetof(mng_jhdr, iWidth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_NOHIGHBIT,
     1, 0, 4, 4,
     offsetof(mng_jhdr, iHeight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     8, 16, 1, 1,
     offsetof(mng_jhdr, iColortype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     8, 20, 1, 1,
     offsetof(mng_jhdr, iImagesampledepth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     8, 8, 1, 1,
     offsetof(mng_jhdr, iImagecompression), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 8, 1, 1,
     offsetof(mng_jhdr, iImageinterlace), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 16, 1, 1,
     offsetof(mng_jhdr, iAlphasampledepth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 8, 1, 1,
     offsetof(mng_jhdr, iAlphacompression), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_jhdr, iAlphafilter), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_jhdr, iAlphainterlace), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifdef MNG_INCLUDE_JNG
#define mng_fields_jdaa mng_fields_idat
#define mng_fields_jdat mng_fields_idat
#endif

/* ************************************************************************** */
/* ************************************************************************** */
/* MNG chunks */

MNG_LOCAL mng_field_descriptor mng_fields_mhdr [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iWidth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iHeight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iTicks), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iLayercount), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iFramecount), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iPlaytime), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_mhdr, iSimplicity), MNG_NULL, MNG_NULL}
  };

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

#ifndef MNG_SKIPCHUNK_LOOP
MNG_LOCAL mng_field_descriptor mng_fields_loop [] =
  {
    {mng_debunk_loop,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_LOOP
MNG_LOCAL mng_field_descriptor mng_fields_endl [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFF, 1, 1,
     offsetof(mng_endl, iLevel), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_DEFI
MNG_LOCAL mng_field_descriptor mng_fields_defi [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_defi, iObjectid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 0xFF, 1, 1,
     offsetof(mng_defi, iDonotshow), offsetof(mng_defi, bHasdonotshow), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 0xFF, 1, 1,
     offsetof(mng_defi, iConcrete), offsetof(mng_defi, bHasconcrete), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_defi, iXlocation), offsetof(mng_defi, bHasloca), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_defi, iYlocation), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2,
     0, 0, 4, 4,
     offsetof(mng_defi, iLeftcb), offsetof(mng_defi, bHasclip), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2,
     0, 0, 4, 4,
     offsetof(mng_defi, iRightcb), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2,
     0, 0, 4, 4,
     offsetof(mng_defi, iTopcb), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2,
     0, 0, 4, 4,
     offsetof(mng_defi, iBottomcb), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_BASI
MNG_LOCAL mng_field_descriptor mng_fields_basi [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_basi, iWidth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_basi, iHeight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 16, 1, 1,
     offsetof(mng_basi, iBitdepth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 6, 1, 1,
     offsetof(mng_basi, iColortype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_basi, iCompression), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_basi, iFilter), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_basi, iInterlace), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0xFFFF, 2, 2,
     offsetof(mng_basi, iRed), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0xFFFF, 2, 2,
     offsetof(mng_basi, iGreen), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0xFFFF, 2, 2,
     offsetof(mng_basi, iBlue), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 0xFFFF, 2, 2,
     offsetof(mng_basi, iAlpha), offsetof(mng_basi, bHasalpha), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 1, 1, 1,
     offsetof(mng_basi, iViewable), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_CLON
MNG_LOCAL mng_field_descriptor mng_fields_clon [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_clon, iSourceid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_clon, iCloneid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 2, 1, 1,
     offsetof(mng_clon, iClonetype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 1, 1, 1,
     offsetof(mng_clon, iDonotshow), offsetof(mng_clon, bHasdonotshow), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 1, 1, 1,
     offsetof(mng_clon, iConcrete), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 2, 1, 1,
     offsetof(mng_clon, iLocationtype), offsetof(mng_clon, bHasloca), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_clon, iLocationx), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_clon, iLocationy), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_PAST
MNG_LOCAL mng_field_descriptor mng_fields_past [] =
  {
    {mng_debunk_past,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_DISC
MNG_LOCAL mng_field_descriptor mng_fields_disc [] =
  {
    {mng_disc_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_BACK
MNG_LOCAL mng_field_descriptor mng_fields_back [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_back, iRed), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_back, iGreen), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_back, iBlue), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 3, 1, 1,
     offsetof(mng_back, iMandatory), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 0xFFFF, 2, 2,
     offsetof(mng_back, iImageid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 1, 1, 1,
     offsetof(mng_back, iTile), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_FRAM
MNG_LOCAL mng_field_descriptor mng_fields_fram [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 4, 1, 1,
     offsetof(mng_fram, iMode), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_TERMINATOR | MNG_FIELD_OPTIONAL,
     0, 0, 1, 79,
     offsetof(mng_fram, zName), MNG_NULL, offsetof(mng_fram, iNamesize)},
    {mng_fram_remainder,
     MNG_FIELD_OPTIONAL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_MOVE
MNG_LOCAL mng_field_descriptor mng_fields_move [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_move, iFirstid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_move, iLastid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_move, iMovetype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_move, iMovex), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_move, iMovey), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_CLIP
MNG_LOCAL mng_field_descriptor mng_fields_clip [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_clip, iFirstid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_clip, iLastid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_clip, iCliptype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_clip, iClipl), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_clip, iClipr), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_clip, iClipt), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_clip, iClipb), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_SHOW
MNG_LOCAL mng_field_descriptor mng_fields_show [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0xFFFF, 2, 2,
     offsetof(mng_show, iFirstid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     1, 0xFFFF, 2, 2,
     offsetof(mng_show, iLastid), offsetof(mng_show, bHaslastid), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL,
     0, 7, 1, 1,
     offsetof(mng_show, iMode), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_TERM
MNG_LOCAL mng_field_descriptor mng_fields_term [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 3, 1, 1,
     offsetof(mng_term, iTermaction), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 2, 1, 1,
     offsetof(mng_term, iIteraction), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_term, iDelay), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_term, iItermax), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_SAVE
MNG_LOCAL mng_field_descriptor mng_fields_save [] =
  {
    {mng_save_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_SEEK
MNG_LOCAL mng_field_descriptor mng_fields_seek [] =
  {
    {MNG_NULL,
     MNG_NULL,
     0, 0, 1, 79,
     offsetof(mng_seek, zName), MNG_NULL, offsetof(mng_seek, iNamesize)}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_eXPI
MNG_LOCAL mng_field_descriptor mng_fields_expi [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_expi, iSnapshotid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_NULL,
     0, 0, 1, 79,
     offsetof(mng_expi, zName), MNG_NULL, offsetof(mng_expi, iNamesize)}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_fPRI
MNG_LOCAL mng_field_descriptor mng_fields_fpri [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_fpri, iDeltatype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFF, 1, 1,
     offsetof(mng_fpri, iPriority), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_nEED
MNG_LOCAL mng_field_descriptor mng_fields_need [] =
  {
    {MNG_NULL,
     MNG_NULL,
     0, 0, 1, 0,
     offsetof(mng_need, zKeywords), MNG_NULL, offsetof(mng_need, iKeywordssize)}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_pHYg
#define mng_fields_phyg mng_fields_phys
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_field_descriptor mng_fields_dhdr [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_dhdr, iObjectid), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 2, 1, 1,
     offsetof(mng_dhdr, iImagetype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 7, 1, 1,
     offsetof(mng_dhdr, iDeltatype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_dhdr, iBlockwidth), offsetof(mng_dhdr, bHasblocksize), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP1,
     0, 0, 4, 4,
     offsetof(mng_dhdr, iBlockheight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2,
     0, 0, 4, 4,
     offsetof(mng_dhdr, iBlockx), offsetof(mng_dhdr, bHasblockloc), MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT | MNG_FIELD_OPTIONAL | MNG_FIELD_GROUP2,
     0, 0, 4, 4,
     offsetof(mng_dhdr, iBlocky), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_field_descriptor mng_fields_prom [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 14, 1, 1,
     offsetof(mng_prom, iColortype), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 16, 1, 1,
     offsetof(mng_prom, iSampledepth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_prom, iFilltype), MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_field_descriptor mng_fields_pplt [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 5, 1, 1,
     offsetof(mng_pplt, iDeltatype), MNG_NULL, MNG_NULL},
    {mng_pplt_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_field_descriptor mng_fields_drop [] =
  {
    {mng_drop_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DBYK
MNG_LOCAL mng_field_descriptor mng_fields_dbyk [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_dbyk, iChunkname), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_dbyk, iPolarity), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_NULL,
     0, 0, 1, 0,
     offsetof(mng_dbyk, zKeywords), MNG_NULL, offsetof(mng_dbyk, iKeywordssize)}
  };
#endif
#endif

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

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
MNG_LOCAL mng_field_descriptor mng_fields_ordr [] =
  {
    {mng_drop_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif
#endif

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

#ifndef MNG_SKIPCHUNK_MAGN
MNG_LOCAL mng_field_descriptor mng_fields_magn [] =
  {
    {mng_debunk_magn,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_LOCAL mng_field_descriptor mng_fields_mpng [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0, 4, 4,
     offsetof(mng_mpng, iFramewidth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0, 4, 4,
     offsetof(mng_mpng, iFrameheight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0xFFFF, 2, 2,
     offsetof(mng_mpng, iNumplays), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0xFFFF, 2, 2,
     offsetof(mng_mpng, iTickspersec), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 1, 1,
     offsetof(mng_mpng, iCompressionmethod), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_DEFLATED,
     0, 0, 1, 0,
     offsetof(mng_mpng, pFrames), MNG_NULL, offsetof(mng_mpng, iFramessize)}
  };
#endif

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

#ifdef MNG_INCLUDE_ANG_PROPOSAL
MNG_LOCAL mng_field_descriptor mng_fields_ahdr [] =
  {
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0, 4, 4,
     offsetof(mng_ahdr, iNumframes), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_ahdr, iTickspersec), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 0, 4, 4,
     offsetof(mng_ahdr, iNumplays), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0, 4, 4,
     offsetof(mng_ahdr, iTilewidth), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     1, 0, 4, 4,
     offsetof(mng_ahdr, iTileheight), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_ahdr, iInterlace), MNG_NULL, MNG_NULL},
    {MNG_NULL,
     MNG_FIELD_INT,
     0, 1, 1, 1,
     offsetof(mng_ahdr, iStillused), MNG_NULL, MNG_NULL}
  };

MNG_LOCAL mng_field_descriptor mng_fields_adat [] =
  {
    {mng_adat_tiles,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

#ifndef MNG_SKIPCHUNK_evNT
MNG_LOCAL mng_field_descriptor mng_fields_evnt [] =
  {
    {mng_evnt_entries,
     MNG_NULL,
     0, 0, 0, 0,
     MNG_NULL, MNG_NULL, MNG_NULL}
  };
#endif

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

MNG_LOCAL mng_field_descriptor mng_fields_unknown [] =
  {
    {MNG_NULL,
     MNG_NULL,
     0, 0, 1, 0,
     offsetof(mng_unknown_chunk, pData), MNG_NULL, offsetof(mng_unknown_chunk, iDatasize)}
  };

/* ************************************************************************** */
/* ************************************************************************** */
/* PNG chunks */

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ihdr =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_ihdr,
     mng_fields_ihdr, (sizeof(mng_fields_ihdr) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL,
     MNG_NULL,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOJHDR | MNG_DESCR_NOBASI | MNG_DESCR_NOIDAT | MNG_DESCR_NOPLTE};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_plte =
    {mng_it_png, mng_create_none, 0, offsetof(mng_plte, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_plte,
     mng_fields_plte, (sizeof(mng_fields_plte) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_idat =
    {mng_it_png, mng_create_none, 0, offsetof(mng_idat, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_idat,
     mng_fields_idat, (sizeof(mng_fields_idat) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOJSEP};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_iend =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_iend,
     MNG_NULL, 0,
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_GenHDR,
     MNG_NULL};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_trns =
    {mng_it_png, mng_create_none, 0, offsetof(mng_trns, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_trns,
     mng_fields_trns, (sizeof(mng_fields_trns) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};

#ifndef MNG_SKIPCHUNK_gAMA
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_gama =
    {mng_it_png, mng_create_none, 0, offsetof(mng_gama, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_gama,
     mng_fields_gama, (sizeof(mng_fields_gama) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_cHRM
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_chrm =
    {mng_it_png, mng_create_none, 0, offsetof(mng_chrm, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_chrm,
     mng_fields_chrm, (sizeof(mng_fields_chrm) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_sRGB
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_srgb =
    {mng_it_png, mng_create_none, 0, offsetof(mng_srgb, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_srgb,
     mng_fields_srgb, (sizeof(mng_fields_srgb) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_iCCP
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_iccp =
    {mng_it_png, mng_create_none, 0, offsetof(mng_iccp, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_iccp,
     mng_fields_iccp, (sizeof(mng_fields_iccp) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOPLTE | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_tEXt
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_text =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_text,
     mng_fields_text, (sizeof(mng_fields_text) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL,
     MNG_DESCR_GenHDR,
     MNG_NULL};
#endif

#ifndef MNG_SKIPCHUNK_zTXt
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ztxt =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_ztxt,
     mng_fields_ztxt, (sizeof(mng_fields_ztxt) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL,
     MNG_DESCR_GenHDR,
     MNG_NULL};
#endif

#ifndef MNG_SKIPCHUNK_iTXt
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_itxt =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_itxt,
     mng_fields_itxt, (sizeof(mng_fields_itxt) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL,
     MNG_DESCR_GenHDR,
     MNG_NULL};
#endif

#ifndef MNG_SKIPCHUNK_bKGD
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_bkgd =
    {mng_it_png, mng_create_none, 0, offsetof(mng_bkgd, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_bkgd,
     mng_fields_bkgd, (sizeof(mng_fields_bkgd) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_pHYs
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_phys =
    {mng_it_png, mng_create_none, 0, offsetof(mng_phys, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_phys,
     mng_fields_phys, (sizeof(mng_fields_phys) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_sBIT
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_sbit =
    {mng_it_png, mng_create_none, 0, offsetof(mng_sbit, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_sbit,
     mng_fields_sbit, (sizeof(mng_fields_sbit) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_sPLT
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_splt =
    {mng_it_png, mng_create_none, 0, offsetof(mng_splt, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_splt,
     mng_fields_splt, (sizeof(mng_fields_splt) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL | MNG_DESCR_EMPTYEMBED | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_GenHDR,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_hIST
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_hist =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_hist,
     mng_fields_hist, (sizeof(mng_fields_hist) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_GenHDR | MNG_DESCR_PLTE,
     MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT | MNG_DESCR_NOJDAA};
#endif

#ifndef MNG_SKIPCHUNK_tIME
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_time =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_time,
     mng_fields_time, (sizeof(mng_fields_time) / sizeof(mng_field_descriptor)),
     MNG_DESCR_GLOBAL,
     MNG_DESCR_GenHDR,
     MNG_NULL};
#endif

/* ************************************************************************** */
/* JNG chunks */

#ifdef MNG_INCLUDE_JNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jhdr =
    {mng_it_jng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_jhdr,
     mng_fields_jhdr, (sizeof(mng_fields_jhdr) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_NULL,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifdef MNG_INCLUDE_JNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jdaa =
    {mng_it_jng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_jdaa,
     mng_fields_jdaa, (sizeof(mng_fields_jdaa) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_JngHDR,
     MNG_DESCR_NOJSEP};
#endif

#ifdef MNG_INCLUDE_JNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jdat =
    {mng_it_jng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_jdat,
     mng_fields_jdat, (sizeof(mng_fields_jdat) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_JngHDR,
     MNG_NULL};
#endif

#ifdef MNG_INCLUDE_JNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_jsep =
    {mng_it_jng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_jsep,
     MNG_NULL, 0,
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_JngHDR,
     MNG_DESCR_NOJSEP};
#endif

/* ************************************************************************** */
/* MNG chunks */

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_mhdr =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_mhdr,
     mng_fields_mhdr, (sizeof(mng_fields_mhdr) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_NULL,
     MNG_DESCR_NOMHDR | MNG_DESCR_NOIHDR | MNG_DESCR_NOJHDR};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_mend =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_mend,
     MNG_NULL, 0,
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_MHDR,
     MNG_NULL};

#ifndef MNG_SKIPCHUNK_LOOP
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_loop =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_loop,
     mng_fields_loop, (sizeof(mng_fields_loop) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_endl =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_endl,
     mng_fields_endl, (sizeof(mng_fields_endl) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_DEFI
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_defi =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_defi,
     mng_fields_defi, (sizeof(mng_fields_defi) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_BASI
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_basi =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_basi,
     mng_fields_basi, (sizeof(mng_fields_basi) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_CLON
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_clon =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_clon,
     mng_fields_clon, (sizeof(mng_fields_clon) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_PAST
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_past =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_past,
     mng_fields_past, (sizeof(mng_fields_past) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_DISC
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_disc =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_disc,
     mng_fields_disc, (sizeof(mng_fields_disc) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_BACK
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_back =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_back,
     mng_fields_back, (sizeof(mng_fields_back) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_FRAM
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_fram =
    {mng_it_mng, mng_create_none, 0, offsetof(mng_fram, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_fram,
     mng_fields_fram, (sizeof(mng_fields_fram) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_MOVE
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_move =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_move,
     mng_fields_move, (sizeof(mng_fields_move) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_CLIP
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_clip =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_clip,
     mng_fields_clip, (sizeof(mng_fields_clip) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_SHOW
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_show =
    {mng_it_mng, mng_create_none, 0, offsetof(mng_show, bEmpty),
     MNG_NULL, MNG_NULL, mng_special_show,
     mng_fields_show, (sizeof(mng_fields_show) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_TERM
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_term =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_term,
     mng_fields_term, (sizeof(mng_fields_term) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR | MNG_DESCR_NOTERM | MNG_DESCR_NOLOOP};
#endif

#ifndef MNG_SKIPCHUNK_SAVE
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_save =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_save,
     mng_fields_save, (sizeof(mng_fields_save) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOSAVE | MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_SEEK
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_seek =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_seek,
     mng_fields_seek, (sizeof(mng_fields_seek) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYGLOBAL,
     MNG_DESCR_MHDR | MNG_DESCR_SAVE,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_eXPI
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_expi =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_expi,
     mng_fields_expi, (sizeof(mng_fields_expi) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_fPRI
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_fpri =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_fpri,
     mng_fields_fpri, (sizeof(mng_fields_fpri) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_nEED
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_need =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_need,
     mng_fields_need, (sizeof(mng_fields_need) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_pHYg
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_phyg =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_phyg,
     mng_fields_phyg, (sizeof(mng_fields_phyg) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_dhdr =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_dhdr,
     mng_fields_dhdr, (sizeof(mng_fields_dhdr) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_prom =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_prom,
     mng_fields_prom, (sizeof(mng_fields_prom) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ipng =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_ipng,
     MNG_NULL, 0,
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_pplt =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_pplt,
     mng_fields_pplt, (sizeof(mng_fields_pplt) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif

#ifndef MNG_NO_DELTA_PNG
#ifdef MNG_INCLUDE_JNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ijng =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_ijng,
     MNG_NULL, 0,
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif
#endif

#ifndef MNG_NO_DELTA_PNG
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_drop =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_drop,
     mng_fields_drop, (sizeof(mng_fields_drop) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DBYK
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_dbyk =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_dbyk,
     mng_fields_dbyk, (sizeof(mng_fields_dbyk) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif
#endif

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ordr =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_ordr,
     mng_fields_ordr, (sizeof(mng_fields_ordr) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR | MNG_DESCR_DHDR,
     MNG_NULL};
#endif
#endif

#ifndef MNG_SKIPCHUNK_MAGN
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_magn =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_magn,
     mng_fields_magn, (sizeof(mng_fields_magn) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOIHDR | MNG_DESCR_NOBASI | MNG_DESCR_NODHDR | MNG_DESCR_NOJHDR};
#endif

#ifndef MNG_SKIPCHUNK_evNT
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_evnt =
    {mng_it_mng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_evnt,
     mng_fields_evnt, (sizeof(mng_fields_evnt) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_MHDR,
     MNG_DESCR_NOSAVE};
#endif

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_mpng =
    {mng_it_mpng, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_mpng,
     mng_fields_mpng, (sizeof(mng_fields_mpng) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_NULL,
     MNG_DESCR_NOMHDR | MNG_DESCR_NOIDAT | MNG_DESCR_NOJDAT};
#endif

#ifdef MNG_INCLUDE_ANG_PROPOSAL
MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_ahdr =
    {mng_it_ang, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_ahdr,
     mng_fields_ahdr, (sizeof(mng_fields_ahdr) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_IHDR,
     MNG_DESCR_NOMHDR | MNG_DESCR_NOJHDR | MNG_DESCR_NOIDAT};

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_adat =
    {mng_it_ang, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_adat,
     mng_fields_adat, (sizeof(mng_fields_adat) / sizeof(mng_field_descriptor)),
     MNG_NULL,
     MNG_DESCR_IHDR,
     MNG_DESCR_NOMHDR | MNG_DESCR_NOJHDR};
#endif

/* ************************************************************************** */
/* ************************************************************************** */
/* the good ol' unknown babe */

MNG_LOCAL mng_chunk_descriptor mng_chunk_descr_unknown =
    {mng_it_png, mng_create_none, 0, 0,
     MNG_NULL, MNG_NULL, mng_special_unknown,
     mng_fields_unknown, (sizeof(mng_fields_unknown) / sizeof(mng_field_descriptor)),
     MNG_DESCR_EMPTY | MNG_DESCR_EMPTYEMBED,
     MNG_NULL,
     MNG_NULL};

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

MNG_LOCAL mng_chunk_header mng_chunk_unknown =
    {MNG_UINT_HUH, mng_init_general, mng_free_unknown,
     mng_read_general, mng_write_unknown, mng_assign_unknown,
     0, 0, sizeof(mng_unknown_chunk), &mng_chunk_descr_unknown};

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

  /* the table-idea & binary search code was adapted from
     libpng 1.1.0 (pngread.c) */
  /* NOTE1: the table must remain sorted by chunkname, otherwise the binary
     search will break !!! (ps. watch upper-/lower-case chunknames !!) */
  /* NOTE2: the layout must remain equal to the header part of all the
     chunk-structures (yes, that means even the pNext and pPrev fields;
     it's wasting a bit of space, but hey, the code is a lot easier) */

MNG_LOCAL mng_chunk_header mng_chunk_table [] =
  {
#ifndef MNG_SKIPCHUNK_BACK
    {MNG_UINT_BACK, mng_init_general, mng_free_general, mng_read_general, mng_write_back, mng_assign_general, 0, 0, sizeof(mng_back), &mng_chunk_descr_back},
#endif
#ifndef MNG_SKIPCHUNK_BASI
    {MNG_UINT_BASI, mng_init_general, mng_free_general, mng_read_general, mng_write_basi, mng_assign_general, 0, 0, sizeof(mng_basi), &mng_chunk_descr_basi},
#endif
#ifndef MNG_SKIPCHUNK_CLIP
    {MNG_UINT_CLIP, mng_init_general, mng_free_general, mng_read_general, mng_write_clip, mng_assign_general, 0, 0, sizeof(mng_clip), &mng_chunk_descr_clip},
#endif
#ifndef MNG_SKIPCHUNK_CLON
    {MNG_UINT_CLON, mng_init_general, mng_free_general, mng_read_general, mng_write_clon, mng_assign_general, 0, 0, sizeof(mng_clon), &mng_chunk_descr_clon},
#endif
#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DBYK
    {MNG_UINT_DBYK, mng_init_general, mng_free_dbyk,    mng_read_general, mng_write_dbyk, mng_assign_dbyk,    0, 0, sizeof(mng_dbyk), &mng_chunk_descr_dbyk},
#endif
#endif
#ifndef MNG_SKIPCHUNK_DEFI
    {MNG_UINT_DEFI, mng_init_general, mng_free_general, mng_read_general, mng_write_defi, mng_assign_general, 0, 0, sizeof(mng_defi), &mng_chunk_descr_defi},
#endif
#ifndef MNG_NO_DELTA_PNG
    {MNG_UINT_DHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_dhdr, mng_assign_general, 0, 0, sizeof(mng_dhdr), &mng_chunk_descr_dhdr},
#endif
#ifndef MNG_SKIPCHUNK_DISC
    {MNG_UINT_DISC, mng_init_general, mng_free_disc,    mng_read_general, mng_write_disc, mng_assign_disc,    0, 0, sizeof(mng_disc), &mng_chunk_descr_disc},
#endif
#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DROP
    {MNG_UINT_DROP, mng_init_general, mng_free_drop,    mng_read_general, mng_write_drop, mng_assign_drop,    0, 0, sizeof(mng_drop), &mng_chunk_descr_drop},
#endif
#endif
#ifndef MNG_SKIPCHUNK_LOOP
    {MNG_UINT_ENDL, mng_init_general, mng_free_general, mng_read_general, mng_write_endl, mng_assign_general, 0, 0, sizeof(mng_endl), &mng_chunk_descr_endl},
#endif
#ifndef MNG_SKIPCHUNK_FRAM
    {MNG_UINT_FRAM, mng_init_general, mng_free_fram,    mng_read_general, mng_write_fram, mng_assign_fram,    0, 0, sizeof(mng_fram), &mng_chunk_descr_fram},
#endif
    {MNG_UINT_IDAT, mng_init_general, mng_free_idat,    mng_read_general, mng_write_idat, mng_assign_idat,    0, 0, sizeof(mng_idat), &mng_chunk_descr_idat},  /* 12-th element! */
    {MNG_UINT_IEND, mng_init_general, mng_free_general, mng_read_general, mng_write_iend, mng_assign_general, 0, 0, sizeof(mng_iend), &mng_chunk_descr_iend},
    {MNG_UINT_IHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_ihdr, mng_assign_general, 0, 0, sizeof(mng_ihdr), &mng_chunk_descr_ihdr},
#ifndef MNG_NO_DELTA_PNG
#ifdef MNG_INCLUDE_JNG
    {MNG_UINT_IJNG, mng_init_general, mng_free_general, mng_read_general, mng_write_ijng, mng_assign_general, 0, 0, sizeof(mng_ijng), &mng_chunk_descr_ijng},
#endif
    {MNG_UINT_IPNG, mng_init_general, mng_free_general, mng_read_general, mng_write_ipng, mng_assign_general, 0, 0, sizeof(mng_ipng), &mng_chunk_descr_ipng},
#endif
#ifdef MNG_INCLUDE_JNG
    {MNG_UINT_JDAA, mng_init_general, mng_free_jdaa,    mng_read_general, mng_write_jdaa, mng_assign_jdaa,    0, 0, sizeof(mng_jdaa), &mng_chunk_descr_jdaa},
    {MNG_UINT_JDAT, mng_init_general, mng_free_jdat,    mng_read_general, mng_write_jdat, mng_assign_jdat,    0, 0, sizeof(mng_jdat), &mng_chunk_descr_jdat},
    {MNG_UINT_JHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_jhdr, mng_assign_general, 0, 0, sizeof(mng_jhdr), &mng_chunk_descr_jhdr},
    {MNG_UINT_JSEP, mng_init_general, mng_free_general, mng_read_general, mng_write_jsep, mng_assign_general, 0, 0, sizeof(mng_jsep), &mng_chunk_descr_jsep},
    {MNG_UINT_JdAA, mng_init_general, mng_free_jdaa,    mng_read_general, mng_write_jdaa, mng_assign_jdaa,    0, 0, sizeof(mng_jdaa), &mng_chunk_descr_jdaa},
#endif
#ifndef MNG_SKIPCHUNK_LOOP
    {MNG_UINT_LOOP, mng_init_general, mng_free_loop,    mng_read_general, mng_write_loop, mng_assign_loop,    0, 0, sizeof(mng_loop), &mng_chunk_descr_loop},
#endif
#ifndef MNG_SKIPCHUNK_MAGN
    {MNG_UINT_MAGN, mng_init_general, mng_free_general, mng_read_general, mng_write_magn, mng_assign_general, 0, 0, sizeof(mng_magn), &mng_chunk_descr_magn},
#endif
    {MNG_UINT_MEND, mng_init_general, mng_free_general, mng_read_general, mng_write_mend, mng_assign_general, 0, 0, sizeof(mng_mend), &mng_chunk_descr_mend},
    {MNG_UINT_MHDR, mng_init_general, mng_free_general, mng_read_general, mng_write_mhdr, mng_assign_general, 0, 0, sizeof(mng_mhdr), &mng_chunk_descr_mhdr},
#ifndef MNG_SKIPCHUNK_MOVE
    {MNG_UINT_MOVE, mng_init_general, mng_free_general, mng_read_general, mng_write_move, mng_assign_general, 0, 0, sizeof(mng_move), &mng_chunk_descr_move},
#endif
#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
    {MNG_UINT_ORDR, mng_init_general, mng_free_ordr,    mng_read_general, mng_write_ordr, mng_assign_ordr,    0, 0, sizeof(mng_ordr), &mng_chunk_descr_ordr},
#endif
#endif
#ifndef MNG_SKIPCHUNK_PAST
    {MNG_UINT_PAST, mng_init_general, mng_free_past,    mng_read_general, mng_write_past, mng_assign_past,    0, 0, sizeof(mng_past), &mng_chunk_descr_past},
#endif
    {MNG_UINT_PLTE, mng_init_general, mng_free_general, mng_read_general, mng_write_plte, mng_assign_general, 0, 0, sizeof(mng_plte), &mng_chunk_descr_plte},
#ifndef MNG_NO_DELTA_PNG
    {MNG_UINT_PPLT, mng_init_general, mng_free_general, mng_read_general, mng_write_pplt, mng_assign_general, 0, 0, sizeof(mng_pplt), &mng_chunk_descr_pplt},
    {MNG_UINT_PROM, mng_init_general, mng_free_general, mng_read_general, mng_write_prom, mng_assign_general, 0, 0, sizeof(mng_prom), &mng_chunk_descr_prom},
#endif
#ifndef MNG_SKIPCHUNK_SAVE
    {MNG_UINT_SAVE, mng_init_general, mng_free_save,    mng_read_general, mng_write_save, mng_assign_save,    0, 0, sizeof(mng_save), &mng_chunk_descr_save},
#endif
#ifndef MNG_SKIPCHUNK_SEEK
    {MNG_UINT_SEEK, mng_init_general, mng_free_seek,    mng_read_general, mng_write_seek, mng_assign_seek,    0, 0, sizeof(mng_seek), &mng_chunk_descr_seek},
#endif
#ifndef MNG_SKIPCHUNK_SHOW
    {MNG_UINT_SHOW, mng_init_general, mng_free_general, mng_read_general, mng_write_show, mng_assign_general, 0, 0, sizeof(mng_show), &mng_chunk_descr_show},
#endif
#ifndef MNG_SKIPCHUNK_TERM
    {MNG_UINT_TERM, mng_init_general, mng_free_general, mng_read_general, mng_write_term, mng_assign_general, 0, 0, sizeof(mng_term), &mng_chunk_descr_term},
#endif
#ifdef MNG_INCLUDE_ANG_PROPOSAL
    {MNG_UINT_adAT, mng_init_general, mng_free_adat,    mng_read_general, mng_write_adat, mng_assign_adat,    0, 0, sizeof(mng_adat), &mng_chunk_descr_adat},
    {MNG_UINT_ahDR, mng_init_general, mng_free_general, mng_read_general, mng_write_ahdr, mng_assign_ahdr,    0, 0, sizeof(mng_ahdr), &mng_chunk_descr_ahdr},
#endif
#ifndef MNG_SKIPCHUNK_bKGD
    {MNG_UINT_bKGD, mng_init_general, mng_free_general, mng_read_general, mng_write_bkgd, mng_assign_general, 0, 0, sizeof(mng_bkgd), &mng_chunk_descr_bkgd},
#endif
#ifndef MNG_SKIPCHUNK_cHRM
    {MNG_UINT_cHRM, mng_init_general, mng_free_general, mng_read_general, mng_write_chrm, mng_assign_general, 0, 0, sizeof(mng_chrm), &mng_chunk_descr_chrm},
#endif
#ifndef MNG_SKIPCHUNK_eXPI
    {MNG_UINT_eXPI, mng_init_general, mng_free_expi,    mng_read_general, mng_write_expi, mng_assign_expi,    0, 0, sizeof(mng_expi), &mng_chunk_descr_expi},
#endif
#ifndef MNG_SKIPCHUNK_evNT
    {MNG_UINT_evNT, mng_init_general, mng_free_evnt,    mng_read_general, mng_write_evnt, mng_assign_evnt,    0, 0, sizeof(mng_evnt), &mng_chunk_descr_evnt},
#endif
#ifndef MNG_SKIPCHUNK_fPRI
    {MNG_UINT_fPRI, mng_init_general, mng_free_general, mng_read_general, mng_write_fpri, mng_assign_general, 0, 0, sizeof(mng_fpri), &mng_chunk_descr_fpri},
#endif
#ifndef MNG_SKIPCHUNK_gAMA
    {MNG_UINT_gAMA, mng_init_general, mng_free_general, mng_read_general, mng_write_gama, mng_assign_general, 0, 0, sizeof(mng_gama), &mng_chunk_descr_gama},
#endif
#ifndef MNG_SKIPCHUNK_hIST
    {MNG_UINT_hIST, mng_init_general, mng_free_general, mng_read_general, mng_write_hist, mng_assign_general, 0, 0, sizeof(mng_hist), &mng_chunk_descr_hist},
#endif
#ifndef MNG_SKIPCHUNK_iCCP
    {MNG_UINT_iCCP, mng_init_general, mng_free_iccp,    mng_read_general, mng_write_iccp, mng_assign_iccp,    0, 0, sizeof(mng_iccp), &mng_chunk_descr_iccp},
#endif
#ifndef MNG_SKIPCHUNK_iTXt
    {MNG_UINT_iTXt, mng_init_general, mng_free_itxt,    mng_read_general, mng_write_itxt, mng_assign_itxt,    0, 0, sizeof(mng_itxt), &mng_chunk_descr_itxt},
#endif
#ifdef MNG_INCLUDE_MPNG_PROPOSAL
    {MNG_UINT_mpNG, mng_init_general, mng_free_mpng,    mng_read_general, mng_write_mpng, mng_assign_mpng,    0, 0, sizeof(mng_mpng), &mng_chunk_descr_mpng},
#endif
#ifndef MNG_SKIPCHUNK_nEED
    {MNG_UINT_nEED, mng_init_general, mng_free_need,    mng_read_general, mng_write_need, mng_assign_need,    0, 0, sizeof(mng_need), &mng_chunk_descr_need},
#endif
/* TODO:     {MNG_UINT_oFFs, 0, 0, 0, 0, 0, 0},  */
/* TODO:     {MNG_UINT_pCAL, 0, 0, 0, 0, 0, 0},  */
#ifndef MNG_SKIPCHUNK_pHYg
    {MNG_UINT_pHYg, mng_init_general, mng_free_general, mng_read_general, mng_write_phyg, mng_assign_general, 0, 0, sizeof(mng_phyg), &mng_chunk_descr_phyg},
#endif
#ifndef MNG_SKIPCHUNK_pHYs
    {MNG_UINT_pHYs, mng_init_general, mng_free_general, mng_read_general, mng_write_phys, mng_assign_general, 0, 0, sizeof(mng_phys), &mng_chunk_descr_phys},
#endif
#ifndef MNG_SKIPCHUNK_sBIT
    {MNG_UINT_sBIT, mng_init_general, mng_free_general, mng_read_general, mng_write_sbit, mng_assign_general, 0, 0, sizeof(mng_sbit), &mng_chunk_descr_sbit},
#endif
/* TODO:     {MNG_UINT_sCAL, 0, 0, 0, 0, 0, 0},  */
#ifndef MNG_SKIPCHUNK_sPLT
    {MNG_UINT_sPLT, mng_init_general, mng_free_splt,    mng_read_general, mng_write_splt, mng_assign_splt,    0, 0, sizeof(mng_splt), &mng_chunk_descr_splt},
#endif
    {MNG_UINT_sRGB, mng_init_general, mng_free_general, mng_read_general, mng_write_srgb, mng_assign_general, 0, 0, sizeof(mng_srgb), &mng_chunk_descr_srgb},
#ifndef MNG_SKIPCHUNK_tEXt
    {MNG_UINT_tEXt, mng_init_general, mng_free_text,    mng_read_general, mng_write_text, mng_assign_text,    0, 0, sizeof(mng_text), &mng_chunk_descr_text},
#endif
#ifndef MNG_SKIPCHUNK_tIME
    {MNG_UINT_tIME, mng_init_general, mng_free_general, mng_read_general, mng_write_time, mng_assign_general, 0, 0, sizeof(mng_time), &mng_chunk_descr_time},
#endif
    {MNG_UINT_tRNS, mng_init_general, mng_free_general, mng_read_general, mng_write_trns, mng_assign_general, 0, 0, sizeof(mng_trns), &mng_chunk_descr_trns},
#ifndef MNG_SKIPCHUNK_zTXt
    {MNG_UINT_zTXt, mng_init_general, mng_free_ztxt,    mng_read_general, mng_write_ztxt, mng_assign_ztxt,    0, 0, sizeof(mng_ztxt), &mng_chunk_descr_ztxt},
#endif
  };

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

void mng_get_chunkheader (mng_chunkid       iChunkname,
                          mng_chunk_headerp pResult)
{
                                       /* binary search variables */
  mng_int32         iTop, iLower, iUpper, iMiddle;
  mng_chunk_headerp pEntry;            /* pointer to found entry */
                                       /* determine max index of table */
  iTop = (sizeof (mng_chunk_table) / sizeof (mng_chunk_table [0])) - 1;

  /* binary search; with 54 chunks, worst-case is 7 comparisons */
  iLower  = 0;
#ifndef MNG_NO_DELTA_PNG
  iMiddle = 11;                        /* start with the IDAT entry */
#else
  iMiddle = 8;
#endif
  iUpper  = iTop;
  pEntry  = 0;                         /* no goods yet! */

  do                                   /* the binary search itself */
    {
      if (mng_chunk_table [iMiddle].iChunkname < iChunkname)
        iLower = iMiddle + 1;
      else if (mng_chunk_table [iMiddle].iChunkname > iChunkname)
        iUpper = iMiddle - 1;
      else
      {
        pEntry = &mng_chunk_table [iMiddle];
        break;
      }
      iMiddle = (iLower + iUpper) >> 1;
    }
  while (iLower <= iUpper);

  if (!pEntry)                         /* unknown chunk ? */
    pEntry = &mng_chunk_unknown;       /* make it so! */

  MNG_COPY (pResult, pEntry, sizeof(mng_chunk_header));

  return;
}

/* ************************************************************************** */
/* ************************************************************************** */
/* PNG chunks */

MNG_C_SPECIALFUNC (mng_special_ihdr)
{
  pData->bHasIHDR      = MNG_TRUE;     /* indicate IHDR is present */
                                       /* and store interesting fields */
  if ((!pData->bHasDHDR) || (pData->iDeltatype == MNG_DELTATYPE_NOCHANGE))
  {
    pData->iDatawidth  = ((mng_ihdrp)pChunk)->iWidth;
    pData->iDataheight = ((mng_ihdrp)pChunk)->iHeight;
  }

  pData->iBitdepth     = ((mng_ihdrp)pChunk)->iBitdepth;
  pData->iColortype    = ((mng_ihdrp)pChunk)->iColortype;
  pData->iCompression  = ((mng_ihdrp)pChunk)->iCompression;
  pData->iFilter       = ((mng_ihdrp)pChunk)->iFilter;
  pData->iInterlace    = ((mng_ihdrp)pChunk)->iInterlace;

#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
  pData->iPNGmult = 1;
  pData->iPNGdepth = pData->iBitdepth;
#endif

#ifdef MNG_NO_1_2_4BIT_SUPPORT
  if (pData->iBitdepth < 8)
      pData->iBitdepth = 8;
#endif

#ifdef MNG_NO_16BIT_SUPPORT
  if (pData->iBitdepth > 8)
    {
      pData->iBitdepth = 8;
      pData->iPNGmult = 2;
    }
#endif

  if ((pData->iBitdepth !=  8)      /* parameter validity checks */
#ifndef MNG_NO_1_2_4BIT_SUPPORT
      && (pData->iBitdepth !=  1) &&
      (pData->iBitdepth !=  2) &&
      (pData->iBitdepth !=  4)
#endif
#ifndef MNG_NO_16BIT_SUPPORT
      && (pData->iBitdepth != 16)   
#endif
      )
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

  if ((pData->iColortype != MNG_COLORTYPE_GRAY   ) &&
      (pData->iColortype != MNG_COLORTYPE_RGB    ) &&
      (pData->iColortype != MNG_COLORTYPE_INDEXED) &&
      (pData->iColortype != MNG_COLORTYPE_GRAYA  ) &&
      (pData->iColortype != MNG_COLORTYPE_RGBA   )    )
    MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);

  if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

  if (((pData->iColortype == MNG_COLORTYPE_RGB    ) ||
       (pData->iColortype == MNG_COLORTYPE_GRAYA  ) ||
       (pData->iColortype == MNG_COLORTYPE_RGBA   )    ) &&
      (pData->iBitdepth < 8                            )    )
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

  if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
    MNG_ERROR (pData, MNG_INVALIDCOMPRESS);

#if defined(FILTER192) || defined(FILTER193)
  if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
#if defined(FILTER192) && defined(FILTER193)
      (pData->iFilter != MNG_FILTER_DIFFERING) &&
      (pData->iFilter != MNG_FILTER_NOFILTER )    )
#else
#ifdef FILTER192
      (pData->iFilter != MNG_FILTER_DIFFERING)    )
#else
      (pData->iFilter != MNG_FILTER_NOFILTER )    )
#endif
#endif
    MNG_ERROR (pData, MNG_INVALIDFILTER);
#else
  if (pData->iFilter)
    MNG_ERROR (pData, MNG_INVALIDFILTER);
#endif

  if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
      (pData->iInterlace != MNG_INTERLACE_ADAM7)    )
    MNG_ERROR (pData, MNG_INVALIDINTERLACE);

#ifdef MNG_SUPPORT_DISPLAY 
#ifndef MNG_NO_DELTA_PNG
  if (pData->bHasDHDR)                 /* check the colortype for delta-images ! */
  {
    mng_imagedatap pBuf = ((mng_imagep)pData->pObjzero)->pImgbuf;

    if (pData->iColortype != pBuf->iColortype)
    {
      if ( ( (pData->iColortype != MNG_COLORTYPE_INDEXED) ||
             (pBuf->iColortype  == MNG_COLORTYPE_GRAY   )    ) &&
           ( (pData->iColortype != MNG_COLORTYPE_GRAY   ) ||
             (pBuf->iColortype  == MNG_COLORTYPE_INDEXED)    )    )
        MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
    }
  }
#endif
#endif

  if (!pData->bHasheader)              /* first chunk ? */
  {
    pData->bHasheader = MNG_TRUE;      /* we've got a header */
    pData->eImagetype = mng_it_png;    /* then this must be a PNG */
    pData->iWidth     = pData->iDatawidth;
    pData->iHeight    = pData->iDataheight;
                                       /* predict alpha-depth ! */
    if ((pData->iColortype == MNG_COLORTYPE_GRAYA  ) ||
        (pData->iColortype == MNG_COLORTYPE_RGBA   )    )
      pData->iAlphadepth = pData->iBitdepth;
    else
    if (pData->iColortype == MNG_COLORTYPE_INDEXED)
      pData->iAlphadepth = 8;          /* worst case scenario */
    else
      pData->iAlphadepth = 1;  /* Possible tRNS cheap binary transparency */
                                       /* fits on maximum canvas ? */
    if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
      MNG_WARNING (pData, MNG_IMAGETOOLARGE);

#if !defined(MNG_INCLUDE_MPNG_PROPOSAL) || !defined(MNG_SUPPORT_DISPLAY)
    if (pData->fProcessheader)         /* inform the app ? */
      if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
        MNG_ERROR (pData, MNG_APPMISCERROR);
#endif
  }

  if (!pData->bHasDHDR)
    pData->iImagelevel++;              /* one level deeper */

#ifdef MNG_SUPPORT_DISPLAY
  return mng_process_display_ihdr (pData);
#else
  return MNG_NOERROR;                 
#endif /* MNG_SUPPORT_DISPLAY */
}

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

MNG_F_SPECIALFUNC (mng_debunk_plte)
{
  mng_pltep  pPLTE    = (mng_pltep)pChunk;
  mng_uint32 iRawlen  = *piRawlen;
  mng_uint8p pRawdata = *ppRawdata;
                                       /* length must be multiple of 3 */
  if (((iRawlen % 3) != 0) || (iRawlen > 768))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);
                                       /* this is the exact length */
  pPLTE->iEntrycount = iRawlen / 3;

  MNG_COPY (pPLTE->aEntries, pRawdata, iRawlen);

  *piRawlen = 0;

  return MNG_NOERROR;
}

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

MNG_C_SPECIALFUNC (mng_special_plte)
{                                      /* multiple PLTE only inside BASI */
  if ((pData->bHasPLTE) && (!pData->bHasBASI))
    MNG_ERROR (pData, MNG_MULTIPLEERROR);

  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
  {                                    /* only allowed for indexed-color or
                                          rgb(a)-color! */
    if ((pData->iColortype != MNG_COLORTYPE_RGB    ) &&
        (pData->iColortype != MNG_COLORTYPE_INDEXED) &&
        (pData->iColortype != MNG_COLORTYPE_RGBA   )   )
      MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
                                       /* empty only allowed if global present */
    if ((((mng_pltep)pChunk)->bEmpty) && (!pData->bHasglobalPLTE))
      MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
  }
  else
  {
    if (((mng_pltep)pChunk)->bEmpty)   /* cannot be empty as global! */
      MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
  }

  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
    pData->bHasPLTE = MNG_TRUE;        /* got it! */
  else
    pData->bHasglobalPLTE = MNG_TRUE;

  pData->iPLTEcount = ((mng_pltep)pChunk)->iEntrycount;

#ifdef MNG_SUPPORT_DISPLAY
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
  {
    mng_imagep     pImage;
    mng_imagedatap pBuf;

#ifndef MNG_NO_DELTA_PNG
    if (pData->bHasDHDR)               /* processing delta-image ? */
    {                                  /* store in object 0 !!! */
      pImage           = (mng_imagep)pData->pObjzero;
      pBuf             = pImage->pImgbuf;
      pBuf->bHasPLTE   = MNG_TRUE;     /* it's definitely got a PLTE now */
      pBuf->iPLTEcount = ((mng_pltep)pChunk)->iEntrycount;
      MNG_COPY (pBuf->aPLTEentries, ((mng_pltep)pChunk)->aEntries,
                sizeof (pBuf->aPLTEentries));
    }
    else
#endif
    {                                  /* get the current object */
      pImage = (mng_imagep)pData->pCurrentobj;
      if (!pImage)                     /* no object then dump it in obj 0 */
        pImage = (mng_imagep)pData->pObjzero;

      pBuf = pImage->pImgbuf;          /* address the object buffer */
      pBuf->bHasPLTE = MNG_TRUE;       /* and tell it it's got a PLTE now */

      if (((mng_pltep)pChunk)->bEmpty) /* if empty, inherit from global */
      {
        pBuf->iPLTEcount = pData->iGlobalPLTEcount;
        MNG_COPY (pBuf->aPLTEentries, pData->aGlobalPLTEentries,
                  sizeof (pBuf->aPLTEentries));

        if (pData->bHasglobalTRNS)     /* also copy global tRNS ? */
        {
          mng_uint32 iRawlen2  = pData->iGlobalTRNSrawlen;
          mng_uint8p pRawdata2 = (mng_uint8p)(pData->aGlobalTRNSrawdata);
                                       /* indicate tRNS available */
          pBuf->bHasTRNS = MNG_TRUE;
                                       /* global length oke ? */
          if ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount))
            MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
                                       /* copy it */
          pBuf->iTRNScount = iRawlen2;
          MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2);
        }
      }
      else
      {                                /* store fields for future reference */
        pBuf->iPLTEcount = ((mng_pltep)pChunk)->iEntrycount;
        MNG_COPY (pBuf->aPLTEentries, ((mng_pltep)pChunk)->aEntries,
                  sizeof (pBuf->aPLTEentries));
      }
    }
  }
  else                                 /* store as global */
  {
    pData->iGlobalPLTEcount = ((mng_pltep)pChunk)->iEntrycount;
    MNG_COPY (pData->aGlobalPLTEentries, ((mng_pltep)pChunk)->aEntries,
              sizeof (pData->aGlobalPLTEentries));
                                       /* create an animation object */
    return mng_create_ani_plte (pData);
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}

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

MNG_C_SPECIALFUNC (mng_special_idat)
{
#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasJHDR) &&
      (pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE))
    MNG_ERROR (pData, MNG_SEQUENCEERROR);
#endif
                                       /* not allowed for deltatype NO_CHANGE */
#ifndef MNG_NO_DELTA_PNG
  if ((pData->bHasDHDR) && ((pData->iDeltatype == MNG_DELTATYPE_NOCHANGE)))
    MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
#endif
                                       /* can only be empty in BASI-block! */
  if ((((mng_idatp)pChunk)->bEmpty) && (!pData->bHasBASI))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);
                                       /* indexed-color requires PLTE */
  if ((pData->bHasIHDR) && (pData->iColortype == 3) && (!pData->bHasPLTE))
    MNG_ERROR (pData, MNG_PLTEMISSING);

  pData->bHasIDAT = MNG_TRUE;          /* got some IDAT now, don't we */

  return MNG_NOERROR;                  /* done */
}

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

MNG_C_SPECIALFUNC (mng_special_iend)
{                                      /* IHDR-block requires IDAT */
  if ((pData->bHasIHDR) && (!pData->bHasIDAT))
    MNG_ERROR (pData, MNG_IDATMISSING);

  pData->iImagelevel--;                /* one level up */

#ifdef MNG_SUPPORT_DISPLAY
  {                                    /* create an animation object */
    mng_retcode iRetcode = mng_create_ani_image (pData);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
                                       /* display processing */
    iRetcode = mng_process_display_iend (pData);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
  }
#endif /* MNG_SUPPORT_DISPLAY */

#ifdef MNG_SUPPORT_DISPLAY
  if (!pData->bTimerset)               /* reset only if not broken !!! */
  {
#endif
                                       /* IEND signals the end for most ... */
    pData->bHasIHDR         = MNG_FALSE;
    pData->bHasBASI         = MNG_FALSE;
    pData->bHasDHDR         = MNG_FALSE;
#ifdef MNG_INCLUDE_JNG
    pData->bHasJHDR         = MNG_FALSE;
    pData->bHasJSEP         = MNG_FALSE;
    pData->bHasJDAA         = MNG_FALSE;
    pData->bHasJDAT         = MNG_FALSE;
#endif
    pData->bHasPLTE         = MNG_FALSE;
    pData->bHasTRNS         = MNG_FALSE;
    pData->bHasGAMA         = MNG_FALSE;
    pData->bHasCHRM         = MNG_FALSE;
    pData->bHasSRGB         = MNG_FALSE;
    pData->bHasICCP         = MNG_FALSE;
    pData->bHasBKGD         = MNG_FALSE;
    pData->bHasIDAT         = MNG_FALSE;
#ifdef MNG_SUPPORT_DISPLAY
  }
#endif

  return MNG_NOERROR;                  /* done */
}

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

MNG_F_SPECIALFUNC (mng_debunk_trns)
{
  mng_trnsp  pTRNS    = (mng_trnsp)pChunk;
  mng_uint32 iRawlen  = *piRawlen;
  mng_uint8p pRawdata = *ppRawdata;

  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
  {                                  /* not global! */
    pTRNS->bGlobal = MNG_FALSE;
    pTRNS->iType   = pData->iColortype;

    if (iRawlen != 0)
    {
      switch (pData->iColortype)     /* store fields */
      {
        case 0: {                    /* gray */
                  if (iRawlen != 2)
                    MNG_ERROR (pData, MNG_INVALIDLENGTH);
                  pTRNS->iGray  = mng_get_uint16 (pRawdata);
                  break;
                }
        case 2: {                    /* rgb */
                  if (iRawlen != 6)
                    MNG_ERROR (pData, MNG_INVALIDLENGTH);
                  pTRNS->iRed   = mng_get_uint16 (pRawdata);
                  pTRNS->iGreen = mng_get_uint16 (pRawdata+2);
                  pTRNS->iBlue  = mng_get_uint16 (pRawdata+4);
                  break;
                }
        case 3: {                    /* indexed */
                  if (iRawlen > 256)
                    MNG_ERROR (pData, MNG_INVALIDLENGTH);
                  pTRNS->iCount = iRawlen;
                  MNG_COPY (pTRNS->aEntries, pRawdata, iRawlen);
                  break;
                }
      }
    }
  }
  else                               /* it's global! */
  {
    if (iRawlen == 0)
      MNG_ERROR (pData, MNG_INVALIDLENGTH);
    pTRNS->bGlobal = MNG_TRUE;
    pTRNS->iType   = 0;
    pTRNS->iRawlen = iRawlen;
    MNG_COPY (pTRNS->aRawdata, pRawdata, iRawlen);

    pData->iGlobalTRNSrawlen = iRawlen;
    MNG_COPY (pData->aGlobalTRNSrawdata, pRawdata, iRawlen);
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}

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

MNG_C_SPECIALFUNC (mng_special_trns)
{                                      /* multiple tRNS only inside BASI */
  if ((pData->bHasTRNS) && (!pData->bHasBASI))
    MNG_ERROR (pData, MNG_MULTIPLEERROR);

  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
  {                                    /* not allowed with full alpha-channel */
    if ((pData->iColortype == 4) || (pData->iColortype == 6))
      MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);

    if (!((mng_trnsp)pChunk)->bEmpty)  /* filled ? */
    {                                
#ifdef MNG_SUPPORT_DISPLAY
      if (pData->iColortype == 3)
      {
        mng_imagep     pImage = (mng_imagep)pData->pCurrentobj;
        mng_imagedatap pBuf;

        if (!pImage)                   /* no object then check obj 0 */
          pImage = (mng_imagep)pData->pObjzero;

        pBuf = pImage->pImgbuf;        /* address object buffer */

        if (((mng_trnsp)pChunk)->iCount > pBuf->iPLTEcount)
          MNG_ERROR (pData, MNG_INVALIDLENGTH);
      }
#endif
    }
    else                               /* if empty there must be global stuff! */
    {
      if (!pData->bHasglobalTRNS)
        MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
    }
  }

  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
    pData->bHasTRNS = MNG_TRUE;        /* indicate tRNS available */
  else
    pData->bHasglobalTRNS = MNG_TRUE;

#ifdef MNG_SUPPORT_DISPLAY
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
  {
    mng_imagep     pImage;
    mng_imagedatap pBuf;
    mng_uint8p     pRawdata2;
    mng_uint32     iRawlen2;

#ifndef MNG_NO_DELTA_PNG
    if (pData->bHasDHDR)               /* processing delta-image ? */
    {                                  /* store in object 0 !!! */
#if defined(MNG_NO_1_2_4BIT_SUPPORT)
      mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1,0,0,0,0,0,0,0,1};
#endif
      pImage = (mng_imagep)pData->pObjzero;
      pBuf   = pImage->pImgbuf;        /* address object buffer */
      pBuf->bHasTRNS   = MNG_TRUE;     /* tell it it's got a tRNS now */
      pBuf->iTRNSgray  = 0;
      pBuf->iTRNSred   = 0;
      pBuf->iTRNSgreen = 0;
      pBuf->iTRNSblue  = 0;
      pBuf->iTRNScount = 0;

      switch (pData->iColortype)       /* store fields for future reference */
      {
        case 0: {                      /* gray */
                  pBuf->iTRNSgray  = ((mng_trnsp)pChunk)->iGray;
#if defined(MNG_NO_1_2_4BIT_SUPPORT)
                  pBuf->iTRNSgray *= multiplier[pData->iPNGdepth];
#endif
#if defined(MNG_NO_16BIT_SUPPORT)
                  if (pData->iPNGmult == 2)
                     pBuf->iTRNSgray >>= 8;
#endif
                  break;
                }
        case 2: {                      /* rgb */
                  pBuf->iTRNSred   = ((mng_trnsp)pChunk)->iRed;
                  pBuf->iTRNSgreen = ((mng_trnsp)pChunk)->iGreen;
                  pBuf->iTRNSblue  = ((mng_trnsp)pChunk)->iBlue;
#if defined(MNG_NO_16BIT_SUPPORT)
                  if (pData->iPNGmult == 2)
                  {
                     pBuf->iTRNSred   >>= 8;
                     pBuf->iTRNSgreen >>= 8;
                     pBuf->iTRNSblue  >>= 8;
                  }
#endif
                  break;
                }
        case 3: {                      /* indexed */
                  pBuf->iTRNScount = ((mng_trnsp)pChunk)->iCount;
                  MNG_COPY (pBuf->aTRNSentries,
                            ((mng_trnsp)pChunk)->aEntries,
                            ((mng_trnsp)pChunk)->iCount);
                  break;
                }
      }
    }
    else
#endif
    {                                  /* address current object */
      pImage = (mng_imagep)pData->pCurrentobj;

      if (!pImage)                     /* no object then dump it in obj 0 */
        pImage = (mng_imagep)pData->pObjzero;

      pBuf = pImage->pImgbuf;          /* address object buffer */
      pBuf->bHasTRNS   = MNG_TRUE;     /* and tell it it's got a tRNS now */
      pBuf->iTRNSgray  = 0;
      pBuf->iTRNSred   = 0;
      pBuf->iTRNSgreen = 0;
      pBuf->iTRNSblue  = 0;
      pBuf->iTRNScount = 0;

      if (((mng_trnsp)pChunk)->bEmpty) /* if empty, inherit from global */
      {
        iRawlen2  = pData->iGlobalTRNSrawlen;
        pRawdata2 = (mng_ptr)(pData->aGlobalTRNSrawdata);
                                       /* global length oke ? */
        if ((pData->iColortype == 0) && (iRawlen2 != 2))
          MNG_ERROR (pData, MNG_GLOBALLENGTHERR);

        if ((pData->iColortype == 2) && (iRawlen2 != 6))
          MNG_ERROR (pData, MNG_GLOBALLENGTHERR);

        if ((pData->iColortype == 3) && ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount)))
          MNG_ERROR (pData, MNG_GLOBALLENGTHERR);

        switch (pData->iColortype)     /* store fields for future reference */
        {
          case 0: {                    /* gray */
                    pBuf->iTRNSgray = mng_get_uint16 (pRawdata2);
#if defined(MNG_NO_16BIT_SUPPORT)
                    if (pData->iPNGmult == 2)
                       pBuf->iTRNSgray >>= 8;
#endif
                    break;
                  }
          case 2: {                    /* rgb */
                    pBuf->iTRNSred   = mng_get_uint16 (pRawdata2);
                    pBuf->iTRNSgreen = mng_get_uint16 (pRawdata2+2);
                    pBuf->iTRNSblue  = mng_get_uint16 (pRawdata2+4);
#if defined(MNG_NO_16BIT_SUPPORT)
                    if (pData->iPNGmult == 2)
                    {
                       pBuf->iTRNSred   >>= 8;
                       pBuf->iTRNSgreen >>= 8;
                       pBuf->iTRNSblue  >>= 8;
                    }
#endif
                    break;
                  }
          case 3: {                    /* indexed */
                    pBuf->iTRNScount = iRawlen2;
                    MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2);
                    break;
                  }
        }
      }
      else
      {
        switch (pData->iColortype)     /* store fields for future reference */
        {
          case 0: {                    /* gray */
                    pBuf->iTRNSgray = ((mng_trnsp)pChunk)->iGray;
#if defined(MNG_NO_16BIT_SUPPORT)
                    if (pData->iPNGmult == 2)
                       pBuf->iTRNSgray >>= 8;
#endif
                    break;
                  }
          case 2: {                    /* rgb */
                    pBuf->iTRNSred   = ((mng_trnsp)pChunk)->iRed;
                    pBuf->iTRNSgreen = ((mng_trnsp)pChunk)->iGreen;
                    pBuf->iTRNSblue  = ((mng_trnsp)pChunk)->iBlue;
#if defined(MNG_NO_16BIT_SUPPORT)
                    if (pData->iPNGmult == 2)
                    {
                       pBuf->iTRNSred   >>= 8;
                       pBuf->iTRNSgreen >>= 8;
                       pBuf->iTRNSblue  >>= 8;
                    }
#endif
                    break;
                  }
          case 3: {                    /* indexed */
                    pBuf->iTRNScount = ((mng_trnsp)pChunk)->iCount;
                    MNG_COPY (pBuf->aTRNSentries,
                              ((mng_trnsp)pChunk)->aEntries,
                              ((mng_trnsp)pChunk)->iCount);
                    break;
                  }
        }
      }
    }
  }
  else
  {                                    /* create an animation object */
    return mng_create_ani_trns (pData);
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}

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

MNG_C_SPECIALFUNC (mng_special_gama)
{
#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
    pData->bHasGAMA = MNG_TRUE;        /* indicate we've got it */
  else
    pData->bHasglobalGAMA = (mng_bool)!((mng_gamap)pChunk)->bEmpty;

#ifdef MNG_SUPPORT_DISPLAY
#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
  {
    mng_imagep pImage;

#ifndef MNG_NO_DELTA_PNG
    if (pData->bHasDHDR)               /* update delta image ? */
      pImage = (mng_imagep)pData->pObjzero;
    else
#endif
    {
      pImage = (mng_imagep)pData->pCurrentobj;
      if (!pImage)                     /* no object then dump it in obj 0 */
        pImage = (mng_imagep)pData->pObjzero;
    }
                                       /* store for color-processing routines */
    pImage->pImgbuf->iGamma   = ((mng_gamap)pChunk)->iGamma;
    pImage->pImgbuf->bHasGAMA = MNG_TRUE;
  }
  else
  {                                    /* store as global */
    if (!((mng_gamap)pChunk)->bEmpty)
      pData->iGlobalGamma = ((mng_gamap)pChunk)->iGamma;
                                       /* create an animation object */
    return mng_create_ani_gama (pData, pChunk);
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}

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

#ifndef MNG_SKIPCHUNK_cHRM
MNG_C_SPECIALFUNC (mng_special_chrm)
{
#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
    pData->bHasCHRM = MNG_TRUE;        /* indicate we've got it */
  else
    pData->bHasglobalCHRM = (mng_bool)!((mng_chrmp)pChunk)->bEmpty;

#ifdef MNG_SUPPORT_DISPLAY
  {
#ifdef MNG_INCLUDE_JNG
    if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
    if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
    {
      mng_imagep     pImage;
      mng_imagedatap pBuf;

#ifndef MNG_NO_DELTA_PNG
      if (pData->bHasDHDR)             /* update delta image ? */
        pImage = (mng_imagep)pData->pObjzero;
      else
#endif
      {
        pImage = (mng_imagep)pData->pCurrentobj;
        if (!pImage)                   /* no object then dump it in obj 0 */
          pImage = (mng_imagep)pData->pObjzero;
      }

      pBuf = pImage->pImgbuf;          /* address object buffer */
      pBuf->bHasCHRM = MNG_TRUE;       /* and tell it it's got a CHRM now */
                                       /* store for color-processing routines */
      pBuf->iWhitepointx   = ((mng_chrmp)pChunk)->iWhitepointx;
      pBuf->iWhitepointy   = ((mng_chrmp)pChunk)->iWhitepointy;
      pBuf->iPrimaryredx   = ((mng_chrmp)pChunk)->iRedx;
      pBuf->iPrimaryredy   = ((mng_chrmp)pChunk)->iRedy;
      pBuf->iPrimarygreenx = ((mng_chrmp)pChunk)->iGreenx;
      pBuf->iPrimarygreeny = ((mng_chrmp)pChunk)->iGreeny;
      pBuf->iPrimarybluex  = ((mng_chrmp)pChunk)->iBluex;
      pBuf->iPrimarybluey  = ((mng_chrmp)pChunk)->iBluey;
    }
    else
    {                                  /* store as global */
      if (!((mng_chrmp)pChunk)->bEmpty)
      {
        pData->iGlobalWhitepointx   = ((mng_chrmp)pChunk)->iWhitepointx;
        pData->iGlobalWhitepointy   = ((mng_chrmp)pChunk)->iWhitepointy;
        pData->iGlobalPrimaryredx   = ((mng_chrmp)pChunk)->iRedx;
        pData->iGlobalPrimaryredy   = ((mng_chrmp)pChunk)->iRedy;
        pData->iGlobalPrimarygreenx = ((mng_chrmp)pChunk)->iGreenx;
        pData->iGlobalPrimarygreeny = ((mng_chrmp)pChunk)->iGreeny;
        pData->iGlobalPrimarybluex  = ((mng_chrmp)pChunk)->iBluex;
        pData->iGlobalPrimarybluey  = ((mng_chrmp)pChunk)->iBluey;
      }
                                       /* create an animation object */
      return mng_create_ani_chrm (pData, pChunk);
    }
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

MNG_C_SPECIALFUNC (mng_special_srgb)
{
#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
    pData->bHasSRGB = MNG_TRUE;        /* indicate we've got it */
  else
    pData->bHasglobalSRGB = (mng_bool)!((mng_srgbp)pChunk)->bEmpty;

#ifdef MNG_SUPPORT_DISPLAY
#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
  {
    mng_imagep pImage;

#ifndef MNG_NO_DELTA_PNG
    if (pData->bHasDHDR)               /* update delta image ? */
      pImage = (mng_imagep)pData->pObjzero;
    else
#endif
    {
      pImage = (mng_imagep)pData->pCurrentobj;
      if (!pImage)                     /* no object then dump it in obj 0 */
        pImage = (mng_imagep)pData->pObjzero;
    }
                                       /* store for color-processing routines */
    pImage->pImgbuf->iRenderingintent = ((mng_srgbp)pChunk)->iRenderingintent;
    pImage->pImgbuf->bHasSRGB         = MNG_TRUE;
  }
  else
  {                                    /* store as global */
    if (!((mng_srgbp)pChunk)->bEmpty)
      pData->iGlobalRendintent = ((mng_srgbp)pChunk)->iRenderingintent;
                                       /* create an animation object */
    return mng_create_ani_srgb (pData, pChunk);
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}

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

#ifndef MNG_SKIPCHUNK_iCCP
MNG_C_SPECIALFUNC (mng_special_iccp)
{
  mng_retcode       iRetcode;
  mng_chunk_headerp pDummy;

#ifdef MNG_CHECK_BAD_ICCP              /* Check for bad iCCP chunk */
  if (!strncmp (((mng_iccpp)pChunk)->zName, "Photoshop ICC profile", 21))
  {
    if (((mng_iccpp)pChunk)->iProfilesize == 2615) /* is it the sRGB profile ? */
    {
      mng_chunk_header chunk_srgb;
      mng_get_chunkheader (MNG_UINT_sRGB, &chunk_srgb);
                                       /* pretend it's an sRGB chunk then ! */
      iRetcode = mng_read_general (pData, &chunk_srgb, 1, (mng_ptr)"0", &pDummy);
      if (iRetcode)                    /* on error bail out */
        return iRetcode;

      pDummy->fCleanup (pData, pDummy);  
    }
  }
  else
  {
#endif /* MNG_CHECK_BAD_ICCP */

#ifdef MNG_INCLUDE_JNG
    if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
    if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
      pData->bHasICCP = MNG_TRUE;      /* indicate we've got it */
    else
      pData->bHasglobalICCP = (mng_bool)!((mng_iccpp)pChunk)->bEmpty;

#ifdef MNG_SUPPORT_DISPLAY
#ifdef MNG_INCLUDE_JNG
    if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
    if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
    {
      mng_imagep pImage;

#ifndef MNG_NO_DELTA_PNG
      if (pData->bHasDHDR)             /* update delta image ? */
      {                                /* store in object 0 ! */
        pImage = (mng_imagep)pData->pObjzero;

        if (pImage->pImgbuf->pProfile) /* profile existed ? */
          MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize);
                                       /* allocate a buffer & copy it */
        MNG_ALLOC (pData, pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->iProfilesize);
        MNG_COPY  (pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->pProfile, ((mng_iccpp)pChunk)->iProfilesize);
                                       /* store its length as well */
        pImage->pImgbuf->iProfilesize = ((mng_iccpp)pChunk)->iProfilesize;
        pImage->pImgbuf->bHasICCP     = MNG_TRUE;
      }
      else
#endif
      {
        pImage = (mng_imagep)pData->pCurrentobj;

        if (!pImage)                   /* no object then dump it in obj 0 */
          pImage = (mng_imagep)pData->pObjzero;

        if (pImage->pImgbuf->pProfile) /* profile existed ? */
          MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize);
                                       /* allocate a buffer & copy it */
        MNG_ALLOC (pData, pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->iProfilesize);
        MNG_COPY  (pImage->pImgbuf->pProfile, ((mng_iccpp)pChunk)->pProfile, ((mng_iccpp)pChunk)->iProfilesize);
                                       /* store its length as well */
        pImage->pImgbuf->iProfilesize = ((mng_iccpp)pChunk)->iProfilesize;
        pImage->pImgbuf->bHasICCP     = MNG_TRUE;
      }
    }
    else
    {                                  /* store as global */
      if (pData->pGlobalProfile)     /* did we have a global profile ? */
        MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize);

      if (((mng_iccpp)pChunk)->bEmpty) /* empty chunk ? */
      {
        pData->iGlobalProfilesize = 0; /* reset to null */
        pData->pGlobalProfile     = MNG_NULL;
      }
      else
      {                                /* allocate a global buffer & copy it */
        MNG_ALLOC (pData, pData->pGlobalProfile, ((mng_iccpp)pChunk)->iProfilesize);
        MNG_COPY  (pData->pGlobalProfile, ((mng_iccpp)pChunk)->pProfile, ((mng_iccpp)pChunk)->iProfilesize);
                                       /* store its length as well */
        pData->iGlobalProfilesize = ((mng_iccpp)pChunk)->iProfilesize;
      }
                                       /* create an animation object */
      return mng_create_ani_iccp (pData, pChunk);
    }
#endif /* MNG_SUPPORT_DISPLAY */

#ifdef MNG_CHECK_BAD_ICCP
  }
#endif

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_tEXt
MNG_C_SPECIALFUNC (mng_special_text)
{
  if (pData->fProcesstext)             /* inform the application ? */
  {
    mng_bool bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_TEXT,
                                         ((mng_textp)pChunk)->zKeyword,
                                         ((mng_textp)pChunk)->zText, 0, 0);
    if (!bOke)
      MNG_ERROR (pData, MNG_APPMISCERROR);
  }

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_zTXt
MNG_C_SPECIALFUNC (mng_special_ztxt)
{
  if (pData->fProcesstext)             /* inform the application ? */
  {
    mng_bool bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ZTXT,
                                         ((mng_ztxtp)pChunk)->zKeyword,
                                         ((mng_ztxtp)pChunk)->zText, 0, 0);
    if (!bOke)
      MNG_ERROR (pData, MNG_APPMISCERROR);
  }

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_iTXt
MNG_F_SPECIALFUNC (mng_deflate_itxt)
{
  mng_itxtp  pITXT    = (mng_itxtp)pChunk;
  mng_uint32 iBufsize = 0;
  mng_uint8p pBuf     = 0;
  mng_uint32 iTextlen = 0;

  if (pITXT->iCompressionflag)         /* decompress the text ? */
  {
    mng_retcode iRetcode = mng_inflate_buffer (pData, *ppRawdata, *piRawlen,
                                               &pBuf, &iBufsize, &iTextlen);

    if (iRetcode)                      /* on error bail out */
    {                                  /* don't forget to drop the temp buffer */
      MNG_FREEX (pData, pBuf, iBufsize);
      return iRetcode;
    }

    MNG_ALLOC (pData, pITXT->zText, iTextlen+1);
    MNG_COPY (pITXT->zText, pBuf, iTextlen);

    pITXT->iTextsize = iTextlen;

    MNG_FREEX (pData, pBuf, iBufsize);

  } else {

    MNG_ALLOC (pData, pITXT->zText, (*piRawlen)+1);
    MNG_COPY (pITXT->zText, *ppRawdata, *piRawlen);

    pITXT->iTextsize = *piRawlen;
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_iTXt
MNG_C_SPECIALFUNC (mng_special_itxt)
{
  if (pData->fProcesstext)             /* inform the application ? */
  {
    mng_bool bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ITXT,
                                         ((mng_itxtp)pChunk)->zKeyword,
                                         ((mng_itxtp)pChunk)->zText,
                                         ((mng_itxtp)pChunk)->zLanguage,
                                         ((mng_itxtp)pChunk)->zTranslation);
    if (!bOke)
      MNG_ERROR (pData, MNG_APPMISCERROR);
  }

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_bKGD
MNG_C_SPECIALFUNC (mng_special_bkgd)
{
#ifdef MNG_SUPPORT_DISPLAY
  mng_imagep     pImage = (mng_imagep)pData->pCurrentobj;
  mng_imagedatap pBuf;
#endif

#ifdef MNG_INCLUDE_JNG
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
#else
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
#endif
    pData->bHasBKGD = MNG_TRUE;        /* indicate bKGD available */
  else
    pData->bHasglobalBKGD = (mng_bool)!(((mng_bkgdp)pChunk)->bEmpty);

#ifdef MNG_SUPPORT_DISPLAY
  if (!pImage)                         /* if no object dump it in obj 0 */
    pImage = (mng_imagep)pData->pObjzero;
  pBuf = pImage->pImgbuf;              /* address object buffer */

#ifdef MNG_INCLUDE_JNG
  if (pData->bHasJHDR)
  {
    pBuf->bHasBKGD = MNG_TRUE;         /* tell the object it's got bKGD now */

    switch (pData->iJHDRcolortype)     /* store fields for future reference */
    {
      case  8 : ;                      /* gray */
      case 12 : {                      /* graya */
                  pBuf->iBKGDgray  = ((mng_bkgdp)pChunk)->iGray;
                  break;
                }
      case 10 : ;                      /* rgb */
      case 14 : {                      /* rgba */
                  pBuf->iBKGDred   = ((mng_bkgdp)pChunk)->iRed;
                  pBuf->iBKGDgreen = ((mng_bkgdp)pChunk)->iGreen;
                  pBuf->iBKGDblue  = ((mng_bkgdp)pChunk)->iBlue;
                  break;
                }
    }
  }
  else
#endif /* MNG_INCLUDE_JNG */
  if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
  {
    pBuf->bHasBKGD = MNG_TRUE;         /* tell the object it's got bKGD now */

    switch (pData->iColortype)         /* store fields for future reference */
    {
      case 0 : ;                        /* gray */
      case 4 : {                        /* graya */
                 pBuf->iBKGDgray  = ((mng_bkgdp)pChunk)->iGray;
                 break;
               }
      case 2 : ;                        /* rgb */
      case 6 : {                        /* rgba */
                 pBuf->iBKGDred   = ((mng_bkgdp)pChunk)->iRed;
                 pBuf->iBKGDgreen = ((mng_bkgdp)pChunk)->iGreen;
                 pBuf->iBKGDblue  = ((mng_bkgdp)pChunk)->iBlue;
                 break;
               }
      case 3 : {                        /* indexed */
                 pBuf->iBKGDindex = ((mng_bkgdp)pChunk)->iIndex;
                 break;
               }
    }
  }
  else                                 /* store as global */
  {
    if (!(((mng_bkgdp)pChunk)->bEmpty))
    {
      pData->iGlobalBKGDred   = ((mng_bkgdp)pChunk)->iRed;
      pData->iGlobalBKGDgreen = ((mng_bkgdp)pChunk)->iGreen;
      pData->iGlobalBKGDblue  = ((mng_bkgdp)pChunk)->iBlue;
    }
                                       /* create an animation object */
    return mng_create_ani_bkgd (pData);
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_pHYs
MNG_C_SPECIALFUNC (mng_special_phys)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_sBIT
MNG_C_SPECIALFUNC (mng_special_sbit)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_sPLT
MNG_F_SPECIALFUNC (mng_splt_entries)
{
  mng_spltp  pSPLT    = (mng_spltp)pChunk;
  mng_uint32 iRawlen  = *piRawlen;
  mng_uint8p pRawdata = *ppRawdata;

  if ((pSPLT->iSampledepth != MNG_BITDEPTH_8 ) &&
      (pSPLT->iSampledepth != MNG_BITDEPTH_16)   )
    MNG_ERROR (pData, MNG_INVSAMPLEDEPTH);
                                       /* check remaining length */
  if ( ((pSPLT->iSampledepth == MNG_BITDEPTH_8 ) && (iRawlen %  6 != 0)) ||
       ((pSPLT->iSampledepth == MNG_BITDEPTH_16) && (iRawlen % 10 != 0))    )
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  if (pSPLT->iSampledepth == MNG_BITDEPTH_8)
    pSPLT->iEntrycount = iRawlen / 6;
  else
    pSPLT->iEntrycount = iRawlen / 10;

  if (iRawlen)
  {
    MNG_ALLOC (pData, pSPLT->pEntries, iRawlen);
    MNG_COPY (pSPLT->pEntries, pRawdata, iRawlen);
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_sPLT
MNG_C_SPECIALFUNC (mng_special_splt)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_hIST
MNG_F_SPECIALFUNC (mng_hist_entries)
{
  mng_histp  pHIST    = (mng_histp)pChunk;
  mng_uint32 iRawlen  = *piRawlen;
  mng_uint8p pRawdata = *ppRawdata;
  mng_uint32 iX;

  if ( ((iRawlen & 0x01) != 0) || ((iRawlen >> 1) != pData->iPLTEcount) )
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  pHIST->iEntrycount = iRawlen >> 1;

  for (iX = 0; iX < pHIST->iEntrycount; iX++)
  {
    pHIST->aEntries[iX] = mng_get_uint16 (pRawdata);
    pRawdata += 2;
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_hIST
MNG_C_SPECIALFUNC (mng_special_hist)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_tIME
MNG_C_SPECIALFUNC (mng_special_time)
{
/*  if (pData->fProcesstime) */            /* inform the application ? */
/*  {

    pData->fProcesstime ((mng_handle)pData, );
  } */

  return MNG_NOERROR;                  /* done */
}
#endif

/* ************************************************************************** */
/* ************************************************************************** */
/* JNG chunks */

#ifdef MNG_INCLUDE_JNG
MNG_C_SPECIALFUNC (mng_special_jhdr)
{
  if ((pData->eSigtype == mng_it_jng) && (pData->iChunkseq > 1))
    MNG_ERROR (pData, MNG_SEQUENCEERROR);
                                       /* inside a JHDR-IEND block now */
  pData->bHasJHDR              = MNG_TRUE;
                                       /* and store interesting fields */
  pData->iDatawidth            = ((mng_jhdrp)pChunk)->iWidth;
  pData->iDataheight           = ((mng_jhdrp)pChunk)->iHeight;
  pData->iJHDRcolortype        = ((mng_jhdrp)pChunk)->iColortype;
  pData->iJHDRimgbitdepth      = ((mng_jhdrp)pChunk)->iImagesampledepth;
  pData->iJHDRimgcompression   = ((mng_jhdrp)pChunk)->iImagecompression;
  pData->iJHDRimginterlace     = ((mng_jhdrp)pChunk)->iImageinterlace;
  pData->iJHDRalphabitdepth    = ((mng_jhdrp)pChunk)->iAlphasampledepth;
  pData->iJHDRalphacompression = ((mng_jhdrp)pChunk)->iAlphacompression;
  pData->iJHDRalphafilter      = ((mng_jhdrp)pChunk)->iAlphafilter;
  pData->iJHDRalphainterlace   = ((mng_jhdrp)pChunk)->iAlphainterlace;

#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
  pData->iPNGmult = 1;
  pData->iPNGdepth = pData->iJHDRalphabitdepth;
#endif

#ifdef MNG_NO_1_2_4BIT_SUPPORT
  if (pData->iJHDRalphabitdepth < 8)
    pData->iJHDRalphabitdepth = 8;
#endif

#ifdef MNG_NO_16BIT_SUPPORT
  if (pData->iJHDRalphabitdepth > 8)
  {
    pData->iPNGmult = 2;
    pData->iJHDRalphabitdepth = 8;
  }
#endif
                                       /* parameter validity checks */
  if ((pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAY  ) &&
      (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLOR ) &&
      (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAYA ) &&
      (pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLORA)    )
    MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);

  if ((pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8     ) &&
      (pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG12    ) &&
      (pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8AND12)    )
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

  if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
      (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA)    )
  {
    if ((pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 )
#ifndef MNG_NO_1_2_4BIT_SUPPORT
        && (pData->iJHDRalphabitdepth != MNG_BITDEPTH_1 ) &&
        (pData->iJHDRalphabitdepth != MNG_BITDEPTH_2 ) &&
        (pData->iJHDRalphabitdepth != MNG_BITDEPTH_4 )
#endif
#ifndef MNG_NO_16BIT_SUPPORT
        && (pData->iJHDRalphabitdepth != MNG_BITDEPTH_16)
#endif
        )
      MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

    if ((pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE     ) &&
        (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG)    )
      MNG_ERROR (pData, MNG_INVALIDCOMPRESS);

    if ((pData->iJHDRalphacompression == MNG_COMPRESSION_BASELINEJPEG) &&
        (pData->iJHDRalphabitdepth    !=  MNG_BITDEPTH_8             )    )
      MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

#if defined(FILTER192) || defined(FILTER193)
    if ((pData->iJHDRalphafilter != MNG_FILTER_ADAPTIVE ) &&
#if defined(FILTER192) && defined(FILTER193)
        (pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) &&
        (pData->iJHDRalphafilter != MNG_FILTER_NOFILTER )    )
#else
#ifdef FILTER192
        (pData->iJHDRalphafilter != MNG_FILTER_DIFFERING)    )
#else
        (pData->iJHDRalphafilter != MNG_FILTER_NOFILTER )    )
#endif
#endif
      MNG_ERROR (pData, MNG_INVALIDFILTER);
#else
    if (pData->iJHDRalphafilter)
      MNG_ERROR (pData, MNG_INVALIDFILTER);
#endif

  }
  else
  {
    if (pData->iJHDRalphabitdepth)
      MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
    if (pData->iJHDRalphacompression)
      MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
    if (pData->iJHDRalphafilter)
      MNG_ERROR (pData, MNG_INVALIDFILTER);
    if (pData->iJHDRalphainterlace)
      MNG_ERROR (pData, MNG_INVALIDINTERLACE);
  }

  if (!pData->bHasheader)              /* first chunk ? */
  {
    pData->bHasheader = MNG_TRUE;      /* we've got a header */
    pData->eImagetype = mng_it_jng;    /* then this must be a JNG */
    pData->iWidth     = ((mng_jhdrp)pChunk)->iWidth;
    pData->iHeight    = ((mng_jhdrp)pChunk)->iHeight;
                                       /* predict alpha-depth ! */
    if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
        (pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA)    )
      pData->iAlphadepth = pData->iJHDRalphabitdepth;
    else
      pData->iAlphadepth = 0;
                                       /* fits on maximum canvas ? */
    if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
      MNG_WARNING (pData, MNG_IMAGETOOLARGE);

    if (pData->fProcessheader)         /* inform the app ? */
      if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
        MNG_ERROR (pData, MNG_APPMISCERROR);

  }

  pData->iColortype = 0;               /* fake grayscale for other routines */
  pData->iImagelevel++;                /* one level deeper */

#ifdef MNG_SUPPORT_DISPLAY
  {
    mng_retcode iRetcode = mng_process_display_jhdr (pData);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
  }
#endif /* MNG_SUPPORT_DISPLAY */

#ifdef MNG_NO_16BIT_SUPPORT
  if (((mng_jhdrp)pChunk)->iAlphasampledepth > 8)
    ((mng_jhdrp)pChunk)->iAlphasampledepth = 8;
#endif

  return MNG_NOERROR;                  /* done */
}
#endif /* MNG_INCLUDE_JNG */

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

#ifdef MNG_INCLUDE_JNG
MNG_C_SPECIALFUNC (mng_special_jdaa)
{
  if (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG)
    MNG_ERROR (pData, MNG_SEQUENCEERROR);

  pData->bHasJDAA = MNG_TRUE;          /* got some JDAA now, don't we */
  return MNG_NOERROR;
}
#endif /* MNG_INCLUDE_JNG */

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

#ifdef MNG_INCLUDE_JNG
MNG_C_SPECIALFUNC (mng_special_jdat)
{
  pData->bHasJDAT = MNG_TRUE;          /* got some JDAT now, don't we */
  return MNG_NOERROR;
}
#endif /* MNG_INCLUDE_JNG */

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

#ifdef MNG_INCLUDE_JNG
MNG_C_SPECIALFUNC (mng_special_jsep)
{
  pData->bHasJSEP = MNG_TRUE;          /* indicate we've had the 8-/12-bit separator */
  return MNG_NOERROR;
}
#endif /* MNG_INCLUDE_JNG */

/* ************************************************************************** */
/* ************************************************************************** */
/* MNG chunks */

MNG_C_SPECIALFUNC (mng_special_mhdr)
{
  if (pData->bHasheader)               /* can only be the first chunk! */
    MNG_ERROR (pData, MNG_SEQUENCEERROR);

  pData->bHasMHDR     = MNG_TRUE;      /* oh boy, a real MNG */
  pData->bHasheader   = MNG_TRUE;      /* we've got a header */
  pData->eImagetype   = mng_it_mng;    /* fill header fields */
  pData->iWidth       = ((mng_mhdrp)pChunk)->iWidth;
  pData->iHeight      = ((mng_mhdrp)pChunk)->iHeight;
  pData->iTicks       = ((mng_mhdrp)pChunk)->iTicks;
  pData->iLayercount  = ((mng_mhdrp)pChunk)->iLayercount;
  pData->iFramecount  = ((mng_mhdrp)pChunk)->iFramecount;
  pData->iPlaytime    = ((mng_mhdrp)pChunk)->iPlaytime;
  pData->iSimplicity  = ((mng_mhdrp)pChunk)->iSimplicity;
#ifndef MNG_NO_OLD_VERSIONS
  pData->bPreDraft48  = MNG_FALSE;
#endif
                                       /* predict alpha-depth */
  if ((pData->iSimplicity & 0x00000001) == 0)
#ifndef MNG_NO_16BIT_SUPPORT
    pData->iAlphadepth = 16;           /* no indicators = assume the worst */
#else
    pData->iAlphadepth = 8;            /* anything else = assume the worst */
#endif
  else
  if ((pData->iSimplicity & 0x00000008) == 0)
    pData->iAlphadepth = 0;            /* no transparency at all */
  else
  if ((pData->iSimplicity & 0x00000140) == 0x00000040)
    pData->iAlphadepth = 1;            /* no semi-transparency guaranteed */
  else
#ifndef MNG_NO_16BIT_SUPPORT
    pData->iAlphadepth = 16;           /* anything else = assume the worst */
#else
    pData->iAlphadepth = 8;            /* anything else = assume the worst */
#endif

#ifdef MNG_INCLUDE_JNG                 /* can we handle the complexity ? */
  if (pData->iSimplicity & 0x0000FC00)
#else
  if (pData->iSimplicity & 0x0000FC10)
#endif
    MNG_ERROR (pData, MNG_MNGTOOCOMPLEX);
                                       /* fits on maximum canvas ? */
  if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
    MNG_WARNING (pData, MNG_IMAGETOOLARGE);

  if (pData->fProcessheader)           /* inform the app ? */
    if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
      MNG_ERROR (pData, MNG_APPMISCERROR);

  pData->iImagelevel++;                /* one level deeper */

  return MNG_NOERROR;                  /* done */
}

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

MNG_C_SPECIALFUNC (mng_special_mend)
{
#ifdef MNG_SUPPORT_DISPLAY
  {                                    /* do something */
    mng_retcode iRetcode = mng_process_display_mend (pData);

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

    if (!pData->iTotalframes)          /* save totals */
      pData->iTotalframes   = pData->iFrameseq;
    if (!pData->iTotallayers)
      pData->iTotallayers   = pData->iLayerseq;
    if (!pData->iTotalplaytime)
      pData->iTotalplaytime = pData->iFrametime;
  }
#endif /* MNG_SUPPORT_DISPLAY */

  pData->bHasMHDR = MNG_FALSE;         /* end of the line, bro! */

  return MNG_NOERROR;                  /* done */
}

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

#ifndef MNG_SKIPCHUNK_LOOP
MNG_F_SPECIALFUNC (mng_debunk_loop)
{
  mng_loopp  pLOOP    = (mng_loopp)pChunk;
  mng_uint32 iRawlen  = *piRawlen;
  mng_uint8p pRawdata = *ppRawdata;

  if (iRawlen >= 5)                    /* length checks */
  {
    if (iRawlen >= 6)
    {
      if ((iRawlen - 6) % 4 != 0)
        MNG_ERROR (pData, MNG_INVALIDLENGTH);
    }
  }
  else
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  if (iRawlen >= 5)                  /* store the fields */
  {
    pLOOP->iLevel  = *pRawdata;

#ifndef MNG_NO_OLD_VERSIONS
    if (pData->bPreDraft48)
    {
      pLOOP->iTermination = *(pRawdata+1);
      pLOOP->iRepeat = mng_get_uint32 (pRawdata+2);
    }
    else
#endif
    {
      pLOOP->iRepeat = mng_get_uint32 (pRawdata+1);
    }

    if (iRawlen >= 6)
    {
#ifndef MNG_NO_OLD_VERSIONS
      if (!pData->bPreDraft48)
#endif
        pLOOP->iTermination = *(pRawdata+5);

      if (iRawlen >= 10)
      {
        pLOOP->iItermin = mng_get_uint32 (pRawdata+6);

#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
        if (iRawlen >= 14)
        {
          pLOOP->iItermax = mng_get_uint32 (pRawdata+10);
          pLOOP->iCount   = (iRawlen - 14) / 4;

          if (pLOOP->iCount)
          {
            MNG_ALLOC (pData, pLOOP->pSignals, pLOOP->iCount << 2);

#ifndef MNG_BIGENDIAN_SUPPORTED
            {
              mng_uint32  iX;
              mng_uint8p  pIn  = pRawdata + 14;
              mng_uint32p pOut = (mng_uint32p)pLOOP->pSignals;

              for (iX = 0; iX < pLOOP->iCount; iX++)
              {
                *pOut++ = mng_get_uint32 (pIn);
                pIn += 4;
              }
            }
#else
            MNG_COPY (pLOOP->pSignals, pRawdata + 14, pLOOP->iCount << 2);
#endif /* !MNG_BIGENDIAN_SUPPORTED */
          }
        }
#endif
      }
    }
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_LOOP
MNG_C_SPECIALFUNC (mng_special_loop)
{
  if (!pData->bCacheplayback)          /* must store playback info to work!! */
    MNG_ERROR (pData, MNG_LOOPWITHCACHEOFF);

#ifdef MNG_SUPPORT_DISPLAY
  {
    mng_retcode iRetcode;

    pData->bHasLOOP = MNG_TRUE;        /* indicate we're inside a loop */
                                       /* create the LOOP ani-object */
    iRetcode = mng_create_ani_loop (pData, pChunk);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
                                       /* skip till matching ENDL if iteration=0 */
    if ((!pData->bSkipping) && (((mng_loopp)pChunk)->iRepeat == 0))
      pData->bSkipping = MNG_TRUE;
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_LOOP
MNG_C_SPECIALFUNC (mng_special_endl)
{
#ifdef MNG_SUPPORT_DISPLAY
  if (pData->bHasLOOP)                 /* are we really processing a loop ? */
  {
    mng_uint8 iLevel = ((mng_endlp)pChunk)->iLevel;
                                       /* create an ENDL animation object */
    return mng_create_ani_endl (pData, iLevel);
  }
  else
    MNG_ERROR (pData, MNG_NOMATCHINGLOOP);
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_DEFI
MNG_C_SPECIALFUNC (mng_special_defi)
{
#ifdef MNG_SUPPORT_DISPLAY
  mng_retcode iRetcode;

  pData->iDEFIobjectid     = ((mng_defip)pChunk)->iObjectid;
  pData->bDEFIhasdonotshow = ((mng_defip)pChunk)->bHasdonotshow;
  pData->iDEFIdonotshow    = ((mng_defip)pChunk)->iDonotshow;
  pData->bDEFIhasconcrete  = ((mng_defip)pChunk)->bHasconcrete;
  pData->iDEFIconcrete     = ((mng_defip)pChunk)->iConcrete;
  pData->bDEFIhasloca      = ((mng_defip)pChunk)->bHasloca;
  pData->iDEFIlocax        = ((mng_defip)pChunk)->iXlocation;
  pData->iDEFIlocay        = ((mng_defip)pChunk)->iYlocation;
  pData->bDEFIhasclip      = ((mng_defip)pChunk)->bHasclip;
  pData->iDEFIclipl        = ((mng_defip)pChunk)->iLeftcb;
  pData->iDEFIclipr        = ((mng_defip)pChunk)->iRightcb;
  pData->iDEFIclipt        = ((mng_defip)pChunk)->iTopcb;
  pData->iDEFIclipb        = ((mng_defip)pChunk)->iBottomcb;
                                       /* create an animation object */
  iRetcode = mng_create_ani_defi (pData);
  if (!iRetcode)                       /* do display processing */
    iRetcode = mng_process_display_defi (pData);
  return iRetcode;
#else
  return MNG_NOERROR;                  /* done */
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_BASI
MNG_C_SPECIALFUNC (mng_special_basi)
{
  pData->bHasBASI     = MNG_TRUE;      /* inside a BASI-IEND block now */
                                       /* store interesting fields */
  pData->iDatawidth   = ((mng_basip)pChunk)->iWidth;
  pData->iDataheight  = ((mng_basip)pChunk)->iHeight;
  pData->iBitdepth    = ((mng_basip)pChunk)->iBitdepth;   
  pData->iColortype   = ((mng_basip)pChunk)->iColortype;
  pData->iCompression = ((mng_basip)pChunk)->iCompression;
  pData->iFilter      = ((mng_basip)pChunk)->iFilter;
  pData->iInterlace   = ((mng_basip)pChunk)->iInterlace;

#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
  pData->iPNGmult = 1;
  pData->iPNGdepth = pData->iBitdepth;
#endif

#ifdef MNG_NO_1_2_4BIT_SUPPORT
  if (pData->iBitdepth < 8)
    pData->iBitdepth = 8;
#endif
#ifdef MNG_NO_16BIT_SUPPORT
  if (pData->iBitdepth > 8)
    {
      pData->iBitdepth = 8;
      pData->iPNGmult = 2;
    }
#endif

  if ((pData->iBitdepth !=  8)      /* parameter validity checks */
#ifndef MNG_NO_1_2_4BIT_SUPPORT
      && (pData->iBitdepth !=  1) &&
      (pData->iBitdepth !=  2) &&
      (pData->iBitdepth !=  4)
#endif
#ifndef MNG_NO_16BIT_SUPPORT
      && (pData->iBitdepth != 16)
#endif
      )
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

  if ((pData->iColortype != MNG_COLORTYPE_GRAY   ) &&
      (pData->iColortype != MNG_COLORTYPE_RGB    ) &&
      (pData->iColortype != MNG_COLORTYPE_INDEXED) &&
      (pData->iColortype != MNG_COLORTYPE_GRAYA  ) &&
      (pData->iColortype != MNG_COLORTYPE_RGBA   )    )
    MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);

  if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

  if (((pData->iColortype == MNG_COLORTYPE_RGB    ) ||
       (pData->iColortype == MNG_COLORTYPE_GRAYA  ) ||
       (pData->iColortype == MNG_COLORTYPE_RGBA   )    ) &&
      (pData->iBitdepth < 8                            )    )
    MNG_ERROR (pData, MNG_INVALIDBITDEPTH);

#if defined(FILTER192) || defined(FILTER193)
  if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
#if defined(FILTER192) && defined(FILTER193)
      (pData->iFilter != MNG_FILTER_DIFFERING) &&
      (pData->iFilter != MNG_FILTER_NOFILTER )    )
#else
#ifdef FILTER192
      (pData->iFilter != MNG_FILTER_DIFFERING)    )
#else
      (pData->iFilter != MNG_FILTER_NOFILTER )    )
#endif
#endif
    MNG_ERROR (pData, MNG_INVALIDFILTER);
#else
  if (pData->iFilter)
    MNG_ERROR (pData, MNG_INVALIDFILTER);
#endif

  pData->iImagelevel++;                /* one level deeper */

#ifdef MNG_SUPPORT_DISPLAY
  {                                    /* create an animation object */
    mng_retcode iRetcode = mng_create_ani_basi (pData, pChunk);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
  }
#endif /* MNG_SUPPORT_DISPLAY */

#ifdef MNG_NO_16BIT_SUPPORT
  if (((mng_basip)pChunk)->iBitdepth > 8)
    ((mng_basip)pChunk)->iBitdepth = 8;
#endif

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_CLON
MNG_C_SPECIALFUNC (mng_special_clon)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_clon (pData, pChunk);
#else
  return MNG_NOERROR;                  /* done */
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_PAST
MNG_F_SPECIALFUNC (mng_debunk_past)
{
  mng_pastp        pPAST    = (mng_pastp)pChunk;
  mng_uint32       iRawlen  = *piRawlen;
  mng_uint8p       pRawdata = *ppRawdata;
  mng_uint32       iSize;
  mng_uint32       iX;
  mng_past_sourcep pSource;
                                       /* check the length */
  if ((iRawlen < 41) || (((iRawlen - 11) % 30) != 0))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  pPAST->iDestid     = mng_get_uint16 (pRawdata);
  pPAST->iTargettype = *(pRawdata+2);
  pPAST->iTargetx    = mng_get_int32  (pRawdata+3);
  pPAST->iTargety    = mng_get_int32  (pRawdata+7);
  pPAST->iCount      = ((iRawlen - 11) / 30); /* how many entries again? */
  iSize              = pPAST->iCount * sizeof (mng_past_source);

  pRawdata += 11;
                                       /* get a buffer for all the source blocks */
  MNG_ALLOC (pData, pPAST->pSources, iSize);

  pSource = (mng_past_sourcep)(pPAST->pSources);

  for (iX = pPAST->iCount; iX > 0; iX--)
  {                                    /* now copy the source blocks */
    pSource->iSourceid     = mng_get_uint16 (pRawdata);
    pSource->iComposition  = *(pRawdata+2);
    pSource->iOrientation  = *(pRawdata+3);
    pSource->iOffsettype   = *(pRawdata+4);
    pSource->iOffsetx      = mng_get_int32 (pRawdata+5);
    pSource->iOffsety      = mng_get_int32 (pRawdata+9);
    pSource->iBoundarytype = *(pRawdata+13);
    pSource->iBoundaryl    = mng_get_int32 (pRawdata+14);
    pSource->iBoundaryr    = mng_get_int32 (pRawdata+18);
    pSource->iBoundaryt    = mng_get_int32 (pRawdata+22);
    pSource->iBoundaryb    = mng_get_int32 (pRawdata+26);

    pSource++;
    pRawdata += 30;
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_PAST
MNG_C_SPECIALFUNC (mng_special_past)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_past (pData, pChunk);
#else
  return MNG_NOERROR;
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_DISC
MNG_F_SPECIALFUNC (mng_disc_entries)
{
  mng_discp   pDISC    = (mng_discp)pChunk;
  mng_uint32  iRawlen  = *piRawlen;
  mng_uint8p  pRawdata = *ppRawdata;

  if ((iRawlen % 2) != 0)              /* check the length */
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  pDISC->iCount = (iRawlen / sizeof (mng_uint16));

  if (pDISC->iCount)
  {
    MNG_ALLOC (pData, pDISC->pObjectids, iRawlen);

#ifndef MNG_BIGENDIAN_SUPPORTED
    {
      mng_uint32  iX;
      mng_uint8p  pIn  = pRawdata;
      mng_uint16p pOut = pDISC->pObjectids;

      for (iX = pDISC->iCount; iX > 0; iX--)
      {
        *pOut++ = mng_get_uint16 (pIn);
        pIn += 2;
      }
    }
#else
    MNG_COPY (pDISC->pObjectids, pRawdata, iRawlen);
#endif /* !MNG_BIGENDIAN_SUPPORTED */
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_DISC
MNG_C_SPECIALFUNC (mng_special_disc)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_disc (pData, pChunk);
#else
  return MNG_NOERROR;                  
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_BACK
MNG_C_SPECIALFUNC (mng_special_back)
{
#ifdef MNG_SUPPORT_DISPLAY
                                       /* retrieve the fields */
  pData->bHasBACK       = MNG_TRUE;
  pData->iBACKred       = ((mng_backp)pChunk)->iRed;
  pData->iBACKgreen     = ((mng_backp)pChunk)->iGreen;
  pData->iBACKblue      = ((mng_backp)pChunk)->iBlue;
  pData->iBACKmandatory = ((mng_backp)pChunk)->iMandatory;
  pData->iBACKimageid   = ((mng_backp)pChunk)->iImageid;
  pData->iBACKtile      = ((mng_backp)pChunk)->iTile;

  return mng_create_ani_back (pData);
#else
  return MNG_NOERROR;
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_FRAM
MNG_F_SPECIALFUNC (mng_fram_remainder)
{
  mng_framp  pFRAM     = (mng_framp)pChunk;
  mng_uint32 iRawlen   = *piRawlen;
  mng_uint8p pRawdata  = *ppRawdata;
  mng_uint32 iRequired = 0;

  if (iRawlen < 4)                     /* must have at least 4 bytes */
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  iRequired = 4;                       /* calculate and check required remaining length */

  pFRAM->iChangedelay    = *pRawdata;
  pFRAM->iChangetimeout  = *(pRawdata+1);
  pFRAM->iChangeclipping = *(pRawdata+2);
  pFRAM->iChangesyncid   = *(pRawdata+3);

  if (pFRAM->iChangedelay   ) { iRequired +=  4; }
  if (pFRAM->iChangetimeout ) { iRequired +=  4; }
  if (pFRAM->iChangeclipping) { iRequired += 17; }

  if (pFRAM->iChangesyncid)
  {
    if ((iRawlen - iRequired) % 4 != 0)
      MNG_ERROR (pData, MNG_INVALIDLENGTH);
  }
  else
  {
    if (iRawlen != iRequired)
      MNG_ERROR (pData, MNG_INVALIDLENGTH);
  }

  pRawdata += 4;

  if (pFRAM->iChangedelay)              /* delay changed ? */
  {
    pFRAM->iDelay = mng_get_uint32 (pRawdata);
    pRawdata += 4;
  }

  if (pFRAM->iChangetimeout)            /* timeout changed ? */
  {
    pFRAM->iTimeout = mng_get_uint32 (pRawdata);
    pRawdata += 4;
  }

  if (pFRAM->iChangeclipping)           /* clipping changed ? */
  {
    pFRAM->iBoundarytype = *pRawdata;
    pFRAM->iBoundaryl    = mng_get_int32 (pRawdata+1);
    pFRAM->iBoundaryr    = mng_get_int32 (pRawdata+5);
    pFRAM->iBoundaryt    = mng_get_int32 (pRawdata+9);
    pFRAM->iBoundaryb    = mng_get_int32 (pRawdata+13);
    pRawdata += 17;
  }

  if (pFRAM->iChangesyncid)
  {
    pFRAM->iCount    = (iRawlen - iRequired) / 4;

    if (pFRAM->iCount)
    {
      MNG_ALLOC (pData, pFRAM->pSyncids, pFRAM->iCount * 4);

#ifndef MNG_BIGENDIAN_SUPPORTED
      {
        mng_uint32 iX;
        mng_uint32p pOut = pFRAM->pSyncids;

        for (iX = pFRAM->iCount; iX > 0; iX--)
        {
          *pOut++ = mng_get_uint32 (pRawdata);
          pRawdata += 4;
        }
      }
#else
      MNG_COPY (pFRAM->pSyncids, pRawdata, pFRAM->iCount * 4);
#endif /* !MNG_BIGENDIAN_SUPPORTED */
    }
  }

#ifndef MNG_NO_OLD_VERSIONS
  if (pData->bPreDraft48)              /* old style input-stream ? */
  {
    switch (pFRAM->iMode)              /* fix the framing mode then */
    {
      case  0: { break; }
      case  1: { pFRAM->iMode = 3; break; }
      case  2: { pFRAM->iMode = 4; break; }
      case  3: { pFRAM->iMode = 1; break; }
      case  4: { pFRAM->iMode = 1; break; }
      case  5: { pFRAM->iMode = 2; break; }
      default: { pFRAM->iMode = 1; break; }
    }
  }
#endif

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_FRAM
MNG_C_SPECIALFUNC (mng_special_fram)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_fram (pData, pChunk);
#else
  return MNG_NOERROR;
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_MOVE
MNG_C_SPECIALFUNC (mng_special_move)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_move (pData, pChunk);
#else
  return MNG_NOERROR;
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_CLIP
MNG_C_SPECIALFUNC (mng_special_clip)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_clip (pData, pChunk);
#else
  return MNG_NOERROR;                  
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_SHOW
MNG_C_SPECIALFUNC (mng_special_show)
{
#ifdef MNG_SUPPORT_DISPLAY
  mng_retcode iRetcode;

  if (!((mng_showp)pChunk)->bEmpty)    /* any data ? */
  {
    if (!((mng_showp)pChunk)->bHaslastid)
      ((mng_showp)pChunk)->iLastid = ((mng_showp)pChunk)->iFirstid;

    pData->iSHOWfromid = ((mng_showp)pChunk)->iFirstid;
    pData->iSHOWtoid   = ((mng_showp)pChunk)->iLastid;
    pData->iSHOWmode   = ((mng_showp)pChunk)->iMode;
  }
  else                                 /* use defaults then */
  {
    pData->iSHOWfromid = 1;
    pData->iSHOWtoid   = 65535;
    pData->iSHOWmode   = 2;
  }
                                       /* create a SHOW animation object */
  iRetcode = mng_create_ani_show (pData);
  if (!iRetcode)                       /* go and do it! */
    iRetcode = mng_process_display_show (pData);

#endif /* MNG_SUPPORT_DISPLAY */

  return iRetcode;
}
#endif

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

#ifndef MNG_SKIPCHUNK_TERM
MNG_C_SPECIALFUNC (mng_special_term)
{
                                       /* should be behind MHDR or SAVE !! */
  if ((!pData->bHasSAVE) && (pData->iChunkseq > 2))
  {
    pData->bMisplacedTERM = MNG_TRUE;  /* indicate we found a misplaced TERM */
                                       /* and send a warning signal!!! */
    MNG_WARNING (pData, MNG_SEQUENCEERROR);
  }

  pData->bHasTERM = MNG_TRUE;

  if (pData->fProcessterm)             /* inform the app ? */
    if (!pData->fProcessterm (((mng_handle)pData),
                              ((mng_termp)pChunk)->iTermaction,
                              ((mng_termp)pChunk)->iIteraction,
                              ((mng_termp)pChunk)->iDelay,
                              ((mng_termp)pChunk)->iItermax))
      MNG_ERROR (pData, MNG_APPMISCERROR);

#ifdef MNG_SUPPORT_DISPLAY
  {                                    /* create the TERM ani-object */
    mng_retcode iRetcode = mng_create_ani_term (pData, pChunk);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
                                       /* save for future reference */
    pData->pTermaniobj = pData->pLastaniobj;
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_SAVE
MNG_F_SPECIALFUNC (mng_save_entries)
{
  mng_savep       pSAVE     = (mng_savep)pChunk;
  mng_uint32      iRawlen   = *piRawlen;
  mng_uint8p      pRawdata  = *ppRawdata;
  mng_save_entryp pEntry    = MNG_NULL;
  mng_uint32      iCount    = 0;
  mng_uint8       iOtype    = *pRawdata;
  mng_uint8       iEtype;
  mng_uint8p      pTemp;
  mng_uint8p      pNull;
  mng_uint32      iLen;
  mng_uint32      iOffset[2];
  mng_uint32      iStarttime[2];
  mng_uint32      iFramenr;
  mng_uint32      iLayernr;
  mng_uint32      iX;
  mng_uint32      iNamesize;

  if ((iOtype != 4) && (iOtype != 8))
    MNG_ERROR (pData, MNG_INVOFFSETSIZE);

  pSAVE->iOffsettype = iOtype;

  for (iX = 0; iX < 2; iX++)       /* do this twice to get the count first ! */
  {
    pTemp = pRawdata + 1;
    iLen  = iRawlen  - 1;

    if (iX)                        /* second run ? */
    {
      MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_save_entry)));

      pSAVE->iCount   = iCount;
      pSAVE->pEntries = pEntry;
    }

    while (iLen)                   /* anything left ? */
    {
      iEtype = *pTemp;             /* entrytype */

      if ((iEtype != 0) && (iEtype != 1) && (iEtype != 2) && (iEtype != 3))
        MNG_ERROR (pData, MNG_INVENTRYTYPE);

      pTemp++;

      if (iEtype > 1)
      {
        iOffset    [0] = 0;
        iOffset    [1] = 0;
        iStarttime [0] = 0;
        iStarttime [1] = 0;
        iLayernr       = 0;
        iFramenr       = 0;
      }
      else
      {
        if (iOtype == 4)
        {
          iOffset [0] = 0;
          iOffset [1] = mng_get_uint32 (pTemp);

          pTemp += 4;
        }
        else
        {
          iOffset [0] = mng_get_uint32 (pTemp);
          iOffset [1] = mng_get_uint32 (pTemp+4);

          pTemp += 8;
        }

        if (iEtype > 0)
        {
          iStarttime [0] = 0;
          iStarttime [1] = 0;
          iLayernr       = 0;
          iFramenr       = 0;
        }
        else
        {
          if (iOtype == 4)
          {
            iStarttime [0] = 0;
            iStarttime [1] = mng_get_uint32 (pTemp+0);
            iLayernr       = mng_get_uint32 (pTemp+4);
            iFramenr       = mng_get_uint32 (pTemp+8);

            pTemp += 12;
          }
          else
          {
            iStarttime [0] = mng_get_uint32 (pTemp+0);
            iStarttime [1] = mng_get_uint32 (pTemp+4);
            iLayernr       = mng_get_uint32 (pTemp+8);
            iFramenr       = mng_get_uint32 (pTemp+12);

            pTemp += 16;
          }
        }
      }

      pNull = pTemp;               /* get the name length */
      while (*pNull)
        pNull++;

      if ((pNull - pRawdata) > (mng_int32)iRawlen)
      {
        iNamesize = iLen;          /* no null found; so end of SAVE */
        iLen      = 0;
      }
      else
      {
        iNamesize = pNull - pTemp; /* should be another entry */
        iLen     -= iNamesize;

        if (!iLen)                 /* must not end with a null ! */
          MNG_ERROR (pData, MNG_ENDWITHNULL);
      }

      if (!pEntry)
      {
        iCount++;
      }
      else
      {
        pEntry->iEntrytype     = iEtype;
        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, pTemp, iNamesize);
        }

        pEntry++;
      }

      pTemp += iNamesize;
    }
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_SAVE
MNG_C_SPECIALFUNC (mng_special_save)
{
  pData->bHasSAVE = MNG_TRUE;

  if (pData->fProcesssave)             /* inform the application ? */
  {
    mng_bool bOke = pData->fProcesssave ((mng_handle)pData);
    if (!bOke)
      MNG_ERROR (pData, MNG_APPMISCERROR);
  }

#ifdef MNG_SUPPORT_DISPLAY
  {
    mng_retcode iRetcode;

    /* TODO: something with the parameters */

                                       /* create a SAVE animation object */
    iRetcode = mng_create_ani_save (pData);
    if (!iRetcode)                     /* process it */
      iRetcode = mng_process_display_save (pData);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_SEEK
MNG_C_SPECIALFUNC (mng_special_seek)
{
  mng_retcode iRetcode;

#ifdef MNG_SUPPORT_DISPLAY
                                       /* create a SEEK animation object */
  iRetcode = mng_create_ani_seek (pData, pChunk);
  if (iRetcode)                        /* on error bail out */
    return iRetcode;

#endif /* MNG_SUPPORT_DISPLAY */

  if (pData->fProcessseek)             /* inform the app ? */
    if (!pData->fProcessseek ((mng_handle)pData, ((mng_seekp)pChunk)->zName))
      MNG_ERROR (pData, MNG_APPMISCERROR);

#ifdef MNG_SUPPORT_DISPLAY
  return mng_process_display_seek (pData);
#else
  return MNG_NOERROR;                  
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_eXPI
MNG_C_SPECIALFUNC (mng_special_expi)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_fPRI
MNG_C_SPECIALFUNC (mng_special_fpri)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_nEED
MNG_LOCAL mng_bool CheckKeyword (mng_datap  pData,
                                 mng_uint8p pKeyword)
{
  mng_chunkid handled_chunks [] =
  {
    MNG_UINT_BACK,                     /* keep it sorted !!!! */
    MNG_UINT_BASI,
    MNG_UINT_CLIP,
    MNG_UINT_CLON,
#ifndef MNG_NO_DELTA_PNG
/* TODO:    MNG_UINT_DBYK,  */
#endif
    MNG_UINT_DEFI,
#ifndef MNG_NO_DELTA_PNG
    MNG_UINT_DHDR,
#endif
    MNG_UINT_DISC,
#ifndef MNG_NO_DELTA_PNG
/* TODO:    MNG_UINT_DROP,  */
#endif
    MNG_UINT_ENDL,
    MNG_UINT_FRAM,
    MNG_UINT_IDAT,
    MNG_UINT_IEND,
    MNG_UINT_IHDR,
#ifndef MNG_NO_DELTA_PNG
#ifdef MNG_INCLUDE_JNG
    MNG_UINT_IJNG,
#endif    
    MNG_UINT_IPNG,
#endif
#ifdef MNG_INCLUDE_JNG
    MNG_UINT_JDAA,
    MNG_UINT_JDAT,
    MNG_UINT_JHDR,
/* TODO:    MNG_UINT_JSEP,  */
    MNG_UINT_JdAA,
#endif
    MNG_UINT_LOOP,
    MNG_UINT_MAGN,
    MNG_UINT_MEND,
    MNG_UINT_MHDR,
    MNG_UINT_MOVE,
/* TODO:    MNG_UINT_ORDR,  */
    MNG_UINT_PAST,
    MNG_UINT_PLTE,
#ifndef MNG_NO_DELTA_PNG
    MNG_UINT_PPLT,
    MNG_UINT_PROM,
#endif
    MNG_UINT_SAVE,
    MNG_UINT_SEEK,
    MNG_UINT_SHOW,
    MNG_UINT_TERM,
    MNG_UINT_bKGD,
    MNG_UINT_cHRM,
/* TODO:    MNG_UINT_eXPI,  */
    MNG_UINT_evNT,
/* TODO:    MNG_UINT_fPRI,  */
    MNG_UINT_gAMA,
/* TODO:    MNG_UINT_hIST,  */
    MNG_UINT_iCCP,
    MNG_UINT_iTXt,
    MNG_UINT_nEED,
/* TODO:    MNG_UINT_oFFs,  */
/* TODO:    MNG_UINT_pCAL,  */
/* TODO:    MNG_UINT_pHYg,  */
/* TODO:    MNG_UINT_pHYs,  */
/* TODO:    MNG_UINT_sBIT,  */
/* TODO:    MNG_UINT_sCAL,  */
/* TODO:    MNG_UINT_sPLT,  */
    MNG_UINT_sRGB,
    MNG_UINT_tEXt,
    MNG_UINT_tIME,
    MNG_UINT_tRNS,
    MNG_UINT_zTXt,
  };

  mng_bool bOke = MNG_FALSE;

  if (pData->fProcessneed)             /* does the app handle it ? */
    bOke = pData->fProcessneed ((mng_handle)pData, (mng_pchar)pKeyword);

  if (!bOke)
  {                                    /* find the keyword length */
    mng_uint8p pNull = pKeyword;
    while (*pNull)
      pNull++;

    if ((pNull - pKeyword) == 4)       /* test a chunk ? */
    {                                  /* get the chunk-id */
      mng_chunkid iChunkid = (*pKeyword     << 24) + (*(pKeyword+1) << 16) +
                             (*(pKeyword+2) <<  8) + (*(pKeyword+3)      );
                                       /* binary search variables */
      mng_int32   iTop, iLower, iUpper, iMiddle;
                                       /* determine max index of table */
      iTop = (sizeof (handled_chunks) / sizeof (handled_chunks [0])) - 1;

      /* binary search; with 52 chunks, worst-case is 7 comparisons */
      iLower  = 0;
      iMiddle = iTop >> 1;
      iUpper  = iTop;

      do                                   /* the binary search itself */
        {
          if (handled_chunks [iMiddle] < iChunkid)
            iLower = iMiddle + 1;
          else if (handled_chunks [iMiddle] > iChunkid)
            iUpper = iMiddle - 1;
          else
          {
            bOke = MNG_TRUE;
            break;
          }

          iMiddle = (iLower + iUpper) >> 1;
        }
      while (iLower <= iUpper);
    }
                                       /* test draft ? */
    if ((!bOke) && ((pNull - pKeyword) == 8) &&
        (*pKeyword     == 'd') && (*(pKeyword+1) == 'r') &&
        (*(pKeyword+2) == 'a') && (*(pKeyword+3) == 'f') &&
        (*(pKeyword+4) == 't') && (*(pKeyword+5) == ' '))
    {
      mng_uint32 iDraft;

      iDraft = (*(pKeyword+6) - '0') * 10 + (*(pKeyword+7) - '0');
      bOke   = (mng_bool)(iDraft <= MNG_MNG_DRAFT);
    }
                                       /* test MNG 1.0/1.1 ? */
    if ((!bOke) && ((pNull - pKeyword) == 7) &&
        (*pKeyword     == 'M') && (*(pKeyword+1) == 'N') &&
        (*(pKeyword+2) == 'G') && (*(pKeyword+3) == '-') &&
        (*(pKeyword+4) == '1') && (*(pKeyword+5) == '.') &&
        ((*(pKeyword+6) == '0') || (*(pKeyword+6) == '1')))
      bOke   = MNG_TRUE;
                                       /* test CACHEOFF ? */
    if ((!bOke) && ((pNull - pKeyword) == 8) &&
        (*pKeyword     == 'C') && (*(pKeyword+1) == 'A') &&
        (*(pKeyword+2) == 'C') && (*(pKeyword+3) == 'H') &&
        (*(pKeyword+4) == 'E') && (*(pKeyword+5) == 'O') &&
        (*(pKeyword+6) == 'F') && (*(pKeyword+7) == 'F'))
    {
      if (!pData->pFirstaniobj)        /* only if caching hasn't started yet ! */
      {
        bOke                  = MNG_TRUE;
        pData->bCacheplayback = MNG_FALSE;
        pData->bStorechunks   = MNG_FALSE;
      }
    }
  }

  return bOke;
}
#endif

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

#ifndef MNG_SKIPCHUNK_nEED
MNG_C_SPECIALFUNC (mng_special_need)
{
                                       /* let's check it */
  mng_bool   bOke = MNG_TRUE;
  mng_uint8p pNull, pTemp, pMax;

  pTemp = (mng_uint8p)((mng_needp)pChunk)->zKeywords;
  pMax  = (mng_uint8p)(pTemp + ((mng_needp)pChunk)->iKeywordssize);
  pNull = pTemp;
  while (*pNull)
    pNull++;

  while ((bOke) && (pNull < pMax))
  {
    bOke  = CheckKeyword (pData, pTemp);
    pTemp = pNull + 1;
    pNull = pTemp;
    while (*pNull)
      pNull++;
  }

  if (bOke)
    bOke = CheckKeyword (pData, pTemp);

  if (!bOke)
    MNG_ERROR (pData, MNG_UNSUPPORTEDNEED);

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_SKIPCHUNK_pHYg
MNG_C_SPECIALFUNC (mng_special_phyg)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_C_SPECIALFUNC (mng_special_dhdr)
{
  if ((((mng_dhdrp)pChunk)->iDeltatype == MNG_DELTATYPE_REPLACE) && (((mng_dhdrp)pChunk)->bHasblockloc))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);
  if ((((mng_dhdrp)pChunk)->iDeltatype == MNG_DELTATYPE_NOCHANGE) && (((mng_dhdrp)pChunk)->bHasblocksize))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  pData->bHasDHDR   = MNG_TRUE;        /* inside a DHDR-IEND block now */
  pData->iDeltatype = ((mng_dhdrp)pChunk)->iDeltatype;

  pData->iImagelevel++;                /* one level deeper */

#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_dhdr (pData, pChunk);
#else
  return MNG_NOERROR;                  
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_C_SPECIALFUNC (mng_special_prom)
{
  if ((((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_GRAY   ) &&
      (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_RGB    ) &&
      (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_INDEXED) &&
      (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_GRAYA  ) &&
      (((mng_promp)pChunk)->iColortype != MNG_COLORTYPE_RGBA   )    )
    MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);

#ifdef MNG_NO_16BIT_SUPPORT
  if (((mng_promp)pChunk)->iSampledepth == MNG_BITDEPTH_16 )
      ((mng_promp)pChunk)->iSampledepth = MNG_BITDEPTH_8;
#endif

  if ((((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_1 ) &&
      (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_2 ) &&
      (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_4 ) &&
      (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_8 )
#ifndef MNG_NO_16BIT_SUPPORT
      && (((mng_promp)pChunk)->iSampledepth != MNG_BITDEPTH_16)
#endif
    )
    MNG_ERROR (pData, MNG_INVSAMPLEDEPTH);

#ifdef MNG_SUPPORT_DISPLAY
  {
    mng_retcode iRetcode = mng_create_ani_prom (pData, pChunk);
    if (iRetcode)                      /* on error bail out */
      return iRetcode;
  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_C_SPECIALFUNC (mng_special_ipng)
{
#ifdef MNG_SUPPORT_DISPLAY
  mng_retcode iRetcode = mng_create_ani_ipng (pData);
  if (!iRetcode)                       /* process it */
    iRetcode = mng_process_display_ipng (pData);
  if (iRetcode)                        /* on error bail out */
    return iRetcode;
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_F_SPECIALFUNC (mng_pplt_entries)
{
  mng_ppltp     pPPLT      = (mng_ppltp)pChunk;
  mng_uint32    iRawlen    = *piRawlen;
  mng_uint8p    pRawdata   = *ppRawdata;
  mng_uint8     iDeltatype = pPPLT->iDeltatype;
  mng_uint32    iMax       = 0;
  mng_int32     iX, iY, iM;
  mng_rgbpaltab aIndexentries;
  mng_uint8arr  aAlphaentries;
  mng_uint8arr  aUsedentries;
                                       /* must be indexed color ! */
  if (pData->iColortype != MNG_COLORTYPE_INDEXED)
    MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);

  for (iY = 255; iY >= 0; iY--)        /* reset arrays */
  {
    aIndexentries [iY].iRed   = 0;
    aIndexentries [iY].iGreen = 0;
    aIndexentries [iY].iBlue  = 0;
    aAlphaentries [iY]        = 255;
    aUsedentries  [iY]        = 0;
  }

  while (iRawlen)                      /* as long as there are entries left ... */
  {
    mng_uint32 iDiff;

    if (iRawlen < 2)
      MNG_ERROR (pData, MNG_INVALIDLENGTH);

    iX = (mng_int32)(*pRawdata);      /* get start and end index */
    iM = (mng_int32)(*(pRawdata+1));

    if (iM < iX)
      MNG_ERROR (pData, MNG_INVALIDINDEX);

    if (iM >= (mng_int32) iMax)       /* determine highest used index */
      iMax = iM + 1;

    pRawdata += 2;
    iRawlen  -= 2;
    iDiff = (iM - iX + 1);
    if ((iDeltatype == MNG_DELTATYPE_REPLACERGB  ) ||
        (iDeltatype == MNG_DELTATYPE_DELTARGB    )    )
      iDiff = iDiff * 3;
    else
    if ((iDeltatype == MNG_DELTATYPE_REPLACERGBA) ||
        (iDeltatype == MNG_DELTATYPE_DELTARGBA  )    )
      iDiff = iDiff * 4;

    if (iRawlen < iDiff)
      MNG_ERROR (pData, MNG_INVALIDLENGTH);

    if ((iDeltatype == MNG_DELTATYPE_REPLACERGB  ) ||
        (iDeltatype == MNG_DELTATYPE_DELTARGB    )    )
    {
      for (iY = iX; iY <= iM; iY++)
      {
        aIndexentries [iY].iRed   = *pRawdata;
        aIndexentries [iY].iGreen = *(pRawdata+1);
        aIndexentries [iY].iBlue  = *(pRawdata+2);
        aUsedentries  [iY]        = 1;

        pRawdata += 3;
        iRawlen  -= 3;
      }
    }
    else
    if ((iDeltatype == MNG_DELTATYPE_REPLACEALPHA) ||
        (iDeltatype == MNG_DELTATYPE_DELTAALPHA  )    )
    {
      for (iY = iX; iY <= iM; iY++)
      {
        aAlphaentries [iY]        = *pRawdata;
        aUsedentries  [iY]        = 1;

        pRawdata++;
        iRawlen--;
      }
    }
    else
    {
      for (iY = iX; iY <= iM; iY++)
      {
        aIndexentries [iY].iRed   = *pRawdata;
        aIndexentries [iY].iGreen = *(pRawdata+1);
        aIndexentries [iY].iBlue  = *(pRawdata+2);
        aAlphaentries [iY]        = *(pRawdata+3);
        aUsedentries  [iY]        = 1;

        pRawdata += 4;
        iRawlen  -= 4;
      }
    }
  }

  switch (pData->iBitdepth)            /* check maximum allowed entries for bitdepth */
  {
    case MNG_BITDEPTH_1 : {
                            if (iMax > 2)
                              MNG_ERROR (pData, MNG_INVALIDINDEX);
                            break;
                          }
    case MNG_BITDEPTH_2 : {
                            if (iMax > 4)
                              MNG_ERROR (pData, MNG_INVALIDINDEX);
                            break;
                          }
    case MNG_BITDEPTH_4 : {
                            if (iMax > 16)
                              MNG_ERROR (pData, MNG_INVALIDINDEX);
                            break;
                          }
  }

  pPPLT->iCount = iMax;

  for (iY = 255; iY >= 0; iY--)        
  {
    pPPLT->aEntries [iY].iRed   = aIndexentries [iY].iRed;
    pPPLT->aEntries [iY].iGreen = aIndexentries [iY].iGreen;
    pPPLT->aEntries [iY].iBlue  = aIndexentries [iY].iBlue;
    pPPLT->aEntries [iY].iAlpha = aAlphaentries [iY];
    pPPLT->aEntries [iY].bUsed  = (mng_bool)(aUsedentries [iY]);
  }

  {                                    /* create animation object */
    mng_retcode iRetcode = mng_create_ani_pplt (pData, iDeltatype, iMax,
                                                aIndexentries, aAlphaentries,
                                                aUsedentries);
    if (iRetcode)
      return iRetcode;
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_C_SPECIALFUNC (mng_special_pplt)
{
  return MNG_NOERROR;                 
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
#ifdef MNG_INCLUDE_JNG
MNG_C_SPECIALFUNC (mng_special_ijng)
{
#ifdef MNG_SUPPORT_DISPLAY
  mng_retcode iRetcode = mng_create_ani_ijng (pData);
  if (!iRetcode)                       /* process it */
    iRetcode = mng_process_display_ijng (pData);
  return iRetcode;
#else
  return MNG_NOERROR;                  /* done */
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_F_SPECIALFUNC (mng_drop_entries)
{
  mng_dropp   pDROP    = (mng_dropp)pChunk;
  mng_uint32  iRawlen  = *piRawlen;
  mng_uint8p  pRawdata = *ppRawdata;
  mng_uint32  iX;
  mng_uint32p pEntry;
                                       /* check length */
  if ((iRawlen < 4) || ((iRawlen % 4) != 0))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  MNG_ALLOC (pData, pEntry, iRawlen);
  pDROP->iCount      = iRawlen / 4;
  pDROP->pChunknames = (mng_ptr)pEntry;

  for (iX = pDROP->iCount; iX > 0; iX--)
  {
    *pEntry++ = mng_get_uint32 (pRawdata);
    pRawdata += 4;
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
MNG_C_SPECIALFUNC (mng_special_drop)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif

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

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_DBYK
MNG_C_SPECIALFUNC (mng_special_dbyk)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif
#endif

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

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
MNG_F_SPECIALFUNC (mng_ordr_entries)
{
  mng_ordrp       pORDR    = (mng_ordrp)pChunk;
  mng_uint32      iRawlen  = *piRawlen;
  mng_uint8p      pRawdata = *ppRawdata;
  mng_uint32      iX;
  mng_ordr_entryp pEntry;
                                       /* check length */
  if ((iRawlen < 5) || ((iRawlen % 5) != 0))
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  MNG_ALLOC (pData, pEntry, iRawlen);
  pORDR->iCount   = iRawlen / 5;
  pORDR->pEntries = (mng_ptr)pEntry;

  for (iX = pORDR->iCount; iX > 0; iX--)
  {
    pEntry->iChunkname = mng_get_uint32 (pRawdata);
    pEntry->iOrdertype = *(pRawdata+4);
    pEntry++;
    pRawdata += 5;
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif
#endif

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

#ifndef MNG_NO_DELTA_PNG
#ifndef MNG_SKIPCHUNK_ORDR
MNG_C_SPECIALFUNC (mng_special_ordr)
{
#ifdef MNG_SUPPORT_DISPLAY
  {


    /* TODO: something !!! */


  }
#endif /* MNG_SUPPORT_DISPLAY */

  return MNG_NOERROR;                  /* done */
}
#endif
#endif

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

#ifndef MNG_SKIPCHUNK_MAGN
MNG_F_SPECIALFUNC (mng_debunk_magn)
{
  mng_magnp  pMAGN    = (mng_magnp)pChunk;
  mng_uint32 iRawlen  = *piRawlen;
  mng_uint8p pRawdata = *ppRawdata;
  mng_bool   bFaulty;
                                       /* check length */
  if (iRawlen > 20)
    MNG_ERROR (pData, MNG_INVALIDLENGTH);

  /* following is an ugly hack to allow faulty layout caused by previous
     versions of libmng and MNGeye, which wrote MAGN with a 16-bit
     MethodX/MethodY (as opposed to the proper 8-bit as defined in the spec!) */

  if ((iRawlen ==  6) || (iRawlen ==  8) || (iRawlen == 10) || (iRawlen == 12) ||
      (iRawlen == 14) || (iRawlen == 16) || (iRawlen == 20))
    bFaulty = MNG_TRUE;                /* these lengths are all wrong */
  else                                 /* length 18 can be right or wrong !!! */
  if ((iRawlen ==  18) && (mng_get_uint16 (pRawdata+4) <= 5) &&
      (mng_get_uint16 (pRawdata+6)  < 256) &&
      (mng_get_uint16 (pRawdata+8)  < 256) &&
      (mng_get_uint16 (pRawdata+10) < 256) &&
      (mng_get_uint16 (pRawdata+12) < 256) &&
      (mng_get_uint16 (pRawdata+14) < 256) &&
      (mng_get_uint16 (pRawdata+16) < 256))
    bFaulty = MNG_TRUE;                /* this is very likely the wrong layout */
  else
    bFaulty = MNG_FALSE;               /* all other cases are handled as right */

  if (bFaulty)                         /* wrong layout ? */
  {
    if (iRawlen > 0)                   /* get the fields */
      pMAGN->iFirstid = mng_get_uint16 (pRawdata);
    else
      pMAGN->iFirstid = 0;

    if (iRawlen > 2)
      pMAGN->iLastid  = mng_get_uint16 (pRawdata+2);
    else
      pMAGN->iLastid  = pMAGN->iFirstid;

    if (iRawlen > 4)
      pMAGN->iMethodX = (mng_uint8)(mng_get_uint16 (pRawdata+4));
    else
      pMAGN->iMethodX = 0;

    if (iRawlen > 6)
      pMAGN->iMX      = mng_get_uint16 (pRawdata+6);
    else
      pMAGN->iMX      = 1;

    if (iRawlen > 8)
      pMAGN->iMY      = mng_get_uint16 (pRawdata+8);
    else
      pMAGN->iMY      = pMAGN->iMX;

    if (iRawlen > 10)
      pMAGN->iML      = mng_get_uint16 (pRawdata+10);
    else
      pMAGN->iML      = pMAGN->iMX;

    if (iRawlen > 12)
      pMAGN->iMR      = mng_get_uint16 (pRawdata+12);
    else
      pMAGN->iMR      = pMAGN->iMX;

    if (iRawlen > 14)
      pMAGN->iMT      = mng_get_uint16 (pRawdata+14);
    else
      pMAGN->iMT      = pMAGN->iMY;

    if (iRawlen > 16)
      pMAGN->iMB      = mng_get_uint16 (pRawdata+16);
    else
      pMAGN->iMB      = pMAGN->iMY;

    if (iRawlen > 18)
      pMAGN->iMethodY = (mng_uint8)(mng_get_uint16 (pRawdata+18));
    else
      pMAGN->iMethodY = pMAGN->iMethodX;
  }
  else                                 /* proper layout !!!! */
  {
    if (iRawlen > 0)                   /* get the fields */
      pMAGN->iFirstid = mng_get_uint16 (pRawdata);
    else
      pMAGN->iFirstid = 0;

    if (iRawlen > 2)
      pMAGN->iLastid  = mng_get_uint16 (pRawdata+2);
    else
      pMAGN->iLastid  = pMAGN->iFirstid;

    if (iRawlen > 4)
      pMAGN->iMethodX = *(pRawdata+4);
    else
      pMAGN->iMethodX = 0;

    if (iRawlen > 5)
      pMAGN->iMX      = mng_get_uint16 (pRawdata+5);
    else
      pMAGN->iMX      = 1;

    if (iRawlen > 7)
      pMAGN->iMY      = mng_get_uint16 (pRawdata+7);
    else
      pMAGN->iMY      = pMAGN->iMX;

    if (iRawlen > 9)
      pMAGN->iML      = mng_get_uint16 (pRawdata+9);
    else
      pMAGN->iML      = pMAGN->iMX;

    if (iRawlen > 11)
      pMAGN->iMR      = mng_get_uint16 (pRawdata+11);
    else
      pMAGN->iMR      = pMAGN->iMX;

    if (iRawlen > 13)
      pMAGN->iMT      = mng_get_uint16 (pRawdata+13);
    else
      pMAGN->iMT      = pMAGN->iMY;

    if (iRawlen > 15)
      pMAGN->iMB      = mng_get_uint16 (pRawdata+15);
    else
      pMAGN->iMB      = pMAGN->iMY;

    if (iRawlen > 17)
      pMAGN->iMethodY = *(pRawdata+17);
    else
      pMAGN->iMethodY = pMAGN->iMethodX;
  }
                                       /* check field validity */
  if ((pMAGN->iMethodX > 5) || (pMAGN->iMethodY > 5))
    MNG_ERROR (pData, MNG_INVALIDMETHOD);

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_MAGN
MNG_C_SPECIALFUNC (mng_special_magn)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ani_magn (pData, pChunk);
#else
  return MNG_NOERROR;                  
#endif /* MNG_SUPPORT_DISPLAY */
}
#endif

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

#ifndef MNG_SKIPCHUNK_evNT
MNG_F_SPECIALFUNC (mng_evnt_entries)
{
  mng_evntp       pEVNT = (mng_evntp)pChunk;
  mng_uint32      iRawlen;
  mng_uint8p      pRawdata;
#if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG)
  mng_retcode     iRetcode;
#endif
  mng_uint8p      pNull;
  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      iNamesize;
  mng_uint32      iCount = 0;
  mng_evnt_entryp pEntry = MNG_NULL;
  mng_uint32      iX;

  for (iX = 0; iX < 2; iX++)
  {
    iRawlen  = *piRawlen;
    pRawdata = *ppRawdata;

    if (iX)                            /* second run ? */
    {
      MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_evnt_entry)));
      pEVNT->iCount   = iCount;
      pEVNT->pEntries = pEntry;
    }

    while (iRawlen)                    /* anything left ? */
    {
      if (iRawlen < 2)                 /* must have at least 2 bytes ! */
        MNG_ERROR (pData, MNG_INVALIDLENGTH);

      iEventtype = *pRawdata;          /* eventtype */
      if (iEventtype > 5)
        MNG_ERROR (pData, MNG_INVALIDEVENT);

      pRawdata++;

      iMasktype  = *pRawdata;          /* masktype */
      if (iMasktype > 5)
        MNG_ERROR (pData, MNG_INVALIDMASK);

      pRawdata++;
      iRawlen -= 2;

      iLeft     = 0;
      iRight    = 0;
      iTop      = 0;
      iBottom   = 0;
      iObjectid = 0;
      iIndex    = 0;

      switch (iMasktype)
      {
        case 1 :
          {
            if (iRawlen > 16)
            {
              iLeft     = mng_get_int32 (pRawdata);
              iRight    = mng_get_int32 (pRawdata+4);
              iTop      = mng_get_int32 (pRawdata+8);
              iBottom   = mng_get_int32 (pRawdata+12);
              pRawdata += 16;
              iRawlen -= 16;
            }
            else
              MNG_ERROR (pData, MNG_INVALIDLENGTH);
            break;
          }
        case 2 :
          {
            if (iRawlen > 2)
            {
              iObjectid = mng_get_uint16 (pRawdata);
              pRawdata += 2;
              iRawlen -= 2;
            }
            else
              MNG_ERROR (pData, MNG_INVALIDLENGTH);
            break;
          }
        case 3 :
          {
            if (iRawlen > 3)
            {
              iObjectid = mng_get_uint16 (pRawdata);
              iIndex    = *(pRawdata+2);
              pRawdata += 3;
              iRawlen -= 3;
            }
            else
              MNG_ERROR (pData, MNG_INVALIDLENGTH);
            break;
          }
        case 4 :
          {
            if (iRawlen > 18)
            {
              iLeft     = mng_get_int32 (pRawdata);
              iRight    = mng_get_int32 (pRawdata+4);
              iTop      = mng_get_int32 (pRawdata+8);
              iBottom   = mng_get_int32 (pRawdata+12);
              iObjectid = mng_get_uint16 (pRawdata+16);
              pRawdata += 18;
              iRawlen -= 18;
            }
            else
              MNG_ERROR (pData, MNG_INVALIDLENGTH);
            break;
          }
        case 5 :
          {
            if (iRawlen > 19)
            {
              iLeft     = mng_get_int32 (pRawdata);
              iRight    = mng_get_int32 (pRawdata+4);
              iTop      = mng_get_int32 (pRawdata+8);
              iBottom   = mng_get_int32 (pRawdata+12);
              iObjectid = mng_get_uint16 (pRawdata+16);
              iIndex    = *(pRawdata+18);
              pRawdata += 19;
              iRawlen -= 19;
            }
            else
              MNG_ERROR (pData, MNG_INVALIDLENGTH);
            break;
          }
      }

      pNull = pRawdata;                /* get the name length */
      while (*pNull)
        pNull++;

      if ((pNull - pRawdata) > (mng_int32)iRawlen)
      {
        iNamesize = iRawlen;           /* no null found; so end of evNT */
        iRawlen   = 0;
      }
      else
      {
        iNamesize = pNull - pRawdata;  /* should be another entry */
        iRawlen   = iRawlen - iNamesize - 1;

        if (!iRawlen)                  /* must not end with a null ! */
          MNG_ERROR (pData, MNG_ENDWITHNULL);
      }

      if (!iX)
      {
        iCount++;
      }
      else
      {
        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 = iNamesize;

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

#if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG)
        iRetcode = mng_create_event (pData, (mng_ptr)pEntry);
        if (iRetcode)                    /* on error bail out */
          return iRetcode;
#endif

        pEntry++;
      }

      pRawdata = pRawdata + iNamesize + 1;
    }
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifndef MNG_SKIPCHUNK_evNT
MNG_C_SPECIALFUNC (mng_special_evnt)
{
  return MNG_NOERROR;
}
#endif

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

#ifdef MNG_INCLUDE_MPNG_PROPOSAL
MNG_C_SPECIALFUNC (mng_special_mpng)
{
  if ((pData->eImagetype != mng_it_png) && (pData->eImagetype != mng_it_jng))
    MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
    
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_mpng_obj (pData, pChunk);
#else
  return MNG_NOERROR;
#endif
}
#endif

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

#ifdef MNG_INCLUDE_ANG_PROPOSAL
MNG_C_SPECIALFUNC (mng_special_ahdr)
{
#ifdef MNG_SUPPORT_DISPLAY
  return mng_create_ang_obj (pData, pChunk);
#else
  return MNG_NOERROR;
#endif
}
#endif

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

#ifdef MNG_INCLUDE_ANG_PROPOSAL
MNG_F_SPECIALFUNC (mng_adat_tiles)
{
  if ((pData->eImagetype != mng_it_ang) || (!pData->pANG))
    MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);

  {
    mng_adatp      pADAT = (mng_adatp)pChunk;
    mng_ang_objp   pANG  = (mng_ang_objp)pData->pANG;
    mng_uint32     iRawlen  = *piRawlen;
    mng_uint8p     pRawdata = *ppRawdata;
    mng_retcode    iRetcode;
    mng_uint8p     pBuf;
    mng_uint32     iBufsize;
    mng_uint32     iRealsize;
    mng_uint8p     pTemp;
    mng_uint8p     pTemp2;
    mng_int32      iX;
    mng_int32      iSize;

#ifdef MNG_SUPPORT_DISPLAY
    mng_imagep     pImage;
    mng_int32      iTemplen;
    mng_uint8p     pSwap;

    mng_processobject pProcess;

    mng_uint32     iSavedatawidth;
    mng_uint32     iSavedataheight;

    mng_fptr       fSaveinitrowproc;
    mng_fptr       fSavestorerow;
    mng_fptr       fSaveprocessrow;
    mng_fptr       fSavedifferrow;
    mng_imagep     fSavestoreobj;
    mng_imagedatap fSavestorebuf;

#ifdef MNG_OPTIMIZE_FOOTPRINT_INIT
    png_imgtype    eSavepngimgtype;
#endif

    mng_uint8      iSaveinterlace;
    mng_int8       iSavepass;
    mng_int32      iSaverow;
    mng_int32      iSaverowinc;
    mng_int32      iSavecol;
    mng_int32      iSavecolinc;
    mng_int32      iSaverowsamples;
    mng_int32      iSavesamplemul;
    mng_int32      iSavesampleofs;
    mng_int32      iSavesamplediv;
    mng_int32      iSaverowsize;
    mng_int32      iSaverowmax;
    mng_int32      iSavefilterofs;
    mng_int32      iSavepixelofs;
    mng_uint32     iSavelevel0;
    mng_uint32     iSavelevel1;
    mng_uint32     iSavelevel2;
    mng_uint32     iSavelevel3;
    mng_uint8p     pSaveworkrow;
    mng_uint8p     pSaveprevrow;
    mng_uint8p     pSaverGBArow;
    mng_bool       bSaveisRGBA16;
    mng_bool       bSaveisOpaque;
    mng_int32      iSavefilterbpp;

    mng_int32      iSavedestl;
    mng_int32      iSavedestt;
    mng_int32      iSavedestr;
    mng_int32      iSavedestb;
    mng_int32      iSavesourcel;
    mng_int32      iSavesourcet;
    mng_int32      iSavesourcer;
    mng_int32      iSavesourceb;
#endif /* MNG_SUPPORT_DISPLAY */

    iRetcode = mng_inflate_buffer (pData, pRawdata, iRawlen,
                                   &pBuf, &iBufsize, &iRealsize);
    if (iRetcode)                      /* on error bail out */
    {                                  /* don't forget to drop the temp buffer */
      MNG_FREEX (pData, pBuf, iBufsize);
      return iRetcode;
    }
                                       /* get buffer for tile info in ADAT chunk */
    pADAT->iTilessize = pANG->iNumframes * sizeof(mng_adat_tile);
    MNG_ALLOCX (pData, pADAT->pTiles, pADAT->iTilessize);
    if (!pADAT->pTiles)
    {
      pADAT->iTilessize = 0;
      MNG_FREEX (pData, pBuf, iBufsize);
      MNG_ERROR (pData, MNG_OUTOFMEMORY);
    }

    pTemp  = pBuf;
    pTemp2 = (mng_uint8p)pADAT->pTiles;

    if (!pANG->iStillused)
      iSize = 12;
    else
      iSize = 13;

    for (iX = 0; iX < pANG->iNumframes; iX++)
    {
      MNG_COPY (pTemp2, pTemp, iSize);
      pTemp  += iSize;
      pTemp2 += sizeof(mng_adat_tile);
    }

#ifdef MNG_SUPPORT_DISPLAY
                                       /* get buffer for tile info in ANG object */
    pANG->iTilessize = pADAT->iTilessize;
    MNG_ALLOCX (pData, pANG->pTiles, pANG->iTilessize);
    if (!pANG->pTiles)
    {
      pANG->iTilessize = 0;
      MNG_FREEX (pData, pBuf, iBufsize);
      MNG_ERROR (pData, MNG_OUTOFMEMORY);
    }
                                       /* copy it from the ADAT object */
    MNG_COPY (pANG->pTiles, pADAT->pTiles, pANG->iTilessize);

                                       /* save IDAT work-parms */
    fSaveinitrowproc    = pData->fInitrowproc;
    fSavestorerow       = pData->fDisplayrow;
    fSaveprocessrow     = pData->fProcessrow;
    fSavedifferrow      = pData->fDifferrow;
    fSavestoreobj       = pData->pStoreobj;
    fSavestorebuf       = pData->pStorebuf;

#ifdef MNG_OPTIMIZE_FOOTPRINT_INIT
    eSavepngimgtype     = pData->ePng_imgtype;
#endif

    iSavedatawidth      = pData->iDatawidth;
    iSavedataheight     = pData->iDataheight;
    iSaveinterlace      = pData->iInterlace;
    iSavepass           = pData->iPass;
    iSaverow            = pData->iRow;
    iSaverowinc         = pData->iRowinc;
    iSavecol            = pData->iCol;
    iSavecolinc         = pData->iColinc;
    iSaverowsamples     = pData->iRowsamples;
    iSavesamplemul      = pData->iSamplemul;
    iSavesampleofs      = pData->iSampleofs;
    iSavesamplediv      = pData->iSamplediv;
    iSaverowsize        = pData->iRowsize;
    iSaverowmax         = pData->iRowmax;
    iSavefilterofs      = pData->iFilterofs;
    iSavepixelofs       = pData->iPixelofs;
    iSavelevel0         = pData->iLevel0;
    iSavelevel1         = pData->iLevel1;
    iSavelevel2         = pData->iLevel2;
    iSavelevel3         = pData->iLevel3;
    pSaveworkrow        = pData->pWorkrow;
    pSaveprevrow        = pData->pPrevrow;
    pSaverGBArow        = pData->pRGBArow;
    bSaveisRGBA16       = pData->bIsRGBA16;
    bSaveisOpaque       = pData->bIsOpaque;
    iSavefilterbpp      = pData->iFilterbpp;
    iSavedestl          = pData->iDestl;
    iSavedestt          = pData->iDestt;
    iSavedestr          = pData->iDestr;
    iSavedestb          = pData->iDestb;
    iSavesourcel        = pData->iSourcel;
    iSavesourcet        = pData->iSourcet;
    iSavesourcer        = pData->iSourcer;
    iSavesourceb        = pData->iSourceb;

    pData->iDatawidth   = pANG->iTilewidth;
    pData->iDataheight  = pANG->iTileheight;

    pData->iDestl       = 0;
    pData->iDestt       = 0;
    pData->iDestr       = pANG->iTilewidth;
    pData->iDestb       = pANG->iTileheight;
    pData->iSourcel     = 0;
    pData->iSourcet     = 0;
    pData->iSourcer     = pANG->iTilewidth;
    pData->iSourceb     = pANG->iTileheight;

    pData->fInitrowproc = MNG_NULL;
    pData->fStorerow    = MNG_NULL;
    pData->fProcessrow  = MNG_NULL;
    pData->fDifferrow   = MNG_NULL;

    /* clone image object to store the pixel-data from object 0 */
    iRetcode = mng_clone_imageobject (pData, 1, MNG_FALSE, MNG_FALSE, MNG_FALSE,
                                      MNG_FALSE, 0, 0, 0, pData->pObjzero, &pImage);
    if (iRetcode)                      /* on error, drop temp buffer and bail */
    {
      MNG_FREEX (pData, pBuf, iBufsize);
      return iRetcode;
    }

    /* make sure we got the right dimensions and interlacing */
    iRetcode = mng_reset_object_details (pData, pImage, pANG->iTilewidth, pANG->iTileheight,
                                         pImage->pImgbuf->iBitdepth, pImage->pImgbuf->iColortype,
                                         pImage->pImgbuf->iCompression, pImage->pImgbuf->iFilter,
                                         pANG->iInterlace, MNG_FALSE);
    if (iRetcode)                      /* on error, drop temp buffer and bail */
    {
      MNG_FREEX (pData, pBuf, iBufsize);
      return iRetcode;
    }

    pData->pStoreobj    = pImage;

#ifdef MNG_OPTIMIZE_FOOTPRINT_INIT
    pData->fInitrowproc = (mng_fptr)mng_init_rowproc;
    pData->ePng_imgtype = mng_png_imgtype(pData->iColortype,pData->iBitdepth);
#else
    switch (pData->iColortype)         /* determine row initialization routine */
    {
      case 0 : {                       /* gray */
                 switch (pData->iBitdepth)
                 {
#ifndef MNG_NO_1_2_4BIT_SUPPORT
                   case  1 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_g1_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_g1_i;

                               break;
                             }
                   case  2 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_g2_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_g2_i;

                               break;
                             }
                   case  4 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_g4_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_g4_i;
                               break;
                             }
#endif /* MNG_NO_1_2_4BIT_SUPPORT */
                   case  8 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_g8_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_g8_i;

                               break;
                             }
#ifndef MNG_NO_16BIT_SUPPORT
                   case 16 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_g16_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_g16_i;

                               break;
                             }
#endif
                 }

                 break;
               }
      case 2 : {                       /* rgb */
                 switch (pData->iBitdepth)
                 {
                   case  8 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgb8_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgb8_i;
                               break;
                             }
#ifndef MNG_NO_16BIT_SUPPORT
                   case 16 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgb16_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgb16_i;

                               break;
                             }
#endif
                 }

                 break;
               }
      case 3 : {                       /* indexed */
                 switch (pData->iBitdepth)
                 {
#ifndef MNG_NO_1_2_4BIT_SUPPORT
                   case  1 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx1_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx1_i;

                               break;
                             }
                   case  2 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx2_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx2_i;

                               break;
                             }
                   case  4 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx4_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx4_i;

                               break;
                             }
#endif /* MNG_NO_1_2_4BIT_SUPPORT */
                   case  8 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx8_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_idx8_i;

                               break;
                             }
                 }

                 break;
               }
      case 4 : {                       /* gray+alpha */
                 switch (pData->iBitdepth)
                 {
                   case  8 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_ga8_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_ga8_i;

                               break;
                             }
#ifndef MNG_NO_16BIT_SUPPORT
                   case 16 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_ga16_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_ga16_i;
                               break;
                             }
#endif
                 }

                 break;
               }
      case 6 : {                       /* rgb+alpha */
                 switch (pData->iBitdepth)
                 {
                   case  8 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgba8_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgba8_i;

                               break;
                             }
#ifndef MNG_NO_16BIT_SUPPORT
                   case 16 : {
                               if (!pData->iInterlace)
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgba16_ni;
                               else
                                 pData->fInitrowproc = (mng_fptr)mng_init_rgba16_i;

                               break;
                             }
#endif
                 }

                 break;
               }
    }
#endif /* MNG_OPTIMIZE_FOOTPRINT_INIT */

    pData->iFilterofs = 0;             /* determine filter characteristics */
    pData->iLevel0    = 0;             /* default levels */
    pData->iLevel1    = 0;    
    pData->iLevel2    = 0;
    pData->iLevel3    = 0;

#ifdef FILTER192                       /* leveling & differing ? */
    if (pData->iFilter == MNG_FILTER_DIFFERING)
    {
      switch (pData->iColortype)
      {
        case 0 : {
                   if (pData->iBitdepth <= 8)
                     pData->iFilterofs = 1;
                   else
                     pData->iFilterofs = 2;

                   break;
                 }
        case 2 : {
                   if (pData->iBitdepth <= 8)
                     pData->iFilterofs = 3;
                   else
                     pData->iFilterofs = 6;

                   break;
                 }
        case 3 : {
                   pData->iFilterofs = 1;
                   break;
                 }
        case 4 : {
                   if (pData->iBitdepth <= 8)
                     pData->iFilterofs = 2;
                   else
                     pData->iFilterofs = 4;

                   break;
                 }
        case 6 : {
                   if (pData->iBitdepth <= 8)
                     pData->iFilterofs = 4;
                   else
                     pData->iFilterofs = 8;

                   break;
                 }
      }
    }
#endif

#ifdef FILTER193                       /* no adaptive filtering ? */
    if (pData->iFilter == MNG_FILTER_NOFILTER)
      pData->iPixelofs = pData->iFilterofs;
    else
#endif
      pData->iPixelofs = pData->iFilterofs + 1;

    if (pData->fInitrowproc)           /* need to initialize row processing? */
    {
      iRetcode = ((mng_initrowproc)pData->fInitrowproc) (pData);
      if (iRetcode)
      {
         MNG_FREEX (pData, pBuf, iBufsize);
         return iRetcode;
      }
    }
                                       /* calculate remainder of buffer */
    pTemp    = pBuf + (mng_int32)(pANG->iNumframes * iSize);
    iTemplen = iRealsize - (mng_int32)(pANG->iNumframes * iSize);

    do
    {
      if (iTemplen > pData->iRowmax)   /* get a pixel-row from the temp buffer */
      {
        MNG_COPY (pData->pWorkrow, pTemp, pData->iRowmax);
      }
      else
      {
        MNG_COPY (pData->pWorkrow, pTemp, iTemplen);
      }

      {                                /* image not completed yet ? */
        if (pData->iRow < (mng_int32)pData->iDataheight)
        {
#ifdef MNG_NO_1_2_4BIT_SUPPORT
          if (pData->iPNGdepth == 1)
          {
            /* Inflate Workrow to 8-bit */
            mng_int32  iX;
            mng_uint8p pSrc = pData->pWorkrow+1;
            mng_uint8p pDest = pSrc + pData->iRowsize - (pData->iRowsize+7)/8;

            for (iX = ((pData->iRowsize+7)/8) ; iX > 0 ; iX--)
              *pDest++ = *pSrc++;

            pDest = pData->pWorkrow+1;
            pSrc = pDest + pData->iRowsize - (pData->iRowsize+7)/8;
            for (iX = pData->iRowsize; ;)
            {
              *pDest++ = (((*pSrc)>>7)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>6)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>5)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>4)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>3)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>2)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>1)&1);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)   )&1);
              if (iX-- <= 0)
                break;
              pSrc++;
            }
          }
          else if (pData->iPNGdepth == 2)
          {
            /* Inflate Workrow to 8-bit */
            mng_int32  iX;
            mng_uint8p pSrc = pData->pWorkrow+1;
            mng_uint8p pDest = pSrc + pData->iRowsize - (2*pData->iRowsize+7)/8;

            for (iX = ((2*pData->iRowsize+7)/8) ; iX > 0 ; iX--)
               *pDest++ = *pSrc++;

            pDest = pData->pWorkrow+1;
            pSrc = pDest + pData->iRowsize - (2*pData->iRowsize+7)/8;
            for (iX = pData->iRowsize; ;)
            {
              *pDest++ = (((*pSrc)>>6)&3);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>4)&3);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)>>2)&3);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)   )&3);
              if (iX-- <= 0)
                break;
              pSrc++;
            }
          }
          else if (pData->iPNGdepth == 4)
          {
            /* Inflate Workrow to 8-bit */
            mng_int32  iX;
            mng_uint8p pSrc = pData->pWorkrow+1;
            mng_uint8p pDest = pSrc + pData->iRowsize - (4*pData->iRowsize+7)/8;

            for (iX = ((4*pData->iRowsize+7)/8) ; iX > 0 ; iX--)
               *pDest++ = *pSrc++;

            pDest = pData->pWorkrow+1;
            pSrc = pDest + pData->iRowsize - (4*pData->iRowsize+7)/8;
            for (iX = pData->iRowsize; ;)
            {
              *pDest++ = (((*pSrc)>>4)&0x0f);
              if (iX-- <= 0)
                break;
              *pDest++ = (((*pSrc)   )&0x0f);
              if (iX-- <= 0)
                break;
              pSrc++;
            }
          }
          if (pData->iPNGdepth < 8 && pData->iColortype == 0)
          {
            /* Expand samples to 8-bit by LBR */
            mng_int32  iX;
            mng_uint8p pSrc = pData->pWorkrow+1;
            mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1};

            for (iX = pData->iRowsize; iX > 0; iX--)
                *pSrc++ *= multiplier[pData->iPNGdepth];
          }
#endif
#ifdef MNG_NO_16BIT_SUPPORT
          if (pData->iPNGdepth > 8)
          {
            /* Reduce Workrow to 8-bit */
            mng_int32  iX;
            mng_uint8p pSrc = pData->pWorkrow+1;
            mng_uint8p pDest = pSrc;

            for (iX = pData->iRowsize; iX > 0; iX--)
            {
              *pDest = *pSrc;
              pDest++;
              pSrc+=2;
            }
          }
#endif

#ifdef FILTER192                       /* has leveling info ? */
          if (pData->iFilterofs == MNG_FILTER_DIFFERING)
            iRetcode = init_rowdiffering (pData);
          else
#endif
            iRetcode = MNG_NOERROR;
                                       /* filter the row if necessary */
          if ((!iRetcode) && (pData->iFilterofs < pData->iPixelofs  ) &&
                             (*(pData->pWorkrow + pData->iFilterofs))    )
            iRetcode = mng_filter_a_row (pData);

                                       /* additional leveling/differing ? */
          if ((!iRetcode) && (pData->fDifferrow))
          {
            iRetcode = ((mng_differrow)pData->fDifferrow) (pData);

            pSwap           = pData->pWorkrow;
            pData->pWorkrow = pData->pPrevrow;
            pData->pPrevrow = pSwap;   /* make sure we're processing the right data */
          }

          if (!iRetcode)
          {
            {                          /* process this row */
              if ((!iRetcode) && (pData->fProcessrow))
                iRetcode = ((mng_processrow)pData->fProcessrow) (pData);
                                       /* store in object ? */
              if ((!iRetcode) && (pData->fStorerow))
                iRetcode = ((mng_storerow)pData->fStorerow)     (pData);
            }
          }

          if (iRetcode)                   /* on error bail out */
          {
            MNG_FREEX (pData, pBuf, iBufsize);
            MNG_ERROR (pData, iRetcode);
          }

          if (!pData->fDifferrow)      /* swap row-pointers */
          {
            pSwap           = pData->pWorkrow;
            pData->pWorkrow = pData->pPrevrow;
            pData->pPrevrow = pSwap;   /* so prev points to the processed row! */
          }
                                       /* adjust variables for next row */
          iRetcode = mng_next_row (pData);

          if (iRetcode)                   /* on error bail out */
          {
            MNG_FREEX (pData, pBuf, iBufsize);
            MNG_ERROR (pData, iRetcode);
          }
        }
      }

      pTemp    += pData->iRowmax;
      iTemplen -= pData->iRowmax;
    }                                  /* until some error or EOI
                                          or all pixels received */
    while ( (iTemplen > 0)  &&
            ( (pData->iRow < (mng_int32)pData->iDataheight) ||
              ( (pData->iPass >= 0) && (pData->iPass < 7) )    )    );

    mng_cleanup_rowproc (pData);       /* cleanup row processing buffers !! */

                                       /* restore saved work-parms */
    pData->iDatawidth   = iSavedatawidth;
    pData->iDataheight  = iSavedataheight;

    pData->fInitrowproc = fSaveinitrowproc;
    pData->fDisplayrow  = fSavestorerow;
    pData->fProcessrow  = fSaveprocessrow;
    pData->fDifferrow   = fSavedifferrow;
    pData->pStoreobj    = fSavestoreobj;
    pData->pStorebuf    = fSavestorebuf;

#ifdef MNG_OPTIMIZE_FOOTPRINT_INIT
    pData->ePng_imgtype = eSavepngimgtype;
#endif

    pData->iInterlace   = iSaveinterlace;
    pData->iPass        = iSavepass;
    pData->iRow         = iSaverow;
    pData->iRowinc      = iSaverowinc;
    pData->iCol         = iSavecol;
    pData->iColinc      = iSavecolinc;
    pData->iRowsamples  = iSaverowsamples;
    pData->iSamplemul   = iSavesamplemul;
    pData->iSampleofs   = iSavesampleofs;
    pData->iSamplediv   = iSavesamplediv;
    pData->iRowsize     = iSaverowsize;
    pData->iRowmax      = iSaverowmax;
    pData->iFilterofs   = iSavefilterofs;
    pData->iPixelofs    = iSavepixelofs;
    pData->iLevel0      = iSavelevel0;
    pData->iLevel1      = iSavelevel1;
    pData->iLevel2      = iSavelevel2;
    pData->iLevel3      = iSavelevel3;
    pData->pWorkrow     = pSaveworkrow;
    pData->pPrevrow     = pSaveprevrow;
    pData->pRGBArow     = pSaverGBArow;
    pData->bIsRGBA16    = bSaveisRGBA16;
    pData->bIsOpaque    = bSaveisOpaque;
    pData->iFilterbpp   = iSavefilterbpp;
    pData->iDestl       = iSavedestl;
    pData->iDestt       = iSavedestt;
    pData->iDestr       = iSavedestr;
    pData->iDestb       = iSavedestb;
    pData->iSourcel     = iSavesourcel;
    pData->iSourcet     = iSavesourcet;
    pData->iSourcer     = iSavesourcer;
    pData->iSourceb     = iSavesourceb;

                                       /* create the animation directives ! */
    pProcess = (mng_processobject)pANG->sHeader.fProcess;
    iRetcode = pProcess (pData, (mng_objectp)pData->pANG);
    if (iRetcode)
      return iRetcode;

#endif /* MNG_SUPPORT_DISPLAY */

    MNG_FREE (pData, pBuf, iBufsize);  /* always free the temp buffer ! */
  }

  *piRawlen = 0;

  return MNG_NOERROR;
}
#endif

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

#ifdef MNG_INCLUDE_ANG_PROPOSAL
MNG_C_SPECIALFUNC (mng_special_adat)
{
  return MNG_NOERROR;
}
#endif

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

MNG_C_SPECIALFUNC (mng_special_unknown)
{
                                       /* critical chunk ? */
  if ((((mng_uint32)pData->iChunkname & 0x20000000) == 0)
#ifdef MNG_SKIPCHUNK_SAVE
    && (pData->iChunkname != MNG_UINT_SAVE)
#endif
#ifdef MNG_SKIPCHUNK_SEEK
    && (pData->iChunkname != MNG_UINT_SEEK)
#endif
#ifdef MNG_SKIPCHUNK_DBYK
    && (pData->iChunkname != MNG_UINT_DBYK)
#endif
#ifdef MNG_SKIPCHUNK_ORDR
    && (pData->iChunkname != MNG_UINT_ORDR)
#endif
      )
    MNG_ERROR (pData, MNG_UNKNOWNCRITICAL);

  if (pData->fProcessunknown)          /* let the app handle it ? */
  {
    mng_bool bOke = pData->fProcessunknown ((mng_handle)pData, pData->iChunkname,
                                            ((mng_unknown_chunkp)pChunk)->iDatasize,
                                            ((mng_unknown_chunkp)pChunk)->pData);
    if (!bOke)
      MNG_ERROR (pData, MNG_APPMISCERROR);
  }

  return MNG_NOERROR;                  /* done */
}

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

#endif /* MNG_INCLUDE_READ_PROCS || MNG_INCLUDE_WRITE_PROCS */
#endif /* MNG_OPTIMIZE_CHUNKREADER */

/* ************************************************************************** */
/* * end of file                                                            * */
/* ************************************************************************** */