TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-28 11:03:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Torque3D/Engine/lib/lmng/libmng_chunk_descr.c
DavidWyand-GG 7dbfe6994d Engine directory for ticket #1
2012-09-19 11:15:01 -04:00

6090 lines
193 KiB
C
Raw Blame History

/* ************************************************************************** */
/* * 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 * */
/* ************************************************************************** */
Reference in a new issue View git blame Copy permalink