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