« back to all changes in this revision
Viewing changes to libmng_chunk_io.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Shiju p. Nair
- Date: 2006-04-07 09:49:11 UTC
- mfrom: (0.2.2 upstream)
- Revision ID: james.westby@ubuntu.com-20060407094911-ay3179o63gvlh4ll
Tags: 1.0.9-1
* New upstream release. (closes: #303968, #271979)
* Patch from Aurelien Jarno <aurel32@debian.org> to support GNU/kFreeBSD.
Closes: #314696)
* Patch from Christopher Bodenstein <cb@physicman.net> to support
hurd-i386. (closes: #361103)
* README.Debian provide information on what options are compiled in to
libmng.(closes: #174523)
* Patch from Aurelien Jarno <aurel32@debian.org> to support GNU/kFreeBSD.
Closes: #314696)
* Patch from Christopher Bodenstein <cb@physicman.net> to support
hurd-i386. (closes: #361103)
* README.Debian provide information on what options are compiled in to
libmng.(closes: #174523)
- files added:
- debian/libmng-dev.README.debian
- debian/patches
- unmaintained
- files removed:
- autogen.sh
- files modified:
- CHANGES
added
removed
libmng_chunk_io.c
1
/** ************************************************************************* */
2
/* * For conditions of distribution and use, * */
3
/* * see copyright notice in libmng.h * */
4
/* ************************************************************************** */
5
/* * * */
6
/* * project : libmng * */
7
/* * file : libmng_chunk_io.c copyright (c) 2000-2004 G.Juyn * */
8
/* * version : 1.0.8 * */
9
/* * * */
10
/* * purpose : Chunk I/O routines (implementation) * */
11
/* * * */
12
/* * author : G.Juyn * */
13
/* * * */
14
/* * comment : implementation of chunk input/output routines * */
15
/* * * */
16
/* * changes : 0.5.1 - 05/01/2000 - G.Juyn * */
17
/* * - cleaned up left-over teststuff in the BACK chunk routine * */
18
/* * 0.5.1 - 05/04/2000 - G.Juyn * */
19
/* * - changed CRC initialization to use dynamic structure * */
20
/* * (wasn't thread-safe the old way !) * */
21
/* * 0.5.1 - 05/06/2000 - G.Juyn * */
22
/* * - filled in many missing sequence&length checks * */
23
/* * - filled in many missing chunk-store snippets * */
24
/* * 0.5.1 - 05/08/2000 - G.Juyn * */
25
/* * - added checks for running animations * */
26
/* * - filled some write routines * */
27
/* * - changed strict-ANSI stuff * */
28
/* * 0.5.1 - 05/10/2000 - G.Juyn * */
29
/* * - filled some more write routines * */
30
/* * 0.5.1 - 05/11/2000 - G.Juyn * */
31
/* * - filled remaining write routines * */
32
/* * - fixed read_pplt with regard to deltatype * */
33
/* * - added callback error-reporting support * */
34
/* * - added pre-draft48 support (short MHDR, frame_mode, LOOP) * */
35
/* * 0.5.1 - 05/12/2000 - G.Juyn * */
36
/* * - changed trace to macro for callback error-reporting * */
37
/* * - fixed chunk-storage bit in several routines * */
38
/* * 0.5.1 - 05/13/2000 - G.Juyn * */
39
/* * - added eMNGma hack (will be removed in 1.0.0 !!!) * */
40
/* * - added TERM animation object pointer (easier reference) * */
41
/* * - supplemented the SAVE & SEEK display processing * */
42
/* * * */
43
/* * 0.5.2 - 05/18/2000 - G.Juyn * */
44
/* * - B004 - fixed problem with MNG_SUPPORT_WRITE not defined * */
45
/* * also for MNG_SUPPORT_WRITE without MNG_INCLUDE_JNG * */
46
/* * 0.5.2 - 05/19/2000 - G.Juyn * */
47
/* * - cleaned up some code regarding mixed support * */
48
/* * 0.5.2 - 05/20/2000 - G.Juyn * */
49
/* * - implemented JNG support * */
50
/* * 0.5.2 - 05/24/2000 - G.Juyn * */
51
/* * - added support for global color-chunks in animation * */
52
/* * - added support for global PLTE,tRNS,bKGD in animation * */
53
/* * - added support for SAVE & SEEK in animation * */
54
/* * 0.5.2 - 05/29/2000 - G.Juyn * */
55
/* * - changed ani_create calls not returning object pointer * */
56
/* * - create ani objects always (not just inside TERM/LOOP) * */
57
/* * 0.5.2 - 05/30/2000 - G.Juyn * */
58
/* * - added support for delta-image processing * */
59
/* * 0.5.2 - 05/31/2000 - G.Juyn * */
60
/* * - fixed up punctuation (contributed by Tim Rowley) * */
61
/* * 0.5.2 - 06/02/2000 - G.Juyn * */
62
/* * - changed SWAP_ENDIAN to BIGENDIAN_SUPPORTED * */
63
/* * 0.5.2 - 06/03/2000 - G.Juyn * */
64
/* * - fixed makeup for Linux gcc compile * */
65
/* * * */
66
/* * 0.5.3 - 06/12/2000 - G.Juyn * */
67
/* * - added processing of color-info on delta-image * */
68
/* * 0.5.3 - 06/13/2000 - G.Juyn * */
69
/* * - fixed handling of empty SAVE chunk * */
70
/* * 0.5.3 - 06/17/2000 - G.Juyn * */
71
/* * - changed to support delta-images * */
72
/* * - added extra checks for delta-images * */
73
/* * 0.5.3 - 06/20/2000 - G.Juyn * */
74
/* * - fixed possible trouble if IEND display-process got * */
75
/* * broken up * */
76
/* * 0.5.3 - 06/21/2000 - G.Juyn * */
77
/* * - added processing of PLTE & tRNS for delta-images * */
78
/* * - added administration of imagelevel parameter * */
79
/* * 0.5.3 - 06/22/2000 - G.Juyn * */
80
/* * - implemented support for PPLT chunk * */
81
/* * 0.5.3 - 06/26/2000 - G.Juyn * */
82
/* * - added precaution against faulty iCCP chunks from PS * */
83
/* * 0.5.3 - 06/29/2000 - G.Juyn * */
84
/* * - fixed some 64-bit warnings * */
85
/* * * */
86
/* * 0.9.1 - 07/14/2000 - G.Juyn * */
87
/* * - changed pre-draft48 frame_mode=3 to frame_mode=1 * */
88
/* * 0.9.1 - 07/16/2000 - G.Juyn * */
89
/* * - fixed storage of images during mng_read() * */
90
/* * - fixed support for mng_display() after mng_read() * */
91
/* * 0.9.1 - 07/19/2000 - G.Juyn * */
92
/* * - fixed several chunk-writing routines * */
93
/* * 0.9.1 - 07/24/2000 - G.Juyn * */
94
/* * - fixed reading of still-images * */
95
/* * * */
96
/* * 0.9.2 - 08/05/2000 - G.Juyn * */
97
/* * - changed file-prefixes * */
98
/* * * */
99
/* * 0.9.3 - 08/07/2000 - G.Juyn * */
100
/* * - B111300 - fixup for improved portability * */
101
/* * 0.9.3 - 08/08/2000 - G.Juyn * */
102
/* * - fixed compiler-warnings from Mozilla * */
103
/* * 0.9.3 - 08/09/2000 - G.Juyn * */
104
/* * - added check for simplicity-bits in MHDR * */
105
/* * 0.9.3 - 08/12/2000 - G.Juyn * */
106
/* * - fixed check for simplicity-bits in MHDR (JNG) * */
107
/* * 0.9.3 - 08/12/2000 - G.Juyn * */
108
/* * - added workaround for faulty PhotoShop iCCP chunk * */
109
/* * 0.9.3 - 08/22/2000 - G.Juyn * */
110
/* * - fixed write-code for zTXt & iTXt * */
111
/* * - fixed read-code for iTXt * */
112
/* * 0.9.3 - 08/26/2000 - G.Juyn * */
113
/* * - added MAGN chunk * */
114
/* * 0.9.3 - 09/07/2000 - G.Juyn * */
115
/* * - added support for new filter_types * */
116
/* * 0.9.3 - 09/10/2000 - G.Juyn * */
117
/* * - fixed DEFI behavior * */
118
/* * 0.9.3 - 10/02/2000 - G.Juyn * */
119
/* * - fixed simplicity-check in compliance with draft 81/0.98a * */
120
/* * 0.9.3 - 10/10/2000 - G.Juyn * */
121
/* * - added support for alpha-depth prediction * */
122
/* * 0.9.3 - 10/11/2000 - G.Juyn * */
123
/* * - added support for nEED * */
124
/* * 0.9.3 - 10/16/2000 - G.Juyn * */
125
/* * - added support for JDAA * */
126
/* * 0.9.3 - 10/17/2000 - G.Juyn * */
127
/* * - fixed support for MAGN * */
128
/* * - implemented nEED "xxxx" (where "xxxx" is a chunkid) * */
129
/* * - added callback to process non-critical unknown chunks * */
130
/* * - fixed support for bKGD * */
131
/* * 0.9.3 - 10/23/2000 - G.Juyn * */
132
/* * - fixed bug in empty PLTE handling * */
133
/* * * */
134
/* * 0.9.4 - 11/20/2000 - G.Juyn * */
135
/* * - changed IHDR filter_method check for PNGs * */
136
/* * 0.9.4 - 1/18/2001 - G.Juyn * */
137
/* * - added errorchecking for MAGN methods * */
138
/* * - removed test filter-methods 1 & 65 * */
139
/* * * */
140
/* * 0.9.5 - 1/25/2001 - G.Juyn * */
141
/* * - fixed some small compiler warnings (thanks Nikki) * */
142
/* * * */
143
/* * 1.0.2 - 05/05/2000 - G.Juyn * */
144
/* * - B421427 - writes wrong format in bKGD and tRNS * */
145
/* * 1.0.2 - 06/20/2000 - G.Juyn * */
146
/* * - B434583 - compiler-warning if MNG_STORE_CHUNKS undefined * */
147
/* * * */
148
/* * 1.0.5 - 07/08/2002 - G.Juyn * */
149
/* * - B578572 - removed eMNGma hack (thanks Dimitri!) * */
150
/* * 1.0.5 - 08/07/2002 - G.Juyn * */
151
/* * - added test-option for PNG filter method 193 (=no filter) * */
152
/* * 1.0.5 - 08/15/2002 - G.Juyn * */
153
/* * - completed PROM support * */
154
/* * 1.0.5 - 08/19/2002 - G.Juyn * */
155
/* * - B597134 - libmng pollutes the linker namespace * */
156
/* * 1.0.5 - 09/07/2002 - G.Juyn * */
157
/* * - fixed reading of FRAM with just frame_mode and name * */
158
/* * 1.0.5 - 09/13/2002 - G.Juyn * */
159
/* * - fixed read/write of MAGN chunk * */
160
/* * 1.0.5 - 09/14/2002 - G.Juyn * */
161
/* * - added event handling for dynamic MNG * */
162
/* * 1.0.5 - 09/15/2002 - G.Juyn * */
163
/* * - fixed LOOP iteration=0 special case * */
164
/* * 1.0.5 - 09/19/2002 - G.Juyn * */
165
/* * - misplaced TERM is now treated as warning * */
166
/* * 1.0.5 - 09/20/2002 - G.Juyn * */
167
/* * - added support for PAST * */
168
/* * 1.0.5 - 10/03/2002 - G.Juyn * */
169
/* * - fixed chunk-storage for evNT chunk * */
170
/* * 1.0.5 - 10/07/2002 - G.Juyn * */
171
/* * - fixed DISC support * */
172
/* * - added another fix for misplaced TERM chunk * */
173
/* * 1.0.5 - 10/17/2002 - G.Juyn * */
174
/* * - fixed initializtion of pIds in dISC read routine * */
175
/* * 1.0.5 - 11/06/2002 - G.Juyn * */
176
/* * - added support for nEED "MNG 1.1" * */
177
/* * - added support for nEED "CACHEOFF" * */
178
/* * * */
179
/* * 1.0.6 - 05/25/2003 - G.R-P * */
180
/* * - added MNG_SKIPCHUNK_cHNK footprint optimizations * */
181
/* * 1.0.6 - 06/02/2003 - G.R-P * */
182
/* * - removed some redundant checks for iRawlen==0 * */
183
/* * 1.0.6 - 06/22/2003 - G.R-P * */
184
/* * - added MNG_NO_16BIT_SUPPORT, MNG_NO_DELTA_PNG reductions * */
185
/* * - optionally use zlib's crc32 function instead of * */
186
/* * local mng_update_crc * */
187
/* * 1.0.6 - 07/14/2003 - G.R-P * */
188
/* * - added MNG_NO_LOOP_SIGNALS_SUPPORTED conditional * */
189
/* * 1.0.6 - 07/29/2003 - G.R-P * */
190
/* * - added conditionals around PAST chunk support * */
191
/* * 1.0.6 - 08/17/2003 - G.R-P * */
192
/* * - added conditionals around non-VLC chunk support * */
193
/* * * */
194
/* * 1.0.7 - 10/29/2003 - G.R-P * */
195
/* * - revised JDAA and JDAT readers to avoid compiler bug * */
196
/* * 1.0.7 - 01/25/2004 - J.S * */
197
/* * - added premultiplied alpha canvas' for RGBA, ARGB, ABGR * */
198
/* * 1.0.7 - 01/27/2004 - J.S * */
199
/* * - fixed inclusion of IJNG chunk for non-JNG use * */
200
/* * 1.0.7 - 02/26/2004 - G.Juyn * */
201
/* * - fixed bug in chunk-storage of SHOW chunk (from == to) * */
202
/* * * */
203
/* * 1.0.8 - 04/02/2004 - G.Juyn * */
204
/* * - added CRC existence & checking flags * */
205
/* * 1.0.8 - 07/07/2004 - G.R-P * */
206
/* * - change worst-case iAlphadepth to 1 for standalone PNGs * */
207
/* * * */
208
/* ************************************************************************** */
209
210
#include "libmng.h"
211
#include "libmng_data.h"
212
#include "libmng_error.h"
213
#include "libmng_trace.h"
214
#ifdef __BORLANDC__
215
#pragma hdrstop
216
#endif
217
#include "libmng_objects.h"
218
#include "libmng_object_prc.h"
219
#include "libmng_chunks.h"
220
#ifdef MNG_CHECK_BAD_ICCP
221
#include "libmng_chunk_prc.h"
222
#endif
223
#include "libmng_memory.h"
224
#include "libmng_display.h"
225
#include "libmng_zlib.h"
226
#include "libmng_pixels.h"
227
#include "libmng_chunk_io.h"
228
229
#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
230
#pragma option -A /* force ANSI-C */
231
#endif
232
233
/* ************************************************************************** */
234
/* * * */
235
/* * CRC - Cyclic Redundancy Check * */
236
/* * * */
237
/* * The code below is taken directly from the sample provided with the * */
238
/* * PNG specification. * */
239
/* * (it is only adapted to the library's internal data-definitions) * */
240
/* * * */
241
/* ************************************************************************** */
242
/* Make the table for a fast CRC. */
243
#ifndef MNG_USE_ZLIB_CRC
244
MNG_LOCAL void make_crc_table (mng_datap pData)
245
{
246
mng_uint32 iC;
247
mng_int32 iN, iK;
248
249
for (iN = 0; iN < 256; iN++)
250
{
251
iC = (mng_uint32) iN;
252
253
for (iK = 0; iK < 8; iK++)
254
{
255
if (iC & 1)
256
iC = 0xedb88320U ^ (iC >> 1);
257
else
258
iC = iC >> 1;
259
}
260
261
pData->aCRCtable [iN] = iC;
262
}
263
264
pData->bCRCcomputed = MNG_TRUE;
265
}
266
#endif
267
268
/* Update a running CRC with the bytes buf[0..len-1]--the CRC
269
should be initialized to all 1's, and the transmitted value
270
is the 1's complement of the final running CRC (see the
271
crc() routine below). */
272
273
MNG_LOCAL mng_uint32 update_crc (mng_datap pData,
274
mng_uint32 iCrc,
275
mng_uint8p pBuf,
276
mng_int32 iLen)
277
{
278
#ifdef MNG_USE_ZLIB_CRC
279
return crc32 (iCrc, pBuf, iLen);
280
#else
281
mng_uint32 iC = iCrc;
282
mng_int32 iN;
283
284
if (!pData->bCRCcomputed)
285
make_crc_table (pData);
286
287
for (iN = 0; iN < iLen; iN++)
288
iC = pData->aCRCtable [(iC ^ pBuf [iN]) & 0xff] ^ (iC >> 8);
289
290
return iC;
291
#endif
292
}
293
294
/* Return the CRC of the bytes buf[0..len-1]. */
295
mng_uint32 mng_crc (mng_datap pData,
296
mng_uint8p pBuf,
297
mng_int32 iLen)
298
{
299
#ifdef MNG_USE_ZLIB_CRC
300
return update_crc (pData, 0, pBuf, iLen);
301
#else
302
return update_crc (pData, 0xffffffffU, pBuf, iLen) ^ 0xffffffffU;
303
#endif
304
}
305
306
/* ************************************************************************** */
307
/* * * */
308
/* * Routines for swapping byte-order from and to graphic files * */
309
/* * (This code is adapted from the libpng package) * */
310
/* * * */
311
/* ************************************************************************** */
312
313
#ifndef MNG_BIGENDIAN_SUPPORTED
314
315
/* ************************************************************************** */
316
317
mng_uint32 mng_get_uint32 (mng_uint8p pBuf)
318
{
319
mng_uint32 i = ((mng_uint32)(*pBuf) << 24) +
320
((mng_uint32)(*(pBuf + 1)) << 16) +
321
((mng_uint32)(*(pBuf + 2)) << 8) +
322
(mng_uint32)(*(pBuf + 3));
323
return (i);
324
}
325
326
/* ************************************************************************** */
327
328
mng_int32 mng_get_int32 (mng_uint8p pBuf)
329
{
330
mng_int32 i = ((mng_int32)(*pBuf) << 24) +
331
((mng_int32)(*(pBuf + 1)) << 16) +
332
((mng_int32)(*(pBuf + 2)) << 8) +
333
(mng_int32)(*(pBuf + 3));
334
return (i);
335
}
336
337
/* ************************************************************************** */
338
339
mng_uint16 mng_get_uint16 (mng_uint8p pBuf)
340
{
341
mng_uint16 i = (mng_uint16)(((mng_uint16)(*pBuf) << 8) +
342
(mng_uint16)(*(pBuf + 1)));
343
return (i);
344
}
345
346
/* ************************************************************************** */
347
348
void mng_put_uint32 (mng_uint8p pBuf,
349
mng_uint32 i)
350
{
351
*pBuf = (mng_uint8)((i >> 24) & 0xff);
352
*(pBuf+1) = (mng_uint8)((i >> 16) & 0xff);
353
*(pBuf+2) = (mng_uint8)((i >> 8) & 0xff);
354
*(pBuf+3) = (mng_uint8)(i & 0xff);
355
}
356
357
/* ************************************************************************** */
358
359
void mng_put_int32 (mng_uint8p pBuf,
360
mng_int32 i)
361
{
362
*pBuf = (mng_uint8)((i >> 24) & 0xff);
363
*(pBuf+1) = (mng_uint8)((i >> 16) & 0xff);
364
*(pBuf+2) = (mng_uint8)((i >> 8) & 0xff);
365
*(pBuf+3) = (mng_uint8)(i & 0xff);
366
}
367
368
/* ************************************************************************** */
369
370
void mng_put_uint16 (mng_uint8p pBuf,
371
mng_uint16 i)
372
{
373
*pBuf = (mng_uint8)((i >> 8) & 0xff);
374
*(pBuf+1) = (mng_uint8)(i & 0xff);
375
}
376
377
/* ************************************************************************** */
378
379
#endif /* !MNG_BIGENDIAN_SUPPORTED */
380
381
/* ************************************************************************** */
382
/* * * */
383
/* * Helper routines to simplify chunk-data extraction * */
384
/* * * */
385
/* ************************************************************************** */
386
387
#ifdef MNG_INCLUDE_READ_PROCS
388
389
/* ************************************************************************** */
390
391
MNG_LOCAL mng_uint8p find_null (mng_uint8p pIn)
392
{
393
mng_uint8p pOut = pIn;
394
395
while (*pOut) /* the read_graphic routine has made sure there's */
396
pOut++; /* always at least 1 zero-byte in the buffer */
397
398
return pOut;
399
}
400
401
/* ************************************************************************** */
402
403
#if !defined(MNG_SKIPCHUNK_iCCP) && !defined(MNG_SKIPCHUNK_zTXt) && !defined(MNG_SKIPCHUNK_iTXt)
404
MNG_LOCAL mng_retcode inflate_buffer (mng_datap pData,
405
mng_uint8p pInbuf,
406
mng_uint32 iInsize,
407
mng_uint8p *pOutbuf,
408
mng_uint32 *iOutsize,
409
mng_uint32 *iRealsize)
410
{
411
mng_retcode iRetcode = MNG_NOERROR;
412
413
#ifdef MNG_SUPPORT_TRACE
414
MNG_TRACE (pData, MNG_FN_INFLATE_BUFFER, MNG_LC_START)
415
#endif
416
417
if (iInsize) /* anything to do ? */
418
{
419
*iOutsize = iInsize * 3; /* estimate uncompressed size */
420
/* and allocate a temporary buffer */
421
MNG_ALLOC (pData, *pOutbuf, *iOutsize)
422
423
do
424
{
425
mngzlib_inflateinit (pData); /* initialize zlib */
426
/* let zlib know where to store the output */
427
pData->sZlib.next_out = *pOutbuf;
428
/* "size - 1" so we've got space for the
429
zero-termination of a possible string */
430
pData->sZlib.avail_out = *iOutsize - 1;
431
/* ok; let's inflate... */
432
iRetcode = mngzlib_inflatedata (pData, iInsize, pInbuf);
433
/* determine actual output size */
434
*iRealsize = (mng_uint32)pData->sZlib.total_out;
435
436
mngzlib_inflatefree (pData); /* zlib's done */
437
438
if (iRetcode == MNG_BUFOVERFLOW) /* not enough space ? */
439
{ /* then get some more */
440
MNG_FREEX (pData, *pOutbuf, *iOutsize)
441
*iOutsize = *iOutsize + iInsize;
442
MNG_ALLOC (pData, *pOutbuf, *iOutsize)
443
}
444
} /* repeat if we didn't have enough space */
445
while ((iRetcode == MNG_BUFOVERFLOW) &&
446
(*iOutsize < 20 * iInsize));
447
448
if (!iRetcode) /* if oke ? */
449
*((*pOutbuf) + *iRealsize) = 0; /* then put terminator zero */
450
451
}
452
else
453
{
454
*pOutbuf = 0; /* nothing to do; then there's no output */
455
*iOutsize = 0;
456
*iRealsize = 0;
457
}
458
459
#ifdef MNG_SUPPORT_TRACE
460
MNG_TRACE (pData, MNG_FN_INFLATE_BUFFER, MNG_LC_END)
461
#endif
462
463
return iRetcode;
464
}
465
#endif
466
467
/* ************************************************************************** */
468
469
#endif /* MNG_INCLUDE_READ_PROCS */
470
471
/* ************************************************************************** */
472
/* * * */
473
/* * Helper routines to simplify chunk writing * */
474
/* * * */
475
/* ************************************************************************** */
476
#ifdef MNG_INCLUDE_WRITE_PROCS
477
/* ************************************************************************** */
478
479
#if !defined(MNG_SKIPCHUNK_iCCP) && !defined(MNG_SKIPCHUNK_zTXt) && !defined(MNG_SKIPCHUNK_iTXt)
480
MNG_LOCAL mng_retcode deflate_buffer (mng_datap pData,
481
mng_uint8p pInbuf,
482
mng_uint32 iInsize,
483
mng_uint8p *pOutbuf,
484
mng_uint32 *iOutsize,
485
mng_uint32 *iRealsize)
486
{
487
mng_retcode iRetcode = MNG_NOERROR;
488
489
#ifdef MNG_SUPPORT_TRACE
490
MNG_TRACE (pData, MNG_FN_DEFLATE_BUFFER, MNG_LC_START)
491
#endif
492
493
if (iInsize) /* anything to do ? */
494
{
495
*iOutsize = (iInsize * 5) >> 2; /* estimate compressed size */
496
/* and allocate a temporary buffer */
497
MNG_ALLOC (pData, *pOutbuf, *iOutsize)
498
499
do
500
{
501
mngzlib_deflateinit (pData); /* initialize zlib */
502
/* let zlib know where to store the output */
503
pData->sZlib.next_out = *pOutbuf;
504
pData->sZlib.avail_out = *iOutsize;
505
/* ok; let's deflate... */
506
iRetcode = mngzlib_deflatedata (pData, iInsize, pInbuf);
507
/* determine actual output size */
508
*iRealsize = pData->sZlib.total_out;
509
510
mngzlib_deflatefree (pData); /* zlib's done */
511
512
if (iRetcode == MNG_BUFOVERFLOW) /* not enough space ? */
513
{ /* then get some more */
514
MNG_FREEX (pData, *pOutbuf, *iOutsize)
515
*iOutsize = *iOutsize + (iInsize >> 1);
516
MNG_ALLOC (pData, *pOutbuf, *iOutsize)
517
}
518
} /* repeat if we didn't have enough space */
519
while (iRetcode == MNG_BUFOVERFLOW);
520
}
521
else
522
{
523
*pOutbuf = 0; /* nothing to do; then there's no output */
524
*iOutsize = 0;
525
*iRealsize = 0;
526
}
527
528
#ifdef MNG_SUPPORT_TRACE
529
MNG_TRACE (pData, MNG_FN_DEFLATE_BUFFER, MNG_LC_END)
530
#endif
531
532
return iRetcode;
533
}
534
#endif
535
536
/* ************************************************************************** */
537
538
MNG_LOCAL mng_retcode write_raw_chunk (mng_datap pData,
539
mng_chunkid iChunkname,
540
mng_uint32 iRawlen,
541
mng_uint8p pRawdata)
542
{
543
mng_uint32 iCrc;
544
mng_uint32 iWritten;
545
546
#ifdef MNG_SUPPORT_TRACE
547
MNG_TRACE (pData, MNG_FN_WRITE_RAW_CHUNK, MNG_LC_START)
548
#endif
549
/* temporary buffer ? */
550
if ((pRawdata != 0) && (pRawdata != pData->pWritebuf+8))
551
{ /* store length & chunktype in default buffer */
552
mng_put_uint32 (pData->pWritebuf, iRawlen);
553
mng_put_uint32 (pData->pWritebuf+4, (mng_uint32)iChunkname);
554
555
if (pData->iCrcmode & MNG_CRC_OUTPUT)
556
{
557
if ((pData->iCrcmode & MNG_CRC_OUTPUT) == MNG_CRC_OUTPUT_GENERATE)
558
{ /* calculate the crc */
559
iCrc = update_crc (pData, 0xffffffffL, pData->pWritebuf+4, 4);
560
iCrc = update_crc (pData, iCrc, pRawdata, iRawlen) ^ 0xffffffffL;
561
} else {
562
iCrc = 0; /* dummy crc */
563
} /* store in default buffer */
564
mng_put_uint32 (pData->pWritebuf+8, iCrc);
565
}
566
/* write the length & chunktype */
567
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, 8, &iWritten))
568
MNG_ERROR (pData, MNG_APPIOERROR)
569
570
if (iWritten != 8) /* disk full ? */
571
MNG_ERROR (pData, MNG_OUTPUTERROR)
572
/* write the temporary buffer */
573
if (!pData->fWritedata ((mng_handle)pData, pRawdata, iRawlen, &iWritten))
574
MNG_ERROR (pData, MNG_APPIOERROR)
575
576
if (iWritten != iRawlen) /* disk full ? */
577
MNG_ERROR (pData, MNG_OUTPUTERROR)
578
579
if (pData->iCrcmode & MNG_CRC_OUTPUT)
580
{ /* write the crc */
581
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf+8, 4, &iWritten))
582
MNG_ERROR (pData, MNG_APPIOERROR)
583
584
if (iWritten != 4) /* disk full ? */
585
MNG_ERROR (pData, MNG_OUTPUTERROR)
586
}
587
}
588
else
589
{ /* prefix with length & chunktype */
590
mng_put_uint32 (pData->pWritebuf, iRawlen);
591
mng_put_uint32 (pData->pWritebuf+4, (mng_uint32)iChunkname);
592
593
if (pData->iCrcmode & MNG_CRC_OUTPUT)
594
{
595
if ((pData->iCrcmode & MNG_CRC_OUTPUT) == MNG_CRC_OUTPUT_GENERATE)
596
/* calculate the crc */
597
iCrc = mng_crc (pData, pData->pWritebuf+4, iRawlen + 4);
598
else
599
iCrc = 0; /* dummy crc */
600
/* add it to the buffer */
601
mng_put_uint32 (pData->pWritebuf + iRawlen + 8, iCrc);
602
/* write it in a single pass */
603
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, iRawlen + 12, &iWritten))
604
MNG_ERROR (pData, MNG_APPIOERROR)
605
606
if (iWritten != iRawlen + 12) /* disk full ? */
607
MNG_ERROR (pData, MNG_OUTPUTERROR)
608
} else {
609
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, iRawlen + 8, &iWritten))
610
MNG_ERROR (pData, MNG_APPIOERROR)
611
612
if (iWritten != iRawlen + 8) /* disk full ? */
613
MNG_ERROR (pData, MNG_OUTPUTERROR)
614
}
615
}
616
617
#ifdef MNG_SUPPORT_TRACE
618
MNG_TRACE (pData, MNG_FN_WRITE_RAW_CHUNK, MNG_LC_END)
619
#endif
620
621
return MNG_NOERROR;
622
}
623
624
/* ************************************************************************** */
625
/* B004 */
626
#endif /* MNG_INCLUDE_WRITE_PROCS */
627
/* B004 */
628
/* ************************************************************************** */
629
/* * * */
630
/* * chunk read functions * */
631
/* * * */
632
/* ************************************************************************** */
633
634
#ifdef MNG_INCLUDE_READ_PROCS
635
636
/* ************************************************************************** */
637
638
READ_CHUNK (mng_read_ihdr)
639
{
640
#ifdef MNG_SUPPORT_TRACE
641
MNG_TRACE (pData, MNG_FN_READ_IHDR, MNG_LC_START)
642
#endif
643
644
if (iRawlen != 13) /* length oke ? */
645
MNG_ERROR (pData, MNG_INVALIDLENGTH)
646
/* only allowed inside PNG or MNG */
647
if ((pData->eSigtype != mng_it_png) && (pData->eSigtype != mng_it_mng))
648
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED)
649
/* sequence checks */
650
if ((pData->eSigtype == mng_it_png) && (pData->iChunkseq > 1))
651
MNG_ERROR (pData, MNG_SEQUENCEERROR)
652
653
#ifdef MNG_INCLUDE_JNG
654
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasIDAT) || (pData->bHasJHDR))
655
#else
656
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasIDAT))
657
#endif
658
MNG_ERROR (pData, MNG_SEQUENCEERROR)
659
660
pData->bHasIHDR = MNG_TRUE; /* indicate IHDR is present */
661
/* and store interesting fields */
662
if ((!pData->bHasDHDR) || (pData->iDeltatype == MNG_DELTATYPE_NOCHANGE))
663
{
664
pData->iDatawidth = mng_get_uint32 (pRawdata);
665
pData->iDataheight = mng_get_uint32 (pRawdata+4);
666
}
667
668
pData->iBitdepth = *(pRawdata+8);
669
pData->iColortype = *(pRawdata+9);
670
pData->iCompression = *(pRawdata+10);
671
pData->iFilter = *(pRawdata+11);
672
pData->iInterlace = *(pRawdata+12);
673
674
#if defined(MNG_NO_16BIT_SUPPORT)
675
pData->iPNGmult = 1;
676
pData->iPNGdepth = pData->iBitdepth;
677
678
if (pData->iBitdepth > 8)
679
{
680
pData->iBitdepth = 8;
681
pData->iPNGmult = 2;
682
}
683
#endif
684
685
if ((pData->iBitdepth != 8) /* parameter validity checks */
686
&& (pData->iBitdepth != 1) &&
687
(pData->iBitdepth != 2) &&
688
(pData->iBitdepth != 4)
689
#ifndef MNG_NO_16BIT_SUPPORT
690
&& (pData->iBitdepth != 16)
691
#endif
692
)
693
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
694
695
if ((pData->iColortype != MNG_COLORTYPE_GRAY ) &&
696
(pData->iColortype != MNG_COLORTYPE_RGB ) &&
697
(pData->iColortype != MNG_COLORTYPE_INDEXED) &&
698
(pData->iColortype != MNG_COLORTYPE_GRAYA ) &&
699
(pData->iColortype != MNG_COLORTYPE_RGBA ) )
700
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
701
702
if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
703
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
704
705
if (((pData->iColortype == MNG_COLORTYPE_RGB ) ||
706
(pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
707
(pData->iColortype == MNG_COLORTYPE_RGBA ) ) &&
708
(pData->iBitdepth < 8 ) )
709
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
710
711
if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
712
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
713
714
#if defined(FILTER192) || defined(FILTER193)
715
if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
716
#if defined(FILTER192) && defined(FILTER193)
717
(pData->iFilter != MNG_FILTER_DIFFERING) &&
718
(pData->iFilter != MNG_FILTER_NOFILTER ) )
719
#else
720
#ifdef FILTER192
721
(pData->iFilter != MNG_FILTER_DIFFERING) )
722
#else
723
(pData->iFilter != MNG_FILTER_NOFILTER ) )
724
#endif
725
#endif
726
MNG_ERROR (pData, MNG_INVALIDFILTER)
727
#else
728
if (pData->iFilter)
729
MNG_ERROR (pData, MNG_INVALIDFILTER)
730
#endif
731
732
if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
733
(pData->iInterlace != MNG_INTERLACE_ADAM7) )
734
MNG_ERROR (pData, MNG_INVALIDINTERLACE)
735
736
#ifdef MNG_SUPPORT_DISPLAY
737
#ifndef MNG_NO_DELTA_PNG
738
if (pData->bHasDHDR) /* check the colortype for delta-images ! */
739
{
740
mng_imagedatap pBuf = ((mng_imagep)pData->pObjzero)->pImgbuf;
741
742
if (pData->iColortype != pBuf->iColortype)
743
{
744
if ( ( (pData->iColortype != MNG_COLORTYPE_INDEXED) ||
745
(pBuf->iColortype == MNG_COLORTYPE_GRAY ) ) &&
746
( (pData->iColortype != MNG_COLORTYPE_GRAY ) ||
747
(pBuf->iColortype == MNG_COLORTYPE_INDEXED) ) )
748
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
749
}
750
}
751
#endif
752
#endif
753
754
if (!pData->bHasheader) /* first chunk ? */
755
{
756
pData->bHasheader = MNG_TRUE; /* we've got a header */
757
pData->eImagetype = mng_it_png; /* then this must be a PNG */
758
pData->iWidth = pData->iDatawidth;
759
pData->iHeight = pData->iDataheight;
760
/* predict alpha-depth ! */
761
if ((pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
762
(pData->iColortype == MNG_COLORTYPE_RGBA ) )
763
pData->iAlphadepth = pData->iBitdepth;
764
else
765
if (pData->iColortype == MNG_COLORTYPE_INDEXED)
766
pData->iAlphadepth = 8; /* worst case scenario */
767
else
768
pData->iAlphadepth = 1; /* Possible tRNS cheap binary transparency */
769
/* fits on maximum canvas ? */
770
if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
771
MNG_WARNING (pData, MNG_IMAGETOOLARGE)
772
773
if (pData->fProcessheader) /* inform the app ? */
774
if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
775
MNG_ERROR (pData, MNG_APPMISCERROR)
776
}
777
778
if (!pData->bHasDHDR)
779
pData->iImagelevel++; /* one level deeper */
780
781
#ifdef MNG_SUPPORT_DISPLAY
782
{
783
mng_retcode iRetcode = mng_process_display_ihdr (pData);
784
785
if (iRetcode) /* on error bail out */
786
return iRetcode;
787
}
788
#endif /* MNG_SUPPORT_DISPLAY */
789
790
#ifdef MNG_STORE_CHUNKS
791
if (pData->bStorechunks)
792
{ /* initialize storage */
793
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
794
795
if (iRetcode) /* on error bail out */
796
return iRetcode;
797
/* fill the fields */
798
((mng_ihdrp)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
799
((mng_ihdrp)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
800
((mng_ihdrp)*ppChunk)->iBitdepth = pData->iBitdepth;
801
((mng_ihdrp)*ppChunk)->iColortype = pData->iColortype;
802
((mng_ihdrp)*ppChunk)->iCompression = pData->iCompression;
803
((mng_ihdrp)*ppChunk)->iFilter = pData->iFilter;
804
((mng_ihdrp)*ppChunk)->iInterlace = pData->iInterlace;
805
}
806
#endif /* MNG_STORE_CHUNKS */
807
808
#ifdef MNG_SUPPORT_TRACE
809
MNG_TRACE (pData, MNG_FN_READ_IHDR, MNG_LC_END)
810
#endif
811
812
return MNG_NOERROR; /* done */
813
}
814
815
/* ************************************************************************** */
816
817
READ_CHUNK (mng_read_plte)
818
{
819
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
820
mng_uint32 iX;
821
mng_uint8p pRawdata2;
822
#endif
823
#ifdef MNG_SUPPORT_DISPLAY
824
mng_uint32 iRawlen2;
825
#endif
826
827
#ifdef MNG_SUPPORT_TRACE
828
MNG_TRACE (pData, MNG_FN_READ_PLTE, MNG_LC_START)
829
#endif
830
/* sequence checks */
831
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
832
(!pData->bHasBASI) && (!pData->bHasDHDR) )
833
MNG_ERROR (pData, MNG_SEQUENCEERROR)
834
835
#ifdef MNG_INCLUDE_JNG
836
if ((pData->bHasIDAT) || (pData->bHasJHDR))
837
#else
838
if (pData->bHasIDAT)
839
#endif
840
MNG_ERROR (pData, MNG_SEQUENCEERROR)
841
/* multiple PLTE only inside BASI */
842
if ((pData->bHasPLTE) && (!pData->bHasBASI))
843
MNG_ERROR (pData, MNG_MULTIPLEERROR)
844
/* length must be multiple of 3 */
845
if (((iRawlen % 3) != 0) || (iRawlen > 768))
846
MNG_ERROR (pData, MNG_INVALIDLENGTH)
847
848
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
849
{ /* only allowed for indexed-color or
850
rgb(a)-color! */
851
if ((pData->iColortype != 2) && (pData->iColortype != 3) && (pData->iColortype != 6))
852
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED)
853
/* empty only allowed if global present */
854
if ((iRawlen == 0) && (!pData->bHasglobalPLTE))
855
MNG_ERROR (pData, MNG_CANNOTBEEMPTY)
856
}
857
else
858
{
859
if (iRawlen == 0) /* cannot be empty as global! */
860
MNG_ERROR (pData, MNG_CANNOTBEEMPTY)
861
}
862
863
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
864
pData->bHasPLTE = MNG_TRUE; /* got it! */
865
else
866
pData->bHasglobalPLTE = MNG_TRUE;
867
868
pData->iPLTEcount = iRawlen / 3;
869
870
#ifdef MNG_SUPPORT_DISPLAY
871
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
872
{
873
mng_imagep pImage;
874
mng_imagedatap pBuf;
875
876
#ifndef MNG_NO_DELTA_PNG
877
if (pData->bHasDHDR) /* processing delta-image ? */
878
{ /* store in object 0 !!! */
879
pImage = (mng_imagep)pData->pObjzero;
880
pBuf = pImage->pImgbuf;
881
pBuf->bHasPLTE = MNG_TRUE; /* it's definitely got a PLTE now */
882
pBuf->iPLTEcount = iRawlen / 3; /* this is the exact length */
883
pRawdata2 = pRawdata; /* copy the entries */
884
885
for (iX = 0; iX < iRawlen / 3; iX++)
886
{
887
pBuf->aPLTEentries[iX].iRed = *pRawdata2;
888
pBuf->aPLTEentries[iX].iGreen = *(pRawdata2+1);
889
pBuf->aPLTEentries[iX].iBlue = *(pRawdata2+2);
890
891
pRawdata2 += 3;
892
}
893
}
894
else
895
#endif
896
{ /* get the current object */
897
pImage = (mng_imagep)pData->pCurrentobj;
898
899
if (!pImage) /* no object then dump it in obj 0 */
900
pImage = (mng_imagep)pData->pObjzero;
901
902
pBuf = pImage->pImgbuf; /* address the object buffer */
903
pBuf->bHasPLTE = MNG_TRUE; /* and tell it it's got a PLTE now */
904
905
if (!iRawlen) /* if empty, inherit from global */
906
{
907
pBuf->iPLTEcount = pData->iGlobalPLTEcount;
908
MNG_COPY (pBuf->aPLTEentries, pData->aGlobalPLTEentries,
909
sizeof (pBuf->aPLTEentries))
910
911
if (pData->bHasglobalTRNS) /* also copy global tRNS ? */
912
{ /* indicate tRNS available */
913
pBuf->bHasTRNS = MNG_TRUE;
914
915
iRawlen2 = pData->iGlobalTRNSrawlen;
916
pRawdata2 = (mng_uint8p)(pData->aGlobalTRNSrawdata);
917
/* global length oke ? */
918
if ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount))
919
MNG_ERROR (pData, MNG_GLOBALLENGTHERR)
920
/* copy it */
921
pBuf->iTRNScount = iRawlen2;
922
MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2)
923
}
924
}
925
else
926
{ /* store fields for future reference */
927
pBuf->iPLTEcount = iRawlen / 3;
928
pRawdata2 = pRawdata;
929
930
for (iX = 0; iX < pBuf->iPLTEcount; iX++)
931
{
932
pBuf->aPLTEentries[iX].iRed = *pRawdata2;
933
pBuf->aPLTEentries[iX].iGreen = *(pRawdata2+1);
934
pBuf->aPLTEentries[iX].iBlue = *(pRawdata2+2);
935
936
pRawdata2 += 3;
937
}
938
}
939
}
940
}
941
else /* store as global */
942
{
943
pData->iGlobalPLTEcount = iRawlen / 3;
944
pRawdata2 = pRawdata;
945
946
for (iX = 0; iX < pData->iGlobalPLTEcount; iX++)
947
{
948
pData->aGlobalPLTEentries[iX].iRed = *pRawdata2;
949
pData->aGlobalPLTEentries[iX].iGreen = *(pRawdata2+1);
950
pData->aGlobalPLTEentries[iX].iBlue = *(pRawdata2+2);
951
952
pRawdata2 += 3;
953
}
954
955
{ /* create an animation object */
956
mng_retcode iRetcode = mng_create_ani_plte (pData, pData->iGlobalPLTEcount,
957
pData->aGlobalPLTEentries);
958
959
if (iRetcode) /* on error bail out */
960
return iRetcode;
961
}
962
}
963
#endif /* MNG_SUPPORT_DISPLAY */
964
965
#ifdef MNG_STORE_CHUNKS
966
if (pData->bStorechunks)
967
{ /* initialize storage */
968
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
969
970
if (iRetcode) /* on error bail out */
971
return iRetcode;
972
/* store the fields */
973
((mng_pltep)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
974
((mng_pltep)*ppChunk)->iEntrycount = iRawlen / 3;
975
pRawdata2 = pRawdata;
976
977
for (iX = 0; iX < ((mng_pltep)*ppChunk)->iEntrycount; iX++)
978
{
979
((mng_pltep)*ppChunk)->aEntries[iX].iRed = *pRawdata2;
980
((mng_pltep)*ppChunk)->aEntries[iX].iGreen = *(pRawdata2+1);
981
((mng_pltep)*ppChunk)->aEntries[iX].iBlue = *(pRawdata2+2);
982
983
pRawdata2 += 3;
984
}
985
}
986
#endif /* MNG_STORE_CHUNKS */
987
988
#ifdef MNG_SUPPORT_TRACE
989
MNG_TRACE (pData, MNG_FN_READ_PLTE, MNG_LC_END)
990
#endif
991
992
return MNG_NOERROR; /* done */
993
}
994
995
/* ************************************************************************** */
996
997
READ_CHUNK (mng_read_idat)
998
{
999
#ifdef MNG_SUPPORT_TRACE
1000
MNG_TRACE (pData, MNG_FN_READ_IDAT, MNG_LC_START)
1001
#endif
1002
1003
#ifdef MNG_INCLUDE_JNG /* sequence checks */
1004
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1005
#else
1006
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
1007
#endif
1008
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1009
1010
#ifdef MNG_INCLUDE_JNG
1011
if ((pData->bHasJHDR) &&
1012
(pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE))
1013
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1014
1015
if (pData->bHasJSEP)
1016
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1017
#endif
1018
/* not allowed for deltatype NO_CHANGE */
1019
#ifndef MNG_NO_DELTA_PNG
1020
if ((pData->bHasDHDR) && ((pData->iDeltatype == MNG_DELTATYPE_NOCHANGE)))
1021
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED)
1022
#endif
1023
/* can only be empty in BASI-block! */
1024
if ((iRawlen == 0) && (!pData->bHasBASI))
1025
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1026
/* indexed-color requires PLTE */
1027
if ((pData->bHasIHDR) && (pData->iColortype == 3) && (!pData->bHasPLTE))
1028
MNG_ERROR (pData, MNG_PLTEMISSING)
1029
1030
pData->bHasIDAT = MNG_TRUE; /* got some IDAT now, don't we */
1031
1032
#ifdef MNG_SUPPORT_DISPLAY
1033
if (iRawlen)
1034
{ /* display processing */
1035
mng_retcode iRetcode = mng_process_display_idat (pData, iRawlen, pRawdata);
1036
1037
if (iRetcode) /* on error bail out */
1038
return iRetcode;
1039
}
1040
#endif /* MNG_SUPPORT_DISPLAY */
1041
1042
#ifdef MNG_STORE_CHUNKS
1043
if (pData->bStorechunks)
1044
{ /* initialize storage */
1045
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1046
1047
if (iRetcode) /* on error bail out */
1048
return iRetcode;
1049
/* store the fields */
1050
((mng_idatp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1051
((mng_idatp)*ppChunk)->iDatasize = iRawlen;
1052
1053
if (iRawlen != 0) /* is there any data ? */
1054
{
1055
MNG_ALLOC (pData, ((mng_idatp)*ppChunk)->pData, iRawlen)
1056
MNG_COPY (((mng_idatp)*ppChunk)->pData, pRawdata, iRawlen)
1057
}
1058
}
1059
#endif /* MNG_STORE_CHUNKS */
1060
1061
#ifdef MNG_SUPPORT_TRACE
1062
MNG_TRACE (pData, MNG_FN_READ_IDAT, MNG_LC_END)
1063
#endif
1064
1065
return MNG_NOERROR; /* done */
1066
}
1067
1068
/* ************************************************************************** */
1069
1070
READ_CHUNK (mng_read_iend)
1071
{
1072
#ifdef MNG_SUPPORT_TRACE
1073
MNG_TRACE (pData, MNG_FN_READ_IEND, MNG_LC_START)
1074
#endif
1075
1076
if (iRawlen > 0) /* must not contain data! */
1077
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1078
1079
#ifdef MNG_INCLUDE_JNG /* sequence checks */
1080
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1081
#else
1082
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
1083
#endif
1084
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1085
/* IHDR-block requires IDAT */
1086
if ((pData->bHasIHDR) && (!pData->bHasIDAT))
1087
MNG_ERROR (pData, MNG_IDATMISSING)
1088
1089
pData->iImagelevel--; /* one level up */
1090
1091
#ifdef MNG_SUPPORT_DISPLAY
1092
{ /* create an animation object */
1093
mng_retcode iRetcode = mng_create_ani_image (pData);
1094
1095
if (iRetcode) /* on error bail out */
1096
return iRetcode;
1097
/* display processing */
1098
iRetcode = mng_process_display_iend (pData);
1099
1100
if (iRetcode) /* on error bail out */
1101
return iRetcode;
1102
}
1103
#endif /* MNG_SUPPORT_DISPLAY */
1104
1105
#ifdef MNG_SUPPORT_DISPLAY
1106
if (!pData->bTimerset) /* reset only if not broken !!! */
1107
{
1108
#endif
1109
/* IEND signals the end for most ... */
1110
pData->bHasIHDR = MNG_FALSE;
1111
pData->bHasBASI = MNG_FALSE;
1112
pData->bHasDHDR = MNG_FALSE;
1113
#ifdef MNG_INCLUDE_JNG
1114
pData->bHasJHDR = MNG_FALSE;
1115
pData->bHasJSEP = MNG_FALSE;
1116
pData->bHasJDAA = MNG_FALSE;
1117
pData->bHasJDAT = MNG_FALSE;
1118
#endif
1119
pData->bHasPLTE = MNG_FALSE;
1120
pData->bHasTRNS = MNG_FALSE;
1121
pData->bHasGAMA = MNG_FALSE;
1122
pData->bHasCHRM = MNG_FALSE;
1123
pData->bHasSRGB = MNG_FALSE;
1124
pData->bHasICCP = MNG_FALSE;
1125
pData->bHasBKGD = MNG_FALSE;
1126
pData->bHasIDAT = MNG_FALSE;
1127
#ifdef MNG_SUPPORT_DISPLAY
1128
}
1129
#endif
1130
1131
#ifdef MNG_STORE_CHUNKS
1132
if (pData->bStorechunks)
1133
{ /* initialize storage */
1134
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1135
1136
if (iRetcode) /* on error bail out */
1137
return iRetcode;
1138
}
1139
#endif /* MNG_STORE_CHUNKS */
1140
1141
#ifdef MNG_SUPPORT_TRACE
1142
MNG_TRACE (pData, MNG_FN_READ_IEND, MNG_LC_END)
1143
#endif
1144
1145
return MNG_NOERROR; /* done */
1146
}
1147
1148
/* ************************************************************************** */
1149
1150
READ_CHUNK (mng_read_trns)
1151
{
1152
#ifdef MNG_SUPPORT_TRACE
1153
MNG_TRACE (pData, MNG_FN_READ_TRNS, MNG_LC_START)
1154
#endif
1155
/* sequence checks */
1156
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1157
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1158
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1159
1160
#ifdef MNG_INCLUDE_JNG
1161
if ((pData->bHasIDAT) || (pData->bHasJHDR))
1162
#else
1163
if (pData->bHasIDAT)
1164
#endif
1165
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1166
/* multiple tRNS only inside BASI */
1167
if ((pData->bHasTRNS) && (!pData->bHasBASI))
1168
MNG_ERROR (pData, MNG_MULTIPLEERROR)
1169
1170
if (iRawlen > 256) /* it just can't be bigger than that! */
1171
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1172
1173
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1174
{ /* not allowed with full alpha-channel */
1175
if ((pData->iColortype == 4) || (pData->iColortype == 6))
1176
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED)
1177
1178
if (iRawlen != 0) /* filled ? */
1179
{ /* length checks */
1180
if ((pData->iColortype == 0) && (iRawlen != 2))
1181
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1182
1183
if ((pData->iColortype == 2) && (iRawlen != 6))
1184
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1185
1186
#ifdef MNG_SUPPORT_DISPLAY
1187
if (pData->iColortype == 3)
1188
{
1189
mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
1190
mng_imagedatap pBuf;
1191
1192
if (!pImage) /* no object then check obj 0 */
1193
pImage = (mng_imagep)pData->pObjzero;
1194
1195
pBuf = pImage->pImgbuf; /* address object buffer */
1196
1197
if (iRawlen > pBuf->iPLTEcount)
1198
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1199
}
1200
#endif
1201
}
1202
else /* if empty there must be global stuff! */
1203
{
1204
if (!pData->bHasglobalTRNS)
1205
MNG_ERROR (pData, MNG_CANNOTBEEMPTY)
1206
}
1207
}
1208
1209
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1210
pData->bHasTRNS = MNG_TRUE; /* indicate tRNS available */
1211
else
1212
pData->bHasglobalTRNS = MNG_TRUE;
1213
1214
#ifdef MNG_SUPPORT_DISPLAY
1215
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1216
{
1217
mng_imagep pImage;
1218
mng_imagedatap pBuf;
1219
mng_uint8p pRawdata2;
1220
mng_uint32 iRawlen2;
1221
1222
#ifndef MNG_NO_DELTA_PNG
1223
if (pData->bHasDHDR) /* processing delta-image ? */
1224
{ /* store in object 0 !!! */
1225
pImage = (mng_imagep)pData->pObjzero;
1226
pBuf = pImage->pImgbuf; /* address object buffer */
1227
1228
switch (pData->iColortype) /* store fields for future reference */
1229
{
1230
case 0: { /* gray */
1231
pBuf->iTRNSgray = mng_get_uint16 (pRawdata);
1232
pBuf->iTRNSred = 0;
1233
pBuf->iTRNSgreen = 0;
1234
pBuf->iTRNSblue = 0;
1235
pBuf->iTRNScount = 0;
1236
break;
1237
}
1238
case 2: { /* rgb */
1239
pBuf->iTRNSgray = 0;
1240
pBuf->iTRNSred = mng_get_uint16 (pRawdata);
1241
pBuf->iTRNSgreen = mng_get_uint16 (pRawdata+2);
1242
pBuf->iTRNSblue = mng_get_uint16 (pRawdata+4);
1243
pBuf->iTRNScount = 0;
1244
break;
1245
}
1246
case 3: { /* indexed */
1247
pBuf->iTRNSgray = 0;
1248
pBuf->iTRNSred = 0;
1249
pBuf->iTRNSgreen = 0;
1250
pBuf->iTRNSblue = 0;
1251
pBuf->iTRNScount = iRawlen;
1252
MNG_COPY (pBuf->aTRNSentries, pRawdata, iRawlen)
1253
break;
1254
}
1255
}
1256
1257
pBuf->bHasTRNS = MNG_TRUE; /* tell it it's got a tRNS now */
1258
}
1259
else
1260
#endif
1261
{ /* address current object */
1262
pImage = (mng_imagep)pData->pCurrentobj;
1263
1264
if (!pImage) /* no object then dump it in obj 0 */
1265
pImage = (mng_imagep)pData->pObjzero;
1266
1267
pBuf = pImage->pImgbuf; /* address object buffer */
1268
pBuf->bHasTRNS = MNG_TRUE; /* and tell it it's got a tRNS now */
1269
1270
if (iRawlen == 0) /* if empty, inherit from global */
1271
{
1272
iRawlen2 = pData->iGlobalTRNSrawlen;
1273
pRawdata2 = (mng_ptr)(pData->aGlobalTRNSrawdata);
1274
/* global length oke ? */
1275
if ((pData->iColortype == 0) && (iRawlen2 != 2))
1276
MNG_ERROR (pData, MNG_GLOBALLENGTHERR)
1277
1278
if ((pData->iColortype == 2) && (iRawlen2 != 6))
1279
MNG_ERROR (pData, MNG_GLOBALLENGTHERR)
1280
1281
if ((pData->iColortype == 3) && ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount)))
1282
MNG_ERROR (pData, MNG_GLOBALLENGTHERR)
1283
}
1284
else
1285
{
1286
iRawlen2 = iRawlen;
1287
pRawdata2 = pRawdata;
1288
}
1289
1290
switch (pData->iColortype) /* store fields for future reference */
1291
{
1292
case 0: { /* gray */
1293
pBuf->iTRNSgray = mng_get_uint16 (pRawdata2);
1294
pBuf->iTRNSred = 0;
1295
pBuf->iTRNSgreen = 0;
1296
pBuf->iTRNSblue = 0;
1297
pBuf->iTRNScount = 0;
1298
break;
1299
}
1300
case 2: { /* rgb */
1301
pBuf->iTRNSgray = 0;
1302
pBuf->iTRNSred = mng_get_uint16 (pRawdata2);
1303
pBuf->iTRNSgreen = mng_get_uint16 (pRawdata2+2);
1304
pBuf->iTRNSblue = mng_get_uint16 (pRawdata2+4);
1305
pBuf->iTRNScount = 0;
1306
break;
1307
}
1308
case 3: { /* indexed */
1309
pBuf->iTRNSgray = 0;
1310
pBuf->iTRNSred = 0;
1311
pBuf->iTRNSgreen = 0;
1312
pBuf->iTRNSblue = 0;
1313
pBuf->iTRNScount = iRawlen2;
1314
MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2)
1315
break;
1316
}
1317
}
1318
}
1319
}
1320
else /* store as global */
1321
{
1322
pData->iGlobalTRNSrawlen = iRawlen;
1323
MNG_COPY (pData->aGlobalTRNSrawdata, pRawdata, iRawlen)
1324
1325
{ /* create an animation object */
1326
mng_retcode iRetcode = mng_create_ani_trns (pData, pData->iGlobalTRNSrawlen,
1327
pData->aGlobalTRNSrawdata);
1328
1329
if (iRetcode) /* on error bail out */
1330
return iRetcode;
1331
}
1332
}
1333
#endif /* MNG_SUPPORT_DISPLAY */
1334
1335
#ifdef MNG_STORE_CHUNKS
1336
if (pData->bStorechunks)
1337
{ /* initialize storage */
1338
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1339
1340
if (iRetcode) /* on error bail out */
1341
return iRetcode;
1342
1343
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1344
{ /* not global! */
1345
((mng_trnsp)*ppChunk)->bGlobal = MNG_FALSE;
1346
((mng_trnsp)*ppChunk)->iType = pData->iColortype;
1347
1348
if (iRawlen == 0) /* if empty, indicate so */
1349
((mng_trnsp)*ppChunk)->bEmpty = MNG_TRUE;
1350
else
1351
{
1352
((mng_trnsp)*ppChunk)->bEmpty = MNG_FALSE;
1353
1354
switch (pData->iColortype) /* store fields */
1355
{
1356
case 0: { /* gray */
1357
((mng_trnsp)*ppChunk)->iGray = mng_get_uint16 (pRawdata);
1358
break;
1359
}
1360
case 2: { /* rgb */
1361
((mng_trnsp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
1362
((mng_trnsp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
1363
((mng_trnsp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
1364
break;
1365
}
1366
case 3: { /* indexed */
1367
((mng_trnsp)*ppChunk)->iCount = iRawlen;
1368
MNG_COPY (((mng_trnsp)*ppChunk)->aEntries, pRawdata, iRawlen)
1369
break;
1370
}
1371
}
1372
}
1373
}
1374
else /* it's global! */
1375
{
1376
((mng_trnsp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1377
((mng_trnsp)*ppChunk)->bGlobal = MNG_TRUE;
1378
((mng_trnsp)*ppChunk)->iType = 0;
1379
((mng_trnsp)*ppChunk)->iRawlen = iRawlen;
1380
1381
MNG_COPY (((mng_trnsp)*ppChunk)->aRawdata, pRawdata, iRawlen)
1382
}
1383
}
1384
#endif /* MNG_STORE_CHUNKS */
1385
1386
#ifdef MNG_SUPPORT_TRACE
1387
MNG_TRACE (pData, MNG_FN_READ_TRNS, MNG_LC_END)
1388
#endif
1389
1390
return MNG_NOERROR; /* done */
1391
}
1392
1393
/* ************************************************************************** */
1394
1395
READ_CHUNK (mng_read_gama)
1396
{
1397
#ifdef MNG_SUPPORT_TRACE
1398
MNG_TRACE (pData, MNG_FN_READ_GAMA, MNG_LC_START)
1399
#endif
1400
/* sequence checks */
1401
#ifdef MNG_INCLUDE_JNG
1402
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1403
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1404
#else
1405
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1406
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1407
#endif
1408
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1409
1410
#ifdef MNG_INCLUDE_JNG
1411
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
1412
#else
1413
if ((pData->bHasIDAT) || (pData->bHasPLTE))
1414
#endif
1415
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1416
1417
#ifdef MNG_INCLUDE_JNG
1418
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1419
#else
1420
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1421
#endif
1422
{ /* length must be exactly 4 */
1423
if (iRawlen != 4)
1424
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1425
}
1426
else
1427
{ /* length must be empty or exactly 4 */
1428
if ((iRawlen != 0) && (iRawlen != 4))
1429
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1430
}
1431
1432
#ifdef MNG_INCLUDE_JNG
1433
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1434
#else
1435
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1436
#endif
1437
pData->bHasGAMA = MNG_TRUE; /* indicate we've got it */
1438
else
1439
pData->bHasglobalGAMA = (mng_bool)(iRawlen != 0);
1440
1441
#ifdef MNG_SUPPORT_DISPLAY
1442
#ifdef MNG_INCLUDE_JNG
1443
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1444
#else
1445
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1446
#endif
1447
{
1448
mng_imagep pImage;
1449
1450
#ifndef MNG_NO_DELTA_PNG
1451
if (pData->bHasDHDR) /* update delta image ? */
1452
{ /* store in object 0 ! */
1453
pImage = (mng_imagep)pData->pObjzero;
1454
/* store for color-processing routines */
1455
pImage->pImgbuf->iGamma = mng_get_uint32 (pRawdata);
1456
pImage->pImgbuf->bHasGAMA = MNG_TRUE;
1457
}
1458
else
1459
#endif
1460
{
1461
pImage = (mng_imagep)pData->pCurrentobj;
1462
1463
if (!pImage) /* no object then dump it in obj 0 */
1464
pImage = (mng_imagep)pData->pObjzero;
1465
/* store for color-processing routines */
1466
pImage->pImgbuf->iGamma = mng_get_uint32 (pRawdata);
1467
pImage->pImgbuf->bHasGAMA = MNG_TRUE;
1468
}
1469
}
1470
else
1471
{ /* store as global */
1472
if (iRawlen != 0)
1473
pData->iGlobalGamma = mng_get_uint32 (pRawdata);
1474
1475
{ /* create an animation object */
1476
mng_retcode iRetcode = mng_create_ani_gama (pData, (mng_bool)(iRawlen == 0),
1477
pData->iGlobalGamma);
1478
1479
if (iRetcode) /* on error bail out */
1480
return iRetcode;
1481
}
1482
}
1483
#endif /* MNG_SUPPORT_DISPLAY */
1484
1485
#ifdef MNG_STORE_CHUNKS
1486
if (pData->bStorechunks)
1487
{ /* initialize storage */
1488
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1489
1490
if (iRetcode) /* on error bail out */
1491
return iRetcode;
1492
/* store the fields */
1493
((mng_gamap)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1494
1495
if (iRawlen)
1496
((mng_gamap)*ppChunk)->iGamma = mng_get_uint32 (pRawdata);
1497
1498
}
1499
#endif /* MNG_STORE_CHUNKS */
1500
1501
#ifdef MNG_SUPPORT_TRACE
1502
MNG_TRACE (pData, MNG_FN_READ_GAMA, MNG_LC_END)
1503
#endif
1504
1505
return MNG_NOERROR; /* done */
1506
}
1507
1508
/* ************************************************************************** */
1509
1510
#ifndef MNG_SKIPCHUNK_cHRM
1511
READ_CHUNK (mng_read_chrm)
1512
{
1513
#ifdef MNG_SUPPORT_TRACE
1514
MNG_TRACE (pData, MNG_FN_READ_CHRM, MNG_LC_START)
1515
#endif
1516
/* sequence checks */
1517
#ifdef MNG_INCLUDE_JNG
1518
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1519
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1520
#else
1521
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1522
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1523
#endif
1524
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1525
1526
#ifdef MNG_INCLUDE_JNG
1527
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
1528
#else
1529
if ((pData->bHasIDAT) || (pData->bHasPLTE))
1530
#endif
1531
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1532
1533
#ifdef MNG_INCLUDE_JNG
1534
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1535
#else
1536
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1537
#endif
1538
{ /* length must be exactly 32 */
1539
if (iRawlen != 32)
1540
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1541
}
1542
else
1543
{ /* length must be empty or exactly 32 */
1544
if ((iRawlen != 0) && (iRawlen != 32))
1545
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1546
}
1547
1548
#ifdef MNG_INCLUDE_JNG
1549
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1550
#else
1551
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1552
#endif
1553
pData->bHasCHRM = MNG_TRUE; /* indicate we've got it */
1554
else
1555
pData->bHasglobalCHRM = (mng_bool)(iRawlen != 0);
1556
1557
#ifdef MNG_SUPPORT_DISPLAY
1558
{
1559
mng_uint32 iWhitepointx, iWhitepointy;
1560
mng_uint32 iPrimaryredx, iPrimaryredy;
1561
mng_uint32 iPrimarygreenx, iPrimarygreeny;
1562
mng_uint32 iPrimarybluex, iPrimarybluey;
1563
1564
iWhitepointx = mng_get_uint32 (pRawdata);
1565
iWhitepointy = mng_get_uint32 (pRawdata+4);
1566
iPrimaryredx = mng_get_uint32 (pRawdata+8);
1567
iPrimaryredy = mng_get_uint32 (pRawdata+12);
1568
iPrimarygreenx = mng_get_uint32 (pRawdata+16);
1569
iPrimarygreeny = mng_get_uint32 (pRawdata+20);
1570
iPrimarybluex = mng_get_uint32 (pRawdata+24);
1571
iPrimarybluey = mng_get_uint32 (pRawdata+28);
1572
1573
#ifdef MNG_INCLUDE_JNG
1574
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1575
#else
1576
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1577
#endif
1578
{
1579
mng_imagep pImage;
1580
mng_imagedatap pBuf;
1581
1582
#ifndef MNG_NO_DELTA_PNG
1583
if (pData->bHasDHDR) /* update delta image ? */
1584
{ /* store it in object 0 ! */
1585
pImage = (mng_imagep)pData->pObjzero;
1586
1587
pBuf = pImage->pImgbuf; /* address object buffer */
1588
pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */
1589
/* store for color-processing routines */
1590
pBuf->iWhitepointx = iWhitepointx;
1591
pBuf->iWhitepointy = iWhitepointy;
1592
pBuf->iPrimaryredx = iPrimaryredx;
1593
pBuf->iPrimaryredy = iPrimaryredy;
1594
pBuf->iPrimarygreenx = iPrimarygreenx;
1595
pBuf->iPrimarygreeny = iPrimarygreeny;
1596
pBuf->iPrimarybluex = iPrimarybluex;
1597
pBuf->iPrimarybluey = iPrimarybluey;
1598
}
1599
else
1600
#endif
1601
{
1602
pImage = (mng_imagep)pData->pCurrentobj;
1603
1604
if (!pImage) /* no object then dump it in obj 0 */
1605
pImage = (mng_imagep)pData->pObjzero;
1606
1607
pBuf = pImage->pImgbuf; /* address object buffer */
1608
pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */
1609
/* store for color-processing routines */
1610
pBuf->iWhitepointx = iWhitepointx;
1611
pBuf->iWhitepointy = iWhitepointy;
1612
pBuf->iPrimaryredx = iPrimaryredx;
1613
pBuf->iPrimaryredy = iPrimaryredy;
1614
pBuf->iPrimarygreenx = iPrimarygreenx;
1615
pBuf->iPrimarygreeny = iPrimarygreeny;
1616
pBuf->iPrimarybluex = iPrimarybluex;
1617
pBuf->iPrimarybluey = iPrimarybluey;
1618
}
1619
}
1620
else
1621
{ /* store as global */
1622
if (iRawlen != 0)
1623
{
1624
pData->iGlobalWhitepointx = iWhitepointx;
1625
pData->iGlobalWhitepointy = iWhitepointy;
1626
pData->iGlobalPrimaryredx = iPrimaryredx;
1627
pData->iGlobalPrimaryredy = iPrimaryredy;
1628
pData->iGlobalPrimarygreenx = iPrimarygreenx;
1629
pData->iGlobalPrimarygreeny = iPrimarygreeny;
1630
pData->iGlobalPrimarybluex = iPrimarybluex;
1631
pData->iGlobalPrimarybluey = iPrimarybluey;
1632
}
1633
1634
{ /* create an animation object */
1635
mng_retcode iRetcode = mng_create_ani_chrm (pData, (mng_bool)(iRawlen == 0),
1636
iWhitepointx, iWhitepointy,
1637
iPrimaryredx, iPrimaryredy,
1638
iPrimarygreenx, iPrimarygreeny,
1639
iPrimarybluex, iPrimarybluey);
1640
1641
if (iRetcode) /* on error bail out */
1642
return iRetcode;
1643
}
1644
}
1645
}
1646
#endif /* MNG_SUPPORT_DISPLAY */
1647
1648
#ifdef MNG_STORE_CHUNKS
1649
if (pData->bStorechunks)
1650
{ /* initialize storage */
1651
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1652
1653
if (iRetcode) /* on error bail out */
1654
return iRetcode;
1655
/* store the fields */
1656
((mng_chrmp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1657
1658
if (iRawlen)
1659
{
1660
((mng_chrmp)*ppChunk)->iWhitepointx = mng_get_uint32 (pRawdata);
1661
((mng_chrmp)*ppChunk)->iWhitepointy = mng_get_uint32 (pRawdata+4);
1662
((mng_chrmp)*ppChunk)->iRedx = mng_get_uint32 (pRawdata+8);
1663
((mng_chrmp)*ppChunk)->iRedy = mng_get_uint32 (pRawdata+12);
1664
((mng_chrmp)*ppChunk)->iGreenx = mng_get_uint32 (pRawdata+16);
1665
((mng_chrmp)*ppChunk)->iGreeny = mng_get_uint32 (pRawdata+20);
1666
((mng_chrmp)*ppChunk)->iBluex = mng_get_uint32 (pRawdata+24);
1667
((mng_chrmp)*ppChunk)->iBluey = mng_get_uint32 (pRawdata+28);
1668
}
1669
}
1670
#endif /* MNG_STORE_CHUNKS */
1671
1672
#ifdef MNG_SUPPORT_TRACE
1673
MNG_TRACE (pData, MNG_FN_READ_CHRM, MNG_LC_END)
1674
#endif
1675
1676
return MNG_NOERROR; /* done */
1677
}
1678
#endif
1679
1680
/* ************************************************************************** */
1681
1682
READ_CHUNK (mng_read_srgb)
1683
{
1684
#ifdef MNG_SUPPORT_TRACE
1685
MNG_TRACE (pData, MNG_FN_READ_SRGB, MNG_LC_START)
1686
#endif
1687
/* sequence checks */
1688
#ifdef MNG_INCLUDE_JNG
1689
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1690
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1691
#else
1692
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1693
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1694
#endif
1695
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1696
1697
#ifdef MNG_INCLUDE_JNG
1698
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
1699
#else
1700
if ((pData->bHasIDAT) || (pData->bHasPLTE))
1701
#endif
1702
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1703
1704
#ifdef MNG_INCLUDE_JNG
1705
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1706
#else
1707
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1708
#endif
1709
{ /* length must be exactly 1 */
1710
if (iRawlen != 1)
1711
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1712
}
1713
else
1714
{ /* length must be empty or exactly 1 */
1715
if ((iRawlen != 0) && (iRawlen != 1))
1716
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1717
}
1718
1719
#ifdef MNG_INCLUDE_JNG
1720
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1721
#else
1722
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1723
#endif
1724
pData->bHasSRGB = MNG_TRUE; /* indicate we've got it */
1725
else
1726
pData->bHasglobalSRGB = (mng_bool)(iRawlen != 0);
1727
1728
#ifdef MNG_SUPPORT_DISPLAY
1729
#ifdef MNG_INCLUDE_JNG
1730
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1731
#else
1732
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1733
#endif
1734
{
1735
mng_imagep pImage;
1736
1737
#ifndef MNG_NO_DELTA_PNG
1738
if (pData->bHasDHDR) /* update delta image ? */
1739
{ /* store in object 0 ! */
1740
pImage = (mng_imagep)pData->pObjzero;
1741
/* store for color-processing routines */
1742
pImage->pImgbuf->iRenderingintent = *pRawdata;
1743
pImage->pImgbuf->bHasSRGB = MNG_TRUE;
1744
}
1745
else
1746
#endif
1747
{
1748
pImage = (mng_imagep)pData->pCurrentobj;
1749
1750
if (!pImage) /* no object then dump it in obj 0 */
1751
pImage = (mng_imagep)pData->pObjzero;
1752
/* store for color-processing routines */
1753
pImage->pImgbuf->iRenderingintent = *pRawdata;
1754
pImage->pImgbuf->bHasSRGB = MNG_TRUE;
1755
}
1756
}
1757
else
1758
{ /* store as global */
1759
if (iRawlen != 0)
1760
pData->iGlobalRendintent = *pRawdata;
1761
1762
{ /* create an animation object */
1763
mng_retcode iRetcode = mng_create_ani_srgb (pData, (mng_bool)(iRawlen == 0),
1764
pData->iGlobalRendintent);
1765
1766
if (iRetcode) /* on error bail out */
1767
return iRetcode;
1768
}
1769
}
1770
#endif /* MNG_SUPPORT_DISPLAY */
1771
1772
#ifdef MNG_STORE_CHUNKS
1773
if (pData->bStorechunks)
1774
{ /* initialize storage */
1775
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1776
1777
if (iRetcode) /* on error bail out */
1778
return iRetcode;
1779
/* store the fields */
1780
((mng_srgbp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1781
1782
if (iRawlen)
1783
((mng_srgbp)*ppChunk)->iRenderingintent = *pRawdata;
1784
1785
}
1786
#endif /* MNG_STORE_CHUNKS */
1787
1788
#ifdef MNG_SUPPORT_TRACE
1789
MNG_TRACE (pData, MNG_FN_READ_SRGB, MNG_LC_END)
1790
#endif
1791
1792
return MNG_NOERROR; /* done */
1793
}
1794
1795
/* ************************************************************************** */
1796
1797
#ifndef MNG_SKIPCHUNK_iCCP
1798
READ_CHUNK (mng_read_iccp)
1799
{
1800
mng_retcode iRetcode;
1801
mng_uint8p pTemp;
1802
mng_uint32 iCompressedsize;
1803
mng_uint32 iProfilesize;
1804
mng_uint32 iBufsize = 0;
1805
mng_uint8p pBuf = 0;
1806
1807
#ifdef MNG_SUPPORT_TRACE
1808
MNG_TRACE (pData, MNG_FN_READ_ICCP, MNG_LC_START)
1809
#endif
1810
/* sequence checks */
1811
#ifdef MNG_INCLUDE_JNG
1812
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1813
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1814
#else
1815
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1816
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1817
#endif
1818
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1819
1820
#ifdef MNG_INCLUDE_JNG
1821
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
1822
#else
1823
if ((pData->bHasIDAT) || (pData->bHasPLTE))
1824
#endif
1825
MNG_ERROR (pData, MNG_SEQUENCEERROR)
1826
1827
#ifdef MNG_INCLUDE_JNG
1828
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1829
#else
1830
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1831
#endif
1832
{ /* length must be at least 2 */
1833
if (iRawlen < 2)
1834
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1835
}
1836
else
1837
{ /* length must be empty or at least 2 */
1838
if ((iRawlen != 0) && (iRawlen < 2))
1839
MNG_ERROR (pData, MNG_INVALIDLENGTH)
1840
}
1841
1842
pTemp = find_null (pRawdata); /* find null-separator */
1843
/* not found inside input-data ? */
1844
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
1845
MNG_ERROR (pData, MNG_NULLNOTFOUND)
1846
/* determine size of compressed profile */
1847
iCompressedsize = (mng_uint32)(iRawlen - (pTemp - pRawdata) - 2);
1848
/* decompress the profile */
1849
iRetcode = inflate_buffer (pData, pTemp+2, iCompressedsize,
1850
&pBuf, &iBufsize, &iProfilesize);
1851
1852
#ifdef MNG_CHECK_BAD_ICCP /* Check for bad iCCP chunk */
1853
if ((iRetcode) && (!strncmp ((char *)pRawdata, "Photoshop ICC profile", 21)))
1854
{
1855
if (iRawlen == 2615) /* is it the sRGB profile ? */
1856
{
1857
mng_chunk_header chunk_srgb = {MNG_UINT_sRGB, mng_init_srgb, mng_free_srgb,
1858
mng_read_srgb, mng_write_srgb, mng_assign_srgb,
1859
0, 0};
1860
/* pretend it's an sRGB chunk then ! */
1861
iRetcode = mng_read_srgb (pData, &chunk_srgb, 1, (mng_ptr)"0", ppChunk);
1862
1863
if (iRetcode) /* on error bail out */
1864
{ /* don't forget to drop the temp buffer */
1865
MNG_FREEX (pData, pBuf, iBufsize)
1866
return iRetcode;
1867
}
1868
}
1869
}
1870
else
1871
{
1872
#endif /* MNG_CHECK_BAD_ICCP */
1873
1874
if (iRetcode) /* on error bail out */
1875
{ /* don't forget to drop the temp buffer */
1876
MNG_FREEX (pData, pBuf, iBufsize)
1877
return iRetcode;
1878
}
1879
1880
#ifdef MNG_INCLUDE_JNG
1881
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1882
#else
1883
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1884
#endif
1885
pData->bHasICCP = MNG_TRUE; /* indicate we've got it */
1886
else
1887
pData->bHasglobalICCP = (mng_bool)(iRawlen != 0);
1888
1889
#ifdef MNG_SUPPORT_DISPLAY
1890
#ifdef MNG_INCLUDE_JNG
1891
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1892
#else
1893
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1894
#endif
1895
{
1896
mng_imagep pImage;
1897
1898
#ifndef MNG_NO_DELTA_PNG
1899
if (pData->bHasDHDR) /* update delta image ? */
1900
{ /* store in object 0 ! */
1901
pImage = (mng_imagep)pData->pObjzero;
1902
1903
if (pImage->pImgbuf->pProfile) /* profile existed ? */
1904
MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize)
1905
/* allocate a buffer & copy it */
1906
MNG_ALLOC (pData, pImage->pImgbuf->pProfile, iProfilesize)
1907
MNG_COPY (pImage->pImgbuf->pProfile, pBuf, iProfilesize)
1908
/* store it's length as well */
1909
pImage->pImgbuf->iProfilesize = iProfilesize;
1910
pImage->pImgbuf->bHasICCP = MNG_TRUE;
1911
}
1912
else
1913
#endif
1914
{
1915
pImage = (mng_imagep)pData->pCurrentobj;
1916
1917
if (!pImage) /* no object then dump it in obj 0 */
1918
pImage = (mng_imagep)pData->pObjzero;
1919
1920
if (pImage->pImgbuf->pProfile) /* profile existed ? */
1921
MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize)
1922
/* allocate a buffer & copy it */
1923
MNG_ALLOC (pData, pImage->pImgbuf->pProfile, iProfilesize)
1924
MNG_COPY (pImage->pImgbuf->pProfile, pBuf, iProfilesize)
1925
/* store it's length as well */
1926
pImage->pImgbuf->iProfilesize = iProfilesize;
1927
pImage->pImgbuf->bHasICCP = MNG_TRUE;
1928
}
1929
}
1930
else
1931
{ /* store as global */
1932
if (iRawlen == 0) /* empty chunk ? */
1933
{
1934
if (pData->pGlobalProfile) /* did we have a global profile ? */
1935
MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize)
1936
1937
pData->iGlobalProfilesize = 0; /* reset to null */
1938
pData->pGlobalProfile = MNG_NULL;
1939
}
1940
else
1941
{ /* allocate a global buffer & copy it */
1942
MNG_ALLOC (pData, pData->pGlobalProfile, iProfilesize)
1943
MNG_COPY (pData->pGlobalProfile, pBuf, iProfilesize)
1944
/* store it's length as well */
1945
pData->iGlobalProfilesize = iProfilesize;
1946
}
1947
1948
/* create an animation object */
1949
iRetcode = mng_create_ani_iccp (pData, (mng_bool)(iRawlen == 0),
1950
pData->iGlobalProfilesize,
1951
pData->pGlobalProfile);
1952
1953
if (iRetcode) /* on error bail out */
1954
return iRetcode;
1955
}
1956
#endif /* MNG_SUPPORT_DISPLAY */
1957
1958
#ifdef MNG_STORE_CHUNKS
1959
if (pData->bStorechunks)
1960
{ /* initialize storage */
1961
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1962
1963
if (iRetcode) /* on error bail out */
1964
{ /* don't forget to drop the temp buffer */
1965
MNG_FREEX (pData, pBuf, iBufsize)
1966
return iRetcode;
1967
}
1968
/* store the fields */
1969
((mng_iccpp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1970
1971
if (iRawlen) /* not empty ? */
1972
{
1973
if (!pBuf) /* hasn't been unpuzzled it yet ? */
1974
{ /* find null-separator */
1975
pTemp = find_null (pRawdata);
1976
/* not found inside input-data ? */
1977
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
1978
MNG_ERROR (pData, MNG_NULLNOTFOUND)
1979
/* determine size of compressed profile */
1980
iCompressedsize = iRawlen - (pTemp - pRawdata) - 2;
1981
/* decompress the profile */
1982
iRetcode = inflate_buffer (pData, pTemp+2, iCompressedsize,
1983
&pBuf, &iBufsize, &iProfilesize);
1984
1985
if (iRetcode) /* on error bail out */
1986
{ /* don't forget to drop the temp buffer */
1987
MNG_FREEX (pData, pBuf, iBufsize)
1988
return iRetcode;
1989
}
1990
}
1991
1992
((mng_iccpp)*ppChunk)->iNamesize = (mng_uint32)(pTemp - pRawdata);
1993
1994
if (((mng_iccpp)*ppChunk)->iNamesize)
1995
{
1996
MNG_ALLOC (pData, ((mng_iccpp)*ppChunk)->zName,
1997
((mng_iccpp)*ppChunk)->iNamesize + 1)
1998
MNG_COPY (((mng_iccpp)*ppChunk)->zName, pRawdata,
1999
((mng_iccpp)*ppChunk)->iNamesize)
2000
}
2001
2002
((mng_iccpp)*ppChunk)->iCompression = *(pTemp+1);
2003
((mng_iccpp)*ppChunk)->iProfilesize = iProfilesize;
2004
2005
MNG_ALLOC (pData, ((mng_iccpp)*ppChunk)->pProfile, iProfilesize)
2006
MNG_COPY (((mng_iccpp)*ppChunk)->pProfile, pBuf, iProfilesize)
2007
}
2008
}
2009
#endif /* MNG_STORE_CHUNKS */
2010
2011
if (pBuf) /* free the temporary buffer */
2012
MNG_FREEX (pData, pBuf, iBufsize)
2013
2014
#ifdef MNG_CHECK_BAD_ICCP
2015
}
2016
#endif
2017
2018
#ifdef MNG_SUPPORT_TRACE
2019
MNG_TRACE (pData, MNG_FN_READ_ICCP, MNG_LC_END)
2020
#endif
2021
2022
return MNG_NOERROR; /* done */
2023
}
2024
#endif
2025
2026
/* ************************************************************************** */
2027
2028
#ifndef MNG_SKIPCHUNK_tEXt
2029
READ_CHUNK (mng_read_text)
2030
{
2031
mng_uint32 iKeywordlen, iTextlen;
2032
mng_pchar zKeyword, zText;
2033
mng_uint8p pTemp;
2034
2035
#ifdef MNG_SUPPORT_TRACE
2036
MNG_TRACE (pData, MNG_FN_READ_TEXT, MNG_LC_START)
2037
#endif
2038
/* sequence checks */
2039
#ifdef MNG_INCLUDE_JNG
2040
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2041
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2042
#else
2043
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2044
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2045
#endif
2046
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2047
2048
if (iRawlen < 2) /* length must be at least 2 */
2049
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2050
2051
pTemp = find_null (pRawdata); /* find the null separator */
2052
/* not found inside input-data ? */
2053
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2054
MNG_ERROR (pData, MNG_NULLNOTFOUND)
2055
2056
if (pTemp == pRawdata) /* there must be at least 1 char for keyword */
2057
MNG_ERROR (pData, MNG_KEYWORDNULL)
2058
2059
iKeywordlen = (mng_uint32)(pTemp - pRawdata);
2060
iTextlen = iRawlen - iKeywordlen - 1;
2061
2062
if (pData->fProcesstext) /* inform the application ? */
2063
{
2064
mng_bool bOke;
2065
2066
MNG_ALLOC (pData, zKeyword, iKeywordlen + 1)
2067
MNG_COPY (zKeyword, pRawdata, iKeywordlen)
2068
2069
MNG_ALLOCX (pData, zText, iTextlen + 1)
2070
2071
if (!zText) /* on error bail out */
2072
{
2073
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2074
MNG_ERROR (pData, MNG_OUTOFMEMORY)
2075
}
2076
2077
if (iTextlen)
2078
MNG_COPY (zText, pTemp+1, iTextlen)
2079
2080
bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_TEXT, zKeyword, zText, 0, 0);
2081
2082
MNG_FREEX (pData, zText, iTextlen + 1)
2083
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2084
2085
if (!bOke)
2086
MNG_ERROR (pData, MNG_APPMISCERROR)
2087
2088
}
2089
2090
#ifdef MNG_STORE_CHUNKS
2091
if (pData->bStorechunks)
2092
{ /* initialize storage */
2093
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2094
2095
if (iRetcode) /* on error bail out */
2096
return iRetcode;
2097
/* store the fields */
2098
((mng_textp)*ppChunk)->iKeywordsize = iKeywordlen;
2099
((mng_textp)*ppChunk)->iTextsize = iTextlen;
2100
2101
if (iKeywordlen)
2102
{
2103
MNG_ALLOC (pData, ((mng_textp)*ppChunk)->zKeyword, iKeywordlen+1)
2104
MNG_COPY (((mng_textp)*ppChunk)->zKeyword, pRawdata, iKeywordlen)
2105
}
2106
2107
if (iTextlen)
2108
{
2109
MNG_ALLOC (pData, ((mng_textp)*ppChunk)->zText, iTextlen+1)
2110
MNG_COPY (((mng_textp)*ppChunk)->zText, pTemp+1, iTextlen)
2111
}
2112
}
2113
#endif /* MNG_STORE_CHUNKS */
2114
2115
#ifdef MNG_SUPPORT_TRACE
2116
MNG_TRACE (pData, MNG_FN_READ_TEXT, MNG_LC_END)
2117
#endif
2118
2119
return MNG_NOERROR; /* done */
2120
}
2121
#endif
2122
2123
/* ************************************************************************** */
2124
2125
#ifndef MNG_SKIPCHUNK_zTXt
2126
READ_CHUNK (mng_read_ztxt)
2127
{
2128
mng_retcode iRetcode;
2129
mng_uint32 iKeywordlen, iTextlen;
2130
mng_pchar zKeyword;
2131
mng_uint8p pTemp;
2132
mng_uint32 iCompressedsize;
2133
mng_uint32 iBufsize;
2134
mng_uint8p pBuf;
2135
2136
#ifdef MNG_SUPPORT_TRACE
2137
MNG_TRACE (pData, MNG_FN_READ_ZTXT, MNG_LC_START)
2138
#endif
2139
/* sequence checks */
2140
#ifdef MNG_INCLUDE_JNG
2141
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2142
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2143
#else
2144
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2145
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2146
#endif
2147
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2148
2149
if (iRawlen < 3) /* length must be at least 3 */
2150
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2151
2152
pTemp = find_null (pRawdata); /* find the null separator */
2153
/* not found inside input-data ? */
2154
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2155
MNG_ERROR (pData, MNG_NULLNOTFOUND)
2156
2157
if (pTemp == pRawdata) /* there must be at least 1 char for keyword */
2158
MNG_ERROR (pData, MNG_KEYWORDNULL)
2159
2160
if (*(pTemp+1) != 0) /* only deflate compression-method allowed */
2161
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
2162
2163
iKeywordlen = (mng_uint32)(pTemp - pRawdata);
2164
iCompressedsize = (mng_uint32)(iRawlen - iKeywordlen - 2);
2165
2166
zKeyword = 0; /* there's no keyword buffer yet */
2167
pBuf = 0; /* or a temporary buffer ! */
2168
2169
if (pData->fProcesstext) /* inform the application ? */
2170
{ /* decompress the text */
2171
iRetcode = inflate_buffer (pData, pTemp+2, iCompressedsize,
2172
&pBuf, &iBufsize, &iTextlen);
2173
2174
if (iRetcode) /* on error bail out */
2175
{ /* don't forget to drop the temp buffers */
2176
MNG_FREEX (pData, pBuf, iBufsize)
2177
return iRetcode;
2178
}
2179
2180
MNG_ALLOCX (pData, zKeyword, iKeywordlen+1)
2181
2182
if (!zKeyword) /* on error bail out */
2183
{ /* don't forget to drop the temp buffers */
2184
MNG_FREEX (pData, pBuf, iBufsize)
2185
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2186
}
2187
2188
MNG_COPY (zKeyword, pRawdata, iKeywordlen)
2189
2190
if (!pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ZTXT, zKeyword, (mng_pchar)pBuf, 0, 0))
2191
{ /* don't forget to drop the temp buffers */
2192
MNG_FREEX (pData, pBuf, iBufsize)
2193
MNG_FREEX (pData, zKeyword, iKeywordlen+1)
2194
MNG_ERROR (pData, MNG_APPMISCERROR)
2195
}
2196
}
2197
2198
#ifdef MNG_STORE_CHUNKS
2199
if (pData->bStorechunks)
2200
{ /* initialize storage */
2201
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2202
2203
if (iRetcode) /* on error bail out */
2204
{ /* don't forget to drop the temp buffers */
2205
MNG_FREEX (pData, pBuf, iBufsize)
2206
MNG_FREEX (pData, zKeyword, iKeywordlen+1)
2207
return iRetcode;
2208
}
2209
/* store the fields */
2210
((mng_ztxtp)*ppChunk)->iKeywordsize = iKeywordlen;
2211
((mng_ztxtp)*ppChunk)->iCompression = *(pTemp+1);
2212
2213
if ((!pBuf) && (iCompressedsize)) /* did we not get a text-buffer yet ? */
2214
{ /* decompress the text */
2215
iRetcode = inflate_buffer (pData, pTemp+2, iCompressedsize,
2216
&pBuf, &iBufsize, &iTextlen);
2217
2218
if (iRetcode) /* on error bail out */
2219
{ /* don't forget to drop the temp buffers */
2220
MNG_FREEX (pData, pBuf, iBufsize)
2221
MNG_FREEX (pData, zKeyword, iKeywordlen+1)
2222
return iRetcode;
2223
}
2224
}
2225
2226
MNG_ALLOCX (pData, ((mng_ztxtp)*ppChunk)->zKeyword, iKeywordlen + 1)
2227
/* on error bail out */
2228
if (!((mng_ztxtp)*ppChunk)->zKeyword)
2229
{ /* don't forget to drop the temp buffers */
2230
MNG_FREEX (pData, pBuf, iBufsize)
2231
MNG_FREEX (pData, zKeyword, iKeywordlen+1)
2232
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2233
}
2234
2235
MNG_COPY (((mng_ztxtp)*ppChunk)->zKeyword, pRawdata, iKeywordlen)
2236
2237
((mng_ztxtp)*ppChunk)->iTextsize = iTextlen;
2238
2239
if (iCompressedsize)
2240
{
2241
MNG_ALLOCX (pData, ((mng_ztxtp)*ppChunk)->zText, iTextlen + 1)
2242
/* on error bail out */
2243
if (!((mng_ztxtp)*ppChunk)->zText)
2244
{ /* don't forget to drop the temp buffers */
2245
MNG_FREEX (pData, pBuf, iBufsize)
2246
MNG_FREEX (pData, zKeyword, iKeywordlen+1)
2247
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2248
}
2249
2250
MNG_COPY (((mng_ztxtp)*ppChunk)->zText, pBuf, iTextlen)
2251
}
2252
}
2253
#endif /* MNG_STORE_CHUNKS */
2254
2255
MNG_FREEX (pData, pBuf, iBufsize) /* free the temporary buffers */
2256
MNG_FREEX (pData, zKeyword, iKeywordlen+1)
2257
2258
#ifdef MNG_SUPPORT_TRACE
2259
MNG_TRACE (pData, MNG_FN_READ_ZTXT, MNG_LC_END)
2260
#endif
2261
2262
return MNG_NOERROR; /* done */
2263
}
2264
#endif
2265
2266
/* ************************************************************************** */
2267
2268
#ifndef MNG_SKIPCHUNK_iTXt
2269
READ_CHUNK (mng_read_itxt)
2270
{
2271
mng_retcode iRetcode;
2272
mng_uint32 iKeywordlen, iTextlen, iLanguagelen, iTranslationlen;
2273
mng_pchar zKeyword, zLanguage, zTranslation;
2274
mng_uint8p pNull1, pNull2, pNull3;
2275
mng_uint32 iCompressedsize;
2276
mng_uint8 iCompressionflag;
2277
mng_uint32 iBufsize;
2278
mng_uint8p pBuf;
2279
2280
#ifdef MNG_SUPPORT_TRACE
2281
MNG_TRACE (pData, MNG_FN_READ_ITXT, MNG_LC_START)
2282
#endif
2283
/* sequence checks */
2284
#ifdef MNG_INCLUDE_JNG
2285
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2286
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2287
#else
2288
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2289
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2290
#endif
2291
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2292
2293
if (iRawlen < 6) /* length must be at least 6 */
2294
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2295
2296
pNull1 = find_null (pRawdata); /* find the null separators */
2297
pNull2 = find_null (pNull1+3);
2298
pNull3 = find_null (pNull2+1);
2299
/* not found inside input-data ? */
2300
if (((pNull1 - pRawdata) > (mng_int32)iRawlen) ||
2301
((pNull2 - pRawdata) > (mng_int32)iRawlen) ||
2302
((pNull3 - pRawdata) > (mng_int32)iRawlen) )
2303
MNG_ERROR (pData, MNG_NULLNOTFOUND)
2304
2305
if (pNull1 == pRawdata) /* there must be at least 1 char for keyword */
2306
MNG_ERROR (pData, MNG_KEYWORDNULL)
2307
/* compression or not ? */
2308
if ((*(pNull1+1) != 0) && (*(pNull1+1) != 1))
2309
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
2310
2311
if (*(pNull1+2) != 0) /* only deflate compression-method allowed */
2312
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
2313
2314
iKeywordlen = (mng_uint32)(pNull1 - pRawdata);
2315
iLanguagelen = (mng_uint32)(pNull2 - pNull1 - 3);
2316
iTranslationlen = (mng_uint32)(pNull3 - pNull2 - 1);
2317
iCompressedsize = (mng_uint32)(iRawlen - iKeywordlen - iLanguagelen - iTranslationlen - 5);
2318
iCompressionflag = *(pNull1+1);
2319
2320
zKeyword = 0; /* no buffers acquired yet */
2321
zLanguage = 0;
2322
zTranslation = 0;
2323
pBuf = 0;
2324
iTextlen = 0;
2325
2326
if (pData->fProcesstext) /* inform the application ? */
2327
{
2328
if (iCompressionflag) /* decompress the text ? */
2329
{
2330
iRetcode = inflate_buffer (pData, pNull3+1, iCompressedsize,
2331
&pBuf, &iBufsize, &iTextlen);
2332
2333
if (iRetcode) /* on error bail out */
2334
{ /* don't forget to drop the temp buffer */
2335
MNG_FREEX (pData, pBuf, iBufsize)
2336
return iRetcode;
2337
}
2338
}
2339
else
2340
{
2341
iTextlen = iCompressedsize;
2342
iBufsize = iTextlen+1; /* plus 1 for terminator byte!!! */
2343
2344
MNG_ALLOC (pData, pBuf, iBufsize);
2345
MNG_COPY (pBuf, pNull3+1, iTextlen);
2346
}
2347
2348
MNG_ALLOCX (pData, zKeyword, iKeywordlen + 1)
2349
MNG_ALLOCX (pData, zLanguage, iLanguagelen + 1)
2350
MNG_ALLOCX (pData, zTranslation, iTranslationlen + 1)
2351
/* on error bail out */
2352
if ((!zKeyword) || (!zLanguage) || (!zTranslation))
2353
{ /* don't forget to drop the temp buffers */
2354
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2355
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2356
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2357
MNG_FREEX (pData, pBuf, iBufsize)
2358
MNG_ERROR (pData, MNG_OUTOFMEMORY)
2359
}
2360
2361
MNG_COPY (zKeyword, pRawdata, iKeywordlen)
2362
MNG_COPY (zLanguage, pNull1+3, iLanguagelen)
2363
MNG_COPY (zTranslation, pNull2+1, iTranslationlen)
2364
2365
if (!pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ITXT, zKeyword, (mng_pchar)pBuf,
2366
zLanguage, zTranslation))
2367
{ /* don't forget to drop the temp buffers */
2368
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2369
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2370
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2371
MNG_FREEX (pData, pBuf, iBufsize)
2372
2373
MNG_ERROR (pData, MNG_APPMISCERROR)
2374
}
2375
}
2376
2377
#ifdef MNG_STORE_CHUNKS
2378
if (pData->bStorechunks)
2379
{ /* initialize storage */
2380
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2381
2382
if (iRetcode) /* on error bail out */
2383
{ /* don't forget to drop the temp buffers */
2384
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2385
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2386
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2387
MNG_FREEX (pData, pBuf, iBufsize)
2388
return iRetcode;
2389
}
2390
/* store the fields */
2391
((mng_itxtp)*ppChunk)->iKeywordsize = iKeywordlen;
2392
((mng_itxtp)*ppChunk)->iLanguagesize = iLanguagelen;
2393
((mng_itxtp)*ppChunk)->iTranslationsize = iTranslationlen;
2394
((mng_itxtp)*ppChunk)->iCompressionflag = *(pNull1+1);
2395
((mng_itxtp)*ppChunk)->iCompressionmethod = *(pNull1+2);
2396
2397
if ((!pBuf) && (iCompressedsize)) /* did we not get a text-buffer yet ? */
2398
{
2399
if (iCompressionflag) /* decompress the text ? */
2400
{
2401
iRetcode = inflate_buffer (pData, pNull3+1, iCompressedsize,
2402
&pBuf, &iBufsize, &iTextlen);
2403
2404
if (iRetcode) /* on error bail out */
2405
{ /* don't forget to drop the temp buffers */
2406
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2407
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2408
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2409
MNG_FREEX (pData, pBuf, iBufsize)
2410
return iRetcode;
2411
}
2412
}
2413
else
2414
{
2415
iTextlen = iCompressedsize;
2416
iBufsize = iTextlen+1; /* plus 1 for terminator byte!!! */
2417
2418
MNG_ALLOC (pData, pBuf, iBufsize);
2419
MNG_COPY (pBuf, pNull3+1, iTextlen);
2420
}
2421
}
2422
2423
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zKeyword, iKeywordlen + 1)
2424
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zLanguage, iLanguagelen + 1)
2425
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zTranslation, iTranslationlen + 1)
2426
/* on error bail out */
2427
if ((!((mng_itxtp)*ppChunk)->zKeyword ) ||
2428
(!((mng_itxtp)*ppChunk)->zLanguage ) ||
2429
(!((mng_itxtp)*ppChunk)->zTranslation) )
2430
{ /* don't forget to drop the temp buffers */
2431
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2432
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2433
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2434
MNG_FREEX (pData, pBuf, iBufsize)
2435
MNG_ERROR (pData, MNG_OUTOFMEMORY)
2436
}
2437
2438
MNG_COPY (((mng_itxtp)*ppChunk)->zKeyword, pRawdata, iKeywordlen)
2439
MNG_COPY (((mng_itxtp)*ppChunk)->zLanguage, pNull1+3, iLanguagelen)
2440
MNG_COPY (((mng_itxtp)*ppChunk)->zTranslation, pNull2+1, iTranslationlen)
2441
2442
((mng_itxtp)*ppChunk)->iTextsize = iTextlen;
2443
2444
if (iTextlen)
2445
{
2446
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zText, iTextlen + 1)
2447
2448
if (!((mng_itxtp)*ppChunk)->zText)
2449
{ /* don't forget to drop the temp buffers */
2450
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2451
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2452
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2453
MNG_FREEX (pData, pBuf, iBufsize)
2454
MNG_ERROR (pData, MNG_OUTOFMEMORY)
2455
}
2456
2457
MNG_COPY (((mng_itxtp)*ppChunk)->zText, pBuf, iTextlen)
2458
}
2459
}
2460
#endif /* MNG_STORE_CHUNKS */
2461
/* free the temporary buffers */
2462
MNG_FREEX (pData, zTranslation, iTranslationlen + 1)
2463
MNG_FREEX (pData, zLanguage, iLanguagelen + 1)
2464
MNG_FREEX (pData, zKeyword, iKeywordlen + 1)
2465
MNG_FREEX (pData, pBuf, iBufsize)
2466
2467
#ifdef MNG_SUPPORT_TRACE
2468
MNG_TRACE (pData, MNG_FN_READ_ITXT, MNG_LC_END)
2469
#endif
2470
2471
return MNG_NOERROR; /* done */
2472
}
2473
#endif
2474
2475
/* ************************************************************************** */
2476
2477
#ifndef MNG_SKIPCHUNK_bKGD
2478
READ_CHUNK (mng_read_bkgd)
2479
{
2480
#ifdef MNG_SUPPORT_DISPLAY
2481
mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
2482
mng_imagedatap pBuf;
2483
#endif
2484
2485
#ifdef MNG_SUPPORT_TRACE
2486
MNG_TRACE (pData, MNG_FN_READ_BKGD, MNG_LC_START)
2487
#endif
2488
/* sequence checks */
2489
#ifdef MNG_INCLUDE_JNG
2490
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2491
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2492
#else
2493
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2494
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2495
#endif
2496
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2497
2498
#ifdef MNG_INCLUDE_JNG
2499
if ((pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
2500
#else
2501
if (pData->bHasIDAT)
2502
#endif
2503
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2504
2505
if (iRawlen > 6) /* it just can't be bigger than that! */
2506
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2507
2508
#ifdef MNG_INCLUDE_JNG /* length checks */
2509
if (pData->bHasJHDR)
2510
{
2511
if (((pData->iJHDRcolortype == 8) || (pData->iJHDRcolortype == 12)) && (iRawlen != 2))
2512
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2513
2514
if (((pData->iJHDRcolortype == 10) || (pData->iJHDRcolortype == 14)) && (iRawlen != 6))
2515
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2516
}
2517
else
2518
#endif /* MNG_INCLUDE_JNG */
2519
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2520
{
2521
if (((pData->iColortype == 0) || (pData->iColortype == 4)) && (iRawlen != 2))
2522
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2523
2524
if (((pData->iColortype == 2) || (pData->iColortype == 6)) && (iRawlen != 6))
2525
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2526
2527
if ((pData->iColortype == 3) && (iRawlen != 1))
2528
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2529
}
2530
else
2531
{
2532
if (iRawlen != 6) /* global is always 16-bit RGB ! */
2533
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2534
}
2535
2536
#ifdef MNG_INCLUDE_JNG
2537
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2538
#else
2539
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2540
#endif
2541
pData->bHasBKGD = MNG_TRUE; /* indicate bKGD available */
2542
else
2543
pData->bHasglobalBKGD = (mng_bool)(iRawlen != 0);
2544
2545
#ifdef MNG_SUPPORT_DISPLAY
2546
if (!pImage) /* if no object dump it in obj 0 */
2547
pImage = (mng_imagep)pData->pObjzero;
2548
2549
pBuf = pImage->pImgbuf; /* address object buffer */
2550
2551
#ifdef MNG_INCLUDE_JNG
2552
if (pData->bHasJHDR)
2553
{
2554
pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */
2555
2556
switch (pData->iJHDRcolortype) /* store fields for future reference */
2557
{
2558
case 8 : ; /* gray */
2559
case 12 : { /* graya */
2560
pBuf->iBKGDgray = mng_get_uint16 (pRawdata);
2561
break;
2562
}
2563
case 10 : ; /* rgb */
2564
case 14 : { /* rgba */
2565
pBuf->iBKGDred = mng_get_uint16 (pRawdata);
2566
pBuf->iBKGDgreen = mng_get_uint16 (pRawdata+2);
2567
pBuf->iBKGDblue = mng_get_uint16 (pRawdata+4);
2568
break;
2569
}
2570
}
2571
}
2572
else
2573
#endif /* MNG_INCLUDE_JNG */
2574
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2575
{
2576
pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */
2577
2578
switch (pData->iColortype) /* store fields for future reference */
2579
{
2580
case 0 : ; /* gray */
2581
case 4 : { /* graya */
2582
pBuf->iBKGDgray = mng_get_uint16 (pRawdata);
2583
break;
2584
}
2585
case 2 : ; /* rgb */
2586
case 6 : { /* rgba */
2587
pBuf->iBKGDred = mng_get_uint16 (pRawdata);
2588
pBuf->iBKGDgreen = mng_get_uint16 (pRawdata+2);
2589
pBuf->iBKGDblue = mng_get_uint16 (pRawdata+4);
2590
break;
2591
}
2592
case 3 : { /* indexed */
2593
pBuf->iBKGDindex = *pRawdata;
2594
break;
2595
}
2596
}
2597
}
2598
else /* store as global */
2599
{
2600
if (iRawlen)
2601
{
2602
pData->iGlobalBKGDred = mng_get_uint16 (pRawdata);
2603
pData->iGlobalBKGDgreen = mng_get_uint16 (pRawdata+2);
2604
pData->iGlobalBKGDblue = mng_get_uint16 (pRawdata+4);
2605
}
2606
2607
{ /* create an animation object */
2608
mng_retcode iRetcode = mng_create_ani_bkgd (pData, pData->iGlobalBKGDred,
2609
pData->iGlobalBKGDgreen,
2610
pData->iGlobalBKGDblue);
2611
2612
if (iRetcode) /* on error bail out */
2613
return iRetcode;
2614
}
2615
}
2616
#endif /* MNG_SUPPORT_DISPLAY */
2617
2618
#ifdef MNG_STORE_CHUNKS
2619
if (pData->bStorechunks)
2620
{ /* initialize storage */
2621
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2622
2623
if (iRetcode) /* on error bail out */
2624
return iRetcode;
2625
/* store the fields */
2626
((mng_bkgdp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2627
((mng_bkgdp)*ppChunk)->iType = pData->iColortype;
2628
2629
if (iRawlen)
2630
{
2631
switch (iRawlen) /* guess from length */
2632
{
2633
case 1 : { /* indexed */
2634
((mng_bkgdp)*ppChunk)->iType = 3;
2635
((mng_bkgdp)*ppChunk)->iIndex = *pRawdata;
2636
break;
2637
}
2638
case 2 : { /* gray */
2639
((mng_bkgdp)*ppChunk)->iType = 0;
2640
((mng_bkgdp)*ppChunk)->iGray = mng_get_uint16 (pRawdata);
2641
break;
2642
}
2643
case 6 : { /* rgb */
2644
((mng_bkgdp)*ppChunk)->iType = 2;
2645
((mng_bkgdp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
2646
((mng_bkgdp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
2647
((mng_bkgdp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
2648
break;
2649
}
2650
}
2651
}
2652
}
2653
#endif /* MNG_STORE_CHUNKS */
2654
2655
#ifdef MNG_SUPPORT_TRACE
2656
MNG_TRACE (pData, MNG_FN_READ_BKGD, MNG_LC_END)
2657
#endif
2658
2659
return MNG_NOERROR; /* done */
2660
}
2661
#endif
2662
2663
/* ************************************************************************** */
2664
2665
#ifndef MNG_SKIPCHUNK_pHYs
2666
READ_CHUNK (mng_read_phys)
2667
{
2668
#ifdef MNG_SUPPORT_TRACE
2669
MNG_TRACE (pData, MNG_FN_READ_PHYS, MNG_LC_START)
2670
#endif
2671
/* sequence checks */
2672
#ifdef MNG_INCLUDE_JNG
2673
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2674
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2675
#else
2676
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2677
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2678
#endif
2679
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2680
2681
#ifdef MNG_INCLUDE_JNG
2682
if ((pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
2683
#else
2684
if (pData->bHasIDAT)
2685
#endif
2686
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2687
/* it's 9 bytes or empty; no more, no less! */
2688
if ((iRawlen != 9) && (iRawlen != 0))
2689
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2690
2691
#ifdef MNG_SUPPORT_DISPLAY
2692
{
2693
2694
2695
/* TODO: something !!! */
2696
2697
2698
}
2699
#endif /* MNG_SUPPORT_DISPLAY */
2700
2701
#ifdef MNG_STORE_CHUNKS
2702
if (pData->bStorechunks)
2703
{ /* initialize storage */
2704
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2705
2706
if (iRetcode) /* on error bail out */
2707
return iRetcode;
2708
/* store the fields */
2709
((mng_physp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2710
2711
if (iRawlen)
2712
{
2713
((mng_physp)*ppChunk)->iSizex = mng_get_uint32 (pRawdata);
2714
((mng_physp)*ppChunk)->iSizey = mng_get_uint32 (pRawdata+4);
2715
((mng_physp)*ppChunk)->iUnit = *(pRawdata+8);
2716
}
2717
}
2718
#endif /* MNG_STORE_CHUNKS */
2719
2720
#ifdef MNG_SUPPORT_TRACE
2721
MNG_TRACE (pData, MNG_FN_READ_PHYS, MNG_LC_END)
2722
#endif
2723
2724
return MNG_NOERROR; /* done */
2725
}
2726
#endif
2727
2728
/* ************************************************************************** */
2729
2730
#ifndef MNG_SKIPCHUNK_sBIT
2731
READ_CHUNK (mng_read_sbit)
2732
{
2733
#ifdef MNG_SUPPORT_TRACE
2734
MNG_TRACE (pData, MNG_FN_READ_SBIT, MNG_LC_START)
2735
#endif
2736
/* sequence checks */
2737
#ifdef MNG_INCLUDE_JNG
2738
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2739
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2740
#else
2741
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2742
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2743
#endif
2744
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2745
2746
#ifdef MNG_INCLUDE_JNG
2747
if ((pData->bHasPLTE) || (pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
2748
#else
2749
if ((pData->bHasPLTE) || (pData->bHasIDAT))
2750
#endif
2751
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2752
2753
if (iRawlen > 4) /* it just can't be bigger than that! */
2754
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2755
2756
#ifdef MNG_INCLUDE_JNG /* length checks */
2757
if (pData->bHasJHDR)
2758
{
2759
if ((pData->iJHDRcolortype == 8) && (iRawlen != 1))
2760
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2761
2762
if ((pData->iJHDRcolortype == 10) && (iRawlen != 3))
2763
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2764
2765
if ((pData->iJHDRcolortype == 12) && (iRawlen != 2))
2766
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2767
2768
if ((pData->iJHDRcolortype == 14) && (iRawlen != 4))
2769
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2770
}
2771
else
2772
#endif /* MNG_INCLUDE_JNG */
2773
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2774
{
2775
if ((pData->iColortype == 0) && (iRawlen != 1))
2776
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2777
2778
if ((pData->iColortype == 2) && (iRawlen != 3))
2779
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2780
2781
if ((pData->iColortype == 3) && (iRawlen != 3))
2782
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2783
2784
if ((pData->iColortype == 4) && (iRawlen != 2))
2785
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2786
2787
if ((pData->iColortype == 6) && (iRawlen != 4))
2788
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2789
}
2790
else
2791
{ /* global = empty or RGBA */
2792
if ((iRawlen != 0) && (iRawlen != 4))
2793
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2794
}
2795
2796
#ifdef MNG_SUPPORT_DISPLAY
2797
{
2798
2799
2800
/* TODO: something !!! */
2801
2802
2803
}
2804
#endif /* MNG_SUPPORT_DISPLAY */
2805
2806
#ifdef MNG_STORE_CHUNKS
2807
if (pData->bStorechunks)
2808
{ /* initialize storage */
2809
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2810
2811
if (iRetcode) /* on error bail out */
2812
return iRetcode;
2813
/* store the fields */
2814
((mng_sbitp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2815
2816
if (iRawlen)
2817
{
2818
#ifdef MNG_INCLUDE_JNG
2819
if (pData->bHasJHDR)
2820
((mng_sbitp)*ppChunk)->iType = pData->iJHDRcolortype;
2821
else
2822
#endif
2823
if (pData->bHasIHDR)
2824
((mng_sbitp)*ppChunk)->iType = pData->iColortype;
2825
else /* global ! */
2826
((mng_sbitp)*ppChunk)->iType = 6;
2827
2828
if (iRawlen > 0)
2829
((mng_sbitp)*ppChunk)->aBits [0] = *pRawdata;
2830
if (iRawlen > 1)
2831
((mng_sbitp)*ppChunk)->aBits [1] = *(pRawdata+1);
2832
if (iRawlen > 2)
2833
((mng_sbitp)*ppChunk)->aBits [2] = *(pRawdata+2);
2834
if (iRawlen > 3)
2835
((mng_sbitp)*ppChunk)->aBits [3] = *(pRawdata+3);
2836
2837
}
2838
}
2839
#endif /* MNG_STORE_CHUNKS */
2840
2841
#ifdef MNG_SUPPORT_TRACE
2842
MNG_TRACE (pData, MNG_FN_READ_SBIT, MNG_LC_END)
2843
#endif
2844
2845
return MNG_NOERROR; /* done */
2846
}
2847
#endif
2848
2849
/* ************************************************************************** */
2850
2851
#ifndef MNG_SKIPCHUNK_sPLT
2852
READ_CHUNK (mng_read_splt)
2853
{
2854
mng_uint8p pTemp;
2855
mng_uint32 iNamelen;
2856
mng_uint8 iSampledepth;
2857
mng_uint32 iRemain;
2858
2859
#ifdef MNG_SUPPORT_TRACE
2860
MNG_TRACE (pData, MNG_FN_READ_SPLT, MNG_LC_START)
2861
#endif
2862
/* sequence checks */
2863
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2864
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2865
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2866
2867
if (pData->bHasIDAT)
2868
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2869
2870
if (iRawlen)
2871
{
2872
pTemp = find_null (pRawdata); /* find null-separator */
2873
/* not found inside input-data ? */
2874
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2875
MNG_ERROR (pData, MNG_NULLNOTFOUND)
2876
2877
iNamelen = (mng_uint32)(pTemp - pRawdata);
2878
iSampledepth = *(pTemp+1);
2879
iRemain = (iRawlen - 2 - iNamelen);
2880
2881
if ((iSampledepth != 1) && (iSampledepth != 2))
2882
MNG_ERROR (pData, MNG_INVSAMPLEDEPTH)
2883
/* check remaining length */
2884
if ( ((iSampledepth == 1) && (iRemain % 6 != 0)) ||
2885
((iSampledepth == 2) && (iRemain % 10 != 0)) )
2886
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2887
2888
}
2889
else
2890
{
2891
pTemp = MNG_NULL;
2892
iNamelen = 0;
2893
iSampledepth = 0;
2894
iRemain = 0;
2895
}
2896
2897
#ifdef MNG_SUPPORT_DISPLAY
2898
{
2899
2900
2901
/* TODO: something !!! */
2902
2903
2904
}
2905
#endif /* MNG_SUPPORT_DISPLAY */
2906
2907
#ifdef MNG_STORE_CHUNKS
2908
if (pData->bStorechunks)
2909
{ /* initialize storage */
2910
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2911
2912
if (iRetcode) /* on error bail out */
2913
return iRetcode;
2914
/* store the fields */
2915
((mng_spltp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2916
2917
if (iRawlen)
2918
{
2919
((mng_spltp)*ppChunk)->iNamesize = iNamelen;
2920
((mng_spltp)*ppChunk)->iSampledepth = iSampledepth;
2921
2922
if (iSampledepth == 1)
2923
((mng_spltp)*ppChunk)->iEntrycount = iRemain / 6;
2924
else
2925
((mng_spltp)*ppChunk)->iEntrycount = iRemain / 10;
2926
2927
if (iNamelen)
2928
{
2929
MNG_ALLOC (pData, ((mng_spltp)*ppChunk)->zName, iNamelen+1)
2930
MNG_COPY (((mng_spltp)*ppChunk)->zName, pRawdata, iNamelen)
2931
}
2932
2933
if (iRemain)
2934
{
2935
MNG_ALLOC (pData, ((mng_spltp)*ppChunk)->pEntries, iRemain)
2936
MNG_COPY (((mng_spltp)*ppChunk)->pEntries, pTemp+2, iRemain)
2937
}
2938
}
2939
}
2940
#endif /* MNG_STORE_CHUNKS */
2941
2942
#ifdef MNG_SUPPORT_TRACE
2943
MNG_TRACE (pData, MNG_FN_READ_SPLT, MNG_LC_END)
2944
#endif
2945
2946
return MNG_NOERROR; /* done */
2947
}
2948
#endif
2949
2950
/* ************************************************************************** */
2951
2952
#ifndef MNG_SKIPCHUNK_hIST
2953
READ_CHUNK (mng_read_hist)
2954
{
2955
#ifdef MNG_SUPPORT_TRACE
2956
MNG_TRACE (pData, MNG_FN_READ_HIST, MNG_LC_START)
2957
#endif
2958
/* sequence checks */
2959
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) )
2960
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2961
2962
if ((!pData->bHasPLTE) || (pData->bHasIDAT))
2963
MNG_ERROR (pData, MNG_SEQUENCEERROR)
2964
/* length oke ? */
2965
if ( ((iRawlen & 0x01) != 0) || ((iRawlen >> 1) != pData->iPLTEcount) )
2966
MNG_ERROR (pData, MNG_INVALIDLENGTH)
2967
2968
#ifdef MNG_SUPPORT_DISPLAY
2969
{
2970
2971
2972
/* TODO: something !!! */
2973
2974
2975
}
2976
#endif /* MNG_SUPPORT_DISPLAY */
2977
2978
#ifdef MNG_STORE_CHUNKS
2979
if (pData->bStorechunks)
2980
{
2981
mng_uint32 iX;
2982
/* initialize storage */
2983
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2984
2985
if (iRetcode) /* on error bail out */
2986
return iRetcode;
2987
/* store the fields */
2988
((mng_histp)*ppChunk)->iEntrycount = iRawlen >> 1;
2989
2990
for (iX = 0; iX < (iRawlen >> 1); iX++)
2991
{
2992
((mng_histp)*ppChunk)->aEntries [iX] = mng_get_uint16 (pRawdata);
2993
pRawdata += 2;
2994
}
2995
}
2996
#endif /* MNG_STORE_CHUNKS */
2997
2998
#ifdef MNG_SUPPORT_TRACE
2999
MNG_TRACE (pData, MNG_FN_READ_HIST, MNG_LC_END)
3000
#endif
3001
3002
return MNG_NOERROR; /* done */
3003
}
3004
#endif
3005
3006
/* ************************************************************************** */
3007
3008
#ifndef MNG_SKIPCHUNK_tIME
3009
READ_CHUNK (mng_read_time)
3010
{
3011
#ifdef MNG_SUPPORT_TRACE
3012
MNG_TRACE (pData, MNG_FN_READ_TIME, MNG_LC_START)
3013
#endif
3014
/* sequence checks */
3015
#ifdef MNG_INCLUDE_JNG
3016
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3017
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
3018
#else
3019
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3020
(!pData->bHasBASI) && (!pData->bHasDHDR) )
3021
#endif
3022
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3023
3024
if (iRawlen != 7) /* length must be exactly 7 */
3025
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3026
3027
/* if (pData->fProcesstime) */ /* inform the application ? */
3028
/* {
3029
3030
pData->fProcesstime ((mng_handle)pData, );
3031
} */
3032
3033
#ifdef MNG_STORE_CHUNKS
3034
if (pData->bStorechunks)
3035
{ /* initialize storage */
3036
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3037
3038
if (iRetcode) /* on error bail out */
3039
return iRetcode;
3040
/* store the fields */
3041
((mng_timep)*ppChunk)->iYear = mng_get_uint16 (pRawdata);
3042
((mng_timep)*ppChunk)->iMonth = *(pRawdata+2);
3043
((mng_timep)*ppChunk)->iDay = *(pRawdata+3);
3044
((mng_timep)*ppChunk)->iHour = *(pRawdata+4);
3045
((mng_timep)*ppChunk)->iMinute = *(pRawdata+5);
3046
((mng_timep)*ppChunk)->iSecond = *(pRawdata+6);
3047
}
3048
#endif /* MNG_STORE_CHUNKS */
3049
3050
#ifdef MNG_SUPPORT_TRACE
3051
MNG_TRACE (pData, MNG_FN_READ_TIME, MNG_LC_END)
3052
#endif
3053
3054
return MNG_NOERROR; /* done */
3055
}
3056
#endif
3057
3058
/* ************************************************************************** */
3059
3060
READ_CHUNK (mng_read_mhdr)
3061
{
3062
#ifdef MNG_SUPPORT_TRACE
3063
MNG_TRACE (pData, MNG_FN_READ_MHDR, MNG_LC_START)
3064
#endif
3065
3066
if (pData->eSigtype != mng_it_mng) /* sequence checks */
3067
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED)
3068
3069
if (pData->bHasheader) /* can only be the first chunk! */
3070
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3071
/* correct length ? */
3072
#ifndef MNG_NO_OLD_VERSIONS
3073
if ((iRawlen != 28) && (iRawlen != 12))
3074
#else
3075
if ((iRawlen != 28))
3076
#endif
3077
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3078
3079
pData->bHasMHDR = MNG_TRUE; /* oh boy, a real MNG */
3080
pData->bHasheader = MNG_TRUE; /* we've got a header */
3081
pData->eImagetype = mng_it_mng; /* fill header fields */
3082
pData->iWidth = mng_get_uint32 (pRawdata);
3083
pData->iHeight = mng_get_uint32 (pRawdata+4);
3084
pData->iTicks = mng_get_uint32 (pRawdata+8);
3085
3086
#ifndef MNG_NO_OLD_VERSIONS
3087
if (iRawlen == 28) /* proper MHDR ? */
3088
{
3089
#endif
3090
pData->iLayercount = mng_get_uint32 (pRawdata+12);
3091
pData->iFramecount = mng_get_uint32 (pRawdata+16);
3092
pData->iPlaytime = mng_get_uint32 (pRawdata+20);
3093
pData->iSimplicity = mng_get_uint32 (pRawdata+24);
3094
3095
#ifndef MNG_NO_OLD_VERSIONS
3096
pData->bPreDraft48 = MNG_FALSE;
3097
}
3098
else /* probably pre-draft48 then */
3099
{
3100
pData->iLayercount = 0;
3101
pData->iFramecount = 0;
3102
pData->iPlaytime = 0;
3103
pData->iSimplicity = 0;
3104
3105
pData->bPreDraft48 = MNG_TRUE;
3106
}
3107
#endif
3108
/* predict alpha-depth */
3109
if ((pData->iSimplicity & 0x00000001) == 0)
3110
#ifndef MNG_NO_16BIT_SUPPORT
3111
pData->iAlphadepth = 16; /* no indicators = assume the worst */
3112
#else
3113
pData->iAlphadepth = 8; /* anything else = assume the worst */
3114
#endif
3115
else
3116
if ((pData->iSimplicity & 0x00000008) == 0)
3117
pData->iAlphadepth = 0; /* no transparency at all */
3118
else
3119
if ((pData->iSimplicity & 0x00000140) == 0x00000040)
3120
pData->iAlphadepth = 1; /* no semi-transparency guaranteed */
3121
else
3122
#ifndef MNG_NO_16BIT_SUPPORT
3123
pData->iAlphadepth = 16; /* anything else = assume the worst */
3124
#else
3125
pData->iAlphadepth = 8; /* anything else = assume the worst */
3126
#endif
3127
3128
#ifdef MNG_INCLUDE_JNG /* can we handle the complexity ? */
3129
if (pData->iSimplicity & 0x0000FC00)
3130
#else
3131
if (pData->iSimplicity & 0x0000FC10)
3132
#endif
3133
MNG_ERROR (pData, MNG_MNGTOOCOMPLEX)
3134
/* fits on maximum canvas ? */
3135
if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
3136
MNG_WARNING (pData, MNG_IMAGETOOLARGE)
3137
3138
if (pData->fProcessheader) /* inform the app ? */
3139
if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
3140
MNG_ERROR (pData, MNG_APPMISCERROR)
3141
3142
pData->iImagelevel++; /* one level deeper */
3143
3144
#ifdef MNG_STORE_CHUNKS
3145
if (pData->bStorechunks)
3146
{ /* initialize storage */
3147
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3148
3149
if (iRetcode) /* on error bail out */
3150
return iRetcode;
3151
/* store the fields */
3152
((mng_mhdrp)*ppChunk)->iWidth = pData->iWidth;
3153
((mng_mhdrp)*ppChunk)->iHeight = pData->iHeight;
3154
((mng_mhdrp)*ppChunk)->iTicks = pData->iTicks;
3155
((mng_mhdrp)*ppChunk)->iLayercount = pData->iLayercount;
3156
((mng_mhdrp)*ppChunk)->iFramecount = pData->iFramecount;
3157
((mng_mhdrp)*ppChunk)->iPlaytime = pData->iPlaytime;
3158
((mng_mhdrp)*ppChunk)->iSimplicity = pData->iSimplicity;
3159
}
3160
#endif /* MNG_STORE_CHUNKS */
3161
3162
#ifdef MNG_SUPPORT_TRACE
3163
MNG_TRACE (pData, MNG_FN_READ_MHDR, MNG_LC_END)
3164
#endif
3165
3166
return MNG_NOERROR; /* done */
3167
}
3168
3169
/* ************************************************************************** */
3170
3171
READ_CHUNK (mng_read_mend)
3172
{
3173
#ifdef MNG_SUPPORT_TRACE
3174
MNG_TRACE (pData, MNG_FN_READ_MEND, MNG_LC_START)
3175
#endif
3176
3177
if (!pData->bHasMHDR) /* sequence checks */
3178
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3179
3180
if (iRawlen > 0) /* must not contain data! */
3181
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3182
3183
#ifdef MNG_SUPPORT_DISPLAY
3184
{ /* do something */
3185
mng_retcode iRetcode = mng_process_display_mend (pData);
3186
3187
if (iRetcode) /* on error bail out */
3188
return iRetcode;
3189
3190
if (!pData->iTotalframes) /* save totals */
3191
pData->iTotalframes = pData->iFrameseq;
3192
if (!pData->iTotallayers)
3193
pData->iTotallayers = pData->iLayerseq;
3194
if (!pData->iTotalplaytime)
3195
pData->iTotalplaytime = pData->iFrametime;
3196
}
3197
#endif /* MNG_SUPPORT_DISPLAY */
3198
3199
pData->bHasMHDR = MNG_FALSE; /* end of the line, bro! */
3200
3201
#ifdef MNG_STORE_CHUNKS
3202
if (pData->bStorechunks)
3203
{ /* initialize storage */
3204
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3205
3206
if (iRetcode) /* on error bail out */
3207
return iRetcode;
3208
}
3209
#endif /* MNG_STORE_CHUNKS */
3210
3211
#ifdef MNG_SUPPORT_TRACE
3212
MNG_TRACE (pData, MNG_FN_READ_MEND, MNG_LC_END)
3213
#endif
3214
3215
return MNG_NOERROR; /* done */
3216
}
3217
3218
/* ************************************************************************** */
3219
3220
#ifndef MNG_SKIPCHUNK_LOOP
3221
READ_CHUNK (mng_read_loop)
3222
{
3223
#ifdef MNG_SUPPORT_TRACE
3224
MNG_TRACE (pData, MNG_FN_READ_LOOP, MNG_LC_START)
3225
#endif
3226
3227
if (!pData->bHasMHDR) /* sequence checks */
3228
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3229
3230
if (!pData->bCacheplayback) /* must store playback info to work!! */
3231
MNG_ERROR (pData, MNG_LOOPWITHCACHEOFF)
3232
3233
#ifdef MNG_INCLUDE_JNG
3234
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3235
#else
3236
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3237
#endif
3238
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3239
3240
if (iRawlen >= 5) /* length checks */
3241
{
3242
if (iRawlen >= 6)
3243
{
3244
if ((iRawlen - 6) % 4 != 0)
3245
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3246
}
3247
}
3248
else
3249
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3250
3251
#ifdef MNG_SUPPORT_DISPLAY
3252
{
3253
mng_uint8 iLevel;
3254
mng_uint32 iRepeat;
3255
mng_uint8 iTermination = 0;
3256
mng_uint32 iItermin = 1;
3257
mng_uint32 iItermax = 0x7fffffffL;
3258
mng_retcode iRetcode;
3259
3260
pData->bHasLOOP = MNG_TRUE; /* indicate we're inside a loop */
3261
3262
iLevel = *pRawdata; /* determine the fields for processing */
3263
3264
#ifndef MNG_NO_OLD_VERSIONS
3265
if (pData->bPreDraft48)
3266
{
3267
iTermination = *(pRawdata+1);
3268
3269
iRepeat = mng_get_uint32 (pRawdata+2);
3270
}
3271
else
3272
#endif
3273
iRepeat = mng_get_uint32 (pRawdata+1);
3274
3275
if (iRawlen >= 6)
3276
{
3277
#ifndef MNG_NO_OLD_VERSIONS
3278
if (!pData->bPreDraft48)
3279
#endif
3280
iTermination = *(pRawdata+5);
3281
3282
if (iRawlen >= 10)
3283
{
3284
iItermin = mng_get_uint32 (pRawdata+6);
3285
3286
if (iRawlen >= 14)
3287
{
3288
iItermax = mng_get_uint32 (pRawdata+10);
3289
3290
/* TODO: process signals */
3291
3292
}
3293
}
3294
}
3295
/* create the LOOP ani-object */
3296
iRetcode = mng_create_ani_loop (pData, iLevel, iRepeat, iTermination,
3297
iItermin, iItermax, 0, 0);
3298
3299
if (iRetcode) /* on error bail out */
3300
return iRetcode;
3301
/* skip till matching ENDL if iteration=0 */
3302
if ((!pData->bSkipping) && (iRepeat == 0))
3303
pData->bSkipping = MNG_TRUE;
3304
}
3305
#endif /* MNG_SUPPORT_DISPLAY */
3306
3307
#ifdef MNG_STORE_CHUNKS
3308
if (pData->bStorechunks)
3309
{ /* initialize storage */
3310
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3311
3312
if (iRetcode) /* on error bail out */
3313
return iRetcode;
3314
3315
if (iRawlen >= 5) /* store the fields */
3316
{
3317
((mng_loopp)*ppChunk)->iLevel = *pRawdata;
3318
3319
#ifndef MNG_NO_OLD_VERSIONS
3320
if (pData->bPreDraft48)
3321
{
3322
((mng_loopp)*ppChunk)->iTermination = *(pRawdata+1);
3323
((mng_loopp)*ppChunk)->iRepeat = mng_get_uint32 (pRawdata+2);
3324
}
3325
else
3326
#endif
3327
{
3328
((mng_loopp)*ppChunk)->iRepeat = mng_get_uint32 (pRawdata+1);
3329
}
3330
3331
if (iRawlen >= 6)
3332
{
3333
#ifndef MNG_NO_OLD_VERSIONS
3334
if (!pData->bPreDraft48)
3335
#endif
3336
((mng_loopp)*ppChunk)->iTermination = *(pRawdata+5);
3337
3338
if (iRawlen >= 10)
3339
{
3340
((mng_loopp)*ppChunk)->iItermin = mng_get_uint32 (pRawdata+6);
3341
3342
#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
3343
if (iRawlen >= 14)
3344
{
3345
((mng_loopp)*ppChunk)->iItermax = mng_get_uint32 (pRawdata+10);
3346
((mng_loopp)*ppChunk)->iCount = (iRawlen - 14) / 4;
3347
3348
if (((mng_loopp)*ppChunk)->iCount)
3349
{
3350
MNG_ALLOC (pData, ((mng_loopp)*ppChunk)->pSignals,
3351
((mng_loopp)*ppChunk)->iCount << 2)
3352
3353
#ifndef MNG_BIGENDIAN_SUPPORTED
3354
{
3355
mng_uint32 iX;
3356
mng_uint8p pIn = pRawdata + 14;
3357
mng_uint32p pOut = (mng_uint32p)((mng_loopp)*ppChunk)->pSignals;
3358
3359
for (iX = 0; iX < ((mng_loopp)*ppChunk)->iCount; iX++)
3360
{
3361
*pOut++ = mng_get_uint32 (pIn);
3362
pIn += 4;
3363
}
3364
}
3365
#else
3366
MNG_COPY (((mng_loopp)*ppChunk)->pSignals, pRawdata + 14,
3367
((mng_loopp)*ppChunk)->iCount << 2)
3368
#endif /* !MNG_BIGENDIAN_SUPPORTED */
3369
}
3370
}
3371
#endif
3372
}
3373
}
3374
}
3375
}
3376
#endif /* MNG_STORE_CHUNKS */
3377
3378
#ifdef MNG_SUPPORT_TRACE
3379
MNG_TRACE (pData, MNG_FN_READ_LOOP, MNG_LC_END)
3380
#endif
3381
3382
return MNG_NOERROR; /* done */
3383
}
3384
#endif
3385
3386
/* ************************************************************************** */
3387
3388
#ifndef MNG_SKIPCHUNK_LOOP
3389
READ_CHUNK (mng_read_endl)
3390
{
3391
#ifdef MNG_SUPPORT_TRACE
3392
MNG_TRACE (pData, MNG_FN_READ_ENDL, MNG_LC_START)
3393
#endif
3394
3395
if (!pData->bHasMHDR) /* sequence checks */
3396
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3397
3398
#ifdef MNG_INCLUDE_JNG
3399
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3400
#else
3401
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3402
#endif
3403
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3404
3405
if (iRawlen != 1) /* length must be exactly 1 */
3406
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3407
3408
#ifdef MNG_SUPPORT_DISPLAY
3409
{
3410
if (pData->bHasLOOP) /* are we really processing a loop ? */
3411
{
3412
mng_uint8 iLevel = *pRawdata; /* get the nest level */
3413
/* create an ENDL animation object */
3414
mng_retcode iRetcode = mng_create_ani_endl (pData, iLevel);
3415
3416
if (iRetcode) /* on error bail out */
3417
return iRetcode;
3418
3419
{ /* process it */
3420
mng_ani_endlp pENDL = (mng_ani_endlp)pData->pLastaniobj;
3421
3422
iRetcode = pENDL->sHeader.fProcess (pData, pENDL);
3423
3424
if (iRetcode) /* on error bail out */
3425
return iRetcode;
3426
}
3427
}
3428
else
3429
MNG_ERROR (pData, MNG_NOMATCHINGLOOP)
3430
3431
}
3432
#endif /* MNG_SUPPORT_DISPLAY */
3433
3434
#ifdef MNG_STORE_CHUNKS
3435
if (pData->bStorechunks)
3436
{ /* initialize storage */
3437
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3438
3439
if (iRetcode) /* on error bail out */
3440
return iRetcode;
3441
/* store the fields */
3442
((mng_endlp)*ppChunk)->iLevel = *pRawdata;
3443
}
3444
#endif /* MNG_STORE_CHUNKS */
3445
3446
#ifdef MNG_SUPPORT_TRACE
3447
MNG_TRACE (pData, MNG_FN_READ_ENDL, MNG_LC_END)
3448
#endif
3449
3450
return MNG_NOERROR; /* done */
3451
}
3452
#endif
3453
3454
/* ************************************************************************** */
3455
3456
#ifndef MNG_SKIPCHUNK_DEFI
3457
READ_CHUNK (mng_read_defi)
3458
{
3459
#ifdef MNG_SUPPORT_TRACE
3460
MNG_TRACE (pData, MNG_FN_READ_DEFI, MNG_LC_START)
3461
#endif
3462
3463
if (!pData->bHasMHDR) /* sequence checks */
3464
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3465
3466
#ifdef MNG_INCLUDE_JNG
3467
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3468
#else
3469
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3470
#endif
3471
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3472
/* check the length */
3473
if ((iRawlen != 2) && (iRawlen != 3) && (iRawlen != 4) &&
3474
(iRawlen != 12) && (iRawlen != 28))
3475
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3476
3477
#ifdef MNG_SUPPORT_DISPLAY
3478
{
3479
mng_retcode iRetcode;
3480
3481
pData->iDEFIobjectid = mng_get_uint16 (pRawdata);
3482
3483
if (iRawlen > 2)
3484
{
3485
pData->bDEFIhasdonotshow = MNG_TRUE;
3486
pData->iDEFIdonotshow = *(pRawdata+2);
3487
}
3488
else
3489
{
3490
pData->bDEFIhasdonotshow = MNG_FALSE;
3491
pData->iDEFIdonotshow = 0;
3492
}
3493
3494
if (iRawlen > 3)
3495
{
3496
pData->bDEFIhasconcrete = MNG_TRUE;
3497
pData->iDEFIconcrete = *(pRawdata+3);
3498
}
3499
else
3500
{
3501
pData->bDEFIhasconcrete = MNG_FALSE;
3502
pData->iDEFIconcrete = 0;
3503
}
3504
3505
if (iRawlen > 4)
3506
{
3507
pData->bDEFIhasloca = MNG_TRUE;
3508
pData->iDEFIlocax = mng_get_int32 (pRawdata+4);
3509
pData->iDEFIlocay = mng_get_int32 (pRawdata+8);
3510
}
3511
else
3512
{
3513
pData->bDEFIhasloca = MNG_FALSE;
3514
pData->iDEFIlocax = 0;
3515
pData->iDEFIlocay = 0;
3516
}
3517
3518
if (iRawlen > 12)
3519
{
3520
pData->bDEFIhasclip = MNG_TRUE;
3521
pData->iDEFIclipl = mng_get_int32 (pRawdata+12);
3522
pData->iDEFIclipr = mng_get_int32 (pRawdata+16);
3523
pData->iDEFIclipt = mng_get_int32 (pRawdata+20);
3524
pData->iDEFIclipb = mng_get_int32 (pRawdata+24);
3525
}
3526
else
3527
{
3528
pData->bDEFIhasclip = MNG_FALSE;
3529
pData->iDEFIclipl = 0;
3530
pData->iDEFIclipr = 0;
3531
pData->iDEFIclipt = 0;
3532
pData->iDEFIclipb = 0;
3533
}
3534
/* create an animation object */
3535
iRetcode = mng_create_ani_defi (pData);
3536
3537
if (!iRetcode) /* do display processing */
3538
iRetcode = mng_process_display_defi (pData);
3539
3540
if (iRetcode) /* on error bail out */
3541
return iRetcode;
3542
3543
}
3544
#endif /* MNG_SUPPORT_DISPLAY */
3545
3546
#ifdef MNG_STORE_CHUNKS
3547
if (pData->bStorechunks)
3548
{ /* initialize storage */
3549
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3550
3551
if (iRetcode) /* on error bail out */
3552
return iRetcode;
3553
/* store the fields */
3554
((mng_defip)*ppChunk)->iObjectid = mng_get_uint16 (pRawdata);
3555
3556
if (iRawlen > 2)
3557
{
3558
((mng_defip)*ppChunk)->bHasdonotshow = MNG_TRUE;
3559
((mng_defip)*ppChunk)->iDonotshow = *(pRawdata+2);
3560
}
3561
else
3562
((mng_defip)*ppChunk)->bHasdonotshow = MNG_FALSE;
3563
3564
if (iRawlen > 3)
3565
{
3566
((mng_defip)*ppChunk)->bHasconcrete = MNG_TRUE;
3567
((mng_defip)*ppChunk)->iConcrete = *(pRawdata+3);
3568
}
3569
else
3570
((mng_defip)*ppChunk)->bHasconcrete = MNG_FALSE;
3571
3572
if (iRawlen > 4)
3573
{
3574
((mng_defip)*ppChunk)->bHasloca = MNG_TRUE;
3575
((mng_defip)*ppChunk)->iXlocation = mng_get_int32 (pRawdata+4);
3576
((mng_defip)*ppChunk)->iYlocation = mng_get_int32 (pRawdata+8);
3577
}
3578
else
3579
((mng_defip)*ppChunk)->bHasloca = MNG_FALSE;
3580
3581
if (iRawlen > 12)
3582
{
3583
((mng_defip)*ppChunk)->bHasclip = MNG_TRUE;
3584
((mng_defip)*ppChunk)->iLeftcb = mng_get_int32 (pRawdata+12);
3585
((mng_defip)*ppChunk)->iRightcb = mng_get_int32 (pRawdata+16);
3586
((mng_defip)*ppChunk)->iTopcb = mng_get_int32 (pRawdata+20);
3587
((mng_defip)*ppChunk)->iBottomcb = mng_get_int32 (pRawdata+24);
3588
}
3589
else
3590
((mng_defip)*ppChunk)->bHasclip = MNG_FALSE;
3591
3592
}
3593
#endif /* MNG_STORE_CHUNKS */
3594
3595
#ifdef MNG_SUPPORT_TRACE
3596
MNG_TRACE (pData, MNG_FN_READ_DEFI, MNG_LC_END)
3597
#endif
3598
3599
return MNG_NOERROR; /* done */
3600
}
3601
#endif
3602
3603
/* ************************************************************************** */
3604
3605
#ifndef MNG_SKIPCHUNK_BASI
3606
READ_CHUNK (mng_read_basi)
3607
{
3608
#ifdef MNG_SUPPORT_TRACE
3609
MNG_TRACE (pData, MNG_FN_READ_BASI, MNG_LC_START)
3610
#endif
3611
3612
if (!pData->bHasMHDR) /* sequence checks */
3613
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3614
3615
#ifdef MNG_INCLUDE_JNG
3616
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3617
#else
3618
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3619
#endif
3620
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3621
/* check the length */
3622
if ((iRawlen != 13) && (iRawlen != 19) && (iRawlen != 21) && (iRawlen != 22))
3623
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3624
3625
pData->bHasBASI = MNG_TRUE; /* inside a BASI-IEND block now */
3626
/* store interesting fields */
3627
pData->iDatawidth = mng_get_uint32 (pRawdata);
3628
pData->iDataheight = mng_get_uint32 (pRawdata+4);
3629
pData->iBitdepth = *(pRawdata+8);
3630
pData->iColortype = *(pRawdata+9);
3631
pData->iCompression = *(pRawdata+10);
3632
pData->iFilter = *(pRawdata+11);
3633
pData->iInterlace = *(pRawdata+12);
3634
3635
3636
#if defined(MNG_NO_16BIT_SUPPORT)
3637
pData->iPNGmult = 1;
3638
pData->iPNGdepth = pData->iBitdepth;
3639
if (pData->iBitdepth > 8)
3640
{
3641
pData->iBitdepth = 8;
3642
pData->iPNGmult = 2;
3643
}
3644
#endif
3645
3646
if ((pData->iBitdepth != 8) /* parameter validity checks */
3647
&& (pData->iBitdepth != 1) &&
3648
(pData->iBitdepth != 2) &&
3649
(pData->iBitdepth != 4)
3650
#ifndef MNG_NO_16BIT_SUPPORT
3651
&& (pData->iBitdepth != 16)
3652
#endif
3653
)
3654
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
3655
3656
if ((pData->iColortype != MNG_COLORTYPE_GRAY ) &&
3657
(pData->iColortype != MNG_COLORTYPE_RGB ) &&
3658
(pData->iColortype != MNG_COLORTYPE_INDEXED) &&
3659
(pData->iColortype != MNG_COLORTYPE_GRAYA ) &&
3660
(pData->iColortype != MNG_COLORTYPE_RGBA ) )
3661
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
3662
3663
if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
3664
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
3665
3666
if (((pData->iColortype == MNG_COLORTYPE_RGB ) ||
3667
(pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
3668
(pData->iColortype == MNG_COLORTYPE_RGBA ) ) &&
3669
(pData->iBitdepth < 8 ) )
3670
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
3671
3672
if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
3673
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
3674
3675
#if defined(FILTER192) || defined(FILTER193)
3676
if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
3677
#if defined(FILTER192) && defined(FILTER193)
3678
(pData->iFilter != MNG_FILTER_DIFFERING) &&
3679
(pData->iFilter != MNG_FILTER_NOFILTER ) )
3680
#else
3681
#ifdef FILTER192
3682
(pData->iFilter != MNG_FILTER_DIFFERING) )
3683
#else
3684
(pData->iFilter != MNG_FILTER_NOFILTER ) )
3685
#endif
3686
#endif
3687
MNG_ERROR (pData, MNG_INVALIDFILTER)
3688
#else
3689
if (pData->iFilter)
3690
MNG_ERROR (pData, MNG_INVALIDFILTER)
3691
#endif
3692
3693
if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
3694
(pData->iInterlace != MNG_INTERLACE_ADAM7) )
3695
MNG_ERROR (pData, MNG_INVALIDINTERLACE)
3696
3697
pData->iImagelevel++; /* one level deeper */
3698
3699
#ifdef MNG_SUPPORT_DISPLAY
3700
{
3701
mng_uint16 iRed = 0;
3702
mng_uint16 iGreen = 0;
3703
mng_uint16 iBlue = 0;
3704
mng_bool bHasalpha = MNG_FALSE;
3705
mng_uint16 iAlpha = 0xFFFF;
3706
mng_uint8 iViewable = 0;
3707
mng_retcode iRetcode;
3708
3709
if (iRawlen > 13) /* get remaining fields, if any */
3710
{
3711
iRed = mng_get_uint16 (pRawdata+13);
3712
iGreen = mng_get_uint16 (pRawdata+15);
3713
iBlue = mng_get_uint16 (pRawdata+17);
3714
}
3715
3716
if (iRawlen > 19)
3717
{
3718
bHasalpha = MNG_TRUE;
3719
iAlpha = mng_get_uint16 (pRawdata+19);
3720
}
3721
3722
if (iRawlen > 21)
3723
iViewable = *(pRawdata+21);
3724
/* create an animation object */
3725
iRetcode = mng_create_ani_basi (pData, iRed, iGreen, iBlue,
3726
bHasalpha, iAlpha, iViewable);
3727
3728
if (!iRetcode) /* display-processing... */
3729
iRetcode = mng_process_display_basi (pData, iRed, iGreen, iBlue,
3730
bHasalpha, iAlpha, iViewable);
3731
3732
if (iRetcode) /* on error bail out */
3733
return iRetcode;
3734
3735
}
3736
#endif /* MNG_SUPPORT_DISPLAY */
3737
3738
#ifdef MNG_STORE_CHUNKS
3739
if (pData->bStorechunks)
3740
{ /* initialize storage */
3741
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3742
3743
if (iRetcode) /* on error bail out */
3744
return iRetcode;
3745
/* store the fields */
3746
((mng_basip)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
3747
((mng_basip)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
3748
#ifdef MNG_NO_16BIT_SUPPORT
3749
if (*(pRawdata+8) > 8)
3750
((mng_basip)*ppChunk)->iBitdepth = 8;
3751
else
3752
#endif
3753
((mng_basip)*ppChunk)->iBitdepth = *(pRawdata+8);
3754
((mng_basip)*ppChunk)->iColortype = *(pRawdata+9);
3755
((mng_basip)*ppChunk)->iCompression = *(pRawdata+10);
3756
((mng_basip)*ppChunk)->iFilter = *(pRawdata+11);
3757
((mng_basip)*ppChunk)->iInterlace = *(pRawdata+12);
3758
3759
if (iRawlen > 13)
3760
{
3761
((mng_basip)*ppChunk)->iRed = mng_get_uint16 (pRawdata+13);
3762
((mng_basip)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+15);
3763
((mng_basip)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+17);
3764
}
3765
3766
if (iRawlen > 19)
3767
((mng_basip)*ppChunk)->iAlpha = mng_get_uint16 (pRawdata+19);
3768
3769
if (iRawlen > 21)
3770
((mng_basip)*ppChunk)->iViewable = *(pRawdata+21);
3771
3772
}
3773
#endif /* MNG_STORE_CHUNKS */
3774
3775
#ifdef MNG_SUPPORT_TRACE
3776
MNG_TRACE (pData, MNG_FN_READ_BASI, MNG_LC_END)
3777
#endif
3778
3779
return MNG_NOERROR; /* done */
3780
}
3781
3782
/* ************************************************************************** */
3783
3784
READ_CHUNK (mng_read_clon)
3785
{
3786
#ifdef MNG_SUPPORT_TRACE
3787
MNG_TRACE (pData, MNG_FN_READ_CLON, MNG_LC_START)
3788
#endif
3789
3790
if (!pData->bHasMHDR) /* sequence checks */
3791
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3792
3793
#ifdef MNG_INCLUDE_JNG
3794
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3795
#else
3796
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3797
#endif
3798
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3799
/* check the length */
3800
if ((iRawlen != 4) && (iRawlen != 5) && (iRawlen != 6) &&
3801
(iRawlen != 7) && (iRawlen != 16))
3802
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3803
3804
#ifdef MNG_SUPPORT_DISPLAY
3805
{
3806
mng_uint16 iSourceid, iCloneid;
3807
mng_uint8 iClonetype = 0;
3808
mng_bool bHasdonotshow = MNG_FALSE;
3809
mng_uint8 iDonotshow = 0;
3810
mng_uint8 iConcrete = 0;
3811
mng_bool bHasloca = MNG_FALSE;
3812
mng_uint8 iLocationtype = 0;
3813
mng_int32 iLocationx = 0;
3814
mng_int32 iLocationy = 0;
3815
mng_retcode iRetcode;
3816
3817
iSourceid = mng_get_uint16 (pRawdata);
3818
iCloneid = mng_get_uint16 (pRawdata+2);
3819
3820
if (iRawlen > 4)
3821
iClonetype = *(pRawdata+4);
3822
3823
if (iRawlen > 5)
3824
{
3825
bHasdonotshow = MNG_TRUE;
3826
iDonotshow = *(pRawdata+5);
3827
}
3828
3829
if (iRawlen > 6)
3830
iConcrete = *(pRawdata+6);
3831
3832
if (iRawlen > 7)
3833
{
3834
bHasloca = MNG_TRUE;
3835
iLocationtype = *(pRawdata+7);
3836
iLocationx = mng_get_int32 (pRawdata+8);
3837
iLocationy = mng_get_int32 (pRawdata+12);
3838
}
3839
3840
iRetcode = mng_create_ani_clon (pData, iSourceid, iCloneid, iClonetype,
3841
bHasdonotshow, iDonotshow, iConcrete,
3842
bHasloca, iLocationtype, iLocationx, iLocationy);
3843
3844
if (!iRetcode) /* do display processing */
3845
iRetcode = mng_process_display_clon (pData, iSourceid, iCloneid, iClonetype,
3846
bHasdonotshow, iDonotshow, iConcrete,
3847
bHasloca, iLocationtype, iLocationx,
3848
iLocationy);
3849
3850
if (iRetcode) /* on error bail out */
3851
return iRetcode;
3852
3853
}
3854
#endif /* MNG_SUPPORT_DISPLAY */
3855
3856
#ifdef MNG_STORE_CHUNKS
3857
if (pData->bStorechunks)
3858
{ /* initialize storage */
3859
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3860
3861
if (iRetcode) /* on error bail out */
3862
return iRetcode;
3863
/* store the fields */
3864
((mng_clonp)*ppChunk)->iSourceid = mng_get_uint16 (pRawdata);
3865
((mng_clonp)*ppChunk)->iCloneid = mng_get_uint16 (pRawdata+2);
3866
3867
if (iRawlen > 4)
3868
((mng_clonp)*ppChunk)->iClonetype = *(pRawdata+4);
3869
3870
if (iRawlen > 5)
3871
((mng_clonp)*ppChunk)->iDonotshow = *(pRawdata+5);
3872
3873
if (iRawlen > 6)
3874
((mng_clonp)*ppChunk)->iConcrete = *(pRawdata+6);
3875
3876
if (iRawlen > 7)
3877
{
3878
((mng_clonp)*ppChunk)->bHasloca = MNG_TRUE;
3879
((mng_clonp)*ppChunk)->iLocationtype = *(pRawdata+7);
3880
((mng_clonp)*ppChunk)->iLocationx = mng_get_int32 (pRawdata+8);
3881
((mng_clonp)*ppChunk)->iLocationy = mng_get_int32 (pRawdata+12);
3882
}
3883
else
3884
{
3885
((mng_clonp)*ppChunk)->bHasloca = MNG_FALSE;
3886
}
3887
}
3888
#endif /* MNG_STORE_CHUNKS */
3889
3890
#ifdef MNG_SUPPORT_TRACE
3891
MNG_TRACE (pData, MNG_FN_READ_CLON, MNG_LC_END)
3892
#endif
3893
3894
return MNG_NOERROR; /* done */
3895
}
3896
#endif
3897
3898
/* ************************************************************************** */
3899
3900
#ifndef MNG_SKIPCHUNK_PAST
3901
READ_CHUNK (mng_read_past)
3902
{
3903
#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
3904
mng_retcode iRetcode;
3905
mng_uint16 iTargetid;
3906
mng_uint8 iTargettype;
3907
mng_int32 iTargetx;
3908
mng_int32 iTargety;
3909
mng_uint32 iCount;
3910
mng_uint32 iSize;
3911
mng_ptr pSources;
3912
mng_uint32 iX;
3913
mng_past_sourcep pSource;
3914
#endif
3915
3916
#ifdef MNG_SUPPORT_TRACE
3917
MNG_TRACE (pData, MNG_FN_READ_PAST, MNG_LC_START)
3918
#endif
3919
3920
if (!pData->bHasMHDR) /* sequence checks */
3921
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3922
3923
#ifdef MNG_INCLUDE_JNG
3924
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3925
#else
3926
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3927
#endif
3928
MNG_ERROR (pData, MNG_SEQUENCEERROR)
3929
3930
/* check the length */
3931
if ((iRawlen < 41) || (((iRawlen - 11) % 30) != 0))
3932
MNG_ERROR (pData, MNG_INVALIDLENGTH)
3933
3934
#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
3935
iTargetid = mng_get_uint16 (pRawdata);
3936
iTargettype = *(pRawdata+2);
3937
iTargetx = mng_get_int32 (pRawdata+3);
3938
iTargety = mng_get_int32 (pRawdata+7);
3939
iCount = ((iRawlen - 11) / 30); /* how many entries again? */
3940
iSize = iCount * sizeof (mng_past_source);
3941
3942
pRawdata += 11;
3943
/* get a buffer for all the source blocks */
3944
MNG_ALLOC (pData, pSources, iSize)
3945
3946
pSource = (mng_past_sourcep)pSources;
3947
3948
for (iX = 0; iX < iCount; iX++) /* now copy the source blocks */
3949
{
3950
pSource->iSourceid = mng_get_uint16 (pRawdata);
3951
pSource->iComposition = *(pRawdata+2);
3952
pSource->iOrientation = *(pRawdata+3);
3953
pSource->iOffsettype = *(pRawdata+4);
3954
pSource->iOffsetx = mng_get_int32 (pRawdata+5);
3955
pSource->iOffsety = mng_get_int32 (pRawdata+9);
3956
pSource->iBoundarytype = *(pRawdata+13);
3957
pSource->iBoundaryl = mng_get_int32 (pRawdata+14);
3958
pSource->iBoundaryr = mng_get_int32 (pRawdata+18);
3959
pSource->iBoundaryt = mng_get_int32 (pRawdata+22);
3960
pSource->iBoundaryb = mng_get_int32 (pRawdata+26);
3961
3962
pSource++;
3963
pRawdata += 30;
3964
}
3965
#endif
3966
3967
#ifdef MNG_SUPPORT_DISPLAY
3968
{ /* create playback object */
3969
iRetcode = mng_create_ani_past (pData, iTargetid, iTargettype, iTargetx,
3970
iTargety, iCount, pSources);
3971
3972
if (!iRetcode) /* do display processing */
3973
iRetcode = mng_process_display_past (pData, iTargetid, iTargettype, iTargetx,
3974
iTargety, iCount, pSources);
3975
3976
if (iRetcode) /* on error bail out */
3977
{
3978
MNG_FREEX (pData, pSources, iSize)
3979
return iRetcode;
3980
}
3981
}
3982
#endif /* MNG_SUPPORT_DISPLAY */
3983
3984
#ifdef MNG_STORE_CHUNKS
3985
if (pData->bStorechunks)
3986
{ /* initialize storage */
3987
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3988
3989
if (iRetcode) /* on error bail out */
3990
{
3991
MNG_FREEX (pData, pSources, iSize)
3992
return iRetcode;
3993
}
3994
/* store the fields */
3995
((mng_pastp)*ppChunk)->iDestid = iTargetid;
3996
((mng_pastp)*ppChunk)->iTargettype = iTargettype;
3997
((mng_pastp)*ppChunk)->iTargetx = iTargetx;
3998
((mng_pastp)*ppChunk)->iTargety = iTargety;
3999
((mng_pastp)*ppChunk)->iCount = iCount;
4000
/* get a buffer & copy the source blocks */
4001
MNG_ALLOC (pData, ((mng_pastp)*ppChunk)->pSources, iSize)
4002
MNG_COPY (((mng_pastp)*ppChunk)->pSources, pSources, iSize)
4003
}
4004
#endif /* MNG_STORE_CHUNKS */
4005
4006
#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
4007
/* free the source block buffer */
4008
MNG_FREEX (pData, pSources, iSize)
4009
#endif
4010
4011
#ifdef MNG_SUPPORT_TRACE
4012
MNG_TRACE (pData, MNG_FN_READ_PAST, MNG_LC_END)
4013
#endif
4014
4015
return MNG_NOERROR; /* done */
4016
}
4017
#endif
4018
4019
/* ************************************************************************** */
4020
4021
#ifndef MNG_SKIPCHUNK_DISC
4022
READ_CHUNK (mng_read_disc)
4023
{
4024
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
4025
mng_uint32 iCount;
4026
mng_uint16p pIds = MNG_NULL;
4027
mng_retcode iRetcode;
4028
#endif
4029
4030
#ifdef MNG_SUPPORT_TRACE
4031
MNG_TRACE (pData, MNG_FN_READ_DISC, MNG_LC_START)
4032
#endif
4033
4034
if (!pData->bHasMHDR) /* sequence checks */
4035
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4036
4037
#ifdef MNG_INCLUDE_JNG
4038
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4039
#else
4040
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4041
#endif
4042
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4043
4044
if ((iRawlen % 2) != 0) /* check the length */
4045
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4046
4047
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
4048
iCount = (iRawlen / sizeof (mng_uint16));
4049
4050
if (iCount)
4051
{
4052
MNG_ALLOC (pData, pIds, iRawlen)
4053
4054
#ifndef MNG_BIGENDIAN_SUPPORTED
4055
{
4056
mng_uint32 iX;
4057
mng_uint8p pIn = pRawdata;
4058
mng_uint16p pOut = pIds;
4059
4060
for (iX = 0; iX < iCount; iX++)
4061
{
4062
*pOut++ = mng_get_uint16 (pIn);
4063
pIn += 2;
4064
}
4065
}
4066
#else
4067
MNG_COPY (pIds, pRawdata, iRawlen)
4068
#endif /* !MNG_BIGENDIAN_SUPPORTED */
4069
}
4070
#endif
4071
4072
#ifdef MNG_SUPPORT_DISPLAY
4073
{ /* create playback object */
4074
iRetcode = mng_create_ani_disc (pData, iCount, pIds);
4075
4076
if (iRetcode) /* on error bail out */
4077
return iRetcode;
4078
/* now process it */
4079
iRetcode = mng_process_display_disc (pData, iCount, pIds);
4080
4081
if (iRetcode) /* on error bail out */
4082
return iRetcode;
4083
}
4084
#endif /* MNG_SUPPORT_DISPLAY */
4085
4086
#ifdef MNG_STORE_CHUNKS
4087
if (pData->bStorechunks)
4088
{ /* initialize storage */
4089
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4090
4091
if (iRetcode) /* on error bail out */
4092
return iRetcode;
4093
/* store the fields */
4094
((mng_discp)*ppChunk)->iCount = iCount;
4095
4096
if (iRawlen)
4097
{
4098
MNG_ALLOC (pData, ((mng_discp)*ppChunk)->pObjectids, iRawlen)
4099
MNG_COPY (((mng_discp)*ppChunk)->pObjectids, pIds, iRawlen)
4100
}
4101
}
4102
#endif /* MNG_STORE_CHUNKS */
4103
4104
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
4105
if (iRawlen)
4106
MNG_FREEX (pData, pIds, iRawlen)
4107
#endif
4108
4109
#ifdef MNG_SUPPORT_TRACE
4110
MNG_TRACE (pData, MNG_FN_READ_DISC, MNG_LC_END)
4111
#endif
4112
4113
return MNG_NOERROR; /* done */
4114
}
4115
#endif
4116
4117
/* ************************************************************************** */
4118
4119
#ifndef MNG_SKIPCHUNK_BACK
4120
READ_CHUNK (mng_read_back)
4121
{
4122
#ifdef MNG_SUPPORT_TRACE
4123
MNG_TRACE (pData, MNG_FN_READ_BACK, MNG_LC_START)
4124
#endif
4125
4126
if (!pData->bHasMHDR) /* sequence checks */
4127
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4128
4129
#ifdef MNG_INCLUDE_JNG
4130
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4131
#else
4132
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4133
#endif
4134
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4135
/* check the length */
4136
if ((iRawlen != 6) && (iRawlen != 7) && (iRawlen != 9) && (iRawlen != 10))
4137
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4138
4139
#ifdef MNG_SUPPORT_DISPLAY
4140
{
4141
mng_retcode iRetcode;
4142
/* retrieve the fields */
4143
pData->bHasBACK = MNG_TRUE;
4144
pData->iBACKred = mng_get_uint16 (pRawdata);
4145
pData->iBACKgreen = mng_get_uint16 (pRawdata+2);
4146
pData->iBACKblue = mng_get_uint16 (pRawdata+4);
4147
4148
if (iRawlen > 6)
4149
pData->iBACKmandatory = *(pRawdata+6);
4150
else
4151
pData->iBACKmandatory = 0;
4152
4153
if (iRawlen > 7)
4154
pData->iBACKimageid = mng_get_uint16 (pRawdata+7);
4155
else
4156
pData->iBACKimageid = 0;
4157
4158
if (iRawlen > 9)
4159
pData->iBACKtile = *(pRawdata+9);
4160
else
4161
pData->iBACKtile = 0;
4162
4163
iRetcode = mng_create_ani_back (pData, pData->iBACKred, pData->iBACKgreen,
4164
pData->iBACKblue, pData->iBACKmandatory,
4165
pData->iBACKimageid, pData->iBACKtile);
4166
4167
if (iRetcode) /* on error bail out */
4168
return iRetcode;
4169
}
4170
#endif /* MNG_SUPPORT_DISPLAY */
4171
4172
#ifdef MNG_STORE_CHUNKS
4173
if (pData->bStorechunks)
4174
{ /* initialize storage */
4175
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4176
4177
if (iRetcode) /* on error bail out */
4178
return iRetcode;
4179
/* store the fields */
4180
((mng_backp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
4181
((mng_backp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
4182
((mng_backp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
4183
4184
if (iRawlen > 6)
4185
((mng_backp)*ppChunk)->iMandatory = *(pRawdata+6);
4186
4187
if (iRawlen > 7)
4188
((mng_backp)*ppChunk)->iImageid = mng_get_uint16 (pRawdata+7);
4189
4190
if (iRawlen > 9)
4191
((mng_backp)*ppChunk)->iTile = *(pRawdata+9);
4192
4193
}
4194
#endif /* MNG_STORE_CHUNKS */
4195
4196
#ifdef MNG_SUPPORT_TRACE
4197
MNG_TRACE (pData, MNG_FN_READ_BACK, MNG_LC_END)
4198
#endif
4199
4200
return MNG_NOERROR; /* done */
4201
}
4202
#endif
4203
4204
/* ************************************************************************** */
4205
4206
#ifndef MNG_SKIPCHUNK_FRAM
4207
READ_CHUNK (mng_read_fram)
4208
{
4209
mng_uint8p pTemp;
4210
#ifdef MNG_STORE_CHUNKS
4211
mng_uint32 iNamelen;
4212
#endif
4213
mng_uint32 iRemain;
4214
mng_uint32 iRequired = 0;
4215
4216
#ifdef MNG_SUPPORT_TRACE
4217
MNG_TRACE (pData, MNG_FN_READ_FRAM, MNG_LC_START)
4218
#endif
4219
4220
if (!pData->bHasMHDR) /* sequence checks */
4221
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4222
4223
#ifdef MNG_INCLUDE_JNG
4224
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4225
#else
4226
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4227
#endif
4228
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4229
4230
if (iRawlen <= 1) /* only framing-mode ? */
4231
{
4232
#ifdef MNG_STORE_CHUNKS
4233
iNamelen = 0; /* indicate so */
4234
#endif
4235
iRemain = 0;
4236
pTemp = MNG_NULL;
4237
}
4238
else
4239
{
4240
pTemp = find_null (pRawdata+1); /* find null-separator */
4241
/* not found inside input-data ? */
4242
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
4243
pTemp = pRawdata + iRawlen; /* than remainder is name */
4244
4245
#ifdef MNG_STORE_CHUNKS
4246
iNamelen = (mng_uint32)((pTemp - pRawdata) - 1);
4247
#endif
4248
iRemain = (mng_uint32)(iRawlen - (pTemp - pRawdata));
4249
4250
if (iRemain) /* if there is remaining data it's less 1 byte */
4251
iRemain--;
4252
4253
if ((iRemain) && (iRemain < 4)) /* remains must be empty or at least 4 bytes */
4254
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4255
4256
if (iRemain)
4257
{
4258
iRequired = 4; /* calculate and check required remaining length */
4259
4260
if (*(pTemp+1)) { iRequired += 4; }
4261
if (*(pTemp+2)) { iRequired += 4; }
4262
if (*(pTemp+3)) { iRequired += 17; }
4263
4264
if (*(pTemp+4))
4265
{
4266
if ((iRemain - iRequired) % 4 != 0)
4267
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4268
}
4269
else
4270
{
4271
if (iRemain != iRequired)
4272
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4273
}
4274
}
4275
}
4276
4277
#ifdef MNG_SUPPORT_DISPLAY
4278
{
4279
mng_uint8p pWork = pTemp;
4280
mng_uint8 iFramemode = 0;
4281
mng_uint8 iChangedelay = 0;
4282
mng_uint32 iDelay = 0;
4283
mng_uint8 iChangetimeout = 0;
4284
mng_uint32 iTimeout = 0;
4285
mng_uint8 iChangeclipping = 0;
4286
mng_uint8 iCliptype = 0;
4287
mng_int32 iClipl = 0;
4288
mng_int32 iClipr = 0;
4289
mng_int32 iClipt = 0;
4290
mng_int32 iClipb = 0;
4291
mng_retcode iRetcode;
4292
4293
if (iRawlen) /* any data specified ? */
4294
{
4295
if (*(pRawdata)) /* save the new framing mode ? */
4296
{
4297
iFramemode = *(pRawdata);
4298
4299
#ifndef MNG_NO_OLD_VERSIONS
4300
if (pData->bPreDraft48) /* old style input-stream ? */
4301
{
4302
switch (iFramemode)
4303
{
4304
case 0: { break; }
4305
case 1: { iFramemode = 3; break; }
4306
case 2: { iFramemode = 4; break; }
4307
case 3: { iFramemode = 1; break; }
4308
case 4: { iFramemode = 1; break; }
4309
case 5: { iFramemode = 2; break; }
4310
default: { iFramemode = 1; break; }
4311
}
4312
}
4313
#endif
4314
}
4315
4316
if (iRemain)
4317
{
4318
iChangedelay = *(pWork+1);
4319
iChangetimeout = *(pWork+2);
4320
iChangeclipping = *(pWork+3);
4321
pWork += 5;
4322
4323
if (iChangedelay) /* delay changed ? */
4324
{
4325
iDelay = mng_get_uint32 (pWork);
4326
pWork += 4;
4327
}
4328
4329
if (iChangetimeout) /* timeout changed ? */
4330
{
4331
iTimeout = mng_get_uint32 (pWork);
4332
pWork += 4;
4333
}
4334
4335
if (iChangeclipping) /* clipping changed ? */
4336
{
4337
iCliptype = *pWork;
4338
iClipl = mng_get_int32 (pWork+1);
4339
iClipr = mng_get_int32 (pWork+5);
4340
iClipt = mng_get_int32 (pWork+9);
4341
iClipb = mng_get_int32 (pWork+13);
4342
}
4343
}
4344
}
4345
4346
iRetcode = mng_create_ani_fram (pData, iFramemode, iChangedelay, iDelay,
4347
iChangetimeout, iTimeout,
4348
iChangeclipping, iCliptype,
4349
iClipl, iClipr, iClipt, iClipb);
4350
4351
if (!iRetcode) /* now go and do something */
4352
iRetcode = mng_process_display_fram (pData, iFramemode, iChangedelay, iDelay,
4353
iChangetimeout, iTimeout,
4354
iChangeclipping, iCliptype,
4355
iClipl, iClipr, iClipt, iClipb);
4356
4357
if (iRetcode) /* on error bail out */
4358
return iRetcode;
4359
4360
}
4361
#endif /* MNG_SUPPORT_DISPLAY */
4362
4363
#ifdef MNG_STORE_CHUNKS
4364
if (pData->bStorechunks)
4365
{ /* initialize storage */
4366
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4367
4368
if (iRetcode) /* on error bail out */
4369
return iRetcode;
4370
/* store the fields */
4371
((mng_framp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
4372
4373
if (iRawlen)
4374
{
4375
mng_uint8 iFramemode = *(pRawdata);
4376
4377
#ifndef MNG_NO_OLD_VERSIONS
4378
if (pData->bPreDraft48) /* old style input-stream ? */
4379
{
4380
switch (iFramemode)
4381
{
4382
case 1: { iFramemode = 3; break; }
4383
case 2: { iFramemode = 4; break; }
4384
case 3: { iFramemode = 5; break; } /* TODO: provision for mode=5 ??? */
4385
case 4: { iFramemode = 1; break; }
4386
case 5: { iFramemode = 2; break; }
4387
default: { iFramemode = 1; break; }
4388
}
4389
}
4390
#endif
4391
4392
((mng_framp)*ppChunk)->iMode = iFramemode;
4393
((mng_framp)*ppChunk)->iNamesize = iNamelen;
4394
4395
if (iNamelen)
4396
{
4397
MNG_ALLOC (pData, ((mng_framp)*ppChunk)->zName, iNamelen+1)
4398
MNG_COPY (((mng_framp)*ppChunk)->zName, pRawdata+1, iNamelen)
4399
}
4400
4401
if (iRemain)
4402
{
4403
((mng_framp)*ppChunk)->iChangedelay = *(pTemp+1);
4404
((mng_framp)*ppChunk)->iChangetimeout = *(pTemp+2);
4405
((mng_framp)*ppChunk)->iChangeclipping = *(pTemp+3);
4406
((mng_framp)*ppChunk)->iChangesyncid = *(pTemp+4);
4407
4408
pTemp += 5;
4409
4410
if (((mng_framp)*ppChunk)->iChangedelay)
4411
{
4412
((mng_framp)*ppChunk)->iDelay = mng_get_uint32 (pTemp);
4413
pTemp += 4;
4414
}
4415
4416
if (((mng_framp)*ppChunk)->iChangetimeout)
4417
{
4418
((mng_framp)*ppChunk)->iTimeout = mng_get_uint32 (pTemp);
4419
pTemp += 4;
4420
}
4421
4422
if (((mng_framp)*ppChunk)->iChangeclipping)
4423
{
4424
((mng_framp)*ppChunk)->iBoundarytype = *pTemp;
4425
((mng_framp)*ppChunk)->iBoundaryl = mng_get_int32 (pTemp+1);
4426
((mng_framp)*ppChunk)->iBoundaryr = mng_get_int32 (pTemp+5);
4427
((mng_framp)*ppChunk)->iBoundaryt = mng_get_int32 (pTemp+9);
4428
((mng_framp)*ppChunk)->iBoundaryb = mng_get_int32 (pTemp+13);
4429
pTemp += 17;
4430
}
4431
4432
if (((mng_framp)*ppChunk)->iChangesyncid)
4433
{
4434
((mng_framp)*ppChunk)->iCount = (iRemain - iRequired) / 4;
4435
4436
if (((mng_framp)*ppChunk)->iCount)
4437
{
4438
MNG_ALLOC (pData, ((mng_framp)*ppChunk)->pSyncids,
4439
((mng_framp)*ppChunk)->iCount * 4);
4440
4441
#ifndef MNG_BIGENDIAN_SUPPORTED
4442
{
4443
mng_uint32 iX;
4444
mng_uint32p pOut = ((mng_framp)*ppChunk)->pSyncids;
4445
4446
for (iX = 0; iX < ((mng_framp)*ppChunk)->iCount; iX++)
4447
{
4448
*pOut++ = mng_get_uint32 (pTemp);
4449
pTemp += 4;
4450
}
4451
}
4452
#else
4453
MNG_COPY (((mng_framp)*ppChunk)->pSyncids, pTemp,
4454
((mng_framp)*ppChunk)->iCount * 4)
4455
#endif /* !MNG_BIGENDIAN_SUPPORTED */
4456
}
4457
}
4458
}
4459
}
4460
}
4461
#endif /* MNG_STORE_CHUNKS */
4462
4463
#ifdef MNG_SUPPORT_TRACE
4464
MNG_TRACE (pData, MNG_FN_READ_FRAM, MNG_LC_END)
4465
#endif
4466
4467
return MNG_NOERROR; /* done */
4468
}
4469
#endif
4470
4471
/* ************************************************************************** */
4472
4473
#ifndef MNG_SKIPCHUNK_MOVE
4474
READ_CHUNK (mng_read_move)
4475
{
4476
#ifdef MNG_SUPPORT_TRACE
4477
MNG_TRACE (pData, MNG_FN_READ_MOVE, MNG_LC_START)
4478
#endif
4479
4480
if (!pData->bHasMHDR) /* sequence checks */
4481
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4482
4483
#ifdef MNG_INCLUDE_JNG
4484
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4485
#else
4486
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4487
#endif
4488
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4489
4490
if (iRawlen != 13) /* check the length */
4491
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4492
4493
#ifdef MNG_SUPPORT_DISPLAY
4494
{
4495
mng_retcode iRetcode;
4496
/* create a MOVE animation object */
4497
iRetcode = mng_create_ani_move (pData, mng_get_uint16 (pRawdata),
4498
mng_get_uint16 (pRawdata+2),
4499
*(pRawdata+4),
4500
mng_get_int32 (pRawdata+5),
4501
mng_get_int32 (pRawdata+9));
4502
4503
if (!iRetcode) /* process the move */
4504
iRetcode = mng_process_display_move (pData,
4505
mng_get_uint16 (pRawdata),
4506
mng_get_uint16 (pRawdata+2),
4507
*(pRawdata+4),
4508
mng_get_int32 (pRawdata+5),
4509
mng_get_int32 (pRawdata+9));
4510
4511
if (iRetcode) /* on error bail out */
4512
return iRetcode;
4513
4514
}
4515
#endif /* MNG_SUPPORT_DISPLAY */
4516
4517
#ifdef MNG_STORE_CHUNKS
4518
if (pData->bStorechunks)
4519
{ /* initialize storage */
4520
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4521
4522
if (iRetcode) /* on error bail out */
4523
return iRetcode;
4524
/* store the fields */
4525
((mng_movep)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
4526
((mng_movep)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
4527
((mng_movep)*ppChunk)->iMovetype = *(pRawdata+4);
4528
((mng_movep)*ppChunk)->iMovex = mng_get_int32 (pRawdata+5);
4529
((mng_movep)*ppChunk)->iMovey = mng_get_int32 (pRawdata+9);
4530
}
4531
#endif /* MNG_STORE_CHUNKS */
4532
4533
#ifdef MNG_SUPPORT_TRACE
4534
MNG_TRACE (pData, MNG_FN_READ_MOVE, MNG_LC_END)
4535
#endif
4536
4537
return MNG_NOERROR; /* done */
4538
}
4539
#endif
4540
4541
/* ************************************************************************** */
4542
4543
#ifndef MNG_SKIPCHUNK_CLIP
4544
READ_CHUNK (mng_read_clip)
4545
{
4546
#ifdef MNG_SUPPORT_TRACE
4547
MNG_TRACE (pData, MNG_FN_READ_CLIP, MNG_LC_START)
4548
#endif
4549
4550
if (!pData->bHasMHDR) /* sequence checks */
4551
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4552
4553
#ifdef MNG_INCLUDE_JNG
4554
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4555
#else
4556
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4557
#endif
4558
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4559
4560
if (iRawlen != 21) /* check the length */
4561
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4562
4563
#ifdef MNG_SUPPORT_DISPLAY
4564
{
4565
mng_retcode iRetcode;
4566
/* create a CLIP animation object */
4567
iRetcode = mng_create_ani_clip (pData, mng_get_uint16 (pRawdata),
4568
mng_get_uint16 (pRawdata+2),
4569
*(pRawdata+4),
4570
mng_get_int32 (pRawdata+5),
4571
mng_get_int32 (pRawdata+9),
4572
mng_get_int32 (pRawdata+13),
4573
mng_get_int32 (pRawdata+17));
4574
4575
if (!iRetcode) /* process the clipping */
4576
iRetcode = mng_process_display_clip (pData,
4577
mng_get_uint16 (pRawdata),
4578
mng_get_uint16 (pRawdata+2),
4579
*(pRawdata+4),
4580
mng_get_int32 (pRawdata+5),
4581
mng_get_int32 (pRawdata+9),
4582
mng_get_int32 (pRawdata+13),
4583
mng_get_int32 (pRawdata+17));
4584
4585
if (iRetcode) /* on error bail out */
4586
return iRetcode;
4587
4588
}
4589
#endif /* MNG_SUPPORT_DISPLAY */
4590
4591
#ifdef MNG_STORE_CHUNKS
4592
if (pData->bStorechunks)
4593
{ /* initialize storage */
4594
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4595
4596
if (iRetcode) /* on error bail out */
4597
return iRetcode;
4598
/* store the fields */
4599
((mng_clipp)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
4600
((mng_clipp)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
4601
((mng_clipp)*ppChunk)->iCliptype = *(pRawdata+4);
4602
((mng_clipp)*ppChunk)->iClipl = mng_get_int32 (pRawdata+5);
4603
((mng_clipp)*ppChunk)->iClipr = mng_get_int32 (pRawdata+9);
4604
((mng_clipp)*ppChunk)->iClipt = mng_get_int32 (pRawdata+13);
4605
((mng_clipp)*ppChunk)->iClipb = mng_get_int32 (pRawdata+17);
4606
}
4607
#endif /* MNG_STORE_CHUNKS */
4608
4609
#ifdef MNG_SUPPORT_TRACE
4610
MNG_TRACE (pData, MNG_FN_READ_CLIP, MNG_LC_END)
4611
#endif
4612
4613
return MNG_NOERROR; /* done */
4614
}
4615
#endif
4616
4617
/* ************************************************************************** */
4618
4619
#ifndef MNG_SKIPCHUNK_SHOW
4620
READ_CHUNK (mng_read_show)
4621
{
4622
#ifdef MNG_SUPPORT_TRACE
4623
MNG_TRACE (pData, MNG_FN_READ_SHOW, MNG_LC_START)
4624
#endif
4625
4626
if (!pData->bHasMHDR) /* sequence checks */
4627
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4628
4629
#ifdef MNG_INCLUDE_JNG
4630
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4631
#else
4632
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4633
#endif
4634
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4635
/* check the length */
4636
if ((iRawlen != 0) && (iRawlen != 2) && (iRawlen != 4) && (iRawlen != 5))
4637
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4638
4639
#ifdef MNG_SUPPORT_DISPLAY
4640
{
4641
mng_retcode iRetcode;
4642
4643
if (iRawlen) /* determine parameters if any */
4644
{
4645
pData->iSHOWfromid = mng_get_uint16 (pRawdata);
4646
4647
if (iRawlen > 2)
4648
pData->iSHOWtoid = mng_get_uint16 (pRawdata+2);
4649
else
4650
pData->iSHOWtoid = pData->iSHOWfromid;
4651
4652
if (iRawlen > 4)
4653
pData->iSHOWmode = *(pRawdata+4);
4654
else
4655
pData->iSHOWmode = 0;
4656
}
4657
else /* use defaults then */
4658
{
4659
pData->iSHOWmode = 2;
4660
pData->iSHOWfromid = 1;
4661
pData->iSHOWtoid = 65535;
4662
}
4663
/* create a SHOW animation object */
4664
iRetcode = mng_create_ani_show (pData, pData->iSHOWfromid,
4665
pData->iSHOWtoid, pData->iSHOWmode);
4666
4667
if (!iRetcode) /* go and do it! */
4668
iRetcode = mng_process_display_show (pData);
4669
4670
if (iRetcode) /* on error bail out */
4671
return iRetcode;
4672
4673
}
4674
#endif /* MNG_SUPPORT_DISPLAY */
4675
4676
#ifdef MNG_STORE_CHUNKS
4677
if (pData->bStorechunks)
4678
{ /* initialize storage */
4679
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4680
4681
if (iRetcode) /* on error bail out */
4682
return iRetcode;
4683
/* store the fields */
4684
((mng_showp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
4685
4686
if (iRawlen)
4687
{
4688
((mng_showp)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
4689
4690
if (iRawlen > 2)
4691
((mng_showp)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
4692
else
4693
((mng_showp)*ppChunk)->iLastid = ((mng_showp)*ppChunk)->iFirstid;
4694
4695
if (iRawlen > 4)
4696
((mng_showp)*ppChunk)->iMode = *(pRawdata+4);
4697
}
4698
}
4699
#endif /* MNG_STORE_CHUNKS */
4700
4701
#ifdef MNG_SUPPORT_TRACE
4702
MNG_TRACE (pData, MNG_FN_READ_SHOW, MNG_LC_END)
4703
#endif
4704
4705
return MNG_NOERROR; /* done */
4706
}
4707
#endif
4708
4709
/* ************************************************************************** */
4710
4711
#ifndef MNG_SKIPCHUNK_TERM
4712
READ_CHUNK (mng_read_term)
4713
{
4714
mng_uint8 iTermaction;
4715
mng_uint8 iIteraction = 0;
4716
mng_uint32 iDelay = 0;
4717
mng_uint32 iItermax = 0;
4718
4719
#ifdef MNG_SUPPORT_TRACE
4720
MNG_TRACE (pData, MNG_FN_READ_TERM, MNG_LC_START)
4721
#endif
4722
4723
if (!pData->bHasMHDR) /* sequence checks */
4724
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4725
4726
#ifdef MNG_INCLUDE_JNG
4727
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4728
#else
4729
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4730
#endif
4731
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4732
4733
/* should be behind MHDR or SAVE !! */
4734
if ((!pData->bHasSAVE) && (pData->iChunkseq > 2))
4735
{
4736
pData->bMisplacedTERM = MNG_TRUE; /* indicate we found a misplaced TERM */
4737
/* and send a warning signal!!! */
4738
MNG_WARNING (pData, MNG_SEQUENCEERROR)
4739
}
4740
4741
if (pData->bHasLOOP) /* no way, jose! */
4742
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4743
4744
if (pData->bHasTERM) /* only 1 allowed! */
4745
MNG_ERROR (pData, MNG_MULTIPLEERROR)
4746
/* check the length */
4747
if ((iRawlen != 1) && (iRawlen != 10))
4748
MNG_ERROR (pData, MNG_INVALIDLENGTH)
4749
4750
pData->bHasTERM = MNG_TRUE;
4751
4752
iTermaction = *pRawdata; /* get the fields */
4753
4754
if (iRawlen > 1)
4755
{
4756
iIteraction = *(pRawdata+1);
4757
iDelay = mng_get_uint32 (pRawdata+2);
4758
iItermax = mng_get_uint32 (pRawdata+6);
4759
}
4760
4761
if (pData->fProcessterm) /* inform the app ? */
4762
if (!pData->fProcessterm (((mng_handle)pData), iTermaction, iIteraction,
4763
iDelay, iItermax))
4764
MNG_ERROR (pData, MNG_APPMISCERROR)
4765
4766
#ifdef MNG_SUPPORT_DISPLAY
4767
{ /* create the TERM ani-object */
4768
mng_retcode iRetcode = mng_create_ani_term (pData, iTermaction, iIteraction,
4769
iDelay, iItermax);
4770
4771
if (iRetcode) /* on error bail out */
4772
return iRetcode;
4773
/* save for future reference */
4774
pData->pTermaniobj = pData->pLastaniobj;
4775
}
4776
#endif /* MNG_SUPPORT_DISPLAY */
4777
4778
#ifdef MNG_STORE_CHUNKS
4779
if (pData->bStorechunks)
4780
{ /* initialize storage */
4781
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4782
4783
if (iRetcode) /* on error bail out */
4784
return iRetcode;
4785
/* store the fields */
4786
((mng_termp)*ppChunk)->iTermaction = iTermaction;
4787
((mng_termp)*ppChunk)->iIteraction = iIteraction;
4788
((mng_termp)*ppChunk)->iDelay = iDelay;
4789
((mng_termp)*ppChunk)->iItermax = iItermax;
4790
}
4791
#endif /* MNG_STORE_CHUNKS */
4792
4793
#ifdef MNG_SUPPORT_TRACE
4794
MNG_TRACE (pData, MNG_FN_READ_TERM, MNG_LC_END)
4795
#endif
4796
4797
return MNG_NOERROR; /* done */
4798
}
4799
#endif
4800
4801
/* ************************************************************************** */
4802
4803
#ifndef MNG_SKIPCHUNK_SAVE
4804
READ_CHUNK (mng_read_save)
4805
{
4806
#ifdef MNG_SUPPORT_TRACE
4807
MNG_TRACE (pData, MNG_FN_READ_SAVE, MNG_LC_START)
4808
#endif
4809
/* sequence checks */
4810
if ((!pData->bHasMHDR) || (pData->bHasSAVE))
4811
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4812
4813
#ifdef MNG_INCLUDE_JNG
4814
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4815
#else
4816
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4817
#endif
4818
MNG_ERROR (pData, MNG_SEQUENCEERROR)
4819
4820
pData->bHasSAVE = MNG_TRUE;
4821
4822
if (pData->fProcesssave) /* inform the application ? */
4823
{
4824
mng_bool bOke = pData->fProcesssave ((mng_handle)pData);
4825
4826
if (!bOke)
4827
MNG_ERROR (pData, MNG_APPMISCERROR)
4828
}
4829
4830
#ifdef MNG_SUPPORT_DISPLAY
4831
{
4832
mng_retcode iRetcode;
4833
4834
4835
/* TODO: something with the parameters */
4836
4837
4838
/* create a SAVE animation object */
4839
iRetcode = mng_create_ani_save (pData);
4840
4841
if (!iRetcode) /* process it */
4842
iRetcode = mng_process_display_save (pData);
4843
4844
if (iRetcode) /* on error bail out */
4845
return iRetcode;
4846
4847
}
4848
#endif /* MNG_SUPPORT_DISPLAY */
4849
4850
#ifdef MNG_STORE_CHUNKS
4851
if (pData->bStorechunks)
4852
{ /* initialize storage */
4853
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4854
4855
if (iRetcode) /* on error bail out */
4856
return iRetcode;
4857
/* store the fields */
4858
((mng_savep)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
4859
4860
if (iRawlen) /* not empty ? */
4861
{
4862
mng_uint8 iOtype = *pRawdata;
4863
mng_uint8 iEtype;
4864
mng_uint32 iCount = 0;
4865
mng_uint8p pTemp;
4866
mng_uint8p pNull;
4867
mng_uint32 iLen;
4868
mng_uint32 iOffset[2];
4869
mng_uint32 iStarttime[2];
4870
mng_uint32 iFramenr;
4871
mng_uint32 iLayernr;
4872
mng_uint32 iX;
4873
mng_save_entryp pEntry = MNG_NULL;
4874
mng_uint32 iNamesize;
4875
4876
if ((iOtype != 4) && (iOtype != 8))
4877
MNG_ERROR (pData, MNG_INVOFFSETSIZE);
4878
4879
((mng_savep)*ppChunk)->iOffsettype = iOtype;
4880
4881
for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */
4882
{
4883
pTemp = pRawdata + 1;
4884
iLen = iRawlen - 1;
4885
4886
if (iX) /* second run ? */
4887
{
4888
MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_save_entry)))
4889
4890
((mng_savep)*ppChunk)->iCount = iCount;
4891
((mng_savep)*ppChunk)->pEntries = pEntry;
4892
}
4893
4894
while (iLen) /* anything left ? */
4895
{
4896
iEtype = *pTemp; /* entrytype */
4897
4898
if ((iEtype != 0) && (iEtype != 1) && (iEtype != 2) && (iEtype != 3))
4899
MNG_ERROR (pData, MNG_INVENTRYTYPE);
4900
4901
pTemp++;
4902
4903
if (iEtype > 1)
4904
{
4905
iOffset [0] = 0;
4906
iOffset [1] = 0;
4907
iStarttime [0] = 0;
4908
iStarttime [1] = 0;
4909
iLayernr = 0;
4910
iFramenr = 0;
4911
}
4912
else
4913
{
4914
if (iOtype == 4)
4915
{
4916
iOffset [0] = 0;
4917
iOffset [1] = mng_get_uint32 (pTemp);
4918
4919
pTemp += 4;
4920
}
4921
else
4922
{
4923
iOffset [0] = mng_get_uint32 (pTemp);
4924
iOffset [1] = mng_get_uint32 (pTemp+4);
4925
4926
pTemp += 8;
4927
}
4928
4929
if (iEtype > 0)
4930
{
4931
iStarttime [0] = 0;
4932
iStarttime [1] = 0;
4933
iLayernr = 0;
4934
iFramenr = 0;
4935
}
4936
else
4937
{
4938
if (iOtype == 4)
4939
{
4940
iStarttime [0] = 0;
4941
iStarttime [1] = mng_get_uint32 (pTemp+0);
4942
iLayernr = mng_get_uint32 (pTemp+4);
4943
iFramenr = mng_get_uint32 (pTemp+8);
4944
4945
pTemp += 12;
4946
}
4947
else
4948
{
4949
iStarttime [0] = mng_get_uint32 (pTemp+0);
4950
iStarttime [1] = mng_get_uint32 (pTemp+4);
4951
iLayernr = mng_get_uint32 (pTemp+8);
4952
iFramenr = mng_get_uint32 (pTemp+12);
4953
4954
pTemp += 16;
4955
}
4956
}
4957
}
4958
4959
pNull = find_null (pTemp); /* get the name length */
4960
4961
if ((pNull - pRawdata) > (mng_int32)iRawlen)
4962
{
4963
iNamesize = iLen; /* no null found; so end of SAVE */
4964
iLen = 0;
4965
}
4966
else
4967
{
4968
iNamesize = pNull - pTemp; /* should be another entry */
4969
iLen -= iNamesize;
4970
4971
if (!iLen) /* must not end with a null ! */
4972
MNG_ERROR (pData, MNG_ENDWITHNULL)
4973
}
4974
4975
if (!pEntry)
4976
{
4977
iCount++;
4978
}
4979
else
4980
{
4981
pEntry->iEntrytype = iEtype;
4982
pEntry->iOffset [0] = iOffset [0];
4983
pEntry->iOffset [1] = iOffset [1];
4984
pEntry->iStarttime [0] = iStarttime [0];
4985
pEntry->iStarttime [1] = iStarttime [1];
4986
pEntry->iLayernr = iLayernr;
4987
pEntry->iFramenr = iFramenr;
4988
pEntry->iNamesize = iNamesize;
4989
4990
if (iNamesize)
4991
{
4992
MNG_ALLOC (pData, pEntry->zName, iNamesize+1)
4993
MNG_COPY (pEntry->zName, pTemp, iNamesize)
4994
}
4995
4996
pEntry++;
4997
}
4998
4999
pTemp += iNamesize;
5000
}
5001
}
5002
}
5003
}
5004
#endif /* MNG_STORE_CHUNKS */
5005
5006
#ifdef MNG_SUPPORT_TRACE
5007
MNG_TRACE (pData, MNG_FN_READ_SAVE, MNG_LC_END)
5008
#endif
5009
5010
return MNG_NOERROR; /* done */
5011
}
5012
#endif
5013
5014
/* ************************************************************************** */
5015
5016
#ifndef MNG_SKIPCHUNK_SEEK
5017
READ_CHUNK (mng_read_seek)
5018
{
5019
mng_retcode iRetcode;
5020
5021
#ifdef MNG_SUPPORT_TRACE
5022
MNG_TRACE (pData, MNG_FN_READ_SEEK, MNG_LC_START)
5023
#endif
5024
/* sequence checks */
5025
if ((!pData->bHasMHDR) || (!pData->bHasSAVE))
5026
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5027
5028
#ifdef MNG_INCLUDE_JNG
5029
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5030
#else
5031
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5032
#endif
5033
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5034
5035
#ifdef MNG_SUPPORT_DISPLAY
5036
/* create a SEEK animation object */
5037
iRetcode = mng_create_ani_seek (pData, iRawlen, (mng_pchar)pRawdata);
5038
5039
if (iRetcode) /* on error bail out */
5040
return iRetcode;
5041
5042
#endif /* MNG_SUPPORT_DISPLAY */
5043
5044
if (pData->fProcessseek) /* inform the app ? */
5045
{
5046
mng_bool bOke;
5047
mng_pchar zName;
5048
5049
MNG_ALLOC (pData, zName, iRawlen + 1)
5050
5051
if (iRawlen)
5052
MNG_COPY (zName, pRawdata, iRawlen)
5053
5054
bOke = pData->fProcessseek ((mng_handle)pData, zName);
5055
5056
MNG_FREEX (pData, zName, iRawlen + 1)
5057
5058
if (!bOke)
5059
MNG_ERROR (pData, MNG_APPMISCERROR)
5060
}
5061
5062
#ifdef MNG_SUPPORT_DISPLAY
5063
/* do display processing of the SEEK */
5064
iRetcode = mng_process_display_seek (pData);
5065
5066
if (iRetcode) /* on error bail out */
5067
return iRetcode;
5068
#endif /* MNG_SUPPORT_DISPLAY */
5069
5070
#ifdef MNG_STORE_CHUNKS
5071
if (pData->bStorechunks)
5072
{ /* initialize storage */
5073
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5074
5075
if (iRetcode) /* on error bail out */
5076
return iRetcode;
5077
/* store the fields */
5078
((mng_seekp)*ppChunk)->iNamesize = iRawlen;
5079
5080
if (iRawlen)
5081
{
5082
MNG_ALLOC (pData, ((mng_seekp)*ppChunk)->zName, iRawlen+1)
5083
MNG_COPY (((mng_seekp)*ppChunk)->zName, pRawdata, iRawlen)
5084
}
5085
}
5086
#endif /* MNG_STORE_CHUNKS */
5087
5088
#ifdef MNG_SUPPORT_TRACE
5089
MNG_TRACE (pData, MNG_FN_READ_SEEK, MNG_LC_END)
5090
#endif
5091
5092
return MNG_NOERROR; /* done */
5093
}
5094
#endif
5095
5096
/* ************************************************************************** */
5097
5098
#ifndef MNG_SKIPCHUNK_eXPI
5099
READ_CHUNK (mng_read_expi)
5100
{
5101
#ifdef MNG_SUPPORT_TRACE
5102
MNG_TRACE (pData, MNG_FN_READ_EXPI, MNG_LC_START)
5103
#endif
5104
5105
if (!pData->bHasMHDR) /* sequence checks */
5106
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5107
5108
#ifdef MNG_INCLUDE_JNG
5109
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5110
#else
5111
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5112
#endif
5113
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5114
5115
if (iRawlen < 3) /* check the length */
5116
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5117
5118
#ifdef MNG_SUPPORT_DISPLAY
5119
{
5120
5121
5122
/* TODO: something !!! */
5123
5124
5125
}
5126
#endif /* MNG_SUPPORT_DISPLAY */
5127
5128
#ifdef MNG_STORE_CHUNKS
5129
if (pData->bStorechunks)
5130
{ /* initialize storage */
5131
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5132
5133
if (iRetcode) /* on error bail out */
5134
return iRetcode;
5135
/* store the fields */
5136
((mng_expip)*ppChunk)->iSnapshotid = mng_get_uint16 (pRawdata);
5137
((mng_expip)*ppChunk)->iNamesize = iRawlen - 2;
5138
5139
if (((mng_expip)*ppChunk)->iNamesize)
5140
{
5141
MNG_ALLOC (pData, ((mng_expip)*ppChunk)->zName,
5142
((mng_expip)*ppChunk)->iNamesize + 1)
5143
MNG_COPY (((mng_expip)*ppChunk)->zName, pRawdata+2,
5144
((mng_expip)*ppChunk)->iNamesize)
5145
}
5146
}
5147
#endif /* MNG_STORE_CHUNKS */
5148
5149
#ifdef MNG_SUPPORT_TRACE
5150
MNG_TRACE (pData, MNG_FN_READ_EXPI, MNG_LC_END)
5151
#endif
5152
5153
return MNG_NOERROR; /* done */
5154
}
5155
#endif
5156
5157
/* ************************************************************************** */
5158
5159
#ifndef MNG_SKIPCHUNK_fPRI
5160
READ_CHUNK (mng_read_fpri)
5161
{
5162
#ifdef MNG_SUPPORT_TRACE
5163
MNG_TRACE (pData, MNG_FN_READ_FPRI, MNG_LC_START)
5164
#endif
5165
5166
if (!pData->bHasMHDR) /* sequence checks */
5167
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5168
5169
#ifdef MNG_INCLUDE_JNG
5170
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5171
#else
5172
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5173
#endif
5174
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5175
5176
if (iRawlen != 2) /* must be two bytes long */
5177
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5178
5179
#ifdef MNG_SUPPORT_DISPLAY
5180
{
5181
5182
5183
/* TODO: something !!! */
5184
5185
5186
}
5187
#endif /* MNG_SUPPORT_DISPLAY */
5188
5189
#ifdef MNG_STORE_CHUNKS
5190
if (pData->bStorechunks)
5191
{ /* initialize storage */
5192
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5193
5194
if (iRetcode) /* on error bail out */
5195
return iRetcode;
5196
/* store the fields */
5197
((mng_fprip)*ppChunk)->iDeltatype = *pRawdata;
5198
((mng_fprip)*ppChunk)->iPriority = *(pRawdata+1);
5199
}
5200
#endif /* MNG_STORE_CHUNKS */
5201
5202
#ifdef MNG_SUPPORT_TRACE
5203
MNG_TRACE (pData, MNG_FN_READ_FPRI, MNG_LC_END)
5204
#endif
5205
5206
return MNG_NOERROR; /* done */
5207
}
5208
#endif
5209
5210
/* ************************************************************************** */
5211
5212
#ifndef MNG_SKIPCHUNK_nEED
5213
MNG_LOCAL mng_bool CheckKeyword (mng_datap pData,
5214
mng_uint8p pKeyword)
5215
{
5216
mng_chunkid handled_chunks [] =
5217
{
5218
MNG_UINT_BACK, /* keep it sorted !!!! */
5219
MNG_UINT_BASI,
5220
MNG_UINT_CLIP,
5221
MNG_UINT_CLON,
5222
#ifndef MNG_NO_DELTA_PNG
5223
/* TODO: MNG_UINT_DBYK, */
5224
#endif
5225
MNG_UINT_DEFI,
5226
#ifndef MNG_NO_DELTA_PNG
5227
MNG_UINT_DHDR,
5228
#endif
5229
MNG_UINT_DISC,
5230
#ifndef MNG_NO_DELTA_PNG
5231
/* TODO: MNG_UINT_DROP, */
5232
#endif
5233
MNG_UINT_ENDL,
5234
MNG_UINT_FRAM,
5235
MNG_UINT_IDAT,
5236
MNG_UINT_IEND,
5237
MNG_UINT_IHDR,
5238
#ifndef MNG_NO_DELTA_PNG
5239
#ifdef MNG_INCLUDE_JNG
5240
MNG_UINT_IJNG,
5241
#endif
5242
MNG_UINT_IPNG,
5243
#endif
5244
#ifdef MNG_INCLUDE_JNG
5245
MNG_UINT_JDAA,
5246
MNG_UINT_JDAT,
5247
MNG_UINT_JHDR,
5248
/* TODO: MNG_UINT_JSEP, */
5249
MNG_UINT_JdAA,
5250
#endif
5251
MNG_UINT_LOOP,
5252
MNG_UINT_MAGN,
5253
MNG_UINT_MEND,
5254
MNG_UINT_MHDR,
5255
MNG_UINT_MOVE,
5256
/* TODO: MNG_UINT_ORDR, */
5257
MNG_UINT_PAST,
5258
MNG_UINT_PLTE,
5259
#ifndef MNG_NO_DELTA_PNG
5260
MNG_UINT_PPLT,
5261
MNG_UINT_PROM,
5262
#endif
5263
MNG_UINT_SAVE,
5264
MNG_UINT_SEEK,
5265
MNG_UINT_SHOW,
5266
MNG_UINT_TERM,
5267
MNG_UINT_bKGD,
5268
MNG_UINT_cHRM,
5269
/* TODO: MNG_UINT_eXPI, */
5270
MNG_UINT_evNT,
5271
/* TODO: MNG_UINT_fPRI, */
5272
MNG_UINT_gAMA,
5273
/* TODO: MNG_UINT_hIST, */
5274
MNG_UINT_iCCP,
5275
MNG_UINT_iTXt,
5276
MNG_UINT_nEED,
5277
/* TODO: MNG_UINT_oFFs, */
5278
/* TODO: MNG_UINT_pCAL, */
5279
/* TODO: MNG_UINT_pHYg, */
5280
/* TODO: MNG_UINT_pHYs, */
5281
/* TODO: MNG_UINT_sBIT, */
5282
/* TODO: MNG_UINT_sCAL, */
5283
/* TODO: MNG_UINT_sPLT, */
5284
MNG_UINT_sRGB,
5285
MNG_UINT_tEXt,
5286
MNG_UINT_tIME,
5287
MNG_UINT_tRNS,
5288
MNG_UINT_zTXt,
5289
};
5290
5291
mng_bool bOke = MNG_FALSE;
5292
5293
if (pData->fProcessneed) /* does the app handle it ? */
5294
bOke = pData->fProcessneed ((mng_handle)pData, (mng_pchar)pKeyword);
5295
5296
if (!bOke)
5297
{ /* find the keyword length */
5298
mng_uint8p pNull = find_null (pKeyword);
5299
5300
if (pNull - pKeyword == 4) /* test a chunk ? */
5301
{ /* get the chunk-id */
5302
mng_chunkid iChunkid = (*pKeyword << 24) + (*(pKeyword+1) << 16) +
5303
(*(pKeyword+2) << 8) + (*(pKeyword+3) );
5304
/* binary search variables */
5305
mng_int32 iTop, iLower, iUpper, iMiddle;
5306
/* determine max index of table */
5307
iTop = (sizeof (handled_chunks) / sizeof (handled_chunks [0])) - 1;
5308
5309
/* binary search; with 52 chunks, worst-case is 7 comparisons */
5310
iLower = 0;
5311
iMiddle = iTop >> 1;
5312
iUpper = iTop;
5313
5314
do /* the binary search itself */
5315
{
5316
if (handled_chunks [iMiddle] < iChunkid)
5317
iLower = iMiddle + 1;
5318
else if (handled_chunks [iMiddle] > iChunkid)
5319
iUpper = iMiddle - 1;
5320
else
5321
{
5322
bOke = MNG_TRUE;
5323
break;
5324
}
5325
5326
iMiddle = (iLower + iUpper) >> 1;
5327
}
5328
while (iLower <= iUpper);
5329
}
5330
/* test draft ? */
5331
if ((!bOke) && (pNull - pKeyword == 8) &&
5332
(*pKeyword == 'd') && (*(pKeyword+1) == 'r') &&
5333
(*(pKeyword+2) == 'a') && (*(pKeyword+3) == 'f') &&
5334
(*(pKeyword+4) == 't') && (*(pKeyword+5) == ' '))
5335
{
5336
mng_uint32 iDraft;
5337
5338
iDraft = (*(pKeyword+6) - '0') * 10 + (*(pKeyword+7) - '0');
5339
bOke = (mng_bool)(iDraft <= MNG_MNG_DRAFT);
5340
}
5341
/* test MNG 1.0/1.1 ? */
5342
if ((!bOke) && (pNull - pKeyword == 7) &&
5343
(*pKeyword == 'M') && (*(pKeyword+1) == 'N') &&
5344
(*(pKeyword+2) == 'G') && (*(pKeyword+3) == '-') &&
5345
(*(pKeyword+4) == '1') && (*(pKeyword+5) == '.') &&
5346
((*(pKeyword+6) == '0') || (*(pKeyword+6) == '1')))
5347
bOke = MNG_TRUE;
5348
/* test CACHEOFF ? */
5349
if ((!bOke) && (pNull - pKeyword == 8) &&
5350
(*pKeyword == 'C') && (*(pKeyword+1) == 'A') &&
5351
(*(pKeyword+2) == 'C') && (*(pKeyword+3) == 'H') &&
5352
(*(pKeyword+4) == 'E') && (*(pKeyword+5) == 'O') &&
5353
(*(pKeyword+6) == 'F') && (*(pKeyword+7) == 'F'))
5354
{
5355
if (!pData->pFirstaniobj) /* only if caching hasn't started yet ! */
5356
{
5357
bOke = MNG_TRUE;
5358
pData->bCacheplayback = MNG_FALSE;
5359
pData->bStorechunks = MNG_FALSE;
5360
}
5361
}
5362
}
5363
5364
return bOke;
5365
}
5366
#endif
5367
5368
/* ************************************************************************** */
5369
5370
#ifndef MNG_SKIPCHUNK_nEED
5371
READ_CHUNK (mng_read_need)
5372
{
5373
#ifdef MNG_SUPPORT_TRACE
5374
MNG_TRACE (pData, MNG_FN_READ_NEED, MNG_LC_START)
5375
#endif
5376
5377
if (!pData->bHasMHDR) /* sequence checks */
5378
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5379
5380
#ifdef MNG_INCLUDE_JNG
5381
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5382
#else
5383
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5384
#endif
5385
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5386
5387
if (iRawlen < 1) /* check the length */
5388
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5389
5390
{ /* let's check it */
5391
mng_bool bOke = MNG_TRUE;
5392
mng_pchar zKeywords;
5393
mng_uint8p pNull, pTemp;
5394
5395
MNG_ALLOC (pData, zKeywords, iRawlen + 1)
5396
5397
if (iRawlen)
5398
MNG_COPY (zKeywords, pRawdata, iRawlen)
5399
5400
pTemp = (mng_uint8p)zKeywords;
5401
pNull = find_null (pTemp);
5402
5403
while ((bOke) && (pNull < (mng_uint8p)zKeywords + iRawlen))
5404
{
5405
bOke = CheckKeyword (pData, pTemp);
5406
pTemp = pNull + 1;
5407
pNull = find_null (pTemp);
5408
}
5409
5410
if (bOke)
5411
bOke = CheckKeyword (pData, pTemp);
5412
5413
MNG_FREEX (pData, zKeywords, iRawlen + 1)
5414
5415
if (!bOke)
5416
MNG_ERROR (pData, MNG_UNSUPPORTEDNEED)
5417
}
5418
5419
#ifdef MNG_STORE_CHUNKS
5420
if (pData->bStorechunks)
5421
{ /* initialize storage */
5422
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5423
5424
if (iRetcode) /* on error bail out */
5425
return iRetcode;
5426
/* store the fields */
5427
((mng_needp)*ppChunk)->iKeywordssize = iRawlen;
5428
5429
if (iRawlen)
5430
{
5431
MNG_ALLOC (pData, ((mng_needp)*ppChunk)->zKeywords, iRawlen+1)
5432
MNG_COPY (((mng_needp)*ppChunk)->zKeywords, pRawdata, iRawlen)
5433
}
5434
}
5435
#endif /* MNG_STORE_CHUNKS */
5436
5437
#ifdef MNG_SUPPORT_TRACE
5438
MNG_TRACE (pData, MNG_FN_READ_NEED, MNG_LC_END)
5439
#endif
5440
5441
return MNG_NOERROR; /* done */
5442
}
5443
#endif
5444
5445
/* ************************************************************************** */
5446
5447
#ifndef MNG_SKIPCHUNK_pHYg
5448
READ_CHUNK (mng_read_phyg)
5449
{
5450
#ifdef MNG_SUPPORT_TRACE
5451
MNG_TRACE (pData, MNG_FN_READ_PHYG, MNG_LC_START)
5452
#endif
5453
5454
if (!pData->bHasMHDR) /* sequence checks */
5455
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5456
5457
#ifdef MNG_INCLUDE_JNG
5458
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5459
#else
5460
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5461
#endif
5462
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5463
/* it's 9 bytes or empty; no more, no less! */
5464
if ((iRawlen != 9) && (iRawlen != 0))
5465
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5466
5467
#ifdef MNG_SUPPORT_DISPLAY
5468
{
5469
5470
5471
/* TODO: something !!! */
5472
5473
5474
}
5475
#endif /* MNG_SUPPORT_DISPLAY */
5476
5477
#ifdef MNG_STORE_CHUNKS
5478
if (pData->bStorechunks)
5479
{ /* initialize storage */
5480
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5481
5482
if (iRetcode) /* on error bail out */
5483
return iRetcode;
5484
/* store the fields */
5485
((mng_phygp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
5486
5487
if (iRawlen)
5488
{
5489
((mng_phygp)*ppChunk)->iSizex = mng_get_uint32 (pRawdata);
5490
((mng_phygp)*ppChunk)->iSizey = mng_get_uint32 (pRawdata+4);
5491
((mng_phygp)*ppChunk)->iUnit = *(pRawdata+8);
5492
}
5493
}
5494
#endif /* MNG_STORE_CHUNKS */
5495
5496
#ifdef MNG_SUPPORT_TRACE
5497
MNG_TRACE (pData, MNG_FN_READ_PHYG, MNG_LC_END)
5498
#endif
5499
5500
return MNG_NOERROR; /* done */
5501
}
5502
#endif
5503
5504
/* ************************************************************************** */
5505
5506
#ifdef MNG_INCLUDE_JNG
5507
READ_CHUNK (mng_read_jhdr)
5508
{
5509
#ifdef MNG_SUPPORT_TRACE
5510
MNG_TRACE (pData, MNG_FN_READ_JHDR, MNG_LC_START)
5511
#endif
5512
/* sequence checks */
5513
if ((pData->eSigtype != mng_it_jng) && (pData->eSigtype != mng_it_mng))
5514
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED)
5515
5516
if ((pData->eSigtype == mng_it_jng) && (pData->iChunkseq > 1))
5517
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5518
5519
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5520
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5521
5522
if (iRawlen != 16) /* length oke ? */
5523
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5524
/* inside a JHDR-IEND block now */
5525
pData->bHasJHDR = MNG_TRUE;
5526
/* and store interesting fields */
5527
pData->iDatawidth = mng_get_uint32 (pRawdata);
5528
pData->iDataheight = mng_get_uint32 (pRawdata+4);
5529
pData->iJHDRcolortype = *(pRawdata+8);
5530
pData->iJHDRimgbitdepth = *(pRawdata+9);
5531
pData->iJHDRimgcompression = *(pRawdata+10);
5532
pData->iJHDRimginterlace = *(pRawdata+11);
5533
pData->iJHDRalphabitdepth = *(pRawdata+12);
5534
pData->iJHDRalphacompression = *(pRawdata+13);
5535
pData->iJHDRalphafilter = *(pRawdata+14);
5536
pData->iJHDRalphainterlace = *(pRawdata+15);
5537
5538
5539
#if defined(MNG_NO_16BIT_SUPPORT)
5540
pData->iPNGmult = 1;
5541
pData->iPNGdepth = pData->iJHDRalphabitdepth;
5542
#endif
5543
5544
#ifdef MNG_NO_16BIT_SUPPORT
5545
if (pData->iJHDRalphabitdepth > 8)
5546
{
5547
pData->iPNGmult = 2;
5548
pData->iJHDRalphabitdepth = 8;
5549
}
5550
#endif
5551
/* parameter validity checks */
5552
if ((pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAY ) &&
5553
(pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLOR ) &&
5554
(pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAYA ) &&
5555
(pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLORA) )
5556
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
5557
5558
if ((pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8 ) &&
5559
(pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG12 ) &&
5560
(pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8AND12) )
5561
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
5562
5563
if (pData->iJHDRimgcompression != MNG_COMPRESSION_BASELINEJPEG)
5564
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
5565
5566
if ((pData->iJHDRimginterlace != MNG_INTERLACE_SEQUENTIAL ) &&
5567
(pData->iJHDRimginterlace != MNG_INTERLACE_PROGRESSIVE) )
5568
MNG_ERROR (pData, MNG_INVALIDINTERLACE)
5569
5570
if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
5571
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) )
5572
{
5573
if ((pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 )
5574
&& (pData->iJHDRalphabitdepth != MNG_BITDEPTH_1 ) &&
5575
(pData->iJHDRalphabitdepth != MNG_BITDEPTH_2 ) &&
5576
(pData->iJHDRalphabitdepth != MNG_BITDEPTH_4 )
5577
#ifndef MNG_NO_16BIT_SUPPORT
5578
&& (pData->iJHDRalphabitdepth != MNG_BITDEPTH_16)
5579
#endif
5580
)
5581
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
5582
5583
if ((pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE ) &&
5584
(pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG) )
5585
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
5586
5587
if ((pData->iJHDRalphacompression == MNG_COMPRESSION_BASELINEJPEG) &&
5588
(pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 ) )
5589
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
5590
5591
#if defined(FILTER192) || defined(FILTER193)
5592
if ((pData->iJHDRalphafilter != MNG_FILTER_ADAPTIVE ) &&
5593
#if defined(FILTER192) && defined(FILTER193)
5594
(pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) &&
5595
(pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) )
5596
#else
5597
#ifdef FILTER192
5598
(pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) )
5599
#else
5600
(pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) )
5601
#endif
5602
#endif
5603
MNG_ERROR (pData, MNG_INVALIDFILTER)
5604
#else
5605
if (pData->iJHDRalphafilter)
5606
MNG_ERROR (pData, MNG_INVALIDFILTER)
5607
#endif
5608
5609
if ((pData->iJHDRalphainterlace != MNG_INTERLACE_NONE ) &&
5610
(pData->iJHDRalphainterlace != MNG_INTERLACE_ADAM7) )
5611
MNG_ERROR (pData, MNG_INVALIDINTERLACE)
5612
5613
}
5614
else
5615
{
5616
if (pData->iJHDRalphabitdepth)
5617
MNG_ERROR (pData, MNG_INVALIDBITDEPTH)
5618
5619
if (pData->iJHDRalphacompression)
5620
MNG_ERROR (pData, MNG_INVALIDCOMPRESS)
5621
5622
if (pData->iJHDRalphafilter)
5623
MNG_ERROR (pData, MNG_INVALIDFILTER)
5624
5625
if (pData->iJHDRalphainterlace)
5626
MNG_ERROR (pData, MNG_INVALIDINTERLACE)
5627
5628
}
5629
5630
if (!pData->bHasheader) /* first chunk ? */
5631
{
5632
pData->bHasheader = MNG_TRUE; /* we've got a header */
5633
pData->eImagetype = mng_it_jng; /* then this must be a JNG */
5634
pData->iWidth = mng_get_uint32 (pRawdata);
5635
pData->iHeight = mng_get_uint32 (pRawdata+4);
5636
/* predict alpha-depth ! */
5637
if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
5638
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) )
5639
pData->iAlphadepth = pData->iJHDRalphabitdepth;
5640
else
5641
pData->iAlphadepth = 0;
5642
/* fits on maximum canvas ? */
5643
if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
5644
MNG_WARNING (pData, MNG_IMAGETOOLARGE)
5645
5646
if (pData->fProcessheader) /* inform the app ? */
5647
if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
5648
MNG_ERROR (pData, MNG_APPMISCERROR)
5649
5650
}
5651
5652
pData->iColortype = 0; /* fake grayscale for other routines */
5653
pData->iImagelevel++; /* one level deeper */
5654
5655
#ifdef MNG_SUPPORT_DISPLAY
5656
{
5657
mng_retcode iRetcode = mng_process_display_jhdr (pData);
5658
5659
if (iRetcode) /* on error bail out */
5660
return iRetcode;
5661
}
5662
#endif /* MNG_SUPPORT_DISPLAY */
5663
5664
#ifdef MNG_STORE_CHUNKS
5665
if (pData->bStorechunks)
5666
{ /* initialize storage */
5667
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5668
5669
if (iRetcode) /* on error bail out */
5670
return iRetcode;
5671
/* store the fields */
5672
((mng_jhdrp)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
5673
((mng_jhdrp)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
5674
((mng_jhdrp)*ppChunk)->iColortype = *(pRawdata+8);
5675
((mng_jhdrp)*ppChunk)->iImagesampledepth = *(pRawdata+9);
5676
((mng_jhdrp)*ppChunk)->iImagecompression = *(pRawdata+10);
5677
((mng_jhdrp)*ppChunk)->iImageinterlace = *(pRawdata+11);
5678
((mng_jhdrp)*ppChunk)->iAlphasampledepth = *(pRawdata+12);
5679
#ifdef MNG_NO_16BIT_SUPPORT
5680
if (*(pRawdata+12) > 8)
5681
((mng_jhdrp)*ppChunk)->iAlphasampledepth = 8;
5682
#endif
5683
((mng_jhdrp)*ppChunk)->iAlphacompression = *(pRawdata+13);
5684
((mng_jhdrp)*ppChunk)->iAlphafilter = *(pRawdata+14);
5685
((mng_jhdrp)*ppChunk)->iAlphainterlace = *(pRawdata+15);
5686
}
5687
#endif /* MNG_STORE_CHUNKS */
5688
5689
#ifdef MNG_SUPPORT_TRACE
5690
MNG_TRACE (pData, MNG_FN_READ_JHDR, MNG_LC_END)
5691
#endif
5692
5693
return MNG_NOERROR; /* done */
5694
}
5695
#else
5696
#define read_jhdr 0
5697
#endif /* MNG_INCLUDE_JNG */
5698
5699
/* ************************************************************************** */
5700
5701
#ifdef MNG_INCLUDE_JNG
5702
READ_CHUNK (mng_read_jdaa)
5703
{
5704
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
5705
volatile mng_retcode iRetcode;
5706
5707
iRetcode=MNG_NOERROR;
5708
#endif
5709
5710
#ifdef MNG_SUPPORT_TRACE
5711
MNG_TRACE (pData, MNG_FN_READ_JDAA, MNG_LC_START)
5712
#endif
5713
/* sequence checks */
5714
if ((!pData->bHasJHDR) && (!pData->bHasDHDR))
5715
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5716
5717
if (pData->bHasJSEP)
5718
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5719
5720
if (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG)
5721
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5722
5723
if (iRawlen == 0) /* can never be empty */
5724
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5725
5726
pData->bHasJDAA = MNG_TRUE; /* got some JDAA now, don't we */
5727
5728
#ifdef MNG_SUPPORT_DISPLAY
5729
iRetcode = mng_process_display_jdaa (pData, iRawlen, pRawdata);
5730
5731
if (iRetcode) /* on error bail out */
5732
return iRetcode;
5733
#endif /* MNG_SUPPORT_DISPLAY */
5734
5735
#ifdef MNG_STORE_CHUNKS
5736
if (pData->bStorechunks)
5737
{ /* initialize storage */
5738
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5739
5740
if (iRetcode) /* on error bail out */
5741
return iRetcode;
5742
/* store the fields */
5743
((mng_jdaap)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
5744
((mng_jdaap)*ppChunk)->iDatasize = iRawlen;
5745
5746
if (iRawlen != 0) /* is there any data ? */
5747
{
5748
MNG_ALLOC (pData, ((mng_jdaap)*ppChunk)->pData, iRawlen)
5749
MNG_COPY (((mng_jdaap)*ppChunk)->pData, pRawdata, iRawlen)
5750
}
5751
}
5752
#endif /* MNG_STORE_CHUNKS */
5753
5754
#ifdef MNG_SUPPORT_TRACE
5755
MNG_TRACE (pData, MNG_FN_READ_JDAA, MNG_LC_END)
5756
#endif
5757
5758
return MNG_NOERROR; /* done */
5759
}
5760
#else
5761
#define read_jdaa 0
5762
#endif /* MNG_INCLUDE_JNG */
5763
5764
/* ************************************************************************** */
5765
5766
#ifdef MNG_INCLUDE_JNG
5767
READ_CHUNK (mng_read_jdat)
5768
{
5769
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
5770
volatile mng_retcode iRetcode;
5771
5772
iRetcode=MNG_NOERROR;
5773
#endif
5774
5775
#ifdef MNG_SUPPORT_TRACE
5776
MNG_TRACE (pData, MNG_FN_READ_JDAT, MNG_LC_START)
5777
#endif
5778
/* sequence checks */
5779
if ((!pData->bHasJHDR) && (!pData->bHasDHDR))
5780
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5781
5782
if (iRawlen == 0) /* can never be empty */
5783
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5784
5785
pData->bHasJDAT = MNG_TRUE; /* got some JDAT now, don't we */
5786
5787
#ifdef MNG_SUPPORT_DISPLAY
5788
iRetcode = mng_process_display_jdat (pData, iRawlen, pRawdata);
5789
5790
if (iRetcode) /* on error bail out */
5791
return iRetcode;
5792
#endif /* MNG_SUPPORT_DISPLAY */
5793
5794
#ifdef MNG_STORE_CHUNKS
5795
if (pData->bStorechunks)
5796
{ /* initialize storage */
5797
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5798
5799
if (iRetcode) /* on error bail out */
5800
return iRetcode;
5801
/* store the fields */
5802
((mng_jdatp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
5803
((mng_jdatp)*ppChunk)->iDatasize = iRawlen;
5804
5805
if (iRawlen != 0) /* is there any data ? */
5806
{
5807
MNG_ALLOC (pData, ((mng_jdatp)*ppChunk)->pData, iRawlen)
5808
MNG_COPY (((mng_jdatp)*ppChunk)->pData, pRawdata, iRawlen)
5809
}
5810
}
5811
#endif /* MNG_STORE_CHUNKS */
5812
5813
#ifdef MNG_SUPPORT_TRACE
5814
MNG_TRACE (pData, MNG_FN_READ_JDAT, MNG_LC_END)
5815
#endif
5816
5817
return MNG_NOERROR; /* done */
5818
}
5819
#else
5820
#define read_jdat 0
5821
#endif /* MNG_INCLUDE_JNG */
5822
5823
/* ************************************************************************** */
5824
5825
#ifdef MNG_INCLUDE_JNG
5826
READ_CHUNK (mng_read_jsep)
5827
{
5828
#ifdef MNG_SUPPORT_TRACE
5829
MNG_TRACE (pData, MNG_FN_READ_JSEP, MNG_LC_START)
5830
#endif
5831
5832
if (!pData->bHasJHDR) /* sequence checks */
5833
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5834
5835
if (iRawlen != 0) /* must be empty ! */
5836
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5837
5838
pData->bHasJSEP = MNG_TRUE; /* indicate we've had the 8-/12-bit separator */
5839
5840
#ifdef MNG_STORE_CHUNKS
5841
if (pData->bStorechunks)
5842
{ /* initialize storage */
5843
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5844
5845
if (iRetcode) /* on error bail out */
5846
return iRetcode;
5847
5848
}
5849
#endif /* MNG_STORE_CHUNKS */
5850
5851
#ifdef MNG_SUPPORT_TRACE
5852
MNG_TRACE (pData, MNG_FN_READ_JSEP, MNG_LC_END)
5853
#endif
5854
5855
return MNG_NOERROR; /* done */
5856
}
5857
#else
5858
#define read_jsep 0
5859
#endif /* MNG_INCLUDE_JNG */
5860
5861
/* ************************************************************************** */
5862
5863
#ifndef MNG_NO_DELTA_PNG
5864
READ_CHUNK (mng_read_dhdr)
5865
{
5866
mng_uint8 iImagetype, iDeltatype;
5867
#ifdef MNG_SUPPORT_TRACE
5868
MNG_TRACE (pData, MNG_FN_READ_DHDR, MNG_LC_START)
5869
#endif
5870
5871
if (!pData->bHasMHDR) /* sequence checks */
5872
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5873
5874
#ifdef MNG_INCLUDE_JNG
5875
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5876
#else
5877
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5878
#endif
5879
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5880
/* check for valid length */
5881
if ((iRawlen != 4) && (iRawlen != 12) && (iRawlen != 20))
5882
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5883
5884
iImagetype = *(pRawdata+2); /* check fields for validity */
5885
iDeltatype = *(pRawdata+3);
5886
5887
if (iImagetype > MNG_IMAGETYPE_JNG)
5888
MNG_ERROR (pData, MNG_INVIMAGETYPE)
5889
5890
if (iDeltatype > MNG_DELTATYPE_NOCHANGE)
5891
MNG_ERROR (pData, MNG_INVDELTATYPE)
5892
5893
if ((iDeltatype == MNG_DELTATYPE_REPLACE) && (iRawlen > 12))
5894
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5895
5896
if ((iDeltatype == MNG_DELTATYPE_NOCHANGE) && (iRawlen > 4))
5897
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5898
5899
pData->bHasDHDR = MNG_TRUE; /* inside a DHDR-IEND block now */
5900
pData->iDeltatype = iDeltatype;
5901
5902
pData->iImagelevel++; /* one level deeper */
5903
5904
#ifdef MNG_SUPPORT_DISPLAY
5905
{
5906
mng_uint16 iObjectid = mng_get_uint16 (pRawdata);
5907
mng_uint32 iBlockwidth = 0;
5908
mng_uint32 iBlockheight = 0;
5909
mng_uint32 iBlockx = 0;
5910
mng_uint32 iBlocky = 0;
5911
mng_retcode iRetcode;
5912
5913
if (iRawlen > 4)
5914
{
5915
iBlockwidth = mng_get_uint32 (pRawdata+4);
5916
iBlockheight = mng_get_uint32 (pRawdata+8);
5917
}
5918
5919
if (iRawlen > 12)
5920
{
5921
iBlockx = mng_get_uint32 (pRawdata+12);
5922
iBlocky = mng_get_uint32 (pRawdata+16);
5923
}
5924
5925
iRetcode = mng_create_ani_dhdr (pData, iObjectid, iImagetype, iDeltatype,
5926
iBlockwidth, iBlockheight, iBlockx, iBlocky);
5927
5928
if (!iRetcode) /* display processing ? */
5929
iRetcode = mng_process_display_dhdr (pData, iObjectid, iImagetype, iDeltatype,
5930
iBlockwidth, iBlockheight, iBlockx, iBlocky);
5931
5932
if (iRetcode) /* on error bail out */
5933
return iRetcode;
5934
5935
}
5936
#endif /* MNG_SUPPORT_DISPLAY */
5937
5938
#ifdef MNG_STORE_CHUNKS
5939
if (pData->bStorechunks)
5940
{ /* initialize storage */
5941
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5942
5943
if (iRetcode) /* on error bail out */
5944
return iRetcode;
5945
/* store the fields */
5946
((mng_dhdrp)*ppChunk)->iObjectid = mng_get_uint16 (pRawdata);
5947
((mng_dhdrp)*ppChunk)->iImagetype = iImagetype;
5948
((mng_dhdrp)*ppChunk)->iDeltatype = iDeltatype;
5949
5950
if (iRawlen > 4)
5951
{
5952
((mng_dhdrp)*ppChunk)->iBlockwidth = mng_get_uint32 (pRawdata+4);
5953
((mng_dhdrp)*ppChunk)->iBlockheight = mng_get_uint32 (pRawdata+8);
5954
}
5955
5956
if (iRawlen > 12)
5957
{
5958
((mng_dhdrp)*ppChunk)->iBlockx = mng_get_uint32 (pRawdata+12);
5959
((mng_dhdrp)*ppChunk)->iBlocky = mng_get_uint32 (pRawdata+16);
5960
}
5961
}
5962
#endif /* MNG_STORE_CHUNKS */
5963
5964
#ifdef MNG_SUPPORT_TRACE
5965
MNG_TRACE (pData, MNG_FN_READ_DHDR, MNG_LC_END)
5966
#endif
5967
5968
return MNG_NOERROR; /* done */
5969
}
5970
#endif
5971
5972
/* ************************************************************************** */
5973
5974
#ifndef MNG_NO_DELTA_PNG
5975
READ_CHUNK (mng_read_prom)
5976
{
5977
mng_uint8 iColortype;
5978
mng_uint8 iSampledepth;
5979
mng_uint8 iFilltype;
5980
5981
#ifdef MNG_SUPPORT_TRACE
5982
MNG_TRACE (pData, MNG_FN_READ_PROM, MNG_LC_START)
5983
#endif
5984
/* sequence checks */
5985
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
5986
MNG_ERROR (pData, MNG_SEQUENCEERROR)
5987
5988
if (iRawlen != 3) /* gotta be exactly 3 bytes */
5989
MNG_ERROR (pData, MNG_INVALIDLENGTH)
5990
5991
iColortype = *pRawdata; /* check fields for validity */
5992
iSampledepth = *(pRawdata+1);
5993
iFilltype = *(pRawdata+2);
5994
5995
if ((iColortype != MNG_COLORTYPE_GRAY ) &&
5996
(iColortype != MNG_COLORTYPE_RGB ) &&
5997
(iColortype != MNG_COLORTYPE_INDEXED) &&
5998
(iColortype != MNG_COLORTYPE_GRAYA ) &&
5999
(iColortype != MNG_COLORTYPE_RGBA ) )
6000
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
6001
6002
#ifdef MNG_NO_16BIT_SUPPORT
6003
if (iSampledepth == MNG_BITDEPTH_16 )
6004
iSampledepth = MNG_BITDEPTH_8;
6005
#endif
6006
6007
if ((iSampledepth != MNG_BITDEPTH_1 ) &&
6008
(iSampledepth != MNG_BITDEPTH_2 ) &&
6009
(iSampledepth != MNG_BITDEPTH_4 ) &&
6010
(iSampledepth != MNG_BITDEPTH_8 )
6011
#ifndef MNG_NO_16BIT_SUPPORT
6012
&& (iSampledepth != MNG_BITDEPTH_16)
6013
#endif
6014
)
6015
MNG_ERROR (pData, MNG_INVSAMPLEDEPTH)
6016
6017
if ((iFilltype != MNG_FILLMETHOD_LEFTBITREPLICATE) &&
6018
(iFilltype != MNG_FILLMETHOD_ZEROFILL ) )
6019
MNG_ERROR (pData, MNG_INVFILLMETHOD)
6020
6021
#ifdef MNG_SUPPORT_DISPLAY
6022
{
6023
mng_retcode iRetcode = mng_create_ani_prom (pData, iSampledepth,
6024
iColortype, iFilltype);
6025
6026
if (!iRetcode) /* display processing ? */
6027
iRetcode = mng_process_display_prom (pData, iSampledepth,
6028
iColortype, iFilltype);
6029
if (iRetcode) /* on error bail out */
6030
return iRetcode;
6031
}
6032
#endif /* MNG_SUPPORT_DISPLAY */
6033
6034
#ifdef MNG_STORE_CHUNKS
6035
if (pData->bStorechunks)
6036
{ /* initialize storage */
6037
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6038
6039
if (iRetcode) /* on error bail out */
6040
return iRetcode;
6041
/* store the fields */
6042
((mng_promp)*ppChunk)->iColortype = iColortype;
6043
((mng_promp)*ppChunk)->iSampledepth = iSampledepth;
6044
((mng_promp)*ppChunk)->iFilltype = iFilltype;
6045
}
6046
#endif /* MNG_STORE_CHUNKS */
6047
6048
#ifdef MNG_SUPPORT_TRACE
6049
MNG_TRACE (pData, MNG_FN_READ_PROM, MNG_LC_END)
6050
#endif
6051
6052
return MNG_NOERROR; /* done */
6053
}
6054
#endif
6055
6056
/* ************************************************************************** */
6057
6058
#ifndef MNG_NO_DELTA_PNG
6059
READ_CHUNK (mng_read_ipng)
6060
{
6061
#ifdef MNG_SUPPORT_TRACE
6062
MNG_TRACE (pData, MNG_FN_READ_IPNG, MNG_LC_START)
6063
#endif
6064
/* sequence checks */
6065
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6066
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6067
6068
if (iRawlen != 0) /* gotta be empty */
6069
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6070
6071
#ifdef MNG_SUPPORT_DISPLAY
6072
{
6073
mng_retcode iRetcode = mng_create_ani_ipng (pData);
6074
6075
if (!iRetcode) /* process it */
6076
iRetcode = mng_process_display_ipng (pData);
6077
6078
if (iRetcode) /* on error bail out */
6079
return iRetcode;
6080
6081
}
6082
#endif /* MNG_SUPPORT_DISPLAY */
6083
6084
#ifdef MNG_STORE_CHUNKS
6085
if (pData->bStorechunks)
6086
{ /* initialize storage */
6087
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6088
6089
if (iRetcode) /* on error bail out */
6090
return iRetcode;
6091
}
6092
#endif /* MNG_STORE_CHUNKS */
6093
6094
#ifdef MNG_SUPPORT_TRACE
6095
MNG_TRACE (pData, MNG_FN_READ_IPNG, MNG_LC_END)
6096
#endif
6097
6098
return MNG_NOERROR; /* done */
6099
}
6100
#endif
6101
6102
/* ************************************************************************** */
6103
6104
#ifndef MNG_NO_DELTA_PNG
6105
READ_CHUNK (mng_read_pplt)
6106
{
6107
mng_uint8 iDeltatype;
6108
mng_uint8p pTemp;
6109
mng_uint32 iLen;
6110
mng_uint8 iX, iM;
6111
mng_uint32 iY;
6112
mng_uint32 iMax;
6113
mng_rgbpaltab aIndexentries;
6114
mng_uint8arr aAlphaentries;
6115
mng_uint8arr aUsedentries;
6116
6117
#ifdef MNG_SUPPORT_TRACE
6118
MNG_TRACE (pData, MNG_FN_READ_PPLT, MNG_LC_START)
6119
#endif
6120
/* sequence checks */
6121
if ((!pData->bHasMHDR) && (!pData->bHasDHDR))
6122
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6123
6124
if (iRawlen < 1) /* must have at least 1 byte */
6125
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6126
6127
iDeltatype = *pRawdata;
6128
/* valid ? */
6129
if (iDeltatype > MNG_DELTATYPE_DELTARGBA)
6130
MNG_ERROR (pData, MNG_INVDELTATYPE)
6131
/* must be indexed color ! */
6132
if (pData->iColortype != MNG_COLORTYPE_INDEXED)
6133
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
6134
6135
pTemp = pRawdata + 1;
6136
iLen = iRawlen - 1;
6137
iMax = 0;
6138
6139
for (iY = 0; iY < 256; iY++) /* reset arrays */
6140
{
6141
aIndexentries [iY].iRed = 0;
6142
aIndexentries [iY].iGreen = 0;
6143
aIndexentries [iY].iBlue = 0;
6144
aAlphaentries [iY] = 255;
6145
aUsedentries [iY] = 0;
6146
}
6147
6148
while (iLen) /* as long as there are entries left ... */
6149
{
6150
mng_uint32 iDiff;
6151
6152
if (iLen < 2)
6153
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6154
6155
iX = *pTemp; /* get start and end index */
6156
iM = *(pTemp+1);
6157
6158
if (iM < iX)
6159
MNG_ERROR (pData, MNG_INVALIDINDEX)
6160
6161
if ((mng_uint32)iM >= iMax) /* determine highest used index */
6162
iMax = (mng_uint32)iM + 1;
6163
6164
pTemp += 2;
6165
iLen -= 2;
6166
6167
if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) ||
6168
(iDeltatype == MNG_DELTATYPE_DELTARGB ) )
6169
iDiff = (iM - iX + 1) * 3;
6170
else
6171
if ((iDeltatype == MNG_DELTATYPE_REPLACEALPHA) ||
6172
(iDeltatype == MNG_DELTATYPE_DELTAALPHA ) )
6173
iDiff = (iM - iX + 1);
6174
else
6175
iDiff = (iM - iX + 1) * 4;
6176
6177
if (iLen < iDiff)
6178
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6179
6180
if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) ||
6181
(iDeltatype == MNG_DELTATYPE_DELTARGB ) )
6182
{
6183
for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
6184
{
6185
aIndexentries [iY].iRed = *pTemp;
6186
aIndexentries [iY].iGreen = *(pTemp+1);
6187
aIndexentries [iY].iBlue = *(pTemp+2);
6188
aUsedentries [iY] = 1;
6189
6190
pTemp += 3;
6191
iLen -= 3;
6192
}
6193
}
6194
else
6195
if ((iDeltatype == MNG_DELTATYPE_REPLACEALPHA) ||
6196
(iDeltatype == MNG_DELTATYPE_DELTAALPHA ) )
6197
{
6198
for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
6199
{
6200
aAlphaentries [iY] = *pTemp;
6201
aUsedentries [iY] = 1;
6202
6203
pTemp++;
6204
iLen--;
6205
}
6206
}
6207
else
6208
{
6209
for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
6210
{
6211
aIndexentries [iY].iRed = *pTemp;
6212
aIndexentries [iY].iGreen = *(pTemp+1);
6213
aIndexentries [iY].iBlue = *(pTemp+2);
6214
aAlphaentries [iY] = *(pTemp+3);
6215
aUsedentries [iY] = 1;
6216
6217
pTemp += 4;
6218
iLen -= 4;
6219
}
6220
}
6221
}
6222
6223
switch (pData->iBitdepth) /* check maximum allowed entries for bitdepth */
6224
{
6225
case MNG_BITDEPTH_1 : {
6226
if (iMax > 2)
6227
MNG_ERROR (pData, MNG_INVALIDINDEX)
6228
break;
6229
}
6230
case MNG_BITDEPTH_2 : {
6231
if (iMax > 4)
6232
MNG_ERROR (pData, MNG_INVALIDINDEX)
6233
break;
6234
}
6235
case MNG_BITDEPTH_4 : {
6236
if (iMax > 16)
6237
MNG_ERROR (pData, MNG_INVALIDINDEX)
6238
break;
6239
}
6240
}
6241
6242
#ifdef MNG_SUPPORT_DISPLAY
6243
{ /* create animation object */
6244
mng_retcode iRetcode = mng_create_ani_pplt (pData, iDeltatype, iMax,
6245
aIndexentries, aAlphaentries,
6246
aUsedentries);
6247
6248
if (!iRetcode) /* execute it now ? */
6249
iRetcode = mng_process_display_pplt (pData, iDeltatype, iMax, aIndexentries,
6250
aAlphaentries, aUsedentries);
6251
6252
if (iRetcode) /* on error bail out */
6253
return iRetcode;
6254
6255
}
6256
#endif /* MNG_SUPPORT_DISPLAY */
6257
6258
#ifdef MNG_STORE_CHUNKS
6259
if (pData->bStorechunks)
6260
{ /* initialize storage */
6261
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6262
6263
if (iRetcode) /* on error bail out */
6264
return iRetcode;
6265
/* store the fields */
6266
((mng_ppltp)*ppChunk)->iDeltatype = iDeltatype;
6267
((mng_ppltp)*ppChunk)->iCount = iMax;
6268
6269
for (iY = 0; iY < 256; iY++)
6270
{
6271
((mng_ppltp)*ppChunk)->aEntries [iY].iRed = aIndexentries [iY].iRed;
6272
((mng_ppltp)*ppChunk)->aEntries [iY].iGreen = aIndexentries [iY].iGreen;
6273
((mng_ppltp)*ppChunk)->aEntries [iY].iBlue = aIndexentries [iY].iBlue;
6274
((mng_ppltp)*ppChunk)->aEntries [iY].iAlpha = aAlphaentries [iY];
6275
((mng_ppltp)*ppChunk)->aEntries [iY].bUsed = (mng_bool)(aUsedentries [iY]);
6276
}
6277
}
6278
#endif /* MNG_STORE_CHUNKS */
6279
6280
#ifdef MNG_SUPPORT_TRACE
6281
MNG_TRACE (pData, MNG_FN_READ_PPLT, MNG_LC_END)
6282
#endif
6283
6284
return MNG_NOERROR; /* done */
6285
}
6286
#endif
6287
6288
/* ************************************************************************** */
6289
6290
#ifndef MNG_NO_DELTA_PNG
6291
#ifdef MNG_INCLUDE_JNG
6292
READ_CHUNK (mng_read_ijng)
6293
{
6294
#ifdef MNG_SUPPORT_TRACE
6295
MNG_TRACE (pData, MNG_FN_READ_IJNG, MNG_LC_START)
6296
#endif
6297
/* sequence checks */
6298
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6299
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6300
6301
if (iRawlen != 0) /* gotta be empty */
6302
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6303
6304
#ifdef MNG_SUPPORT_DISPLAY
6305
{
6306
mng_retcode iRetcode = mng_create_ani_ijng (pData);
6307
6308
if (!iRetcode) /* process it */
6309
iRetcode = mng_process_display_ijng (pData);
6310
6311
if (iRetcode) /* on error bail out */
6312
return iRetcode;
6313
6314
}
6315
#endif /* MNG_SUPPORT_DISPLAY */
6316
6317
#ifdef MNG_STORE_CHUNKS
6318
if (pData->bStorechunks)
6319
{ /* initialize storage */
6320
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6321
6322
if (iRetcode) /* on error bail out */
6323
return iRetcode;
6324
}
6325
#endif /* MNG_STORE_CHUNKS */
6326
6327
#ifdef MNG_SUPPORT_TRACE
6328
MNG_TRACE (pData, MNG_FN_READ_IJNG, MNG_LC_END)
6329
#endif
6330
6331
return MNG_NOERROR; /* done */
6332
}
6333
#endif
6334
#endif
6335
6336
/* ************************************************************************** */
6337
6338
#ifndef MNG_NO_DELTA_PNG
6339
READ_CHUNK (mng_read_drop)
6340
{
6341
#ifdef MNG_SUPPORT_TRACE
6342
MNG_TRACE (pData, MNG_FN_READ_DROP, MNG_LC_START)
6343
#endif
6344
/* sequence checks */
6345
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6346
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6347
/* check length */
6348
if ((iRawlen < 4) || ((iRawlen % 4) != 0))
6349
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6350
6351
#ifdef MNG_SUPPORT_DISPLAY
6352
{
6353
6354
6355
/* TODO: something !!! */
6356
6357
6358
}
6359
#endif /* MNG_SUPPORT_DISPLAY */
6360
6361
#ifdef MNG_STORE_CHUNKS
6362
if (pData->bStorechunks)
6363
{ /* initialize storage */
6364
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6365
6366
if (iRetcode) /* on error bail out */
6367
return iRetcode;
6368
/* store the fields */
6369
((mng_dropp)*ppChunk)->iCount = iRawlen / 4;
6370
6371
if (iRawlen)
6372
{
6373
mng_uint32 iX;
6374
mng_uint8p pTemp = pRawdata;
6375
mng_uint32p pEntry;
6376
6377
MNG_ALLOC (pData, pEntry, iRawlen)
6378
6379
((mng_dropp)*ppChunk)->pChunknames = (mng_ptr)pEntry;
6380
6381
for (iX = 0; iX < iRawlen / 4; iX++)
6382
{
6383
*pEntry = mng_get_uint32 (pTemp);
6384
6385
pTemp += 4;
6386
pEntry++;
6387
}
6388
}
6389
}
6390
#endif /* MNG_STORE_CHUNKS */
6391
6392
#ifdef MNG_SUPPORT_TRACE
6393
MNG_TRACE (pData, MNG_FN_READ_DROP, MNG_LC_END)
6394
#endif
6395
6396
return MNG_NOERROR; /* done */
6397
}
6398
#endif
6399
6400
/* ************************************************************************** */
6401
6402
#ifndef MNG_NO_DELTA_PNG
6403
#ifndef MNG_SKIPCHUNK_DBYK
6404
READ_CHUNK (mng_read_dbyk)
6405
{
6406
#ifdef MNG_SUPPORT_TRACE
6407
MNG_TRACE (pData, MNG_FN_READ_DBYK, MNG_LC_START)
6408
#endif
6409
/* sequence checks */
6410
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6411
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6412
6413
if (iRawlen < 6) /* must be at least 6 long */
6414
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6415
6416
#ifdef MNG_SUPPORT_DISPLAY
6417
{
6418
6419
6420
/* TODO: something !!! */
6421
6422
6423
}
6424
#endif /* MNG_SUPPORT_DISPLAY */
6425
6426
#ifdef MNG_STORE_CHUNKS
6427
if (pData->bStorechunks)
6428
{ /* initialize storage */
6429
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6430
6431
if (iRetcode) /* on error bail out */
6432
return iRetcode;
6433
/* store the fields */
6434
((mng_dbykp)*ppChunk)->iChunkname = mng_get_uint32 (pRawdata);
6435
((mng_dbykp)*ppChunk)->iPolarity = *(pRawdata+4);
6436
((mng_dbykp)*ppChunk)->iKeywordssize = iRawlen - 5;
6437
6438
if (iRawlen > 5)
6439
{
6440
MNG_ALLOC (pData, ((mng_dbykp)*ppChunk)->zKeywords, iRawlen-4)
6441
MNG_COPY (((mng_dbykp)*ppChunk)->zKeywords, pRawdata+5, iRawlen-5)
6442
}
6443
}
6444
#endif /* MNG_STORE_CHUNKS */
6445
6446
#ifdef MNG_SUPPORT_TRACE
6447
MNG_TRACE (pData, MNG_FN_READ_DBYK, MNG_LC_END)
6448
#endif
6449
6450
return MNG_NOERROR; /* done */
6451
}
6452
#endif
6453
#endif
6454
6455
/* ************************************************************************** */
6456
6457
#ifndef MNG_NO_DELTA_PNG
6458
#ifndef MNG_SKIPCHUNK_ORDR
6459
READ_CHUNK (mng_read_ordr)
6460
{
6461
#ifdef MNG_SUPPORT_TRACE
6462
MNG_TRACE (pData, MNG_FN_READ_ORDR, MNG_LC_START)
6463
#endif
6464
/* sequence checks */
6465
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6466
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6467
/* check length */
6468
if ((iRawlen < 5) || ((iRawlen % 5) != 0))
6469
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6470
6471
#ifdef MNG_SUPPORT_DISPLAY
6472
{
6473
6474
6475
/* TODO: something !!! */
6476
6477
6478
}
6479
#endif /* MNG_SUPPORT_DISPLAY */
6480
6481
#ifdef MNG_STORE_CHUNKS
6482
if (pData->bStorechunks)
6483
{ /* initialize storage */
6484
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6485
6486
if (iRetcode) /* on error bail out */
6487
return iRetcode;
6488
/* store the fields */
6489
((mng_ordrp)*ppChunk)->iCount = iRawlen / 5;
6490
6491
if (iRawlen)
6492
{
6493
mng_uint32 iX;
6494
mng_ordr_entryp pEntry;
6495
mng_uint8p pTemp = pRawdata;
6496
6497
MNG_ALLOC (pData, pEntry, iRawlen)
6498
6499
((mng_ordrp)*ppChunk)->pEntries = pEntry;
6500
6501
for (iX = 0; iX < iRawlen / 5; iX++)
6502
{
6503
pEntry->iChunkname = mng_get_uint32 (pTemp);
6504
pEntry->iOrdertype = *(pTemp+4);
6505
6506
pTemp += 5;
6507
pEntry++;
6508
}
6509
}
6510
}
6511
#endif /* MNG_STORE_CHUNKS */
6512
6513
#ifdef MNG_SUPPORT_TRACE
6514
MNG_TRACE (pData, MNG_FN_READ_ORDR, MNG_LC_END)
6515
#endif
6516
6517
return MNG_NOERROR; /* done */
6518
}
6519
#endif
6520
#endif
6521
6522
/* ************************************************************************** */
6523
6524
#ifndef MNG_SKIPCHUNK_MAGN
6525
READ_CHUNK (mng_read_magn)
6526
{
6527
mng_uint16 iFirstid, iLastid;
6528
mng_uint8 iMethodX, iMethodY;
6529
mng_uint16 iMX, iMY, iML, iMR, iMT, iMB;
6530
mng_bool bFaulty;
6531
6532
#ifdef MNG_SUPPORT_TRACE
6533
MNG_TRACE (pData, MNG_FN_READ_MAGN, MNG_LC_START)
6534
#endif
6535
/* sequence checks */
6536
#ifdef MNG_SUPPORT_JNG
6537
if ((!pData->bHasMHDR) || (pData->bHasIHDR) || (pData->bHasDHDR) || (pData->bHasJHDR))
6538
#else
6539
if ((!pData->bHasMHDR) || (pData->bHasIHDR) || (pData->bHasDHDR))
6540
#endif
6541
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6542
/* check length */
6543
if (iRawlen > 20)
6544
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6545
6546
/* following is an ugly hack to allow faulty layout caused by previous
6547
versions of libmng and MNGeye, which wrote MAGN with a 16-bit
6548
MethodX/MethodY (as opposed to the proper 8-bit as defined in the spec!) */
6549
6550
if ((iRawlen == 6) || (iRawlen == 8) || (iRawlen == 10) || (iRawlen == 12) ||
6551
(iRawlen == 14) || (iRawlen == 16) || (iRawlen == 20))
6552
bFaulty = MNG_TRUE; /* these lengths are all wrong */
6553
else /* length 18 can be right or wrong !!! */
6554
if ((iRawlen == 18) && (mng_get_uint16 (pRawdata+4) <= 5) &&
6555
(mng_get_uint16 (pRawdata+6) < 256) &&
6556
(mng_get_uint16 (pRawdata+8) < 256) &&
6557
(mng_get_uint16 (pRawdata+10) < 256) &&
6558
(mng_get_uint16 (pRawdata+12) < 256) &&
6559
(mng_get_uint16 (pRawdata+14) < 256) &&
6560
(mng_get_uint16 (pRawdata+16) < 256))
6561
bFaulty = MNG_TRUE; /* this is very likely the wrong layout */
6562
else
6563
bFaulty = MNG_FALSE; /* all other cases are handled as right */
6564
6565
if (bFaulty) /* wrong layout ? */
6566
{
6567
if (iRawlen > 0) /* get the fields */
6568
iFirstid = mng_get_uint16 (pRawdata);
6569
else
6570
iFirstid = 0;
6571
6572
if (iRawlen > 2)
6573
iLastid = mng_get_uint16 (pRawdata+2);
6574
else
6575
iLastid = iFirstid;
6576
6577
if (iRawlen > 4)
6578
iMethodX = (mng_uint8)(mng_get_uint16 (pRawdata+4));
6579
else
6580
iMethodX = 0;
6581
6582
if (iRawlen > 6)
6583
iMX = mng_get_uint16 (pRawdata+6);
6584
else
6585
iMX = 1;
6586
6587
if (iRawlen > 8)
6588
iMY = mng_get_uint16 (pRawdata+8);
6589
else
6590
iMY = iMX;
6591
6592
if (iRawlen > 10)
6593
iML = mng_get_uint16 (pRawdata+10);
6594
else
6595
iML = iMX;
6596
6597
if (iRawlen > 12)
6598
iMR = mng_get_uint16 (pRawdata+12);
6599
else
6600
iMR = iMX;
6601
6602
if (iRawlen > 14)
6603
iMT = mng_get_uint16 (pRawdata+14);
6604
else
6605
iMT = iMY;
6606
6607
if (iRawlen > 16)
6608
iMB = mng_get_uint16 (pRawdata+16);
6609
else
6610
iMB = iMY;
6611
6612
if (iRawlen > 18)
6613
iMethodY = (mng_uint8)(mng_get_uint16 (pRawdata+18));
6614
else
6615
iMethodY = iMethodX;
6616
}
6617
else /* proper layout !!!! */
6618
{
6619
if (iRawlen > 0) /* get the fields */
6620
iFirstid = mng_get_uint16 (pRawdata);
6621
else
6622
iFirstid = 0;
6623
6624
if (iRawlen > 2)
6625
iLastid = mng_get_uint16 (pRawdata+2);
6626
else
6627
iLastid = iFirstid;
6628
6629
if (iRawlen > 4)
6630
iMethodX = *(pRawdata+4);
6631
else
6632
iMethodX = 0;
6633
6634
if (iRawlen > 5)
6635
iMX = mng_get_uint16 (pRawdata+5);
6636
else
6637
iMX = 1;
6638
6639
if (iRawlen > 7)
6640
iMY = mng_get_uint16 (pRawdata+7);
6641
else
6642
iMY = iMX;
6643
6644
if (iRawlen > 9)
6645
iML = mng_get_uint16 (pRawdata+9);
6646
else
6647
iML = iMX;
6648
6649
if (iRawlen > 11)
6650
iMR = mng_get_uint16 (pRawdata+11);
6651
else
6652
iMR = iMX;
6653
6654
if (iRawlen > 13)
6655
iMT = mng_get_uint16 (pRawdata+13);
6656
else
6657
iMT = iMY;
6658
6659
if (iRawlen > 15)
6660
iMB = mng_get_uint16 (pRawdata+15);
6661
else
6662
iMB = iMY;
6663
6664
if (iRawlen > 17)
6665
iMethodY = *(pRawdata+17);
6666
else
6667
iMethodY = iMethodX;
6668
}
6669
/* check field validity */
6670
if ((iMethodX > 5) || (iMethodY > 5))
6671
MNG_ERROR (pData, MNG_INVALIDMETHOD)
6672
6673
#ifdef MNG_SUPPORT_DISPLAY
6674
{
6675
mng_retcode iRetcode;
6676
6677
iRetcode = mng_create_ani_magn (pData, iFirstid, iLastid, iMethodX,
6678
iMX, iMY, iML, iMR, iMT, iMB, iMethodY);
6679
6680
if (!iRetcode) /* display processing ? */
6681
iRetcode = mng_process_display_magn (pData, iFirstid, iLastid, iMethodX,
6682
iMX, iMY, iML, iMR, iMT, iMB, iMethodY);
6683
6684
if (iRetcode) /* on error bail out */
6685
return iRetcode;
6686
6687
}
6688
#endif /* MNG_SUPPORT_DISPLAY */
6689
6690
#ifdef MNG_STORE_CHUNKS
6691
if (pData->bStorechunks)
6692
{ /* initialize storage */
6693
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6694
6695
if (iRetcode) /* on error bail out */
6696
return iRetcode;
6697
/* store the fields */
6698
((mng_magnp)*ppChunk)->iFirstid = iFirstid;
6699
((mng_magnp)*ppChunk)->iLastid = iLastid;
6700
((mng_magnp)*ppChunk)->iMethodX = iMethodX;
6701
((mng_magnp)*ppChunk)->iMX = iMX;
6702
((mng_magnp)*ppChunk)->iMY = iMY;
6703
((mng_magnp)*ppChunk)->iML = iML;
6704
((mng_magnp)*ppChunk)->iMR = iMR;
6705
((mng_magnp)*ppChunk)->iMT = iMT;
6706
((mng_magnp)*ppChunk)->iMB = iMB;
6707
((mng_magnp)*ppChunk)->iMethodY = iMethodY;
6708
}
6709
#endif /* MNG_STORE_CHUNKS */
6710
6711
#ifdef MNG_SUPPORT_TRACE
6712
MNG_TRACE (pData, MNG_FN_READ_MAGN, MNG_LC_END)
6713
#endif
6714
6715
return MNG_NOERROR; /* done */
6716
}
6717
#endif
6718
6719
/* ************************************************************************** */
6720
6721
#ifndef MNG_SKIPCHUNK_evNT
6722
READ_CHUNK (mng_read_evnt)
6723
{
6724
#ifdef MNG_SUPPORT_TRACE
6725
MNG_TRACE (pData, MNG_FN_READ_EVNT, MNG_LC_START)
6726
#endif
6727
/* sequence checks */
6728
if ((!pData->bHasMHDR) || (pData->bHasSAVE))
6729
MNG_ERROR (pData, MNG_SEQUENCEERROR)
6730
6731
if (iRawlen < 2) /* must have at least 1 entry ! */
6732
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6733
6734
#if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG)
6735
{
6736
if (iRawlen) /* not empty ? */
6737
{
6738
mng_retcode iRetcode;
6739
mng_uint8p pTemp;
6740
mng_uint8p pNull;
6741
mng_uint32 iLen;
6742
mng_uint8 iEventtype;
6743
mng_uint8 iMasktype;
6744
mng_int32 iLeft;
6745
mng_int32 iRight;
6746
mng_int32 iTop;
6747
mng_int32 iBottom;
6748
mng_uint16 iObjectid;
6749
mng_uint8 iIndex;
6750
mng_uint32 iNamesize;
6751
6752
pTemp = pRawdata;
6753
iLen = iRawlen;
6754
6755
while (iLen) /* anything left ? */
6756
{
6757
iEventtype = *pTemp; /* eventtype */
6758
if (iEventtype > 5)
6759
MNG_ERROR (pData, MNG_INVALIDEVENT);
6760
6761
pTemp++;
6762
6763
iMasktype = *pTemp; /* masktype */
6764
if (iMasktype > 5)
6765
MNG_ERROR (pData, MNG_INVALIDMASK);
6766
6767
pTemp++;
6768
iLen -= 2;
6769
6770
iLeft = 0;
6771
iRight = 0;
6772
iTop = 0;
6773
iBottom = 0;
6774
iObjectid = 0;
6775
iIndex = 0;
6776
6777
switch (iMasktype)
6778
{
6779
case 1 :
6780
{
6781
if (iLen > 16)
6782
{
6783
iLeft = mng_get_int32 (pTemp);
6784
iRight = mng_get_int32 (pTemp+4);
6785
iTop = mng_get_int32 (pTemp+8);
6786
iBottom = mng_get_int32 (pTemp+12);
6787
pTemp += 16;
6788
iLen -= 16;
6789
}
6790
else
6791
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6792
break;
6793
}
6794
case 2 :
6795
{
6796
if (iLen > 2)
6797
{
6798
iObjectid = mng_get_uint16 (pTemp);
6799
pTemp += 2;
6800
iLen -= 2;
6801
}
6802
else
6803
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6804
break;
6805
}
6806
case 3 :
6807
{
6808
if (iLen > 3)
6809
{
6810
iObjectid = mng_get_uint16 (pTemp);
6811
iIndex = *(pTemp+2);
6812
pTemp += 3;
6813
iLen -= 3;
6814
}
6815
else
6816
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6817
break;
6818
}
6819
case 4 :
6820
{
6821
if (iLen > 18)
6822
{
6823
iLeft = mng_get_int32 (pTemp);
6824
iRight = mng_get_int32 (pTemp+4);
6825
iTop = mng_get_int32 (pTemp+8);
6826
iBottom = mng_get_int32 (pTemp+12);
6827
iObjectid = mng_get_uint16 (pTemp+16);
6828
pTemp += 18;
6829
iLen -= 18;
6830
}
6831
else
6832
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6833
break;
6834
}
6835
case 5 :
6836
{
6837
if (iLen > 19)
6838
{
6839
iLeft = mng_get_int32 (pTemp);
6840
iRight = mng_get_int32 (pTemp+4);
6841
iTop = mng_get_int32 (pTemp+8);
6842
iBottom = mng_get_int32 (pTemp+12);
6843
iObjectid = mng_get_uint16 (pTemp+16);
6844
iIndex = *(pTemp+18);
6845
pTemp += 19;
6846
iLen -= 19;
6847
}
6848
else
6849
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6850
break;
6851
}
6852
}
6853
6854
pNull = find_null (pTemp); /* get the name length */
6855
6856
if ((pNull - pTemp) > (mng_int32)iLen)
6857
{
6858
iNamesize = iLen; /* no null found; so end of evNT */
6859
iLen = 0;
6860
}
6861
else
6862
{
6863
iNamesize = pNull - pTemp; /* should be another entry */
6864
iLen = iLen - iNamesize - 1;
6865
6866
if (!iLen) /* must not end with a null ! */
6867
MNG_ERROR (pData, MNG_ENDWITHNULL)
6868
}
6869
6870
iRetcode = mng_create_event (pData, iEventtype, iMasktype, iLeft, iRight,
6871
iTop, iBottom, iObjectid, iIndex,
6872
iNamesize, (mng_pchar)pTemp);
6873
6874
if (iRetcode) /* on error bail out */
6875
return iRetcode;
6876
6877
pTemp = pTemp + iNamesize + 1;
6878
}
6879
}
6880
}
6881
#endif /* MNG_SUPPORT_DISPLAY && MNG_SUPPORT_DYNAMICMNG */
6882
6883
#ifdef MNG_STORE_CHUNKS
6884
if (pData->bStorechunks)
6885
{ /* initialize storage */
6886
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6887
6888
if (iRetcode) /* on error bail out */
6889
return iRetcode;
6890
6891
if (iRawlen) /* not empty ? */
6892
{
6893
mng_uint32 iX;
6894
mng_uint32 iCount = 0;
6895
mng_uint8p pTemp;
6896
mng_uint8p pNull;
6897
mng_uint32 iLen;
6898
mng_uint8 iEventtype;
6899
mng_uint8 iMasktype;
6900
mng_int32 iLeft;
6901
mng_int32 iRight;
6902
mng_int32 iTop;
6903
mng_int32 iBottom;
6904
mng_uint16 iObjectid;
6905
mng_uint8 iIndex;
6906
mng_uint32 iNamesize;
6907
mng_evnt_entryp pEntry = MNG_NULL;
6908
6909
for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */
6910
{
6911
pTemp = pRawdata;
6912
iLen = iRawlen;
6913
6914
if (iX) /* second run ? */
6915
{
6916
MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_evnt_entry)))
6917
6918
((mng_evntp)*ppChunk)->iCount = iCount;
6919
((mng_evntp)*ppChunk)->pEntries = pEntry;
6920
}
6921
6922
while (iLen) /* anything left ? */
6923
{
6924
iEventtype = *pTemp; /* eventtype */
6925
if (iEventtype > 5)
6926
MNG_ERROR (pData, MNG_INVALIDEVENT);
6927
6928
pTemp++;
6929
6930
iMasktype = *pTemp; /* masktype */
6931
if (iMasktype > 5)
6932
MNG_ERROR (pData, MNG_INVALIDMASK);
6933
6934
pTemp++;
6935
iLen -= 2;
6936
6937
iLeft = 0;
6938
iRight = 0;
6939
iTop = 0;
6940
iBottom = 0;
6941
iObjectid = 0;
6942
iIndex = 0;
6943
6944
switch (iMasktype)
6945
{
6946
case 1 :
6947
{
6948
if (iLen > 16)
6949
{
6950
iLeft = mng_get_int32 (pTemp);
6951
iRight = mng_get_int32 (pTemp+4);
6952
iTop = mng_get_int32 (pTemp+8);
6953
iBottom = mng_get_int32 (pTemp+12);
6954
pTemp += 16;
6955
iLen -= 16;
6956
}
6957
else
6958
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6959
break;
6960
}
6961
case 2 :
6962
{
6963
if (iLen > 2)
6964
{
6965
iObjectid = mng_get_uint16 (pTemp);
6966
pTemp += 2;
6967
iLen -= 2;
6968
}
6969
else
6970
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6971
break;
6972
}
6973
case 3 :
6974
{
6975
if (iLen > 3)
6976
{
6977
iObjectid = mng_get_uint16 (pTemp);
6978
iIndex = *(pTemp+2);
6979
pTemp += 3;
6980
iLen -= 3;
6981
}
6982
else
6983
MNG_ERROR (pData, MNG_INVALIDLENGTH)
6984
break;
6985
}
6986
case 4 :
6987
{
6988
if (iLen > 18)
6989
{
6990
iLeft = mng_get_int32 (pTemp);
6991
iRight = mng_get_int32 (pTemp+4);
6992
iTop = mng_get_int32 (pTemp+8);
6993
iBottom = mng_get_int32 (pTemp+12);
6994
iObjectid = mng_get_uint16 (pTemp+16);
6995
pTemp += 18;
6996
iLen -= 18;
6997
}
6998
else
6999
MNG_ERROR (pData, MNG_INVALIDLENGTH)
7000
break;
7001
}
7002
case 5 :
7003
{
7004
if (iLen > 19)
7005
{
7006
iLeft = mng_get_int32 (pTemp);
7007
iRight = mng_get_int32 (pTemp+4);
7008
iTop = mng_get_int32 (pTemp+8);
7009
iBottom = mng_get_int32 (pTemp+12);
7010
iObjectid = mng_get_uint16 (pTemp+16);
7011
iIndex = *(pTemp+18);
7012
pTemp += 19;
7013
iLen -= 19;
7014
}
7015
else
7016
MNG_ERROR (pData, MNG_INVALIDLENGTH)
7017
break;
7018
}
7019
}
7020
7021
pNull = find_null (pTemp); /* get the name length */
7022
7023
if ((pNull - pTemp) > (mng_int32)iLen)
7024
{
7025
iNamesize = iLen; /* no null found; so end of evNT */
7026
iLen = 0;
7027
}
7028
else
7029
{
7030
iNamesize = pNull - pTemp; /* should be another entry */
7031
iLen = iLen - iNamesize - 1;
7032
7033
if (!iLen) /* must not end with a null ! */
7034
MNG_ERROR (pData, MNG_ENDWITHNULL)
7035
}
7036
7037
if (!iX)
7038
{
7039
iCount++;
7040
}
7041
else
7042
{
7043
pEntry->iEventtype = iEventtype;
7044
pEntry->iMasktype = iMasktype;
7045
pEntry->iLeft = iLeft;
7046
pEntry->iRight = iRight;
7047
pEntry->iTop = iTop;
7048
pEntry->iBottom = iBottom;
7049
pEntry->iObjectid = iObjectid;
7050
pEntry->iIndex = iIndex;
7051
pEntry->iSegmentnamesize = iNamesize;
7052
7053
if (iNamesize)
7054
{
7055
MNG_ALLOC (pData, pEntry->zSegmentname, iNamesize+1)
7056
MNG_COPY (pEntry->zSegmentname, pTemp, iNamesize)
7057
}
7058
7059
pEntry++;
7060
}
7061
7062
pTemp = pTemp + iNamesize + 1;
7063
}
7064
}
7065
}
7066
}
7067
#endif /* MNG_STORE_CHUNKS */
7068
7069
#ifdef MNG_SUPPORT_TRACE
7070
MNG_TRACE (pData, MNG_FN_READ_EVNT, MNG_LC_END)
7071
#endif
7072
7073
return MNG_NOERROR; /* done */
7074
}
7075
#endif
7076
7077
/* ************************************************************************** */
7078
7079
READ_CHUNK (mng_read_unknown)
7080
{
7081
#ifdef MNG_SUPPORT_TRACE
7082
MNG_TRACE (pData, MNG_FN_READ_UNKNOWN, MNG_LC_START)
7083
#endif
7084
/* sequence checks */
7085
#ifdef MNG_INCLUDE_JNG
7086
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
7087
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
7088
#else
7089
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
7090
(!pData->bHasBASI) && (!pData->bHasDHDR) )
7091
#endif
7092
MNG_ERROR (pData, MNG_SEQUENCEERROR)
7093
/* critical chunk ? */
7094
if ((((mng_uint32)pData->iChunkname & 0x20000000) == 0)
7095
#ifdef MNG_SKIPCHUNK_SAVE
7096
&& (pData->iChunkname != MNG_UINT_SAVE)
7097
#endif
7098
#ifdef MNG_SKIPCHUNK_SEEK
7099
&& (pData->iChunkname != MNG_UINT_SEEK)
7100
#endif
7101
#ifdef MNG_SKIPCHUNK_DBYK
7102
&& (pData->iChunkname != MNG_UINT_DBYK)
7103
#endif
7104
#ifdef MNG_SKIPCHUNK_ORDR
7105
&& (pData->iChunkname != MNG_UINT_ORDR)
7106
#endif
7107
)
7108
MNG_ERROR (pData, MNG_UNKNOWNCRITICAL)
7109
7110
if (pData->fProcessunknown) /* let the app handle it ? */
7111
{
7112
mng_bool bOke = pData->fProcessunknown ((mng_handle)pData, pData->iChunkname,
7113
iRawlen, (mng_ptr)pRawdata);
7114
7115
if (!bOke)
7116
MNG_ERROR (pData, MNG_APPMISCERROR)
7117
}
7118
7119
#ifdef MNG_STORE_CHUNKS
7120
if (pData->bStorechunks)
7121
{ /* initialize storage */
7122
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
7123
7124
if (iRetcode) /* on error bail out */
7125
return iRetcode;
7126
/* store the length */
7127
((mng_chunk_headerp)*ppChunk)->iChunkname = pData->iChunkname;
7128
((mng_unknown_chunkp)*ppChunk)->iDatasize = iRawlen;
7129
7130
if (iRawlen == 0) /* any data at all ? */
7131
((mng_unknown_chunkp)*ppChunk)->pData = 0;
7132
else
7133
{ /* then store it */
7134
MNG_ALLOC (pData, ((mng_unknown_chunkp)*ppChunk)->pData, iRawlen)
7135
MNG_COPY (((mng_unknown_chunkp)*ppChunk)->pData, pRawdata, iRawlen)
7136
}
7137
}
7138
#endif /* MNG_STORE_CHUNKS */
7139
7140
#ifdef MNG_SUPPORT_TRACE
7141
MNG_TRACE (pData, MNG_FN_READ_UNKNOWN, MNG_LC_END)
7142
#endif
7143
7144
return MNG_NOERROR; /* done */
7145
}
7146
7147
/* ************************************************************************** */
7148
7149
#endif /* MNG_INCLUDE_READ_PROCS */
7150
7151
/* ************************************************************************** */
7152
/* * * */
7153
/* * chunk write functions * */
7154
/* * * */
7155
/* ************************************************************************** */
7156
7157
#ifdef MNG_INCLUDE_WRITE_PROCS
7158
7159
/* ************************************************************************** */
7160
7161
WRITE_CHUNK (mng_write_ihdr)
7162
{
7163
mng_ihdrp pIHDR;
7164
mng_uint8p pRawdata;
7165
mng_uint32 iRawlen;
7166
mng_retcode iRetcode;
7167
7168
#ifdef MNG_SUPPORT_TRACE
7169
MNG_TRACE (pData, MNG_FN_WRITE_IHDR, MNG_LC_START)
7170
#endif
7171
7172
pIHDR = (mng_ihdrp)pChunk; /* address the proper chunk */
7173
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7174
iRawlen = 13;
7175
/* fill the output buffer */
7176
mng_put_uint32 (pRawdata, pIHDR->iWidth);
7177
mng_put_uint32 (pRawdata+4, pIHDR->iHeight);
7178
7179
*(pRawdata+8) = pIHDR->iBitdepth;
7180
*(pRawdata+9) = pIHDR->iColortype;
7181
*(pRawdata+10) = pIHDR->iCompression;
7182
*(pRawdata+11) = pIHDR->iFilter;
7183
*(pRawdata+12) = pIHDR->iInterlace;
7184
/* and write it */
7185
iRetcode = write_raw_chunk (pData, pIHDR->sHeader.iChunkname, iRawlen, pRawdata);
7186
7187
#ifdef MNG_SUPPORT_TRACE
7188
MNG_TRACE (pData, MNG_FN_WRITE_IHDR, MNG_LC_END)
7189
#endif
7190
7191
return iRetcode;
7192
}
7193
7194
/* ************************************************************************** */
7195
7196
WRITE_CHUNK (mng_write_plte)
7197
{
7198
mng_pltep pPLTE;
7199
mng_uint8p pRawdata;
7200
mng_uint32 iRawlen;
7201
mng_retcode iRetcode;
7202
mng_uint8p pTemp;
7203
mng_uint32 iX;
7204
7205
#ifdef MNG_SUPPORT_TRACE
7206
MNG_TRACE (pData, MNG_FN_WRITE_PLTE, MNG_LC_START)
7207
#endif
7208
7209
pPLTE = (mng_pltep)pChunk; /* address the proper chunk */
7210
7211
if (pPLTE->bEmpty) /* write empty chunk ? */
7212
iRetcode = write_raw_chunk (pData, pPLTE->sHeader.iChunkname, 0, 0);
7213
else
7214
{
7215
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7216
iRawlen = pPLTE->iEntrycount * 3;
7217
/* fill the output buffer */
7218
pTemp = pRawdata;
7219
7220
for (iX = 0; iX < pPLTE->iEntrycount; iX++)
7221
{
7222
*pTemp = pPLTE->aEntries [iX].iRed;
7223
*(pTemp+1) = pPLTE->aEntries [iX].iGreen;
7224
*(pTemp+2) = pPLTE->aEntries [iX].iBlue;
7225
7226
pTemp += 3;
7227
}
7228
/* and write it */
7229
iRetcode = write_raw_chunk (pData, pPLTE->sHeader.iChunkname, iRawlen, pRawdata);
7230
}
7231
7232
#ifdef MNG_SUPPORT_TRACE
7233
MNG_TRACE (pData, MNG_FN_WRITE_PLTE, MNG_LC_END)
7234
#endif
7235
7236
return iRetcode;
7237
}
7238
7239
/* ************************************************************************** */
7240
7241
WRITE_CHUNK (mng_write_idat)
7242
{
7243
mng_idatp pIDAT;
7244
mng_retcode iRetcode;
7245
7246
#ifdef MNG_SUPPORT_TRACE
7247
MNG_TRACE (pData, MNG_FN_WRITE_IDAT, MNG_LC_START)
7248
#endif
7249
7250
pIDAT = (mng_idatp)pChunk; /* address the proper chunk */
7251
7252
if (pIDAT->bEmpty) /* and write it */
7253
iRetcode = write_raw_chunk (pData, pIDAT->sHeader.iChunkname, 0, 0);
7254
else
7255
iRetcode = write_raw_chunk (pData, pIDAT->sHeader.iChunkname,
7256
pIDAT->iDatasize, pIDAT->pData);
7257
7258
#ifdef MNG_SUPPORT_TRACE
7259
MNG_TRACE (pData, MNG_FN_WRITE_IDAT, MNG_LC_END)
7260
#endif
7261
7262
return iRetcode;
7263
}
7264
7265
/* ************************************************************************** */
7266
7267
WRITE_CHUNK (mng_write_iend)
7268
{
7269
mng_iendp pIEND;
7270
mng_retcode iRetcode;
7271
7272
#ifdef MNG_SUPPORT_TRACE
7273
MNG_TRACE (pData, MNG_FN_WRITE_IEND, MNG_LC_START)
7274
#endif
7275
7276
pIEND = (mng_iendp)pChunk; /* address the proper chunk */
7277
/* and write it */
7278
iRetcode = write_raw_chunk (pData, pIEND->sHeader.iChunkname, 0, 0);
7279
7280
#ifdef MNG_SUPPORT_TRACE
7281
MNG_TRACE (pData, MNG_FN_WRITE_IEND, MNG_LC_END)
7282
#endif
7283
7284
return iRetcode;
7285
}
7286
7287
/* ************************************************************************** */
7288
7289
WRITE_CHUNK (mng_write_trns)
7290
{
7291
mng_trnsp pTRNS;
7292
mng_uint8p pRawdata;
7293
mng_uint32 iRawlen;
7294
mng_retcode iRetcode;
7295
mng_uint8p pTemp;
7296
mng_uint32 iX;
7297
7298
#ifdef MNG_SUPPORT_TRACE
7299
MNG_TRACE (pData, MNG_FN_WRITE_TRNS, MNG_LC_START)
7300
#endif
7301
7302
pTRNS = (mng_trnsp)pChunk; /* address the proper chunk */
7303
7304
if (pTRNS->bEmpty) /* write empty chunk ? */
7305
iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname, 0, 0);
7306
else
7307
if (pTRNS->bGlobal) /* write global chunk ? */
7308
iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname,
7309
pTRNS->iRawlen, (mng_uint8p)pTRNS->aRawdata);
7310
else
7311
{
7312
pRawdata = pData->pWritebuf+8; /* init output buffer */
7313
iRawlen = 0; /* and default size */
7314
7315
switch (pTRNS->iType)
7316
{
7317
case 0: {
7318
iRawlen = 2; /* fill the size & output buffer */
7319
mng_put_uint16 (pRawdata, pTRNS->iGray);
7320
7321
break;
7322
}
7323
case 2: {
7324
iRawlen = 6; /* fill the size & output buffer */
7325
mng_put_uint16 (pRawdata, pTRNS->iRed);
7326
mng_put_uint16 (pRawdata+2, pTRNS->iGreen);
7327
mng_put_uint16 (pRawdata+4, pTRNS->iBlue);
7328
7329
break;
7330
}
7331
case 3: { /* init output buffer size */
7332
iRawlen = pTRNS->iCount;
7333
7334
pTemp = pRawdata; /* fill the output buffer */
7335
7336
for (iX = 0; iX < pTRNS->iCount; iX++)
7337
{
7338
*pTemp = pTRNS->aEntries[iX];
7339
pTemp++;
7340
}
7341
7342
break;
7343
}
7344
}
7345
/* write the chunk */
7346
iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname,
7347
iRawlen, pRawdata);
7348
}
7349
7350
#ifdef MNG_SUPPORT_TRACE
7351
MNG_TRACE (pData, MNG_FN_WRITE_TRNS, MNG_LC_END)
7352
#endif
7353
7354
return iRetcode;
7355
}
7356
7357
/* ************************************************************************** */
7358
7359
WRITE_CHUNK (mng_write_gama)
7360
{
7361
mng_gamap pGAMA;
7362
mng_uint8p pRawdata;
7363
mng_uint32 iRawlen;
7364
mng_retcode iRetcode;
7365
7366
#ifdef MNG_SUPPORT_TRACE
7367
MNG_TRACE (pData, MNG_FN_WRITE_GAMA, MNG_LC_START)
7368
#endif
7369
7370
pGAMA = (mng_gamap)pChunk; /* address the proper chunk */
7371
7372
if (pGAMA->bEmpty) /* write empty ? */
7373
iRetcode = write_raw_chunk (pData, pGAMA->sHeader.iChunkname, 0, 0);
7374
else
7375
{
7376
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7377
iRawlen = 4;
7378
/* fill the buffer */
7379
mng_put_uint32 (pRawdata, pGAMA->iGamma);
7380
/* and write it */
7381
iRetcode = write_raw_chunk (pData, pGAMA->sHeader.iChunkname,
7382
iRawlen, pRawdata);
7383
}
7384
7385
#ifdef MNG_SUPPORT_TRACE
7386
MNG_TRACE (pData, MNG_FN_WRITE_GAMA, MNG_LC_END)
7387
#endif
7388
7389
return iRetcode;
7390
}
7391
7392
/* ************************************************************************** */
7393
7394
#ifndef MNG_SKIPCHUNK_cHRM
7395
WRITE_CHUNK (mng_write_chrm)
7396
{
7397
mng_chrmp pCHRM;
7398
mng_uint8p pRawdata;
7399
mng_uint32 iRawlen;
7400
mng_retcode iRetcode;
7401
7402
#ifdef MNG_SUPPORT_TRACE
7403
MNG_TRACE (pData, MNG_FN_WRITE_CHRM, MNG_LC_START)
7404
#endif
7405
7406
pCHRM = (mng_chrmp)pChunk; /* address the proper chunk */
7407
7408
if (pCHRM->bEmpty) /* write empty ? */
7409
iRetcode = write_raw_chunk (pData, pCHRM->sHeader.iChunkname, 0, 0);
7410
else
7411
{
7412
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7413
iRawlen = 32;
7414
/* fill the buffer */
7415
mng_put_uint32 (pRawdata, pCHRM->iWhitepointx);
7416
mng_put_uint32 (pRawdata+4, pCHRM->iWhitepointy);
7417
mng_put_uint32 (pRawdata+8, pCHRM->iRedx);
7418
mng_put_uint32 (pRawdata+12, pCHRM->iRedy);
7419
mng_put_uint32 (pRawdata+16, pCHRM->iGreenx);
7420
mng_put_uint32 (pRawdata+20, pCHRM->iGreeny);
7421
mng_put_uint32 (pRawdata+24, pCHRM->iBluex);
7422
mng_put_uint32 (pRawdata+28, pCHRM->iBluey);
7423
/* and write it */
7424
iRetcode = write_raw_chunk (pData, pCHRM->sHeader.iChunkname,
7425
iRawlen, pRawdata);
7426
}
7427
7428
#ifdef MNG_SUPPORT_TRACE
7429
MNG_TRACE (pData, MNG_FN_WRITE_CHRM, MNG_LC_END)
7430
#endif
7431
7432
return iRetcode;
7433
}
7434
#endif
7435
7436
/* ************************************************************************** */
7437
7438
WRITE_CHUNK (mng_write_srgb)
7439
{
7440
mng_srgbp pSRGB;
7441
mng_uint8p pRawdata;
7442
mng_uint32 iRawlen;
7443
mng_retcode iRetcode;
7444
7445
#ifdef MNG_SUPPORT_TRACE
7446
MNG_TRACE (pData, MNG_FN_WRITE_SRGB, MNG_LC_START)
7447
#endif
7448
7449
pSRGB = (mng_srgbp)pChunk; /* address the proper chunk */
7450
7451
if (pSRGB->bEmpty) /* write empty ? */
7452
iRetcode = write_raw_chunk (pData, pSRGB->sHeader.iChunkname, 0, 0);
7453
else
7454
{
7455
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7456
iRawlen = 1;
7457
/* fill the buffer */
7458
*pRawdata = pSRGB->iRenderingintent;
7459
/* and write it */
7460
iRetcode = write_raw_chunk (pData, pSRGB->sHeader.iChunkname,
7461
iRawlen, pRawdata);
7462
}
7463
7464
#ifdef MNG_SUPPORT_TRACE
7465
MNG_TRACE (pData, MNG_FN_WRITE_SRGB, MNG_LC_END)
7466
#endif
7467
7468
return iRetcode;
7469
}
7470
7471
/* ************************************************************************** */
7472
7473
#ifndef MNG_SKIPCHUNK_iCCP
7474
WRITE_CHUNK (mng_write_iccp)
7475
{
7476
mng_iccpp pICCP;
7477
mng_uint8p pRawdata;
7478
mng_uint32 iRawlen;
7479
mng_retcode iRetcode;
7480
mng_uint8p pTemp;
7481
mng_uint8p pBuf = 0;
7482
mng_uint32 iBuflen;
7483
mng_uint32 iReallen;
7484
7485
#ifdef MNG_SUPPORT_TRACE
7486
MNG_TRACE (pData, MNG_FN_WRITE_ICCP, MNG_LC_START)
7487
#endif
7488
7489
pICCP = (mng_iccpp)pChunk; /* address the proper chunk */
7490
7491
if (pICCP->bEmpty) /* write empty ? */
7492
iRetcode = write_raw_chunk (pData, pICCP->sHeader.iChunkname, 0, 0);
7493
else
7494
{ /* compress the profile */
7495
iRetcode = deflate_buffer (pData, pICCP->pProfile, pICCP->iProfilesize,
7496
&pBuf, &iBuflen, &iReallen);
7497
7498
if (!iRetcode) /* still oke ? */
7499
{
7500
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7501
iRawlen = pICCP->iNamesize + 2 + iReallen;
7502
/* requires large buffer ? */
7503
if (iRawlen > pData->iWritebufsize)
7504
MNG_ALLOC (pData, pRawdata, iRawlen)
7505
7506
pTemp = pRawdata; /* fill the buffer */
7507
7508
if (pICCP->iNamesize)
7509
{
7510
MNG_COPY (pTemp, pICCP->zName, pICCP->iNamesize)
7511
pTemp += pICCP->iNamesize;
7512
}
7513
7514
*pTemp = 0;
7515
*(pTemp+1) = pICCP->iCompression;
7516
pTemp += 2;
7517
7518
if (iReallen)
7519
MNG_COPY (pTemp, pBuf, iReallen)
7520
/* and write it */
7521
iRetcode = write_raw_chunk (pData, pICCP->sHeader.iChunkname,
7522
iRawlen, pRawdata);
7523
/* drop the temp buffer ? */
7524
if (iRawlen > pData->iWritebufsize)
7525
MNG_FREEX (pData, pRawdata, iRawlen)
7526
7527
}
7528
7529
MNG_FREEX (pData, pBuf, iBuflen) /* always drop the extra buffer */
7530
}
7531
7532
#ifdef MNG_SUPPORT_TRACE
7533
MNG_TRACE (pData, MNG_FN_WRITE_ICCP, MNG_LC_END)
7534
#endif
7535
7536
return iRetcode;
7537
}
7538
#endif
7539
7540
/* ************************************************************************** */
7541
7542
#ifndef MNG_SKIPCHUNK_tEXt
7543
WRITE_CHUNK (mng_write_text)
7544
{
7545
mng_textp pTEXT;
7546
mng_uint8p pRawdata;
7547
mng_uint32 iRawlen;
7548
mng_retcode iRetcode;
7549
mng_uint8p pTemp;
7550
7551
#ifdef MNG_SUPPORT_TRACE
7552
MNG_TRACE (pData, MNG_FN_WRITE_TEXT, MNG_LC_START)
7553
#endif
7554
7555
pTEXT = (mng_textp)pChunk; /* address the proper chunk */
7556
7557
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7558
iRawlen = pTEXT->iKeywordsize + 1 + pTEXT->iTextsize;
7559
/* requires large buffer ? */
7560
if (iRawlen > pData->iWritebufsize)
7561
MNG_ALLOC (pData, pRawdata, iRawlen)
7562
7563
pTemp = pRawdata; /* fill the buffer */
7564
7565
if (pTEXT->iKeywordsize)
7566
{
7567
MNG_COPY (pTemp, pTEXT->zKeyword, pTEXT->iKeywordsize)
7568
pTemp += pTEXT->iKeywordsize;
7569
}
7570
7571
*pTemp = 0;
7572
pTemp += 1;
7573
7574
if (pTEXT->iTextsize)
7575
MNG_COPY (pTemp, pTEXT->zText, pTEXT->iTextsize)
7576
/* and write it */
7577
iRetcode = write_raw_chunk (pData, pTEXT->sHeader.iChunkname,
7578
iRawlen, pRawdata);
7579
7580
if (iRawlen > pData->iWritebufsize) /* drop the temp buffer ? */
7581
MNG_FREEX (pData, pRawdata, iRawlen)
7582
7583
#ifdef MNG_SUPPORT_TRACE
7584
MNG_TRACE (pData, MNG_FN_WRITE_TEXT, MNG_LC_END)
7585
#endif
7586
7587
return iRetcode;
7588
}
7589
#endif
7590
7591
/* ************************************************************************** */
7592
7593
#ifndef MNG_SKIPCHUNK_zTXt
7594
WRITE_CHUNK (mng_write_ztxt)
7595
{
7596
mng_ztxtp pZTXT;
7597
mng_uint8p pRawdata;
7598
mng_uint32 iRawlen;
7599
mng_retcode iRetcode;
7600
mng_uint8p pTemp;
7601
mng_uint8p pBuf = 0;
7602
mng_uint32 iBuflen;
7603
mng_uint32 iReallen;
7604
7605
#ifdef MNG_SUPPORT_TRACE
7606
MNG_TRACE (pData, MNG_FN_WRITE_ZTXT, MNG_LC_START)
7607
#endif
7608
7609
pZTXT = (mng_ztxtp)pChunk; /* address the proper chunk */
7610
/* compress the text */
7611
iRetcode = deflate_buffer (pData, (mng_uint8p)pZTXT->zText, pZTXT->iTextsize,
7612
&pBuf, &iBuflen, &iReallen);
7613
7614
if (!iRetcode) /* all ok ? */
7615
{
7616
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7617
iRawlen = pZTXT->iKeywordsize + 2 + iReallen;
7618
/* requires large buffer ? */
7619
if (iRawlen > pData->iWritebufsize)
7620
MNG_ALLOC (pData, pRawdata, iRawlen)
7621
7622
pTemp = pRawdata; /* fill the buffer */
7623
7624
if (pZTXT->iKeywordsize)
7625
{
7626
MNG_COPY (pTemp, pZTXT->zKeyword, pZTXT->iKeywordsize)
7627
pTemp += pZTXT->iKeywordsize;
7628
}
7629
7630
*pTemp = 0; /* terminator zero */
7631
pTemp++;
7632
*pTemp = 0; /* compression type */
7633
pTemp++;
7634
7635
if (iReallen)
7636
MNG_COPY (pTemp, pBuf, iReallen)
7637
/* and write it */
7638
iRetcode = write_raw_chunk (pData, pZTXT->sHeader.iChunkname,
7639
iRawlen, pRawdata);
7640
/* drop the temp buffer ? */
7641
if (iRawlen > pData->iWritebufsize)
7642
MNG_FREEX (pData, pRawdata, iRawlen)
7643
7644
}
7645
7646
MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
7647
7648
#ifdef MNG_SUPPORT_TRACE
7649
MNG_TRACE (pData, MNG_FN_WRITE_ZTXT, MNG_LC_END)
7650
#endif
7651
7652
return iRetcode;
7653
}
7654
#endif
7655
7656
/* ************************************************************************** */
7657
7658
#ifndef MNG_SKIPCHUNK_iTXt
7659
WRITE_CHUNK (mng_write_itxt)
7660
{
7661
mng_itxtp pITXT;
7662
mng_uint8p pRawdata;
7663
mng_uint32 iRawlen;
7664
mng_retcode iRetcode;
7665
mng_uint8p pTemp;
7666
mng_uint8p pBuf = 0;
7667
mng_uint32 iBuflen;
7668
mng_uint32 iReallen;
7669
7670
#ifdef MNG_SUPPORT_TRACE
7671
MNG_TRACE (pData, MNG_FN_WRITE_ITXT, MNG_LC_START)
7672
#endif
7673
7674
pITXT = (mng_itxtp)pChunk; /* address the proper chunk */
7675
7676
if (pITXT->iCompressionflag) /* compress the text */
7677
iRetcode = deflate_buffer (pData, (mng_uint8p)pITXT->zText, pITXT->iTextsize,
7678
&pBuf, &iBuflen, &iReallen);
7679
else
7680
iRetcode = MNG_NOERROR;
7681
7682
if (!iRetcode) /* all ok ? */
7683
{
7684
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7685
iRawlen = pITXT->iKeywordsize + pITXT->iLanguagesize +
7686
pITXT->iTranslationsize + 5;
7687
7688
if (pITXT->iCompressionflag)
7689
iRawlen = iRawlen + iReallen;
7690
else
7691
iRawlen = iRawlen + pITXT->iTextsize;
7692
/* requires large buffer ? */
7693
if (iRawlen > pData->iWritebufsize)
7694
MNG_ALLOC (pData, pRawdata, iRawlen)
7695
7696
pTemp = pRawdata; /* fill the buffer */
7697
7698
if (pITXT->iKeywordsize)
7699
{
7700
MNG_COPY (pTemp, pITXT->zKeyword, pITXT->iKeywordsize)
7701
pTemp += pITXT->iKeywordsize;
7702
}
7703
7704
*pTemp = 0;
7705
pTemp++;
7706
*pTemp = pITXT->iCompressionflag;
7707
pTemp++;
7708
*pTemp = pITXT->iCompressionmethod;
7709
pTemp++;
7710
7711
if (pITXT->iLanguagesize)
7712
{
7713
MNG_COPY (pTemp, pITXT->zLanguage, pITXT->iLanguagesize)
7714
pTemp += pITXT->iLanguagesize;
7715
}
7716
7717
*pTemp = 0;
7718
pTemp++;
7719
7720
if (pITXT->iTranslationsize)
7721
{
7722
MNG_COPY (pTemp, pITXT->zTranslation, pITXT->iTranslationsize)
7723
pTemp += pITXT->iTranslationsize;
7724
}
7725
7726
*pTemp = 0;
7727
pTemp++;
7728
7729
if (pITXT->iCompressionflag)
7730
{
7731
if (iReallen)
7732
MNG_COPY (pTemp, pBuf, iReallen)
7733
}
7734
else
7735
{
7736
if (pITXT->iTextsize)
7737
MNG_COPY (pTemp, pITXT->zText, pITXT->iTextsize)
7738
}
7739
/* and write it */
7740
iRetcode = write_raw_chunk (pData, pITXT->sHeader.iChunkname,
7741
iRawlen, pRawdata);
7742
/* drop the temp buffer ? */
7743
if (iRawlen > pData->iWritebufsize)
7744
MNG_FREEX (pData, pRawdata, iRawlen)
7745
7746
}
7747
7748
MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
7749
7750
if (iRetcode) /* on error bail out */
7751
return iRetcode;
7752
7753
#ifdef MNG_SUPPORT_TRACE
7754
MNG_TRACE (pData, MNG_FN_WRITE_ITXT, MNG_LC_END)
7755
#endif
7756
7757
return MNG_NOERROR;
7758
}
7759
#endif
7760
7761
/* ************************************************************************** */
7762
7763
#ifndef MNG_SKIPCHUNK_bKGD
7764
WRITE_CHUNK (mng_write_bkgd)
7765
{
7766
mng_bkgdp pBKGD;
7767
mng_uint8p pRawdata;
7768
mng_uint32 iRawlen;
7769
mng_retcode iRetcode;
7770
7771
#ifdef MNG_SUPPORT_TRACE
7772
MNG_TRACE (pData, MNG_FN_WRITE_BKGD, MNG_LC_START)
7773
#endif
7774
7775
pBKGD = (mng_bkgdp)pChunk; /* address the proper chunk */
7776
7777
if (pBKGD->bEmpty) /* write empty ? */
7778
iRetcode = write_raw_chunk (pData, pBKGD->sHeader.iChunkname, 0, 0);
7779
else
7780
{
7781
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7782
iRawlen = 0; /* and default size */
7783
7784
switch (pBKGD->iType)
7785
{
7786
case 0: { /* gray */
7787
iRawlen = 2; /* fill the size & output buffer */
7788
mng_put_uint16 (pRawdata, pBKGD->iGray);
7789
7790
break;
7791
}
7792
case 2: { /* rgb */
7793
iRawlen = 6; /* fill the size & output buffer */
7794
mng_put_uint16 (pRawdata, pBKGD->iRed);
7795
mng_put_uint16 (pRawdata+2, pBKGD->iGreen);
7796
mng_put_uint16 (pRawdata+4, pBKGD->iBlue);
7797
7798
break;
7799
}
7800
case 3: { /* indexed */
7801
iRawlen = 1; /* fill the size & output buffer */
7802
*pRawdata = pBKGD->iIndex;
7803
7804
break;
7805
}
7806
}
7807
/* and write it */
7808
iRetcode = write_raw_chunk (pData, pBKGD->sHeader.iChunkname,
7809
iRawlen, pRawdata);
7810
}
7811
7812
#ifdef MNG_SUPPORT_TRACE
7813
MNG_TRACE (pData, MNG_FN_WRITE_BKGD, MNG_LC_END)
7814
#endif
7815
7816
return iRetcode;
7817
}
7818
#endif
7819
7820
/* ************************************************************************** */
7821
7822
#ifndef MNG_SKIPCHUNK_pHYs
7823
WRITE_CHUNK (mng_write_phys)
7824
{
7825
mng_physp pPHYS;
7826
mng_uint8p pRawdata;
7827
mng_uint32 iRawlen;
7828
mng_retcode iRetcode;
7829
7830
#ifdef MNG_SUPPORT_TRACE
7831
MNG_TRACE (pData, MNG_FN_WRITE_PHYS, MNG_LC_START)
7832
#endif
7833
7834
pPHYS = (mng_physp)pChunk; /* address the proper chunk */
7835
7836
if (pPHYS->bEmpty) /* write empty ? */
7837
iRetcode = write_raw_chunk (pData, pPHYS->sHeader.iChunkname, 0, 0);
7838
else
7839
{
7840
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7841
iRawlen = 9;
7842
/* fill the output buffer */
7843
mng_put_uint32 (pRawdata, pPHYS->iSizex);
7844
mng_put_uint32 (pRawdata+4, pPHYS->iSizey);
7845
7846
*(pRawdata+8) = pPHYS->iUnit;
7847
/* and write it */
7848
iRetcode = write_raw_chunk (pData, pPHYS->sHeader.iChunkname,
7849
iRawlen, pRawdata);
7850
}
7851
7852
#ifdef MNG_SUPPORT_TRACE
7853
MNG_TRACE (pData, MNG_FN_WRITE_PHYS, MNG_LC_END)
7854
#endif
7855
7856
return iRetcode;
7857
}
7858
#endif
7859
7860
/* ************************************************************************** */
7861
7862
#ifndef MNG_SKIPCHUNK_sBIT
7863
WRITE_CHUNK (mng_write_sbit)
7864
{
7865
mng_sbitp pSBIT;
7866
mng_uint8p pRawdata;
7867
mng_uint32 iRawlen;
7868
mng_retcode iRetcode;
7869
7870
#ifdef MNG_SUPPORT_TRACE
7871
MNG_TRACE (pData, MNG_FN_WRITE_SBIT, MNG_LC_START)
7872
#endif
7873
7874
pSBIT = (mng_sbitp)pChunk; /* address the proper chunk */
7875
7876
if (pSBIT->bEmpty) /* write empty ? */
7877
iRetcode = write_raw_chunk (pData, pSBIT->sHeader.iChunkname, 0, 0);
7878
else
7879
{
7880
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7881
iRawlen = 0; /* and default size */
7882
7883
switch (pSBIT->iType)
7884
{
7885
case 0: { /* gray */
7886
iRawlen = 1; /* fill the size & output buffer */
7887
*pRawdata = pSBIT->aBits[0];
7888
7889
break;
7890
}
7891
case 2: { /* rgb */
7892
iRawlen = 3; /* fill the size & output buffer */
7893
*pRawdata = pSBIT->aBits[0];
7894
*(pRawdata+1) = pSBIT->aBits[1];
7895
*(pRawdata+2) = pSBIT->aBits[2];
7896
7897
break;
7898
}
7899
case 3: { /* indexed */
7900
iRawlen = 1; /* fill the size & output buffer */
7901
*pRawdata = pSBIT->aBits[0];
7902
7903
break;
7904
}
7905
case 4: { /* gray + alpha */
7906
iRawlen = 2; /* fill the size & output buffer */
7907
*pRawdata = pSBIT->aBits[0];
7908
*(pRawdata+1) = pSBIT->aBits[1];
7909
7910
break;
7911
}
7912
case 6: { /* rgb + alpha */
7913
iRawlen = 4; /* fill the size & output buffer */
7914
*pRawdata = pSBIT->aBits[0];
7915
*(pRawdata+1) = pSBIT->aBits[1];
7916
*(pRawdata+2) = pSBIT->aBits[2];
7917
*(pRawdata+3) = pSBIT->aBits[3];
7918
7919
break;
7920
}
7921
case 10: { /* jpeg gray */
7922
iRawlen = 1; /* fill the size & output buffer */
7923
*pRawdata = pSBIT->aBits[0];
7924
7925
break;
7926
}
7927
case 12: { /* jpeg rgb */
7928
iRawlen = 3; /* fill the size & output buffer */
7929
*pRawdata = pSBIT->aBits[0];
7930
*(pRawdata+1) = pSBIT->aBits[1];
7931
*(pRawdata+2) = pSBIT->aBits[2];
7932
7933
break;
7934
}
7935
case 14: { /* jpeg gray + alpha */
7936
iRawlen = 2; /* fill the size & output buffer */
7937
*pRawdata = pSBIT->aBits[0];
7938
*(pRawdata+1) = pSBIT->aBits[1];
7939
7940
break;
7941
}
7942
case 16: { /* jpeg rgb + alpha */
7943
iRawlen = 4; /* fill the size & output buffer */
7944
*pRawdata = pSBIT->aBits[0];
7945
*(pRawdata+1) = pSBIT->aBits[1];
7946
*(pRawdata+2) = pSBIT->aBits[2];
7947
*(pRawdata+3) = pSBIT->aBits[3];
7948
7949
break;
7950
}
7951
}
7952
/* and write it */
7953
iRetcode = write_raw_chunk (pData, pSBIT->sHeader.iChunkname,
7954
iRawlen, pRawdata);
7955
}
7956
7957
#ifdef MNG_SUPPORT_TRACE
7958
MNG_TRACE (pData, MNG_FN_WRITE_SBIT, MNG_LC_END)
7959
#endif
7960
7961
return iRetcode;
7962
}
7963
#endif
7964
7965
/* ************************************************************************** */
7966
7967
#ifndef MNG_SKIPCHUNK_sPLT
7968
WRITE_CHUNK (mng_write_splt)
7969
{
7970
mng_spltp pSPLT;
7971
mng_uint8p pRawdata;
7972
mng_uint32 iRawlen;
7973
mng_retcode iRetcode;
7974
mng_uint32 iEntrieslen;
7975
mng_uint8p pTemp;
7976
7977
#ifdef MNG_SUPPORT_TRACE
7978
MNG_TRACE (pData, MNG_FN_WRITE_SPLT, MNG_LC_START)
7979
#endif
7980
7981
pSPLT = (mng_spltp)pChunk; /* address the proper chunk */
7982
7983
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7984
iEntrieslen = ((pSPLT->iSampledepth >> 3) * 4 + 2) * pSPLT->iEntrycount;
7985
iRawlen = pSPLT->iNamesize + 2 + iEntrieslen;
7986
/* requires large buffer ? */
7987
if (iRawlen > pData->iWritebufsize)
7988
MNG_ALLOC (pData, pRawdata, iRawlen)
7989
7990
pTemp = pRawdata; /* fill the buffer */
7991
7992
if (pSPLT->iNamesize)
7993
{
7994
MNG_COPY (pTemp, pSPLT->zName, pSPLT->iNamesize)
7995
pTemp += pSPLT->iNamesize;
7996
}
7997
7998
*pTemp = 0;
7999
*(pTemp+1) = pSPLT->iSampledepth;
8000
pTemp += 2;
8001
8002
if (pSPLT->iEntrycount)
8003
MNG_COPY (pTemp, pSPLT->pEntries, iEntrieslen)
8004
/* and write it */
8005
iRetcode = write_raw_chunk (pData, pSPLT->sHeader.iChunkname,
8006
iRawlen, pRawdata);
8007
8008
if (iRawlen > pData->iWritebufsize) /* drop the temp buffer ? */
8009
MNG_FREEX (pData, pRawdata, iRawlen)
8010
8011
#ifdef MNG_SUPPORT_TRACE
8012
MNG_TRACE (pData, MNG_FN_WRITE_SPLT, MNG_LC_END)
8013
#endif
8014
8015
return iRetcode;
8016
}
8017
#endif
8018
8019
/* ************************************************************************** */
8020
8021
#ifndef MNG_SKIPCHUNK_hIST
8022
WRITE_CHUNK (mng_write_hist)
8023
{
8024
mng_histp pHIST;
8025
mng_uint8p pRawdata;
8026
mng_uint32 iRawlen;
8027
mng_retcode iRetcode;
8028
mng_uint8p pTemp;
8029
mng_uint32 iX;
8030
8031
#ifdef MNG_SUPPORT_TRACE
8032
MNG_TRACE (pData, MNG_FN_WRITE_HIST, MNG_LC_START)
8033
#endif
8034
8035
pHIST = (mng_histp)pChunk; /* address the proper chunk */
8036
8037
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8038
iRawlen = pHIST->iEntrycount << 1;
8039
8040
pTemp = pRawdata; /* fill the output buffer */
8041
8042
for (iX = 0; iX < pHIST->iEntrycount; iX++)
8043
{
8044
mng_put_uint16 (pTemp, pHIST->aEntries [iX]);
8045
pTemp += 2;
8046
}
8047
/* and write it */
8048
iRetcode = write_raw_chunk (pData, pHIST->sHeader.iChunkname,
8049
iRawlen, pRawdata);
8050
8051
#ifdef MNG_SUPPORT_TRACE
8052
MNG_TRACE (pData, MNG_FN_WRITE_HIST, MNG_LC_END)
8053
#endif
8054
8055
return iRetcode;
8056
}
8057
#endif
8058
8059
/* ************************************************************************** */
8060
8061
#ifndef MNG_SKIPCHUNK_tIME
8062
WRITE_CHUNK (mng_write_time)
8063
{
8064
mng_timep pTIME;
8065
mng_uint8p pRawdata;
8066
mng_uint32 iRawlen;
8067
mng_retcode iRetcode;
8068
8069
#ifdef MNG_SUPPORT_TRACE
8070
MNG_TRACE (pData, MNG_FN_WRITE_TIME, MNG_LC_START)
8071
#endif
8072
8073
pTIME = (mng_timep)pChunk; /* address the proper chunk */
8074
8075
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8076
iRawlen = 7;
8077
/* fill the output buffer */
8078
mng_put_uint16 (pRawdata, pTIME->iYear);
8079
8080
*(pRawdata+2) = pTIME->iMonth;
8081
*(pRawdata+3) = pTIME->iDay;
8082
*(pRawdata+4) = pTIME->iHour;
8083
*(pRawdata+5) = pTIME->iMinute;
8084
*(pRawdata+6) = pTIME->iSecond;
8085
/* and write it */
8086
iRetcode = write_raw_chunk (pData, pTIME->sHeader.iChunkname,
8087
iRawlen, pRawdata);
8088
8089
#ifdef MNG_SUPPORT_TRACE
8090
MNG_TRACE (pData, MNG_FN_WRITE_TIME, MNG_LC_END)
8091
#endif
8092
8093
return iRetcode;
8094
}
8095
#endif
8096
8097
/* ************************************************************************** */
8098
8099
WRITE_CHUNK (mng_write_mhdr)
8100
{
8101
mng_mhdrp pMHDR;
8102
mng_uint8p pRawdata;
8103
mng_uint32 iRawlen;
8104
mng_retcode iRetcode;
8105
8106
#ifdef MNG_SUPPORT_TRACE
8107
MNG_TRACE (pData, MNG_FN_WRITE_MHDR, MNG_LC_START)
8108
#endif
8109
8110
pMHDR = (mng_mhdrp)pChunk; /* address the proper chunk */
8111
8112
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8113
iRawlen = 28;
8114
/* fill the output buffer */
8115
mng_put_uint32 (pRawdata, pMHDR->iWidth);
8116
mng_put_uint32 (pRawdata+4, pMHDR->iHeight);
8117
mng_put_uint32 (pRawdata+8, pMHDR->iTicks);
8118
mng_put_uint32 (pRawdata+12, pMHDR->iLayercount);
8119
mng_put_uint32 (pRawdata+16, pMHDR->iFramecount);
8120
mng_put_uint32 (pRawdata+20, pMHDR->iPlaytime);
8121
mng_put_uint32 (pRawdata+24, pMHDR->iSimplicity);
8122
8123
/* and write it */
8124
iRetcode = write_raw_chunk (pData, pMHDR->sHeader.iChunkname,
8125
iRawlen, pRawdata);
8126
8127
#ifdef MNG_SUPPORT_TRACE
8128
MNG_TRACE (pData, MNG_FN_WRITE_MHDR, MNG_LC_END)
8129
#endif
8130
8131
return iRetcode;
8132
}
8133
8134
/* ************************************************************************** */
8135
8136
WRITE_CHUNK (mng_write_mend)
8137
{
8138
mng_mendp pMEND;
8139
mng_retcode iRetcode;
8140
8141
#ifdef MNG_SUPPORT_TRACE
8142
MNG_TRACE (pData, MNG_FN_WRITE_MEND, MNG_LC_START)
8143
#endif
8144
8145
pMEND = (mng_mendp)pChunk; /* address the proper chunk */
8146
/* and write it */
8147
iRetcode = write_raw_chunk (pData, pMEND->sHeader.iChunkname, 0, 0);
8148
8149
#ifdef MNG_SUPPORT_TRACE
8150
MNG_TRACE (pData, MNG_FN_WRITE_MEND, MNG_LC_END)
8151
#endif
8152
8153
return iRetcode;
8154
}
8155
8156
/* ************************************************************************** */
8157
8158
WRITE_CHUNK (mng_write_loop)
8159
{
8160
mng_loopp pLOOP;
8161
mng_uint8p pRawdata;
8162
mng_uint32 iRawlen;
8163
mng_retcode iRetcode;
8164
#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
8165
mng_uint8p pTemp1;
8166
mng_uint32p pTemp2;
8167
mng_uint32 iX;
8168
#endif
8169
8170
#ifdef MNG_SUPPORT_TRACE
8171
MNG_TRACE (pData, MNG_FN_WRITE_LOOP, MNG_LC_START)
8172
#endif
8173
8174
pLOOP = (mng_loopp)pChunk; /* address the proper chunk */
8175
8176
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8177
iRawlen = 5;
8178
/* fill the output buffer */
8179
*pRawdata = pLOOP->iLevel;
8180
mng_put_uint32 (pRawdata+1, pLOOP->iRepeat);
8181
8182
if (pLOOP->iTermination)
8183
{
8184
iRawlen++;
8185
*(pRawdata+5) = pLOOP->iTermination;
8186
8187
if ((pLOOP->iCount) ||
8188
(pLOOP->iItermin != 1) || (pLOOP->iItermax != 0x7FFFFFFFL))
8189
{
8190
iRawlen += 8;
8191
8192
mng_put_uint32 (pRawdata+6, pLOOP->iItermin);
8193
mng_put_uint32 (pRawdata+10, pLOOP->iItermax);
8194
8195
#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
8196
if (pLOOP->iCount)
8197
{
8198
iRawlen += pLOOP->iCount * 4;
8199
8200
pTemp1 = pRawdata+14;
8201
pTemp2 = pLOOP->pSignals;
8202
8203
for (iX = 0; iX < pLOOP->iCount; iX++)
8204
{
8205
mng_put_uint32 (pTemp1, *pTemp2);
8206
8207
pTemp1 += 4;
8208
pTemp2++;
8209
}
8210
}
8211
#endif
8212
}
8213
}
8214
/* and write it */
8215
iRetcode = write_raw_chunk (pData, pLOOP->sHeader.iChunkname,
8216
iRawlen, pRawdata);
8217
8218
#ifdef MNG_SUPPORT_TRACE
8219
MNG_TRACE (pData, MNG_FN_WRITE_LOOP, MNG_LC_END)
8220
#endif
8221
8222
return iRetcode;
8223
}
8224
8225
/* ************************************************************************** */
8226
8227
WRITE_CHUNK (mng_write_endl)
8228
{
8229
mng_endlp pENDL;
8230
mng_uint8p pRawdata;
8231
mng_uint32 iRawlen;
8232
mng_retcode iRetcode;
8233
8234
#ifdef MNG_SUPPORT_TRACE
8235
MNG_TRACE (pData, MNG_FN_WRITE_ENDL, MNG_LC_START)
8236
#endif
8237
8238
pENDL = (mng_endlp)pChunk; /* address the proper chunk */
8239
8240
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8241
iRawlen = 1;
8242
8243
*pRawdata = pENDL->iLevel; /* fill the output buffer */
8244
/* and write it */
8245
iRetcode = write_raw_chunk (pData, pENDL->sHeader.iChunkname,
8246
iRawlen, pRawdata);
8247
8248
#ifdef MNG_SUPPORT_TRACE
8249
MNG_TRACE (pData, MNG_FN_WRITE_ENDL, MNG_LC_END)
8250
#endif
8251
8252
return iRetcode;
8253
}
8254
8255
/* ************************************************************************** */
8256
8257
WRITE_CHUNK (mng_write_defi)
8258
{
8259
mng_defip pDEFI;
8260
mng_uint8p pRawdata;
8261
mng_uint32 iRawlen;
8262
mng_retcode iRetcode;
8263
8264
#ifdef MNG_SUPPORT_TRACE
8265
MNG_TRACE (pData, MNG_FN_WRITE_DEFI, MNG_LC_START)
8266
#endif
8267
8268
pDEFI = (mng_defip)pChunk; /* address the proper chunk */
8269
8270
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8271
iRawlen = 2;
8272
/* fill the output buffer */
8273
mng_put_uint16 (pRawdata, pDEFI->iObjectid);
8274
8275
if ((pDEFI->iDonotshow) || (pDEFI->iConcrete) || (pDEFI->bHasloca) || (pDEFI->bHasclip))
8276
{
8277
iRawlen++;
8278
*(pRawdata+2) = pDEFI->iDonotshow;
8279
8280
if ((pDEFI->iConcrete) || (pDEFI->bHasloca) || (pDEFI->bHasclip))
8281
{
8282
iRawlen++;
8283
*(pRawdata+3) = pDEFI->iConcrete;
8284
8285
if ((pDEFI->bHasloca) || (pDEFI->bHasclip))
8286
{
8287
iRawlen += 8;
8288
8289
mng_put_uint32 (pRawdata+4, pDEFI->iXlocation);
8290
mng_put_uint32 (pRawdata+8, pDEFI->iYlocation);
8291
8292
if (pDEFI->bHasclip)
8293
{
8294
iRawlen += 16;
8295
8296
mng_put_uint32 (pRawdata+12, pDEFI->iLeftcb);
8297
mng_put_uint32 (pRawdata+16, pDEFI->iRightcb);
8298
mng_put_uint32 (pRawdata+20, pDEFI->iTopcb);
8299
mng_put_uint32 (pRawdata+24, pDEFI->iBottomcb);
8300
}
8301
}
8302
}
8303
}
8304
/* and write it */
8305
iRetcode = write_raw_chunk (pData, pDEFI->sHeader.iChunkname,
8306
iRawlen, pRawdata);
8307
8308
#ifdef MNG_SUPPORT_TRACE
8309
MNG_TRACE (pData, MNG_FN_WRITE_DEFI, MNG_LC_END)
8310
#endif
8311
8312
return iRetcode;
8313
}
8314
8315
/* ************************************************************************** */
8316
8317
WRITE_CHUNK (mng_write_basi)
8318
{
8319
mng_basip pBASI;
8320
mng_uint8p pRawdata;
8321
mng_uint32 iRawlen;
8322
mng_retcode iRetcode;
8323
mng_bool bOpaque;
8324
8325
#ifdef MNG_SUPPORT_TRACE
8326
MNG_TRACE (pData, MNG_FN_WRITE_BASI, MNG_LC_START)
8327
#endif
8328
8329
pBASI = (mng_basip)pChunk; /* address the proper chunk */
8330
8331
#ifndef MNG_NO_16BIT_SUPPORT
8332
if (pBASI->iBitdepth <= 8) /* determine opacity alpha-field */
8333
#endif
8334
bOpaque = (mng_bool)(pBASI->iAlpha == 0xFF);
8335
#ifndef MNG_NO_16BIT_SUPPORT
8336
else
8337
bOpaque = (mng_bool)(pBASI->iAlpha == 0xFFFF);
8338
#endif
8339
8340
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8341
iRawlen = 13;
8342
/* fill the output buffer */
8343
mng_put_uint32 (pRawdata, pBASI->iWidth);
8344
mng_put_uint32 (pRawdata+4, pBASI->iHeight);
8345
8346
*(pRawdata+8) = pBASI->iBitdepth;
8347
*(pRawdata+9) = pBASI->iColortype;
8348
*(pRawdata+10) = pBASI->iCompression;
8349
*(pRawdata+11) = pBASI->iFilter;
8350
*(pRawdata+12) = pBASI->iInterlace;
8351
8352
if ((pBASI->iRed) || (pBASI->iGreen) || (pBASI->iBlue) ||
8353
(!bOpaque) || (pBASI->iViewable))
8354
{
8355
iRawlen += 6;
8356
mng_put_uint16 (pRawdata+13, pBASI->iRed);
8357
mng_put_uint16 (pRawdata+15, pBASI->iGreen);
8358
mng_put_uint16 (pRawdata+17, pBASI->iBlue);
8359
8360
if ((!bOpaque) || (pBASI->iViewable))
8361
{
8362
iRawlen += 2;
8363
mng_put_uint16 (pRawdata+19, pBASI->iAlpha);
8364
8365
if (pBASI->iViewable)
8366
{
8367
iRawlen++;
8368
*(pRawdata+21) = pBASI->iViewable;
8369
}
8370
}
8371
}
8372
/* and write it */
8373
iRetcode = write_raw_chunk (pData, pBASI->sHeader.iChunkname,
8374
iRawlen, pRawdata);
8375
8376
#ifdef MNG_SUPPORT_TRACE
8377
MNG_TRACE (pData, MNG_FN_WRITE_BASI, MNG_LC_END)
8378
#endif
8379
8380
return iRetcode;
8381
}
8382
8383
/* ************************************************************************** */
8384
8385
WRITE_CHUNK (mng_write_clon)
8386
{
8387
mng_clonp pCLON;
8388
mng_uint8p pRawdata;
8389
mng_uint32 iRawlen;
8390
mng_retcode iRetcode;
8391
8392
#ifdef MNG_SUPPORT_TRACE
8393
MNG_TRACE (pData, MNG_FN_WRITE_CLON, MNG_LC_START)
8394
#endif
8395
8396
pCLON = (mng_clonp)pChunk; /* address the proper chunk */
8397
8398
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8399
iRawlen = 4;
8400
/* fill the output buffer */
8401
mng_put_uint16 (pRawdata, pCLON->iSourceid);
8402
mng_put_uint16 (pRawdata+2, pCLON->iCloneid);
8403
8404
if ((pCLON->iClonetype) || (pCLON->iDonotshow) || (pCLON->iConcrete) || (pCLON->bHasloca))
8405
{
8406
iRawlen++;
8407
*(pRawdata+4) = pCLON->iClonetype;
8408
8409
if ((pCLON->iDonotshow) || (pCLON->iConcrete) || (pCLON->bHasloca))
8410
{
8411
iRawlen++;
8412
*(pRawdata+5) = pCLON->iDonotshow;
8413
8414
if ((pCLON->iConcrete) || (pCLON->bHasloca))
8415
{
8416
iRawlen++;
8417
*(pRawdata+6) = pCLON->iConcrete;
8418
8419
if (pCLON->bHasloca)
8420
{
8421
iRawlen += 9;
8422
*(pRawdata+7) = pCLON->iLocationtype;
8423
mng_put_int32 (pRawdata+8, pCLON->iLocationx);
8424
mng_put_int32 (pRawdata+12, pCLON->iLocationy);
8425
}
8426
}
8427
}
8428
}
8429
/* and write it */
8430
iRetcode = write_raw_chunk (pData, pCLON->sHeader.iChunkname,
8431
iRawlen, pRawdata);
8432
8433
#ifdef MNG_SUPPORT_TRACE
8434
MNG_TRACE (pData, MNG_FN_WRITE_CLON, MNG_LC_END)
8435
#endif
8436
8437
return iRetcode;
8438
}
8439
8440
/* ************************************************************************** */
8441
8442
#ifndef MNG_SKIPCHUNK_PAST
8443
WRITE_CHUNK (mng_write_past)
8444
{
8445
mng_pastp pPAST;
8446
mng_uint8p pRawdata;
8447
mng_uint32 iRawlen;
8448
mng_retcode iRetcode;
8449
mng_past_sourcep pSource;
8450
mng_uint32 iX;
8451
mng_uint8p pTemp;
8452
8453
#ifdef MNG_SUPPORT_TRACE
8454
MNG_TRACE (pData, MNG_FN_WRITE_PAST, MNG_LC_START)
8455
#endif
8456
8457
pPAST = (mng_pastp)pChunk; /* address the proper chunk */
8458
8459
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8460
iRawlen = 11 + (30 * pPAST->iCount);
8461
/* requires large buffer ? */
8462
if (iRawlen > pData->iWritebufsize)
8463
MNG_ALLOC (pData, pRawdata, iRawlen)
8464
/* fill the output buffer */
8465
mng_put_uint16 (pRawdata, pPAST->iDestid);
8466
8467
*(pRawdata+2) = pPAST->iTargettype;
8468
8469
mng_put_int32 (pRawdata+3, pPAST->iTargetx);
8470
mng_put_int32 (pRawdata+7, pPAST->iTargety);
8471
8472
pTemp = pRawdata+11;
8473
pSource = pPAST->pSources;
8474
8475
for (iX = 0; iX < pPAST->iCount; iX++)
8476
{
8477
mng_put_uint16 (pTemp, pSource->iSourceid);
8478
8479
*(pTemp+2) = pSource->iComposition;
8480
*(pTemp+3) = pSource->iOrientation;
8481
*(pTemp+4) = pSource->iOffsettype;
8482
8483
mng_put_int32 (pTemp+5, pSource->iOffsetx);
8484
mng_put_int32 (pTemp+9, pSource->iOffsety);
8485
8486
*(pTemp+13) = pSource->iBoundarytype;
8487
8488
mng_put_int32 (pTemp+14, pSource->iBoundaryl);
8489
mng_put_int32 (pTemp+18, pSource->iBoundaryr);
8490
mng_put_int32 (pTemp+22, pSource->iBoundaryt);
8491
mng_put_int32 (pTemp+26, pSource->iBoundaryb);
8492
8493
pSource++;
8494
pTemp += 30;
8495
}
8496
/* and write it */
8497
iRetcode = write_raw_chunk (pData, pPAST->sHeader.iChunkname,
8498
iRawlen, pRawdata);
8499
/* free temporary buffer ? */
8500
if (iRawlen > pData->iWritebufsize)
8501
MNG_FREEX (pData, pRawdata, iRawlen)
8502
8503
#ifdef MNG_SUPPORT_TRACE
8504
MNG_TRACE (pData, MNG_FN_WRITE_PAST, MNG_LC_END)
8505
#endif
8506
8507
return iRetcode;
8508
}
8509
#endif
8510
8511
/* ************************************************************************** */
8512
8513
WRITE_CHUNK (mng_write_disc)
8514
{
8515
mng_discp pDISC;
8516
mng_uint8p pRawdata;
8517
mng_uint32 iRawlen;
8518
mng_retcode iRetcode;
8519
mng_uint32 iX;
8520
mng_uint8p pTemp1;
8521
mng_uint16p pTemp2;
8522
8523
#ifdef MNG_SUPPORT_TRACE
8524
MNG_TRACE (pData, MNG_FN_WRITE_DISC, MNG_LC_START)
8525
#endif
8526
8527
pDISC = (mng_discp)pChunk; /* address the proper chunk */
8528
8529
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8530
iRawlen = pDISC->iCount << 1;
8531
8532
pTemp1 = pRawdata; /* fill the output buffer */
8533
pTemp2 = pDISC->pObjectids;
8534
8535
for (iX = 0; iX < pDISC->iCount; iX++)
8536
{
8537
mng_put_uint16 (pTemp1, *pTemp2);
8538
8539
pTemp2++;
8540
pTemp1 += 2;
8541
}
8542
/* and write it */
8543
iRetcode = write_raw_chunk (pData, pDISC->sHeader.iChunkname,
8544
iRawlen, pRawdata);
8545
8546
#ifdef MNG_SUPPORT_TRACE
8547
MNG_TRACE (pData, MNG_FN_WRITE_DISC, MNG_LC_END)
8548
#endif
8549
8550
return iRetcode;
8551
}
8552
8553
/* ************************************************************************** */
8554
8555
WRITE_CHUNK (mng_write_back)
8556
{
8557
mng_backp pBACK;
8558
mng_uint8p pRawdata;
8559
mng_uint32 iRawlen;
8560
mng_retcode iRetcode;
8561
8562
#ifdef MNG_SUPPORT_TRACE
8563
MNG_TRACE (pData, MNG_FN_WRITE_BACK, MNG_LC_START)
8564
#endif
8565
8566
pBACK = (mng_backp)pChunk; /* address the proper chunk */
8567
8568
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8569
iRawlen = 6;
8570
/* fill the output buffer */
8571
mng_put_uint16 (pRawdata, pBACK->iRed);
8572
mng_put_uint16 (pRawdata+2, pBACK->iGreen);
8573
mng_put_uint16 (pRawdata+4, pBACK->iBlue);
8574
8575
if ((pBACK->iMandatory) || (pBACK->iImageid) || (pBACK->iTile))
8576
{
8577
iRawlen++;
8578
*(pRawdata+6) = pBACK->iMandatory;
8579
8580
if ((pBACK->iImageid) || (pBACK->iTile))
8581
{
8582
iRawlen += 2;
8583
mng_put_uint16 (pRawdata+7, pBACK->iImageid);
8584
8585
if (pBACK->iTile)
8586
{
8587
iRawlen++;
8588
*(pRawdata+9) = pBACK->iTile;
8589
}
8590
}
8591
}
8592
/* and write it */
8593
iRetcode = write_raw_chunk (pData, pBACK->sHeader.iChunkname,
8594
iRawlen, pRawdata);
8595
8596
#ifdef MNG_SUPPORT_TRACE
8597
MNG_TRACE (pData, MNG_FN_WRITE_BACK, MNG_LC_END)
8598
#endif
8599
8600
return iRetcode;
8601
}
8602
8603
/* ************************************************************************** */
8604
8605
WRITE_CHUNK (mng_write_fram)
8606
{
8607
mng_framp pFRAM;
8608
mng_uint8p pRawdata;
8609
mng_uint32 iRawlen;
8610
mng_retcode iRetcode;
8611
mng_uint8p pTemp;
8612
mng_uint32p pTemp2;
8613
mng_uint32 iX;
8614
8615
#ifdef MNG_SUPPORT_TRACE
8616
MNG_TRACE (pData, MNG_FN_WRITE_FRAM, MNG_LC_START)
8617
#endif
8618
8619
pFRAM = (mng_framp)pChunk; /* address the proper chunk */
8620
8621
if (pFRAM->bEmpty) /* empty ? */
8622
iRetcode = write_raw_chunk (pData, pFRAM->sHeader.iChunkname, 0, 0);
8623
else
8624
{
8625
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8626
iRawlen = 1;
8627
/* fill the output buffer */
8628
*pRawdata = pFRAM->iMode;
8629
8630
if ((pFRAM->iNamesize ) ||
8631
(pFRAM->iChangedelay ) || (pFRAM->iChangetimeout) ||
8632
(pFRAM->iChangeclipping) || (pFRAM->iChangesyncid ) )
8633
{
8634
if (pFRAM->iNamesize)
8635
MNG_COPY (pRawdata+1, pFRAM->zName, pFRAM->iNamesize)
8636
8637
iRawlen += pFRAM->iNamesize;
8638
pTemp = pRawdata + pFRAM->iNamesize + 1;
8639
8640
if ((pFRAM->iChangedelay ) || (pFRAM->iChangetimeout) ||
8641
(pFRAM->iChangeclipping) || (pFRAM->iChangesyncid ) )
8642
{
8643
*pTemp = 0;
8644
*(pTemp+1) = pFRAM->iChangedelay;
8645
*(pTemp+2) = pFRAM->iChangetimeout;
8646
*(pTemp+3) = pFRAM->iChangeclipping;
8647
*(pTemp+4) = pFRAM->iChangesyncid;
8648
8649
iRawlen += 5;
8650
pTemp += 5;
8651
8652
if (pFRAM->iChangedelay)
8653
{
8654
mng_put_uint32 (pTemp, pFRAM->iDelay);
8655
iRawlen += 4;
8656
pTemp += 4;
8657
}
8658
8659
if (pFRAM->iChangetimeout)
8660
{
8661
mng_put_uint32 (pTemp, pFRAM->iTimeout);
8662
iRawlen += 4;
8663
pTemp += 4;
8664
}
8665
8666
if (pFRAM->iChangeclipping)
8667
{
8668
*pTemp = pFRAM->iBoundarytype;
8669
8670
mng_put_uint32 (pTemp+1, pFRAM->iBoundaryl);
8671
mng_put_uint32 (pTemp+5, pFRAM->iBoundaryr);
8672
mng_put_uint32 (pTemp+9, pFRAM->iBoundaryt);
8673
mng_put_uint32 (pTemp+13, pFRAM->iBoundaryb);
8674
8675
iRawlen += 17;
8676
pTemp += 17;
8677
}
8678
8679
if (pFRAM->iChangesyncid)
8680
{
8681
iRawlen += pFRAM->iCount * 4;
8682
pTemp2 = pFRAM->pSyncids;
8683
8684
for (iX = 0; iX < pFRAM->iCount; iX++)
8685
{
8686
mng_put_uint32 (pTemp, *pTemp2);
8687
8688
pTemp2++;
8689
pTemp += 4;
8690
}
8691
}
8692
}
8693
}
8694
/* and write it */
8695
iRetcode = write_raw_chunk (pData, pFRAM->sHeader.iChunkname,
8696
iRawlen, pRawdata);
8697
}
8698
8699
#ifdef MNG_SUPPORT_TRACE
8700
MNG_TRACE (pData, MNG_FN_WRITE_FRAM, MNG_LC_END)
8701
#endif
8702
8703
return iRetcode;
8704
}
8705
8706
/* ************************************************************************** */
8707
8708
WRITE_CHUNK (mng_write_move)
8709
{
8710
mng_movep pMOVE;
8711
mng_uint8p pRawdata;
8712
mng_uint32 iRawlen;
8713
mng_retcode iRetcode;
8714
8715
#ifdef MNG_SUPPORT_TRACE
8716
MNG_TRACE (pData, MNG_FN_WRITE_MOVE, MNG_LC_START)
8717
#endif
8718
8719
pMOVE = (mng_movep)pChunk; /* address the proper chunk */
8720
8721
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8722
iRawlen = 13;
8723
/* fill the output buffer */
8724
mng_put_uint16 (pRawdata, pMOVE->iFirstid);
8725
mng_put_uint16 (pRawdata+2, pMOVE->iLastid);
8726
8727
*(pRawdata+4) = pMOVE->iMovetype;
8728
8729
mng_put_int32 (pRawdata+5, pMOVE->iMovex);
8730
mng_put_int32 (pRawdata+9, pMOVE->iMovey);
8731
/* and write it */
8732
iRetcode = write_raw_chunk (pData, pMOVE->sHeader.iChunkname,
8733
iRawlen, pRawdata);
8734
8735
#ifdef MNG_SUPPORT_TRACE
8736
MNG_TRACE (pData, MNG_FN_WRITE_MOVE, MNG_LC_END)
8737
#endif
8738
8739
return iRetcode;
8740
}
8741
8742
/* ************************************************************************** */
8743
8744
WRITE_CHUNK (mng_write_clip)
8745
{
8746
mng_clipp pCLIP;
8747
mng_uint8p pRawdata;
8748
mng_uint32 iRawlen;
8749
mng_retcode iRetcode;
8750
8751
#ifdef MNG_SUPPORT_TRACE
8752
MNG_TRACE (pData, MNG_FN_WRITE_CLIP, MNG_LC_START)
8753
#endif
8754
8755
pCLIP = (mng_clipp)pChunk; /* address the proper chunk */
8756
8757
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8758
iRawlen = 21;
8759
/* fill the output buffer */
8760
mng_put_uint16 (pRawdata, pCLIP->iFirstid);
8761
mng_put_uint16 (pRawdata+2, pCLIP->iLastid);
8762
8763
*(pRawdata+4) = pCLIP->iCliptype;
8764
8765
mng_put_int32 (pRawdata+5, pCLIP->iClipl);
8766
mng_put_int32 (pRawdata+9, pCLIP->iClipr);
8767
mng_put_int32 (pRawdata+13, pCLIP->iClipt);
8768
mng_put_int32 (pRawdata+17, pCLIP->iClipb);
8769
/* and write it */
8770
iRetcode = write_raw_chunk (pData, pCLIP->sHeader.iChunkname,
8771
iRawlen, pRawdata);
8772
8773
#ifdef MNG_SUPPORT_TRACE
8774
MNG_TRACE (pData, MNG_FN_WRITE_CLIP, MNG_LC_END)
8775
#endif
8776
8777
return iRetcode;
8778
}
8779
8780
/* ************************************************************************** */
8781
8782
WRITE_CHUNK (mng_write_show)
8783
{
8784
mng_showp pSHOW;
8785
mng_uint8p pRawdata;
8786
mng_uint32 iRawlen;
8787
mng_retcode iRetcode;
8788
8789
#ifdef MNG_SUPPORT_TRACE
8790
MNG_TRACE (pData, MNG_FN_WRITE_SHOW, MNG_LC_START)
8791
#endif
8792
8793
pSHOW = (mng_showp)pChunk; /* address the proper chunk */
8794
8795
if (pSHOW->bEmpty) /* empty ? */
8796
iRetcode = write_raw_chunk (pData, pSHOW->sHeader.iChunkname, 0, 0);
8797
else
8798
{
8799
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8800
iRawlen = 2;
8801
/* fill the output buffer */
8802
mng_put_uint16 (pRawdata, pSHOW->iFirstid);
8803
8804
if ((pSHOW->iLastid != pSHOW->iFirstid) || (pSHOW->iMode))
8805
{
8806
iRawlen += 2;
8807
mng_put_uint16 (pRawdata+2, pSHOW->iLastid);
8808
8809
if (pSHOW->iMode)
8810
{
8811
iRawlen++;
8812
*(pRawdata+4) = pSHOW->iMode;
8813
}
8814
}
8815
/* and write it */
8816
iRetcode = write_raw_chunk (pData, pSHOW->sHeader.iChunkname,
8817
iRawlen, pRawdata);
8818
}
8819
8820
#ifdef MNG_SUPPORT_TRACE
8821
MNG_TRACE (pData, MNG_FN_WRITE_SHOW, MNG_LC_END)
8822
#endif
8823
8824
return iRetcode;
8825
}
8826
8827
/* ************************************************************************** */
8828
8829
WRITE_CHUNK (mng_write_term)
8830
{
8831
mng_termp pTERM;
8832
mng_uint8p pRawdata;
8833
mng_uint32 iRawlen;
8834
mng_retcode iRetcode;
8835
8836
#ifdef MNG_SUPPORT_TRACE
8837
MNG_TRACE (pData, MNG_FN_WRITE_TERM, MNG_LC_START)
8838
#endif
8839
8840
pTERM = (mng_termp)pChunk; /* address the proper chunk */
8841
8842
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8843
iRawlen = 1;
8844
8845
*pRawdata = pTERM->iTermaction; /* fill the output buffer */
8846
8847
if (pTERM->iTermaction == 3)
8848
{
8849
iRawlen = 10;
8850
*(pRawdata+1) = pTERM->iIteraction;
8851
8852
mng_put_uint32 (pRawdata+2, pTERM->iDelay);
8853
mng_put_uint32 (pRawdata+6, pTERM->iItermax);
8854
}
8855
/* and write it */
8856
iRetcode = write_raw_chunk (pData, pTERM->sHeader.iChunkname,
8857
iRawlen, pRawdata);
8858
8859
#ifdef MNG_SUPPORT_TRACE
8860
MNG_TRACE (pData, MNG_FN_WRITE_TERM, MNG_LC_END)
8861
#endif
8862
8863
return iRetcode;
8864
}
8865
8866
/* ************************************************************************** */
8867
8868
#ifndef MNG_SKIPCHUNK_SAVE
8869
WRITE_CHUNK (mng_write_save)
8870
{
8871
mng_savep pSAVE;
8872
mng_uint8p pRawdata;
8873
mng_uint32 iRawlen;
8874
mng_retcode iRetcode;
8875
mng_save_entryp pEntry;
8876
mng_uint32 iEntrysize;
8877
mng_uint8p pTemp;
8878
mng_uint32 iX;
8879
8880
#ifdef MNG_SUPPORT_TRACE
8881
MNG_TRACE (pData, MNG_FN_WRITE_SAVE, MNG_LC_START)
8882
#endif
8883
8884
pSAVE = (mng_savep)pChunk; /* address the proper chunk */
8885
8886
if (pSAVE->bEmpty) /* empty ? */
8887
iRetcode = write_raw_chunk (pData, pSAVE->sHeader.iChunkname, 0, 0);
8888
else
8889
{
8890
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8891
iRawlen = 1;
8892
8893
*pRawdata = pSAVE->iOffsettype; /* fill the output buffer */
8894
8895
if (pSAVE->iOffsettype == 16)
8896
iEntrysize = 25;
8897
else
8898
iEntrysize = 17;
8899
8900
pTemp = pRawdata+1;
8901
pEntry = pSAVE->pEntries;
8902
8903
for (iX = 0; iX < pSAVE->iCount; iX++)
8904
{
8905
if (iX) /* put separator null-byte, except the first */
8906
{
8907
*pTemp = 0;
8908
pTemp++;
8909
iRawlen++;
8910
}
8911
8912
iRawlen += iEntrysize + pEntry->iNamesize;
8913
*pTemp = pEntry->iEntrytype;
8914
8915
if (pSAVE->iOffsettype == 16)
8916
{
8917
mng_put_uint32 (pTemp+1, pEntry->iOffset[0]);
8918
mng_put_uint32 (pTemp+5, pEntry->iOffset[1]);
8919
mng_put_uint32 (pTemp+9, pEntry->iStarttime[0]);
8920
mng_put_uint32 (pTemp+13, pEntry->iStarttime[1]);
8921
mng_put_uint32 (pTemp+17, pEntry->iLayernr);
8922
mng_put_uint32 (pTemp+21, pEntry->iFramenr);
8923
8924
pTemp += 25;
8925
}
8926
else
8927
{
8928
mng_put_uint32 (pTemp+1, pEntry->iOffset[1]);
8929
mng_put_uint32 (pTemp+5, pEntry->iStarttime[1]);
8930
mng_put_uint32 (pTemp+9, pEntry->iLayernr);
8931
mng_put_uint32 (pTemp+13, pEntry->iFramenr);
8932
8933
pTemp += 17;
8934
}
8935
8936
if (pEntry->iNamesize)
8937
{
8938
MNG_COPY (pTemp, pEntry->zName, pEntry->iNamesize);
8939
pTemp += pEntry->iNamesize;
8940
}
8941
8942
pEntry++;
8943
}
8944
/* and write it */
8945
iRetcode = write_raw_chunk (pData, pSAVE->sHeader.iChunkname,
8946
iRawlen, pRawdata);
8947
}
8948
8949
#ifdef MNG_SUPPORT_TRACE
8950
MNG_TRACE (pData, MNG_FN_WRITE_SAVE, MNG_LC_END)
8951
#endif
8952
8953
return iRetcode;
8954
}
8955
#endif
8956
8957
/* ************************************************************************** */
8958
8959
#ifndef MNG_SKIPCHUNK_SEEK
8960
WRITE_CHUNK (mng_write_seek)
8961
{
8962
mng_seekp pSEEK;
8963
mng_uint8p pRawdata;
8964
mng_uint32 iRawlen;
8965
mng_retcode iRetcode;
8966
8967
#ifdef MNG_SUPPORT_TRACE
8968
MNG_TRACE (pData, MNG_FN_WRITE_SEEK, MNG_LC_START)
8969
#endif
8970
8971
pSEEK = (mng_seekp)pChunk; /* address the proper chunk */
8972
8973
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8974
iRawlen = pSEEK->iNamesize;
8975
8976
if (iRawlen) /* fill the output buffer */
8977
MNG_COPY (pRawdata, pSEEK->zName, iRawlen)
8978
/* and write it */
8979
iRetcode = write_raw_chunk (pData, pSEEK->sHeader.iChunkname,
8980
iRawlen, pRawdata);
8981
8982
#ifdef MNG_SUPPORT_TRACE
8983
MNG_TRACE (pData, MNG_FN_WRITE_SEEK, MNG_LC_END)
8984
#endif
8985
8986
return iRetcode;
8987
}
8988
#endif
8989
8990
/* ************************************************************************** */
8991
8992
#ifndef MNG_SKIPCHUNK_eXPI
8993
WRITE_CHUNK (mng_write_expi)
8994
{
8995
mng_expip pEXPI;
8996
mng_uint8p pRawdata;
8997
mng_uint32 iRawlen;
8998
mng_retcode iRetcode;
8999
9000
#ifdef MNG_SUPPORT_TRACE
9001
MNG_TRACE (pData, MNG_FN_WRITE_EXPI, MNG_LC_START)
9002
#endif
9003
9004
pEXPI = (mng_expip)pChunk; /* address the proper chunk */
9005
9006
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9007
iRawlen = 2 + pEXPI->iNamesize;
9008
/* fill the output buffer */
9009
mng_put_uint16 (pRawdata, pEXPI->iSnapshotid);
9010
9011
if (pEXPI->iNamesize)
9012
MNG_COPY (pRawdata+2, pEXPI->zName, pEXPI->iNamesize)
9013
/* and write it */
9014
iRetcode = write_raw_chunk (pData, pEXPI->sHeader.iChunkname,
9015
iRawlen, pRawdata);
9016
9017
#ifdef MNG_SUPPORT_TRACE
9018
MNG_TRACE (pData, MNG_FN_WRITE_EXPI, MNG_LC_END)
9019
#endif
9020
9021
return iRetcode;
9022
}
9023
#endif
9024
9025
/* ************************************************************************** */
9026
9027
#ifndef MNG_SKIPCHUNK_fPRI
9028
WRITE_CHUNK (mng_write_fpri)
9029
{
9030
mng_fprip pFPRI;
9031
mng_uint8p pRawdata;
9032
mng_uint32 iRawlen;
9033
mng_retcode iRetcode;
9034
9035
#ifdef MNG_SUPPORT_TRACE
9036
MNG_TRACE (pData, MNG_FN_WRITE_FPRI, MNG_LC_START)
9037
#endif
9038
9039
pFPRI = (mng_fprip)pChunk; /* address the proper chunk */
9040
9041
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9042
iRawlen = 2;
9043
9044
*pRawdata = pFPRI->iDeltatype; /* fill the output buffer */
9045
*(pRawdata+1) = pFPRI->iPriority;
9046
/* and write it */
9047
iRetcode = write_raw_chunk (pData, pFPRI->sHeader.iChunkname,
9048
iRawlen, pRawdata);
9049
9050
#ifdef MNG_SUPPORT_TRACE
9051
MNG_TRACE (pData, MNG_FN_WRITE_FPRI, MNG_LC_END)
9052
#endif
9053
9054
return iRetcode;
9055
}
9056
#endif
9057
9058
/* ************************************************************************** */
9059
9060
#ifndef MNG_SKIPCHUNK_nEED
9061
WRITE_CHUNK (mng_write_need)
9062
{
9063
mng_needp pNEED;
9064
mng_uint8p pRawdata;
9065
mng_uint32 iRawlen;
9066
mng_retcode iRetcode;
9067
9068
#ifdef MNG_SUPPORT_TRACE
9069
MNG_TRACE (pData, MNG_FN_WRITE_NEED, MNG_LC_START)
9070
#endif
9071
9072
pNEED = (mng_needp)pChunk; /* address the proper chunk */
9073
9074
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9075
iRawlen = pNEED->iKeywordssize;
9076
/* fill the output buffer */
9077
if (pNEED->iKeywordssize)
9078
MNG_COPY (pRawdata, pNEED->zKeywords, pNEED->iKeywordssize)
9079
/* and write it */
9080
iRetcode = write_raw_chunk (pData, pNEED->sHeader.iChunkname,
9081
iRawlen, pRawdata);
9082
9083
#ifdef MNG_SUPPORT_TRACE
9084
MNG_TRACE (pData, MNG_FN_WRITE_NEED, MNG_LC_END)
9085
#endif
9086
9087
return iRetcode;
9088
}
9089
#endif
9090
9091
/* ************************************************************************** */
9092
9093
#ifndef MNG_SKIPCHUNK_pHYg
9094
WRITE_CHUNK (mng_write_phyg)
9095
{
9096
mng_phygp pPHYG;
9097
mng_uint8p pRawdata;
9098
mng_uint32 iRawlen;
9099
mng_retcode iRetcode;
9100
9101
#ifdef MNG_SUPPORT_TRACE
9102
MNG_TRACE (pData, MNG_FN_WRITE_PHYG, MNG_LC_START)
9103
#endif
9104
9105
pPHYG = (mng_phygp)pChunk; /* address the proper chunk */
9106
9107
if (pPHYG->bEmpty) /* write empty ? */
9108
iRetcode = write_raw_chunk (pData, pPHYG->sHeader.iChunkname, 0, 0);
9109
else
9110
{
9111
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9112
iRawlen = 9;
9113
/* fill the output buffer */
9114
mng_put_uint32 (pRawdata, pPHYG->iSizex);
9115
mng_put_uint32 (pRawdata+4, pPHYG->iSizey);
9116
9117
*(pRawdata+8) = pPHYG->iUnit;
9118
/* and write it */
9119
iRetcode = write_raw_chunk (pData, pPHYG->sHeader.iChunkname,
9120
iRawlen, pRawdata);
9121
}
9122
9123
#ifdef MNG_SUPPORT_TRACE
9124
MNG_TRACE (pData, MNG_FN_WRITE_PHYG, MNG_LC_END)
9125
#endif
9126
9127
return iRetcode;
9128
}
9129
#endif
9130
9131
/* ************************************************************************** */
9132
9133
/* B004 */
9134
#ifdef MNG_INCLUDE_JNG
9135
/* B004 */
9136
WRITE_CHUNK (mng_write_jhdr)
9137
{
9138
mng_jhdrp pJHDR;
9139
mng_uint8p pRawdata;
9140
mng_uint32 iRawlen;
9141
mng_retcode iRetcode;
9142
9143
#ifdef MNG_SUPPORT_TRACE
9144
MNG_TRACE (pData, MNG_FN_WRITE_JHDR, MNG_LC_START)
9145
#endif
9146
9147
pJHDR = (mng_jhdrp)pChunk; /* address the proper chunk */
9148
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9149
iRawlen = 16;
9150
/* fill the output buffer */
9151
mng_put_uint32 (pRawdata, pJHDR->iWidth);
9152
mng_put_uint32 (pRawdata+4, pJHDR->iHeight);
9153
9154
*(pRawdata+8) = pJHDR->iColortype;
9155
*(pRawdata+9) = pJHDR->iImagesampledepth;
9156
*(pRawdata+10) = pJHDR->iImagecompression;
9157
*(pRawdata+11) = pJHDR->iImageinterlace;
9158
*(pRawdata+12) = pJHDR->iAlphasampledepth;
9159
*(pRawdata+13) = pJHDR->iAlphacompression;
9160
*(pRawdata+14) = pJHDR->iAlphafilter;
9161
*(pRawdata+15) = pJHDR->iAlphainterlace;
9162
/* and write it */
9163
iRetcode = write_raw_chunk (pData, pJHDR->sHeader.iChunkname, iRawlen, pRawdata);
9164
9165
#ifdef MNG_SUPPORT_TRACE
9166
MNG_TRACE (pData, MNG_FN_WRITE_JHDR, MNG_LC_END)
9167
#endif
9168
9169
return iRetcode;
9170
}
9171
#else
9172
#define write_jhdr 0
9173
/* B004 */
9174
#endif /* MNG_INCLUDE_JNG */
9175
/* B004 */
9176
9177
/* ************************************************************************** */
9178
9179
#ifdef MNG_INCLUDE_JNG
9180
WRITE_CHUNK (mng_write_jdaa)
9181
{
9182
mng_jdatp pJDAA;
9183
mng_retcode iRetcode;
9184
9185
#ifdef MNG_SUPPORT_TRACE
9186
MNG_TRACE (pData, MNG_FN_WRITE_JDAA, MNG_LC_START)
9187
#endif
9188
9189
pJDAA = (mng_jdaap)pChunk; /* address the proper chunk */
9190
9191
if (pJDAA->bEmpty) /* and write it */
9192
iRetcode = write_raw_chunk (pData, pJDAA->sHeader.iChunkname, 0, 0);
9193
else
9194
iRetcode = write_raw_chunk (pData, pJDAA->sHeader.iChunkname,
9195
pJDAA->iDatasize, pJDAA->pData);
9196
9197
#ifdef MNG_SUPPORT_TRACE
9198
MNG_TRACE (pData, MNG_FN_WRITE_JDAA, MNG_LC_END)
9199
#endif
9200
9201
return iRetcode;
9202
}
9203
#else
9204
#define write_jdaa 0
9205
#endif /* MNG_INCLUDE_JNG */
9206
9207
/* ************************************************************************** */
9208
9209
/* B004 */
9210
#ifdef MNG_INCLUDE_JNG
9211
/* B004 */
9212
WRITE_CHUNK (mng_write_jdat)
9213
{
9214
mng_jdatp pJDAT;
9215
mng_retcode iRetcode;
9216
9217
#ifdef MNG_SUPPORT_TRACE
9218
MNG_TRACE (pData, MNG_FN_WRITE_JDAT, MNG_LC_START)
9219
#endif
9220
9221
pJDAT = (mng_jdatp)pChunk; /* address the proper chunk */
9222
9223
if (pJDAT->bEmpty) /* and write it */
9224
iRetcode = write_raw_chunk (pData, pJDAT->sHeader.iChunkname, 0, 0);
9225
else
9226
iRetcode = write_raw_chunk (pData, pJDAT->sHeader.iChunkname,
9227
pJDAT->iDatasize, pJDAT->pData);
9228
9229
#ifdef MNG_SUPPORT_TRACE
9230
MNG_TRACE (pData, MNG_FN_WRITE_JDAT, MNG_LC_END)
9231
#endif
9232
9233
return iRetcode;
9234
}
9235
#else
9236
#define write_jdat 0
9237
/* B004 */
9238
#endif /* MNG_INCLUDE_JNG */
9239
/* B004 */
9240
9241
/* ************************************************************************** */
9242
9243
/* B004 */
9244
#ifdef MNG_INCLUDE_JNG
9245
/* B004 */
9246
WRITE_CHUNK (mng_write_jsep)
9247
{
9248
mng_jsepp pJSEP;
9249
mng_retcode iRetcode;
9250
9251
#ifdef MNG_SUPPORT_TRACE
9252
MNG_TRACE (pData, MNG_FN_WRITE_JSEP, MNG_LC_START)
9253
#endif
9254
9255
pJSEP = (mng_jsepp)pChunk; /* address the proper chunk */
9256
/* and write it */
9257
iRetcode = write_raw_chunk (pData, pJSEP->sHeader.iChunkname, 0, 0);
9258
9259
#ifdef MNG_SUPPORT_TRACE
9260
MNG_TRACE (pData, MNG_FN_WRITE_JSEP, MNG_LC_END)
9261
#endif
9262
9263
return iRetcode;
9264
}
9265
#else
9266
#define write_jsep 0
9267
/* B004 */
9268
#endif /* MNG_INCLUDE_JNG */
9269
/* B004 */
9270
9271
/* ************************************************************************** */
9272
9273
#ifndef MNG_NO_DELTA_PNG
9274
WRITE_CHUNK (mng_write_dhdr)
9275
{
9276
mng_dhdrp pDHDR;
9277
mng_uint8p pRawdata;
9278
mng_uint32 iRawlen;
9279
mng_retcode iRetcode;
9280
9281
#ifdef MNG_SUPPORT_TRACE
9282
MNG_TRACE (pData, MNG_FN_WRITE_DHDR, MNG_LC_START)
9283
#endif
9284
9285
pDHDR = (mng_dhdrp)pChunk; /* address the proper chunk */
9286
9287
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9288
iRawlen = 4;
9289
/* fill the output buffer */
9290
mng_put_uint16 (pRawdata, pDHDR->iObjectid);
9291
9292
*(pRawdata+2) = pDHDR->iImagetype;
9293
*(pRawdata+3) = pDHDR->iDeltatype;
9294
9295
if (pDHDR->iDeltatype != 7)
9296
{
9297
iRawlen += 8;
9298
mng_put_uint32 (pRawdata+4, pDHDR->iBlockwidth);
9299
mng_put_uint32 (pRawdata+8, pDHDR->iBlockheight);
9300
9301
if (pDHDR->iDeltatype != 0)
9302
{
9303
iRawlen += 8;
9304
mng_put_uint32 (pRawdata+12, pDHDR->iBlockx);
9305
mng_put_uint32 (pRawdata+16, pDHDR->iBlocky);
9306
}
9307
}
9308
/* and write it */
9309
iRetcode = write_raw_chunk (pData, pDHDR->sHeader.iChunkname,
9310
iRawlen, pRawdata);
9311
9312
#ifdef MNG_SUPPORT_TRACE
9313
MNG_TRACE (pData, MNG_FN_WRITE_DHDR, MNG_LC_END)
9314
#endif
9315
9316
return iRetcode;
9317
}
9318
#endif
9319
9320
/* ************************************************************************** */
9321
9322
#ifndef MNG_NO_DELTA_PNG
9323
WRITE_CHUNK (mng_write_prom)
9324
{
9325
mng_promp pPROM;
9326
mng_uint8p pRawdata;
9327
mng_uint32 iRawlen;
9328
mng_retcode iRetcode;
9329
9330
#ifdef MNG_SUPPORT_TRACE
9331
MNG_TRACE (pData, MNG_FN_WRITE_PROM, MNG_LC_START)
9332
#endif
9333
9334
pPROM = (mng_promp)pChunk; /* address the proper chunk */
9335
9336
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9337
iRawlen = 3;
9338
9339
*pRawdata = pPROM->iColortype; /* fill the output buffer */
9340
*(pRawdata+1) = pPROM->iSampledepth;
9341
*(pRawdata+2) = pPROM->iFilltype;
9342
/* and write it */
9343
iRetcode = write_raw_chunk (pData, pPROM->sHeader.iChunkname,
9344
iRawlen, pRawdata);
9345
9346
#ifdef MNG_SUPPORT_TRACE
9347
MNG_TRACE (pData, MNG_FN_WRITE_PROM, MNG_LC_END)
9348
#endif
9349
9350
return iRetcode;
9351
}
9352
#endif
9353
9354
/* ************************************************************************** */
9355
9356
#ifndef MNG_NO_DELTA_PNG
9357
WRITE_CHUNK (mng_write_ipng)
9358
{
9359
mng_ipngp pIPNG;
9360
mng_retcode iRetcode;
9361
9362
#ifdef MNG_SUPPORT_TRACE
9363
MNG_TRACE (pData, MNG_FN_WRITE_IPNG, MNG_LC_START)
9364
#endif
9365
9366
pIPNG = (mng_ipngp)pChunk; /* address the proper chunk */
9367
/* and write it */
9368
iRetcode = write_raw_chunk (pData, pIPNG->sHeader.iChunkname, 0, 0);
9369
9370
#ifdef MNG_SUPPORT_TRACE
9371
MNG_TRACE (pData, MNG_FN_WRITE_IPNG, MNG_LC_END)
9372
#endif
9373
9374
return iRetcode;
9375
}
9376
#endif
9377
9378
/* ************************************************************************** */
9379
9380
#ifndef MNG_NO_DELTA_PNG
9381
WRITE_CHUNK (mng_write_pplt)
9382
{
9383
mng_ppltp pPPLT;
9384
mng_uint8p pRawdata;
9385
mng_uint32 iRawlen;
9386
mng_retcode iRetcode;
9387
mng_pplt_entryp pEntry;
9388
mng_uint8p pTemp;
9389
mng_uint32 iX;
9390
mng_bool bHasgroup;
9391
mng_uint8p pLastid = 0;
9392
9393
#ifdef MNG_SUPPORT_TRACE
9394
MNG_TRACE (pData, MNG_FN_WRITE_PPLT, MNG_LC_START)
9395
#endif
9396
9397
pPPLT = (mng_ppltp)pChunk; /* address the proper chunk */
9398
9399
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9400
iRawlen = 1;
9401
9402
*pRawdata = pPPLT->iDeltatype; /* fill the output buffer */
9403
9404
pTemp = pRawdata+1;
9405
bHasgroup = MNG_FALSE;
9406
9407
for (iX = 0; iX < pPPLT->iCount; iX++)
9408
{
9409
pEntry = &pPPLT->aEntries[iX];
9410
9411
if (pEntry->bUsed) /* valid entry ? */
9412
{
9413
if (!bHasgroup) /* start a new group ? */
9414
{
9415
bHasgroup = MNG_TRUE;
9416
pLastid = pTemp+1;
9417
9418
*pTemp = (mng_uint8)iX;
9419
*(pTemp+1) = 0;
9420
9421
pTemp += 2;
9422
}
9423
9424
switch (pPPLT->iDeltatype) /* add group-entry depending on type */
9425
{
9426
case 0: ;
9427
case 1: {
9428
*pTemp = pEntry->iRed;
9429
*(pTemp+1) = pEntry->iGreen;
9430
*(pTemp+2) = pEntry->iBlue;
9431
9432
pTemp += 3;
9433
9434
break;
9435
}
9436
9437
case 2: ;
9438
case 3: {
9439
*pTemp = pEntry->iAlpha;
9440
9441
pTemp++;
9442
9443
break;
9444
}
9445
9446
case 4: ;
9447
case 5: {
9448
*pTemp = pEntry->iRed;
9449
*(pTemp+1) = pEntry->iGreen;
9450
*(pTemp+2) = pEntry->iBlue;
9451
*(pTemp+3) = pEntry->iAlpha;
9452
9453
pTemp += 4;
9454
9455
break;
9456
}
9457
9458
}
9459
}
9460
else
9461
{
9462
if (bHasgroup) /* finish off a group ? */
9463
*pLastid = (mng_uint8)(iX-1);
9464
9465
bHasgroup = MNG_FALSE;
9466
}
9467
}
9468
9469
if (bHasgroup) /* last group unfinished ? */
9470
*pLastid = (mng_uint8)(pPPLT->iCount-1);
9471
/* write the output buffer */
9472
iRetcode = write_raw_chunk (pData, pPPLT->sHeader.iChunkname,
9473
iRawlen, pRawdata);
9474
9475
#ifdef MNG_SUPPORT_TRACE
9476
MNG_TRACE (pData, MNG_FN_WRITE_PPLT, MNG_LC_END)
9477
#endif
9478
9479
return iRetcode;
9480
}
9481
#endif
9482
9483
/* ************************************************************************** */
9484
9485
#ifndef MNG_NO_DELTA_PNG
9486
#ifdef MNG_INCLUDE_JNG
9487
WRITE_CHUNK (mng_write_ijng)
9488
{
9489
mng_ijngp pIJNG;
9490
mng_retcode iRetcode;
9491
9492
#ifdef MNG_SUPPORT_TRACE
9493
MNG_TRACE (pData, MNG_FN_WRITE_IJNG, MNG_LC_START)
9494
#endif
9495
9496
pIJNG = (mng_ijngp)pChunk; /* address the proper chunk */
9497
/* and write it */
9498
iRetcode = write_raw_chunk (pData, pIJNG->sHeader.iChunkname, 0, 0);
9499
9500
#ifdef MNG_SUPPORT_TRACE
9501
MNG_TRACE (pData, MNG_FN_WRITE_IJNG, MNG_LC_END)
9502
#endif
9503
9504
return iRetcode;
9505
}
9506
#endif
9507
#endif
9508
9509
/* ************************************************************************** */
9510
9511
#ifndef MNG_NO_DELTA_PNG
9512
WRITE_CHUNK (mng_write_drop)
9513
{
9514
mng_dropp pDROP;
9515
mng_uint8p pRawdata;
9516
mng_uint32 iRawlen;
9517
mng_retcode iRetcode;
9518
mng_uint32 iX;
9519
mng_uint8p pTemp1;
9520
mng_chunkidp pTemp2;
9521
9522
#ifdef MNG_SUPPORT_TRACE
9523
MNG_TRACE (pData, MNG_FN_WRITE_DROP, MNG_LC_START)
9524
#endif
9525
9526
pDROP = (mng_dropp)pChunk; /* address the proper chunk */
9527
9528
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9529
iRawlen = pDROP->iCount << 2;
9530
9531
pTemp1 = pRawdata; /* fill the output buffer */
9532
pTemp2 = pDROP->pChunknames;
9533
9534
for (iX = 0; iX < pDROP->iCount; iX++)
9535
{
9536
mng_put_uint32 (pTemp1, (mng_uint32)*pTemp2);
9537
9538
pTemp2++;
9539
pTemp1 += 4;
9540
}
9541
/* and write it */
9542
iRetcode = write_raw_chunk (pData, pDROP->sHeader.iChunkname,
9543
iRawlen, pRawdata);
9544
9545
#ifdef MNG_SUPPORT_TRACE
9546
MNG_TRACE (pData, MNG_FN_WRITE_DROP, MNG_LC_END)
9547
#endif
9548
9549
return iRetcode;
9550
}
9551
#endif
9552
9553
/* ************************************************************************** */
9554
9555
#ifndef MNG_NO_DELTA_PNG
9556
#ifndef MNG_SKIPCHUNK_DBYK
9557
WRITE_CHUNK (mng_write_dbyk)
9558
{
9559
mng_dbykp pDBYK;
9560
mng_uint8p pRawdata;
9561
mng_uint32 iRawlen;
9562
mng_retcode iRetcode;
9563
9564
#ifdef MNG_SUPPORT_TRACE
9565
MNG_TRACE (pData, MNG_FN_WRITE_DBYK, MNG_LC_START)
9566
#endif
9567
9568
pDBYK = (mng_dbykp)pChunk; /* address the proper chunk */
9569
9570
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9571
iRawlen = 5 + pDBYK->iKeywordssize;
9572
/* fill the output buffer */
9573
mng_put_uint32 (pRawdata, pDBYK->iChunkname);
9574
*(pRawdata+4) = pDBYK->iPolarity;
9575
9576
if (pDBYK->iKeywordssize)
9577
MNG_COPY (pRawdata+5, pDBYK->zKeywords, pDBYK->iKeywordssize)
9578
/* and write it */
9579
iRetcode = write_raw_chunk (pData, pDBYK->sHeader.iChunkname,
9580
iRawlen, pRawdata);
9581
9582
#ifdef MNG_SUPPORT_TRACE
9583
MNG_TRACE (pData, MNG_FN_WRITE_DBYK, MNG_LC_END)
9584
#endif
9585
9586
return iRetcode;
9587
}
9588
#endif
9589
#endif
9590
9591
/* ************************************************************************** */
9592
9593
#ifndef MNG_NO_DELTA_PNG
9594
#ifndef MNG_SKIPCHUNK_ORDR
9595
WRITE_CHUNK (mng_write_ordr)
9596
{
9597
mng_ordrp pORDR;
9598
mng_uint8p pRawdata;
9599
mng_uint32 iRawlen;
9600
mng_retcode iRetcode;
9601
mng_uint8p pTemp;
9602
mng_ordr_entryp pEntry;
9603
mng_uint32 iX;
9604
9605
#ifdef MNG_SUPPORT_TRACE
9606
MNG_TRACE (pData, MNG_FN_WRITE_ORDR, MNG_LC_START)
9607
#endif
9608
9609
pORDR = (mng_ordrp)pChunk; /* address the proper chunk */
9610
9611
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9612
iRawlen = pORDR->iCount * 5;
9613
9614
pTemp = pRawdata; /* fill the output buffer */
9615
pEntry = pORDR->pEntries;
9616
9617
for (iX = 0; iX < pORDR->iCount; iX++)
9618
{
9619
mng_put_uint32 (pTemp, pEntry->iChunkname);
9620
*(pTemp+4) = pEntry->iOrdertype;
9621
pTemp += 5;
9622
pEntry++;
9623
}
9624
/* and write it */
9625
iRetcode = write_raw_chunk (pData, pORDR->sHeader.iChunkname,
9626
iRawlen, pRawdata);
9627
9628
#ifdef MNG_SUPPORT_TRACE
9629
MNG_TRACE (pData, MNG_FN_WRITE_ORDR, MNG_LC_END)
9630
#endif
9631
9632
return iRetcode;
9633
}
9634
#endif
9635
#endif
9636
9637
/* ************************************************************************** */
9638
9639
WRITE_CHUNK (mng_write_magn)
9640
{
9641
mng_magnp pMAGN;
9642
mng_uint8p pRawdata;
9643
mng_uint32 iRawlen;
9644
mng_retcode iRetcode;
9645
9646
#ifdef MNG_SUPPORT_TRACE
9647
MNG_TRACE (pData, MNG_FN_WRITE_MAGN, MNG_LC_START)
9648
#endif
9649
9650
pMAGN = (mng_magnp)pChunk; /* address the proper chunk */
9651
9652
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9653
iRawlen = 18;
9654
/* fill the output buffer */
9655
mng_put_uint16 (pRawdata, pMAGN->iFirstid);
9656
mng_put_uint16 (pRawdata+2, pMAGN->iLastid);
9657
*(pRawdata+4) = pMAGN->iMethodX;
9658
mng_put_uint16 (pRawdata+5, pMAGN->iMX);
9659
mng_put_uint16 (pRawdata+7, pMAGN->iMY);
9660
mng_put_uint16 (pRawdata+9, pMAGN->iML);
9661
mng_put_uint16 (pRawdata+11, pMAGN->iMR);
9662
mng_put_uint16 (pRawdata+13, pMAGN->iMT);
9663
mng_put_uint16 (pRawdata+15, pMAGN->iMB);
9664
*(pRawdata+17) = pMAGN->iMethodY;
9665
/* optimize length */
9666
if (pMAGN->iMethodY == pMAGN->iMethodX)
9667
{
9668
iRawlen--;
9669
9670
if (pMAGN->iMB == pMAGN->iMY)
9671
{
9672
iRawlen -= 2;
9673
9674
if (pMAGN->iMT == pMAGN->iMY)
9675
{
9676
iRawlen -= 2;
9677
9678
if (pMAGN->iMR == pMAGN->iMX)
9679
{
9680
iRawlen -= 2;
9681
9682
if (pMAGN->iML == pMAGN->iMX)
9683
{
9684
iRawlen -= 2;
9685
9686
if (pMAGN->iMY == pMAGN->iMX)
9687
{
9688
iRawlen -= 2;
9689
9690
if (pMAGN->iMX == 1)
9691
{
9692
iRawlen -= 2;
9693
9694
if (pMAGN->iMethodX == 0)
9695
{
9696
iRawlen--;
9697
9698
if (pMAGN->iLastid == pMAGN->iFirstid)
9699
{
9700
iRawlen -= 2;
9701
9702
if (pMAGN->iFirstid == 0)
9703
iRawlen = 0;
9704
9705
}
9706
}
9707
}
9708
}
9709
}
9710
}
9711
}
9712
}
9713
}
9714
/* and write it */
9715
iRetcode = write_raw_chunk (pData, pMAGN->sHeader.iChunkname,
9716
iRawlen, pRawdata);
9717
9718
#ifdef MNG_SUPPORT_TRACE
9719
MNG_TRACE (pData, MNG_FN_WRITE_MAGN, MNG_LC_END)
9720
#endif
9721
9722
return iRetcode;
9723
}
9724
9725
/* ************************************************************************** */
9726
9727
#ifndef MNG_SKIPCHUNK_evNT
9728
WRITE_CHUNK (mng_write_evnt)
9729
{
9730
mng_evntp pEVNT;
9731
mng_uint8p pRawdata;
9732
mng_uint32 iRawlen;
9733
mng_retcode iRetcode;
9734
mng_evnt_entryp pEntry;
9735
mng_uint8p pTemp;
9736
mng_uint32 iX;
9737
mng_uint32 iNamesize;
9738
9739
#ifdef MNG_SUPPORT_TRACE
9740
MNG_TRACE (pData, MNG_FN_WRITE_EVNT, MNG_LC_START)
9741
#endif
9742
9743
pEVNT = (mng_evntp)pChunk; /* address the proper chunk */
9744
9745
if (!pEVNT->iCount) /* empty ? */
9746
iRetcode = write_raw_chunk (pData, pEVNT->sHeader.iChunkname, 0, 0);
9747
else
9748
{
9749
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9750
iRawlen = 0;
9751
pTemp = pRawdata;
9752
pEntry = pEVNT->pEntries;
9753
9754
for (iX = 0; iX < pEVNT->iCount; iX++)
9755
{
9756
if (iX) /* put separator null-byte, except the first */
9757
{
9758
*pTemp = 0;
9759
pTemp++;
9760
iRawlen++;
9761
}
9762
9763
*pTemp = pEntry->iEventtype;
9764
*(pTemp+1) = pEntry->iMasktype;
9765
pTemp += 2;
9766
iRawlen += 2;
9767
9768
switch (pEntry->iMasktype)
9769
{
9770
case 1 :
9771
{
9772
mng_put_int32 (pTemp, pEntry->iLeft);
9773
mng_put_int32 (pTemp+4, pEntry->iRight);
9774
mng_put_int32 (pTemp+8, pEntry->iTop);
9775
mng_put_int32 (pTemp+12, pEntry->iBottom);
9776
pTemp += 16;
9777
iRawlen += 16;
9778
break;
9779
}
9780
case 2 :
9781
{
9782
mng_put_uint16 (pTemp, pEntry->iObjectid);
9783
pTemp += 2;
9784
iRawlen += 2;
9785
break;
9786
}
9787
case 3 :
9788
{
9789
mng_put_uint16 (pTemp, pEntry->iObjectid);
9790
*(pTemp+2) = pEntry->iIndex;
9791
pTemp += 3;
9792
iRawlen += 3;
9793
break;
9794
}
9795
case 4 :
9796
{
9797
mng_put_int32 (pTemp, pEntry->iLeft);
9798
mng_put_int32 (pTemp+4, pEntry->iRight);
9799
mng_put_int32 (pTemp+8, pEntry->iTop);
9800
mng_put_int32 (pTemp+12, pEntry->iBottom);
9801
mng_put_uint16 (pTemp+16, pEntry->iObjectid);
9802
pTemp += 18;
9803
iRawlen += 18;
9804
break;
9805
}
9806
case 5 :
9807
{
9808
mng_put_int32 (pTemp, pEntry->iLeft);
9809
mng_put_int32 (pTemp+4, pEntry->iRight);
9810
mng_put_int32 (pTemp+8, pEntry->iTop);
9811
mng_put_int32 (pTemp+12, pEntry->iBottom);
9812
mng_put_uint16 (pTemp+16, pEntry->iObjectid);
9813
*(pTemp+18) = pEntry->iIndex;
9814
pTemp += 19;
9815
iRawlen += 19;
9816
break;
9817
}
9818
}
9819
9820
iNamesize = pEntry->iSegmentnamesize;
9821
9822
if (iNamesize)
9823
{
9824
MNG_COPY (pTemp, pEntry->zSegmentname, iNamesize);
9825
pTemp += iNamesize;
9826
iRawlen += iNamesize;
9827
}
9828
9829
pEntry++;
9830
}
9831
/* and write it */
9832
iRetcode = write_raw_chunk (pData, pEVNT->sHeader.iChunkname,
9833
iRawlen, pRawdata);
9834
}
9835
9836
#ifdef MNG_SUPPORT_TRACE
9837
MNG_TRACE (pData, MNG_FN_WRITE_EVNT, MNG_LC_END)
9838
#endif
9839
9840
return iRetcode;
9841
}
9842
#endif
9843
9844
/* ************************************************************************** */
9845
9846
WRITE_CHUNK (mng_write_unknown)
9847
{
9848
mng_unknown_chunkp pUnknown;
9849
mng_retcode iRetcode;
9850
9851
#ifdef MNG_SUPPORT_TRACE
9852
MNG_TRACE (pData, MNG_FN_WRITE_UNKNOWN, MNG_LC_START)
9853
#endif
9854
/* address the proper chunk */
9855
pUnknown = (mng_unknown_chunkp)pChunk;
9856
/* and write it */
9857
iRetcode = write_raw_chunk (pData, pUnknown->sHeader.iChunkname,
9858
pUnknown->iDatasize, pUnknown->pData);
9859
9860
#ifdef MNG_SUPPORT_TRACE
9861
MNG_TRACE (pData, MNG_FN_WRITE_UNKNOWN, MNG_LC_END)
9862
#endif
9863
9864
return iRetcode;
9865
}
9866
9867
/* ************************************************************************** */
9868
9869
#endif /* MNG_INCLUDE_WRITE_PROCS */
9870
9871
/* ************************************************************************** */
9872
/* * end of file * */
9873
/* ************************************************************************** */
1
/** ************************************************************************* */
2
/* * For conditions of distribution and use, * */
3
/* * see copyright notice in libmng.h * */
4
/* ************************************************************************** */
5
/* * * */
6
/* * project : libmng * */
7
/* * file : libmng_chunk_io.c copyright (c) 2000-2004 G.Juyn * */
8
/* * version : 1.0.9 * */
9
/* * * */
10
/* * purpose : Chunk I/O routines (implementation) * */
11
/* * * */
12
/* * author : G.Juyn * */
13
/* * * */
14
/* * comment : implementation of chunk input/output routines * */
15
/* * * */
16
/* * changes : 0.5.1 - 05/01/2000 - G.Juyn * */
17
/* * - cleaned up left-over teststuff in the BACK chunk routine * */
18
/* * 0.5.1 - 05/04/2000 - G.Juyn * */
19
/* * - changed CRC initialization to use dynamic structure * */
20
/* * (wasn't thread-safe the old way !) * */
21
/* * 0.5.1 - 05/06/2000 - G.Juyn * */
22
/* * - filled in many missing sequence&length checks * */
23
/* * - filled in many missing chunk-store snippets * */
24
/* * 0.5.1 - 05/08/2000 - G.Juyn * */
25
/* * - added checks for running animations * */
26
/* * - filled some write routines * */
27
/* * - changed strict-ANSI stuff * */
28
/* * 0.5.1 - 05/10/2000 - G.Juyn * */
29
/* * - filled some more write routines * */
30
/* * 0.5.1 - 05/11/2000 - G.Juyn * */
31
/* * - filled remaining write routines * */
32
/* * - fixed read_pplt with regard to deltatype * */
33
/* * - added callback error-reporting support * */
34
/* * - added pre-draft48 support (short MHDR, frame_mode, LOOP) * */
35
/* * 0.5.1 - 05/12/2000 - G.Juyn * */
36
/* * - changed trace to macro for callback error-reporting * */
37
/* * - fixed chunk-storage bit in several routines * */
38
/* * 0.5.1 - 05/13/2000 - G.Juyn * */
39
/* * - added eMNGma hack (will be removed in 1.0.0 !!!) * */
40
/* * - added TERM animation object pointer (easier reference) * */
41
/* * - supplemented the SAVE & SEEK display processing * */
42
/* * * */
43
/* * 0.5.2 - 05/18/2000 - G.Juyn * */
44
/* * - B004 - fixed problem with MNG_SUPPORT_WRITE not defined * */
45
/* * also for MNG_SUPPORT_WRITE without MNG_INCLUDE_JNG * */
46
/* * 0.5.2 - 05/19/2000 - G.Juyn * */
47
/* * - cleaned up some code regarding mixed support * */
48
/* * 0.5.2 - 05/20/2000 - G.Juyn * */
49
/* * - implemented JNG support * */
50
/* * 0.5.2 - 05/24/2000 - G.Juyn * */
51
/* * - added support for global color-chunks in animation * */
52
/* * - added support for global PLTE,tRNS,bKGD in animation * */
53
/* * - added support for SAVE & SEEK in animation * */
54
/* * 0.5.2 - 05/29/2000 - G.Juyn * */
55
/* * - changed ani_create calls not returning object pointer * */
56
/* * - create ani objects always (not just inside TERM/LOOP) * */
57
/* * 0.5.2 - 05/30/2000 - G.Juyn * */
58
/* * - added support for delta-image processing * */
59
/* * 0.5.2 - 05/31/2000 - G.Juyn * */
60
/* * - fixed up punctuation (contributed by Tim Rowley) * */
61
/* * 0.5.2 - 06/02/2000 - G.Juyn * */
62
/* * - changed SWAP_ENDIAN to BIGENDIAN_SUPPORTED * */
63
/* * 0.5.2 - 06/03/2000 - G.Juyn * */
64
/* * - fixed makeup for Linux gcc compile * */
65
/* * * */
66
/* * 0.5.3 - 06/12/2000 - G.Juyn * */
67
/* * - added processing of color-info on delta-image * */
68
/* * 0.5.3 - 06/13/2000 - G.Juyn * */
69
/* * - fixed handling of empty SAVE chunk * */
70
/* * 0.5.3 - 06/17/2000 - G.Juyn * */
71
/* * - changed to support delta-images * */
72
/* * - added extra checks for delta-images * */
73
/* * 0.5.3 - 06/20/2000 - G.Juyn * */
74
/* * - fixed possible trouble if IEND display-process got * */
75
/* * broken up * */
76
/* * 0.5.3 - 06/21/2000 - G.Juyn * */
77
/* * - added processing of PLTE & tRNS for delta-images * */
78
/* * - added administration of imagelevel parameter * */
79
/* * 0.5.3 - 06/22/2000 - G.Juyn * */
80
/* * - implemented support for PPLT chunk * */
81
/* * 0.5.3 - 06/26/2000 - G.Juyn * */
82
/* * - added precaution against faulty iCCP chunks from PS * */
83
/* * 0.5.3 - 06/29/2000 - G.Juyn * */
84
/* * - fixed some 64-bit warnings * */
85
/* * * */
86
/* * 0.9.1 - 07/14/2000 - G.Juyn * */
87
/* * - changed pre-draft48 frame_mode=3 to frame_mode=1 * */
88
/* * 0.9.1 - 07/16/2000 - G.Juyn * */
89
/* * - fixed storage of images during mng_read() * */
90
/* * - fixed support for mng_display() after mng_read() * */
91
/* * 0.9.1 - 07/19/2000 - G.Juyn * */
92
/* * - fixed several chunk-writing routines * */
93
/* * 0.9.1 - 07/24/2000 - G.Juyn * */
94
/* * - fixed reading of still-images * */
95
/* * * */
96
/* * 0.9.2 - 08/05/2000 - G.Juyn * */
97
/* * - changed file-prefixes * */
98
/* * * */
99
/* * 0.9.3 - 08/07/2000 - G.Juyn * */
100
/* * - B111300 - fixup for improved portability * */
101
/* * 0.9.3 - 08/08/2000 - G.Juyn * */
102
/* * - fixed compiler-warnings from Mozilla * */
103
/* * 0.9.3 - 08/09/2000 - G.Juyn * */
104
/* * - added check for simplicity-bits in MHDR * */
105
/* * 0.9.3 - 08/12/2000 - G.Juyn * */
106
/* * - fixed check for simplicity-bits in MHDR (JNG) * */
107
/* * 0.9.3 - 08/12/2000 - G.Juyn * */
108
/* * - added workaround for faulty PhotoShop iCCP chunk * */
109
/* * 0.9.3 - 08/22/2000 - G.Juyn * */
110
/* * - fixed write-code for zTXt & iTXt * */
111
/* * - fixed read-code for iTXt * */
112
/* * 0.9.3 - 08/26/2000 - G.Juyn * */
113
/* * - added MAGN chunk * */
114
/* * 0.9.3 - 09/07/2000 - G.Juyn * */
115
/* * - added support for new filter_types * */
116
/* * 0.9.3 - 09/10/2000 - G.Juyn * */
117
/* * - fixed DEFI behavior * */
118
/* * 0.9.3 - 10/02/2000 - G.Juyn * */
119
/* * - fixed simplicity-check in compliance with draft 81/0.98a * */
120
/* * 0.9.3 - 10/10/2000 - G.Juyn * */
121
/* * - added support for alpha-depth prediction * */
122
/* * 0.9.3 - 10/11/2000 - G.Juyn * */
123
/* * - added support for nEED * */
124
/* * 0.9.3 - 10/16/2000 - G.Juyn * */
125
/* * - added support for JDAA * */
126
/* * 0.9.3 - 10/17/2000 - G.Juyn * */
127
/* * - fixed support for MAGN * */
128
/* * - implemented nEED "xxxx" (where "xxxx" is a chunkid) * */
129
/* * - added callback to process non-critical unknown chunks * */
130
/* * - fixed support for bKGD * */
131
/* * 0.9.3 - 10/23/2000 - G.Juyn * */
132
/* * - fixed bug in empty PLTE handling * */
133
/* * * */
134
/* * 0.9.4 - 11/20/2000 - G.Juyn * */
135
/* * - changed IHDR filter_method check for PNGs * */
136
/* * 0.9.4 - 1/18/2001 - G.Juyn * */
137
/* * - added errorchecking for MAGN methods * */
138
/* * - removed test filter-methods 1 & 65 * */
139
/* * * */
140
/* * 0.9.5 - 1/25/2001 - G.Juyn * */
141
/* * - fixed some small compiler warnings (thanks Nikki) * */
142
/* * * */
143
/* * 1.0.2 - 05/05/2000 - G.Juyn * */
144
/* * - B421427 - writes wrong format in bKGD and tRNS * */
145
/* * 1.0.2 - 06/20/2000 - G.Juyn * */
146
/* * - B434583 - compiler-warning if MNG_STORE_CHUNKS undefined * */
147
/* * * */
148
/* * 1.0.5 - 07/08/2002 - G.Juyn * */
149
/* * - B578572 - removed eMNGma hack (thanks Dimitri!) * */
150
/* * 1.0.5 - 08/07/2002 - G.Juyn * */
151
/* * - added test-option for PNG filter method 193 (=no filter) * */
152
/* * 1.0.5 - 08/15/2002 - G.Juyn * */
153
/* * - completed PROM support * */
154
/* * 1.0.5 - 08/19/2002 - G.Juyn * */
155
/* * - B597134 - libmng pollutes the linker namespace * */
156
/* * 1.0.5 - 09/07/2002 - G.Juyn * */
157
/* * - fixed reading of FRAM with just frame_mode and name * */
158
/* * 1.0.5 - 09/13/2002 - G.Juyn * */
159
/* * - fixed read/write of MAGN chunk * */
160
/* * 1.0.5 - 09/14/2002 - G.Juyn * */
161
/* * - added event handling for dynamic MNG * */
162
/* * 1.0.5 - 09/15/2002 - G.Juyn * */
163
/* * - fixed LOOP iteration=0 special case * */
164
/* * 1.0.5 - 09/19/2002 - G.Juyn * */
165
/* * - misplaced TERM is now treated as warning * */
166
/* * 1.0.5 - 09/20/2002 - G.Juyn * */
167
/* * - added support for PAST * */
168
/* * 1.0.5 - 10/03/2002 - G.Juyn * */
169
/* * - fixed chunk-storage for evNT chunk * */
170
/* * 1.0.5 - 10/07/2002 - G.Juyn * */
171
/* * - fixed DISC support * */
172
/* * - added another fix for misplaced TERM chunk * */
173
/* * 1.0.5 - 10/17/2002 - G.Juyn * */
174
/* * - fixed initializtion of pIds in dISC read routine * */
175
/* * 1.0.5 - 11/06/2002 - G.Juyn * */
176
/* * - added support for nEED "MNG 1.1" * */
177
/* * - added support for nEED "CACHEOFF" * */
178
/* * * */
179
/* * 1.0.6 - 05/25/2003 - G.R-P * */
180
/* * - added MNG_SKIPCHUNK_cHNK footprint optimizations * */
181
/* * 1.0.6 - 06/02/2003 - G.R-P * */
182
/* * - removed some redundant checks for iRawlen==0 * */
183
/* * 1.0.6 - 06/22/2003 - G.R-P * */
184
/* * - added MNG_NO_16BIT_SUPPORT, MNG_NO_DELTA_PNG reductions * */
185
/* * - optionally use zlib's crc32 function instead of * */
186
/* * local mng_update_crc * */
187
/* * 1.0.6 - 07/14/2003 - G.R-P * */
188
/* * - added MNG_NO_LOOP_SIGNALS_SUPPORTED conditional * */
189
/* * 1.0.6 - 07/29/2003 - G.R-P * */
190
/* * - added conditionals around PAST chunk support * */
191
/* * 1.0.6 - 08/17/2003 - G.R-P * */
192
/* * - added conditionals around non-VLC chunk support * */
193
/* * * */
194
/* * 1.0.7 - 10/29/2003 - G.R-P * */
195
/* * - revised JDAA and JDAT readers to avoid compiler bug * */
196
/* * 1.0.7 - 01/25/2004 - J.S * */
197
/* * - added premultiplied alpha canvas' for RGBA, ARGB, ABGR * */
198
/* * 1.0.7 - 01/27/2004 - J.S * */
199
/* * - fixed inclusion of IJNG chunk for non-JNG use * */
200
/* * 1.0.7 - 02/26/2004 - G.Juyn * */
201
/* * - fixed bug in chunk-storage of SHOW chunk (from == to) * */
202
/* * * */
203
/* * 1.0.8 - 04/02/2004 - G.Juyn * */
204
/* * - added CRC existence & checking flags * */
205
/* * 1.0.8 - 07/07/2004 - G.R-P * */
206
/* * - change worst-case iAlphadepth to 1 for standalone PNGs * */
207
/* * * */
208
/* * 1.0.9 - 09/28/2004 - G.R-P * */
209
/* * - improved handling of cheap transparency when 16-bit * */
210
/* * support is disabled * */
211
/* * 1.0.9 - 10/04/2004 - G.Juyn * */
212
/* * - fixed bug in writing sBIT for indexed color * */
213
/* * 1.0.9 - 10/10/2004 - G.R-P. * */
214
/* * - added MNG_NO_1_2_4BIT_SUPPORT * */
215
/* * 1.0.9 - 12/05/2004 - G.Juyn * */
216
/* * - added conditional MNG_OPTIMIZE_CHUNKINITFREE * */
217
/* * 1.0.9 - 12/06/2004 - G.Juyn * */
218
/* * - added conditional MNG_OPTIMIZE_CHUNKASSIGN * */
219
/* * 1.0.9 - 12/07/2004 - G.Juyn * */
220
/* * - added conditional MNG_OPTIMIZE_CHUNKREADER * */
221
/* * 1.0.9 - 12/11/2004 - G.Juyn * */
222
/* * - added conditional MNG_OPTIMIZE_DISPLAYCALLS * */
223
/* * 1.0.9 - 12/20/2004 - G.Juyn * */
224
/* * - cleaned up macro-invocations (thanks to D. Airlie) * */
225
/* * 1.0.9 - 01/17/2005 - G.Juyn * */
226
/* * - fixed problem with global PLTE/tRNS * */
227
/* * * */
228
/* ************************************************************************** */
229
230
#include "libmng.h"
231
#include "libmng_data.h"
232
#include "libmng_error.h"
233
#include "libmng_trace.h"
234
#ifdef __BORLANDC__
235
#pragma hdrstop
236
#endif
237
#include "libmng_objects.h"
238
#include "libmng_object_prc.h"
239
#include "libmng_chunks.h"
240
#ifdef MNG_CHECK_BAD_ICCP
241
#include "libmng_chunk_prc.h"
242
#endif
243
#include "libmng_memory.h"
244
#include "libmng_display.h"
245
#include "libmng_zlib.h"
246
#include "libmng_pixels.h"
247
#include "libmng_chunk_io.h"
248
249
#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
250
#pragma option -A /* force ANSI-C */
251
#endif
252
253
/* ************************************************************************** */
254
/* * * */
255
/* * CRC - Cyclic Redundancy Check * */
256
/* * * */
257
/* * The code below is taken directly from the sample provided with the * */
258
/* * PNG specification. * */
259
/* * (it is only adapted to the library's internal data-definitions) * */
260
/* * * */
261
/* ************************************************************************** */
262
/* Make the table for a fast CRC. */
263
#ifndef MNG_USE_ZLIB_CRC
264
MNG_LOCAL void make_crc_table (mng_datap pData)
265
{
266
mng_uint32 iC;
267
mng_int32 iN, iK;
268
269
for (iN = 0; iN < 256; iN++)
270
{
271
iC = (mng_uint32) iN;
272
273
for (iK = 0; iK < 8; iK++)
274
{
275
if (iC & 1)
276
iC = 0xedb88320U ^ (iC >> 1);
277
else
278
iC = iC >> 1;
279
}
280
281
pData->aCRCtable [iN] = iC;
282
}
283
284
pData->bCRCcomputed = MNG_TRUE;
285
}
286
#endif
287
288
/* Update a running CRC with the bytes buf[0..len-1]--the CRC
289
should be initialized to all 1's, and the transmitted value
290
is the 1's complement of the final running CRC (see the
291
crc() routine below). */
292
293
MNG_LOCAL mng_uint32 update_crc (mng_datap pData,
294
mng_uint32 iCrc,
295
mng_uint8p pBuf,
296
mng_int32 iLen)
297
{
298
#ifdef MNG_USE_ZLIB_CRC
299
return crc32 (iCrc, pBuf, iLen);
300
#else
301
mng_uint32 iC = iCrc;
302
mng_int32 iN;
303
304
if (!pData->bCRCcomputed)
305
make_crc_table (pData);
306
307
for (iN = 0; iN < iLen; iN++)
308
iC = pData->aCRCtable [(iC ^ pBuf [iN]) & 0xff] ^ (iC >> 8);
309
310
return iC;
311
#endif
312
}
313
314
/* Return the CRC of the bytes buf[0..len-1]. */
315
mng_uint32 mng_crc (mng_datap pData,
316
mng_uint8p pBuf,
317
mng_int32 iLen)
318
{
319
#ifdef MNG_USE_ZLIB_CRC
320
return update_crc (pData, 0, pBuf, iLen);
321
#else
322
return update_crc (pData, 0xffffffffU, pBuf, iLen) ^ 0xffffffffU;
323
#endif
324
}
325
326
/* ************************************************************************** */
327
/* * * */
328
/* * Routines for swapping byte-order from and to graphic files * */
329
/* * (This code is adapted from the libpng package) * */
330
/* * * */
331
/* ************************************************************************** */
332
333
#ifndef MNG_BIGENDIAN_SUPPORTED
334
335
/* ************************************************************************** */
336
337
mng_uint32 mng_get_uint32 (mng_uint8p pBuf)
338
{
339
mng_uint32 i = ((mng_uint32)(*pBuf) << 24) +
340
((mng_uint32)(*(pBuf + 1)) << 16) +
341
((mng_uint32)(*(pBuf + 2)) << 8) +
342
(mng_uint32)(*(pBuf + 3));
343
return (i);
344
}
345
346
/* ************************************************************************** */
347
348
mng_int32 mng_get_int32 (mng_uint8p pBuf)
349
{
350
mng_int32 i = ((mng_int32)(*pBuf) << 24) +
351
((mng_int32)(*(pBuf + 1)) << 16) +
352
((mng_int32)(*(pBuf + 2)) << 8) +
353
(mng_int32)(*(pBuf + 3));
354
return (i);
355
}
356
357
/* ************************************************************************** */
358
359
mng_uint16 mng_get_uint16 (mng_uint8p pBuf)
360
{
361
mng_uint16 i = (mng_uint16)(((mng_uint16)(*pBuf) << 8) +
362
(mng_uint16)(*(pBuf + 1)));
363
return (i);
364
}
365
366
/* ************************************************************************** */
367
368
void mng_put_uint32 (mng_uint8p pBuf,
369
mng_uint32 i)
370
{
371
*pBuf = (mng_uint8)((i >> 24) & 0xff);
372
*(pBuf+1) = (mng_uint8)((i >> 16) & 0xff);
373
*(pBuf+2) = (mng_uint8)((i >> 8) & 0xff);
374
*(pBuf+3) = (mng_uint8)(i & 0xff);
375
}
376
377
/* ************************************************************************** */
378
379
void mng_put_int32 (mng_uint8p pBuf,
380
mng_int32 i)
381
{
382
*pBuf = (mng_uint8)((i >> 24) & 0xff);
383
*(pBuf+1) = (mng_uint8)((i >> 16) & 0xff);
384
*(pBuf+2) = (mng_uint8)((i >> 8) & 0xff);
385
*(pBuf+3) = (mng_uint8)(i & 0xff);
386
}
387
388
/* ************************************************************************** */
389
390
void mng_put_uint16 (mng_uint8p pBuf,
391
mng_uint16 i)
392
{
393
*pBuf = (mng_uint8)((i >> 8) & 0xff);
394
*(pBuf+1) = (mng_uint8)(i & 0xff);
395
}
396
397
/* ************************************************************************** */
398
399
#endif /* !MNG_BIGENDIAN_SUPPORTED */
400
401
/* ************************************************************************** */
402
/* * * */
403
/* * Helper routines to simplify chunk-data extraction * */
404
/* * * */
405
/* ************************************************************************** */
406
407
#ifdef MNG_INCLUDE_READ_PROCS
408
409
/* ************************************************************************** */
410
411
#ifndef MNG_OPTIMIZE_CHUNKREADER
412
MNG_LOCAL mng_uint8p find_null (mng_uint8p pIn)
413
{
414
mng_uint8p pOut = pIn;
415
while (*pOut) /* the read_graphic routine has made sure there's */
416
pOut++; /* always at least 1 zero-byte in the buffer */
417
return pOut;
418
}
419
#endif
420
421
/* ************************************************************************** */
422
423
#if !defined(MNG_SKIPCHUNK_iCCP) || !defined(MNG_SKIPCHUNK_zTXt) || !defined(MNG_SKIPCHUNK_iTXt)
424
mng_retcode mng_inflate_buffer (mng_datap pData,
425
mng_uint8p pInbuf,
426
mng_uint32 iInsize,
427
mng_uint8p *pOutbuf,
428
mng_uint32 *iOutsize,
429
mng_uint32 *iRealsize)
430
{
431
mng_retcode iRetcode = MNG_NOERROR;
432
433
#ifdef MNG_SUPPORT_TRACE
434
MNG_TRACE (pData, MNG_FN_INFLATE_BUFFER, MNG_LC_START);
435
#endif
436
437
if (iInsize) /* anything to do ? */
438
{
439
*iOutsize = iInsize * 3; /* estimate uncompressed size */
440
/* and allocate a temporary buffer */
441
MNG_ALLOC (pData, *pOutbuf, *iOutsize);
442
443
do
444
{
445
mngzlib_inflateinit (pData); /* initialize zlib */
446
/* let zlib know where to store the output */
447
pData->sZlib.next_out = *pOutbuf;
448
/* "size - 1" so we've got space for the
449
zero-termination of a possible string */
450
pData->sZlib.avail_out = *iOutsize - 1;
451
/* ok; let's inflate... */
452
iRetcode = mngzlib_inflatedata (pData, iInsize, pInbuf);
453
/* determine actual output size */
454
*iRealsize = (mng_uint32)pData->sZlib.total_out;
455
456
mngzlib_inflatefree (pData); /* zlib's done */
457
458
if (iRetcode == MNG_BUFOVERFLOW) /* not enough space ? */
459
{ /* then get some more */
460
MNG_FREEX (pData, *pOutbuf, *iOutsize);
461
*iOutsize = *iOutsize + iInsize;
462
MNG_ALLOC (pData, *pOutbuf, *iOutsize);
463
}
464
} /* repeat if we didn't have enough space */
465
while ((iRetcode == MNG_BUFOVERFLOW) &&
466
(*iOutsize < 20 * iInsize));
467
468
if (!iRetcode) /* if oke ? */
469
*((*pOutbuf) + *iRealsize) = 0; /* then put terminator zero */
470
471
}
472
else
473
{
474
*pOutbuf = 0; /* nothing to do; then there's no output */
475
*iOutsize = 0;
476
*iRealsize = 0;
477
}
478
479
#ifdef MNG_SUPPORT_TRACE
480
MNG_TRACE (pData, MNG_FN_INFLATE_BUFFER, MNG_LC_END);
481
#endif
482
483
return iRetcode;
484
}
485
#endif
486
487
/* ************************************************************************** */
488
489
#endif /* MNG_INCLUDE_READ_PROCS */
490
491
/* ************************************************************************** */
492
/* * * */
493
/* * Helper routines to simplify chunk writing * */
494
/* * * */
495
/* ************************************************************************** */
496
#ifdef MNG_INCLUDE_WRITE_PROCS
497
/* ************************************************************************** */
498
499
#if !defined(MNG_SKIPCHUNK_iCCP) || !defined(MNG_SKIPCHUNK_zTXt) || !defined(MNG_SKIPCHUNK_iTXt)
500
MNG_LOCAL mng_retcode deflate_buffer (mng_datap pData,
501
mng_uint8p pInbuf,
502
mng_uint32 iInsize,
503
mng_uint8p *pOutbuf,
504
mng_uint32 *iOutsize,
505
mng_uint32 *iRealsize)
506
{
507
mng_retcode iRetcode = MNG_NOERROR;
508
509
#ifdef MNG_SUPPORT_TRACE
510
MNG_TRACE (pData, MNG_FN_DEFLATE_BUFFER, MNG_LC_START);
511
#endif
512
513
if (iInsize) /* anything to do ? */
514
{
515
*iOutsize = (iInsize * 5) >> 2; /* estimate compressed size */
516
/* and allocate a temporary buffer */
517
MNG_ALLOC (pData, *pOutbuf, *iOutsize);
518
519
do
520
{
521
mngzlib_deflateinit (pData); /* initialize zlib */
522
/* let zlib know where to store the output */
523
pData->sZlib.next_out = *pOutbuf;
524
pData->sZlib.avail_out = *iOutsize;
525
/* ok; let's deflate... */
526
iRetcode = mngzlib_deflatedata (pData, iInsize, pInbuf);
527
/* determine actual output size */
528
*iRealsize = pData->sZlib.total_out;
529
530
mngzlib_deflatefree (pData); /* zlib's done */
531
532
if (iRetcode == MNG_BUFOVERFLOW) /* not enough space ? */
533
{ /* then get some more */
534
MNG_FREEX (pData, *pOutbuf, *iOutsize);
535
*iOutsize = *iOutsize + (iInsize >> 1);
536
MNG_ALLOC (pData, *pOutbuf, *iOutsize);
537
}
538
} /* repeat if we didn't have enough space */
539
while (iRetcode == MNG_BUFOVERFLOW);
540
}
541
else
542
{
543
*pOutbuf = 0; /* nothing to do; then there's no output */
544
*iOutsize = 0;
545
*iRealsize = 0;
546
}
547
548
#ifdef MNG_SUPPORT_TRACE
549
MNG_TRACE (pData, MNG_FN_DEFLATE_BUFFER, MNG_LC_END);
550
#endif
551
552
return iRetcode;
553
}
554
#endif
555
556
/* ************************************************************************** */
557
558
MNG_LOCAL mng_retcode write_raw_chunk (mng_datap pData,
559
mng_chunkid iChunkname,
560
mng_uint32 iRawlen,
561
mng_uint8p pRawdata)
562
{
563
mng_uint32 iCrc;
564
mng_uint32 iWritten;
565
566
#ifdef MNG_SUPPORT_TRACE
567
MNG_TRACE (pData, MNG_FN_WRITE_RAW_CHUNK, MNG_LC_START);
568
#endif
569
/* temporary buffer ? */
570
if ((pRawdata != 0) && (pRawdata != pData->pWritebuf+8))
571
{ /* store length & chunktype in default buffer */
572
mng_put_uint32 (pData->pWritebuf, iRawlen);
573
mng_put_uint32 (pData->pWritebuf+4, (mng_uint32)iChunkname);
574
575
if (pData->iCrcmode & MNG_CRC_OUTPUT)
576
{
577
if ((pData->iCrcmode & MNG_CRC_OUTPUT) == MNG_CRC_OUTPUT_GENERATE)
578
{ /* calculate the crc */
579
iCrc = update_crc (pData, 0xffffffffL, pData->pWritebuf+4, 4);
580
iCrc = update_crc (pData, iCrc, pRawdata, iRawlen) ^ 0xffffffffL;
581
} else {
582
iCrc = 0; /* dummy crc */
583
} /* store in default buffer */
584
mng_put_uint32 (pData->pWritebuf+8, iCrc);
585
}
586
/* write the length & chunktype */
587
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, 8, &iWritten))
588
MNG_ERROR (pData, MNG_APPIOERROR);
589
590
if (iWritten != 8) /* disk full ? */
591
MNG_ERROR (pData, MNG_OUTPUTERROR);
592
/* write the temporary buffer */
593
if (!pData->fWritedata ((mng_handle)pData, pRawdata, iRawlen, &iWritten))
594
MNG_ERROR (pData, MNG_APPIOERROR);
595
596
if (iWritten != iRawlen) /* disk full ? */
597
MNG_ERROR (pData, MNG_OUTPUTERROR);
598
599
if (pData->iCrcmode & MNG_CRC_OUTPUT)
600
{ /* write the crc */
601
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf+8, 4, &iWritten))
602
MNG_ERROR (pData, MNG_APPIOERROR);
603
604
if (iWritten != 4) /* disk full ? */
605
MNG_ERROR (pData, MNG_OUTPUTERROR);
606
}
607
}
608
else
609
{ /* prefix with length & chunktype */
610
mng_put_uint32 (pData->pWritebuf, iRawlen);
611
mng_put_uint32 (pData->pWritebuf+4, (mng_uint32)iChunkname);
612
613
if (pData->iCrcmode & MNG_CRC_OUTPUT)
614
{
615
if ((pData->iCrcmode & MNG_CRC_OUTPUT) == MNG_CRC_OUTPUT_GENERATE)
616
/* calculate the crc */
617
iCrc = mng_crc (pData, pData->pWritebuf+4, iRawlen + 4);
618
else
619
iCrc = 0; /* dummy crc */
620
/* add it to the buffer */
621
mng_put_uint32 (pData->pWritebuf + iRawlen + 8, iCrc);
622
/* write it in a single pass */
623
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, iRawlen + 12, &iWritten))
624
MNG_ERROR (pData, MNG_APPIOERROR);
625
626
if (iWritten != iRawlen + 12) /* disk full ? */
627
MNG_ERROR (pData, MNG_OUTPUTERROR);
628
} else {
629
if (!pData->fWritedata ((mng_handle)pData, pData->pWritebuf, iRawlen + 8, &iWritten))
630
MNG_ERROR (pData, MNG_APPIOERROR);
631
632
if (iWritten != iRawlen + 8) /* disk full ? */
633
MNG_ERROR (pData, MNG_OUTPUTERROR);
634
}
635
}
636
637
#ifdef MNG_SUPPORT_TRACE
638
MNG_TRACE (pData, MNG_FN_WRITE_RAW_CHUNK, MNG_LC_END);
639
#endif
640
641
return MNG_NOERROR;
642
}
643
644
/* ************************************************************************** */
645
/* B004 */
646
#endif /* MNG_INCLUDE_WRITE_PROCS */
647
/* B004 */
648
/* ************************************************************************** */
649
/* * * */
650
/* * chunk read functions * */
651
/* * * */
652
/* ************************************************************************** */
653
654
#ifdef MNG_INCLUDE_READ_PROCS
655
656
/* ************************************************************************** */
657
658
#ifdef MNG_OPTIMIZE_CHUNKREADER
659
660
/* ************************************************************************** */
661
662
MNG_LOCAL mng_retcode create_chunk_storage (mng_datap pData,
663
mng_chunkp pHeader,
664
mng_uint32 iRawlen,
665
mng_uint8p pRawdata,
666
mng_field_descp pField,
667
mng_uint16 iFields,
668
mng_chunkp* ppChunk,
669
mng_bool bWorkcopy)
670
{
671
mng_field_descp pTempfield = pField;
672
mng_uint16 iFieldcount = iFields;
673
mng_uint8p pTempdata = pRawdata;
674
mng_uint32 iTemplen = iRawlen;
675
mng_uint16 iLastgroup = 0;
676
mng_uint8p pChunkdata;
677
mng_uint32 iDatalen;
678
mng_uint8 iColortype;
679
mng_bool bProcess;
680
/* initialize storage */
681
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
682
if (iRetcode) /* on error bail out */
683
return iRetcode;
684
685
if (((mng_chunk_headerp)(*ppChunk))->iChunkname == MNG_UINT_HUH)
686
((mng_chunk_headerp)(*ppChunk))->iChunkname = pData->iChunkname;
687
688
if ((!bWorkcopy) ||
689
((((mng_chunk_headerp)pHeader)->iChunkname != MNG_UINT_IDAT) &&
690
(((mng_chunk_headerp)pHeader)->iChunkname != MNG_UINT_JDAT) &&
691
(((mng_chunk_headerp)pHeader)->iChunkname != MNG_UINT_JDAA) ))
692
{
693
pChunkdata = (mng_uint8p)(*ppChunk);
694
695
#ifdef MNG_INCLUDE_JNG /* determine current colortype */
696
if (pData->bHasJHDR)
697
iColortype = (mng_uint8)(pData->iJHDRcolortype - 8);
698
else
699
#endif /* MNG_INCLUDE_JNG */
700
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
701
iColortype = pData->iColortype;
702
else
703
iColortype = 6;
704
705
if (iTemplen) /* not empty ? */
706
{ /* then go fill the fields */
707
while ((iFieldcount) && (iTemplen))
708
{
709
if (pTempfield->iOffsetchunk)
710
{
711
if (pTempfield->iFlags & MNG_FIELD_PUTIMGTYPE)
712
{
713
*(pChunkdata+pTempfield->iOffsetchunk) = iColortype;
714
bProcess = MNG_FALSE;
715
}
716
else
717
if (pTempfield->iFlags & MNG_FIELD_IFIMGTYPES)
718
bProcess = (mng_bool)(((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE0) && (iColortype == 0)) ||
719
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE2) && (iColortype == 2)) ||
720
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE3) && (iColortype == 3)) ||
721
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE4) && (iColortype == 4)) ||
722
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE6) && (iColortype == 6)) );
723
else
724
bProcess = MNG_TRUE;
725
726
if (bProcess)
727
{
728
iLastgroup = (mng_uint16)(pTempfield->iFlags & MNG_FIELD_GROUPMASK);
729
/* numeric field ? */
730
if (pTempfield->iFlags & MNG_FIELD_INT)
731
{
732
if (iTemplen < pTempfield->iLengthmax)
733
MNG_ERROR (pData, MNG_INVALIDLENGTH);
734
735
switch (pTempfield->iLengthmax)
736
{
737
case 1 : { mng_uint8 iNum = *pTempdata;
738
if (((mng_uint16)iNum < pTempfield->iMinvalue) ||
739
((mng_uint16)iNum > pTempfield->iMaxvalue) )
740
MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
741
*(pChunkdata+pTempfield->iOffsetchunk) = iNum;
742
break; }
743
case 2 : { mng_uint16 iNum = mng_get_uint16 (pTempdata);
744
if ((iNum < pTempfield->iMinvalue) || (iNum > pTempfield->iMaxvalue))
745
MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
746
*((mng_uint16p)(pChunkdata+pTempfield->iOffsetchunk)) = iNum;
747
break; }
748
case 4 : { mng_uint32 iNum = mng_get_uint32 (pTempdata);
749
if ((iNum < pTempfield->iMinvalue) ||
750
((pTempfield->iFlags & MNG_FIELD_NOHIGHBIT) && (iNum & 0x80000000)) )
751
MNG_ERROR (pData, MNG_INVALIDFIELDVAL);
752
*((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunk)) = iNum;
753
break; }
754
}
755
756
pTempdata += pTempfield->iLengthmax;
757
iTemplen -= pTempfield->iLengthmax;
758
759
} else { /* not numeric so it's a bunch of bytes */
760
761
if (!pTempfield->iOffsetchunklen) /* big fat NONO */
762
MNG_ERROR (pData, MNG_INTERNALERROR);
763
/* with terminating 0 ? */
764
if (pTempfield->iFlags & MNG_FIELD_TERMINATOR)
765
{
766
mng_uint8p pWork = pTempdata;
767
while (*pWork) /* find the zero */
768
pWork++;
769
iDatalen = (mng_uint32)(pWork - pTempdata);
770
} else { /* no terminator, so everything that's left ! */
771
iDatalen = iTemplen;
772
}
773
774
if ((pTempfield->iLengthmax) && (iDatalen > pTempfield->iLengthmax))
775
MNG_ERROR (pData, MNG_INVALIDLENGTH);
776
/* needs decompression ? */
777
if (pTempfield->iFlags & MNG_FIELD_DEFLATED)
778
{
779
mng_uint8p pBuf = 0;
780
mng_uint32 iBufsize = 0;
781
mng_uint32 iRealsize;
782
mng_ptr pWork;
783
784
iRetcode = mng_inflate_buffer (pData, pTempdata, iDatalen,
785
&pBuf, &iBufsize, &iRealsize);
786
787
#ifdef MNG_CHECK_BAD_ICCP /* Check for bad iCCP chunk */
788
if ((iRetcode) && (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_iCCP))
789
{
790
*((mng_ptr *)(pChunkdata+pTempfield->iOffsetchunk)) = MNG_NULL;
791
*((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunklen)) = iDatalen;
792
}
793
else
794
#endif
795
{
796
if (iRetcode)
797
return iRetcode;
798
/* don't forget to generate null terminator */
799
MNG_ALLOC (pData, pWork, iRealsize+1);
800
MNG_COPY (pWork, pBuf, iRealsize);
801
802
*((mng_ptr *)(pChunkdata+pTempfield->iOffsetchunk)) = pWork;
803
*((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunklen)) = iRealsize;
804
}
805
806
if (pBuf) /* free the temporary buffer */
807
MNG_FREEX (pData, pBuf, iBufsize);
808
809
} else { /* no decompression, so just copy */
810
811
mng_ptr pWork;
812
/* don't forget to generate null terminator */
813
MNG_ALLOC (pData, pWork, iDatalen+1);
814
MNG_COPY (pWork, pTempdata, iDatalen);
815
816
*((mng_ptr *)(pChunkdata+pTempfield->iOffsetchunk)) = pWork;
817
*((mng_uint32p)(pChunkdata+pTempfield->iOffsetchunklen)) = iDatalen;
818
}
819
820
if (pTempfield->iFlags & MNG_FIELD_TERMINATOR)
821
iDatalen++; /* skip the terminating zero as well !!! */
822
823
iTemplen -= iDatalen;
824
pTempdata += iDatalen;
825
}
826
/* need to set an indicator ? */
827
if (pTempfield->iOffsetchunkind)
828
*((mng_uint8p)(pChunkdata+pTempfield->iOffsetchunkind)) = MNG_TRUE;
829
}
830
}
831
832
if (pTempfield->pSpecialfunc) /* special function required ? */
833
{
834
iRetcode = pTempfield->pSpecialfunc(pData, *ppChunk, &iTemplen, &pTempdata);
835
if (iRetcode) /* on error bail out */
836
return iRetcode;
837
}
838
839
pTempfield++; /* Neeeeeeexxxtt */
840
iFieldcount--;
841
}
842
843
if (iTemplen) /* extra data ??? */
844
MNG_ERROR (pData, MNG_INVALIDLENGTH);
845
846
while (iFieldcount) /* not enough data ??? */
847
{
848
if (pTempfield->iFlags & MNG_FIELD_IFIMGTYPES)
849
bProcess = (mng_bool)(((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE0) && (iColortype == 0)) ||
850
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE2) && (iColortype == 2)) ||
851
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE3) && (iColortype == 3)) ||
852
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE4) && (iColortype == 4)) ||
853
((pTempfield->iFlags & MNG_FIELD_IFIMGTYPE6) && (iColortype == 6)) );
854
else
855
bProcess = MNG_TRUE;
856
857
if (bProcess)
858
{
859
if (!(pTempfield->iFlags & MNG_FIELD_OPTIONAL))
860
MNG_ERROR (pData, MNG_INVALIDLENGTH);
861
if ((pTempfield->iFlags & MNG_FIELD_GROUPMASK) &&
862
((mng_uint16)(pTempfield->iFlags & MNG_FIELD_GROUPMASK) == iLastgroup))
863
MNG_ERROR (pData, MNG_INVALIDLENGTH);
864
}
865
866
pTempfield++;
867
iFieldcount--;
868
}
869
}
870
}
871
872
return MNG_NOERROR;
873
}
874
875
/* ************************************************************************** */
876
877
READ_CHUNK (mng_read_general)
878
{
879
mng_chunk_descp pDescr = ((mng_chunk_headerp)pHeader)->pChunkdescr;
880
mng_field_descp pField = pDescr->pFielddesc;
881
mng_uint16 iFields = pDescr->iFielddesc;
882
mng_retcode iRetcode = MNG_NOERROR;
883
884
if (!pDescr) /* this is a bad booboo !!! */
885
MNG_ERROR (pData, MNG_INTERNALERROR);
886
/* check chunk against signature */
887
if ((pDescr->eImgtype == mng_it_mng) && (pData->eSigtype != mng_it_mng))
888
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
889
890
if ((pDescr->eImgtype == mng_it_jng) && (pData->eSigtype == mng_it_png))
891
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
892
/* empties allowed ? */
893
if ((iRawlen == 0) && (!(pDescr->iAllowed & MNG_DESCR_EMPTY)))
894
MNG_ERROR (pData, MNG_INVALIDLENGTH);
895
896
if ((pData->eImagetype != mng_it_mng) || (!(pDescr->iAllowed & MNG_DESCR_GLOBAL)))
897
{ /* *a* header required ? */
898
if ((pDescr->iMusthaves & MNG_DESCR_GenHDR) &&
899
#ifdef MNG_INCLUDE_JNG
900
(!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
901
#else
902
(!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
903
#endif
904
MNG_ERROR (pData, MNG_SEQUENCEERROR);
905
906
#ifdef MNG_INCLUDE_JNG
907
if ((pDescr->iMusthaves & MNG_DESCR_JngHDR) &&
908
(!pData->bHasDHDR) && (!pData->bHasJHDR))
909
MNG_ERROR (pData, MNG_SEQUENCEERROR);
910
#endif
911
}
912
/* specific chunk pre-requisite ? */
913
if (((pDescr->iMusthaves & MNG_DESCR_IHDR) && (!pData->bHasIHDR)) ||
914
#ifdef MNG_INCLUDE_JNG
915
((pDescr->iMusthaves & MNG_DESCR_JHDR) && (!pData->bHasJHDR)) ||
916
#endif
917
((pDescr->iMusthaves & MNG_DESCR_DHDR) && (!pData->bHasDHDR)) ||
918
((pDescr->iMusthaves & MNG_DESCR_LOOP) && (!pData->bHasLOOP)) ||
919
((pDescr->iMusthaves & MNG_DESCR_PLTE) && (!pData->bHasPLTE)) ||
920
((pDescr->iMusthaves & MNG_DESCR_MHDR) && (!pData->bHasMHDR)) ||
921
((pDescr->iMusthaves & MNG_DESCR_SAVE) && (!pData->bHasSAVE)) )
922
MNG_ERROR (pData, MNG_SEQUENCEERROR);
923
/* specific chunk undesired ? */
924
if (((pDescr->iMustNOThaves & MNG_DESCR_NOIHDR) && (pData->bHasIHDR)) ||
925
((pDescr->iMustNOThaves & MNG_DESCR_NOBASI) && (pData->bHasBASI)) ||
926
((pDescr->iMustNOThaves & MNG_DESCR_NODHDR) && (pData->bHasDHDR)) ||
927
((pDescr->iMustNOThaves & MNG_DESCR_NOIDAT) && (pData->bHasIDAT)) ||
928
((pDescr->iMustNOThaves & MNG_DESCR_NOPLTE) && (pData->bHasPLTE)) ||
929
#ifdef MNG_INCLUDE_JNG
930
((pDescr->iMustNOThaves & MNG_DESCR_NOJHDR) && (pData->bHasJHDR)) ||
931
((pDescr->iMustNOThaves & MNG_DESCR_NOJDAT) && (pData->bHasJDAT)) ||
932
((pDescr->iMustNOThaves & MNG_DESCR_NOJDAA) && (pData->bHasJDAA)) ||
933
((pDescr->iMustNOThaves & MNG_DESCR_NOJSEP) && (pData->bHasJSEP)) ||
934
#endif
935
((pDescr->iMustNOThaves & MNG_DESCR_NOMHDR) && (pData->bHasMHDR)) ||
936
((pDescr->iMustNOThaves & MNG_DESCR_NOLOOP) && (pData->bHasLOOP)) ||
937
((pDescr->iMustNOThaves & MNG_DESCR_NOTERM) && (pData->bHasTERM)) ||
938
((pDescr->iMustNOThaves & MNG_DESCR_NOSAVE) && (pData->bHasSAVE)) )
939
MNG_ERROR (pData, MNG_SEQUENCEERROR);
940
941
if (pData->eSigtype == mng_it_mng) /* check global and embedded empty chunks */
942
{
943
#ifdef MNG_INCLUDE_JNG
944
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
945
#else
946
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
947
#endif
948
{
949
if ((iRawlen == 0) && (!(pDescr->iAllowed & MNG_DESCR_EMPTYEMBED)))
950
MNG_ERROR (pData, MNG_INVALIDLENGTH);
951
} else {
952
if ((iRawlen == 0) && (!(pDescr->iAllowed & MNG_DESCR_EMPTYGLOBAL)))
953
MNG_ERROR (pData, MNG_INVALIDLENGTH);
954
}
955
}
956
957
if (pDescr->pSpecialfunc) /* need special processing ? */
958
{
959
iRetcode = create_chunk_storage (pData, pHeader, iRawlen, pRawdata,
960
pField, iFields, ppChunk, MNG_TRUE);
961
if (iRetcode) /* on error bail out */
962
return iRetcode;
963
/* empty indicator ? */
964
if ((!iRawlen) && (pDescr->iOffsetempty))
965
*(((mng_uint8p)*ppChunk)+pDescr->iOffsetempty) = MNG_TRUE;
966
967
iRetcode = pDescr->pSpecialfunc(pData, *ppChunk);
968
if (iRetcode) /* on error bail out */
969
return iRetcode;
970
971
if ((((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_IDAT) ||
972
(((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAT) ||
973
(((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAA) )
974
{
975
iRetcode = ((mng_chunk_headerp)*ppChunk)->fCleanup (pData, *ppChunk);
976
if (iRetcode) /* on error bail out */
977
return iRetcode;
978
*ppChunk = MNG_NULL;
979
} else {
980
#ifdef MNG_STORE_CHUNKS
981
if (!pData->bStorechunks)
982
#endif
983
{
984
iRetcode = ((mng_chunk_headerp)*ppChunk)->fCleanup (pData, *ppChunk);
985
if (iRetcode) /* on error bail out */
986
return iRetcode;
987
*ppChunk = MNG_NULL;
988
}
989
}
990
}
991
992
#ifdef MNG_SUPPORT_DISPLAY
993
if (iRawlen)
994
{
995
#ifdef MNG_OPTIMIZE_DISPLAYCALLS
996
pData->iRawlen = iRawlen;
997
pData->pRawdata = pRawdata;
998
#endif
999
1000
/* display processing */
1001
#ifndef MNG_OPTIMIZE_DISPLAYCALLS
1002
if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_IDAT)
1003
iRetcode = mng_process_display_idat (pData, iRawlen, pRawdata);
1004
#ifdef MNG_INCLUDE_JNG
1005
else
1006
if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAT)
1007
iRetcode = mng_process_display_jdat (pData, iRawlen, pRawdata);
1008
else
1009
if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAA)
1010
iRetcode = mng_process_display_jdaa (pData, iRawlen, pRawdata);
1011
#endif
1012
#else
1013
if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_IDAT)
1014
iRetcode = mng_process_display_idat (pData);
1015
#ifdef MNG_INCLUDE_JNG
1016
else
1017
if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAT)
1018
iRetcode = mng_process_display_jdat (pData);
1019
else
1020
if (((mng_chunk_headerp)pHeader)->iChunkname == MNG_UINT_JDAA)
1021
iRetcode = mng_process_display_jdaa (pData);
1022
#endif
1023
#endif
1024
1025
if (iRetcode)
1026
return iRetcode;
1027
}
1028
#endif /* MNG_SUPPORT_DISPLAY */
1029
1030
#ifdef MNG_STORE_CHUNKS
1031
if ((pData->bStorechunks) && (!(*ppChunk)))
1032
{
1033
iRetcode = create_chunk_storage (pData, pHeader, iRawlen, pRawdata,
1034
pField, iFields, ppChunk, MNG_FALSE);
1035
if (iRetcode) /* on error bail out */
1036
return iRetcode;
1037
/* empty indicator ? */
1038
if ((!iRawlen) && (pDescr->iOffsetempty))
1039
*(((mng_uint8p)*ppChunk)+pDescr->iOffsetempty) = MNG_TRUE;
1040
}
1041
#endif /* MNG_STORE_CHUNKS */
1042
1043
return MNG_NOERROR;
1044
}
1045
1046
/* ************************************************************************** */
1047
1048
#endif /* MNG_OPTIMIZE_CHUNKREADER */
1049
1050
/* ************************************************************************** */
1051
1052
#ifndef MNG_OPTIMIZE_CHUNKREADER
1053
READ_CHUNK (mng_read_ihdr)
1054
{
1055
#ifdef MNG_SUPPORT_TRACE
1056
MNG_TRACE (pData, MNG_FN_READ_IHDR, MNG_LC_START);
1057
#endif
1058
1059
if (iRawlen != 13) /* length oke ? */
1060
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1061
/* only allowed inside PNG or MNG */
1062
if ((pData->eSigtype != mng_it_png) && (pData->eSigtype != mng_it_mng))
1063
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
1064
/* sequence checks */
1065
if ((pData->eSigtype == mng_it_png) && (pData->iChunkseq > 1))
1066
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1067
1068
#ifdef MNG_INCLUDE_JNG
1069
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasIDAT) || (pData->bHasJHDR))
1070
#else
1071
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasIDAT))
1072
#endif
1073
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1074
1075
pData->bHasIHDR = MNG_TRUE; /* indicate IHDR is present */
1076
/* and store interesting fields */
1077
if ((!pData->bHasDHDR) || (pData->iDeltatype == MNG_DELTATYPE_NOCHANGE))
1078
{
1079
pData->iDatawidth = mng_get_uint32 (pRawdata);
1080
pData->iDataheight = mng_get_uint32 (pRawdata+4);
1081
}
1082
1083
pData->iBitdepth = *(pRawdata+8);
1084
pData->iColortype = *(pRawdata+9);
1085
pData->iCompression = *(pRawdata+10);
1086
pData->iFilter = *(pRawdata+11);
1087
pData->iInterlace = *(pRawdata+12);
1088
1089
#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
1090
pData->iPNGmult = 1;
1091
pData->iPNGdepth = pData->iBitdepth;
1092
#endif
1093
1094
#ifdef MNG_NO_1_2_4BIT_SUPPORT
1095
if (pData->iBitdepth < 8)
1096
pData->iBitdepth = 8;
1097
#endif
1098
1099
#ifdef MNG_NO_16BIT_SUPPORT
1100
if (pData->iBitdepth > 8)
1101
{
1102
pData->iBitdepth = 8;
1103
pData->iPNGmult = 2;
1104
}
1105
#endif
1106
1107
if ((pData->iBitdepth != 8) /* parameter validity checks */
1108
#ifndef MNG_NO_1_2_4BIT_SUPPORT
1109
&& (pData->iBitdepth != 1) &&
1110
(pData->iBitdepth != 2) &&
1111
(pData->iBitdepth != 4)
1112
#endif
1113
#ifndef MNG_NO_16BIT_SUPPORT
1114
&& (pData->iBitdepth != 16)
1115
#endif
1116
)
1117
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
1118
1119
if ((pData->iColortype != MNG_COLORTYPE_GRAY ) &&
1120
(pData->iColortype != MNG_COLORTYPE_RGB ) &&
1121
(pData->iColortype != MNG_COLORTYPE_INDEXED) &&
1122
(pData->iColortype != MNG_COLORTYPE_GRAYA ) &&
1123
(pData->iColortype != MNG_COLORTYPE_RGBA ) )
1124
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
1125
1126
if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
1127
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
1128
1129
if (((pData->iColortype == MNG_COLORTYPE_RGB ) ||
1130
(pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
1131
(pData->iColortype == MNG_COLORTYPE_RGBA ) ) &&
1132
(pData->iBitdepth < 8 ) )
1133
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
1134
1135
if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
1136
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
1137
1138
#if defined(FILTER192) || defined(FILTER193)
1139
if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
1140
#if defined(FILTER192) && defined(FILTER193)
1141
(pData->iFilter != MNG_FILTER_DIFFERING) &&
1142
(pData->iFilter != MNG_FILTER_NOFILTER ) )
1143
#else
1144
#ifdef FILTER192
1145
(pData->iFilter != MNG_FILTER_DIFFERING) )
1146
#else
1147
(pData->iFilter != MNG_FILTER_NOFILTER ) )
1148
#endif
1149
#endif
1150
MNG_ERROR (pData, MNG_INVALIDFILTER);
1151
#else
1152
if (pData->iFilter)
1153
MNG_ERROR (pData, MNG_INVALIDFILTER);
1154
#endif
1155
1156
if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
1157
(pData->iInterlace != MNG_INTERLACE_ADAM7) )
1158
MNG_ERROR (pData, MNG_INVALIDINTERLACE);
1159
1160
#ifdef MNG_SUPPORT_DISPLAY
1161
#ifndef MNG_NO_DELTA_PNG
1162
if (pData->bHasDHDR) /* check the colortype for delta-images ! */
1163
{
1164
mng_imagedatap pBuf = ((mng_imagep)pData->pObjzero)->pImgbuf;
1165
1166
if (pData->iColortype != pBuf->iColortype)
1167
{
1168
if ( ( (pData->iColortype != MNG_COLORTYPE_INDEXED) ||
1169
(pBuf->iColortype == MNG_COLORTYPE_GRAY ) ) &&
1170
( (pData->iColortype != MNG_COLORTYPE_GRAY ) ||
1171
(pBuf->iColortype == MNG_COLORTYPE_INDEXED) ) )
1172
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
1173
}
1174
}
1175
#endif
1176
#endif
1177
1178
if (!pData->bHasheader) /* first chunk ? */
1179
{
1180
pData->bHasheader = MNG_TRUE; /* we've got a header */
1181
pData->eImagetype = mng_it_png; /* then this must be a PNG */
1182
pData->iWidth = pData->iDatawidth;
1183
pData->iHeight = pData->iDataheight;
1184
/* predict alpha-depth ! */
1185
if ((pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
1186
(pData->iColortype == MNG_COLORTYPE_RGBA ) )
1187
pData->iAlphadepth = pData->iBitdepth;
1188
else
1189
if (pData->iColortype == MNG_COLORTYPE_INDEXED)
1190
pData->iAlphadepth = 8; /* worst case scenario */
1191
else
1192
pData->iAlphadepth = 1; /* Possible tRNS cheap binary transparency */
1193
/* fits on maximum canvas ? */
1194
if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
1195
MNG_WARNING (pData, MNG_IMAGETOOLARGE);
1196
1197
if (pData->fProcessheader) /* inform the app ? */
1198
if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
1199
MNG_ERROR (pData, MNG_APPMISCERROR);
1200
}
1201
1202
if (!pData->bHasDHDR)
1203
pData->iImagelevel++; /* one level deeper */
1204
1205
#ifdef MNG_SUPPORT_DISPLAY
1206
{
1207
mng_retcode iRetcode = mng_process_display_ihdr (pData);
1208
1209
if (iRetcode) /* on error bail out */
1210
return iRetcode;
1211
}
1212
#endif /* MNG_SUPPORT_DISPLAY */
1213
1214
#ifdef MNG_STORE_CHUNKS
1215
if (pData->bStorechunks)
1216
{ /* initialize storage */
1217
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1218
1219
if (iRetcode) /* on error bail out */
1220
return iRetcode;
1221
/* fill the fields */
1222
((mng_ihdrp)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
1223
((mng_ihdrp)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
1224
((mng_ihdrp)*ppChunk)->iBitdepth = pData->iBitdepth;
1225
((mng_ihdrp)*ppChunk)->iColortype = pData->iColortype;
1226
((mng_ihdrp)*ppChunk)->iCompression = pData->iCompression;
1227
((mng_ihdrp)*ppChunk)->iFilter = pData->iFilter;
1228
((mng_ihdrp)*ppChunk)->iInterlace = pData->iInterlace;
1229
}
1230
#endif /* MNG_STORE_CHUNKS */
1231
1232
#ifdef MNG_SUPPORT_TRACE
1233
MNG_TRACE (pData, MNG_FN_READ_IHDR, MNG_LC_END);
1234
#endif
1235
1236
return MNG_NOERROR; /* done */
1237
}
1238
#endif /* MNG_OPTIMIZE_CHUNKREADER */
1239
1240
/* ************************************************************************** */
1241
1242
#ifndef MNG_OPTIMIZE_CHUNKREADER
1243
READ_CHUNK (mng_read_plte)
1244
{
1245
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
1246
mng_uint32 iX;
1247
mng_uint8p pRawdata2;
1248
#endif
1249
#ifdef MNG_SUPPORT_DISPLAY
1250
mng_uint32 iRawlen2;
1251
#endif
1252
1253
#ifdef MNG_SUPPORT_TRACE
1254
MNG_TRACE (pData, MNG_FN_READ_PLTE, MNG_LC_START);
1255
#endif
1256
/* sequence checks */
1257
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1258
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1259
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1260
1261
#ifdef MNG_INCLUDE_JNG
1262
if ((pData->bHasIDAT) || (pData->bHasJHDR))
1263
#else
1264
if (pData->bHasIDAT)
1265
#endif
1266
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1267
/* multiple PLTE only inside BASI */
1268
if ((pData->bHasPLTE) && (!pData->bHasBASI))
1269
MNG_ERROR (pData, MNG_MULTIPLEERROR);
1270
/* length must be multiple of 3 */
1271
if (((iRawlen % 3) != 0) || (iRawlen > 768))
1272
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1273
1274
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1275
{ /* only allowed for indexed-color or
1276
rgb(a)-color! */
1277
if ((pData->iColortype != 2) && (pData->iColortype != 3) && (pData->iColortype != 6))
1278
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
1279
/* empty only allowed if global present */
1280
if ((iRawlen == 0) && (!pData->bHasglobalPLTE))
1281
MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
1282
}
1283
else
1284
{
1285
if (iRawlen == 0) /* cannot be empty as global! */
1286
MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
1287
}
1288
1289
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1290
pData->bHasPLTE = MNG_TRUE; /* got it! */
1291
else
1292
pData->bHasglobalPLTE = MNG_TRUE;
1293
1294
pData->iPLTEcount = iRawlen / 3;
1295
1296
#ifdef MNG_SUPPORT_DISPLAY
1297
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1298
{
1299
mng_imagep pImage;
1300
mng_imagedatap pBuf;
1301
1302
#ifndef MNG_NO_DELTA_PNG
1303
if (pData->bHasDHDR) /* processing delta-image ? */
1304
{ /* store in object 0 !!! */
1305
pImage = (mng_imagep)pData->pObjzero;
1306
pBuf = pImage->pImgbuf;
1307
pBuf->bHasPLTE = MNG_TRUE; /* it's definitely got a PLTE now */
1308
pBuf->iPLTEcount = iRawlen / 3; /* this is the exact length */
1309
pRawdata2 = pRawdata; /* copy the entries */
1310
1311
for (iX = 0; iX < iRawlen / 3; iX++)
1312
{
1313
pBuf->aPLTEentries[iX].iRed = *pRawdata2;
1314
pBuf->aPLTEentries[iX].iGreen = *(pRawdata2+1);
1315
pBuf->aPLTEentries[iX].iBlue = *(pRawdata2+2);
1316
1317
pRawdata2 += 3;
1318
}
1319
}
1320
else
1321
#endif
1322
{ /* get the current object */
1323
pImage = (mng_imagep)pData->pCurrentobj;
1324
1325
if (!pImage) /* no object then dump it in obj 0 */
1326
pImage = (mng_imagep)pData->pObjzero;
1327
1328
pBuf = pImage->pImgbuf; /* address the object buffer */
1329
pBuf->bHasPLTE = MNG_TRUE; /* and tell it it's got a PLTE now */
1330
1331
if (!iRawlen) /* if empty, inherit from global */
1332
{
1333
pBuf->iPLTEcount = pData->iGlobalPLTEcount;
1334
MNG_COPY (pBuf->aPLTEentries, pData->aGlobalPLTEentries,
1335
sizeof (pBuf->aPLTEentries));
1336
1337
if (pData->bHasglobalTRNS) /* also copy global tRNS ? */
1338
{ /* indicate tRNS available */
1339
pBuf->bHasTRNS = MNG_TRUE;
1340
1341
iRawlen2 = pData->iGlobalTRNSrawlen;
1342
pRawdata2 = (mng_uint8p)(pData->aGlobalTRNSrawdata);
1343
/* global length oke ? */
1344
if ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount))
1345
MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
1346
/* copy it */
1347
pBuf->iTRNScount = iRawlen2;
1348
MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2);
1349
}
1350
}
1351
else
1352
{ /* store fields for future reference */
1353
pBuf->iPLTEcount = iRawlen / 3;
1354
pRawdata2 = pRawdata;
1355
1356
for (iX = 0; iX < pBuf->iPLTEcount; iX++)
1357
{
1358
pBuf->aPLTEentries[iX].iRed = *pRawdata2;
1359
pBuf->aPLTEentries[iX].iGreen = *(pRawdata2+1);
1360
pBuf->aPLTEentries[iX].iBlue = *(pRawdata2+2);
1361
1362
pRawdata2 += 3;
1363
}
1364
}
1365
}
1366
}
1367
else /* store as global */
1368
{
1369
pData->iGlobalPLTEcount = iRawlen / 3;
1370
pRawdata2 = pRawdata;
1371
1372
for (iX = 0; iX < pData->iGlobalPLTEcount; iX++)
1373
{
1374
pData->aGlobalPLTEentries[iX].iRed = *pRawdata2;
1375
pData->aGlobalPLTEentries[iX].iGreen = *(pRawdata2+1);
1376
pData->aGlobalPLTEentries[iX].iBlue = *(pRawdata2+2);
1377
1378
pRawdata2 += 3;
1379
}
1380
1381
{ /* create an animation object */
1382
mng_retcode iRetcode = mng_create_ani_plte (pData, pData->iGlobalPLTEcount,
1383
pData->aGlobalPLTEentries);
1384
if (iRetcode) /* on error bail out */
1385
return iRetcode;
1386
}
1387
}
1388
#endif /* MNG_SUPPORT_DISPLAY */
1389
1390
#ifdef MNG_STORE_CHUNKS
1391
if (pData->bStorechunks)
1392
{ /* initialize storage */
1393
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1394
1395
if (iRetcode) /* on error bail out */
1396
return iRetcode;
1397
/* store the fields */
1398
((mng_pltep)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1399
((mng_pltep)*ppChunk)->iEntrycount = iRawlen / 3;
1400
pRawdata2 = pRawdata;
1401
1402
for (iX = 0; iX < ((mng_pltep)*ppChunk)->iEntrycount; iX++)
1403
{
1404
((mng_pltep)*ppChunk)->aEntries[iX].iRed = *pRawdata2;
1405
((mng_pltep)*ppChunk)->aEntries[iX].iGreen = *(pRawdata2+1);
1406
((mng_pltep)*ppChunk)->aEntries[iX].iBlue = *(pRawdata2+2);
1407
1408
pRawdata2 += 3;
1409
}
1410
}
1411
#endif /* MNG_STORE_CHUNKS */
1412
1413
#ifdef MNG_SUPPORT_TRACE
1414
MNG_TRACE (pData, MNG_FN_READ_PLTE, MNG_LC_END);
1415
#endif
1416
1417
return MNG_NOERROR; /* done */
1418
}
1419
#endif /* MNG_OPTIMIZE_CHUNKREADER */
1420
1421
/* ************************************************************************** */
1422
1423
#ifndef MNG_OPTIMIZE_CHUNKREADER
1424
READ_CHUNK (mng_read_idat)
1425
{
1426
#ifdef MNG_SUPPORT_TRACE
1427
MNG_TRACE (pData, MNG_FN_READ_IDAT, MNG_LC_START);
1428
#endif
1429
1430
#ifdef MNG_INCLUDE_JNG /* sequence checks */
1431
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1432
#else
1433
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
1434
#endif
1435
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1436
1437
#ifdef MNG_INCLUDE_JNG
1438
if ((pData->bHasJHDR) &&
1439
(pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE))
1440
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1441
1442
if (pData->bHasJSEP)
1443
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1444
#endif
1445
/* not allowed for deltatype NO_CHANGE */
1446
#ifndef MNG_NO_DELTA_PNG
1447
if ((pData->bHasDHDR) && ((pData->iDeltatype == MNG_DELTATYPE_NOCHANGE)))
1448
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
1449
#endif
1450
/* can only be empty in BASI-block! */
1451
if ((iRawlen == 0) && (!pData->bHasBASI))
1452
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1453
/* indexed-color requires PLTE */
1454
if ((pData->bHasIHDR) && (pData->iColortype == 3) && (!pData->bHasPLTE))
1455
MNG_ERROR (pData, MNG_PLTEMISSING);
1456
1457
pData->bHasIDAT = MNG_TRUE; /* got some IDAT now, don't we */
1458
1459
#ifdef MNG_SUPPORT_DISPLAY
1460
if (iRawlen)
1461
{ /* display processing */
1462
mng_retcode iRetcode = mng_process_display_idat (pData, iRawlen, pRawdata);
1463
1464
if (iRetcode) /* on error bail out */
1465
return iRetcode;
1466
}
1467
#endif /* MNG_SUPPORT_DISPLAY */
1468
1469
#ifdef MNG_STORE_CHUNKS
1470
if (pData->bStorechunks)
1471
{ /* initialize storage */
1472
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1473
1474
if (iRetcode) /* on error bail out */
1475
return iRetcode;
1476
/* store the fields */
1477
((mng_idatp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1478
((mng_idatp)*ppChunk)->iDatasize = iRawlen;
1479
1480
if (iRawlen != 0) /* is there any data ? */
1481
{
1482
MNG_ALLOC (pData, ((mng_idatp)*ppChunk)->pData, iRawlen);
1483
MNG_COPY (((mng_idatp)*ppChunk)->pData, pRawdata, iRawlen);
1484
}
1485
}
1486
#endif /* MNG_STORE_CHUNKS */
1487
1488
#ifdef MNG_SUPPORT_TRACE
1489
MNG_TRACE (pData, MNG_FN_READ_IDAT, MNG_LC_END);
1490
#endif
1491
1492
return MNG_NOERROR; /* done */
1493
}
1494
#endif
1495
1496
/* ************************************************************************** */
1497
1498
#ifndef MNG_OPTIMIZE_CHUNKREADER
1499
READ_CHUNK (mng_read_iend)
1500
{
1501
#ifdef MNG_SUPPORT_TRACE
1502
MNG_TRACE (pData, MNG_FN_READ_IEND, MNG_LC_START);
1503
#endif
1504
1505
if (iRawlen > 0) /* must not contain data! */
1506
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1507
1508
#ifdef MNG_INCLUDE_JNG /* sequence checks */
1509
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1510
#else
1511
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR))
1512
#endif
1513
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1514
/* IHDR-block requires IDAT */
1515
if ((pData->bHasIHDR) && (!pData->bHasIDAT))
1516
MNG_ERROR (pData, MNG_IDATMISSING);
1517
1518
pData->iImagelevel--; /* one level up */
1519
1520
#ifdef MNG_SUPPORT_DISPLAY
1521
{ /* create an animation object */
1522
mng_retcode iRetcode = mng_create_ani_image (pData);
1523
if (iRetcode) /* on error bail out */
1524
return iRetcode;
1525
/* display processing */
1526
iRetcode = mng_process_display_iend (pData);
1527
if (iRetcode) /* on error bail out */
1528
return iRetcode;
1529
}
1530
#endif /* MNG_SUPPORT_DISPLAY */
1531
1532
#ifdef MNG_SUPPORT_DISPLAY
1533
if (!pData->bTimerset) /* reset only if not broken !!! */
1534
{
1535
#endif
1536
/* IEND signals the end for most ... */
1537
pData->bHasIHDR = MNG_FALSE;
1538
pData->bHasBASI = MNG_FALSE;
1539
pData->bHasDHDR = MNG_FALSE;
1540
#ifdef MNG_INCLUDE_JNG
1541
pData->bHasJHDR = MNG_FALSE;
1542
pData->bHasJSEP = MNG_FALSE;
1543
pData->bHasJDAA = MNG_FALSE;
1544
pData->bHasJDAT = MNG_FALSE;
1545
#endif
1546
pData->bHasPLTE = MNG_FALSE;
1547
pData->bHasTRNS = MNG_FALSE;
1548
pData->bHasGAMA = MNG_FALSE;
1549
pData->bHasCHRM = MNG_FALSE;
1550
pData->bHasSRGB = MNG_FALSE;
1551
pData->bHasICCP = MNG_FALSE;
1552
pData->bHasBKGD = MNG_FALSE;
1553
pData->bHasIDAT = MNG_FALSE;
1554
#ifdef MNG_SUPPORT_DISPLAY
1555
}
1556
#endif
1557
1558
#ifdef MNG_STORE_CHUNKS
1559
if (pData->bStorechunks)
1560
{ /* initialize storage */
1561
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1562
1563
if (iRetcode) /* on error bail out */
1564
return iRetcode;
1565
}
1566
#endif /* MNG_STORE_CHUNKS */
1567
1568
#ifdef MNG_SUPPORT_TRACE
1569
MNG_TRACE (pData, MNG_FN_READ_IEND, MNG_LC_END);
1570
#endif
1571
1572
return MNG_NOERROR; /* done */
1573
}
1574
#endif
1575
1576
/* ************************************************************************** */
1577
1578
#ifndef MNG_OPTIMIZE_CHUNKREADER
1579
READ_CHUNK (mng_read_trns)
1580
{
1581
#ifdef MNG_SUPPORT_TRACE
1582
MNG_TRACE (pData, MNG_FN_READ_TRNS, MNG_LC_START);
1583
#endif
1584
/* sequence checks */
1585
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1586
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1587
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1588
1589
#ifdef MNG_INCLUDE_JNG
1590
if ((pData->bHasIDAT) || (pData->bHasJHDR))
1591
#else
1592
if (pData->bHasIDAT)
1593
#endif
1594
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1595
/* multiple tRNS only inside BASI */
1596
if ((pData->bHasTRNS) && (!pData->bHasBASI))
1597
MNG_ERROR (pData, MNG_MULTIPLEERROR);
1598
1599
if (iRawlen > 256) /* it just can't be bigger than that! */
1600
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1601
1602
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1603
{ /* not allowed with full alpha-channel */
1604
if ((pData->iColortype == 4) || (pData->iColortype == 6))
1605
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
1606
1607
if (iRawlen != 0) /* filled ? */
1608
{ /* length checks */
1609
if ((pData->iColortype == 0) && (iRawlen != 2))
1610
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1611
1612
if ((pData->iColortype == 2) && (iRawlen != 6))
1613
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1614
1615
#ifdef MNG_SUPPORT_DISPLAY
1616
if (pData->iColortype == 3)
1617
{
1618
mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
1619
mng_imagedatap pBuf;
1620
1621
if (!pImage) /* no object then check obj 0 */
1622
pImage = (mng_imagep)pData->pObjzero;
1623
1624
pBuf = pImage->pImgbuf; /* address object buffer */
1625
1626
if (iRawlen > pBuf->iPLTEcount)
1627
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1628
}
1629
#endif
1630
}
1631
else /* if empty there must be global stuff! */
1632
{
1633
if (!pData->bHasglobalTRNS)
1634
MNG_ERROR (pData, MNG_CANNOTBEEMPTY);
1635
}
1636
}
1637
1638
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1639
pData->bHasTRNS = MNG_TRUE; /* indicate tRNS available */
1640
else
1641
pData->bHasglobalTRNS = MNG_TRUE;
1642
1643
#ifdef MNG_SUPPORT_DISPLAY
1644
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1645
{
1646
mng_imagep pImage;
1647
mng_imagedatap pBuf;
1648
mng_uint8p pRawdata2;
1649
mng_uint32 iRawlen2;
1650
1651
#ifndef MNG_NO_DELTA_PNG
1652
if (pData->bHasDHDR) /* processing delta-image ? */
1653
{ /* store in object 0 !!! */
1654
pImage = (mng_imagep)pData->pObjzero;
1655
pBuf = pImage->pImgbuf; /* address object buffer */
1656
1657
switch (pData->iColortype) /* store fields for future reference */
1658
{
1659
case 0: { /* gray */
1660
#if defined(MNG_NO_1_2_4BIT_SUPPORT)
1661
mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1,
1662
0,0,0,0,0,0,0,1};
1663
#endif
1664
pBuf->iTRNSgray = mng_get_uint16 (pRawdata);
1665
pBuf->iTRNSred = 0;
1666
pBuf->iTRNSgreen = 0;
1667
pBuf->iTRNSblue = 0;
1668
pBuf->iTRNScount = 0;
1669
#if defined(MNG_NO_1_2_4BIT_SUPPORT)
1670
pBuf->iTRNSgray *= multiplier[pData->iPNGdepth];
1671
#endif
1672
#if defined(MNG_NO_16BIT_SUPPORT)
1673
if (pData->iPNGmult == 2)
1674
pBuf->iTRNSgray >>= 8;
1675
#endif
1676
break;
1677
}
1678
case 2: { /* rgb */
1679
pBuf->iTRNSgray = 0;
1680
pBuf->iTRNSred = mng_get_uint16 (pRawdata);
1681
pBuf->iTRNSgreen = mng_get_uint16 (pRawdata+2);
1682
pBuf->iTRNSblue = mng_get_uint16 (pRawdata+4);
1683
pBuf->iTRNScount = 0;
1684
#if defined(MNG_NO_16BIT_SUPPORT)
1685
if (pData->iPNGmult == 2)
1686
{
1687
pBuf->iTRNSred >>= 8;
1688
pBuf->iTRNSgreen >>= 8;
1689
pBuf->iTRNSblue >>= 8;
1690
}
1691
#endif
1692
break;
1693
}
1694
case 3: { /* indexed */
1695
pBuf->iTRNSgray = 0;
1696
pBuf->iTRNSred = 0;
1697
pBuf->iTRNSgreen = 0;
1698
pBuf->iTRNSblue = 0;
1699
pBuf->iTRNScount = iRawlen;
1700
MNG_COPY (pBuf->aTRNSentries, pRawdata, iRawlen);
1701
break;
1702
}
1703
}
1704
1705
pBuf->bHasTRNS = MNG_TRUE; /* tell it it's got a tRNS now */
1706
}
1707
else
1708
#endif
1709
{ /* address current object */
1710
pImage = (mng_imagep)pData->pCurrentobj;
1711
1712
if (!pImage) /* no object then dump it in obj 0 */
1713
pImage = (mng_imagep)pData->pObjzero;
1714
1715
pBuf = pImage->pImgbuf; /* address object buffer */
1716
pBuf->bHasTRNS = MNG_TRUE; /* and tell it it's got a tRNS now */
1717
1718
if (iRawlen == 0) /* if empty, inherit from global */
1719
{
1720
iRawlen2 = pData->iGlobalTRNSrawlen;
1721
pRawdata2 = (mng_ptr)(pData->aGlobalTRNSrawdata);
1722
/* global length oke ? */
1723
if ((pData->iColortype == 0) && (iRawlen2 != 2))
1724
MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
1725
1726
if ((pData->iColortype == 2) && (iRawlen2 != 6))
1727
MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
1728
1729
if ((pData->iColortype == 3) && ((iRawlen2 == 0) || (iRawlen2 > pBuf->iPLTEcount)))
1730
MNG_ERROR (pData, MNG_GLOBALLENGTHERR);
1731
}
1732
else
1733
{
1734
iRawlen2 = iRawlen;
1735
pRawdata2 = pRawdata;
1736
}
1737
1738
switch (pData->iColortype) /* store fields for future reference */
1739
{
1740
case 0: { /* gray */
1741
pBuf->iTRNSgray = mng_get_uint16 (pRawdata2);
1742
pBuf->iTRNSred = 0;
1743
pBuf->iTRNSgreen = 0;
1744
pBuf->iTRNSblue = 0;
1745
pBuf->iTRNScount = 0;
1746
#if defined(MNG_NO_16BIT_SUPPORT)
1747
if (pData->iPNGmult == 2)
1748
pBuf->iTRNSgray >>= 8;
1749
#endif
1750
break;
1751
}
1752
case 2: { /* rgb */
1753
pBuf->iTRNSgray = 0;
1754
pBuf->iTRNSred = mng_get_uint16 (pRawdata2);
1755
pBuf->iTRNSgreen = mng_get_uint16 (pRawdata2+2);
1756
pBuf->iTRNSblue = mng_get_uint16 (pRawdata2+4);
1757
pBuf->iTRNScount = 0;
1758
#if defined(MNG_NO_16BIT_SUPPORT)
1759
if (pData->iPNGmult == 2)
1760
{
1761
pBuf->iTRNSred >>= 8;
1762
pBuf->iTRNSgreen >>= 8;
1763
pBuf->iTRNSblue >>= 8;
1764
}
1765
#endif
1766
break;
1767
}
1768
case 3: { /* indexed */
1769
pBuf->iTRNSgray = 0;
1770
pBuf->iTRNSred = 0;
1771
pBuf->iTRNSgreen = 0;
1772
pBuf->iTRNSblue = 0;
1773
pBuf->iTRNScount = iRawlen2;
1774
MNG_COPY (pBuf->aTRNSentries, pRawdata2, iRawlen2);
1775
break;
1776
}
1777
}
1778
}
1779
}
1780
else /* store as global */
1781
{
1782
pData->iGlobalTRNSrawlen = iRawlen;
1783
MNG_COPY (pData->aGlobalTRNSrawdata, pRawdata, iRawlen);
1784
1785
{ /* create an animation object */
1786
mng_retcode iRetcode = mng_create_ani_trns (pData, pData->iGlobalTRNSrawlen,
1787
pData->aGlobalTRNSrawdata);
1788
1789
if (iRetcode) /* on error bail out */
1790
return iRetcode;
1791
}
1792
}
1793
#endif /* MNG_SUPPORT_DISPLAY */
1794
1795
#ifdef MNG_STORE_CHUNKS
1796
if (pData->bStorechunks)
1797
{ /* initialize storage */
1798
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1799
1800
if (iRetcode) /* on error bail out */
1801
return iRetcode;
1802
1803
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1804
{ /* not global! */
1805
((mng_trnsp)*ppChunk)->bGlobal = MNG_FALSE;
1806
((mng_trnsp)*ppChunk)->iType = pData->iColortype;
1807
1808
if (iRawlen == 0) /* if empty, indicate so */
1809
((mng_trnsp)*ppChunk)->bEmpty = MNG_TRUE;
1810
else
1811
{
1812
((mng_trnsp)*ppChunk)->bEmpty = MNG_FALSE;
1813
1814
switch (pData->iColortype) /* store fields */
1815
{
1816
case 0: { /* gray */
1817
((mng_trnsp)*ppChunk)->iGray = mng_get_uint16 (pRawdata);
1818
break;
1819
}
1820
case 2: { /* rgb */
1821
((mng_trnsp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
1822
((mng_trnsp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
1823
((mng_trnsp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
1824
break;
1825
}
1826
case 3: { /* indexed */
1827
((mng_trnsp)*ppChunk)->iCount = iRawlen;
1828
MNG_COPY (((mng_trnsp)*ppChunk)->aEntries, pRawdata, iRawlen);
1829
break;
1830
}
1831
}
1832
}
1833
}
1834
else /* it's global! */
1835
{
1836
((mng_trnsp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1837
((mng_trnsp)*ppChunk)->bGlobal = MNG_TRUE;
1838
((mng_trnsp)*ppChunk)->iType = 0;
1839
((mng_trnsp)*ppChunk)->iRawlen = iRawlen;
1840
1841
MNG_COPY (((mng_trnsp)*ppChunk)->aRawdata, pRawdata, iRawlen);
1842
}
1843
}
1844
#endif /* MNG_STORE_CHUNKS */
1845
1846
#ifdef MNG_SUPPORT_TRACE
1847
MNG_TRACE (pData, MNG_FN_READ_TRNS, MNG_LC_END);
1848
#endif
1849
1850
return MNG_NOERROR; /* done */
1851
}
1852
#endif
1853
1854
/* ************************************************************************** */
1855
1856
#ifndef MNG_OPTIMIZE_CHUNKREADER
1857
READ_CHUNK (mng_read_gama)
1858
{
1859
#ifdef MNG_SUPPORT_TRACE
1860
MNG_TRACE (pData, MNG_FN_READ_GAMA, MNG_LC_START);
1861
#endif
1862
/* sequence checks */
1863
#ifdef MNG_INCLUDE_JNG
1864
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1865
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1866
#else
1867
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1868
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1869
#endif
1870
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1871
1872
#ifdef MNG_INCLUDE_JNG
1873
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
1874
#else
1875
if ((pData->bHasIDAT) || (pData->bHasPLTE))
1876
#endif
1877
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1878
1879
#ifdef MNG_INCLUDE_JNG
1880
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1881
#else
1882
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1883
#endif
1884
{ /* length must be exactly 4 */
1885
if (iRawlen != 4)
1886
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1887
}
1888
else
1889
{ /* length must be empty or exactly 4 */
1890
if ((iRawlen != 0) && (iRawlen != 4))
1891
MNG_ERROR (pData, MNG_INVALIDLENGTH);
1892
}
1893
1894
#ifdef MNG_INCLUDE_JNG
1895
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1896
#else
1897
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1898
#endif
1899
pData->bHasGAMA = MNG_TRUE; /* indicate we've got it */
1900
else
1901
pData->bHasglobalGAMA = (mng_bool)(iRawlen != 0);
1902
1903
#ifdef MNG_SUPPORT_DISPLAY
1904
#ifdef MNG_INCLUDE_JNG
1905
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1906
#else
1907
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
1908
#endif
1909
{
1910
mng_imagep pImage;
1911
1912
#ifndef MNG_NO_DELTA_PNG
1913
if (pData->bHasDHDR) /* update delta image ? */
1914
{ /* store in object 0 ! */
1915
pImage = (mng_imagep)pData->pObjzero;
1916
/* store for color-processing routines */
1917
pImage->pImgbuf->iGamma = mng_get_uint32 (pRawdata);
1918
pImage->pImgbuf->bHasGAMA = MNG_TRUE;
1919
}
1920
else
1921
#endif
1922
{
1923
pImage = (mng_imagep)pData->pCurrentobj;
1924
1925
if (!pImage) /* no object then dump it in obj 0 */
1926
pImage = (mng_imagep)pData->pObjzero;
1927
/* store for color-processing routines */
1928
pImage->pImgbuf->iGamma = mng_get_uint32 (pRawdata);
1929
pImage->pImgbuf->bHasGAMA = MNG_TRUE;
1930
}
1931
}
1932
else
1933
{ /* store as global */
1934
if (iRawlen != 0)
1935
pData->iGlobalGamma = mng_get_uint32 (pRawdata);
1936
1937
{ /* create an animation object */
1938
mng_retcode iRetcode = mng_create_ani_gama (pData, (mng_bool)(iRawlen == 0),
1939
pData->iGlobalGamma);
1940
1941
if (iRetcode) /* on error bail out */
1942
return iRetcode;
1943
}
1944
}
1945
#endif /* MNG_SUPPORT_DISPLAY */
1946
1947
#ifdef MNG_STORE_CHUNKS
1948
if (pData->bStorechunks)
1949
{ /* initialize storage */
1950
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
1951
1952
if (iRetcode) /* on error bail out */
1953
return iRetcode;
1954
/* store the fields */
1955
((mng_gamap)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
1956
1957
if (iRawlen)
1958
((mng_gamap)*ppChunk)->iGamma = mng_get_uint32 (pRawdata);
1959
1960
}
1961
#endif /* MNG_STORE_CHUNKS */
1962
1963
#ifdef MNG_SUPPORT_TRACE
1964
MNG_TRACE (pData, MNG_FN_READ_GAMA, MNG_LC_END);
1965
#endif
1966
1967
return MNG_NOERROR; /* done */
1968
}
1969
#endif
1970
1971
/* ************************************************************************** */
1972
1973
#ifndef MNG_OPTIMIZE_CHUNKREADER
1974
#ifndef MNG_SKIPCHUNK_cHRM
1975
READ_CHUNK (mng_read_chrm)
1976
{
1977
#ifdef MNG_SUPPORT_TRACE
1978
MNG_TRACE (pData, MNG_FN_READ_CHRM, MNG_LC_START);
1979
#endif
1980
/* sequence checks */
1981
#ifdef MNG_INCLUDE_JNG
1982
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1983
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
1984
#else
1985
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
1986
(!pData->bHasBASI) && (!pData->bHasDHDR) )
1987
#endif
1988
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1989
1990
#ifdef MNG_INCLUDE_JNG
1991
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
1992
#else
1993
if ((pData->bHasIDAT) || (pData->bHasPLTE))
1994
#endif
1995
MNG_ERROR (pData, MNG_SEQUENCEERROR);
1996
1997
#ifdef MNG_INCLUDE_JNG
1998
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
1999
#else
2000
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2001
#endif
2002
{ /* length must be exactly 32 */
2003
if (iRawlen != 32)
2004
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2005
}
2006
else
2007
{ /* length must be empty or exactly 32 */
2008
if ((iRawlen != 0) && (iRawlen != 32))
2009
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2010
}
2011
2012
#ifdef MNG_INCLUDE_JNG
2013
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2014
#else
2015
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2016
#endif
2017
pData->bHasCHRM = MNG_TRUE; /* indicate we've got it */
2018
else
2019
pData->bHasglobalCHRM = (mng_bool)(iRawlen != 0);
2020
2021
#ifdef MNG_SUPPORT_DISPLAY
2022
{
2023
mng_uint32 iWhitepointx, iWhitepointy;
2024
mng_uint32 iPrimaryredx, iPrimaryredy;
2025
mng_uint32 iPrimarygreenx, iPrimarygreeny;
2026
mng_uint32 iPrimarybluex, iPrimarybluey;
2027
2028
iWhitepointx = mng_get_uint32 (pRawdata);
2029
iWhitepointy = mng_get_uint32 (pRawdata+4);
2030
iPrimaryredx = mng_get_uint32 (pRawdata+8);
2031
iPrimaryredy = mng_get_uint32 (pRawdata+12);
2032
iPrimarygreenx = mng_get_uint32 (pRawdata+16);
2033
iPrimarygreeny = mng_get_uint32 (pRawdata+20);
2034
iPrimarybluex = mng_get_uint32 (pRawdata+24);
2035
iPrimarybluey = mng_get_uint32 (pRawdata+28);
2036
2037
#ifdef MNG_INCLUDE_JNG
2038
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2039
#else
2040
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2041
#endif
2042
{
2043
mng_imagep pImage;
2044
mng_imagedatap pBuf;
2045
2046
#ifndef MNG_NO_DELTA_PNG
2047
if (pData->bHasDHDR) /* update delta image ? */
2048
{ /* store it in object 0 ! */
2049
pImage = (mng_imagep)pData->pObjzero;
2050
2051
pBuf = pImage->pImgbuf; /* address object buffer */
2052
pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */
2053
/* store for color-processing routines */
2054
pBuf->iWhitepointx = iWhitepointx;
2055
pBuf->iWhitepointy = iWhitepointy;
2056
pBuf->iPrimaryredx = iPrimaryredx;
2057
pBuf->iPrimaryredy = iPrimaryredy;
2058
pBuf->iPrimarygreenx = iPrimarygreenx;
2059
pBuf->iPrimarygreeny = iPrimarygreeny;
2060
pBuf->iPrimarybluex = iPrimarybluex;
2061
pBuf->iPrimarybluey = iPrimarybluey;
2062
}
2063
else
2064
#endif
2065
{
2066
pImage = (mng_imagep)pData->pCurrentobj;
2067
2068
if (!pImage) /* no object then dump it in obj 0 */
2069
pImage = (mng_imagep)pData->pObjzero;
2070
2071
pBuf = pImage->pImgbuf; /* address object buffer */
2072
pBuf->bHasCHRM = MNG_TRUE; /* and tell it it's got a CHRM now */
2073
/* store for color-processing routines */
2074
pBuf->iWhitepointx = iWhitepointx;
2075
pBuf->iWhitepointy = iWhitepointy;
2076
pBuf->iPrimaryredx = iPrimaryredx;
2077
pBuf->iPrimaryredy = iPrimaryredy;
2078
pBuf->iPrimarygreenx = iPrimarygreenx;
2079
pBuf->iPrimarygreeny = iPrimarygreeny;
2080
pBuf->iPrimarybluex = iPrimarybluex;
2081
pBuf->iPrimarybluey = iPrimarybluey;
2082
}
2083
}
2084
else
2085
{ /* store as global */
2086
if (iRawlen != 0)
2087
{
2088
pData->iGlobalWhitepointx = iWhitepointx;
2089
pData->iGlobalWhitepointy = iWhitepointy;
2090
pData->iGlobalPrimaryredx = iPrimaryredx;
2091
pData->iGlobalPrimaryredy = iPrimaryredy;
2092
pData->iGlobalPrimarygreenx = iPrimarygreenx;
2093
pData->iGlobalPrimarygreeny = iPrimarygreeny;
2094
pData->iGlobalPrimarybluex = iPrimarybluex;
2095
pData->iGlobalPrimarybluey = iPrimarybluey;
2096
}
2097
2098
{ /* create an animation object */
2099
mng_retcode iRetcode = mng_create_ani_chrm (pData, (mng_bool)(iRawlen == 0),
2100
iWhitepointx, iWhitepointy,
2101
iPrimaryredx, iPrimaryredy,
2102
iPrimarygreenx, iPrimarygreeny,
2103
iPrimarybluex, iPrimarybluey);
2104
2105
if (iRetcode) /* on error bail out */
2106
return iRetcode;
2107
}
2108
}
2109
}
2110
#endif /* MNG_SUPPORT_DISPLAY */
2111
2112
#ifdef MNG_STORE_CHUNKS
2113
if (pData->bStorechunks)
2114
{ /* initialize storage */
2115
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2116
2117
if (iRetcode) /* on error bail out */
2118
return iRetcode;
2119
/* store the fields */
2120
((mng_chrmp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2121
2122
if (iRawlen)
2123
{
2124
((mng_chrmp)*ppChunk)->iWhitepointx = mng_get_uint32 (pRawdata);
2125
((mng_chrmp)*ppChunk)->iWhitepointy = mng_get_uint32 (pRawdata+4);
2126
((mng_chrmp)*ppChunk)->iRedx = mng_get_uint32 (pRawdata+8);
2127
((mng_chrmp)*ppChunk)->iRedy = mng_get_uint32 (pRawdata+12);
2128
((mng_chrmp)*ppChunk)->iGreenx = mng_get_uint32 (pRawdata+16);
2129
((mng_chrmp)*ppChunk)->iGreeny = mng_get_uint32 (pRawdata+20);
2130
((mng_chrmp)*ppChunk)->iBluex = mng_get_uint32 (pRawdata+24);
2131
((mng_chrmp)*ppChunk)->iBluey = mng_get_uint32 (pRawdata+28);
2132
}
2133
}
2134
#endif /* MNG_STORE_CHUNKS */
2135
2136
#ifdef MNG_SUPPORT_TRACE
2137
MNG_TRACE (pData, MNG_FN_READ_CHRM, MNG_LC_END);
2138
#endif
2139
2140
return MNG_NOERROR; /* done */
2141
}
2142
#endif
2143
#endif
2144
2145
/* ************************************************************************** */
2146
2147
#ifndef MNG_OPTIMIZE_CHUNKREADER
2148
READ_CHUNK (mng_read_srgb)
2149
{
2150
#ifdef MNG_SUPPORT_TRACE
2151
MNG_TRACE (pData, MNG_FN_READ_SRGB, MNG_LC_START);
2152
#endif
2153
/* sequence checks */
2154
#ifdef MNG_INCLUDE_JNG
2155
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2156
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2157
#else
2158
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2159
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2160
#endif
2161
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2162
2163
#ifdef MNG_INCLUDE_JNG
2164
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
2165
#else
2166
if ((pData->bHasIDAT) || (pData->bHasPLTE))
2167
#endif
2168
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2169
2170
#ifdef MNG_INCLUDE_JNG
2171
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2172
#else
2173
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2174
#endif
2175
{ /* length must be exactly 1 */
2176
if (iRawlen != 1)
2177
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2178
}
2179
else
2180
{ /* length must be empty or exactly 1 */
2181
if ((iRawlen != 0) && (iRawlen != 1))
2182
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2183
}
2184
2185
#ifdef MNG_INCLUDE_JNG
2186
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2187
#else
2188
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2189
#endif
2190
pData->bHasSRGB = MNG_TRUE; /* indicate we've got it */
2191
else
2192
pData->bHasglobalSRGB = (mng_bool)(iRawlen != 0);
2193
2194
#ifdef MNG_SUPPORT_DISPLAY
2195
#ifdef MNG_INCLUDE_JNG
2196
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2197
#else
2198
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2199
#endif
2200
{
2201
mng_imagep pImage;
2202
2203
#ifndef MNG_NO_DELTA_PNG
2204
if (pData->bHasDHDR) /* update delta image ? */
2205
{ /* store in object 0 ! */
2206
pImage = (mng_imagep)pData->pObjzero;
2207
/* store for color-processing routines */
2208
pImage->pImgbuf->iRenderingintent = *pRawdata;
2209
pImage->pImgbuf->bHasSRGB = MNG_TRUE;
2210
}
2211
else
2212
#endif
2213
{
2214
pImage = (mng_imagep)pData->pCurrentobj;
2215
2216
if (!pImage) /* no object then dump it in obj 0 */
2217
pImage = (mng_imagep)pData->pObjzero;
2218
/* store for color-processing routines */
2219
pImage->pImgbuf->iRenderingintent = *pRawdata;
2220
pImage->pImgbuf->bHasSRGB = MNG_TRUE;
2221
}
2222
}
2223
else
2224
{ /* store as global */
2225
if (iRawlen != 0)
2226
pData->iGlobalRendintent = *pRawdata;
2227
2228
{ /* create an animation object */
2229
mng_retcode iRetcode = mng_create_ani_srgb (pData, (mng_bool)(iRawlen == 0),
2230
pData->iGlobalRendintent);
2231
2232
if (iRetcode) /* on error bail out */
2233
return iRetcode;
2234
}
2235
}
2236
#endif /* MNG_SUPPORT_DISPLAY */
2237
2238
#ifdef MNG_STORE_CHUNKS
2239
if (pData->bStorechunks)
2240
{ /* initialize storage */
2241
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2242
2243
if (iRetcode) /* on error bail out */
2244
return iRetcode;
2245
/* store the fields */
2246
((mng_srgbp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2247
2248
if (iRawlen)
2249
((mng_srgbp)*ppChunk)->iRenderingintent = *pRawdata;
2250
2251
}
2252
#endif /* MNG_STORE_CHUNKS */
2253
2254
#ifdef MNG_SUPPORT_TRACE
2255
MNG_TRACE (pData, MNG_FN_READ_SRGB, MNG_LC_END);
2256
#endif
2257
2258
return MNG_NOERROR; /* done */
2259
}
2260
#endif
2261
2262
/* ************************************************************************** */
2263
2264
#ifndef MNG_OPTIMIZE_CHUNKREADER
2265
#ifndef MNG_SKIPCHUNK_iCCP
2266
READ_CHUNK (mng_read_iccp)
2267
{
2268
mng_retcode iRetcode;
2269
mng_uint8p pTemp;
2270
mng_uint32 iCompressedsize;
2271
mng_uint32 iProfilesize;
2272
mng_uint32 iBufsize = 0;
2273
mng_uint8p pBuf = 0;
2274
2275
#ifdef MNG_SUPPORT_TRACE
2276
MNG_TRACE (pData, MNG_FN_READ_ICCP, MNG_LC_START);
2277
#endif
2278
/* sequence checks */
2279
#ifdef MNG_INCLUDE_JNG
2280
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2281
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2282
#else
2283
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2284
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2285
#endif
2286
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2287
2288
#ifdef MNG_INCLUDE_JNG
2289
if ((pData->bHasIDAT) || (pData->bHasPLTE) || (pData->bHasJDAT) || (pData->bHasJDAA))
2290
#else
2291
if ((pData->bHasIDAT) || (pData->bHasPLTE))
2292
#endif
2293
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2294
2295
#ifdef MNG_INCLUDE_JNG
2296
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2297
#else
2298
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2299
#endif
2300
{ /* length must be at least 2 */
2301
if (iRawlen < 2)
2302
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2303
}
2304
else
2305
{ /* length must be empty or at least 2 */
2306
if ((iRawlen != 0) && (iRawlen < 2))
2307
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2308
}
2309
2310
pTemp = find_null (pRawdata); /* find null-separator */
2311
/* not found inside input-data ? */
2312
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2313
MNG_ERROR (pData, MNG_NULLNOTFOUND);
2314
/* determine size of compressed profile */
2315
iCompressedsize = (mng_uint32)(iRawlen - (pTemp - pRawdata) - 2);
2316
/* decompress the profile */
2317
iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
2318
&pBuf, &iBufsize, &iProfilesize);
2319
2320
#ifdef MNG_CHECK_BAD_ICCP /* Check for bad iCCP chunk */
2321
if ((iRetcode) && (!strncmp ((char *)pRawdata, "Photoshop ICC profile", 21)))
2322
{
2323
if (iRawlen == 2615) /* is it the sRGB profile ? */
2324
{
2325
mng_chunk_header chunk_srgb =
2326
#ifdef MNG_OPTIMIZE_CHUNKINITFREE
2327
{MNG_UINT_sRGB, mng_init_general, mng_free_general, mng_read_srgb, mng_write_srgb, mng_assign_general, 0, 0, sizeof(mng_srgb)};
2328
#else
2329
{MNG_UINT_sRGB, mng_init_srgb, mng_free_srgb, mng_read_srgb, mng_write_srgb, mng_assign_srgb, 0, 0};
2330
#endif
2331
/* pretend it's an sRGB chunk then ! */
2332
iRetcode = mng_read_srgb (pData, &chunk_srgb, 1, (mng_ptr)"0", ppChunk);
2333
2334
if (iRetcode) /* on error bail out */
2335
{ /* don't forget to drop the temp buffer */
2336
MNG_FREEX (pData, pBuf, iBufsize);
2337
return iRetcode;
2338
}
2339
}
2340
}
2341
else
2342
{
2343
#endif /* MNG_CHECK_BAD_ICCP */
2344
2345
if (iRetcode) /* on error bail out */
2346
{ /* don't forget to drop the temp buffer */
2347
MNG_FREEX (pData, pBuf, iBufsize);
2348
return iRetcode;
2349
}
2350
2351
#ifdef MNG_INCLUDE_JNG
2352
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2353
#else
2354
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2355
#endif
2356
pData->bHasICCP = MNG_TRUE; /* indicate we've got it */
2357
else
2358
pData->bHasglobalICCP = (mng_bool)(iRawlen != 0);
2359
2360
#ifdef MNG_SUPPORT_DISPLAY
2361
#ifdef MNG_INCLUDE_JNG
2362
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
2363
#else
2364
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2365
#endif
2366
{
2367
mng_imagep pImage;
2368
2369
#ifndef MNG_NO_DELTA_PNG
2370
if (pData->bHasDHDR) /* update delta image ? */
2371
{ /* store in object 0 ! */
2372
pImage = (mng_imagep)pData->pObjzero;
2373
2374
if (pImage->pImgbuf->pProfile) /* profile existed ? */
2375
MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize);
2376
/* allocate a buffer & copy it */
2377
MNG_ALLOC (pData, pImage->pImgbuf->pProfile, iProfilesize);
2378
MNG_COPY (pImage->pImgbuf->pProfile, pBuf, iProfilesize);
2379
/* store it's length as well */
2380
pImage->pImgbuf->iProfilesize = iProfilesize;
2381
pImage->pImgbuf->bHasICCP = MNG_TRUE;
2382
}
2383
else
2384
#endif
2385
{
2386
pImage = (mng_imagep)pData->pCurrentobj;
2387
2388
if (!pImage) /* no object then dump it in obj 0 */
2389
pImage = (mng_imagep)pData->pObjzero;
2390
2391
if (pImage->pImgbuf->pProfile) /* profile existed ? */
2392
MNG_FREEX (pData, pImage->pImgbuf->pProfile, pImage->pImgbuf->iProfilesize);
2393
/* allocate a buffer & copy it */
2394
MNG_ALLOC (pData, pImage->pImgbuf->pProfile, iProfilesize);
2395
MNG_COPY (pImage->pImgbuf->pProfile, pBuf, iProfilesize);
2396
/* store it's length as well */
2397
pImage->pImgbuf->iProfilesize = iProfilesize;
2398
pImage->pImgbuf->bHasICCP = MNG_TRUE;
2399
}
2400
}
2401
else
2402
{ /* store as global */
2403
if (iRawlen == 0) /* empty chunk ? */
2404
{
2405
if (pData->pGlobalProfile) /* did we have a global profile ? */
2406
MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize);
2407
2408
pData->iGlobalProfilesize = 0; /* reset to null */
2409
pData->pGlobalProfile = MNG_NULL;
2410
}
2411
else
2412
{ /* allocate a global buffer & copy it */
2413
MNG_ALLOC (pData, pData->pGlobalProfile, iProfilesize);
2414
MNG_COPY (pData->pGlobalProfile, pBuf, iProfilesize);
2415
/* store it's length as well */
2416
pData->iGlobalProfilesize = iProfilesize;
2417
}
2418
2419
/* create an animation object */
2420
iRetcode = mng_create_ani_iccp (pData, (mng_bool)(iRawlen == 0),
2421
pData->iGlobalProfilesize,
2422
pData->pGlobalProfile);
2423
2424
if (iRetcode) /* on error bail out */
2425
return iRetcode;
2426
}
2427
#endif /* MNG_SUPPORT_DISPLAY */
2428
2429
#ifdef MNG_STORE_CHUNKS
2430
if (pData->bStorechunks)
2431
{ /* initialize storage */
2432
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2433
2434
if (iRetcode) /* on error bail out */
2435
{ /* don't forget to drop the temp buffer */
2436
MNG_FREEX (pData, pBuf, iBufsize);
2437
return iRetcode;
2438
}
2439
/* store the fields */
2440
((mng_iccpp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
2441
2442
if (iRawlen) /* not empty ? */
2443
{
2444
if (!pBuf) /* hasn't been unpuzzled it yet ? */
2445
{ /* find null-separator */
2446
pTemp = find_null (pRawdata);
2447
/* not found inside input-data ? */
2448
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2449
MNG_ERROR (pData, MNG_NULLNOTFOUND);
2450
/* determine size of compressed profile */
2451
iCompressedsize = iRawlen - (pTemp - pRawdata) - 2;
2452
/* decompress the profile */
2453
iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
2454
&pBuf, &iBufsize, &iProfilesize);
2455
2456
if (iRetcode) /* on error bail out */
2457
{ /* don't forget to drop the temp buffer */
2458
MNG_FREEX (pData, pBuf, iBufsize);
2459
return iRetcode;
2460
}
2461
}
2462
2463
((mng_iccpp)*ppChunk)->iNamesize = (mng_uint32)(pTemp - pRawdata);
2464
2465
if (((mng_iccpp)*ppChunk)->iNamesize)
2466
{
2467
MNG_ALLOC (pData, ((mng_iccpp)*ppChunk)->zName,
2468
((mng_iccpp)*ppChunk)->iNamesize + 1);
2469
MNG_COPY (((mng_iccpp)*ppChunk)->zName, pRawdata,
2470
((mng_iccpp)*ppChunk)->iNamesize);
2471
}
2472
2473
((mng_iccpp)*ppChunk)->iCompression = *(pTemp+1);
2474
((mng_iccpp)*ppChunk)->iProfilesize = iProfilesize;
2475
2476
MNG_ALLOC (pData, ((mng_iccpp)*ppChunk)->pProfile, iProfilesize);
2477
MNG_COPY (((mng_iccpp)*ppChunk)->pProfile, pBuf, iProfilesize);
2478
}
2479
}
2480
#endif /* MNG_STORE_CHUNKS */
2481
2482
if (pBuf) /* free the temporary buffer */
2483
MNG_FREEX (pData, pBuf, iBufsize);
2484
2485
#ifdef MNG_CHECK_BAD_ICCP
2486
}
2487
#endif
2488
2489
#ifdef MNG_SUPPORT_TRACE
2490
MNG_TRACE (pData, MNG_FN_READ_ICCP, MNG_LC_END);
2491
#endif
2492
2493
return MNG_NOERROR; /* done */
2494
}
2495
#endif
2496
#endif
2497
2498
/* ************************************************************************** */
2499
2500
#ifndef MNG_OPTIMIZE_CHUNKREADER
2501
#ifndef MNG_SKIPCHUNK_tEXt
2502
READ_CHUNK (mng_read_text)
2503
{
2504
mng_uint32 iKeywordlen, iTextlen;
2505
mng_pchar zKeyword, zText;
2506
mng_uint8p pTemp;
2507
2508
#ifdef MNG_SUPPORT_TRACE
2509
MNG_TRACE (pData, MNG_FN_READ_TEXT, MNG_LC_START);
2510
#endif
2511
/* sequence checks */
2512
#ifdef MNG_INCLUDE_JNG
2513
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2514
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2515
#else
2516
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2517
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2518
#endif
2519
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2520
2521
if (iRawlen < 2) /* length must be at least 2 */
2522
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2523
2524
pTemp = find_null (pRawdata); /* find the null separator */
2525
/* not found inside input-data ? */
2526
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2527
MNG_ERROR (pData, MNG_NULLNOTFOUND);
2528
2529
if (pTemp == pRawdata) /* there must be at least 1 char for keyword */
2530
MNG_ERROR (pData, MNG_KEYWORDNULL);
2531
2532
iKeywordlen = (mng_uint32)(pTemp - pRawdata);
2533
iTextlen = iRawlen - iKeywordlen - 1;
2534
2535
if (pData->fProcesstext) /* inform the application ? */
2536
{
2537
mng_bool bOke;
2538
2539
MNG_ALLOC (pData, zKeyword, iKeywordlen + 1);
2540
MNG_COPY (zKeyword, pRawdata, iKeywordlen);
2541
2542
MNG_ALLOCX (pData, zText, iTextlen + 1);
2543
2544
if (!zText) /* on error bail out */
2545
{
2546
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2547
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2548
}
2549
2550
if (iTextlen)
2551
MNG_COPY (zText, pTemp+1, iTextlen);
2552
2553
bOke = pData->fProcesstext ((mng_handle)pData, MNG_TYPE_TEXT, zKeyword, zText, 0, 0);
2554
2555
MNG_FREEX (pData, zText, iTextlen + 1);
2556
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2557
2558
if (!bOke)
2559
MNG_ERROR (pData, MNG_APPMISCERROR);
2560
2561
}
2562
2563
#ifdef MNG_STORE_CHUNKS
2564
if (pData->bStorechunks)
2565
{ /* initialize storage */
2566
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2567
2568
if (iRetcode) /* on error bail out */
2569
return iRetcode;
2570
/* store the fields */
2571
((mng_textp)*ppChunk)->iKeywordsize = iKeywordlen;
2572
((mng_textp)*ppChunk)->iTextsize = iTextlen;
2573
2574
if (iKeywordlen)
2575
{
2576
MNG_ALLOC (pData, ((mng_textp)*ppChunk)->zKeyword, iKeywordlen+1);
2577
MNG_COPY (((mng_textp)*ppChunk)->zKeyword, pRawdata, iKeywordlen);
2578
}
2579
2580
if (iTextlen)
2581
{
2582
MNG_ALLOC (pData, ((mng_textp)*ppChunk)->zText, iTextlen+1);
2583
MNG_COPY (((mng_textp)*ppChunk)->zText, pTemp+1, iTextlen);
2584
}
2585
}
2586
#endif /* MNG_STORE_CHUNKS */
2587
2588
#ifdef MNG_SUPPORT_TRACE
2589
MNG_TRACE (pData, MNG_FN_READ_TEXT, MNG_LC_END);
2590
#endif
2591
2592
return MNG_NOERROR; /* done */
2593
}
2594
#endif
2595
#endif
2596
2597
/* ************************************************************************** */
2598
2599
#ifndef MNG_OPTIMIZE_CHUNKREADER
2600
#ifndef MNG_SKIPCHUNK_zTXt
2601
READ_CHUNK (mng_read_ztxt)
2602
{
2603
mng_retcode iRetcode;
2604
mng_uint32 iKeywordlen, iTextlen;
2605
mng_pchar zKeyword;
2606
mng_uint8p pTemp;
2607
mng_uint32 iCompressedsize;
2608
mng_uint32 iBufsize;
2609
mng_uint8p pBuf;
2610
2611
#ifdef MNG_SUPPORT_TRACE
2612
MNG_TRACE (pData, MNG_FN_READ_ZTXT, MNG_LC_START);
2613
#endif
2614
/* sequence checks */
2615
#ifdef MNG_INCLUDE_JNG
2616
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2617
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2618
#else
2619
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2620
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2621
#endif
2622
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2623
2624
if (iRawlen < 3) /* length must be at least 3 */
2625
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2626
2627
pTemp = find_null (pRawdata); /* find the null separator */
2628
/* not found inside input-data ? */
2629
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
2630
MNG_ERROR (pData, MNG_NULLNOTFOUND);
2631
2632
if (pTemp == pRawdata) /* there must be at least 1 char for keyword */
2633
MNG_ERROR (pData, MNG_KEYWORDNULL);
2634
2635
if (*(pTemp+1) != 0) /* only deflate compression-method allowed */
2636
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
2637
2638
iKeywordlen = (mng_uint32)(pTemp - pRawdata);
2639
iCompressedsize = (mng_uint32)(iRawlen - iKeywordlen - 2);
2640
2641
zKeyword = 0; /* there's no keyword buffer yet */
2642
pBuf = 0; /* or a temporary buffer ! */
2643
2644
if (pData->fProcesstext) /* inform the application ? */
2645
{ /* decompress the text */
2646
iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
2647
&pBuf, &iBufsize, &iTextlen);
2648
2649
if (iRetcode) /* on error bail out */
2650
{ /* don't forget to drop the temp buffers */
2651
MNG_FREEX (pData, pBuf, iBufsize);
2652
return iRetcode;
2653
}
2654
2655
MNG_ALLOCX (pData, zKeyword, iKeywordlen+1);
2656
2657
if (!zKeyword) /* on error bail out */
2658
{ /* don't forget to drop the temp buffers */
2659
MNG_FREEX (pData, pBuf, iBufsize);
2660
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2661
}
2662
2663
MNG_COPY (zKeyword, pRawdata, iKeywordlen);
2664
2665
if (!pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ZTXT, zKeyword, (mng_pchar)pBuf, 0, 0))
2666
{ /* don't forget to drop the temp buffers */
2667
MNG_FREEX (pData, pBuf, iBufsize);
2668
MNG_FREEX (pData, zKeyword, iKeywordlen+1);
2669
MNG_ERROR (pData, MNG_APPMISCERROR);
2670
}
2671
}
2672
2673
#ifdef MNG_STORE_CHUNKS
2674
if (pData->bStorechunks)
2675
{ /* initialize storage */
2676
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2677
2678
if (iRetcode) /* on error bail out */
2679
{ /* don't forget to drop the temp buffers */
2680
MNG_FREEX (pData, pBuf, iBufsize);
2681
MNG_FREEX (pData, zKeyword, iKeywordlen+1);
2682
return iRetcode;
2683
}
2684
/* store the fields */
2685
((mng_ztxtp)*ppChunk)->iKeywordsize = iKeywordlen;
2686
((mng_ztxtp)*ppChunk)->iCompression = *(pTemp+1);
2687
2688
if ((!pBuf) && (iCompressedsize)) /* did we not get a text-buffer yet ? */
2689
{ /* decompress the text */
2690
iRetcode = mng_inflate_buffer (pData, pTemp+2, iCompressedsize,
2691
&pBuf, &iBufsize, &iTextlen);
2692
2693
if (iRetcode) /* on error bail out */
2694
{ /* don't forget to drop the temp buffers */
2695
MNG_FREEX (pData, pBuf, iBufsize);
2696
MNG_FREEX (pData, zKeyword, iKeywordlen+1);
2697
return iRetcode;
2698
}
2699
}
2700
2701
MNG_ALLOCX (pData, ((mng_ztxtp)*ppChunk)->zKeyword, iKeywordlen + 1);
2702
/* on error bail out */
2703
if (!((mng_ztxtp)*ppChunk)->zKeyword)
2704
{ /* don't forget to drop the temp buffers */
2705
MNG_FREEX (pData, pBuf, iBufsize);
2706
MNG_FREEX (pData, zKeyword, iKeywordlen+1);
2707
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2708
}
2709
2710
MNG_COPY (((mng_ztxtp)*ppChunk)->zKeyword, pRawdata, iKeywordlen);
2711
2712
((mng_ztxtp)*ppChunk)->iTextsize = iTextlen;
2713
2714
if (iCompressedsize)
2715
{
2716
MNG_ALLOCX (pData, ((mng_ztxtp)*ppChunk)->zText, iTextlen + 1);
2717
/* on error bail out */
2718
if (!((mng_ztxtp)*ppChunk)->zText)
2719
{ /* don't forget to drop the temp buffers */
2720
MNG_FREEX (pData, pBuf, iBufsize);
2721
MNG_FREEX (pData, zKeyword, iKeywordlen+1);
2722
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2723
}
2724
2725
MNG_COPY (((mng_ztxtp)*ppChunk)->zText, pBuf, iTextlen);
2726
}
2727
}
2728
#endif /* MNG_STORE_CHUNKS */
2729
2730
MNG_FREEX (pData, pBuf, iBufsize); /* free the temporary buffers */
2731
MNG_FREEX (pData, zKeyword, iKeywordlen+1);
2732
2733
#ifdef MNG_SUPPORT_TRACE
2734
MNG_TRACE (pData, MNG_FN_READ_ZTXT, MNG_LC_END);
2735
#endif
2736
2737
return MNG_NOERROR; /* done */
2738
}
2739
#endif
2740
#endif
2741
2742
/* ************************************************************************** */
2743
2744
#ifndef MNG_OPTIMIZE_CHUNKREADER
2745
#ifndef MNG_SKIPCHUNK_iTXt
2746
READ_CHUNK (mng_read_itxt)
2747
{
2748
mng_retcode iRetcode;
2749
mng_uint32 iKeywordlen, iTextlen, iLanguagelen, iTranslationlen;
2750
mng_pchar zKeyword, zLanguage, zTranslation;
2751
mng_uint8p pNull1, pNull2, pNull3;
2752
mng_uint32 iCompressedsize;
2753
mng_uint8 iCompressionflag;
2754
mng_uint32 iBufsize;
2755
mng_uint8p pBuf;
2756
2757
#ifdef MNG_SUPPORT_TRACE
2758
MNG_TRACE (pData, MNG_FN_READ_ITXT, MNG_LC_START);
2759
#endif
2760
/* sequence checks */
2761
#ifdef MNG_INCLUDE_JNG
2762
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2763
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2764
#else
2765
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2766
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2767
#endif
2768
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2769
2770
if (iRawlen < 6) /* length must be at least 6 */
2771
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2772
2773
pNull1 = find_null (pRawdata); /* find the null separators */
2774
pNull2 = find_null (pNull1+3);
2775
pNull3 = find_null (pNull2+1);
2776
/* not found inside input-data ? */
2777
if (((pNull1 - pRawdata) > (mng_int32)iRawlen) ||
2778
((pNull2 - pRawdata) > (mng_int32)iRawlen) ||
2779
((pNull3 - pRawdata) > (mng_int32)iRawlen) )
2780
MNG_ERROR (pData, MNG_NULLNOTFOUND);
2781
2782
if (pNull1 == pRawdata) /* there must be at least 1 char for keyword */
2783
MNG_ERROR (pData, MNG_KEYWORDNULL);
2784
/* compression or not ? */
2785
if ((*(pNull1+1) != 0) && (*(pNull1+1) != 1))
2786
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
2787
2788
if (*(pNull1+2) != 0) /* only deflate compression-method allowed */
2789
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
2790
2791
iKeywordlen = (mng_uint32)(pNull1 - pRawdata);
2792
iLanguagelen = (mng_uint32)(pNull2 - pNull1 - 3);
2793
iTranslationlen = (mng_uint32)(pNull3 - pNull2 - 1);
2794
iCompressedsize = (mng_uint32)(iRawlen - iKeywordlen - iLanguagelen - iTranslationlen - 5);
2795
iCompressionflag = *(pNull1+1);
2796
2797
zKeyword = 0; /* no buffers acquired yet */
2798
zLanguage = 0;
2799
zTranslation = 0;
2800
pBuf = 0;
2801
iTextlen = 0;
2802
2803
if (pData->fProcesstext) /* inform the application ? */
2804
{
2805
if (iCompressionflag) /* decompress the text ? */
2806
{
2807
iRetcode = mng_inflate_buffer (pData, pNull3+1, iCompressedsize,
2808
&pBuf, &iBufsize, &iTextlen);
2809
2810
if (iRetcode) /* on error bail out */
2811
{ /* don't forget to drop the temp buffer */
2812
MNG_FREEX (pData, pBuf, iBufsize);
2813
return iRetcode;
2814
}
2815
}
2816
else
2817
{
2818
iTextlen = iCompressedsize;
2819
iBufsize = iTextlen+1; /* plus 1 for terminator byte!!! */
2820
2821
MNG_ALLOC (pData, pBuf, iBufsize);
2822
MNG_COPY (pBuf, pNull3+1, iTextlen);
2823
}
2824
2825
MNG_ALLOCX (pData, zKeyword, iKeywordlen + 1);
2826
MNG_ALLOCX (pData, zLanguage, iLanguagelen + 1);
2827
MNG_ALLOCX (pData, zTranslation, iTranslationlen + 1);
2828
/* on error bail out */
2829
if ((!zKeyword) || (!zLanguage) || (!zTranslation))
2830
{ /* don't forget to drop the temp buffers */
2831
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2832
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2833
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2834
MNG_FREEX (pData, pBuf, iBufsize);
2835
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2836
}
2837
2838
MNG_COPY (zKeyword, pRawdata, iKeywordlen);
2839
MNG_COPY (zLanguage, pNull1+3, iLanguagelen);
2840
MNG_COPY (zTranslation, pNull2+1, iTranslationlen);
2841
2842
if (!pData->fProcesstext ((mng_handle)pData, MNG_TYPE_ITXT, zKeyword, (mng_pchar)pBuf,
2843
zLanguage, zTranslation))
2844
{ /* don't forget to drop the temp buffers */
2845
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2846
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2847
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2848
MNG_FREEX (pData, pBuf, iBufsize);
2849
2850
MNG_ERROR (pData, MNG_APPMISCERROR);
2851
}
2852
}
2853
2854
#ifdef MNG_STORE_CHUNKS
2855
if (pData->bStorechunks)
2856
{ /* initialize storage */
2857
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
2858
2859
if (iRetcode) /* on error bail out */
2860
{ /* don't forget to drop the temp buffers */
2861
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2862
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2863
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2864
MNG_FREEX (pData, pBuf, iBufsize);
2865
return iRetcode;
2866
}
2867
/* store the fields */
2868
((mng_itxtp)*ppChunk)->iKeywordsize = iKeywordlen;
2869
((mng_itxtp)*ppChunk)->iLanguagesize = iLanguagelen;
2870
((mng_itxtp)*ppChunk)->iTranslationsize = iTranslationlen;
2871
((mng_itxtp)*ppChunk)->iCompressionflag = *(pNull1+1);
2872
((mng_itxtp)*ppChunk)->iCompressionmethod = *(pNull1+2);
2873
2874
if ((!pBuf) && (iCompressedsize)) /* did we not get a text-buffer yet ? */
2875
{
2876
if (iCompressionflag) /* decompress the text ? */
2877
{
2878
iRetcode = mng_inflate_buffer (pData, pNull3+1, iCompressedsize,
2879
&pBuf, &iBufsize, &iTextlen);
2880
2881
if (iRetcode) /* on error bail out */
2882
{ /* don't forget to drop the temp buffers */
2883
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2884
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2885
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2886
MNG_FREEX (pData, pBuf, iBufsize);
2887
return iRetcode;
2888
}
2889
}
2890
else
2891
{
2892
iTextlen = iCompressedsize;
2893
iBufsize = iTextlen+1; /* plus 1 for terminator byte!!! */
2894
2895
MNG_ALLOC (pData, pBuf, iBufsize);
2896
MNG_COPY (pBuf, pNull3+1, iTextlen);
2897
}
2898
}
2899
2900
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zKeyword, iKeywordlen + 1);
2901
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zLanguage, iLanguagelen + 1);
2902
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zTranslation, iTranslationlen + 1);
2903
/* on error bail out */
2904
if ((!((mng_itxtp)*ppChunk)->zKeyword ) ||
2905
(!((mng_itxtp)*ppChunk)->zLanguage ) ||
2906
(!((mng_itxtp)*ppChunk)->zTranslation) )
2907
{ /* don't forget to drop the temp buffers */
2908
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2909
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2910
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2911
MNG_FREEX (pData, pBuf, iBufsize);
2912
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2913
}
2914
2915
MNG_COPY (((mng_itxtp)*ppChunk)->zKeyword, pRawdata, iKeywordlen);
2916
MNG_COPY (((mng_itxtp)*ppChunk)->zLanguage, pNull1+3, iLanguagelen);
2917
MNG_COPY (((mng_itxtp)*ppChunk)->zTranslation, pNull2+1, iTranslationlen);
2918
2919
((mng_itxtp)*ppChunk)->iTextsize = iTextlen;
2920
2921
if (iTextlen)
2922
{
2923
MNG_ALLOCX (pData, ((mng_itxtp)*ppChunk)->zText, iTextlen + 1);
2924
2925
if (!((mng_itxtp)*ppChunk)->zText)
2926
{ /* don't forget to drop the temp buffers */
2927
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2928
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2929
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2930
MNG_FREEX (pData, pBuf, iBufsize);
2931
MNG_ERROR (pData, MNG_OUTOFMEMORY);
2932
}
2933
2934
MNG_COPY (((mng_itxtp)*ppChunk)->zText, pBuf, iTextlen);
2935
}
2936
}
2937
#endif /* MNG_STORE_CHUNKS */
2938
/* free the temporary buffers */
2939
MNG_FREEX (pData, zTranslation, iTranslationlen + 1);
2940
MNG_FREEX (pData, zLanguage, iLanguagelen + 1);
2941
MNG_FREEX (pData, zKeyword, iKeywordlen + 1);
2942
MNG_FREEX (pData, pBuf, iBufsize);
2943
2944
#ifdef MNG_SUPPORT_TRACE
2945
MNG_TRACE (pData, MNG_FN_READ_ITXT, MNG_LC_END);
2946
#endif
2947
2948
return MNG_NOERROR; /* done */
2949
}
2950
#endif
2951
#endif
2952
2953
/* ************************************************************************** */
2954
2955
#ifndef MNG_OPTIMIZE_CHUNKREADER
2956
#ifndef MNG_SKIPCHUNK_bKGD
2957
READ_CHUNK (mng_read_bkgd)
2958
{
2959
#ifdef MNG_SUPPORT_DISPLAY
2960
mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
2961
mng_imagedatap pBuf;
2962
#endif
2963
2964
#ifdef MNG_SUPPORT_TRACE
2965
MNG_TRACE (pData, MNG_FN_READ_BKGD, MNG_LC_START);
2966
#endif
2967
/* sequence checks */
2968
#ifdef MNG_INCLUDE_JNG
2969
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2970
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
2971
#else
2972
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
2973
(!pData->bHasBASI) && (!pData->bHasDHDR) )
2974
#endif
2975
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2976
2977
#ifdef MNG_INCLUDE_JNG
2978
if ((pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
2979
#else
2980
if (pData->bHasIDAT)
2981
#endif
2982
MNG_ERROR (pData, MNG_SEQUENCEERROR);
2983
2984
if (iRawlen > 6) /* it just can't be bigger than that! */
2985
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2986
2987
#ifdef MNG_INCLUDE_JNG /* length checks */
2988
if (pData->bHasJHDR)
2989
{
2990
if (((pData->iJHDRcolortype == 8) || (pData->iJHDRcolortype == 12)) && (iRawlen != 2))
2991
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2992
2993
if (((pData->iJHDRcolortype == 10) || (pData->iJHDRcolortype == 14)) && (iRawlen != 6))
2994
MNG_ERROR (pData, MNG_INVALIDLENGTH);
2995
}
2996
else
2997
#endif /* MNG_INCLUDE_JNG */
2998
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
2999
{
3000
if (((pData->iColortype == 0) || (pData->iColortype == 4)) && (iRawlen != 2))
3001
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3002
3003
if (((pData->iColortype == 2) || (pData->iColortype == 6)) && (iRawlen != 6))
3004
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3005
3006
if ((pData->iColortype == 3) && (iRawlen != 1))
3007
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3008
}
3009
else
3010
{
3011
if (iRawlen != 6) /* global is always 16-bit RGB ! */
3012
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3013
}
3014
3015
#ifdef MNG_INCLUDE_JNG
3016
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3017
#else
3018
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3019
#endif
3020
pData->bHasBKGD = MNG_TRUE; /* indicate bKGD available */
3021
else
3022
pData->bHasglobalBKGD = (mng_bool)(iRawlen != 0);
3023
3024
#ifdef MNG_SUPPORT_DISPLAY
3025
if (!pImage) /* if no object dump it in obj 0 */
3026
pImage = (mng_imagep)pData->pObjzero;
3027
3028
pBuf = pImage->pImgbuf; /* address object buffer */
3029
3030
#ifdef MNG_INCLUDE_JNG
3031
if (pData->bHasJHDR)
3032
{
3033
pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */
3034
3035
switch (pData->iJHDRcolortype) /* store fields for future reference */
3036
{
3037
case 8 : ; /* gray */
3038
case 12 : { /* graya */
3039
pBuf->iBKGDgray = mng_get_uint16 (pRawdata);
3040
break;
3041
}
3042
case 10 : ; /* rgb */
3043
case 14 : { /* rgba */
3044
pBuf->iBKGDred = mng_get_uint16 (pRawdata);
3045
pBuf->iBKGDgreen = mng_get_uint16 (pRawdata+2);
3046
pBuf->iBKGDblue = mng_get_uint16 (pRawdata+4);
3047
break;
3048
}
3049
}
3050
}
3051
else
3052
#endif /* MNG_INCLUDE_JNG */
3053
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3054
{
3055
pBuf->bHasBKGD = MNG_TRUE; /* tell the object it's got bKGD now */
3056
3057
switch (pData->iColortype) /* store fields for future reference */
3058
{
3059
case 0 : ; /* gray */
3060
case 4 : { /* graya */
3061
pBuf->iBKGDgray = mng_get_uint16 (pRawdata);
3062
break;
3063
}
3064
case 2 : ; /* rgb */
3065
case 6 : { /* rgba */
3066
pBuf->iBKGDred = mng_get_uint16 (pRawdata);
3067
pBuf->iBKGDgreen = mng_get_uint16 (pRawdata+2);
3068
pBuf->iBKGDblue = mng_get_uint16 (pRawdata+4);
3069
break;
3070
}
3071
case 3 : { /* indexed */
3072
pBuf->iBKGDindex = *pRawdata;
3073
break;
3074
}
3075
}
3076
}
3077
else /* store as global */
3078
{
3079
if (iRawlen)
3080
{
3081
pData->iGlobalBKGDred = mng_get_uint16 (pRawdata);
3082
pData->iGlobalBKGDgreen = mng_get_uint16 (pRawdata+2);
3083
pData->iGlobalBKGDblue = mng_get_uint16 (pRawdata+4);
3084
}
3085
3086
{ /* create an animation object */
3087
mng_retcode iRetcode = mng_create_ani_bkgd (pData, pData->iGlobalBKGDred,
3088
pData->iGlobalBKGDgreen,
3089
pData->iGlobalBKGDblue);
3090
3091
if (iRetcode) /* on error bail out */
3092
return iRetcode;
3093
}
3094
}
3095
#endif /* MNG_SUPPORT_DISPLAY */
3096
3097
#ifdef MNG_STORE_CHUNKS
3098
if (pData->bStorechunks)
3099
{ /* initialize storage */
3100
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3101
3102
if (iRetcode) /* on error bail out */
3103
return iRetcode;
3104
/* store the fields */
3105
((mng_bkgdp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
3106
((mng_bkgdp)*ppChunk)->iType = pData->iColortype;
3107
3108
if (iRawlen)
3109
{
3110
switch (iRawlen) /* guess from length */
3111
{
3112
case 1 : { /* indexed */
3113
((mng_bkgdp)*ppChunk)->iType = 3;
3114
((mng_bkgdp)*ppChunk)->iIndex = *pRawdata;
3115
break;
3116
}
3117
case 2 : { /* gray */
3118
((mng_bkgdp)*ppChunk)->iType = 0;
3119
((mng_bkgdp)*ppChunk)->iGray = mng_get_uint16 (pRawdata);
3120
break;
3121
}
3122
case 6 : { /* rgb */
3123
((mng_bkgdp)*ppChunk)->iType = 2;
3124
((mng_bkgdp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
3125
((mng_bkgdp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
3126
((mng_bkgdp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
3127
break;
3128
}
3129
}
3130
}
3131
}
3132
#endif /* MNG_STORE_CHUNKS */
3133
3134
#ifdef MNG_SUPPORT_TRACE
3135
MNG_TRACE (pData, MNG_FN_READ_BKGD, MNG_LC_END);
3136
#endif
3137
3138
return MNG_NOERROR; /* done */
3139
}
3140
#endif
3141
#endif
3142
3143
/* ************************************************************************** */
3144
3145
#ifndef MNG_OPTIMIZE_CHUNKREADER
3146
#ifndef MNG_SKIPCHUNK_pHYs
3147
READ_CHUNK (mng_read_phys)
3148
{
3149
#ifdef MNG_SUPPORT_TRACE
3150
MNG_TRACE (pData, MNG_FN_READ_PHYS, MNG_LC_START);
3151
#endif
3152
/* sequence checks */
3153
#ifdef MNG_INCLUDE_JNG
3154
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3155
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
3156
#else
3157
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3158
(!pData->bHasBASI) && (!pData->bHasDHDR) )
3159
#endif
3160
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3161
3162
#ifdef MNG_INCLUDE_JNG
3163
if ((pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
3164
#else
3165
if (pData->bHasIDAT)
3166
#endif
3167
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3168
/* it's 9 bytes or empty; no more, no less! */
3169
if ((iRawlen != 9) && (iRawlen != 0))
3170
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3171
3172
#ifdef MNG_SUPPORT_DISPLAY
3173
{
3174
3175
3176
/* TODO: something !!! */
3177
3178
3179
}
3180
#endif /* MNG_SUPPORT_DISPLAY */
3181
3182
#ifdef MNG_STORE_CHUNKS
3183
if (pData->bStorechunks)
3184
{ /* initialize storage */
3185
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3186
3187
if (iRetcode) /* on error bail out */
3188
return iRetcode;
3189
/* store the fields */
3190
((mng_physp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
3191
3192
if (iRawlen)
3193
{
3194
((mng_physp)*ppChunk)->iSizex = mng_get_uint32 (pRawdata);
3195
((mng_physp)*ppChunk)->iSizey = mng_get_uint32 (pRawdata+4);
3196
((mng_physp)*ppChunk)->iUnit = *(pRawdata+8);
3197
}
3198
}
3199
#endif /* MNG_STORE_CHUNKS */
3200
3201
#ifdef MNG_SUPPORT_TRACE
3202
MNG_TRACE (pData, MNG_FN_READ_PHYS, MNG_LC_END);
3203
#endif
3204
3205
return MNG_NOERROR; /* done */
3206
}
3207
#endif
3208
#endif
3209
3210
/* ************************************************************************** */
3211
3212
#ifndef MNG_OPTIMIZE_CHUNKREADER
3213
#ifndef MNG_SKIPCHUNK_sBIT
3214
READ_CHUNK (mng_read_sbit)
3215
{
3216
#ifdef MNG_SUPPORT_TRACE
3217
MNG_TRACE (pData, MNG_FN_READ_SBIT, MNG_LC_START);
3218
#endif
3219
/* sequence checks */
3220
#ifdef MNG_INCLUDE_JNG
3221
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3222
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
3223
#else
3224
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3225
(!pData->bHasBASI) && (!pData->bHasDHDR) )
3226
#endif
3227
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3228
3229
#ifdef MNG_INCLUDE_JNG
3230
if ((pData->bHasPLTE) || (pData->bHasIDAT) || (pData->bHasJDAT) || (pData->bHasJDAA))
3231
#else
3232
if ((pData->bHasPLTE) || (pData->bHasIDAT))
3233
#endif
3234
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3235
3236
if (iRawlen > 4) /* it just can't be bigger than that! */
3237
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3238
3239
#ifdef MNG_INCLUDE_JNG /* length checks */
3240
if (pData->bHasJHDR)
3241
{
3242
if ((pData->iJHDRcolortype == 8) && (iRawlen != 1))
3243
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3244
3245
if ((pData->iJHDRcolortype == 10) && (iRawlen != 3))
3246
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3247
3248
if ((pData->iJHDRcolortype == 12) && (iRawlen != 2))
3249
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3250
3251
if ((pData->iJHDRcolortype == 14) && (iRawlen != 4))
3252
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3253
}
3254
else
3255
#endif /* MNG_INCLUDE_JNG */
3256
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3257
{
3258
if ((pData->iColortype == 0) && (iRawlen != 1))
3259
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3260
3261
if ((pData->iColortype == 2) && (iRawlen != 3))
3262
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3263
3264
if ((pData->iColortype == 3) && (iRawlen != 3))
3265
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3266
3267
if ((pData->iColortype == 4) && (iRawlen != 2))
3268
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3269
3270
if ((pData->iColortype == 6) && (iRawlen != 4))
3271
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3272
}
3273
else
3274
{ /* global = empty or RGBA */
3275
if ((iRawlen != 0) && (iRawlen != 4))
3276
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3277
}
3278
3279
#ifdef MNG_SUPPORT_DISPLAY
3280
{
3281
3282
3283
/* TODO: something !!! */
3284
3285
3286
}
3287
#endif /* MNG_SUPPORT_DISPLAY */
3288
3289
#ifdef MNG_STORE_CHUNKS
3290
if (pData->bStorechunks)
3291
{ /* initialize storage */
3292
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3293
3294
if (iRetcode) /* on error bail out */
3295
return iRetcode;
3296
/* store the fields */
3297
((mng_sbitp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
3298
3299
if (iRawlen)
3300
{
3301
#ifdef MNG_INCLUDE_JNG
3302
if (pData->bHasJHDR)
3303
((mng_sbitp)*ppChunk)->iType = pData->iJHDRcolortype;
3304
else
3305
#endif
3306
if (pData->bHasIHDR)
3307
((mng_sbitp)*ppChunk)->iType = pData->iColortype;
3308
else /* global ! */
3309
((mng_sbitp)*ppChunk)->iType = 6;
3310
3311
if (iRawlen > 0)
3312
((mng_sbitp)*ppChunk)->aBits [0] = *pRawdata;
3313
if (iRawlen > 1)
3314
((mng_sbitp)*ppChunk)->aBits [1] = *(pRawdata+1);
3315
if (iRawlen > 2)
3316
((mng_sbitp)*ppChunk)->aBits [2] = *(pRawdata+2);
3317
if (iRawlen > 3)
3318
((mng_sbitp)*ppChunk)->aBits [3] = *(pRawdata+3);
3319
3320
}
3321
}
3322
#endif /* MNG_STORE_CHUNKS */
3323
3324
#ifdef MNG_SUPPORT_TRACE
3325
MNG_TRACE (pData, MNG_FN_READ_SBIT, MNG_LC_END);
3326
#endif
3327
3328
return MNG_NOERROR; /* done */
3329
}
3330
#endif
3331
#endif
3332
3333
/* ************************************************************************** */
3334
3335
#ifndef MNG_OPTIMIZE_CHUNKREADER
3336
#ifndef MNG_SKIPCHUNK_sPLT
3337
READ_CHUNK (mng_read_splt)
3338
{
3339
mng_uint8p pTemp;
3340
mng_uint32 iNamelen;
3341
mng_uint8 iSampledepth;
3342
mng_uint32 iRemain;
3343
3344
#ifdef MNG_SUPPORT_TRACE
3345
MNG_TRACE (pData, MNG_FN_READ_SPLT, MNG_LC_START);
3346
#endif
3347
/* sequence checks */
3348
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3349
(!pData->bHasBASI) && (!pData->bHasDHDR) )
3350
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3351
3352
if (pData->bHasIDAT)
3353
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3354
3355
if (iRawlen)
3356
{
3357
pTemp = find_null (pRawdata); /* find null-separator */
3358
/* not found inside input-data ? */
3359
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
3360
MNG_ERROR (pData, MNG_NULLNOTFOUND);
3361
3362
iNamelen = (mng_uint32)(pTemp - pRawdata);
3363
iSampledepth = *(pTemp+1);
3364
iRemain = (iRawlen - 2 - iNamelen);
3365
3366
if ((iSampledepth != 1) && (iSampledepth != 2))
3367
MNG_ERROR (pData, MNG_INVSAMPLEDEPTH);
3368
/* check remaining length */
3369
if ( ((iSampledepth == 1) && (iRemain % 6 != 0)) ||
3370
((iSampledepth == 2) && (iRemain % 10 != 0)) )
3371
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3372
3373
}
3374
else
3375
{
3376
pTemp = MNG_NULL;
3377
iNamelen = 0;
3378
iSampledepth = 0;
3379
iRemain = 0;
3380
}
3381
3382
#ifdef MNG_SUPPORT_DISPLAY
3383
{
3384
3385
3386
/* TODO: something !!! */
3387
3388
3389
}
3390
#endif /* MNG_SUPPORT_DISPLAY */
3391
3392
#ifdef MNG_STORE_CHUNKS
3393
if (pData->bStorechunks)
3394
{ /* initialize storage */
3395
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3396
3397
if (iRetcode) /* on error bail out */
3398
return iRetcode;
3399
/* store the fields */
3400
((mng_spltp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
3401
3402
if (iRawlen)
3403
{
3404
((mng_spltp)*ppChunk)->iNamesize = iNamelen;
3405
((mng_spltp)*ppChunk)->iSampledepth = iSampledepth;
3406
3407
if (iSampledepth == 1)
3408
((mng_spltp)*ppChunk)->iEntrycount = iRemain / 6;
3409
else
3410
((mng_spltp)*ppChunk)->iEntrycount = iRemain / 10;
3411
3412
if (iNamelen)
3413
{
3414
MNG_ALLOC (pData, ((mng_spltp)*ppChunk)->zName, iNamelen+1);
3415
MNG_COPY (((mng_spltp)*ppChunk)->zName, pRawdata, iNamelen);
3416
}
3417
3418
if (iRemain)
3419
{
3420
MNG_ALLOC (pData, ((mng_spltp)*ppChunk)->pEntries, iRemain);
3421
MNG_COPY (((mng_spltp)*ppChunk)->pEntries, pTemp+2, iRemain);
3422
}
3423
}
3424
}
3425
#endif /* MNG_STORE_CHUNKS */
3426
3427
#ifdef MNG_SUPPORT_TRACE
3428
MNG_TRACE (pData, MNG_FN_READ_SPLT, MNG_LC_END);
3429
#endif
3430
3431
return MNG_NOERROR; /* done */
3432
}
3433
#endif
3434
#endif
3435
3436
/* ************************************************************************** */
3437
3438
#ifndef MNG_OPTIMIZE_CHUNKREADER
3439
#ifndef MNG_SKIPCHUNK_hIST
3440
READ_CHUNK (mng_read_hist)
3441
{
3442
#ifdef MNG_SUPPORT_TRACE
3443
MNG_TRACE (pData, MNG_FN_READ_HIST, MNG_LC_START);
3444
#endif
3445
/* sequence checks */
3446
if ((!pData->bHasIHDR) && (!pData->bHasBASI) && (!pData->bHasDHDR) )
3447
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3448
3449
if ((!pData->bHasPLTE) || (pData->bHasIDAT))
3450
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3451
/* length oke ? */
3452
if ( ((iRawlen & 0x01) != 0) || ((iRawlen >> 1) != pData->iPLTEcount) )
3453
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3454
3455
#ifdef MNG_SUPPORT_DISPLAY
3456
{
3457
3458
3459
/* TODO: something !!! */
3460
3461
3462
}
3463
#endif /* MNG_SUPPORT_DISPLAY */
3464
3465
#ifdef MNG_STORE_CHUNKS
3466
if (pData->bStorechunks)
3467
{
3468
mng_uint32 iX;
3469
/* initialize storage */
3470
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3471
3472
if (iRetcode) /* on error bail out */
3473
return iRetcode;
3474
/* store the fields */
3475
((mng_histp)*ppChunk)->iEntrycount = iRawlen >> 1;
3476
3477
for (iX = 0; iX < (iRawlen >> 1); iX++)
3478
{
3479
((mng_histp)*ppChunk)->aEntries [iX] = mng_get_uint16 (pRawdata);
3480
pRawdata += 2;
3481
}
3482
}
3483
#endif /* MNG_STORE_CHUNKS */
3484
3485
#ifdef MNG_SUPPORT_TRACE
3486
MNG_TRACE (pData, MNG_FN_READ_HIST, MNG_LC_END);
3487
#endif
3488
3489
return MNG_NOERROR; /* done */
3490
}
3491
#endif
3492
#endif
3493
3494
/* ************************************************************************** */
3495
3496
#ifndef MNG_OPTIMIZE_CHUNKREADER
3497
#ifndef MNG_SKIPCHUNK_tIME
3498
READ_CHUNK (mng_read_time)
3499
{
3500
#ifdef MNG_SUPPORT_TRACE
3501
MNG_TRACE (pData, MNG_FN_READ_TIME, MNG_LC_START);
3502
#endif
3503
/* sequence checks */
3504
#ifdef MNG_INCLUDE_JNG
3505
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3506
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
3507
#else
3508
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
3509
(!pData->bHasBASI) && (!pData->bHasDHDR) )
3510
#endif
3511
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3512
3513
if (iRawlen != 7) /* length must be exactly 7 */
3514
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3515
3516
/* if (pData->fProcesstime) */ /* inform the application ? */
3517
/* {
3518
3519
pData->fProcesstime ((mng_handle)pData, );
3520
} */
3521
3522
#ifdef MNG_STORE_CHUNKS
3523
if (pData->bStorechunks)
3524
{ /* initialize storage */
3525
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3526
3527
if (iRetcode) /* on error bail out */
3528
return iRetcode;
3529
/* store the fields */
3530
((mng_timep)*ppChunk)->iYear = mng_get_uint16 (pRawdata);
3531
((mng_timep)*ppChunk)->iMonth = *(pRawdata+2);
3532
((mng_timep)*ppChunk)->iDay = *(pRawdata+3);
3533
((mng_timep)*ppChunk)->iHour = *(pRawdata+4);
3534
((mng_timep)*ppChunk)->iMinute = *(pRawdata+5);
3535
((mng_timep)*ppChunk)->iSecond = *(pRawdata+6);
3536
}
3537
#endif /* MNG_STORE_CHUNKS */
3538
3539
#ifdef MNG_SUPPORT_TRACE
3540
MNG_TRACE (pData, MNG_FN_READ_TIME, MNG_LC_END);
3541
#endif
3542
3543
return MNG_NOERROR; /* done */
3544
}
3545
#endif
3546
#endif
3547
3548
/* ************************************************************************** */
3549
3550
#ifndef MNG_OPTIMIZE_CHUNKREADER
3551
READ_CHUNK (mng_read_mhdr)
3552
{
3553
#ifdef MNG_SUPPORT_TRACE
3554
MNG_TRACE (pData, MNG_FN_READ_MHDR, MNG_LC_START);
3555
#endif
3556
3557
if (pData->eSigtype != mng_it_mng) /* sequence checks */
3558
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
3559
3560
if (pData->bHasheader) /* can only be the first chunk! */
3561
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3562
/* correct length ? */
3563
#ifndef MNG_NO_OLD_VERSIONS
3564
if ((iRawlen != 28) && (iRawlen != 12))
3565
#else
3566
if ((iRawlen != 28))
3567
#endif
3568
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3569
3570
pData->bHasMHDR = MNG_TRUE; /* oh boy, a real MNG */
3571
pData->bHasheader = MNG_TRUE; /* we've got a header */
3572
pData->eImagetype = mng_it_mng; /* fill header fields */
3573
pData->iWidth = mng_get_uint32 (pRawdata);
3574
pData->iHeight = mng_get_uint32 (pRawdata+4);
3575
pData->iTicks = mng_get_uint32 (pRawdata+8);
3576
3577
#ifndef MNG_NO_OLD_VERSIONS
3578
if (iRawlen == 28) /* proper MHDR ? */
3579
{
3580
#endif
3581
pData->iLayercount = mng_get_uint32 (pRawdata+12);
3582
pData->iFramecount = mng_get_uint32 (pRawdata+16);
3583
pData->iPlaytime = mng_get_uint32 (pRawdata+20);
3584
pData->iSimplicity = mng_get_uint32 (pRawdata+24);
3585
3586
#ifndef MNG_NO_OLD_VERSIONS
3587
pData->bPreDraft48 = MNG_FALSE;
3588
}
3589
else /* probably pre-draft48 then */
3590
{
3591
pData->iLayercount = 0;
3592
pData->iFramecount = 0;
3593
pData->iPlaytime = 0;
3594
pData->iSimplicity = 0;
3595
3596
pData->bPreDraft48 = MNG_TRUE;
3597
}
3598
#endif
3599
/* predict alpha-depth */
3600
if ((pData->iSimplicity & 0x00000001) == 0)
3601
#ifndef MNG_NO_16BIT_SUPPORT
3602
pData->iAlphadepth = 16; /* no indicators = assume the worst */
3603
#else
3604
pData->iAlphadepth = 8; /* anything else = assume the worst */
3605
#endif
3606
else
3607
if ((pData->iSimplicity & 0x00000008) == 0)
3608
pData->iAlphadepth = 0; /* no transparency at all */
3609
else
3610
if ((pData->iSimplicity & 0x00000140) == 0x00000040)
3611
pData->iAlphadepth = 1; /* no semi-transparency guaranteed */
3612
else
3613
#ifndef MNG_NO_16BIT_SUPPORT
3614
pData->iAlphadepth = 16; /* anything else = assume the worst */
3615
#else
3616
pData->iAlphadepth = 8; /* anything else = assume the worst */
3617
#endif
3618
3619
#ifdef MNG_INCLUDE_JNG /* can we handle the complexity ? */
3620
if (pData->iSimplicity & 0x0000FC00)
3621
#else
3622
if (pData->iSimplicity & 0x0000FC10)
3623
#endif
3624
MNG_ERROR (pData, MNG_MNGTOOCOMPLEX);
3625
/* fits on maximum canvas ? */
3626
if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
3627
MNG_WARNING (pData, MNG_IMAGETOOLARGE);
3628
3629
if (pData->fProcessheader) /* inform the app ? */
3630
if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
3631
MNG_ERROR (pData, MNG_APPMISCERROR);
3632
3633
pData->iImagelevel++; /* one level deeper */
3634
3635
#ifdef MNG_STORE_CHUNKS
3636
if (pData->bStorechunks)
3637
{ /* initialize storage */
3638
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3639
3640
if (iRetcode) /* on error bail out */
3641
return iRetcode;
3642
/* store the fields */
3643
((mng_mhdrp)*ppChunk)->iWidth = pData->iWidth;
3644
((mng_mhdrp)*ppChunk)->iHeight = pData->iHeight;
3645
((mng_mhdrp)*ppChunk)->iTicks = pData->iTicks;
3646
((mng_mhdrp)*ppChunk)->iLayercount = pData->iLayercount;
3647
((mng_mhdrp)*ppChunk)->iFramecount = pData->iFramecount;
3648
((mng_mhdrp)*ppChunk)->iPlaytime = pData->iPlaytime;
3649
((mng_mhdrp)*ppChunk)->iSimplicity = pData->iSimplicity;
3650
}
3651
#endif /* MNG_STORE_CHUNKS */
3652
3653
#ifdef MNG_SUPPORT_TRACE
3654
MNG_TRACE (pData, MNG_FN_READ_MHDR, MNG_LC_END);
3655
#endif
3656
3657
return MNG_NOERROR; /* done */
3658
}
3659
#endif
3660
3661
/* ************************************************************************** */
3662
3663
#ifndef MNG_OPTIMIZE_CHUNKREADER
3664
READ_CHUNK (mng_read_mend)
3665
{
3666
#ifdef MNG_SUPPORT_TRACE
3667
MNG_TRACE (pData, MNG_FN_READ_MEND, MNG_LC_START);
3668
#endif
3669
3670
if (!pData->bHasMHDR) /* sequence checks */
3671
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3672
3673
if (iRawlen > 0) /* must not contain data! */
3674
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3675
3676
#ifdef MNG_SUPPORT_DISPLAY
3677
{ /* do something */
3678
mng_retcode iRetcode = mng_process_display_mend (pData);
3679
3680
if (iRetcode) /* on error bail out */
3681
return iRetcode;
3682
3683
if (!pData->iTotalframes) /* save totals */
3684
pData->iTotalframes = pData->iFrameseq;
3685
if (!pData->iTotallayers)
3686
pData->iTotallayers = pData->iLayerseq;
3687
if (!pData->iTotalplaytime)
3688
pData->iTotalplaytime = pData->iFrametime;
3689
}
3690
#endif /* MNG_SUPPORT_DISPLAY */
3691
3692
pData->bHasMHDR = MNG_FALSE; /* end of the line, bro! */
3693
3694
#ifdef MNG_STORE_CHUNKS
3695
if (pData->bStorechunks)
3696
{ /* initialize storage */
3697
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3698
3699
if (iRetcode) /* on error bail out */
3700
return iRetcode;
3701
}
3702
#endif /* MNG_STORE_CHUNKS */
3703
3704
#ifdef MNG_SUPPORT_TRACE
3705
MNG_TRACE (pData, MNG_FN_READ_MEND, MNG_LC_END);
3706
#endif
3707
3708
return MNG_NOERROR; /* done */
3709
}
3710
#endif
3711
3712
/* ************************************************************************** */
3713
3714
#ifndef MNG_OPTIMIZE_CHUNKREADER
3715
#ifndef MNG_SKIPCHUNK_LOOP
3716
READ_CHUNK (mng_read_loop)
3717
{
3718
#ifdef MNG_SUPPORT_TRACE
3719
MNG_TRACE (pData, MNG_FN_READ_LOOP, MNG_LC_START);
3720
#endif
3721
3722
if (!pData->bHasMHDR) /* sequence checks */
3723
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3724
3725
if (!pData->bCacheplayback) /* must store playback info to work!! */
3726
MNG_ERROR (pData, MNG_LOOPWITHCACHEOFF);
3727
3728
#ifdef MNG_INCLUDE_JNG
3729
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3730
#else
3731
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3732
#endif
3733
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3734
3735
if (iRawlen >= 5) /* length checks */
3736
{
3737
if (iRawlen >= 6)
3738
{
3739
if ((iRawlen - 6) % 4 != 0)
3740
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3741
}
3742
}
3743
else
3744
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3745
3746
#ifdef MNG_SUPPORT_DISPLAY
3747
{
3748
mng_uint8 iLevel;
3749
mng_uint32 iRepeat;
3750
mng_uint8 iTermination = 0;
3751
mng_uint32 iItermin = 1;
3752
mng_uint32 iItermax = 0x7fffffffL;
3753
mng_retcode iRetcode;
3754
3755
pData->bHasLOOP = MNG_TRUE; /* indicate we're inside a loop */
3756
3757
iLevel = *pRawdata; /* determine the fields for processing */
3758
3759
#ifndef MNG_NO_OLD_VERSIONS
3760
if (pData->bPreDraft48)
3761
{
3762
iTermination = *(pRawdata+1);
3763
3764
iRepeat = mng_get_uint32 (pRawdata+2);
3765
}
3766
else
3767
#endif
3768
iRepeat = mng_get_uint32 (pRawdata+1);
3769
3770
if (iRawlen >= 6)
3771
{
3772
#ifndef MNG_NO_OLD_VERSIONS
3773
if (!pData->bPreDraft48)
3774
#endif
3775
iTermination = *(pRawdata+5);
3776
3777
if (iRawlen >= 10)
3778
{
3779
iItermin = mng_get_uint32 (pRawdata+6);
3780
3781
if (iRawlen >= 14)
3782
{
3783
iItermax = mng_get_uint32 (pRawdata+10);
3784
3785
/* TODO: process signals */
3786
3787
}
3788
}
3789
}
3790
/* create the LOOP ani-object */
3791
iRetcode = mng_create_ani_loop (pData, iLevel, iRepeat, iTermination,
3792
iItermin, iItermax, 0, 0);
3793
3794
if (iRetcode) /* on error bail out */
3795
return iRetcode;
3796
/* skip till matching ENDL if iteration=0 */
3797
if ((!pData->bSkipping) && (iRepeat == 0))
3798
pData->bSkipping = MNG_TRUE;
3799
}
3800
#endif /* MNG_SUPPORT_DISPLAY */
3801
3802
#ifdef MNG_STORE_CHUNKS
3803
if (pData->bStorechunks)
3804
{ /* initialize storage */
3805
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3806
3807
if (iRetcode) /* on error bail out */
3808
return iRetcode;
3809
3810
if (iRawlen >= 5) /* store the fields */
3811
{
3812
((mng_loopp)*ppChunk)->iLevel = *pRawdata;
3813
3814
#ifndef MNG_NO_OLD_VERSIONS
3815
if (pData->bPreDraft48)
3816
{
3817
((mng_loopp)*ppChunk)->iTermination = *(pRawdata+1);
3818
((mng_loopp)*ppChunk)->iRepeat = mng_get_uint32 (pRawdata+2);
3819
}
3820
else
3821
#endif
3822
{
3823
((mng_loopp)*ppChunk)->iRepeat = mng_get_uint32 (pRawdata+1);
3824
}
3825
3826
if (iRawlen >= 6)
3827
{
3828
#ifndef MNG_NO_OLD_VERSIONS
3829
if (!pData->bPreDraft48)
3830
#endif
3831
((mng_loopp)*ppChunk)->iTermination = *(pRawdata+5);
3832
3833
if (iRawlen >= 10)
3834
{
3835
((mng_loopp)*ppChunk)->iItermin = mng_get_uint32 (pRawdata+6);
3836
3837
#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
3838
if (iRawlen >= 14)
3839
{
3840
((mng_loopp)*ppChunk)->iItermax = mng_get_uint32 (pRawdata+10);
3841
((mng_loopp)*ppChunk)->iCount = (iRawlen - 14) / 4;
3842
3843
if (((mng_loopp)*ppChunk)->iCount)
3844
{
3845
MNG_ALLOC (pData, ((mng_loopp)*ppChunk)->pSignals,
3846
((mng_loopp)*ppChunk)->iCount << 2);
3847
3848
#ifndef MNG_BIGENDIAN_SUPPORTED
3849
{
3850
mng_uint32 iX;
3851
mng_uint8p pIn = pRawdata + 14;
3852
mng_uint32p pOut = (mng_uint32p)((mng_loopp)*ppChunk)->pSignals;
3853
3854
for (iX = 0; iX < ((mng_loopp)*ppChunk)->iCount; iX++)
3855
{
3856
*pOut++ = mng_get_uint32 (pIn);
3857
pIn += 4;
3858
}
3859
}
3860
#else
3861
MNG_COPY (((mng_loopp)*ppChunk)->pSignals, pRawdata + 14,
3862
((mng_loopp)*ppChunk)->iCount << 2);
3863
#endif /* !MNG_BIGENDIAN_SUPPORTED */
3864
}
3865
}
3866
#endif
3867
}
3868
}
3869
}
3870
}
3871
#endif /* MNG_STORE_CHUNKS */
3872
3873
#ifdef MNG_SUPPORT_TRACE
3874
MNG_TRACE (pData, MNG_FN_READ_LOOP, MNG_LC_END);
3875
#endif
3876
3877
return MNG_NOERROR; /* done */
3878
}
3879
#endif
3880
#endif
3881
3882
/* ************************************************************************** */
3883
3884
#ifndef MNG_OPTIMIZE_CHUNKREADER
3885
#ifndef MNG_SKIPCHUNK_LOOP
3886
READ_CHUNK (mng_read_endl)
3887
{
3888
#ifdef MNG_SUPPORT_TRACE
3889
MNG_TRACE (pData, MNG_FN_READ_ENDL, MNG_LC_START);
3890
#endif
3891
3892
if (!pData->bHasMHDR) /* sequence checks */
3893
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3894
3895
#ifdef MNG_INCLUDE_JNG
3896
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3897
#else
3898
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3899
#endif
3900
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3901
3902
if (iRawlen != 1) /* length must be exactly 1 */
3903
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3904
3905
#ifdef MNG_SUPPORT_DISPLAY
3906
{
3907
if (pData->bHasLOOP) /* are we really processing a loop ? */
3908
{
3909
mng_uint8 iLevel = *pRawdata; /* get the nest level */
3910
/* create an ENDL animation object */
3911
mng_retcode iRetcode = mng_create_ani_endl (pData, iLevel);
3912
3913
if (iRetcode) /* on error bail out */
3914
return iRetcode;
3915
3916
{ /* process it */
3917
mng_ani_endlp pENDL = (mng_ani_endlp)pData->pLastaniobj;
3918
3919
iRetcode = pENDL->sHeader.fProcess (pData, pENDL);
3920
3921
if (iRetcode) /* on error bail out */
3922
return iRetcode;
3923
}
3924
}
3925
else
3926
MNG_ERROR (pData, MNG_NOMATCHINGLOOP);
3927
3928
}
3929
#endif /* MNG_SUPPORT_DISPLAY */
3930
3931
#ifdef MNG_STORE_CHUNKS
3932
if (pData->bStorechunks)
3933
{ /* initialize storage */
3934
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
3935
3936
if (iRetcode) /* on error bail out */
3937
return iRetcode;
3938
/* store the fields */
3939
((mng_endlp)*ppChunk)->iLevel = *pRawdata;
3940
}
3941
#endif /* MNG_STORE_CHUNKS */
3942
3943
#ifdef MNG_SUPPORT_TRACE
3944
MNG_TRACE (pData, MNG_FN_READ_ENDL, MNG_LC_END);
3945
#endif
3946
3947
return MNG_NOERROR; /* done */
3948
}
3949
#endif
3950
#endif
3951
3952
/* ************************************************************************** */
3953
3954
#ifndef MNG_OPTIMIZE_CHUNKREADER
3955
#ifndef MNG_SKIPCHUNK_DEFI
3956
READ_CHUNK (mng_read_defi)
3957
{
3958
#ifdef MNG_SUPPORT_TRACE
3959
MNG_TRACE (pData, MNG_FN_READ_DEFI, MNG_LC_START);
3960
#endif
3961
3962
if (!pData->bHasMHDR) /* sequence checks */
3963
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3964
3965
#ifdef MNG_INCLUDE_JNG
3966
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
3967
#else
3968
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
3969
#endif
3970
MNG_ERROR (pData, MNG_SEQUENCEERROR);
3971
/* check the length */
3972
if ((iRawlen != 2) && (iRawlen != 3) && (iRawlen != 4) &&
3973
(iRawlen != 12) && (iRawlen != 28))
3974
MNG_ERROR (pData, MNG_INVALIDLENGTH);
3975
3976
#ifdef MNG_SUPPORT_DISPLAY
3977
{
3978
mng_retcode iRetcode;
3979
3980
pData->iDEFIobjectid = mng_get_uint16 (pRawdata);
3981
3982
if (iRawlen > 2)
3983
{
3984
pData->bDEFIhasdonotshow = MNG_TRUE;
3985
pData->iDEFIdonotshow = *(pRawdata+2);
3986
}
3987
else
3988
{
3989
pData->bDEFIhasdonotshow = MNG_FALSE;
3990
pData->iDEFIdonotshow = 0;
3991
}
3992
3993
if (iRawlen > 3)
3994
{
3995
pData->bDEFIhasconcrete = MNG_TRUE;
3996
pData->iDEFIconcrete = *(pRawdata+3);
3997
}
3998
else
3999
{
4000
pData->bDEFIhasconcrete = MNG_FALSE;
4001
pData->iDEFIconcrete = 0;
4002
}
4003
4004
if (iRawlen > 4)
4005
{
4006
pData->bDEFIhasloca = MNG_TRUE;
4007
pData->iDEFIlocax = mng_get_int32 (pRawdata+4);
4008
pData->iDEFIlocay = mng_get_int32 (pRawdata+8);
4009
}
4010
else
4011
{
4012
pData->bDEFIhasloca = MNG_FALSE;
4013
pData->iDEFIlocax = 0;
4014
pData->iDEFIlocay = 0;
4015
}
4016
4017
if (iRawlen > 12)
4018
{
4019
pData->bDEFIhasclip = MNG_TRUE;
4020
pData->iDEFIclipl = mng_get_int32 (pRawdata+12);
4021
pData->iDEFIclipr = mng_get_int32 (pRawdata+16);
4022
pData->iDEFIclipt = mng_get_int32 (pRawdata+20);
4023
pData->iDEFIclipb = mng_get_int32 (pRawdata+24);
4024
}
4025
else
4026
{
4027
pData->bDEFIhasclip = MNG_FALSE;
4028
pData->iDEFIclipl = 0;
4029
pData->iDEFIclipr = 0;
4030
pData->iDEFIclipt = 0;
4031
pData->iDEFIclipb = 0;
4032
}
4033
/* create an animation object */
4034
iRetcode = mng_create_ani_defi (pData);
4035
4036
if (!iRetcode) /* do display processing */
4037
iRetcode = mng_process_display_defi (pData);
4038
4039
if (iRetcode) /* on error bail out */
4040
return iRetcode;
4041
4042
}
4043
#endif /* MNG_SUPPORT_DISPLAY */
4044
4045
#ifdef MNG_STORE_CHUNKS
4046
if (pData->bStorechunks)
4047
{ /* initialize storage */
4048
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4049
4050
if (iRetcode) /* on error bail out */
4051
return iRetcode;
4052
/* store the fields */
4053
((mng_defip)*ppChunk)->iObjectid = mng_get_uint16 (pRawdata);
4054
4055
if (iRawlen > 2)
4056
{
4057
((mng_defip)*ppChunk)->bHasdonotshow = MNG_TRUE;
4058
((mng_defip)*ppChunk)->iDonotshow = *(pRawdata+2);
4059
}
4060
else
4061
((mng_defip)*ppChunk)->bHasdonotshow = MNG_FALSE;
4062
4063
if (iRawlen > 3)
4064
{
4065
((mng_defip)*ppChunk)->bHasconcrete = MNG_TRUE;
4066
((mng_defip)*ppChunk)->iConcrete = *(pRawdata+3);
4067
}
4068
else
4069
((mng_defip)*ppChunk)->bHasconcrete = MNG_FALSE;
4070
4071
if (iRawlen > 4)
4072
{
4073
((mng_defip)*ppChunk)->bHasloca = MNG_TRUE;
4074
((mng_defip)*ppChunk)->iXlocation = mng_get_int32 (pRawdata+4);
4075
((mng_defip)*ppChunk)->iYlocation = mng_get_int32 (pRawdata+8);
4076
}
4077
else
4078
((mng_defip)*ppChunk)->bHasloca = MNG_FALSE;
4079
4080
if (iRawlen > 12)
4081
{
4082
((mng_defip)*ppChunk)->bHasclip = MNG_TRUE;
4083
((mng_defip)*ppChunk)->iLeftcb = mng_get_int32 (pRawdata+12);
4084
((mng_defip)*ppChunk)->iRightcb = mng_get_int32 (pRawdata+16);
4085
((mng_defip)*ppChunk)->iTopcb = mng_get_int32 (pRawdata+20);
4086
((mng_defip)*ppChunk)->iBottomcb = mng_get_int32 (pRawdata+24);
4087
}
4088
else
4089
((mng_defip)*ppChunk)->bHasclip = MNG_FALSE;
4090
4091
}
4092
#endif /* MNG_STORE_CHUNKS */
4093
4094
#ifdef MNG_SUPPORT_TRACE
4095
MNG_TRACE (pData, MNG_FN_READ_DEFI, MNG_LC_END);
4096
#endif
4097
4098
return MNG_NOERROR; /* done */
4099
}
4100
#endif
4101
#endif
4102
4103
/* ************************************************************************** */
4104
4105
#ifndef MNG_OPTIMIZE_CHUNKREADER
4106
#ifndef MNG_SKIPCHUNK_BASI
4107
READ_CHUNK (mng_read_basi)
4108
{
4109
#ifdef MNG_SUPPORT_TRACE
4110
MNG_TRACE (pData, MNG_FN_READ_BASI, MNG_LC_START);
4111
#endif
4112
4113
if (!pData->bHasMHDR) /* sequence checks */
4114
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4115
4116
#ifdef MNG_INCLUDE_JNG
4117
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4118
#else
4119
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4120
#endif
4121
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4122
/* check the length */
4123
if ((iRawlen != 13) && (iRawlen != 19) && (iRawlen != 21) && (iRawlen != 22))
4124
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4125
4126
pData->bHasBASI = MNG_TRUE; /* inside a BASI-IEND block now */
4127
/* store interesting fields */
4128
pData->iDatawidth = mng_get_uint32 (pRawdata);
4129
pData->iDataheight = mng_get_uint32 (pRawdata+4);
4130
pData->iBitdepth = *(pRawdata+8);
4131
pData->iColortype = *(pRawdata+9);
4132
pData->iCompression = *(pRawdata+10);
4133
pData->iFilter = *(pRawdata+11);
4134
pData->iInterlace = *(pRawdata+12);
4135
4136
4137
#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
4138
pData->iPNGmult = 1;
4139
pData->iPNGdepth = pData->iBitdepth;
4140
#endif
4141
4142
#ifdef MNG_NO_1_2_4BIT_SUPPORT
4143
if (pData->iBitdepth < 8)
4144
pData->iBitdepth = 8;
4145
#endif
4146
#ifdef MNG_NO_16BIT_SUPPORT
4147
if (pData->iBitdepth > 8)
4148
{
4149
pData->iBitdepth = 8;
4150
pData->iPNGmult = 2;
4151
}
4152
#endif
4153
4154
if ((pData->iBitdepth != 8) /* parameter validity checks */
4155
#ifndef MNG_NO_1_2_4BIT_SUPPORT
4156
&& (pData->iBitdepth != 1) &&
4157
(pData->iBitdepth != 2) &&
4158
(pData->iBitdepth != 4)
4159
#endif
4160
#ifndef MNG_NO_16BIT_SUPPORT
4161
&& (pData->iBitdepth != 16)
4162
#endif
4163
)
4164
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
4165
4166
if ((pData->iColortype != MNG_COLORTYPE_GRAY ) &&
4167
(pData->iColortype != MNG_COLORTYPE_RGB ) &&
4168
(pData->iColortype != MNG_COLORTYPE_INDEXED) &&
4169
(pData->iColortype != MNG_COLORTYPE_GRAYA ) &&
4170
(pData->iColortype != MNG_COLORTYPE_RGBA ) )
4171
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
4172
4173
if ((pData->iColortype == MNG_COLORTYPE_INDEXED) && (pData->iBitdepth > 8))
4174
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
4175
4176
if (((pData->iColortype == MNG_COLORTYPE_RGB ) ||
4177
(pData->iColortype == MNG_COLORTYPE_GRAYA ) ||
4178
(pData->iColortype == MNG_COLORTYPE_RGBA ) ) &&
4179
(pData->iBitdepth < 8 ) )
4180
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
4181
4182
if (pData->iCompression != MNG_COMPRESSION_DEFLATE)
4183
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
4184
4185
#if defined(FILTER192) || defined(FILTER193)
4186
if ((pData->iFilter != MNG_FILTER_ADAPTIVE ) &&
4187
#if defined(FILTER192) && defined(FILTER193)
4188
(pData->iFilter != MNG_FILTER_DIFFERING) &&
4189
(pData->iFilter != MNG_FILTER_NOFILTER ) )
4190
#else
4191
#ifdef FILTER192
4192
(pData->iFilter != MNG_FILTER_DIFFERING) )
4193
#else
4194
(pData->iFilter != MNG_FILTER_NOFILTER ) )
4195
#endif
4196
#endif
4197
MNG_ERROR (pData, MNG_INVALIDFILTER);
4198
#else
4199
if (pData->iFilter)
4200
MNG_ERROR (pData, MNG_INVALIDFILTER);
4201
#endif
4202
4203
if ((pData->iInterlace != MNG_INTERLACE_NONE ) &&
4204
(pData->iInterlace != MNG_INTERLACE_ADAM7) )
4205
MNG_ERROR (pData, MNG_INVALIDINTERLACE);
4206
4207
pData->iImagelevel++; /* one level deeper */
4208
4209
#ifdef MNG_SUPPORT_DISPLAY
4210
{
4211
mng_uint16 iRed = 0;
4212
mng_uint16 iGreen = 0;
4213
mng_uint16 iBlue = 0;
4214
mng_bool bHasalpha = MNG_FALSE;
4215
mng_uint16 iAlpha = 0xFFFF;
4216
mng_uint8 iViewable = 0;
4217
mng_retcode iRetcode;
4218
4219
if (iRawlen > 13) /* get remaining fields, if any */
4220
{
4221
iRed = mng_get_uint16 (pRawdata+13);
4222
iGreen = mng_get_uint16 (pRawdata+15);
4223
iBlue = mng_get_uint16 (pRawdata+17);
4224
}
4225
4226
if (iRawlen > 19)
4227
{
4228
bHasalpha = MNG_TRUE;
4229
iAlpha = mng_get_uint16 (pRawdata+19);
4230
}
4231
4232
if (iRawlen > 21)
4233
iViewable = *(pRawdata+21);
4234
/* create an animation object */
4235
iRetcode = mng_create_ani_basi (pData, iRed, iGreen, iBlue,
4236
bHasalpha, iAlpha, iViewable);
4237
4238
if (!iRetcode) /* display-processing... */
4239
iRetcode = mng_process_display_basi (pData, iRed, iGreen, iBlue,
4240
bHasalpha, iAlpha, iViewable);
4241
4242
if (iRetcode) /* on error bail out */
4243
return iRetcode;
4244
4245
}
4246
#endif /* MNG_SUPPORT_DISPLAY */
4247
4248
#ifdef MNG_STORE_CHUNKS
4249
if (pData->bStorechunks)
4250
{ /* initialize storage */
4251
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4252
4253
if (iRetcode) /* on error bail out */
4254
return iRetcode;
4255
/* store the fields */
4256
((mng_basip)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
4257
((mng_basip)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
4258
#ifdef MNG_NO_16BIT_SUPPORT
4259
if (*(pRawdata+8) > 8)
4260
((mng_basip)*ppChunk)->iBitdepth = 8;
4261
else
4262
#endif
4263
((mng_basip)*ppChunk)->iBitdepth = *(pRawdata+8);
4264
((mng_basip)*ppChunk)->iColortype = *(pRawdata+9);
4265
((mng_basip)*ppChunk)->iCompression = *(pRawdata+10);
4266
((mng_basip)*ppChunk)->iFilter = *(pRawdata+11);
4267
((mng_basip)*ppChunk)->iInterlace = *(pRawdata+12);
4268
4269
if (iRawlen > 13)
4270
{
4271
((mng_basip)*ppChunk)->iRed = mng_get_uint16 (pRawdata+13);
4272
((mng_basip)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+15);
4273
((mng_basip)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+17);
4274
}
4275
4276
if (iRawlen > 19)
4277
((mng_basip)*ppChunk)->iAlpha = mng_get_uint16 (pRawdata+19);
4278
4279
if (iRawlen > 21)
4280
((mng_basip)*ppChunk)->iViewable = *(pRawdata+21);
4281
4282
}
4283
#endif /* MNG_STORE_CHUNKS */
4284
4285
#ifdef MNG_SUPPORT_TRACE
4286
MNG_TRACE (pData, MNG_FN_READ_BASI, MNG_LC_END);
4287
#endif
4288
4289
return MNG_NOERROR; /* done */
4290
}
4291
#endif
4292
#endif
4293
4294
/* ************************************************************************** */
4295
4296
#ifndef MNG_OPTIMIZE_CHUNKREADER
4297
#ifndef MNG_SKIPCHUNK_CLON
4298
READ_CHUNK (mng_read_clon)
4299
{
4300
#ifdef MNG_SUPPORT_TRACE
4301
MNG_TRACE (pData, MNG_FN_READ_CLON, MNG_LC_START);
4302
#endif
4303
4304
if (!pData->bHasMHDR) /* sequence checks */
4305
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4306
4307
#ifdef MNG_INCLUDE_JNG
4308
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4309
#else
4310
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4311
#endif
4312
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4313
/* check the length */
4314
if ((iRawlen != 4) && (iRawlen != 5) && (iRawlen != 6) &&
4315
(iRawlen != 7) && (iRawlen != 16))
4316
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4317
4318
#ifdef MNG_SUPPORT_DISPLAY
4319
{
4320
mng_uint16 iSourceid, iCloneid;
4321
mng_uint8 iClonetype = 0;
4322
mng_bool bHasdonotshow = MNG_FALSE;
4323
mng_uint8 iDonotshow = 0;
4324
mng_uint8 iConcrete = 0;
4325
mng_bool bHasloca = MNG_FALSE;
4326
mng_uint8 iLocationtype = 0;
4327
mng_int32 iLocationx = 0;
4328
mng_int32 iLocationy = 0;
4329
mng_retcode iRetcode;
4330
4331
iSourceid = mng_get_uint16 (pRawdata);
4332
iCloneid = mng_get_uint16 (pRawdata+2);
4333
4334
if (iRawlen > 4)
4335
iClonetype = *(pRawdata+4);
4336
4337
if (iRawlen > 5)
4338
{
4339
bHasdonotshow = MNG_TRUE;
4340
iDonotshow = *(pRawdata+5);
4341
}
4342
4343
if (iRawlen > 6)
4344
iConcrete = *(pRawdata+6);
4345
4346
if (iRawlen > 7)
4347
{
4348
bHasloca = MNG_TRUE;
4349
iLocationtype = *(pRawdata+7);
4350
iLocationx = mng_get_int32 (pRawdata+8);
4351
iLocationy = mng_get_int32 (pRawdata+12);
4352
}
4353
4354
iRetcode = mng_create_ani_clon (pData, iSourceid, iCloneid, iClonetype,
4355
bHasdonotshow, iDonotshow, iConcrete,
4356
bHasloca, iLocationtype, iLocationx, iLocationy);
4357
4358
if (!iRetcode) /* do display processing */
4359
iRetcode = mng_process_display_clon (pData, iSourceid, iCloneid, iClonetype,
4360
bHasdonotshow, iDonotshow, iConcrete,
4361
bHasloca, iLocationtype, iLocationx,
4362
iLocationy);
4363
4364
if (iRetcode) /* on error bail out */
4365
return iRetcode;
4366
4367
}
4368
#endif /* MNG_SUPPORT_DISPLAY */
4369
4370
#ifdef MNG_STORE_CHUNKS
4371
if (pData->bStorechunks)
4372
{ /* initialize storage */
4373
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4374
4375
if (iRetcode) /* on error bail out */
4376
return iRetcode;
4377
/* store the fields */
4378
((mng_clonp)*ppChunk)->iSourceid = mng_get_uint16 (pRawdata);
4379
((mng_clonp)*ppChunk)->iCloneid = mng_get_uint16 (pRawdata+2);
4380
4381
if (iRawlen > 4)
4382
((mng_clonp)*ppChunk)->iClonetype = *(pRawdata+4);
4383
4384
if (iRawlen > 5)
4385
((mng_clonp)*ppChunk)->iDonotshow = *(pRawdata+5);
4386
4387
if (iRawlen > 6)
4388
((mng_clonp)*ppChunk)->iConcrete = *(pRawdata+6);
4389
4390
if (iRawlen > 7)
4391
{
4392
((mng_clonp)*ppChunk)->bHasloca = MNG_TRUE;
4393
((mng_clonp)*ppChunk)->iLocationtype = *(pRawdata+7);
4394
((mng_clonp)*ppChunk)->iLocationx = mng_get_int32 (pRawdata+8);
4395
((mng_clonp)*ppChunk)->iLocationy = mng_get_int32 (pRawdata+12);
4396
}
4397
else
4398
{
4399
((mng_clonp)*ppChunk)->bHasloca = MNG_FALSE;
4400
}
4401
}
4402
#endif /* MNG_STORE_CHUNKS */
4403
4404
#ifdef MNG_SUPPORT_TRACE
4405
MNG_TRACE (pData, MNG_FN_READ_CLON, MNG_LC_END);
4406
#endif
4407
4408
return MNG_NOERROR; /* done */
4409
}
4410
#endif
4411
#endif
4412
4413
/* ************************************************************************** */
4414
4415
#ifndef MNG_OPTIMIZE_CHUNKREADER
4416
#ifndef MNG_SKIPCHUNK_PAST
4417
READ_CHUNK (mng_read_past)
4418
{
4419
#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
4420
mng_retcode iRetcode;
4421
mng_uint16 iTargetid;
4422
mng_uint8 iTargettype;
4423
mng_int32 iTargetx;
4424
mng_int32 iTargety;
4425
mng_uint32 iCount;
4426
mng_uint32 iSize;
4427
mng_ptr pSources;
4428
mng_uint32 iX;
4429
mng_past_sourcep pSource;
4430
#endif
4431
4432
#ifdef MNG_SUPPORT_TRACE
4433
MNG_TRACE (pData, MNG_FN_READ_PAST, MNG_LC_START);
4434
#endif
4435
4436
if (!pData->bHasMHDR) /* sequence checks */
4437
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4438
4439
#ifdef MNG_INCLUDE_JNG
4440
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4441
#else
4442
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4443
#endif
4444
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4445
4446
/* check the length */
4447
if ((iRawlen < 41) || (((iRawlen - 11) % 30) != 0))
4448
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4449
4450
#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
4451
iTargetid = mng_get_uint16 (pRawdata);
4452
iTargettype = *(pRawdata+2);
4453
iTargetx = mng_get_int32 (pRawdata+3);
4454
iTargety = mng_get_int32 (pRawdata+7);
4455
iCount = ((iRawlen - 11) / 30); /* how many entries again? */
4456
iSize = iCount * sizeof (mng_past_source);
4457
4458
pRawdata += 11;
4459
/* get a buffer for all the source blocks */
4460
MNG_ALLOC (pData, pSources, iSize);
4461
4462
pSource = (mng_past_sourcep)pSources;
4463
4464
for (iX = 0; iX < iCount; iX++) /* now copy the source blocks */
4465
{
4466
pSource->iSourceid = mng_get_uint16 (pRawdata);
4467
pSource->iComposition = *(pRawdata+2);
4468
pSource->iOrientation = *(pRawdata+3);
4469
pSource->iOffsettype = *(pRawdata+4);
4470
pSource->iOffsetx = mng_get_int32 (pRawdata+5);
4471
pSource->iOffsety = mng_get_int32 (pRawdata+9);
4472
pSource->iBoundarytype = *(pRawdata+13);
4473
pSource->iBoundaryl = mng_get_int32 (pRawdata+14);
4474
pSource->iBoundaryr = mng_get_int32 (pRawdata+18);
4475
pSource->iBoundaryt = mng_get_int32 (pRawdata+22);
4476
pSource->iBoundaryb = mng_get_int32 (pRawdata+26);
4477
4478
pSource++;
4479
pRawdata += 30;
4480
}
4481
#endif
4482
4483
#ifdef MNG_SUPPORT_DISPLAY
4484
{ /* create playback object */
4485
iRetcode = mng_create_ani_past (pData, iTargetid, iTargettype, iTargetx,
4486
iTargety, iCount, pSources);
4487
4488
if (!iRetcode) /* do display processing */
4489
iRetcode = mng_process_display_past (pData, iTargetid, iTargettype, iTargetx,
4490
iTargety, iCount, pSources);
4491
4492
if (iRetcode) /* on error bail out */
4493
{
4494
MNG_FREEX (pData, pSources, iSize);
4495
return iRetcode;
4496
}
4497
}
4498
#endif /* MNG_SUPPORT_DISPLAY */
4499
4500
#ifdef MNG_STORE_CHUNKS
4501
if (pData->bStorechunks)
4502
{ /* initialize storage */
4503
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4504
4505
if (iRetcode) /* on error bail out */
4506
{
4507
MNG_FREEX (pData, pSources, iSize);
4508
return iRetcode;
4509
}
4510
/* store the fields */
4511
((mng_pastp)*ppChunk)->iDestid = iTargetid;
4512
((mng_pastp)*ppChunk)->iTargettype = iTargettype;
4513
((mng_pastp)*ppChunk)->iTargetx = iTargetx;
4514
((mng_pastp)*ppChunk)->iTargety = iTargety;
4515
((mng_pastp)*ppChunk)->iCount = iCount;
4516
/* get a buffer & copy the source blocks */
4517
MNG_ALLOC (pData, ((mng_pastp)*ppChunk)->pSources, iSize);
4518
MNG_COPY (((mng_pastp)*ppChunk)->pSources, pSources, iSize);
4519
}
4520
#endif /* MNG_STORE_CHUNKS */
4521
4522
#if defined(MNG_STORE_CHUNKS) || defined(MNG_SUPPORT_DISPLAY)
4523
/* free the source block buffer */
4524
MNG_FREEX (pData, pSources, iSize);
4525
#endif
4526
4527
#ifdef MNG_SUPPORT_TRACE
4528
MNG_TRACE (pData, MNG_FN_READ_PAST, MNG_LC_END);
4529
#endif
4530
4531
return MNG_NOERROR; /* done */
4532
}
4533
#endif
4534
#endif
4535
4536
/* ************************************************************************** */
4537
4538
#ifndef MNG_OPTIMIZE_CHUNKREADER
4539
#ifndef MNG_SKIPCHUNK_DISC
4540
READ_CHUNK (mng_read_disc)
4541
{
4542
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
4543
mng_uint32 iCount;
4544
mng_uint16p pIds = MNG_NULL;
4545
mng_retcode iRetcode;
4546
#endif
4547
4548
#ifdef MNG_SUPPORT_TRACE
4549
MNG_TRACE (pData, MNG_FN_READ_DISC, MNG_LC_START);
4550
#endif
4551
4552
if (!pData->bHasMHDR) /* sequence checks */
4553
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4554
4555
#ifdef MNG_INCLUDE_JNG
4556
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4557
#else
4558
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4559
#endif
4560
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4561
4562
if ((iRawlen % 2) != 0) /* check the length */
4563
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4564
4565
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
4566
iCount = (iRawlen / sizeof (mng_uint16));
4567
4568
if (iCount)
4569
{
4570
MNG_ALLOC (pData, pIds, iRawlen);
4571
4572
#ifndef MNG_BIGENDIAN_SUPPORTED
4573
{
4574
mng_uint32 iX;
4575
mng_uint8p pIn = pRawdata;
4576
mng_uint16p pOut = pIds;
4577
4578
for (iX = 0; iX < iCount; iX++)
4579
{
4580
*pOut++ = mng_get_uint16 (pIn);
4581
pIn += 2;
4582
}
4583
}
4584
#else
4585
MNG_COPY (pIds, pRawdata, iRawlen);
4586
#endif /* !MNG_BIGENDIAN_SUPPORTED */
4587
}
4588
#endif
4589
4590
#ifdef MNG_SUPPORT_DISPLAY
4591
{ /* create playback object */
4592
iRetcode = mng_create_ani_disc (pData, iCount, pIds);
4593
4594
if (iRetcode) /* on error bail out */
4595
return iRetcode;
4596
/* now process it */
4597
iRetcode = mng_process_display_disc (pData, iCount, pIds);
4598
4599
if (iRetcode) /* on error bail out */
4600
return iRetcode;
4601
}
4602
#endif /* MNG_SUPPORT_DISPLAY */
4603
4604
#ifdef MNG_STORE_CHUNKS
4605
if (pData->bStorechunks)
4606
{ /* initialize storage */
4607
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4608
4609
if (iRetcode) /* on error bail out */
4610
return iRetcode;
4611
/* store the fields */
4612
((mng_discp)*ppChunk)->iCount = iCount;
4613
4614
if (iRawlen)
4615
{
4616
MNG_ALLOC (pData, ((mng_discp)*ppChunk)->pObjectids, iRawlen);
4617
MNG_COPY (((mng_discp)*ppChunk)->pObjectids, pIds, iRawlen);
4618
}
4619
}
4620
#endif /* MNG_STORE_CHUNKS */
4621
4622
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
4623
if (iRawlen)
4624
MNG_FREEX (pData, pIds, iRawlen);
4625
#endif
4626
4627
#ifdef MNG_SUPPORT_TRACE
4628
MNG_TRACE (pData, MNG_FN_READ_DISC, MNG_LC_END);
4629
#endif
4630
4631
return MNG_NOERROR; /* done */
4632
}
4633
#endif
4634
#endif
4635
4636
/* ************************************************************************** */
4637
4638
#ifndef MNG_OPTIMIZE_CHUNKREADER
4639
#ifndef MNG_SKIPCHUNK_BACK
4640
READ_CHUNK (mng_read_back)
4641
{
4642
#ifdef MNG_SUPPORT_TRACE
4643
MNG_TRACE (pData, MNG_FN_READ_BACK, MNG_LC_START);
4644
#endif
4645
4646
if (!pData->bHasMHDR) /* sequence checks */
4647
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4648
4649
#ifdef MNG_INCLUDE_JNG
4650
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4651
#else
4652
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4653
#endif
4654
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4655
/* check the length */
4656
if ((iRawlen != 6) && (iRawlen != 7) && (iRawlen != 9) && (iRawlen != 10))
4657
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4658
4659
#ifdef MNG_SUPPORT_DISPLAY
4660
{
4661
mng_retcode iRetcode;
4662
/* retrieve the fields */
4663
pData->bHasBACK = MNG_TRUE;
4664
pData->iBACKred = mng_get_uint16 (pRawdata);
4665
pData->iBACKgreen = mng_get_uint16 (pRawdata+2);
4666
pData->iBACKblue = mng_get_uint16 (pRawdata+4);
4667
4668
if (iRawlen > 6)
4669
pData->iBACKmandatory = *(pRawdata+6);
4670
else
4671
pData->iBACKmandatory = 0;
4672
4673
if (iRawlen > 7)
4674
pData->iBACKimageid = mng_get_uint16 (pRawdata+7);
4675
else
4676
pData->iBACKimageid = 0;
4677
4678
if (iRawlen > 9)
4679
pData->iBACKtile = *(pRawdata+9);
4680
else
4681
pData->iBACKtile = 0;
4682
4683
iRetcode = mng_create_ani_back (pData, pData->iBACKred, pData->iBACKgreen,
4684
pData->iBACKblue, pData->iBACKmandatory,
4685
pData->iBACKimageid, pData->iBACKtile);
4686
4687
if (iRetcode) /* on error bail out */
4688
return iRetcode;
4689
}
4690
#endif /* MNG_SUPPORT_DISPLAY */
4691
4692
#ifdef MNG_STORE_CHUNKS
4693
if (pData->bStorechunks)
4694
{ /* initialize storage */
4695
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4696
4697
if (iRetcode) /* on error bail out */
4698
return iRetcode;
4699
/* store the fields */
4700
((mng_backp)*ppChunk)->iRed = mng_get_uint16 (pRawdata);
4701
((mng_backp)*ppChunk)->iGreen = mng_get_uint16 (pRawdata+2);
4702
((mng_backp)*ppChunk)->iBlue = mng_get_uint16 (pRawdata+4);
4703
4704
if (iRawlen > 6)
4705
((mng_backp)*ppChunk)->iMandatory = *(pRawdata+6);
4706
4707
if (iRawlen > 7)
4708
((mng_backp)*ppChunk)->iImageid = mng_get_uint16 (pRawdata+7);
4709
4710
if (iRawlen > 9)
4711
((mng_backp)*ppChunk)->iTile = *(pRawdata+9);
4712
4713
}
4714
#endif /* MNG_STORE_CHUNKS */
4715
4716
#ifdef MNG_SUPPORT_TRACE
4717
MNG_TRACE (pData, MNG_FN_READ_BACK, MNG_LC_END);
4718
#endif
4719
4720
return MNG_NOERROR; /* done */
4721
}
4722
#endif
4723
#endif
4724
4725
/* ************************************************************************** */
4726
4727
#ifndef MNG_OPTIMIZE_CHUNKREADER
4728
#ifndef MNG_SKIPCHUNK_FRAM
4729
READ_CHUNK (mng_read_fram)
4730
{
4731
mng_uint8p pTemp;
4732
#ifdef MNG_STORE_CHUNKS
4733
mng_uint32 iNamelen;
4734
#endif
4735
mng_uint32 iRemain;
4736
mng_uint32 iRequired = 0;
4737
4738
#ifdef MNG_SUPPORT_TRACE
4739
MNG_TRACE (pData, MNG_FN_READ_FRAM, MNG_LC_START);
4740
#endif
4741
4742
if (!pData->bHasMHDR) /* sequence checks */
4743
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4744
4745
#ifdef MNG_INCLUDE_JNG
4746
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
4747
#else
4748
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
4749
#endif
4750
MNG_ERROR (pData, MNG_SEQUENCEERROR);
4751
4752
if (iRawlen <= 1) /* only framing-mode ? */
4753
{
4754
#ifdef MNG_STORE_CHUNKS
4755
iNamelen = 0; /* indicate so */
4756
#endif
4757
iRemain = 0;
4758
pTemp = MNG_NULL;
4759
}
4760
else
4761
{
4762
pTemp = find_null (pRawdata+1); /* find null-separator */
4763
/* not found inside input-data ? */
4764
if ((pTemp - pRawdata) > (mng_int32)iRawlen)
4765
pTemp = pRawdata + iRawlen; /* than remainder is name */
4766
4767
#ifdef MNG_STORE_CHUNKS
4768
iNamelen = (mng_uint32)((pTemp - pRawdata) - 1);
4769
#endif
4770
iRemain = (mng_uint32)(iRawlen - (pTemp - pRawdata));
4771
4772
if (iRemain) /* if there is remaining data it's less 1 byte */
4773
iRemain--;
4774
4775
if ((iRemain) && (iRemain < 4)) /* remains must be empty or at least 4 bytes */
4776
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4777
4778
if (iRemain)
4779
{
4780
iRequired = 4; /* calculate and check required remaining length */
4781
4782
if (*(pTemp+1)) { iRequired += 4; }
4783
if (*(pTemp+2)) { iRequired += 4; }
4784
if (*(pTemp+3)) { iRequired += 17; }
4785
4786
if (*(pTemp+4))
4787
{
4788
if ((iRemain - iRequired) % 4 != 0)
4789
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4790
}
4791
else
4792
{
4793
if (iRemain != iRequired)
4794
MNG_ERROR (pData, MNG_INVALIDLENGTH);
4795
}
4796
}
4797
}
4798
4799
#ifdef MNG_SUPPORT_DISPLAY
4800
{
4801
mng_uint8p pWork = pTemp;
4802
mng_uint8 iFramemode = 0;
4803
mng_uint8 iChangedelay = 0;
4804
mng_uint32 iDelay = 0;
4805
mng_uint8 iChangetimeout = 0;
4806
mng_uint32 iTimeout = 0;
4807
mng_uint8 iChangeclipping = 0;
4808
mng_uint8 iCliptype = 0;
4809
mng_int32 iClipl = 0;
4810
mng_int32 iClipr = 0;
4811
mng_int32 iClipt = 0;
4812
mng_int32 iClipb = 0;
4813
mng_retcode iRetcode;
4814
4815
if (iRawlen) /* any data specified ? */
4816
{
4817
if (*(pRawdata)) /* save the new framing mode ? */
4818
{
4819
iFramemode = *(pRawdata);
4820
4821
#ifndef MNG_NO_OLD_VERSIONS
4822
if (pData->bPreDraft48) /* old style input-stream ? */
4823
{
4824
switch (iFramemode)
4825
{
4826
case 0: { break; }
4827
case 1: { iFramemode = 3; break; }
4828
case 2: { iFramemode = 4; break; }
4829
case 3: { iFramemode = 1; break; }
4830
case 4: { iFramemode = 1; break; }
4831
case 5: { iFramemode = 2; break; }
4832
default: { iFramemode = 1; break; }
4833
}
4834
}
4835
#endif
4836
}
4837
4838
if (iRemain)
4839
{
4840
iChangedelay = *(pWork+1);
4841
iChangetimeout = *(pWork+2);
4842
iChangeclipping = *(pWork+3);
4843
pWork += 5;
4844
4845
if (iChangedelay) /* delay changed ? */
4846
{
4847
iDelay = mng_get_uint32 (pWork);
4848
pWork += 4;
4849
}
4850
4851
if (iChangetimeout) /* timeout changed ? */
4852
{
4853
iTimeout = mng_get_uint32 (pWork);
4854
pWork += 4;
4855
}
4856
4857
if (iChangeclipping) /* clipping changed ? */
4858
{
4859
iCliptype = *pWork;
4860
iClipl = mng_get_int32 (pWork+1);
4861
iClipr = mng_get_int32 (pWork+5);
4862
iClipt = mng_get_int32 (pWork+9);
4863
iClipb = mng_get_int32 (pWork+13);
4864
}
4865
}
4866
}
4867
4868
iRetcode = mng_create_ani_fram (pData, iFramemode, iChangedelay, iDelay,
4869
iChangetimeout, iTimeout,
4870
iChangeclipping, iCliptype,
4871
iClipl, iClipr, iClipt, iClipb);
4872
4873
if (!iRetcode) /* now go and do something */
4874
iRetcode = mng_process_display_fram (pData, iFramemode, iChangedelay, iDelay,
4875
iChangetimeout, iTimeout,
4876
iChangeclipping, iCliptype,
4877
iClipl, iClipr, iClipt, iClipb);
4878
4879
if (iRetcode) /* on error bail out */
4880
return iRetcode;
4881
4882
}
4883
#endif /* MNG_SUPPORT_DISPLAY */
4884
4885
#ifdef MNG_STORE_CHUNKS
4886
if (pData->bStorechunks)
4887
{ /* initialize storage */
4888
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
4889
4890
if (iRetcode) /* on error bail out */
4891
return iRetcode;
4892
/* store the fields */
4893
((mng_framp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
4894
4895
if (iRawlen)
4896
{
4897
mng_uint8 iFramemode = *(pRawdata);
4898
4899
#ifndef MNG_NO_OLD_VERSIONS
4900
if (pData->bPreDraft48) /* old style input-stream ? */
4901
{
4902
switch (iFramemode)
4903
{
4904
case 1: { iFramemode = 3; break; }
4905
case 2: { iFramemode = 4; break; }
4906
case 3: { iFramemode = 5; break; } /* TODO: provision for mode=5 ??? */
4907
case 4: { iFramemode = 1; break; }
4908
case 5: { iFramemode = 2; break; }
4909
default: { iFramemode = 1; break; }
4910
}
4911
}
4912
#endif
4913
4914
((mng_framp)*ppChunk)->iMode = iFramemode;
4915
((mng_framp)*ppChunk)->iNamesize = iNamelen;
4916
4917
if (iNamelen)
4918
{
4919
MNG_ALLOC (pData, ((mng_framp)*ppChunk)->zName, iNamelen+1);
4920
MNG_COPY (((mng_framp)*ppChunk)->zName, pRawdata+1, iNamelen);
4921
}
4922
4923
if (iRemain)
4924
{
4925
((mng_framp)*ppChunk)->iChangedelay = *(pTemp+1);
4926
((mng_framp)*ppChunk)->iChangetimeout = *(pTemp+2);
4927
((mng_framp)*ppChunk)->iChangeclipping = *(pTemp+3);
4928
((mng_framp)*ppChunk)->iChangesyncid = *(pTemp+4);
4929
4930
pTemp += 5;
4931
4932
if (((mng_framp)*ppChunk)->iChangedelay)
4933
{
4934
((mng_framp)*ppChunk)->iDelay = mng_get_uint32 (pTemp);
4935
pTemp += 4;
4936
}
4937
4938
if (((mng_framp)*ppChunk)->iChangetimeout)
4939
{
4940
((mng_framp)*ppChunk)->iTimeout = mng_get_uint32 (pTemp);
4941
pTemp += 4;
4942
}
4943
4944
if (((mng_framp)*ppChunk)->iChangeclipping)
4945
{
4946
((mng_framp)*ppChunk)->iBoundarytype = *pTemp;
4947
((mng_framp)*ppChunk)->iBoundaryl = mng_get_int32 (pTemp+1);
4948
((mng_framp)*ppChunk)->iBoundaryr = mng_get_int32 (pTemp+5);
4949
((mng_framp)*ppChunk)->iBoundaryt = mng_get_int32 (pTemp+9);
4950
((mng_framp)*ppChunk)->iBoundaryb = mng_get_int32 (pTemp+13);
4951
pTemp += 17;
4952
}
4953
4954
if (((mng_framp)*ppChunk)->iChangesyncid)
4955
{
4956
((mng_framp)*ppChunk)->iCount = (iRemain - iRequired) / 4;
4957
4958
if (((mng_framp)*ppChunk)->iCount)
4959
{
4960
MNG_ALLOC (pData, ((mng_framp)*ppChunk)->pSyncids,
4961
((mng_framp)*ppChunk)->iCount * 4);
4962
4963
#ifndef MNG_BIGENDIAN_SUPPORTED
4964
{
4965
mng_uint32 iX;
4966
mng_uint32p pOut = ((mng_framp)*ppChunk)->pSyncids;
4967
4968
for (iX = 0; iX < ((mng_framp)*ppChunk)->iCount; iX++)
4969
{
4970
*pOut++ = mng_get_uint32 (pTemp);
4971
pTemp += 4;
4972
}
4973
}
4974
#else
4975
MNG_COPY (((mng_framp)*ppChunk)->pSyncids, pTemp,
4976
((mng_framp)*ppChunk)->iCount * 4);
4977
#endif /* !MNG_BIGENDIAN_SUPPORTED */
4978
}
4979
}
4980
}
4981
}
4982
}
4983
#endif /* MNG_STORE_CHUNKS */
4984
4985
#ifdef MNG_SUPPORT_TRACE
4986
MNG_TRACE (pData, MNG_FN_READ_FRAM, MNG_LC_END);
4987
#endif
4988
4989
return MNG_NOERROR; /* done */
4990
}
4991
#endif
4992
#endif
4993
4994
/* ************************************************************************** */
4995
4996
#ifndef MNG_OPTIMIZE_CHUNKREADER
4997
#ifndef MNG_SKIPCHUNK_MOVE
4998
READ_CHUNK (mng_read_move)
4999
{
5000
#ifdef MNG_SUPPORT_TRACE
5001
MNG_TRACE (pData, MNG_FN_READ_MOVE, MNG_LC_START);
5002
#endif
5003
5004
if (!pData->bHasMHDR) /* sequence checks */
5005
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5006
5007
#ifdef MNG_INCLUDE_JNG
5008
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5009
#else
5010
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5011
#endif
5012
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5013
5014
if (iRawlen != 13) /* check the length */
5015
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5016
5017
#ifdef MNG_SUPPORT_DISPLAY
5018
{
5019
mng_retcode iRetcode;
5020
/* create a MOVE animation object */
5021
iRetcode = mng_create_ani_move (pData, mng_get_uint16 (pRawdata),
5022
mng_get_uint16 (pRawdata+2),
5023
*(pRawdata+4),
5024
mng_get_int32 (pRawdata+5),
5025
mng_get_int32 (pRawdata+9));
5026
5027
if (!iRetcode) /* process the move */
5028
iRetcode = mng_process_display_move (pData,
5029
mng_get_uint16 (pRawdata),
5030
mng_get_uint16 (pRawdata+2),
5031
*(pRawdata+4),
5032
mng_get_int32 (pRawdata+5),
5033
mng_get_int32 (pRawdata+9));
5034
5035
if (iRetcode) /* on error bail out */
5036
return iRetcode;
5037
5038
}
5039
#endif /* MNG_SUPPORT_DISPLAY */
5040
5041
#ifdef MNG_STORE_CHUNKS
5042
if (pData->bStorechunks)
5043
{ /* initialize storage */
5044
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5045
5046
if (iRetcode) /* on error bail out */
5047
return iRetcode;
5048
/* store the fields */
5049
((mng_movep)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
5050
((mng_movep)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
5051
((mng_movep)*ppChunk)->iMovetype = *(pRawdata+4);
5052
((mng_movep)*ppChunk)->iMovex = mng_get_int32 (pRawdata+5);
5053
((mng_movep)*ppChunk)->iMovey = mng_get_int32 (pRawdata+9);
5054
}
5055
#endif /* MNG_STORE_CHUNKS */
5056
5057
#ifdef MNG_SUPPORT_TRACE
5058
MNG_TRACE (pData, MNG_FN_READ_MOVE, MNG_LC_END);
5059
#endif
5060
5061
return MNG_NOERROR; /* done */
5062
}
5063
#endif
5064
#endif
5065
5066
/* ************************************************************************** */
5067
5068
#ifndef MNG_OPTIMIZE_CHUNKREADER
5069
#ifndef MNG_SKIPCHUNK_CLIP
5070
READ_CHUNK (mng_read_clip)
5071
{
5072
#ifdef MNG_SUPPORT_TRACE
5073
MNG_TRACE (pData, MNG_FN_READ_CLIP, MNG_LC_START);
5074
#endif
5075
5076
if (!pData->bHasMHDR) /* sequence checks */
5077
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5078
5079
#ifdef MNG_INCLUDE_JNG
5080
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5081
#else
5082
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5083
#endif
5084
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5085
5086
if (iRawlen != 21) /* check the length */
5087
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5088
5089
#ifdef MNG_SUPPORT_DISPLAY
5090
{
5091
mng_retcode iRetcode;
5092
/* create a CLIP animation object */
5093
iRetcode = mng_create_ani_clip (pData, mng_get_uint16 (pRawdata),
5094
mng_get_uint16 (pRawdata+2),
5095
*(pRawdata+4),
5096
mng_get_int32 (pRawdata+5),
5097
mng_get_int32 (pRawdata+9),
5098
mng_get_int32 (pRawdata+13),
5099
mng_get_int32 (pRawdata+17));
5100
5101
if (!iRetcode) /* process the clipping */
5102
iRetcode = mng_process_display_clip (pData,
5103
mng_get_uint16 (pRawdata),
5104
mng_get_uint16 (pRawdata+2),
5105
*(pRawdata+4),
5106
mng_get_int32 (pRawdata+5),
5107
mng_get_int32 (pRawdata+9),
5108
mng_get_int32 (pRawdata+13),
5109
mng_get_int32 (pRawdata+17));
5110
5111
if (iRetcode) /* on error bail out */
5112
return iRetcode;
5113
5114
}
5115
#endif /* MNG_SUPPORT_DISPLAY */
5116
5117
#ifdef MNG_STORE_CHUNKS
5118
if (pData->bStorechunks)
5119
{ /* initialize storage */
5120
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5121
5122
if (iRetcode) /* on error bail out */
5123
return iRetcode;
5124
/* store the fields */
5125
((mng_clipp)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
5126
((mng_clipp)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
5127
((mng_clipp)*ppChunk)->iCliptype = *(pRawdata+4);
5128
((mng_clipp)*ppChunk)->iClipl = mng_get_int32 (pRawdata+5);
5129
((mng_clipp)*ppChunk)->iClipr = mng_get_int32 (pRawdata+9);
5130
((mng_clipp)*ppChunk)->iClipt = mng_get_int32 (pRawdata+13);
5131
((mng_clipp)*ppChunk)->iClipb = mng_get_int32 (pRawdata+17);
5132
}
5133
#endif /* MNG_STORE_CHUNKS */
5134
5135
#ifdef MNG_SUPPORT_TRACE
5136
MNG_TRACE (pData, MNG_FN_READ_CLIP, MNG_LC_END);
5137
#endif
5138
5139
return MNG_NOERROR; /* done */
5140
}
5141
#endif
5142
#endif
5143
5144
/* ************************************************************************** */
5145
5146
#ifndef MNG_OPTIMIZE_CHUNKREADER
5147
#ifndef MNG_SKIPCHUNK_SHOW
5148
READ_CHUNK (mng_read_show)
5149
{
5150
#ifdef MNG_SUPPORT_TRACE
5151
MNG_TRACE (pData, MNG_FN_READ_SHOW, MNG_LC_START);
5152
#endif
5153
5154
if (!pData->bHasMHDR) /* sequence checks */
5155
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5156
5157
#ifdef MNG_INCLUDE_JNG
5158
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5159
#else
5160
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5161
#endif
5162
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5163
/* check the length */
5164
if ((iRawlen != 0) && (iRawlen != 2) && (iRawlen != 4) && (iRawlen != 5))
5165
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5166
5167
#ifdef MNG_SUPPORT_DISPLAY
5168
{
5169
mng_retcode iRetcode;
5170
5171
if (iRawlen) /* determine parameters if any */
5172
{
5173
pData->iSHOWfromid = mng_get_uint16 (pRawdata);
5174
5175
if (iRawlen > 2)
5176
pData->iSHOWtoid = mng_get_uint16 (pRawdata+2);
5177
else
5178
pData->iSHOWtoid = pData->iSHOWfromid;
5179
5180
if (iRawlen > 4)
5181
pData->iSHOWmode = *(pRawdata+4);
5182
else
5183
pData->iSHOWmode = 0;
5184
}
5185
else /* use defaults then */
5186
{
5187
pData->iSHOWmode = 2;
5188
pData->iSHOWfromid = 1;
5189
pData->iSHOWtoid = 65535;
5190
}
5191
/* create a SHOW animation object */
5192
iRetcode = mng_create_ani_show (pData, pData->iSHOWfromid,
5193
pData->iSHOWtoid, pData->iSHOWmode);
5194
5195
if (!iRetcode) /* go and do it! */
5196
iRetcode = mng_process_display_show (pData);
5197
5198
if (iRetcode) /* on error bail out */
5199
return iRetcode;
5200
5201
}
5202
#endif /* MNG_SUPPORT_DISPLAY */
5203
5204
#ifdef MNG_STORE_CHUNKS
5205
if (pData->bStorechunks)
5206
{ /* initialize storage */
5207
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5208
5209
if (iRetcode) /* on error bail out */
5210
return iRetcode;
5211
/* store the fields */
5212
((mng_showp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
5213
5214
if (iRawlen)
5215
{
5216
((mng_showp)*ppChunk)->iFirstid = mng_get_uint16 (pRawdata);
5217
5218
if (iRawlen > 2)
5219
((mng_showp)*ppChunk)->iLastid = mng_get_uint16 (pRawdata+2);
5220
else
5221
((mng_showp)*ppChunk)->iLastid = ((mng_showp)*ppChunk)->iFirstid;
5222
5223
if (iRawlen > 4)
5224
((mng_showp)*ppChunk)->iMode = *(pRawdata+4);
5225
}
5226
}
5227
#endif /* MNG_STORE_CHUNKS */
5228
5229
#ifdef MNG_SUPPORT_TRACE
5230
MNG_TRACE (pData, MNG_FN_READ_SHOW, MNG_LC_END);
5231
#endif
5232
5233
return MNG_NOERROR; /* done */
5234
}
5235
#endif
5236
#endif
5237
5238
/* ************************************************************************** */
5239
5240
#ifndef MNG_OPTIMIZE_CHUNKREADER
5241
#ifndef MNG_SKIPCHUNK_TERM
5242
READ_CHUNK (mng_read_term)
5243
{
5244
mng_uint8 iTermaction;
5245
mng_uint8 iIteraction = 0;
5246
mng_uint32 iDelay = 0;
5247
mng_uint32 iItermax = 0;
5248
5249
#ifdef MNG_SUPPORT_TRACE
5250
MNG_TRACE (pData, MNG_FN_READ_TERM, MNG_LC_START);
5251
#endif
5252
5253
if (!pData->bHasMHDR) /* sequence checks */
5254
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5255
5256
#ifdef MNG_INCLUDE_JNG
5257
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5258
#else
5259
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5260
#endif
5261
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5262
5263
/* should be behind MHDR or SAVE !! */
5264
if ((!pData->bHasSAVE) && (pData->iChunkseq > 2))
5265
{
5266
pData->bMisplacedTERM = MNG_TRUE; /* indicate we found a misplaced TERM */
5267
/* and send a warning signal!!! */
5268
MNG_WARNING (pData, MNG_SEQUENCEERROR);
5269
}
5270
5271
if (pData->bHasLOOP) /* no way, jose! */
5272
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5273
5274
if (pData->bHasTERM) /* only 1 allowed! */
5275
MNG_ERROR (pData, MNG_MULTIPLEERROR);
5276
/* check the length */
5277
if ((iRawlen != 1) && (iRawlen != 10))
5278
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5279
5280
pData->bHasTERM = MNG_TRUE;
5281
5282
iTermaction = *pRawdata; /* get the fields */
5283
5284
if (iRawlen > 1)
5285
{
5286
iIteraction = *(pRawdata+1);
5287
iDelay = mng_get_uint32 (pRawdata+2);
5288
iItermax = mng_get_uint32 (pRawdata+6);
5289
}
5290
5291
if (pData->fProcessterm) /* inform the app ? */
5292
if (!pData->fProcessterm (((mng_handle)pData), iTermaction, iIteraction,
5293
iDelay, iItermax))
5294
MNG_ERROR (pData, MNG_APPMISCERROR);
5295
5296
#ifdef MNG_SUPPORT_DISPLAY
5297
{ /* create the TERM ani-object */
5298
mng_retcode iRetcode = mng_create_ani_term (pData, iTermaction, iIteraction,
5299
iDelay, iItermax);
5300
5301
if (iRetcode) /* on error bail out */
5302
return iRetcode;
5303
/* save for future reference */
5304
pData->pTermaniobj = pData->pLastaniobj;
5305
}
5306
#endif /* MNG_SUPPORT_DISPLAY */
5307
5308
#ifdef MNG_STORE_CHUNKS
5309
if (pData->bStorechunks)
5310
{ /* initialize storage */
5311
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5312
5313
if (iRetcode) /* on error bail out */
5314
return iRetcode;
5315
/* store the fields */
5316
((mng_termp)*ppChunk)->iTermaction = iTermaction;
5317
((mng_termp)*ppChunk)->iIteraction = iIteraction;
5318
((mng_termp)*ppChunk)->iDelay = iDelay;
5319
((mng_termp)*ppChunk)->iItermax = iItermax;
5320
}
5321
#endif /* MNG_STORE_CHUNKS */
5322
5323
#ifdef MNG_SUPPORT_TRACE
5324
MNG_TRACE (pData, MNG_FN_READ_TERM, MNG_LC_END);
5325
#endif
5326
5327
return MNG_NOERROR; /* done */
5328
}
5329
#endif
5330
#endif
5331
5332
/* ************************************************************************** */
5333
5334
#ifndef MNG_OPTIMIZE_CHUNKREADER
5335
#ifndef MNG_SKIPCHUNK_SAVE
5336
READ_CHUNK (mng_read_save)
5337
{
5338
#ifdef MNG_SUPPORT_TRACE
5339
MNG_TRACE (pData, MNG_FN_READ_SAVE, MNG_LC_START);
5340
#endif
5341
/* sequence checks */
5342
if ((!pData->bHasMHDR) || (pData->bHasSAVE))
5343
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5344
5345
#ifdef MNG_INCLUDE_JNG
5346
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5347
#else
5348
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5349
#endif
5350
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5351
5352
pData->bHasSAVE = MNG_TRUE;
5353
5354
if (pData->fProcesssave) /* inform the application ? */
5355
{
5356
mng_bool bOke = pData->fProcesssave ((mng_handle)pData);
5357
5358
if (!bOke)
5359
MNG_ERROR (pData, MNG_APPMISCERROR);
5360
}
5361
5362
#ifdef MNG_SUPPORT_DISPLAY
5363
{
5364
mng_retcode iRetcode;
5365
5366
5367
/* TODO: something with the parameters */
5368
5369
5370
/* create a SAVE animation object */
5371
iRetcode = mng_create_ani_save (pData);
5372
5373
if (!iRetcode) /* process it */
5374
iRetcode = mng_process_display_save (pData);
5375
5376
if (iRetcode) /* on error bail out */
5377
return iRetcode;
5378
5379
}
5380
#endif /* MNG_SUPPORT_DISPLAY */
5381
5382
#ifdef MNG_STORE_CHUNKS
5383
if (pData->bStorechunks)
5384
{ /* initialize storage */
5385
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5386
5387
if (iRetcode) /* on error bail out */
5388
return iRetcode;
5389
/* store the fields */
5390
((mng_savep)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
5391
5392
if (iRawlen) /* not empty ? */
5393
{
5394
mng_uint8 iOtype = *pRawdata;
5395
mng_uint8 iEtype;
5396
mng_uint32 iCount = 0;
5397
mng_uint8p pTemp;
5398
mng_uint8p pNull;
5399
mng_uint32 iLen;
5400
mng_uint32 iOffset[2];
5401
mng_uint32 iStarttime[2];
5402
mng_uint32 iFramenr;
5403
mng_uint32 iLayernr;
5404
mng_uint32 iX;
5405
mng_save_entryp pEntry = MNG_NULL;
5406
mng_uint32 iNamesize;
5407
5408
if ((iOtype != 4) && (iOtype != 8))
5409
MNG_ERROR (pData, MNG_INVOFFSETSIZE);
5410
5411
((mng_savep)*ppChunk)->iOffsettype = iOtype;
5412
5413
for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */
5414
{
5415
pTemp = pRawdata + 1;
5416
iLen = iRawlen - 1;
5417
5418
if (iX) /* second run ? */
5419
{
5420
MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_save_entry)));
5421
5422
((mng_savep)*ppChunk)->iCount = iCount;
5423
((mng_savep)*ppChunk)->pEntries = pEntry;
5424
}
5425
5426
while (iLen) /* anything left ? */
5427
{
5428
iEtype = *pTemp; /* entrytype */
5429
5430
if ((iEtype != 0) && (iEtype != 1) && (iEtype != 2) && (iEtype != 3))
5431
MNG_ERROR (pData, MNG_INVENTRYTYPE);
5432
5433
pTemp++;
5434
5435
if (iEtype > 1)
5436
{
5437
iOffset [0] = 0;
5438
iOffset [1] = 0;
5439
iStarttime [0] = 0;
5440
iStarttime [1] = 0;
5441
iLayernr = 0;
5442
iFramenr = 0;
5443
}
5444
else
5445
{
5446
if (iOtype == 4)
5447
{
5448
iOffset [0] = 0;
5449
iOffset [1] = mng_get_uint32 (pTemp);
5450
5451
pTemp += 4;
5452
}
5453
else
5454
{
5455
iOffset [0] = mng_get_uint32 (pTemp);
5456
iOffset [1] = mng_get_uint32 (pTemp+4);
5457
5458
pTemp += 8;
5459
}
5460
5461
if (iEtype > 0)
5462
{
5463
iStarttime [0] = 0;
5464
iStarttime [1] = 0;
5465
iLayernr = 0;
5466
iFramenr = 0;
5467
}
5468
else
5469
{
5470
if (iOtype == 4)
5471
{
5472
iStarttime [0] = 0;
5473
iStarttime [1] = mng_get_uint32 (pTemp+0);
5474
iLayernr = mng_get_uint32 (pTemp+4);
5475
iFramenr = mng_get_uint32 (pTemp+8);
5476
5477
pTemp += 12;
5478
}
5479
else
5480
{
5481
iStarttime [0] = mng_get_uint32 (pTemp+0);
5482
iStarttime [1] = mng_get_uint32 (pTemp+4);
5483
iLayernr = mng_get_uint32 (pTemp+8);
5484
iFramenr = mng_get_uint32 (pTemp+12);
5485
5486
pTemp += 16;
5487
}
5488
}
5489
}
5490
5491
pNull = find_null (pTemp); /* get the name length */
5492
5493
if ((pNull - pRawdata) > (mng_int32)iRawlen)
5494
{
5495
iNamesize = iLen; /* no null found; so end of SAVE */
5496
iLen = 0;
5497
}
5498
else
5499
{
5500
iNamesize = pNull - pTemp; /* should be another entry */
5501
iLen -= iNamesize;
5502
5503
if (!iLen) /* must not end with a null ! */
5504
MNG_ERROR (pData, MNG_ENDWITHNULL);
5505
}
5506
5507
if (!pEntry)
5508
{
5509
iCount++;
5510
}
5511
else
5512
{
5513
pEntry->iEntrytype = iEtype;
5514
pEntry->iOffset [0] = iOffset [0];
5515
pEntry->iOffset [1] = iOffset [1];
5516
pEntry->iStarttime [0] = iStarttime [0];
5517
pEntry->iStarttime [1] = iStarttime [1];
5518
pEntry->iLayernr = iLayernr;
5519
pEntry->iFramenr = iFramenr;
5520
pEntry->iNamesize = iNamesize;
5521
5522
if (iNamesize)
5523
{
5524
MNG_ALLOC (pData, pEntry->zName, iNamesize+1);
5525
MNG_COPY (pEntry->zName, pTemp, iNamesize);
5526
}
5527
5528
pEntry++;
5529
}
5530
5531
pTemp += iNamesize;
5532
}
5533
}
5534
}
5535
}
5536
#endif /* MNG_STORE_CHUNKS */
5537
5538
#ifdef MNG_SUPPORT_TRACE
5539
MNG_TRACE (pData, MNG_FN_READ_SAVE, MNG_LC_END);
5540
#endif
5541
5542
return MNG_NOERROR; /* done */
5543
}
5544
#endif
5545
#endif
5546
5547
/* ************************************************************************** */
5548
5549
#ifndef MNG_OPTIMIZE_CHUNKREADER
5550
#ifndef MNG_SKIPCHUNK_SEEK
5551
READ_CHUNK (mng_read_seek)
5552
{
5553
mng_retcode iRetcode;
5554
5555
#ifdef MNG_SUPPORT_TRACE
5556
MNG_TRACE (pData, MNG_FN_READ_SEEK, MNG_LC_START);
5557
#endif
5558
/* sequence checks */
5559
if ((!pData->bHasMHDR) || (!pData->bHasSAVE))
5560
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5561
5562
#ifdef MNG_INCLUDE_JNG
5563
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5564
#else
5565
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5566
#endif
5567
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5568
5569
#ifdef MNG_SUPPORT_DISPLAY
5570
/* create a SEEK animation object */
5571
iRetcode = mng_create_ani_seek (pData, iRawlen, (mng_pchar)pRawdata);
5572
5573
if (iRetcode) /* on error bail out */
5574
return iRetcode;
5575
5576
#endif /* MNG_SUPPORT_DISPLAY */
5577
5578
if (pData->fProcessseek) /* inform the app ? */
5579
{
5580
mng_bool bOke;
5581
mng_pchar zName;
5582
5583
MNG_ALLOC (pData, zName, iRawlen + 1);
5584
5585
if (iRawlen)
5586
MNG_COPY (zName, pRawdata, iRawlen);
5587
5588
bOke = pData->fProcessseek ((mng_handle)pData, zName);
5589
5590
MNG_FREEX (pData, zName, iRawlen + 1);
5591
5592
if (!bOke)
5593
MNG_ERROR (pData, MNG_APPMISCERROR);
5594
}
5595
5596
#ifdef MNG_SUPPORT_DISPLAY
5597
/* do display processing of the SEEK */
5598
iRetcode = mng_process_display_seek (pData);
5599
5600
if (iRetcode) /* on error bail out */
5601
return iRetcode;
5602
#endif /* MNG_SUPPORT_DISPLAY */
5603
5604
#ifdef MNG_STORE_CHUNKS
5605
if (pData->bStorechunks)
5606
{ /* initialize storage */
5607
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5608
5609
if (iRetcode) /* on error bail out */
5610
return iRetcode;
5611
/* store the fields */
5612
((mng_seekp)*ppChunk)->iNamesize = iRawlen;
5613
5614
if (iRawlen)
5615
{
5616
MNG_ALLOC (pData, ((mng_seekp)*ppChunk)->zName, iRawlen+1);
5617
MNG_COPY (((mng_seekp)*ppChunk)->zName, pRawdata, iRawlen);
5618
}
5619
}
5620
#endif /* MNG_STORE_CHUNKS */
5621
5622
#ifdef MNG_SUPPORT_TRACE
5623
MNG_TRACE (pData, MNG_FN_READ_SEEK, MNG_LC_END);
5624
#endif
5625
5626
return MNG_NOERROR; /* done */
5627
}
5628
#endif
5629
#endif
5630
5631
/* ************************************************************************** */
5632
5633
#ifndef MNG_OPTIMIZE_CHUNKREADER
5634
#ifndef MNG_SKIPCHUNK_eXPI
5635
READ_CHUNK (mng_read_expi)
5636
{
5637
#ifdef MNG_SUPPORT_TRACE
5638
MNG_TRACE (pData, MNG_FN_READ_EXPI, MNG_LC_START);
5639
#endif
5640
5641
if (!pData->bHasMHDR) /* sequence checks */
5642
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5643
5644
#ifdef MNG_INCLUDE_JNG
5645
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5646
#else
5647
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5648
#endif
5649
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5650
5651
if (iRawlen < 3) /* check the length */
5652
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5653
5654
#ifdef MNG_SUPPORT_DISPLAY
5655
{
5656
5657
5658
/* TODO: something !!! */
5659
5660
5661
}
5662
#endif /* MNG_SUPPORT_DISPLAY */
5663
5664
#ifdef MNG_STORE_CHUNKS
5665
if (pData->bStorechunks)
5666
{ /* initialize storage */
5667
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5668
5669
if (iRetcode) /* on error bail out */
5670
return iRetcode;
5671
/* store the fields */
5672
((mng_expip)*ppChunk)->iSnapshotid = mng_get_uint16 (pRawdata);
5673
((mng_expip)*ppChunk)->iNamesize = iRawlen - 2;
5674
5675
if (((mng_expip)*ppChunk)->iNamesize)
5676
{
5677
MNG_ALLOC (pData, ((mng_expip)*ppChunk)->zName,
5678
((mng_expip)*ppChunk)->iNamesize + 1);
5679
MNG_COPY (((mng_expip)*ppChunk)->zName, pRawdata+2,
5680
((mng_expip)*ppChunk)->iNamesize);
5681
}
5682
}
5683
#endif /* MNG_STORE_CHUNKS */
5684
5685
#ifdef MNG_SUPPORT_TRACE
5686
MNG_TRACE (pData, MNG_FN_READ_EXPI, MNG_LC_END);
5687
#endif
5688
5689
return MNG_NOERROR; /* done */
5690
}
5691
#endif
5692
#endif
5693
5694
/* ************************************************************************** */
5695
5696
#ifndef MNG_OPTIMIZE_CHUNKREADER
5697
#ifndef MNG_SKIPCHUNK_fPRI
5698
READ_CHUNK (mng_read_fpri)
5699
{
5700
#ifdef MNG_SUPPORT_TRACE
5701
MNG_TRACE (pData, MNG_FN_READ_FPRI, MNG_LC_START);
5702
#endif
5703
5704
if (!pData->bHasMHDR) /* sequence checks */
5705
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5706
5707
#ifdef MNG_INCLUDE_JNG
5708
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5709
#else
5710
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5711
#endif
5712
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5713
5714
if (iRawlen != 2) /* must be two bytes long */
5715
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5716
5717
#ifdef MNG_SUPPORT_DISPLAY
5718
{
5719
5720
5721
/* TODO: something !!! */
5722
5723
5724
}
5725
#endif /* MNG_SUPPORT_DISPLAY */
5726
5727
#ifdef MNG_STORE_CHUNKS
5728
if (pData->bStorechunks)
5729
{ /* initialize storage */
5730
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5731
5732
if (iRetcode) /* on error bail out */
5733
return iRetcode;
5734
/* store the fields */
5735
((mng_fprip)*ppChunk)->iDeltatype = *pRawdata;
5736
((mng_fprip)*ppChunk)->iPriority = *(pRawdata+1);
5737
}
5738
#endif /* MNG_STORE_CHUNKS */
5739
5740
#ifdef MNG_SUPPORT_TRACE
5741
MNG_TRACE (pData, MNG_FN_READ_FPRI, MNG_LC_END);
5742
#endif
5743
5744
return MNG_NOERROR; /* done */
5745
}
5746
#endif
5747
#endif
5748
5749
/* ************************************************************************** */
5750
5751
#ifndef MNG_OPTIMIZE_CHUNKREADER
5752
#ifndef MNG_SKIPCHUNK_nEED
5753
MNG_LOCAL mng_bool CheckKeyword (mng_datap pData,
5754
mng_uint8p pKeyword)
5755
{
5756
mng_chunkid handled_chunks [] =
5757
{
5758
MNG_UINT_BACK, /* keep it sorted !!!! */
5759
MNG_UINT_BASI,
5760
MNG_UINT_CLIP,
5761
MNG_UINT_CLON,
5762
#ifndef MNG_NO_DELTA_PNG
5763
/* TODO: MNG_UINT_DBYK, */
5764
#endif
5765
MNG_UINT_DEFI,
5766
#ifndef MNG_NO_DELTA_PNG
5767
MNG_UINT_DHDR,
5768
#endif
5769
MNG_UINT_DISC,
5770
#ifndef MNG_NO_DELTA_PNG
5771
/* TODO: MNG_UINT_DROP, */
5772
#endif
5773
MNG_UINT_ENDL,
5774
MNG_UINT_FRAM,
5775
MNG_UINT_IDAT,
5776
MNG_UINT_IEND,
5777
MNG_UINT_IHDR,
5778
#ifndef MNG_NO_DELTA_PNG
5779
#ifdef MNG_INCLUDE_JNG
5780
MNG_UINT_IJNG,
5781
#endif
5782
MNG_UINT_IPNG,
5783
#endif
5784
#ifdef MNG_INCLUDE_JNG
5785
MNG_UINT_JDAA,
5786
MNG_UINT_JDAT,
5787
MNG_UINT_JHDR,
5788
/* TODO: MNG_UINT_JSEP, */
5789
MNG_UINT_JdAA,
5790
#endif
5791
MNG_UINT_LOOP,
5792
MNG_UINT_MAGN,
5793
MNG_UINT_MEND,
5794
MNG_UINT_MHDR,
5795
MNG_UINT_MOVE,
5796
/* TODO: MNG_UINT_ORDR, */
5797
MNG_UINT_PAST,
5798
MNG_UINT_PLTE,
5799
#ifndef MNG_NO_DELTA_PNG
5800
MNG_UINT_PPLT,
5801
MNG_UINT_PROM,
5802
#endif
5803
MNG_UINT_SAVE,
5804
MNG_UINT_SEEK,
5805
MNG_UINT_SHOW,
5806
MNG_UINT_TERM,
5807
MNG_UINT_bKGD,
5808
MNG_UINT_cHRM,
5809
/* TODO: MNG_UINT_eXPI, */
5810
MNG_UINT_evNT,
5811
/* TODO: MNG_UINT_fPRI, */
5812
MNG_UINT_gAMA,
5813
/* TODO: MNG_UINT_hIST, */
5814
MNG_UINT_iCCP,
5815
MNG_UINT_iTXt,
5816
MNG_UINT_nEED,
5817
/* TODO: MNG_UINT_oFFs, */
5818
/* TODO: MNG_UINT_pCAL, */
5819
/* TODO: MNG_UINT_pHYg, */
5820
/* TODO: MNG_UINT_pHYs, */
5821
/* TODO: MNG_UINT_sBIT, */
5822
/* TODO: MNG_UINT_sCAL, */
5823
/* TODO: MNG_UINT_sPLT, */
5824
MNG_UINT_sRGB,
5825
MNG_UINT_tEXt,
5826
MNG_UINT_tIME,
5827
MNG_UINT_tRNS,
5828
MNG_UINT_zTXt,
5829
};
5830
5831
mng_bool bOke = MNG_FALSE;
5832
5833
if (pData->fProcessneed) /* does the app handle it ? */
5834
bOke = pData->fProcessneed ((mng_handle)pData, (mng_pchar)pKeyword);
5835
5836
if (!bOke)
5837
{ /* find the keyword length */
5838
mng_uint8p pNull = find_null (pKeyword);
5839
5840
if (pNull - pKeyword == 4) /* test a chunk ? */
5841
{ /* get the chunk-id */
5842
mng_chunkid iChunkid = (*pKeyword << 24) + (*(pKeyword+1) << 16) +
5843
(*(pKeyword+2) << 8) + (*(pKeyword+3) );
5844
/* binary search variables */
5845
mng_int32 iTop, iLower, iUpper, iMiddle;
5846
/* determine max index of table */
5847
iTop = (sizeof (handled_chunks) / sizeof (handled_chunks [0])) - 1;
5848
5849
/* binary search; with 52 chunks, worst-case is 7 comparisons */
5850
iLower = 0;
5851
iMiddle = iTop >> 1;
5852
iUpper = iTop;
5853
5854
do /* the binary search itself */
5855
{
5856
if (handled_chunks [iMiddle] < iChunkid)
5857
iLower = iMiddle + 1;
5858
else if (handled_chunks [iMiddle] > iChunkid)
5859
iUpper = iMiddle - 1;
5860
else
5861
{
5862
bOke = MNG_TRUE;
5863
break;
5864
}
5865
5866
iMiddle = (iLower + iUpper) >> 1;
5867
}
5868
while (iLower <= iUpper);
5869
}
5870
/* test draft ? */
5871
if ((!bOke) && (pNull - pKeyword == 8) &&
5872
(*pKeyword == 'd') && (*(pKeyword+1) == 'r') &&
5873
(*(pKeyword+2) == 'a') && (*(pKeyword+3) == 'f') &&
5874
(*(pKeyword+4) == 't') && (*(pKeyword+5) == ' '))
5875
{
5876
mng_uint32 iDraft;
5877
5878
iDraft = (*(pKeyword+6) - '0') * 10 + (*(pKeyword+7) - '0');
5879
bOke = (mng_bool)(iDraft <= MNG_MNG_DRAFT);
5880
}
5881
/* test MNG 1.0/1.1 ? */
5882
if ((!bOke) && (pNull - pKeyword == 7) &&
5883
(*pKeyword == 'M') && (*(pKeyword+1) == 'N') &&
5884
(*(pKeyword+2) == 'G') && (*(pKeyword+3) == '-') &&
5885
(*(pKeyword+4) == '1') && (*(pKeyword+5) == '.') &&
5886
((*(pKeyword+6) == '0') || (*(pKeyword+6) == '1')))
5887
bOke = MNG_TRUE;
5888
/* test CACHEOFF ? */
5889
if ((!bOke) && (pNull - pKeyword == 8) &&
5890
(*pKeyword == 'C') && (*(pKeyword+1) == 'A') &&
5891
(*(pKeyword+2) == 'C') && (*(pKeyword+3) == 'H') &&
5892
(*(pKeyword+4) == 'E') && (*(pKeyword+5) == 'O') &&
5893
(*(pKeyword+6) == 'F') && (*(pKeyword+7) == 'F'))
5894
{
5895
if (!pData->pFirstaniobj) /* only if caching hasn't started yet ! */
5896
{
5897
bOke = MNG_TRUE;
5898
pData->bCacheplayback = MNG_FALSE;
5899
pData->bStorechunks = MNG_FALSE;
5900
}
5901
}
5902
}
5903
5904
return bOke;
5905
}
5906
#endif
5907
#endif
5908
5909
/* ************************************************************************** */
5910
5911
#ifndef MNG_OPTIMIZE_CHUNKREADER
5912
#ifndef MNG_SKIPCHUNK_nEED
5913
READ_CHUNK (mng_read_need)
5914
{
5915
#ifdef MNG_SUPPORT_TRACE
5916
MNG_TRACE (pData, MNG_FN_READ_NEED, MNG_LC_START);
5917
#endif
5918
5919
if (!pData->bHasMHDR) /* sequence checks */
5920
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5921
5922
#ifdef MNG_INCLUDE_JNG
5923
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
5924
#else
5925
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
5926
#endif
5927
MNG_ERROR (pData, MNG_SEQUENCEERROR);
5928
5929
if (iRawlen < 1) /* check the length */
5930
MNG_ERROR (pData, MNG_INVALIDLENGTH);
5931
5932
{ /* let's check it */
5933
mng_bool bOke = MNG_TRUE;
5934
mng_pchar zKeywords;
5935
mng_uint8p pNull, pTemp;
5936
5937
MNG_ALLOC (pData, zKeywords, iRawlen + 1);
5938
5939
if (iRawlen)
5940
MNG_COPY (zKeywords, pRawdata, iRawlen);
5941
5942
pTemp = (mng_uint8p)zKeywords;
5943
pNull = find_null (pTemp);
5944
5945
while ((bOke) && (pNull < (mng_uint8p)zKeywords + iRawlen))
5946
{
5947
bOke = CheckKeyword (pData, pTemp);
5948
pTemp = pNull + 1;
5949
pNull = find_null (pTemp);
5950
}
5951
5952
if (bOke)
5953
bOke = CheckKeyword (pData, pTemp);
5954
5955
MNG_FREEX (pData, zKeywords, iRawlen + 1);
5956
5957
if (!bOke)
5958
MNG_ERROR (pData, MNG_UNSUPPORTEDNEED);
5959
}
5960
5961
#ifdef MNG_STORE_CHUNKS
5962
if (pData->bStorechunks)
5963
{ /* initialize storage */
5964
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
5965
5966
if (iRetcode) /* on error bail out */
5967
return iRetcode;
5968
/* store the fields */
5969
((mng_needp)*ppChunk)->iKeywordssize = iRawlen;
5970
5971
if (iRawlen)
5972
{
5973
MNG_ALLOC (pData, ((mng_needp)*ppChunk)->zKeywords, iRawlen+1);
5974
MNG_COPY (((mng_needp)*ppChunk)->zKeywords, pRawdata, iRawlen);
5975
}
5976
}
5977
#endif /* MNG_STORE_CHUNKS */
5978
5979
#ifdef MNG_SUPPORT_TRACE
5980
MNG_TRACE (pData, MNG_FN_READ_NEED, MNG_LC_END);
5981
#endif
5982
5983
return MNG_NOERROR; /* done */
5984
}
5985
#endif
5986
#endif
5987
5988
/* ************************************************************************** */
5989
5990
#ifndef MNG_OPTIMIZE_CHUNKREADER
5991
#ifndef MNG_SKIPCHUNK_pHYg
5992
READ_CHUNK (mng_read_phyg)
5993
{
5994
#ifdef MNG_SUPPORT_TRACE
5995
MNG_TRACE (pData, MNG_FN_READ_PHYG, MNG_LC_START);
5996
#endif
5997
5998
if (!pData->bHasMHDR) /* sequence checks */
5999
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6000
6001
#ifdef MNG_INCLUDE_JNG
6002
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
6003
#else
6004
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
6005
#endif
6006
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6007
/* it's 9 bytes or empty; no more, no less! */
6008
if ((iRawlen != 9) && (iRawlen != 0))
6009
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6010
6011
#ifdef MNG_SUPPORT_DISPLAY
6012
{
6013
6014
6015
/* TODO: something !!! */
6016
6017
6018
}
6019
#endif /* MNG_SUPPORT_DISPLAY */
6020
6021
#ifdef MNG_STORE_CHUNKS
6022
if (pData->bStorechunks)
6023
{ /* initialize storage */
6024
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6025
6026
if (iRetcode) /* on error bail out */
6027
return iRetcode;
6028
/* store the fields */
6029
((mng_phygp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
6030
6031
if (iRawlen)
6032
{
6033
((mng_phygp)*ppChunk)->iSizex = mng_get_uint32 (pRawdata);
6034
((mng_phygp)*ppChunk)->iSizey = mng_get_uint32 (pRawdata+4);
6035
((mng_phygp)*ppChunk)->iUnit = *(pRawdata+8);
6036
}
6037
}
6038
#endif /* MNG_STORE_CHUNKS */
6039
6040
#ifdef MNG_SUPPORT_TRACE
6041
MNG_TRACE (pData, MNG_FN_READ_PHYG, MNG_LC_END);
6042
#endif
6043
6044
return MNG_NOERROR; /* done */
6045
}
6046
#endif
6047
#endif
6048
6049
/* ************************************************************************** */
6050
6051
#ifndef MNG_OPTIMIZE_CHUNKREADER
6052
#ifdef MNG_INCLUDE_JNG
6053
READ_CHUNK (mng_read_jhdr)
6054
{
6055
#ifdef MNG_SUPPORT_TRACE
6056
MNG_TRACE (pData, MNG_FN_READ_JHDR, MNG_LC_START);
6057
#endif
6058
/* sequence checks */
6059
if ((pData->eSigtype != mng_it_jng) && (pData->eSigtype != mng_it_mng))
6060
MNG_ERROR (pData, MNG_CHUNKNOTALLOWED);
6061
6062
if ((pData->eSigtype == mng_it_jng) && (pData->iChunkseq > 1))
6063
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6064
6065
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
6066
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6067
6068
if (iRawlen != 16) /* length oke ? */
6069
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6070
/* inside a JHDR-IEND block now */
6071
pData->bHasJHDR = MNG_TRUE;
6072
/* and store interesting fields */
6073
pData->iDatawidth = mng_get_uint32 (pRawdata);
6074
pData->iDataheight = mng_get_uint32 (pRawdata+4);
6075
pData->iJHDRcolortype = *(pRawdata+8);
6076
pData->iJHDRimgbitdepth = *(pRawdata+9);
6077
pData->iJHDRimgcompression = *(pRawdata+10);
6078
pData->iJHDRimginterlace = *(pRawdata+11);
6079
pData->iJHDRalphabitdepth = *(pRawdata+12);
6080
pData->iJHDRalphacompression = *(pRawdata+13);
6081
pData->iJHDRalphafilter = *(pRawdata+14);
6082
pData->iJHDRalphainterlace = *(pRawdata+15);
6083
6084
6085
#if defined(MNG_NO_1_2_4BIT_SUPPORT) || defined(MNG_NO_16BIT_SUPPORT)
6086
pData->iPNGmult = 1;
6087
pData->iPNGdepth = pData->iJHDRalphabitdepth;
6088
#endif
6089
6090
#ifdef MNG_NO_1_2_4BIT_SUPPORT
6091
if (pData->iJHDRalphabitdepth < 8)
6092
pData->iJHDRalphabitdepth = 8;
6093
#endif
6094
6095
#ifdef MNG_NO_16BIT_SUPPORT
6096
if (pData->iJHDRalphabitdepth > 8)
6097
{
6098
pData->iPNGmult = 2;
6099
pData->iJHDRalphabitdepth = 8;
6100
}
6101
#endif
6102
/* parameter validity checks */
6103
if ((pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAY ) &&
6104
(pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLOR ) &&
6105
(pData->iJHDRcolortype != MNG_COLORTYPE_JPEGGRAYA ) &&
6106
(pData->iJHDRcolortype != MNG_COLORTYPE_JPEGCOLORA) )
6107
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
6108
6109
if ((pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8 ) &&
6110
(pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG12 ) &&
6111
(pData->iJHDRimgbitdepth != MNG_BITDEPTH_JPEG8AND12) )
6112
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
6113
6114
if (pData->iJHDRimgcompression != MNG_COMPRESSION_BASELINEJPEG)
6115
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
6116
6117
if ((pData->iJHDRimginterlace != MNG_INTERLACE_SEQUENTIAL ) &&
6118
(pData->iJHDRimginterlace != MNG_INTERLACE_PROGRESSIVE) )
6119
MNG_ERROR (pData, MNG_INVALIDINTERLACE);
6120
6121
if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
6122
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) )
6123
{
6124
if ((pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 )
6125
#ifndef MNG_NO_1_2_4BIT_SUPPORT
6126
&& (pData->iJHDRalphabitdepth != MNG_BITDEPTH_1 ) &&
6127
(pData->iJHDRalphabitdepth != MNG_BITDEPTH_2 ) &&
6128
(pData->iJHDRalphabitdepth != MNG_BITDEPTH_4 )
6129
#endif
6130
#ifndef MNG_NO_16BIT_SUPPORT
6131
&& (pData->iJHDRalphabitdepth != MNG_BITDEPTH_16)
6132
#endif
6133
)
6134
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
6135
6136
if ((pData->iJHDRalphacompression != MNG_COMPRESSION_DEFLATE ) &&
6137
(pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG) )
6138
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
6139
6140
if ((pData->iJHDRalphacompression == MNG_COMPRESSION_BASELINEJPEG) &&
6141
(pData->iJHDRalphabitdepth != MNG_BITDEPTH_8 ) )
6142
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
6143
6144
#if defined(FILTER192) || defined(FILTER193)
6145
if ((pData->iJHDRalphafilter != MNG_FILTER_ADAPTIVE ) &&
6146
#if defined(FILTER192) && defined(FILTER193)
6147
(pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) &&
6148
(pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) )
6149
#else
6150
#ifdef FILTER192
6151
(pData->iJHDRalphafilter != MNG_FILTER_DIFFERING) )
6152
#else
6153
(pData->iJHDRalphafilter != MNG_FILTER_NOFILTER ) )
6154
#endif
6155
#endif
6156
MNG_ERROR (pData, MNG_INVALIDFILTER);
6157
#else
6158
if (pData->iJHDRalphafilter)
6159
MNG_ERROR (pData, MNG_INVALIDFILTER);
6160
#endif
6161
6162
if ((pData->iJHDRalphainterlace != MNG_INTERLACE_NONE ) &&
6163
(pData->iJHDRalphainterlace != MNG_INTERLACE_ADAM7) )
6164
MNG_ERROR (pData, MNG_INVALIDINTERLACE);
6165
6166
}
6167
else
6168
{
6169
if (pData->iJHDRalphabitdepth)
6170
MNG_ERROR (pData, MNG_INVALIDBITDEPTH);
6171
6172
if (pData->iJHDRalphacompression)
6173
MNG_ERROR (pData, MNG_INVALIDCOMPRESS);
6174
6175
if (pData->iJHDRalphafilter)
6176
MNG_ERROR (pData, MNG_INVALIDFILTER);
6177
6178
if (pData->iJHDRalphainterlace)
6179
MNG_ERROR (pData, MNG_INVALIDINTERLACE);
6180
6181
}
6182
6183
if (!pData->bHasheader) /* first chunk ? */
6184
{
6185
pData->bHasheader = MNG_TRUE; /* we've got a header */
6186
pData->eImagetype = mng_it_jng; /* then this must be a JNG */
6187
pData->iWidth = mng_get_uint32 (pRawdata);
6188
pData->iHeight = mng_get_uint32 (pRawdata+4);
6189
/* predict alpha-depth ! */
6190
if ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
6191
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) )
6192
pData->iAlphadepth = pData->iJHDRalphabitdepth;
6193
else
6194
pData->iAlphadepth = 0;
6195
/* fits on maximum canvas ? */
6196
if ((pData->iWidth > pData->iMaxwidth) || (pData->iHeight > pData->iMaxheight))
6197
MNG_WARNING (pData, MNG_IMAGETOOLARGE);
6198
6199
if (pData->fProcessheader) /* inform the app ? */
6200
if (!pData->fProcessheader (((mng_handle)pData), pData->iWidth, pData->iHeight))
6201
MNG_ERROR (pData, MNG_APPMISCERROR);
6202
6203
}
6204
6205
pData->iColortype = 0; /* fake grayscale for other routines */
6206
pData->iImagelevel++; /* one level deeper */
6207
6208
#ifdef MNG_SUPPORT_DISPLAY
6209
{
6210
mng_retcode iRetcode = mng_process_display_jhdr (pData);
6211
6212
if (iRetcode) /* on error bail out */
6213
return iRetcode;
6214
}
6215
#endif /* MNG_SUPPORT_DISPLAY */
6216
6217
#ifdef MNG_STORE_CHUNKS
6218
if (pData->bStorechunks)
6219
{ /* initialize storage */
6220
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6221
6222
if (iRetcode) /* on error bail out */
6223
return iRetcode;
6224
/* store the fields */
6225
((mng_jhdrp)*ppChunk)->iWidth = mng_get_uint32 (pRawdata);
6226
((mng_jhdrp)*ppChunk)->iHeight = mng_get_uint32 (pRawdata+4);
6227
((mng_jhdrp)*ppChunk)->iColortype = *(pRawdata+8);
6228
((mng_jhdrp)*ppChunk)->iImagesampledepth = *(pRawdata+9);
6229
((mng_jhdrp)*ppChunk)->iImagecompression = *(pRawdata+10);
6230
((mng_jhdrp)*ppChunk)->iImageinterlace = *(pRawdata+11);
6231
((mng_jhdrp)*ppChunk)->iAlphasampledepth = *(pRawdata+12);
6232
#ifdef MNG_NO_16BIT_SUPPORT
6233
if (*(pRawdata+12) > 8)
6234
((mng_jhdrp)*ppChunk)->iAlphasampledepth = 8;
6235
#endif
6236
((mng_jhdrp)*ppChunk)->iAlphacompression = *(pRawdata+13);
6237
((mng_jhdrp)*ppChunk)->iAlphafilter = *(pRawdata+14);
6238
((mng_jhdrp)*ppChunk)->iAlphainterlace = *(pRawdata+15);
6239
}
6240
#endif /* MNG_STORE_CHUNKS */
6241
6242
#ifdef MNG_SUPPORT_TRACE
6243
MNG_TRACE (pData, MNG_FN_READ_JHDR, MNG_LC_END);
6244
#endif
6245
6246
return MNG_NOERROR; /* done */
6247
}
6248
#else
6249
#define read_jhdr 0
6250
#endif /* MNG_INCLUDE_JNG */
6251
#endif
6252
6253
/* ************************************************************************** */
6254
6255
#ifndef MNG_OPTIMIZE_CHUNKREADER
6256
#ifdef MNG_INCLUDE_JNG
6257
READ_CHUNK (mng_read_jdaa)
6258
{
6259
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
6260
volatile mng_retcode iRetcode;
6261
6262
iRetcode=MNG_NOERROR;
6263
#endif
6264
6265
#ifdef MNG_SUPPORT_TRACE
6266
MNG_TRACE (pData, MNG_FN_READ_JDAA, MNG_LC_START);
6267
#endif
6268
/* sequence checks */
6269
if ((!pData->bHasJHDR) && (!pData->bHasDHDR))
6270
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6271
6272
if (pData->bHasJSEP)
6273
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6274
6275
if (pData->iJHDRalphacompression != MNG_COMPRESSION_BASELINEJPEG)
6276
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6277
6278
if (iRawlen == 0) /* can never be empty */
6279
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6280
6281
pData->bHasJDAA = MNG_TRUE; /* got some JDAA now, don't we */
6282
6283
#ifdef MNG_SUPPORT_DISPLAY
6284
iRetcode = mng_process_display_jdaa (pData, iRawlen, pRawdata);
6285
6286
if (iRetcode) /* on error bail out */
6287
return iRetcode;
6288
#endif /* MNG_SUPPORT_DISPLAY */
6289
6290
#ifdef MNG_STORE_CHUNKS
6291
if (pData->bStorechunks)
6292
{ /* initialize storage */
6293
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6294
6295
if (iRetcode) /* on error bail out */
6296
return iRetcode;
6297
/* store the fields */
6298
((mng_jdaap)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
6299
((mng_jdaap)*ppChunk)->iDatasize = iRawlen;
6300
6301
if (iRawlen != 0) /* is there any data ? */
6302
{
6303
MNG_ALLOC (pData, ((mng_jdaap)*ppChunk)->pData, iRawlen);
6304
MNG_COPY (((mng_jdaap)*ppChunk)->pData, pRawdata, iRawlen);
6305
}
6306
}
6307
#endif /* MNG_STORE_CHUNKS */
6308
6309
#ifdef MNG_SUPPORT_TRACE
6310
MNG_TRACE (pData, MNG_FN_READ_JDAA, MNG_LC_END);
6311
#endif
6312
6313
return MNG_NOERROR; /* done */
6314
}
6315
#else
6316
#define read_jdaa 0
6317
#endif /* MNG_INCLUDE_JNG */
6318
#endif
6319
6320
/* ************************************************************************** */
6321
6322
#ifndef MNG_OPTIMIZE_CHUNKREADER
6323
#ifdef MNG_INCLUDE_JNG
6324
READ_CHUNK (mng_read_jdat)
6325
{
6326
#if defined(MNG_SUPPORT_DISPLAY) || defined(MNG_STORE_CHUNKS)
6327
volatile mng_retcode iRetcode;
6328
6329
iRetcode=MNG_NOERROR;
6330
#endif
6331
6332
#ifdef MNG_SUPPORT_TRACE
6333
MNG_TRACE (pData, MNG_FN_READ_JDAT, MNG_LC_START);
6334
#endif
6335
/* sequence checks */
6336
if ((!pData->bHasJHDR) && (!pData->bHasDHDR))
6337
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6338
6339
if (iRawlen == 0) /* can never be empty */
6340
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6341
6342
pData->bHasJDAT = MNG_TRUE; /* got some JDAT now, don't we */
6343
6344
#ifdef MNG_SUPPORT_DISPLAY
6345
iRetcode = mng_process_display_jdat (pData, iRawlen, pRawdata);
6346
6347
if (iRetcode) /* on error bail out */
6348
return iRetcode;
6349
#endif /* MNG_SUPPORT_DISPLAY */
6350
6351
#ifdef MNG_STORE_CHUNKS
6352
if (pData->bStorechunks)
6353
{ /* initialize storage */
6354
iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6355
6356
if (iRetcode) /* on error bail out */
6357
return iRetcode;
6358
/* store the fields */
6359
((mng_jdatp)*ppChunk)->bEmpty = (mng_bool)(iRawlen == 0);
6360
((mng_jdatp)*ppChunk)->iDatasize = iRawlen;
6361
6362
if (iRawlen != 0) /* is there any data ? */
6363
{
6364
MNG_ALLOC (pData, ((mng_jdatp)*ppChunk)->pData, iRawlen);
6365
MNG_COPY (((mng_jdatp)*ppChunk)->pData, pRawdata, iRawlen);
6366
}
6367
}
6368
#endif /* MNG_STORE_CHUNKS */
6369
6370
#ifdef MNG_SUPPORT_TRACE
6371
MNG_TRACE (pData, MNG_FN_READ_JDAT, MNG_LC_END);
6372
#endif
6373
6374
return MNG_NOERROR; /* done */
6375
}
6376
#else
6377
#define read_jdat 0
6378
#endif /* MNG_INCLUDE_JNG */
6379
#endif
6380
6381
/* ************************************************************************** */
6382
6383
#ifndef MNG_OPTIMIZE_CHUNKREADER
6384
#ifdef MNG_INCLUDE_JNG
6385
READ_CHUNK (mng_read_jsep)
6386
{
6387
#ifdef MNG_SUPPORT_TRACE
6388
MNG_TRACE (pData, MNG_FN_READ_JSEP, MNG_LC_START);
6389
#endif
6390
6391
if (!pData->bHasJHDR) /* sequence checks */
6392
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6393
6394
if (iRawlen != 0) /* must be empty ! */
6395
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6396
6397
pData->bHasJSEP = MNG_TRUE; /* indicate we've had the 8-/12-bit separator */
6398
6399
#ifdef MNG_STORE_CHUNKS
6400
if (pData->bStorechunks)
6401
{ /* initialize storage */
6402
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6403
6404
if (iRetcode) /* on error bail out */
6405
return iRetcode;
6406
6407
}
6408
#endif /* MNG_STORE_CHUNKS */
6409
6410
#ifdef MNG_SUPPORT_TRACE
6411
MNG_TRACE (pData, MNG_FN_READ_JSEP, MNG_LC_END);
6412
#endif
6413
6414
return MNG_NOERROR; /* done */
6415
}
6416
#else
6417
#define read_jsep 0
6418
#endif /* MNG_INCLUDE_JNG */
6419
#endif
6420
6421
/* ************************************************************************** */
6422
6423
#ifndef MNG_OPTIMIZE_CHUNKREADER
6424
#ifndef MNG_NO_DELTA_PNG
6425
READ_CHUNK (mng_read_dhdr)
6426
{
6427
mng_uint8 iImagetype, iDeltatype;
6428
#ifdef MNG_SUPPORT_TRACE
6429
MNG_TRACE (pData, MNG_FN_READ_DHDR, MNG_LC_START);
6430
#endif
6431
6432
if (!pData->bHasMHDR) /* sequence checks */
6433
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6434
6435
#ifdef MNG_INCLUDE_JNG
6436
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR) || (pData->bHasJHDR))
6437
#else
6438
if ((pData->bHasIHDR) || (pData->bHasBASI) || (pData->bHasDHDR))
6439
#endif
6440
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6441
/* check for valid length */
6442
if ((iRawlen != 4) && (iRawlen != 12) && (iRawlen != 20))
6443
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6444
6445
iImagetype = *(pRawdata+2); /* check fields for validity */
6446
iDeltatype = *(pRawdata+3);
6447
6448
if (iImagetype > MNG_IMAGETYPE_JNG)
6449
MNG_ERROR (pData, MNG_INVIMAGETYPE);
6450
6451
if (iDeltatype > MNG_DELTATYPE_NOCHANGE)
6452
MNG_ERROR (pData, MNG_INVDELTATYPE);
6453
6454
if ((iDeltatype == MNG_DELTATYPE_REPLACE) && (iRawlen > 12))
6455
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6456
6457
if ((iDeltatype == MNG_DELTATYPE_NOCHANGE) && (iRawlen > 4))
6458
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6459
6460
pData->bHasDHDR = MNG_TRUE; /* inside a DHDR-IEND block now */
6461
pData->iDeltatype = iDeltatype;
6462
6463
pData->iImagelevel++; /* one level deeper */
6464
6465
#ifdef MNG_SUPPORT_DISPLAY
6466
{
6467
mng_uint16 iObjectid = mng_get_uint16 (pRawdata);
6468
mng_uint32 iBlockwidth = 0;
6469
mng_uint32 iBlockheight = 0;
6470
mng_uint32 iBlockx = 0;
6471
mng_uint32 iBlocky = 0;
6472
mng_retcode iRetcode;
6473
6474
if (iRawlen > 4)
6475
{
6476
iBlockwidth = mng_get_uint32 (pRawdata+4);
6477
iBlockheight = mng_get_uint32 (pRawdata+8);
6478
}
6479
6480
if (iRawlen > 12)
6481
{
6482
iBlockx = mng_get_uint32 (pRawdata+12);
6483
iBlocky = mng_get_uint32 (pRawdata+16);
6484
}
6485
6486
iRetcode = mng_create_ani_dhdr (pData, iObjectid, iImagetype, iDeltatype,
6487
iBlockwidth, iBlockheight, iBlockx, iBlocky);
6488
6489
if (!iRetcode) /* display processing ? */
6490
iRetcode = mng_process_display_dhdr (pData, iObjectid, iImagetype, iDeltatype,
6491
iBlockwidth, iBlockheight, iBlockx, iBlocky);
6492
6493
if (iRetcode) /* on error bail out */
6494
return iRetcode;
6495
6496
}
6497
#endif /* MNG_SUPPORT_DISPLAY */
6498
6499
#ifdef MNG_STORE_CHUNKS
6500
if (pData->bStorechunks)
6501
{ /* initialize storage */
6502
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6503
6504
if (iRetcode) /* on error bail out */
6505
return iRetcode;
6506
/* store the fields */
6507
((mng_dhdrp)*ppChunk)->iObjectid = mng_get_uint16 (pRawdata);
6508
((mng_dhdrp)*ppChunk)->iImagetype = iImagetype;
6509
((mng_dhdrp)*ppChunk)->iDeltatype = iDeltatype;
6510
6511
if (iRawlen > 4)
6512
{
6513
((mng_dhdrp)*ppChunk)->iBlockwidth = mng_get_uint32 (pRawdata+4);
6514
((mng_dhdrp)*ppChunk)->iBlockheight = mng_get_uint32 (pRawdata+8);
6515
}
6516
6517
if (iRawlen > 12)
6518
{
6519
((mng_dhdrp)*ppChunk)->iBlockx = mng_get_uint32 (pRawdata+12);
6520
((mng_dhdrp)*ppChunk)->iBlocky = mng_get_uint32 (pRawdata+16);
6521
}
6522
}
6523
#endif /* MNG_STORE_CHUNKS */
6524
6525
#ifdef MNG_SUPPORT_TRACE
6526
MNG_TRACE (pData, MNG_FN_READ_DHDR, MNG_LC_END);
6527
#endif
6528
6529
return MNG_NOERROR; /* done */
6530
}
6531
#endif
6532
#endif
6533
6534
/* ************************************************************************** */
6535
6536
#ifndef MNG_OPTIMIZE_CHUNKREADER
6537
#ifndef MNG_NO_DELTA_PNG
6538
READ_CHUNK (mng_read_prom)
6539
{
6540
mng_uint8 iColortype;
6541
mng_uint8 iSampledepth;
6542
mng_uint8 iFilltype;
6543
6544
#ifdef MNG_SUPPORT_TRACE
6545
MNG_TRACE (pData, MNG_FN_READ_PROM, MNG_LC_START);
6546
#endif
6547
/* sequence checks */
6548
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6549
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6550
6551
if (iRawlen != 3) /* gotta be exactly 3 bytes */
6552
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6553
6554
iColortype = *pRawdata; /* check fields for validity */
6555
iSampledepth = *(pRawdata+1);
6556
iFilltype = *(pRawdata+2);
6557
6558
if ((iColortype != MNG_COLORTYPE_GRAY ) &&
6559
(iColortype != MNG_COLORTYPE_RGB ) &&
6560
(iColortype != MNG_COLORTYPE_INDEXED) &&
6561
(iColortype != MNG_COLORTYPE_GRAYA ) &&
6562
(iColortype != MNG_COLORTYPE_RGBA ) )
6563
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
6564
6565
#ifdef MNG_NO_16BIT_SUPPORT
6566
if (iSampledepth == MNG_BITDEPTH_16 )
6567
iSampledepth = MNG_BITDEPTH_8;
6568
#endif
6569
6570
if ((iSampledepth != MNG_BITDEPTH_1 ) &&
6571
(iSampledepth != MNG_BITDEPTH_2 ) &&
6572
(iSampledepth != MNG_BITDEPTH_4 ) &&
6573
(iSampledepth != MNG_BITDEPTH_8 )
6574
#ifndef MNG_NO_16BIT_SUPPORT
6575
&& (iSampledepth != MNG_BITDEPTH_16)
6576
#endif
6577
)
6578
MNG_ERROR (pData, MNG_INVSAMPLEDEPTH);
6579
6580
if ((iFilltype != MNG_FILLMETHOD_LEFTBITREPLICATE) &&
6581
(iFilltype != MNG_FILLMETHOD_ZEROFILL ) )
6582
MNG_ERROR (pData, MNG_INVFILLMETHOD);
6583
6584
#ifdef MNG_SUPPORT_DISPLAY
6585
{
6586
mng_retcode iRetcode = mng_create_ani_prom (pData, iSampledepth,
6587
iColortype, iFilltype);
6588
6589
if (!iRetcode) /* display processing ? */
6590
iRetcode = mng_process_display_prom (pData, iSampledepth,
6591
iColortype, iFilltype);
6592
if (iRetcode) /* on error bail out */
6593
return iRetcode;
6594
}
6595
#endif /* MNG_SUPPORT_DISPLAY */
6596
6597
#ifdef MNG_STORE_CHUNKS
6598
if (pData->bStorechunks)
6599
{ /* initialize storage */
6600
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6601
6602
if (iRetcode) /* on error bail out */
6603
return iRetcode;
6604
/* store the fields */
6605
((mng_promp)*ppChunk)->iColortype = iColortype;
6606
((mng_promp)*ppChunk)->iSampledepth = iSampledepth;
6607
((mng_promp)*ppChunk)->iFilltype = iFilltype;
6608
}
6609
#endif /* MNG_STORE_CHUNKS */
6610
6611
#ifdef MNG_SUPPORT_TRACE
6612
MNG_TRACE (pData, MNG_FN_READ_PROM, MNG_LC_END);
6613
#endif
6614
6615
return MNG_NOERROR; /* done */
6616
}
6617
#endif
6618
#endif
6619
6620
/* ************************************************************************** */
6621
6622
#ifndef MNG_OPTIMIZE_CHUNKREADER
6623
#ifndef MNG_NO_DELTA_PNG
6624
READ_CHUNK (mng_read_ipng)
6625
{
6626
#ifdef MNG_SUPPORT_TRACE
6627
MNG_TRACE (pData, MNG_FN_READ_IPNG, MNG_LC_START);
6628
#endif
6629
/* sequence checks */
6630
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6631
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6632
6633
if (iRawlen != 0) /* gotta be empty */
6634
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6635
6636
#ifdef MNG_SUPPORT_DISPLAY
6637
{
6638
mng_retcode iRetcode = mng_create_ani_ipng (pData);
6639
6640
if (!iRetcode) /* process it */
6641
iRetcode = mng_process_display_ipng (pData);
6642
6643
if (iRetcode) /* on error bail out */
6644
return iRetcode;
6645
6646
}
6647
#endif /* MNG_SUPPORT_DISPLAY */
6648
6649
#ifdef MNG_STORE_CHUNKS
6650
if (pData->bStorechunks)
6651
{ /* initialize storage */
6652
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6653
6654
if (iRetcode) /* on error bail out */
6655
return iRetcode;
6656
}
6657
#endif /* MNG_STORE_CHUNKS */
6658
6659
#ifdef MNG_SUPPORT_TRACE
6660
MNG_TRACE (pData, MNG_FN_READ_IPNG, MNG_LC_END);
6661
#endif
6662
6663
return MNG_NOERROR; /* done */
6664
}
6665
#endif
6666
#endif
6667
6668
/* ************************************************************************** */
6669
6670
#ifndef MNG_OPTIMIZE_CHUNKREADER
6671
#ifndef MNG_NO_DELTA_PNG
6672
READ_CHUNK (mng_read_pplt)
6673
{
6674
mng_uint8 iDeltatype;
6675
mng_uint8p pTemp;
6676
mng_uint32 iLen;
6677
mng_uint8 iX, iM;
6678
mng_uint32 iY;
6679
mng_uint32 iMax;
6680
mng_rgbpaltab aIndexentries;
6681
mng_uint8arr aAlphaentries;
6682
mng_uint8arr aUsedentries;
6683
6684
#ifdef MNG_SUPPORT_TRACE
6685
MNG_TRACE (pData, MNG_FN_READ_PPLT, MNG_LC_START);
6686
#endif
6687
/* sequence checks */
6688
if ((!pData->bHasMHDR) && (!pData->bHasDHDR))
6689
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6690
6691
if (iRawlen < 1) /* must have at least 1 byte */
6692
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6693
6694
iDeltatype = *pRawdata;
6695
/* valid ? */
6696
if (iDeltatype > MNG_DELTATYPE_DELTARGBA)
6697
MNG_ERROR (pData, MNG_INVDELTATYPE);
6698
/* must be indexed color ! */
6699
if (pData->iColortype != MNG_COLORTYPE_INDEXED)
6700
MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
6701
6702
pTemp = pRawdata + 1;
6703
iLen = iRawlen - 1;
6704
iMax = 0;
6705
6706
for (iY = 0; iY < 256; iY++) /* reset arrays */
6707
{
6708
aIndexentries [iY].iRed = 0;
6709
aIndexentries [iY].iGreen = 0;
6710
aIndexentries [iY].iBlue = 0;
6711
aAlphaentries [iY] = 255;
6712
aUsedentries [iY] = 0;
6713
}
6714
6715
while (iLen) /* as long as there are entries left ... */
6716
{
6717
mng_uint32 iDiff;
6718
6719
if (iLen < 2)
6720
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6721
6722
iX = *pTemp; /* get start and end index */
6723
iM = *(pTemp+1);
6724
6725
if (iM < iX)
6726
MNG_ERROR (pData, MNG_INVALIDINDEX);
6727
6728
if ((mng_uint32)iM >= iMax) /* determine highest used index */
6729
iMax = (mng_uint32)iM + 1;
6730
6731
pTemp += 2;
6732
iLen -= 2;
6733
iDiff = (iM - iX + 1);
6734
if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) ||
6735
(iDeltatype == MNG_DELTATYPE_DELTARGB ) )
6736
iDiff = iDiff * 3;
6737
else
6738
if ((iDeltatype == MNG_DELTATYPE_REPLACERGBA) ||
6739
(iDeltatype == MNG_DELTATYPE_DELTARGBA ) )
6740
iDiff = iDiff * 4;
6741
6742
if (iLen < iDiff)
6743
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6744
6745
if ((iDeltatype == MNG_DELTATYPE_REPLACERGB ) ||
6746
(iDeltatype == MNG_DELTATYPE_DELTARGB ) )
6747
{
6748
for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
6749
{
6750
aIndexentries [iY].iRed = *pTemp;
6751
aIndexentries [iY].iGreen = *(pTemp+1);
6752
aIndexentries [iY].iBlue = *(pTemp+2);
6753
aUsedentries [iY] = 1;
6754
6755
pTemp += 3;
6756
iLen -= 3;
6757
}
6758
}
6759
else
6760
if ((iDeltatype == MNG_DELTATYPE_REPLACEALPHA) ||
6761
(iDeltatype == MNG_DELTATYPE_DELTAALPHA ) )
6762
{
6763
for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
6764
{
6765
aAlphaentries [iY] = *pTemp;
6766
aUsedentries [iY] = 1;
6767
6768
pTemp++;
6769
iLen--;
6770
}
6771
}
6772
else
6773
{
6774
for (iY = (mng_uint32)iX; iY <= (mng_uint32)iM; iY++)
6775
{
6776
aIndexentries [iY].iRed = *pTemp;
6777
aIndexentries [iY].iGreen = *(pTemp+1);
6778
aIndexentries [iY].iBlue = *(pTemp+2);
6779
aAlphaentries [iY] = *(pTemp+3);
6780
aUsedentries [iY] = 1;
6781
6782
pTemp += 4;
6783
iLen -= 4;
6784
}
6785
}
6786
}
6787
6788
switch (pData->iBitdepth) /* check maximum allowed entries for bitdepth */
6789
{
6790
case MNG_BITDEPTH_1 : {
6791
if (iMax > 2)
6792
MNG_ERROR (pData, MNG_INVALIDINDEX);
6793
break;
6794
}
6795
case MNG_BITDEPTH_2 : {
6796
if (iMax > 4)
6797
MNG_ERROR (pData, MNG_INVALIDINDEX);
6798
break;
6799
}
6800
case MNG_BITDEPTH_4 : {
6801
if (iMax > 16)
6802
MNG_ERROR (pData, MNG_INVALIDINDEX);
6803
break;
6804
}
6805
}
6806
6807
#ifdef MNG_SUPPORT_DISPLAY
6808
{ /* create animation object */
6809
mng_retcode iRetcode = mng_create_ani_pplt (pData, iDeltatype, iMax,
6810
aIndexentries, aAlphaentries,
6811
aUsedentries);
6812
6813
if (!iRetcode) /* execute it now ? */
6814
iRetcode = mng_process_display_pplt (pData, iDeltatype, iMax, aIndexentries,
6815
aAlphaentries, aUsedentries);
6816
6817
if (iRetcode) /* on error bail out */
6818
return iRetcode;
6819
6820
}
6821
#endif /* MNG_SUPPORT_DISPLAY */
6822
6823
#ifdef MNG_STORE_CHUNKS
6824
if (pData->bStorechunks)
6825
{ /* initialize storage */
6826
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6827
6828
if (iRetcode) /* on error bail out */
6829
return iRetcode;
6830
/* store the fields */
6831
((mng_ppltp)*ppChunk)->iDeltatype = iDeltatype;
6832
((mng_ppltp)*ppChunk)->iCount = iMax;
6833
6834
for (iY = 0; iY < 256; iY++)
6835
{
6836
((mng_ppltp)*ppChunk)->aEntries [iY].iRed = aIndexentries [iY].iRed;
6837
((mng_ppltp)*ppChunk)->aEntries [iY].iGreen = aIndexentries [iY].iGreen;
6838
((mng_ppltp)*ppChunk)->aEntries [iY].iBlue = aIndexentries [iY].iBlue;
6839
((mng_ppltp)*ppChunk)->aEntries [iY].iAlpha = aAlphaentries [iY];
6840
((mng_ppltp)*ppChunk)->aEntries [iY].bUsed = (mng_bool)(aUsedentries [iY]);
6841
}
6842
}
6843
#endif /* MNG_STORE_CHUNKS */
6844
6845
#ifdef MNG_SUPPORT_TRACE
6846
MNG_TRACE (pData, MNG_FN_READ_PPLT, MNG_LC_END);
6847
#endif
6848
6849
return MNG_NOERROR; /* done */
6850
}
6851
#endif
6852
#endif
6853
6854
/* ************************************************************************** */
6855
6856
#ifndef MNG_OPTIMIZE_CHUNKREADER
6857
#ifndef MNG_NO_DELTA_PNG
6858
#ifdef MNG_INCLUDE_JNG
6859
READ_CHUNK (mng_read_ijng)
6860
{
6861
#ifdef MNG_SUPPORT_TRACE
6862
MNG_TRACE (pData, MNG_FN_READ_IJNG, MNG_LC_START);
6863
#endif
6864
/* sequence checks */
6865
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6866
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6867
6868
if (iRawlen != 0) /* gotta be empty */
6869
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6870
6871
#ifdef MNG_SUPPORT_DISPLAY
6872
{
6873
mng_retcode iRetcode = mng_create_ani_ijng (pData);
6874
6875
if (!iRetcode) /* process it */
6876
iRetcode = mng_process_display_ijng (pData);
6877
6878
if (iRetcode) /* on error bail out */
6879
return iRetcode;
6880
6881
}
6882
#endif /* MNG_SUPPORT_DISPLAY */
6883
6884
#ifdef MNG_STORE_CHUNKS
6885
if (pData->bStorechunks)
6886
{ /* initialize storage */
6887
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6888
6889
if (iRetcode) /* on error bail out */
6890
return iRetcode;
6891
}
6892
#endif /* MNG_STORE_CHUNKS */
6893
6894
#ifdef MNG_SUPPORT_TRACE
6895
MNG_TRACE (pData, MNG_FN_READ_IJNG, MNG_LC_END);
6896
#endif
6897
6898
return MNG_NOERROR; /* done */
6899
}
6900
#endif
6901
#endif
6902
#endif
6903
6904
/* ************************************************************************** */
6905
6906
#ifndef MNG_OPTIMIZE_CHUNKREADER
6907
#ifndef MNG_NO_DELTA_PNG
6908
READ_CHUNK (mng_read_drop)
6909
{
6910
#ifdef MNG_SUPPORT_TRACE
6911
MNG_TRACE (pData, MNG_FN_READ_DROP, MNG_LC_START);
6912
#endif
6913
/* sequence checks */
6914
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6915
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6916
/* check length */
6917
if ((iRawlen < 4) || ((iRawlen % 4) != 0))
6918
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6919
6920
#ifdef MNG_SUPPORT_DISPLAY
6921
{
6922
6923
6924
/* TODO: something !!! */
6925
6926
6927
}
6928
#endif /* MNG_SUPPORT_DISPLAY */
6929
6930
#ifdef MNG_STORE_CHUNKS
6931
if (pData->bStorechunks)
6932
{ /* initialize storage */
6933
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
6934
6935
if (iRetcode) /* on error bail out */
6936
return iRetcode;
6937
/* store the fields */
6938
((mng_dropp)*ppChunk)->iCount = iRawlen / 4;
6939
6940
if (iRawlen)
6941
{
6942
mng_uint32 iX;
6943
mng_uint8p pTemp = pRawdata;
6944
mng_uint32p pEntry;
6945
6946
MNG_ALLOC (pData, pEntry, iRawlen);
6947
6948
((mng_dropp)*ppChunk)->pChunknames = (mng_ptr)pEntry;
6949
6950
for (iX = 0; iX < iRawlen / 4; iX++)
6951
{
6952
*pEntry = mng_get_uint32 (pTemp);
6953
6954
pTemp += 4;
6955
pEntry++;
6956
}
6957
}
6958
}
6959
#endif /* MNG_STORE_CHUNKS */
6960
6961
#ifdef MNG_SUPPORT_TRACE
6962
MNG_TRACE (pData, MNG_FN_READ_DROP, MNG_LC_END);
6963
#endif
6964
6965
return MNG_NOERROR; /* done */
6966
}
6967
#endif
6968
#endif
6969
6970
/* ************************************************************************** */
6971
6972
#ifndef MNG_OPTIMIZE_CHUNKREADER
6973
#ifndef MNG_NO_DELTA_PNG
6974
#ifndef MNG_SKIPCHUNK_DBYK
6975
READ_CHUNK (mng_read_dbyk)
6976
{
6977
#ifdef MNG_SUPPORT_TRACE
6978
MNG_TRACE (pData, MNG_FN_READ_DBYK, MNG_LC_START);
6979
#endif
6980
/* sequence checks */
6981
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
6982
MNG_ERROR (pData, MNG_SEQUENCEERROR);
6983
6984
if (iRawlen < 6) /* must be at least 6 long */
6985
MNG_ERROR (pData, MNG_INVALIDLENGTH);
6986
6987
#ifdef MNG_SUPPORT_DISPLAY
6988
{
6989
6990
6991
/* TODO: something !!! */
6992
6993
6994
}
6995
#endif /* MNG_SUPPORT_DISPLAY */
6996
6997
#ifdef MNG_STORE_CHUNKS
6998
if (pData->bStorechunks)
6999
{ /* initialize storage */
7000
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
7001
7002
if (iRetcode) /* on error bail out */
7003
return iRetcode;
7004
/* store the fields */
7005
((mng_dbykp)*ppChunk)->iChunkname = mng_get_uint32 (pRawdata);
7006
((mng_dbykp)*ppChunk)->iPolarity = *(pRawdata+4);
7007
((mng_dbykp)*ppChunk)->iKeywordssize = iRawlen - 5;
7008
7009
if (iRawlen > 5)
7010
{
7011
MNG_ALLOC (pData, ((mng_dbykp)*ppChunk)->zKeywords, iRawlen-4);
7012
MNG_COPY (((mng_dbykp)*ppChunk)->zKeywords, pRawdata+5, iRawlen-5);
7013
}
7014
}
7015
#endif /* MNG_STORE_CHUNKS */
7016
7017
#ifdef MNG_SUPPORT_TRACE
7018
MNG_TRACE (pData, MNG_FN_READ_DBYK, MNG_LC_END);
7019
#endif
7020
7021
return MNG_NOERROR; /* done */
7022
}
7023
#endif
7024
#endif
7025
#endif
7026
7027
/* ************************************************************************** */
7028
7029
#ifndef MNG_OPTIMIZE_CHUNKREADER
7030
#ifndef MNG_NO_DELTA_PNG
7031
#ifndef MNG_SKIPCHUNK_ORDR
7032
READ_CHUNK (mng_read_ordr)
7033
{
7034
#ifdef MNG_SUPPORT_TRACE
7035
MNG_TRACE (pData, MNG_FN_READ_ORDR, MNG_LC_START);
7036
#endif
7037
/* sequence checks */
7038
if ((!pData->bHasMHDR) || (!pData->bHasDHDR))
7039
MNG_ERROR (pData, MNG_SEQUENCEERROR);
7040
/* check length */
7041
if ((iRawlen < 5) || ((iRawlen % 5) != 0))
7042
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7043
7044
#ifdef MNG_SUPPORT_DISPLAY
7045
{
7046
7047
7048
/* TODO: something !!! */
7049
7050
7051
}
7052
#endif /* MNG_SUPPORT_DISPLAY */
7053
7054
#ifdef MNG_STORE_CHUNKS
7055
if (pData->bStorechunks)
7056
{ /* initialize storage */
7057
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
7058
7059
if (iRetcode) /* on error bail out */
7060
return iRetcode;
7061
/* store the fields */
7062
((mng_ordrp)*ppChunk)->iCount = iRawlen / 5;
7063
7064
if (iRawlen)
7065
{
7066
mng_uint32 iX;
7067
mng_ordr_entryp pEntry;
7068
mng_uint8p pTemp = pRawdata;
7069
7070
MNG_ALLOC (pData, pEntry, iRawlen);
7071
7072
((mng_ordrp)*ppChunk)->pEntries = pEntry;
7073
7074
for (iX = 0; iX < iRawlen / 5; iX++)
7075
{
7076
pEntry->iChunkname = mng_get_uint32 (pTemp);
7077
pEntry->iOrdertype = *(pTemp+4);
7078
7079
pTemp += 5;
7080
pEntry++;
7081
}
7082
}
7083
}
7084
#endif /* MNG_STORE_CHUNKS */
7085
7086
#ifdef MNG_SUPPORT_TRACE
7087
MNG_TRACE (pData, MNG_FN_READ_ORDR, MNG_LC_END);
7088
#endif
7089
7090
return MNG_NOERROR; /* done */
7091
}
7092
#endif
7093
#endif
7094
#endif
7095
7096
/* ************************************************************************** */
7097
7098
#ifndef MNG_OPTIMIZE_CHUNKREADER
7099
#ifndef MNG_SKIPCHUNK_MAGN
7100
READ_CHUNK (mng_read_magn)
7101
{
7102
mng_uint16 iFirstid, iLastid;
7103
mng_uint8 iMethodX, iMethodY;
7104
mng_uint16 iMX, iMY, iML, iMR, iMT, iMB;
7105
mng_bool bFaulty;
7106
7107
#ifdef MNG_SUPPORT_TRACE
7108
MNG_TRACE (pData, MNG_FN_READ_MAGN, MNG_LC_START);
7109
#endif
7110
/* sequence checks */
7111
#ifdef MNG_SUPPORT_JNG
7112
if ((!pData->bHasMHDR) || (pData->bHasIHDR) || (pData->bHasDHDR) || (pData->bHasJHDR))
7113
#else
7114
if ((!pData->bHasMHDR) || (pData->bHasIHDR) || (pData->bHasDHDR))
7115
#endif
7116
MNG_ERROR (pData, MNG_SEQUENCEERROR);
7117
/* check length */
7118
if (iRawlen > 20)
7119
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7120
7121
/* following is an ugly hack to allow faulty layout caused by previous
7122
versions of libmng and MNGeye, which wrote MAGN with a 16-bit
7123
MethodX/MethodY (as opposed to the proper 8-bit as defined in the spec!) */
7124
7125
if ((iRawlen == 6) || (iRawlen == 8) || (iRawlen == 10) || (iRawlen == 12) ||
7126
(iRawlen == 14) || (iRawlen == 16) || (iRawlen == 20))
7127
bFaulty = MNG_TRUE; /* these lengths are all wrong */
7128
else /* length 18 can be right or wrong !!! */
7129
if ((iRawlen == 18) && (mng_get_uint16 (pRawdata+4) <= 5) &&
7130
(mng_get_uint16 (pRawdata+6) < 256) &&
7131
(mng_get_uint16 (pRawdata+8) < 256) &&
7132
(mng_get_uint16 (pRawdata+10) < 256) &&
7133
(mng_get_uint16 (pRawdata+12) < 256) &&
7134
(mng_get_uint16 (pRawdata+14) < 256) &&
7135
(mng_get_uint16 (pRawdata+16) < 256))
7136
bFaulty = MNG_TRUE; /* this is very likely the wrong layout */
7137
else
7138
bFaulty = MNG_FALSE; /* all other cases are handled as right */
7139
7140
if (bFaulty) /* wrong layout ? */
7141
{
7142
if (iRawlen > 0) /* get the fields */
7143
iFirstid = mng_get_uint16 (pRawdata);
7144
else
7145
iFirstid = 0;
7146
7147
if (iRawlen > 2)
7148
iLastid = mng_get_uint16 (pRawdata+2);
7149
else
7150
iLastid = iFirstid;
7151
7152
if (iRawlen > 4)
7153
iMethodX = (mng_uint8)(mng_get_uint16 (pRawdata+4));
7154
else
7155
iMethodX = 0;
7156
7157
if (iRawlen > 6)
7158
iMX = mng_get_uint16 (pRawdata+6);
7159
else
7160
iMX = 1;
7161
7162
if (iRawlen > 8)
7163
iMY = mng_get_uint16 (pRawdata+8);
7164
else
7165
iMY = iMX;
7166
7167
if (iRawlen > 10)
7168
iML = mng_get_uint16 (pRawdata+10);
7169
else
7170
iML = iMX;
7171
7172
if (iRawlen > 12)
7173
iMR = mng_get_uint16 (pRawdata+12);
7174
else
7175
iMR = iMX;
7176
7177
if (iRawlen > 14)
7178
iMT = mng_get_uint16 (pRawdata+14);
7179
else
7180
iMT = iMY;
7181
7182
if (iRawlen > 16)
7183
iMB = mng_get_uint16 (pRawdata+16);
7184
else
7185
iMB = iMY;
7186
7187
if (iRawlen > 18)
7188
iMethodY = (mng_uint8)(mng_get_uint16 (pRawdata+18));
7189
else
7190
iMethodY = iMethodX;
7191
}
7192
else /* proper layout !!!! */
7193
{
7194
if (iRawlen > 0) /* get the fields */
7195
iFirstid = mng_get_uint16 (pRawdata);
7196
else
7197
iFirstid = 0;
7198
7199
if (iRawlen > 2)
7200
iLastid = mng_get_uint16 (pRawdata+2);
7201
else
7202
iLastid = iFirstid;
7203
7204
if (iRawlen > 4)
7205
iMethodX = *(pRawdata+4);
7206
else
7207
iMethodX = 0;
7208
7209
if (iRawlen > 5)
7210
iMX = mng_get_uint16 (pRawdata+5);
7211
else
7212
iMX = 1;
7213
7214
if (iRawlen > 7)
7215
iMY = mng_get_uint16 (pRawdata+7);
7216
else
7217
iMY = iMX;
7218
7219
if (iRawlen > 9)
7220
iML = mng_get_uint16 (pRawdata+9);
7221
else
7222
iML = iMX;
7223
7224
if (iRawlen > 11)
7225
iMR = mng_get_uint16 (pRawdata+11);
7226
else
7227
iMR = iMX;
7228
7229
if (iRawlen > 13)
7230
iMT = mng_get_uint16 (pRawdata+13);
7231
else
7232
iMT = iMY;
7233
7234
if (iRawlen > 15)
7235
iMB = mng_get_uint16 (pRawdata+15);
7236
else
7237
iMB = iMY;
7238
7239
if (iRawlen > 17)
7240
iMethodY = *(pRawdata+17);
7241
else
7242
iMethodY = iMethodX;
7243
}
7244
/* check field validity */
7245
if ((iMethodX > 5) || (iMethodY > 5))
7246
MNG_ERROR (pData, MNG_INVALIDMETHOD);
7247
7248
#ifdef MNG_SUPPORT_DISPLAY
7249
{
7250
mng_retcode iRetcode;
7251
7252
iRetcode = mng_create_ani_magn (pData, iFirstid, iLastid, iMethodX,
7253
iMX, iMY, iML, iMR, iMT, iMB, iMethodY);
7254
7255
if (!iRetcode) /* display processing ? */
7256
iRetcode = mng_process_display_magn (pData, iFirstid, iLastid, iMethodX,
7257
iMX, iMY, iML, iMR, iMT, iMB, iMethodY);
7258
7259
if (iRetcode) /* on error bail out */
7260
return iRetcode;
7261
7262
}
7263
#endif /* MNG_SUPPORT_DISPLAY */
7264
7265
#ifdef MNG_STORE_CHUNKS
7266
if (pData->bStorechunks)
7267
{ /* initialize storage */
7268
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
7269
7270
if (iRetcode) /* on error bail out */
7271
return iRetcode;
7272
/* store the fields */
7273
((mng_magnp)*ppChunk)->iFirstid = iFirstid;
7274
((mng_magnp)*ppChunk)->iLastid = iLastid;
7275
((mng_magnp)*ppChunk)->iMethodX = iMethodX;
7276
((mng_magnp)*ppChunk)->iMX = iMX;
7277
((mng_magnp)*ppChunk)->iMY = iMY;
7278
((mng_magnp)*ppChunk)->iML = iML;
7279
((mng_magnp)*ppChunk)->iMR = iMR;
7280
((mng_magnp)*ppChunk)->iMT = iMT;
7281
((mng_magnp)*ppChunk)->iMB = iMB;
7282
((mng_magnp)*ppChunk)->iMethodY = iMethodY;
7283
}
7284
#endif /* MNG_STORE_CHUNKS */
7285
7286
#ifdef MNG_SUPPORT_TRACE
7287
MNG_TRACE (pData, MNG_FN_READ_MAGN, MNG_LC_END);
7288
#endif
7289
7290
return MNG_NOERROR; /* done */
7291
}
7292
#endif
7293
#endif
7294
7295
/* ************************************************************************** */
7296
7297
#ifndef MNG_OPTIMIZE_CHUNKREADER
7298
#ifndef MNG_SKIPCHUNK_evNT
7299
READ_CHUNK (mng_read_evnt)
7300
{
7301
#ifdef MNG_SUPPORT_TRACE
7302
MNG_TRACE (pData, MNG_FN_READ_EVNT, MNG_LC_START);
7303
#endif
7304
/* sequence checks */
7305
if ((!pData->bHasMHDR) || (pData->bHasSAVE))
7306
MNG_ERROR (pData, MNG_SEQUENCEERROR);
7307
7308
if (iRawlen < 2) /* must have at least 1 entry ! */
7309
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7310
7311
#if defined(MNG_SUPPORT_DISPLAY) && defined(MNG_SUPPORT_DYNAMICMNG)
7312
{
7313
if (iRawlen) /* not empty ? */
7314
{
7315
mng_retcode iRetcode;
7316
mng_uint8p pTemp;
7317
mng_uint8p pNull;
7318
mng_uint32 iLen;
7319
mng_uint8 iEventtype;
7320
mng_uint8 iMasktype;
7321
mng_int32 iLeft;
7322
mng_int32 iRight;
7323
mng_int32 iTop;
7324
mng_int32 iBottom;
7325
mng_uint16 iObjectid;
7326
mng_uint8 iIndex;
7327
mng_uint32 iNamesize;
7328
7329
pTemp = pRawdata;
7330
iLen = iRawlen;
7331
7332
while (iLen) /* anything left ? */
7333
{
7334
iEventtype = *pTemp; /* eventtype */
7335
if (iEventtype > 5)
7336
MNG_ERROR (pData, MNG_INVALIDEVENT);
7337
7338
pTemp++;
7339
7340
iMasktype = *pTemp; /* masktype */
7341
if (iMasktype > 5)
7342
MNG_ERROR (pData, MNG_INVALIDMASK);
7343
7344
pTemp++;
7345
iLen -= 2;
7346
7347
iLeft = 0;
7348
iRight = 0;
7349
iTop = 0;
7350
iBottom = 0;
7351
iObjectid = 0;
7352
iIndex = 0;
7353
7354
switch (iMasktype)
7355
{
7356
case 1 :
7357
{
7358
if (iLen > 16)
7359
{
7360
iLeft = mng_get_int32 (pTemp);
7361
iRight = mng_get_int32 (pTemp+4);
7362
iTop = mng_get_int32 (pTemp+8);
7363
iBottom = mng_get_int32 (pTemp+12);
7364
pTemp += 16;
7365
iLen -= 16;
7366
}
7367
else
7368
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7369
break;
7370
}
7371
case 2 :
7372
{
7373
if (iLen > 2)
7374
{
7375
iObjectid = mng_get_uint16 (pTemp);
7376
pTemp += 2;
7377
iLen -= 2;
7378
}
7379
else
7380
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7381
break;
7382
}
7383
case 3 :
7384
{
7385
if (iLen > 3)
7386
{
7387
iObjectid = mng_get_uint16 (pTemp);
7388
iIndex = *(pTemp+2);
7389
pTemp += 3;
7390
iLen -= 3;
7391
}
7392
else
7393
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7394
break;
7395
}
7396
case 4 :
7397
{
7398
if (iLen > 18)
7399
{
7400
iLeft = mng_get_int32 (pTemp);
7401
iRight = mng_get_int32 (pTemp+4);
7402
iTop = mng_get_int32 (pTemp+8);
7403
iBottom = mng_get_int32 (pTemp+12);
7404
iObjectid = mng_get_uint16 (pTemp+16);
7405
pTemp += 18;
7406
iLen -= 18;
7407
}
7408
else
7409
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7410
break;
7411
}
7412
case 5 :
7413
{
7414
if (iLen > 19)
7415
{
7416
iLeft = mng_get_int32 (pTemp);
7417
iRight = mng_get_int32 (pTemp+4);
7418
iTop = mng_get_int32 (pTemp+8);
7419
iBottom = mng_get_int32 (pTemp+12);
7420
iObjectid = mng_get_uint16 (pTemp+16);
7421
iIndex = *(pTemp+18);
7422
pTemp += 19;
7423
iLen -= 19;
7424
}
7425
else
7426
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7427
break;
7428
}
7429
}
7430
7431
pNull = find_null (pTemp); /* get the name length */
7432
7433
if ((pNull - pTemp) > (mng_int32)iLen)
7434
{
7435
iNamesize = iLen; /* no null found; so end of evNT */
7436
iLen = 0;
7437
}
7438
else
7439
{
7440
iNamesize = pNull - pTemp; /* should be another entry */
7441
iLen = iLen - iNamesize - 1;
7442
7443
if (!iLen) /* must not end with a null ! */
7444
MNG_ERROR (pData, MNG_ENDWITHNULL);
7445
}
7446
7447
iRetcode = mng_create_event (pData, iEventtype, iMasktype, iLeft, iRight,
7448
iTop, iBottom, iObjectid, iIndex,
7449
iNamesize, (mng_pchar)pTemp);
7450
7451
if (iRetcode) /* on error bail out */
7452
return iRetcode;
7453
7454
pTemp = pTemp + iNamesize + 1;
7455
}
7456
}
7457
}
7458
#endif /* MNG_SUPPORT_DISPLAY && MNG_SUPPORT_DYNAMICMNG */
7459
7460
#ifdef MNG_STORE_CHUNKS
7461
if (pData->bStorechunks)
7462
{ /* initialize storage */
7463
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
7464
7465
if (iRetcode) /* on error bail out */
7466
return iRetcode;
7467
7468
if (iRawlen) /* not empty ? */
7469
{
7470
mng_uint32 iX;
7471
mng_uint32 iCount = 0;
7472
mng_uint8p pTemp;
7473
mng_uint8p pNull;
7474
mng_uint32 iLen;
7475
mng_uint8 iEventtype;
7476
mng_uint8 iMasktype;
7477
mng_int32 iLeft;
7478
mng_int32 iRight;
7479
mng_int32 iTop;
7480
mng_int32 iBottom;
7481
mng_uint16 iObjectid;
7482
mng_uint8 iIndex;
7483
mng_uint32 iNamesize;
7484
mng_evnt_entryp pEntry = MNG_NULL;
7485
7486
for (iX = 0; iX < 2; iX++) /* do this twice to get the count first ! */
7487
{
7488
pTemp = pRawdata;
7489
iLen = iRawlen;
7490
7491
if (iX) /* second run ? */
7492
{
7493
MNG_ALLOC (pData, pEntry, (iCount * sizeof (mng_evnt_entry)));
7494
7495
((mng_evntp)*ppChunk)->iCount = iCount;
7496
((mng_evntp)*ppChunk)->pEntries = pEntry;
7497
}
7498
7499
while (iLen) /* anything left ? */
7500
{
7501
iEventtype = *pTemp; /* eventtype */
7502
if (iEventtype > 5)
7503
MNG_ERROR (pData, MNG_INVALIDEVENT);
7504
7505
pTemp++;
7506
7507
iMasktype = *pTemp; /* masktype */
7508
if (iMasktype > 5)
7509
MNG_ERROR (pData, MNG_INVALIDMASK);
7510
7511
pTemp++;
7512
iLen -= 2;
7513
7514
iLeft = 0;
7515
iRight = 0;
7516
iTop = 0;
7517
iBottom = 0;
7518
iObjectid = 0;
7519
iIndex = 0;
7520
7521
switch (iMasktype)
7522
{
7523
case 1 :
7524
{
7525
if (iLen > 16)
7526
{
7527
iLeft = mng_get_int32 (pTemp);
7528
iRight = mng_get_int32 (pTemp+4);
7529
iTop = mng_get_int32 (pTemp+8);
7530
iBottom = mng_get_int32 (pTemp+12);
7531
pTemp += 16;
7532
iLen -= 16;
7533
}
7534
else
7535
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7536
break;
7537
}
7538
case 2 :
7539
{
7540
if (iLen > 2)
7541
{
7542
iObjectid = mng_get_uint16 (pTemp);
7543
pTemp += 2;
7544
iLen -= 2;
7545
}
7546
else
7547
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7548
break;
7549
}
7550
case 3 :
7551
{
7552
if (iLen > 3)
7553
{
7554
iObjectid = mng_get_uint16 (pTemp);
7555
iIndex = *(pTemp+2);
7556
pTemp += 3;
7557
iLen -= 3;
7558
}
7559
else
7560
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7561
break;
7562
}
7563
case 4 :
7564
{
7565
if (iLen > 18)
7566
{
7567
iLeft = mng_get_int32 (pTemp);
7568
iRight = mng_get_int32 (pTemp+4);
7569
iTop = mng_get_int32 (pTemp+8);
7570
iBottom = mng_get_int32 (pTemp+12);
7571
iObjectid = mng_get_uint16 (pTemp+16);
7572
pTemp += 18;
7573
iLen -= 18;
7574
}
7575
else
7576
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7577
break;
7578
}
7579
case 5 :
7580
{
7581
if (iLen > 19)
7582
{
7583
iLeft = mng_get_int32 (pTemp);
7584
iRight = mng_get_int32 (pTemp+4);
7585
iTop = mng_get_int32 (pTemp+8);
7586
iBottom = mng_get_int32 (pTemp+12);
7587
iObjectid = mng_get_uint16 (pTemp+16);
7588
iIndex = *(pTemp+18);
7589
pTemp += 19;
7590
iLen -= 19;
7591
}
7592
else
7593
MNG_ERROR (pData, MNG_INVALIDLENGTH);
7594
break;
7595
}
7596
}
7597
7598
pNull = find_null (pTemp); /* get the name length */
7599
7600
if ((pNull - pTemp) > (mng_int32)iLen)
7601
{
7602
iNamesize = iLen; /* no null found; so end of evNT */
7603
iLen = 0;
7604
}
7605
else
7606
{
7607
iNamesize = pNull - pTemp; /* should be another entry */
7608
iLen = iLen - iNamesize - 1;
7609
7610
if (!iLen) /* must not end with a null ! */
7611
MNG_ERROR (pData, MNG_ENDWITHNULL);
7612
}
7613
7614
if (!iX)
7615
{
7616
iCount++;
7617
}
7618
else
7619
{
7620
pEntry->iEventtype = iEventtype;
7621
pEntry->iMasktype = iMasktype;
7622
pEntry->iLeft = iLeft;
7623
pEntry->iRight = iRight;
7624
pEntry->iTop = iTop;
7625
pEntry->iBottom = iBottom;
7626
pEntry->iObjectid = iObjectid;
7627
pEntry->iIndex = iIndex;
7628
pEntry->iSegmentnamesize = iNamesize;
7629
7630
if (iNamesize)
7631
{
7632
MNG_ALLOC (pData, pEntry->zSegmentname, iNamesize+1);
7633
MNG_COPY (pEntry->zSegmentname, pTemp, iNamesize);
7634
}
7635
7636
pEntry++;
7637
}
7638
7639
pTemp = pTemp + iNamesize + 1;
7640
}
7641
}
7642
}
7643
}
7644
#endif /* MNG_STORE_CHUNKS */
7645
7646
#ifdef MNG_SUPPORT_TRACE
7647
MNG_TRACE (pData, MNG_FN_READ_EVNT, MNG_LC_END);
7648
#endif
7649
7650
return MNG_NOERROR; /* done */
7651
}
7652
#endif
7653
#endif
7654
7655
/* ************************************************************************** */
7656
7657
#ifndef MNG_OPTIMIZE_CHUNKREADER
7658
READ_CHUNK (mng_read_unknown)
7659
{
7660
#ifdef MNG_SUPPORT_TRACE
7661
MNG_TRACE (pData, MNG_FN_READ_UNKNOWN, MNG_LC_START);
7662
#endif
7663
/* sequence checks */
7664
#ifdef MNG_INCLUDE_JNG
7665
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
7666
(!pData->bHasBASI) && (!pData->bHasDHDR) && (!pData->bHasJHDR))
7667
#else
7668
if ((!pData->bHasMHDR) && (!pData->bHasIHDR) &&
7669
(!pData->bHasBASI) && (!pData->bHasDHDR) )
7670
#endif
7671
MNG_ERROR (pData, MNG_SEQUENCEERROR);
7672
/* critical chunk ? */
7673
if ((((mng_uint32)pData->iChunkname & 0x20000000) == 0)
7674
#ifdef MNG_SKIPCHUNK_SAVE
7675
&& (pData->iChunkname != MNG_UINT_SAVE)
7676
#endif
7677
#ifdef MNG_SKIPCHUNK_SEEK
7678
&& (pData->iChunkname != MNG_UINT_SEEK)
7679
#endif
7680
#ifdef MNG_SKIPCHUNK_DBYK
7681
&& (pData->iChunkname != MNG_UINT_DBYK)
7682
#endif
7683
#ifdef MNG_SKIPCHUNK_ORDR
7684
&& (pData->iChunkname != MNG_UINT_ORDR)
7685
#endif
7686
)
7687
MNG_ERROR (pData, MNG_UNKNOWNCRITICAL);
7688
7689
if (pData->fProcessunknown) /* let the app handle it ? */
7690
{
7691
mng_bool bOke = pData->fProcessunknown ((mng_handle)pData, pData->iChunkname,
7692
iRawlen, (mng_ptr)pRawdata);
7693
7694
if (!bOke)
7695
MNG_ERROR (pData, MNG_APPMISCERROR);
7696
}
7697
7698
#ifdef MNG_STORE_CHUNKS
7699
if (pData->bStorechunks)
7700
{ /* initialize storage */
7701
mng_retcode iRetcode = ((mng_chunk_headerp)pHeader)->fCreate (pData, pHeader, ppChunk);
7702
7703
if (iRetcode) /* on error bail out */
7704
return iRetcode;
7705
/* store the length */
7706
((mng_chunk_headerp)*ppChunk)->iChunkname = pData->iChunkname;
7707
((mng_unknown_chunkp)*ppChunk)->iDatasize = iRawlen;
7708
7709
if (iRawlen == 0) /* any data at all ? */
7710
((mng_unknown_chunkp)*ppChunk)->pData = 0;
7711
else
7712
{ /* then store it */
7713
MNG_ALLOC (pData, ((mng_unknown_chunkp)*ppChunk)->pData, iRawlen);
7714
MNG_COPY (((mng_unknown_chunkp)*ppChunk)->pData, pRawdata, iRawlen);
7715
}
7716
}
7717
#endif /* MNG_STORE_CHUNKS */
7718
7719
#ifdef MNG_SUPPORT_TRACE
7720
MNG_TRACE (pData, MNG_FN_READ_UNKNOWN, MNG_LC_END);
7721
#endif
7722
7723
return MNG_NOERROR; /* done */
7724
}
7725
#endif
7726
7727
/* ************************************************************************** */
7728
7729
#endif /* MNG_INCLUDE_READ_PROCS */
7730
7731
/* ************************************************************************** */
7732
/* * * */
7733
/* * chunk write functions * */
7734
/* * * */
7735
/* ************************************************************************** */
7736
7737
#ifdef MNG_INCLUDE_WRITE_PROCS
7738
7739
/* ************************************************************************** */
7740
7741
WRITE_CHUNK (mng_write_ihdr)
7742
{
7743
mng_ihdrp pIHDR;
7744
mng_uint8p pRawdata;
7745
mng_uint32 iRawlen;
7746
mng_retcode iRetcode;
7747
7748
#ifdef MNG_SUPPORT_TRACE
7749
MNG_TRACE (pData, MNG_FN_WRITE_IHDR, MNG_LC_START);
7750
#endif
7751
7752
pIHDR = (mng_ihdrp)pChunk; /* address the proper chunk */
7753
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7754
iRawlen = 13;
7755
/* fill the output buffer */
7756
mng_put_uint32 (pRawdata, pIHDR->iWidth);
7757
mng_put_uint32 (pRawdata+4, pIHDR->iHeight);
7758
7759
*(pRawdata+8) = pIHDR->iBitdepth;
7760
*(pRawdata+9) = pIHDR->iColortype;
7761
*(pRawdata+10) = pIHDR->iCompression;
7762
*(pRawdata+11) = pIHDR->iFilter;
7763
*(pRawdata+12) = pIHDR->iInterlace;
7764
/* and write it */
7765
iRetcode = write_raw_chunk (pData, pIHDR->sHeader.iChunkname, iRawlen, pRawdata);
7766
7767
#ifdef MNG_SUPPORT_TRACE
7768
MNG_TRACE (pData, MNG_FN_WRITE_IHDR, MNG_LC_END);
7769
#endif
7770
7771
return iRetcode;
7772
}
7773
7774
/* ************************************************************************** */
7775
7776
WRITE_CHUNK (mng_write_plte)
7777
{
7778
mng_pltep pPLTE;
7779
mng_uint8p pRawdata;
7780
mng_uint32 iRawlen;
7781
mng_retcode iRetcode;
7782
mng_uint8p pTemp;
7783
mng_uint32 iX;
7784
7785
#ifdef MNG_SUPPORT_TRACE
7786
MNG_TRACE (pData, MNG_FN_WRITE_PLTE, MNG_LC_START);
7787
#endif
7788
7789
pPLTE = (mng_pltep)pChunk; /* address the proper chunk */
7790
7791
if (pPLTE->bEmpty) /* write empty chunk ? */
7792
iRetcode = write_raw_chunk (pData, pPLTE->sHeader.iChunkname, 0, 0);
7793
else
7794
{
7795
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7796
iRawlen = pPLTE->iEntrycount * 3;
7797
/* fill the output buffer */
7798
pTemp = pRawdata;
7799
7800
for (iX = 0; iX < pPLTE->iEntrycount; iX++)
7801
{
7802
*pTemp = pPLTE->aEntries [iX].iRed;
7803
*(pTemp+1) = pPLTE->aEntries [iX].iGreen;
7804
*(pTemp+2) = pPLTE->aEntries [iX].iBlue;
7805
7806
pTemp += 3;
7807
}
7808
/* and write it */
7809
iRetcode = write_raw_chunk (pData, pPLTE->sHeader.iChunkname, iRawlen, pRawdata);
7810
}
7811
7812
#ifdef MNG_SUPPORT_TRACE
7813
MNG_TRACE (pData, MNG_FN_WRITE_PLTE, MNG_LC_END);
7814
#endif
7815
7816
return iRetcode;
7817
}
7818
7819
/* ************************************************************************** */
7820
7821
WRITE_CHUNK (mng_write_idat)
7822
{
7823
mng_idatp pIDAT;
7824
mng_retcode iRetcode;
7825
7826
#ifdef MNG_SUPPORT_TRACE
7827
MNG_TRACE (pData, MNG_FN_WRITE_IDAT, MNG_LC_START);
7828
#endif
7829
7830
pIDAT = (mng_idatp)pChunk; /* address the proper chunk */
7831
7832
if (pIDAT->bEmpty) /* and write it */
7833
iRetcode = write_raw_chunk (pData, pIDAT->sHeader.iChunkname, 0, 0);
7834
else
7835
iRetcode = write_raw_chunk (pData, pIDAT->sHeader.iChunkname,
7836
pIDAT->iDatasize, pIDAT->pData);
7837
7838
#ifdef MNG_SUPPORT_TRACE
7839
MNG_TRACE (pData, MNG_FN_WRITE_IDAT, MNG_LC_END);
7840
#endif
7841
7842
return iRetcode;
7843
}
7844
7845
/* ************************************************************************** */
7846
7847
WRITE_CHUNK (mng_write_iend)
7848
{
7849
mng_iendp pIEND;
7850
mng_retcode iRetcode;
7851
7852
#ifdef MNG_SUPPORT_TRACE
7853
MNG_TRACE (pData, MNG_FN_WRITE_IEND, MNG_LC_START);
7854
#endif
7855
7856
pIEND = (mng_iendp)pChunk; /* address the proper chunk */
7857
/* and write it */
7858
iRetcode = write_raw_chunk (pData, pIEND->sHeader.iChunkname, 0, 0);
7859
7860
#ifdef MNG_SUPPORT_TRACE
7861
MNG_TRACE (pData, MNG_FN_WRITE_IEND, MNG_LC_END);
7862
#endif
7863
7864
return iRetcode;
7865
}
7866
7867
/* ************************************************************************** */
7868
7869
WRITE_CHUNK (mng_write_trns)
7870
{
7871
mng_trnsp pTRNS;
7872
mng_uint8p pRawdata;
7873
mng_uint32 iRawlen;
7874
mng_retcode iRetcode;
7875
mng_uint8p pTemp;
7876
mng_uint32 iX;
7877
7878
#ifdef MNG_SUPPORT_TRACE
7879
MNG_TRACE (pData, MNG_FN_WRITE_TRNS, MNG_LC_START);
7880
#endif
7881
7882
pTRNS = (mng_trnsp)pChunk; /* address the proper chunk */
7883
7884
if (pTRNS->bEmpty) /* write empty chunk ? */
7885
iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname, 0, 0);
7886
else
7887
if (pTRNS->bGlobal) /* write global chunk ? */
7888
iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname,
7889
pTRNS->iRawlen, (mng_uint8p)pTRNS->aRawdata);
7890
else
7891
{
7892
pRawdata = pData->pWritebuf+8; /* init output buffer */
7893
iRawlen = 0; /* and default size */
7894
7895
switch (pTRNS->iType)
7896
{
7897
case 0: {
7898
iRawlen = 2; /* fill the size & output buffer */
7899
mng_put_uint16 (pRawdata, pTRNS->iGray);
7900
7901
break;
7902
}
7903
case 2: {
7904
iRawlen = 6; /* fill the size & output buffer */
7905
mng_put_uint16 (pRawdata, pTRNS->iRed);
7906
mng_put_uint16 (pRawdata+2, pTRNS->iGreen);
7907
mng_put_uint16 (pRawdata+4, pTRNS->iBlue);
7908
7909
break;
7910
}
7911
case 3: { /* init output buffer size */
7912
iRawlen = pTRNS->iCount;
7913
7914
pTemp = pRawdata; /* fill the output buffer */
7915
7916
for (iX = 0; iX < pTRNS->iCount; iX++)
7917
{
7918
*pTemp = pTRNS->aEntries[iX];
7919
pTemp++;
7920
}
7921
7922
break;
7923
}
7924
}
7925
/* write the chunk */
7926
iRetcode = write_raw_chunk (pData, pTRNS->sHeader.iChunkname,
7927
iRawlen, pRawdata);
7928
}
7929
7930
#ifdef MNG_SUPPORT_TRACE
7931
MNG_TRACE (pData, MNG_FN_WRITE_TRNS, MNG_LC_END);
7932
#endif
7933
7934
return iRetcode;
7935
}
7936
7937
/* ************************************************************************** */
7938
7939
WRITE_CHUNK (mng_write_gama)
7940
{
7941
mng_gamap pGAMA;
7942
mng_uint8p pRawdata;
7943
mng_uint32 iRawlen;
7944
mng_retcode iRetcode;
7945
7946
#ifdef MNG_SUPPORT_TRACE
7947
MNG_TRACE (pData, MNG_FN_WRITE_GAMA, MNG_LC_START);
7948
#endif
7949
7950
pGAMA = (mng_gamap)pChunk; /* address the proper chunk */
7951
7952
if (pGAMA->bEmpty) /* write empty ? */
7953
iRetcode = write_raw_chunk (pData, pGAMA->sHeader.iChunkname, 0, 0);
7954
else
7955
{
7956
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7957
iRawlen = 4;
7958
/* fill the buffer */
7959
mng_put_uint32 (pRawdata, pGAMA->iGamma);
7960
/* and write it */
7961
iRetcode = write_raw_chunk (pData, pGAMA->sHeader.iChunkname,
7962
iRawlen, pRawdata);
7963
}
7964
7965
#ifdef MNG_SUPPORT_TRACE
7966
MNG_TRACE (pData, MNG_FN_WRITE_GAMA, MNG_LC_END);
7967
#endif
7968
7969
return iRetcode;
7970
}
7971
7972
/* ************************************************************************** */
7973
7974
#ifndef MNG_SKIPCHUNK_cHRM
7975
WRITE_CHUNK (mng_write_chrm)
7976
{
7977
mng_chrmp pCHRM;
7978
mng_uint8p pRawdata;
7979
mng_uint32 iRawlen;
7980
mng_retcode iRetcode;
7981
7982
#ifdef MNG_SUPPORT_TRACE
7983
MNG_TRACE (pData, MNG_FN_WRITE_CHRM, MNG_LC_START);
7984
#endif
7985
7986
pCHRM = (mng_chrmp)pChunk; /* address the proper chunk */
7987
7988
if (pCHRM->bEmpty) /* write empty ? */
7989
iRetcode = write_raw_chunk (pData, pCHRM->sHeader.iChunkname, 0, 0);
7990
else
7991
{
7992
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
7993
iRawlen = 32;
7994
/* fill the buffer */
7995
mng_put_uint32 (pRawdata, pCHRM->iWhitepointx);
7996
mng_put_uint32 (pRawdata+4, pCHRM->iWhitepointy);
7997
mng_put_uint32 (pRawdata+8, pCHRM->iRedx);
7998
mng_put_uint32 (pRawdata+12, pCHRM->iRedy);
7999
mng_put_uint32 (pRawdata+16, pCHRM->iGreenx);
8000
mng_put_uint32 (pRawdata+20, pCHRM->iGreeny);
8001
mng_put_uint32 (pRawdata+24, pCHRM->iBluex);
8002
mng_put_uint32 (pRawdata+28, pCHRM->iBluey);
8003
/* and write it */
8004
iRetcode = write_raw_chunk (pData, pCHRM->sHeader.iChunkname,
8005
iRawlen, pRawdata);
8006
}
8007
8008
#ifdef MNG_SUPPORT_TRACE
8009
MNG_TRACE (pData, MNG_FN_WRITE_CHRM, MNG_LC_END);
8010
#endif
8011
8012
return iRetcode;
8013
}
8014
#endif
8015
8016
/* ************************************************************************** */
8017
8018
WRITE_CHUNK (mng_write_srgb)
8019
{
8020
mng_srgbp pSRGB;
8021
mng_uint8p pRawdata;
8022
mng_uint32 iRawlen;
8023
mng_retcode iRetcode;
8024
8025
#ifdef MNG_SUPPORT_TRACE
8026
MNG_TRACE (pData, MNG_FN_WRITE_SRGB, MNG_LC_START);
8027
#endif
8028
8029
pSRGB = (mng_srgbp)pChunk; /* address the proper chunk */
8030
8031
if (pSRGB->bEmpty) /* write empty ? */
8032
iRetcode = write_raw_chunk (pData, pSRGB->sHeader.iChunkname, 0, 0);
8033
else
8034
{
8035
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8036
iRawlen = 1;
8037
/* fill the buffer */
8038
*pRawdata = pSRGB->iRenderingintent;
8039
/* and write it */
8040
iRetcode = write_raw_chunk (pData, pSRGB->sHeader.iChunkname,
8041
iRawlen, pRawdata);
8042
}
8043
8044
#ifdef MNG_SUPPORT_TRACE
8045
MNG_TRACE (pData, MNG_FN_WRITE_SRGB, MNG_LC_END);
8046
#endif
8047
8048
return iRetcode;
8049
}
8050
8051
/* ************************************************************************** */
8052
8053
#ifndef MNG_SKIPCHUNK_iCCP
8054
WRITE_CHUNK (mng_write_iccp)
8055
{
8056
mng_iccpp pICCP;
8057
mng_uint8p pRawdata;
8058
mng_uint32 iRawlen;
8059
mng_retcode iRetcode;
8060
mng_uint8p pTemp;
8061
mng_uint8p pBuf = 0;
8062
mng_uint32 iBuflen;
8063
mng_uint32 iReallen;
8064
8065
#ifdef MNG_SUPPORT_TRACE
8066
MNG_TRACE (pData, MNG_FN_WRITE_ICCP, MNG_LC_START);
8067
#endif
8068
8069
pICCP = (mng_iccpp)pChunk; /* address the proper chunk */
8070
8071
if (pICCP->bEmpty) /* write empty ? */
8072
iRetcode = write_raw_chunk (pData, pICCP->sHeader.iChunkname, 0, 0);
8073
else
8074
{ /* compress the profile */
8075
iRetcode = deflate_buffer (pData, pICCP->pProfile, pICCP->iProfilesize,
8076
&pBuf, &iBuflen, &iReallen);
8077
8078
if (!iRetcode) /* still oke ? */
8079
{
8080
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8081
iRawlen = pICCP->iNamesize + 2 + iReallen;
8082
/* requires large buffer ? */
8083
if (iRawlen > pData->iWritebufsize)
8084
MNG_ALLOC (pData, pRawdata, iRawlen);
8085
8086
pTemp = pRawdata; /* fill the buffer */
8087
8088
if (pICCP->iNamesize)
8089
{
8090
MNG_COPY (pTemp, pICCP->zName, pICCP->iNamesize);
8091
pTemp += pICCP->iNamesize;
8092
}
8093
8094
*pTemp = 0;
8095
*(pTemp+1) = pICCP->iCompression;
8096
pTemp += 2;
8097
8098
if (iReallen)
8099
MNG_COPY (pTemp, pBuf, iReallen);
8100
/* and write it */
8101
iRetcode = write_raw_chunk (pData, pICCP->sHeader.iChunkname,
8102
iRawlen, pRawdata);
8103
/* drop the temp buffer ? */
8104
if (iRawlen > pData->iWritebufsize)
8105
MNG_FREEX (pData, pRawdata, iRawlen);
8106
8107
}
8108
8109
MNG_FREEX (pData, pBuf, iBuflen); /* always drop the extra buffer */
8110
}
8111
8112
#ifdef MNG_SUPPORT_TRACE
8113
MNG_TRACE (pData, MNG_FN_WRITE_ICCP, MNG_LC_END);
8114
#endif
8115
8116
return iRetcode;
8117
}
8118
#endif
8119
8120
/* ************************************************************************** */
8121
8122
#ifndef MNG_SKIPCHUNK_tEXt
8123
WRITE_CHUNK (mng_write_text)
8124
{
8125
mng_textp pTEXT;
8126
mng_uint8p pRawdata;
8127
mng_uint32 iRawlen;
8128
mng_retcode iRetcode;
8129
mng_uint8p pTemp;
8130
8131
#ifdef MNG_SUPPORT_TRACE
8132
MNG_TRACE (pData, MNG_FN_WRITE_TEXT, MNG_LC_START);
8133
#endif
8134
8135
pTEXT = (mng_textp)pChunk; /* address the proper chunk */
8136
8137
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8138
iRawlen = pTEXT->iKeywordsize + 1 + pTEXT->iTextsize;
8139
/* requires large buffer ? */
8140
if (iRawlen > pData->iWritebufsize)
8141
MNG_ALLOC (pData, pRawdata, iRawlen);
8142
8143
pTemp = pRawdata; /* fill the buffer */
8144
8145
if (pTEXT->iKeywordsize)
8146
{
8147
MNG_COPY (pTemp, pTEXT->zKeyword, pTEXT->iKeywordsize);
8148
pTemp += pTEXT->iKeywordsize;
8149
}
8150
8151
*pTemp = 0;
8152
pTemp += 1;
8153
8154
if (pTEXT->iTextsize)
8155
MNG_COPY (pTemp, pTEXT->zText, pTEXT->iTextsize);
8156
/* and write it */
8157
iRetcode = write_raw_chunk (pData, pTEXT->sHeader.iChunkname,
8158
iRawlen, pRawdata);
8159
8160
if (iRawlen > pData->iWritebufsize) /* drop the temp buffer ? */
8161
MNG_FREEX (pData, pRawdata, iRawlen);
8162
8163
#ifdef MNG_SUPPORT_TRACE
8164
MNG_TRACE (pData, MNG_FN_WRITE_TEXT, MNG_LC_END);
8165
#endif
8166
8167
return iRetcode;
8168
}
8169
#endif
8170
8171
/* ************************************************************************** */
8172
8173
#ifndef MNG_SKIPCHUNK_zTXt
8174
WRITE_CHUNK (mng_write_ztxt)
8175
{
8176
mng_ztxtp pZTXT;
8177
mng_uint8p pRawdata;
8178
mng_uint32 iRawlen;
8179
mng_retcode iRetcode;
8180
mng_uint8p pTemp;
8181
mng_uint8p pBuf = 0;
8182
mng_uint32 iBuflen;
8183
mng_uint32 iReallen;
8184
8185
#ifdef MNG_SUPPORT_TRACE
8186
MNG_TRACE (pData, MNG_FN_WRITE_ZTXT, MNG_LC_START);
8187
#endif
8188
8189
pZTXT = (mng_ztxtp)pChunk; /* address the proper chunk */
8190
/* compress the text */
8191
iRetcode = deflate_buffer (pData, (mng_uint8p)pZTXT->zText, pZTXT->iTextsize,
8192
&pBuf, &iBuflen, &iReallen);
8193
8194
if (!iRetcode) /* all ok ? */
8195
{
8196
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8197
iRawlen = pZTXT->iKeywordsize + 2 + iReallen;
8198
/* requires large buffer ? */
8199
if (iRawlen > pData->iWritebufsize)
8200
MNG_ALLOC (pData, pRawdata, iRawlen);
8201
8202
pTemp = pRawdata; /* fill the buffer */
8203
8204
if (pZTXT->iKeywordsize)
8205
{
8206
MNG_COPY (pTemp, pZTXT->zKeyword, pZTXT->iKeywordsize);
8207
pTemp += pZTXT->iKeywordsize;
8208
}
8209
8210
*pTemp = 0; /* terminator zero */
8211
pTemp++;
8212
*pTemp = 0; /* compression type */
8213
pTemp++;
8214
8215
if (iReallen)
8216
MNG_COPY (pTemp, pBuf, iReallen);
8217
/* and write it */
8218
iRetcode = write_raw_chunk (pData, pZTXT->sHeader.iChunkname,
8219
iRawlen, pRawdata);
8220
/* drop the temp buffer ? */
8221
if (iRawlen > pData->iWritebufsize)
8222
MNG_FREEX (pData, pRawdata, iRawlen);
8223
8224
}
8225
8226
MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
8227
8228
#ifdef MNG_SUPPORT_TRACE
8229
MNG_TRACE (pData, MNG_FN_WRITE_ZTXT, MNG_LC_END);
8230
#endif
8231
8232
return iRetcode;
8233
}
8234
#endif
8235
8236
/* ************************************************************************** */
8237
8238
#ifndef MNG_SKIPCHUNK_iTXt
8239
WRITE_CHUNK (mng_write_itxt)
8240
{
8241
mng_itxtp pITXT;
8242
mng_uint8p pRawdata;
8243
mng_uint32 iRawlen;
8244
mng_retcode iRetcode;
8245
mng_uint8p pTemp;
8246
mng_uint8p pBuf = 0;
8247
mng_uint32 iBuflen;
8248
mng_uint32 iReallen;
8249
8250
#ifdef MNG_SUPPORT_TRACE
8251
MNG_TRACE (pData, MNG_FN_WRITE_ITXT, MNG_LC_START);
8252
#endif
8253
8254
pITXT = (mng_itxtp)pChunk; /* address the proper chunk */
8255
8256
if (pITXT->iCompressionflag) /* compress the text */
8257
iRetcode = deflate_buffer (pData, (mng_uint8p)pITXT->zText, pITXT->iTextsize,
8258
&pBuf, &iBuflen, &iReallen);
8259
else
8260
iRetcode = MNG_NOERROR;
8261
8262
if (!iRetcode) /* all ok ? */
8263
{
8264
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8265
iRawlen = pITXT->iKeywordsize + pITXT->iLanguagesize +
8266
pITXT->iTranslationsize + 5;
8267
8268
if (pITXT->iCompressionflag)
8269
iRawlen = iRawlen + iReallen;
8270
else
8271
iRawlen = iRawlen + pITXT->iTextsize;
8272
/* requires large buffer ? */
8273
if (iRawlen > pData->iWritebufsize)
8274
MNG_ALLOC (pData, pRawdata, iRawlen);
8275
8276
pTemp = pRawdata; /* fill the buffer */
8277
8278
if (pITXT->iKeywordsize)
8279
{
8280
MNG_COPY (pTemp, pITXT->zKeyword, pITXT->iKeywordsize);
8281
pTemp += pITXT->iKeywordsize;
8282
}
8283
8284
*pTemp = 0;
8285
pTemp++;
8286
*pTemp = pITXT->iCompressionflag;
8287
pTemp++;
8288
*pTemp = pITXT->iCompressionmethod;
8289
pTemp++;
8290
8291
if (pITXT->iLanguagesize)
8292
{
8293
MNG_COPY (pTemp, pITXT->zLanguage, pITXT->iLanguagesize);
8294
pTemp += pITXT->iLanguagesize;
8295
}
8296
8297
*pTemp = 0;
8298
pTemp++;
8299
8300
if (pITXT->iTranslationsize)
8301
{
8302
MNG_COPY (pTemp, pITXT->zTranslation, pITXT->iTranslationsize);
8303
pTemp += pITXT->iTranslationsize;
8304
}
8305
8306
*pTemp = 0;
8307
pTemp++;
8308
8309
if (pITXT->iCompressionflag)
8310
{
8311
if (iReallen)
8312
MNG_COPY (pTemp, pBuf, iReallen);
8313
}
8314
else
8315
{
8316
if (pITXT->iTextsize)
8317
MNG_COPY (pTemp, pITXT->zText, pITXT->iTextsize);
8318
}
8319
/* and write it */
8320
iRetcode = write_raw_chunk (pData, pITXT->sHeader.iChunkname,
8321
iRawlen, pRawdata);
8322
/* drop the temp buffer ? */
8323
if (iRawlen > pData->iWritebufsize)
8324
MNG_FREEX (pData, pRawdata, iRawlen);
8325
8326
}
8327
8328
MNG_FREEX (pData, pBuf, iBuflen); /* always drop the compression buffer */
8329
8330
if (iRetcode) /* on error bail out */
8331
return iRetcode;
8332
8333
#ifdef MNG_SUPPORT_TRACE
8334
MNG_TRACE (pData, MNG_FN_WRITE_ITXT, MNG_LC_END);
8335
#endif
8336
8337
return MNG_NOERROR;
8338
}
8339
#endif
8340
8341
/* ************************************************************************** */
8342
8343
#ifndef MNG_SKIPCHUNK_bKGD
8344
WRITE_CHUNK (mng_write_bkgd)
8345
{
8346
mng_bkgdp pBKGD;
8347
mng_uint8p pRawdata;
8348
mng_uint32 iRawlen;
8349
mng_retcode iRetcode;
8350
8351
#ifdef MNG_SUPPORT_TRACE
8352
MNG_TRACE (pData, MNG_FN_WRITE_BKGD, MNG_LC_START);
8353
#endif
8354
8355
pBKGD = (mng_bkgdp)pChunk; /* address the proper chunk */
8356
8357
if (pBKGD->bEmpty) /* write empty ? */
8358
iRetcode = write_raw_chunk (pData, pBKGD->sHeader.iChunkname, 0, 0);
8359
else
8360
{
8361
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8362
iRawlen = 0; /* and default size */
8363
8364
switch (pBKGD->iType)
8365
{
8366
case 0: { /* gray */
8367
iRawlen = 2; /* fill the size & output buffer */
8368
mng_put_uint16 (pRawdata, pBKGD->iGray);
8369
8370
break;
8371
}
8372
case 2: { /* rgb */
8373
iRawlen = 6; /* fill the size & output buffer */
8374
mng_put_uint16 (pRawdata, pBKGD->iRed);
8375
mng_put_uint16 (pRawdata+2, pBKGD->iGreen);
8376
mng_put_uint16 (pRawdata+4, pBKGD->iBlue);
8377
8378
break;
8379
}
8380
case 3: { /* indexed */
8381
iRawlen = 1; /* fill the size & output buffer */
8382
*pRawdata = pBKGD->iIndex;
8383
8384
break;
8385
}
8386
}
8387
/* and write it */
8388
iRetcode = write_raw_chunk (pData, pBKGD->sHeader.iChunkname,
8389
iRawlen, pRawdata);
8390
}
8391
8392
#ifdef MNG_SUPPORT_TRACE
8393
MNG_TRACE (pData, MNG_FN_WRITE_BKGD, MNG_LC_END);
8394
#endif
8395
8396
return iRetcode;
8397
}
8398
#endif
8399
8400
/* ************************************************************************** */
8401
8402
#ifndef MNG_SKIPCHUNK_pHYs
8403
WRITE_CHUNK (mng_write_phys)
8404
{
8405
mng_physp pPHYS;
8406
mng_uint8p pRawdata;
8407
mng_uint32 iRawlen;
8408
mng_retcode iRetcode;
8409
8410
#ifdef MNG_SUPPORT_TRACE
8411
MNG_TRACE (pData, MNG_FN_WRITE_PHYS, MNG_LC_START);
8412
#endif
8413
8414
pPHYS = (mng_physp)pChunk; /* address the proper chunk */
8415
8416
if (pPHYS->bEmpty) /* write empty ? */
8417
iRetcode = write_raw_chunk (pData, pPHYS->sHeader.iChunkname, 0, 0);
8418
else
8419
{
8420
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8421
iRawlen = 9;
8422
/* fill the output buffer */
8423
mng_put_uint32 (pRawdata, pPHYS->iSizex);
8424
mng_put_uint32 (pRawdata+4, pPHYS->iSizey);
8425
8426
*(pRawdata+8) = pPHYS->iUnit;
8427
/* and write it */
8428
iRetcode = write_raw_chunk (pData, pPHYS->sHeader.iChunkname,
8429
iRawlen, pRawdata);
8430
}
8431
8432
#ifdef MNG_SUPPORT_TRACE
8433
MNG_TRACE (pData, MNG_FN_WRITE_PHYS, MNG_LC_END);
8434
#endif
8435
8436
return iRetcode;
8437
}
8438
#endif
8439
8440
/* ************************************************************************** */
8441
8442
#ifndef MNG_SKIPCHUNK_sBIT
8443
WRITE_CHUNK (mng_write_sbit)
8444
{
8445
mng_sbitp pSBIT;
8446
mng_uint8p pRawdata;
8447
mng_uint32 iRawlen;
8448
mng_retcode iRetcode;
8449
8450
#ifdef MNG_SUPPORT_TRACE
8451
MNG_TRACE (pData, MNG_FN_WRITE_SBIT, MNG_LC_START);
8452
#endif
8453
8454
pSBIT = (mng_sbitp)pChunk; /* address the proper chunk */
8455
8456
if (pSBIT->bEmpty) /* write empty ? */
8457
iRetcode = write_raw_chunk (pData, pSBIT->sHeader.iChunkname, 0, 0);
8458
else
8459
{
8460
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8461
iRawlen = 0; /* and default size */
8462
8463
switch (pSBIT->iType)
8464
{
8465
case 0: { /* gray */
8466
iRawlen = 1; /* fill the size & output buffer */
8467
*pRawdata = pSBIT->aBits[0];
8468
8469
break;
8470
}
8471
case 2: { /* rgb */
8472
iRawlen = 3; /* fill the size & output buffer */
8473
*pRawdata = pSBIT->aBits[0];
8474
*(pRawdata+1) = pSBIT->aBits[1];
8475
*(pRawdata+2) = pSBIT->aBits[2];
8476
8477
break;
8478
}
8479
case 3: { /* indexed */
8480
iRawlen = 3; /* fill the size & output buffer */
8481
*pRawdata = pSBIT->aBits[0];
8482
*pRawdata = pSBIT->aBits[1];
8483
*pRawdata = pSBIT->aBits[2];
8484
8485
break;
8486
}
8487
case 4: { /* gray + alpha */
8488
iRawlen = 2; /* fill the size & output buffer */
8489
*pRawdata = pSBIT->aBits[0];
8490
*(pRawdata+1) = pSBIT->aBits[1];
8491
8492
break;
8493
}
8494
case 6: { /* rgb + alpha */
8495
iRawlen = 4; /* fill the size & output buffer */
8496
*pRawdata = pSBIT->aBits[0];
8497
*(pRawdata+1) = pSBIT->aBits[1];
8498
*(pRawdata+2) = pSBIT->aBits[2];
8499
*(pRawdata+3) = pSBIT->aBits[3];
8500
8501
break;
8502
}
8503
case 10: { /* jpeg gray */
8504
iRawlen = 1; /* fill the size & output buffer */
8505
*pRawdata = pSBIT->aBits[0];
8506
8507
break;
8508
}
8509
case 12: { /* jpeg rgb */
8510
iRawlen = 3; /* fill the size & output buffer */
8511
*pRawdata = pSBIT->aBits[0];
8512
*(pRawdata+1) = pSBIT->aBits[1];
8513
*(pRawdata+2) = pSBIT->aBits[2];
8514
8515
break;
8516
}
8517
case 14: { /* jpeg gray + alpha */
8518
iRawlen = 2; /* fill the size & output buffer */
8519
*pRawdata = pSBIT->aBits[0];
8520
*(pRawdata+1) = pSBIT->aBits[1];
8521
8522
break;
8523
}
8524
case 16: { /* jpeg rgb + alpha */
8525
iRawlen = 4; /* fill the size & output buffer */
8526
*pRawdata = pSBIT->aBits[0];
8527
*(pRawdata+1) = pSBIT->aBits[1];
8528
*(pRawdata+2) = pSBIT->aBits[2];
8529
*(pRawdata+3) = pSBIT->aBits[3];
8530
8531
break;
8532
}
8533
}
8534
/* and write it */
8535
iRetcode = write_raw_chunk (pData, pSBIT->sHeader.iChunkname,
8536
iRawlen, pRawdata);
8537
}
8538
8539
#ifdef MNG_SUPPORT_TRACE
8540
MNG_TRACE (pData, MNG_FN_WRITE_SBIT, MNG_LC_END);
8541
#endif
8542
8543
return iRetcode;
8544
}
8545
#endif
8546
8547
/* ************************************************************************** */
8548
8549
#ifndef MNG_SKIPCHUNK_sPLT
8550
WRITE_CHUNK (mng_write_splt)
8551
{
8552
mng_spltp pSPLT;
8553
mng_uint8p pRawdata;
8554
mng_uint32 iRawlen;
8555
mng_retcode iRetcode;
8556
mng_uint32 iEntrieslen;
8557
mng_uint8p pTemp;
8558
8559
#ifdef MNG_SUPPORT_TRACE
8560
MNG_TRACE (pData, MNG_FN_WRITE_SPLT, MNG_LC_START);
8561
#endif
8562
8563
pSPLT = (mng_spltp)pChunk; /* address the proper chunk */
8564
8565
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8566
iEntrieslen = ((pSPLT->iSampledepth >> 3) * 4 + 2) * pSPLT->iEntrycount;
8567
iRawlen = pSPLT->iNamesize + 2 + iEntrieslen;
8568
/* requires large buffer ? */
8569
if (iRawlen > pData->iWritebufsize)
8570
MNG_ALLOC (pData, pRawdata, iRawlen);
8571
8572
pTemp = pRawdata; /* fill the buffer */
8573
8574
if (pSPLT->iNamesize)
8575
{
8576
MNG_COPY (pTemp, pSPLT->zName, pSPLT->iNamesize);
8577
pTemp += pSPLT->iNamesize;
8578
}
8579
8580
*pTemp = 0;
8581
*(pTemp+1) = pSPLT->iSampledepth;
8582
pTemp += 2;
8583
8584
if (pSPLT->iEntrycount)
8585
MNG_COPY (pTemp, pSPLT->pEntries, iEntrieslen);
8586
/* and write it */
8587
iRetcode = write_raw_chunk (pData, pSPLT->sHeader.iChunkname,
8588
iRawlen, pRawdata);
8589
8590
if (iRawlen > pData->iWritebufsize) /* drop the temp buffer ? */
8591
MNG_FREEX (pData, pRawdata, iRawlen);
8592
8593
#ifdef MNG_SUPPORT_TRACE
8594
MNG_TRACE (pData, MNG_FN_WRITE_SPLT, MNG_LC_END);
8595
#endif
8596
8597
return iRetcode;
8598
}
8599
#endif
8600
8601
/* ************************************************************************** */
8602
8603
#ifndef MNG_SKIPCHUNK_hIST
8604
WRITE_CHUNK (mng_write_hist)
8605
{
8606
mng_histp pHIST;
8607
mng_uint8p pRawdata;
8608
mng_uint32 iRawlen;
8609
mng_retcode iRetcode;
8610
mng_uint8p pTemp;
8611
mng_uint32 iX;
8612
8613
#ifdef MNG_SUPPORT_TRACE
8614
MNG_TRACE (pData, MNG_FN_WRITE_HIST, MNG_LC_START);
8615
#endif
8616
8617
pHIST = (mng_histp)pChunk; /* address the proper chunk */
8618
8619
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8620
iRawlen = pHIST->iEntrycount << 1;
8621
8622
pTemp = pRawdata; /* fill the output buffer */
8623
8624
for (iX = 0; iX < pHIST->iEntrycount; iX++)
8625
{
8626
mng_put_uint16 (pTemp, pHIST->aEntries [iX]);
8627
pTemp += 2;
8628
}
8629
/* and write it */
8630
iRetcode = write_raw_chunk (pData, pHIST->sHeader.iChunkname,
8631
iRawlen, pRawdata);
8632
8633
#ifdef MNG_SUPPORT_TRACE
8634
MNG_TRACE (pData, MNG_FN_WRITE_HIST, MNG_LC_END);
8635
#endif
8636
8637
return iRetcode;
8638
}
8639
#endif
8640
8641
/* ************************************************************************** */
8642
8643
#ifndef MNG_SKIPCHUNK_tIME
8644
WRITE_CHUNK (mng_write_time)
8645
{
8646
mng_timep pTIME;
8647
mng_uint8p pRawdata;
8648
mng_uint32 iRawlen;
8649
mng_retcode iRetcode;
8650
8651
#ifdef MNG_SUPPORT_TRACE
8652
MNG_TRACE (pData, MNG_FN_WRITE_TIME, MNG_LC_START);
8653
#endif
8654
8655
pTIME = (mng_timep)pChunk; /* address the proper chunk */
8656
8657
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8658
iRawlen = 7;
8659
/* fill the output buffer */
8660
mng_put_uint16 (pRawdata, pTIME->iYear);
8661
8662
*(pRawdata+2) = pTIME->iMonth;
8663
*(pRawdata+3) = pTIME->iDay;
8664
*(pRawdata+4) = pTIME->iHour;
8665
*(pRawdata+5) = pTIME->iMinute;
8666
*(pRawdata+6) = pTIME->iSecond;
8667
/* and write it */
8668
iRetcode = write_raw_chunk (pData, pTIME->sHeader.iChunkname,
8669
iRawlen, pRawdata);
8670
8671
#ifdef MNG_SUPPORT_TRACE
8672
MNG_TRACE (pData, MNG_FN_WRITE_TIME, MNG_LC_END);
8673
#endif
8674
8675
return iRetcode;
8676
}
8677
#endif
8678
8679
/* ************************************************************************** */
8680
8681
WRITE_CHUNK (mng_write_mhdr)
8682
{
8683
mng_mhdrp pMHDR;
8684
mng_uint8p pRawdata;
8685
mng_uint32 iRawlen;
8686
mng_retcode iRetcode;
8687
8688
#ifdef MNG_SUPPORT_TRACE
8689
MNG_TRACE (pData, MNG_FN_WRITE_MHDR, MNG_LC_START);
8690
#endif
8691
8692
pMHDR = (mng_mhdrp)pChunk; /* address the proper chunk */
8693
8694
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8695
iRawlen = 28;
8696
/* fill the output buffer */
8697
mng_put_uint32 (pRawdata, pMHDR->iWidth);
8698
mng_put_uint32 (pRawdata+4, pMHDR->iHeight);
8699
mng_put_uint32 (pRawdata+8, pMHDR->iTicks);
8700
mng_put_uint32 (pRawdata+12, pMHDR->iLayercount);
8701
mng_put_uint32 (pRawdata+16, pMHDR->iFramecount);
8702
mng_put_uint32 (pRawdata+20, pMHDR->iPlaytime);
8703
mng_put_uint32 (pRawdata+24, pMHDR->iSimplicity);
8704
8705
/* and write it */
8706
iRetcode = write_raw_chunk (pData, pMHDR->sHeader.iChunkname,
8707
iRawlen, pRawdata);
8708
8709
#ifdef MNG_SUPPORT_TRACE
8710
MNG_TRACE (pData, MNG_FN_WRITE_MHDR, MNG_LC_END);
8711
#endif
8712
8713
return iRetcode;
8714
}
8715
8716
/* ************************************************************************** */
8717
8718
WRITE_CHUNK (mng_write_mend)
8719
{
8720
mng_mendp pMEND;
8721
mng_retcode iRetcode;
8722
8723
#ifdef MNG_SUPPORT_TRACE
8724
MNG_TRACE (pData, MNG_FN_WRITE_MEND, MNG_LC_START);
8725
#endif
8726
8727
pMEND = (mng_mendp)pChunk; /* address the proper chunk */
8728
/* and write it */
8729
iRetcode = write_raw_chunk (pData, pMEND->sHeader.iChunkname, 0, 0);
8730
8731
#ifdef MNG_SUPPORT_TRACE
8732
MNG_TRACE (pData, MNG_FN_WRITE_MEND, MNG_LC_END);
8733
#endif
8734
8735
return iRetcode;
8736
}
8737
8738
/* ************************************************************************** */
8739
8740
WRITE_CHUNK (mng_write_loop)
8741
{
8742
mng_loopp pLOOP;
8743
mng_uint8p pRawdata;
8744
mng_uint32 iRawlen;
8745
mng_retcode iRetcode;
8746
#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
8747
mng_uint8p pTemp1;
8748
mng_uint32p pTemp2;
8749
mng_uint32 iX;
8750
#endif
8751
8752
#ifdef MNG_SUPPORT_TRACE
8753
MNG_TRACE (pData, MNG_FN_WRITE_LOOP, MNG_LC_START);
8754
#endif
8755
8756
pLOOP = (mng_loopp)pChunk; /* address the proper chunk */
8757
8758
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8759
iRawlen = 5;
8760
/* fill the output buffer */
8761
*pRawdata = pLOOP->iLevel;
8762
mng_put_uint32 (pRawdata+1, pLOOP->iRepeat);
8763
8764
if (pLOOP->iTermination)
8765
{
8766
iRawlen++;
8767
*(pRawdata+5) = pLOOP->iTermination;
8768
8769
if ((pLOOP->iCount) ||
8770
(pLOOP->iItermin != 1) || (pLOOP->iItermax != 0x7FFFFFFFL))
8771
{
8772
iRawlen += 8;
8773
8774
mng_put_uint32 (pRawdata+6, pLOOP->iItermin);
8775
mng_put_uint32 (pRawdata+10, pLOOP->iItermax);
8776
8777
#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
8778
if (pLOOP->iCount)
8779
{
8780
iRawlen += pLOOP->iCount * 4;
8781
8782
pTemp1 = pRawdata+14;
8783
pTemp2 = pLOOP->pSignals;
8784
8785
for (iX = 0; iX < pLOOP->iCount; iX++)
8786
{
8787
mng_put_uint32 (pTemp1, *pTemp2);
8788
8789
pTemp1 += 4;
8790
pTemp2++;
8791
}
8792
}
8793
#endif
8794
}
8795
}
8796
/* and write it */
8797
iRetcode = write_raw_chunk (pData, pLOOP->sHeader.iChunkname,
8798
iRawlen, pRawdata);
8799
8800
#ifdef MNG_SUPPORT_TRACE
8801
MNG_TRACE (pData, MNG_FN_WRITE_LOOP, MNG_LC_END);
8802
#endif
8803
8804
return iRetcode;
8805
}
8806
8807
/* ************************************************************************** */
8808
8809
WRITE_CHUNK (mng_write_endl)
8810
{
8811
mng_endlp pENDL;
8812
mng_uint8p pRawdata;
8813
mng_uint32 iRawlen;
8814
mng_retcode iRetcode;
8815
8816
#ifdef MNG_SUPPORT_TRACE
8817
MNG_TRACE (pData, MNG_FN_WRITE_ENDL, MNG_LC_START);
8818
#endif
8819
8820
pENDL = (mng_endlp)pChunk; /* address the proper chunk */
8821
8822
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8823
iRawlen = 1;
8824
8825
*pRawdata = pENDL->iLevel; /* fill the output buffer */
8826
/* and write it */
8827
iRetcode = write_raw_chunk (pData, pENDL->sHeader.iChunkname,
8828
iRawlen, pRawdata);
8829
8830
#ifdef MNG_SUPPORT_TRACE
8831
MNG_TRACE (pData, MNG_FN_WRITE_ENDL, MNG_LC_END);
8832
#endif
8833
8834
return iRetcode;
8835
}
8836
8837
/* ************************************************************************** */
8838
8839
WRITE_CHUNK (mng_write_defi)
8840
{
8841
mng_defip pDEFI;
8842
mng_uint8p pRawdata;
8843
mng_uint32 iRawlen;
8844
mng_retcode iRetcode;
8845
8846
#ifdef MNG_SUPPORT_TRACE
8847
MNG_TRACE (pData, MNG_FN_WRITE_DEFI, MNG_LC_START);
8848
#endif
8849
8850
pDEFI = (mng_defip)pChunk; /* address the proper chunk */
8851
8852
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8853
iRawlen = 2;
8854
/* fill the output buffer */
8855
mng_put_uint16 (pRawdata, pDEFI->iObjectid);
8856
8857
if ((pDEFI->iDonotshow) || (pDEFI->iConcrete) || (pDEFI->bHasloca) || (pDEFI->bHasclip))
8858
{
8859
iRawlen++;
8860
*(pRawdata+2) = pDEFI->iDonotshow;
8861
8862
if ((pDEFI->iConcrete) || (pDEFI->bHasloca) || (pDEFI->bHasclip))
8863
{
8864
iRawlen++;
8865
*(pRawdata+3) = pDEFI->iConcrete;
8866
8867
if ((pDEFI->bHasloca) || (pDEFI->bHasclip))
8868
{
8869
iRawlen += 8;
8870
8871
mng_put_uint32 (pRawdata+4, pDEFI->iXlocation);
8872
mng_put_uint32 (pRawdata+8, pDEFI->iYlocation);
8873
8874
if (pDEFI->bHasclip)
8875
{
8876
iRawlen += 16;
8877
8878
mng_put_uint32 (pRawdata+12, pDEFI->iLeftcb);
8879
mng_put_uint32 (pRawdata+16, pDEFI->iRightcb);
8880
mng_put_uint32 (pRawdata+20, pDEFI->iTopcb);
8881
mng_put_uint32 (pRawdata+24, pDEFI->iBottomcb);
8882
}
8883
}
8884
}
8885
}
8886
/* and write it */
8887
iRetcode = write_raw_chunk (pData, pDEFI->sHeader.iChunkname,
8888
iRawlen, pRawdata);
8889
8890
#ifdef MNG_SUPPORT_TRACE
8891
MNG_TRACE (pData, MNG_FN_WRITE_DEFI, MNG_LC_END);
8892
#endif
8893
8894
return iRetcode;
8895
}
8896
8897
/* ************************************************************************** */
8898
8899
WRITE_CHUNK (mng_write_basi)
8900
{
8901
mng_basip pBASI;
8902
mng_uint8p pRawdata;
8903
mng_uint32 iRawlen;
8904
mng_retcode iRetcode;
8905
mng_bool bOpaque;
8906
8907
#ifdef MNG_SUPPORT_TRACE
8908
MNG_TRACE (pData, MNG_FN_WRITE_BASI, MNG_LC_START);
8909
#endif
8910
8911
pBASI = (mng_basip)pChunk; /* address the proper chunk */
8912
8913
#ifndef MNG_NO_16BIT_SUPPORT
8914
if (pBASI->iBitdepth <= 8) /* determine opacity alpha-field */
8915
#endif
8916
bOpaque = (mng_bool)(pBASI->iAlpha == 0xFF);
8917
#ifndef MNG_NO_16BIT_SUPPORT
8918
else
8919
bOpaque = (mng_bool)(pBASI->iAlpha == 0xFFFF);
8920
#endif
8921
8922
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8923
iRawlen = 13;
8924
/* fill the output buffer */
8925
mng_put_uint32 (pRawdata, pBASI->iWidth);
8926
mng_put_uint32 (pRawdata+4, pBASI->iHeight);
8927
8928
*(pRawdata+8) = pBASI->iBitdepth;
8929
*(pRawdata+9) = pBASI->iColortype;
8930
*(pRawdata+10) = pBASI->iCompression;
8931
*(pRawdata+11) = pBASI->iFilter;
8932
*(pRawdata+12) = pBASI->iInterlace;
8933
8934
if ((pBASI->iRed) || (pBASI->iGreen) || (pBASI->iBlue) ||
8935
(!bOpaque) || (pBASI->iViewable))
8936
{
8937
iRawlen += 6;
8938
mng_put_uint16 (pRawdata+13, pBASI->iRed);
8939
mng_put_uint16 (pRawdata+15, pBASI->iGreen);
8940
mng_put_uint16 (pRawdata+17, pBASI->iBlue);
8941
8942
if ((!bOpaque) || (pBASI->iViewable))
8943
{
8944
iRawlen += 2;
8945
mng_put_uint16 (pRawdata+19, pBASI->iAlpha);
8946
8947
if (pBASI->iViewable)
8948
{
8949
iRawlen++;
8950
*(pRawdata+21) = pBASI->iViewable;
8951
}
8952
}
8953
}
8954
/* and write it */
8955
iRetcode = write_raw_chunk (pData, pBASI->sHeader.iChunkname,
8956
iRawlen, pRawdata);
8957
8958
#ifdef MNG_SUPPORT_TRACE
8959
MNG_TRACE (pData, MNG_FN_WRITE_BASI, MNG_LC_END);
8960
#endif
8961
8962
return iRetcode;
8963
}
8964
8965
/* ************************************************************************** */
8966
8967
WRITE_CHUNK (mng_write_clon)
8968
{
8969
mng_clonp pCLON;
8970
mng_uint8p pRawdata;
8971
mng_uint32 iRawlen;
8972
mng_retcode iRetcode;
8973
8974
#ifdef MNG_SUPPORT_TRACE
8975
MNG_TRACE (pData, MNG_FN_WRITE_CLON, MNG_LC_START);
8976
#endif
8977
8978
pCLON = (mng_clonp)pChunk; /* address the proper chunk */
8979
8980
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
8981
iRawlen = 4;
8982
/* fill the output buffer */
8983
mng_put_uint16 (pRawdata, pCLON->iSourceid);
8984
mng_put_uint16 (pRawdata+2, pCLON->iCloneid);
8985
8986
if ((pCLON->iClonetype) || (pCLON->iDonotshow) || (pCLON->iConcrete) || (pCLON->bHasloca))
8987
{
8988
iRawlen++;
8989
*(pRawdata+4) = pCLON->iClonetype;
8990
8991
if ((pCLON->iDonotshow) || (pCLON->iConcrete) || (pCLON->bHasloca))
8992
{
8993
iRawlen++;
8994
*(pRawdata+5) = pCLON->iDonotshow;
8995
8996
if ((pCLON->iConcrete) || (pCLON->bHasloca))
8997
{
8998
iRawlen++;
8999
*(pRawdata+6) = pCLON->iConcrete;
9000
9001
if (pCLON->bHasloca)
9002
{
9003
iRawlen += 9;
9004
*(pRawdata+7) = pCLON->iLocationtype;
9005
mng_put_int32 (pRawdata+8, pCLON->iLocationx);
9006
mng_put_int32 (pRawdata+12, pCLON->iLocationy);
9007
}
9008
}
9009
}
9010
}
9011
/* and write it */
9012
iRetcode = write_raw_chunk (pData, pCLON->sHeader.iChunkname,
9013
iRawlen, pRawdata);
9014
9015
#ifdef MNG_SUPPORT_TRACE
9016
MNG_TRACE (pData, MNG_FN_WRITE_CLON, MNG_LC_END);
9017
#endif
9018
9019
return iRetcode;
9020
}
9021
9022
/* ************************************************************************** */
9023
9024
#ifndef MNG_SKIPCHUNK_PAST
9025
WRITE_CHUNK (mng_write_past)
9026
{
9027
mng_pastp pPAST;
9028
mng_uint8p pRawdata;
9029
mng_uint32 iRawlen;
9030
mng_retcode iRetcode;
9031
mng_past_sourcep pSource;
9032
mng_uint32 iX;
9033
mng_uint8p pTemp;
9034
9035
#ifdef MNG_SUPPORT_TRACE
9036
MNG_TRACE (pData, MNG_FN_WRITE_PAST, MNG_LC_START);
9037
#endif
9038
9039
pPAST = (mng_pastp)pChunk; /* address the proper chunk */
9040
9041
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9042
iRawlen = 11 + (30 * pPAST->iCount);
9043
/* requires large buffer ? */
9044
if (iRawlen > pData->iWritebufsize)
9045
MNG_ALLOC (pData, pRawdata, iRawlen);
9046
/* fill the output buffer */
9047
mng_put_uint16 (pRawdata, pPAST->iDestid);
9048
9049
*(pRawdata+2) = pPAST->iTargettype;
9050
9051
mng_put_int32 (pRawdata+3, pPAST->iTargetx);
9052
mng_put_int32 (pRawdata+7, pPAST->iTargety);
9053
9054
pTemp = pRawdata+11;
9055
pSource = pPAST->pSources;
9056
9057
for (iX = 0; iX < pPAST->iCount; iX++)
9058
{
9059
mng_put_uint16 (pTemp, pSource->iSourceid);
9060
9061
*(pTemp+2) = pSource->iComposition;
9062
*(pTemp+3) = pSource->iOrientation;
9063
*(pTemp+4) = pSource->iOffsettype;
9064
9065
mng_put_int32 (pTemp+5, pSource->iOffsetx);
9066
mng_put_int32 (pTemp+9, pSource->iOffsety);
9067
9068
*(pTemp+13) = pSource->iBoundarytype;
9069
9070
mng_put_int32 (pTemp+14, pSource->iBoundaryl);
9071
mng_put_int32 (pTemp+18, pSource->iBoundaryr);
9072
mng_put_int32 (pTemp+22, pSource->iBoundaryt);
9073
mng_put_int32 (pTemp+26, pSource->iBoundaryb);
9074
9075
pSource++;
9076
pTemp += 30;
9077
}
9078
/* and write it */
9079
iRetcode = write_raw_chunk (pData, pPAST->sHeader.iChunkname,
9080
iRawlen, pRawdata);
9081
/* free temporary buffer ? */
9082
if (iRawlen > pData->iWritebufsize)
9083
MNG_FREEX (pData, pRawdata, iRawlen);
9084
9085
#ifdef MNG_SUPPORT_TRACE
9086
MNG_TRACE (pData, MNG_FN_WRITE_PAST, MNG_LC_END);
9087
#endif
9088
9089
return iRetcode;
9090
}
9091
#endif
9092
9093
/* ************************************************************************** */
9094
9095
WRITE_CHUNK (mng_write_disc)
9096
{
9097
mng_discp pDISC;
9098
mng_uint8p pRawdata;
9099
mng_uint32 iRawlen;
9100
mng_retcode iRetcode;
9101
mng_uint32 iX;
9102
mng_uint8p pTemp1;
9103
mng_uint16p pTemp2;
9104
9105
#ifdef MNG_SUPPORT_TRACE
9106
MNG_TRACE (pData, MNG_FN_WRITE_DISC, MNG_LC_START);
9107
#endif
9108
9109
pDISC = (mng_discp)pChunk; /* address the proper chunk */
9110
9111
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9112
iRawlen = pDISC->iCount << 1;
9113
9114
pTemp1 = pRawdata; /* fill the output buffer */
9115
pTemp2 = pDISC->pObjectids;
9116
9117
for (iX = 0; iX < pDISC->iCount; iX++)
9118
{
9119
mng_put_uint16 (pTemp1, *pTemp2);
9120
9121
pTemp2++;
9122
pTemp1 += 2;
9123
}
9124
/* and write it */
9125
iRetcode = write_raw_chunk (pData, pDISC->sHeader.iChunkname,
9126
iRawlen, pRawdata);
9127
9128
#ifdef MNG_SUPPORT_TRACE
9129
MNG_TRACE (pData, MNG_FN_WRITE_DISC, MNG_LC_END);
9130
#endif
9131
9132
return iRetcode;
9133
}
9134
9135
/* ************************************************************************** */
9136
9137
WRITE_CHUNK (mng_write_back)
9138
{
9139
mng_backp pBACK;
9140
mng_uint8p pRawdata;
9141
mng_uint32 iRawlen;
9142
mng_retcode iRetcode;
9143
9144
#ifdef MNG_SUPPORT_TRACE
9145
MNG_TRACE (pData, MNG_FN_WRITE_BACK, MNG_LC_START);
9146
#endif
9147
9148
pBACK = (mng_backp)pChunk; /* address the proper chunk */
9149
9150
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9151
iRawlen = 6;
9152
/* fill the output buffer */
9153
mng_put_uint16 (pRawdata, pBACK->iRed);
9154
mng_put_uint16 (pRawdata+2, pBACK->iGreen);
9155
mng_put_uint16 (pRawdata+4, pBACK->iBlue);
9156
9157
if ((pBACK->iMandatory) || (pBACK->iImageid) || (pBACK->iTile))
9158
{
9159
iRawlen++;
9160
*(pRawdata+6) = pBACK->iMandatory;
9161
9162
if ((pBACK->iImageid) || (pBACK->iTile))
9163
{
9164
iRawlen += 2;
9165
mng_put_uint16 (pRawdata+7, pBACK->iImageid);
9166
9167
if (pBACK->iTile)
9168
{
9169
iRawlen++;
9170
*(pRawdata+9) = pBACK->iTile;
9171
}
9172
}
9173
}
9174
/* and write it */
9175
iRetcode = write_raw_chunk (pData, pBACK->sHeader.iChunkname,
9176
iRawlen, pRawdata);
9177
9178
#ifdef MNG_SUPPORT_TRACE
9179
MNG_TRACE (pData, MNG_FN_WRITE_BACK, MNG_LC_END);
9180
#endif
9181
9182
return iRetcode;
9183
}
9184
9185
/* ************************************************************************** */
9186
9187
WRITE_CHUNK (mng_write_fram)
9188
{
9189
mng_framp pFRAM;
9190
mng_uint8p pRawdata;
9191
mng_uint32 iRawlen;
9192
mng_retcode iRetcode;
9193
mng_uint8p pTemp;
9194
mng_uint32p pTemp2;
9195
mng_uint32 iX;
9196
9197
#ifdef MNG_SUPPORT_TRACE
9198
MNG_TRACE (pData, MNG_FN_WRITE_FRAM, MNG_LC_START);
9199
#endif
9200
9201
pFRAM = (mng_framp)pChunk; /* address the proper chunk */
9202
9203
if (pFRAM->bEmpty) /* empty ? */
9204
iRetcode = write_raw_chunk (pData, pFRAM->sHeader.iChunkname, 0, 0);
9205
else
9206
{
9207
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9208
iRawlen = 1;
9209
/* fill the output buffer */
9210
*pRawdata = pFRAM->iMode;
9211
9212
if ((pFRAM->iNamesize ) ||
9213
(pFRAM->iChangedelay ) || (pFRAM->iChangetimeout) ||
9214
(pFRAM->iChangeclipping) || (pFRAM->iChangesyncid ) )
9215
{
9216
if (pFRAM->iNamesize)
9217
MNG_COPY (pRawdata+1, pFRAM->zName, pFRAM->iNamesize);
9218
9219
iRawlen += pFRAM->iNamesize;
9220
pTemp = pRawdata + pFRAM->iNamesize + 1;
9221
9222
if ((pFRAM->iChangedelay ) || (pFRAM->iChangetimeout) ||
9223
(pFRAM->iChangeclipping) || (pFRAM->iChangesyncid ) )
9224
{
9225
*pTemp = 0;
9226
*(pTemp+1) = pFRAM->iChangedelay;
9227
*(pTemp+2) = pFRAM->iChangetimeout;
9228
*(pTemp+3) = pFRAM->iChangeclipping;
9229
*(pTemp+4) = pFRAM->iChangesyncid;
9230
9231
iRawlen += 5;
9232
pTemp += 5;
9233
9234
if (pFRAM->iChangedelay)
9235
{
9236
mng_put_uint32 (pTemp, pFRAM->iDelay);
9237
iRawlen += 4;
9238
pTemp += 4;
9239
}
9240
9241
if (pFRAM->iChangetimeout)
9242
{
9243
mng_put_uint32 (pTemp, pFRAM->iTimeout);
9244
iRawlen += 4;
9245
pTemp += 4;
9246
}
9247
9248
if (pFRAM->iChangeclipping)
9249
{
9250
*pTemp = pFRAM->iBoundarytype;
9251
9252
mng_put_uint32 (pTemp+1, pFRAM->iBoundaryl);
9253
mng_put_uint32 (pTemp+5, pFRAM->iBoundaryr);
9254
mng_put_uint32 (pTemp+9, pFRAM->iBoundaryt);
9255
mng_put_uint32 (pTemp+13, pFRAM->iBoundaryb);
9256
9257
iRawlen += 17;
9258
pTemp += 17;
9259
}
9260
9261
if (pFRAM->iChangesyncid)
9262
{
9263
iRawlen += pFRAM->iCount * 4;
9264
pTemp2 = pFRAM->pSyncids;
9265
9266
for (iX = 0; iX < pFRAM->iCount; iX++)
9267
{
9268
mng_put_uint32 (pTemp, *pTemp2);
9269
9270
pTemp2++;
9271
pTemp += 4;
9272
}
9273
}
9274
}
9275
}
9276
/* and write it */
9277
iRetcode = write_raw_chunk (pData, pFRAM->sHeader.iChunkname,
9278
iRawlen, pRawdata);
9279
}
9280
9281
#ifdef MNG_SUPPORT_TRACE
9282
MNG_TRACE (pData, MNG_FN_WRITE_FRAM, MNG_LC_END);
9283
#endif
9284
9285
return iRetcode;
9286
}
9287
9288
/* ************************************************************************** */
9289
9290
WRITE_CHUNK (mng_write_move)
9291
{
9292
mng_movep pMOVE;
9293
mng_uint8p pRawdata;
9294
mng_uint32 iRawlen;
9295
mng_retcode iRetcode;
9296
9297
#ifdef MNG_SUPPORT_TRACE
9298
MNG_TRACE (pData, MNG_FN_WRITE_MOVE, MNG_LC_START);
9299
#endif
9300
9301
pMOVE = (mng_movep)pChunk; /* address the proper chunk */
9302
9303
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9304
iRawlen = 13;
9305
/* fill the output buffer */
9306
mng_put_uint16 (pRawdata, pMOVE->iFirstid);
9307
mng_put_uint16 (pRawdata+2, pMOVE->iLastid);
9308
9309
*(pRawdata+4) = pMOVE->iMovetype;
9310
9311
mng_put_int32 (pRawdata+5, pMOVE->iMovex);
9312
mng_put_int32 (pRawdata+9, pMOVE->iMovey);
9313
/* and write it */
9314
iRetcode = write_raw_chunk (pData, pMOVE->sHeader.iChunkname,
9315
iRawlen, pRawdata);
9316
9317
#ifdef MNG_SUPPORT_TRACE
9318
MNG_TRACE (pData, MNG_FN_WRITE_MOVE, MNG_LC_END);
9319
#endif
9320
9321
return iRetcode;
9322
}
9323
9324
/* ************************************************************************** */
9325
9326
WRITE_CHUNK (mng_write_clip)
9327
{
9328
mng_clipp pCLIP;
9329
mng_uint8p pRawdata;
9330
mng_uint32 iRawlen;
9331
mng_retcode iRetcode;
9332
9333
#ifdef MNG_SUPPORT_TRACE
9334
MNG_TRACE (pData, MNG_FN_WRITE_CLIP, MNG_LC_START);
9335
#endif
9336
9337
pCLIP = (mng_clipp)pChunk; /* address the proper chunk */
9338
9339
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9340
iRawlen = 21;
9341
/* fill the output buffer */
9342
mng_put_uint16 (pRawdata, pCLIP->iFirstid);
9343
mng_put_uint16 (pRawdata+2, pCLIP->iLastid);
9344
9345
*(pRawdata+4) = pCLIP->iCliptype;
9346
9347
mng_put_int32 (pRawdata+5, pCLIP->iClipl);
9348
mng_put_int32 (pRawdata+9, pCLIP->iClipr);
9349
mng_put_int32 (pRawdata+13, pCLIP->iClipt);
9350
mng_put_int32 (pRawdata+17, pCLIP->iClipb);
9351
/* and write it */
9352
iRetcode = write_raw_chunk (pData, pCLIP->sHeader.iChunkname,
9353
iRawlen, pRawdata);
9354
9355
#ifdef MNG_SUPPORT_TRACE
9356
MNG_TRACE (pData, MNG_FN_WRITE_CLIP, MNG_LC_END);
9357
#endif
9358
9359
return iRetcode;
9360
}
9361
9362
/* ************************************************************************** */
9363
9364
WRITE_CHUNK (mng_write_show)
9365
{
9366
mng_showp pSHOW;
9367
mng_uint8p pRawdata;
9368
mng_uint32 iRawlen;
9369
mng_retcode iRetcode;
9370
9371
#ifdef MNG_SUPPORT_TRACE
9372
MNG_TRACE (pData, MNG_FN_WRITE_SHOW, MNG_LC_START);
9373
#endif
9374
9375
pSHOW = (mng_showp)pChunk; /* address the proper chunk */
9376
9377
if (pSHOW->bEmpty) /* empty ? */
9378
iRetcode = write_raw_chunk (pData, pSHOW->sHeader.iChunkname, 0, 0);
9379
else
9380
{
9381
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9382
iRawlen = 2;
9383
/* fill the output buffer */
9384
mng_put_uint16 (pRawdata, pSHOW->iFirstid);
9385
9386
if ((pSHOW->iLastid != pSHOW->iFirstid) || (pSHOW->iMode))
9387
{
9388
iRawlen += 2;
9389
mng_put_uint16 (pRawdata+2, pSHOW->iLastid);
9390
9391
if (pSHOW->iMode)
9392
{
9393
iRawlen++;
9394
*(pRawdata+4) = pSHOW->iMode;
9395
}
9396
}
9397
/* and write it */
9398
iRetcode = write_raw_chunk (pData, pSHOW->sHeader.iChunkname,
9399
iRawlen, pRawdata);
9400
}
9401
9402
#ifdef MNG_SUPPORT_TRACE
9403
MNG_TRACE (pData, MNG_FN_WRITE_SHOW, MNG_LC_END);
9404
#endif
9405
9406
return iRetcode;
9407
}
9408
9409
/* ************************************************************************** */
9410
9411
WRITE_CHUNK (mng_write_term)
9412
{
9413
mng_termp pTERM;
9414
mng_uint8p pRawdata;
9415
mng_uint32 iRawlen;
9416
mng_retcode iRetcode;
9417
9418
#ifdef MNG_SUPPORT_TRACE
9419
MNG_TRACE (pData, MNG_FN_WRITE_TERM, MNG_LC_START);
9420
#endif
9421
9422
pTERM = (mng_termp)pChunk; /* address the proper chunk */
9423
9424
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9425
iRawlen = 1;
9426
9427
*pRawdata = pTERM->iTermaction; /* fill the output buffer */
9428
9429
if (pTERM->iTermaction == 3)
9430
{
9431
iRawlen = 10;
9432
*(pRawdata+1) = pTERM->iIteraction;
9433
9434
mng_put_uint32 (pRawdata+2, pTERM->iDelay);
9435
mng_put_uint32 (pRawdata+6, pTERM->iItermax);
9436
}
9437
/* and write it */
9438
iRetcode = write_raw_chunk (pData, pTERM->sHeader.iChunkname,
9439
iRawlen, pRawdata);
9440
9441
#ifdef MNG_SUPPORT_TRACE
9442
MNG_TRACE (pData, MNG_FN_WRITE_TERM, MNG_LC_END);
9443
#endif
9444
9445
return iRetcode;
9446
}
9447
9448
/* ************************************************************************** */
9449
9450
#ifndef MNG_SKIPCHUNK_SAVE
9451
WRITE_CHUNK (mng_write_save)
9452
{
9453
mng_savep pSAVE;
9454
mng_uint8p pRawdata;
9455
mng_uint32 iRawlen;
9456
mng_retcode iRetcode;
9457
mng_save_entryp pEntry;
9458
mng_uint32 iEntrysize;
9459
mng_uint8p pTemp;
9460
mng_uint32 iX;
9461
9462
#ifdef MNG_SUPPORT_TRACE
9463
MNG_TRACE (pData, MNG_FN_WRITE_SAVE, MNG_LC_START);
9464
#endif
9465
9466
pSAVE = (mng_savep)pChunk; /* address the proper chunk */
9467
9468
if (pSAVE->bEmpty) /* empty ? */
9469
iRetcode = write_raw_chunk (pData, pSAVE->sHeader.iChunkname, 0, 0);
9470
else
9471
{
9472
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9473
iRawlen = 1;
9474
9475
*pRawdata = pSAVE->iOffsettype; /* fill the output buffer */
9476
9477
if (pSAVE->iOffsettype == 16)
9478
iEntrysize = 25;
9479
else
9480
iEntrysize = 17;
9481
9482
pTemp = pRawdata+1;
9483
pEntry = pSAVE->pEntries;
9484
9485
for (iX = 0; iX < pSAVE->iCount; iX++)
9486
{
9487
if (iX) /* put separator null-byte, except the first */
9488
{
9489
*pTemp = 0;
9490
pTemp++;
9491
iRawlen++;
9492
}
9493
9494
iRawlen += iEntrysize + pEntry->iNamesize;
9495
*pTemp = pEntry->iEntrytype;
9496
9497
if (pSAVE->iOffsettype == 16)
9498
{
9499
mng_put_uint32 (pTemp+1, pEntry->iOffset[0]);
9500
mng_put_uint32 (pTemp+5, pEntry->iOffset[1]);
9501
mng_put_uint32 (pTemp+9, pEntry->iStarttime[0]);
9502
mng_put_uint32 (pTemp+13, pEntry->iStarttime[1]);
9503
mng_put_uint32 (pTemp+17, pEntry->iLayernr);
9504
mng_put_uint32 (pTemp+21, pEntry->iFramenr);
9505
9506
pTemp += 25;
9507
}
9508
else
9509
{
9510
mng_put_uint32 (pTemp+1, pEntry->iOffset[1]);
9511
mng_put_uint32 (pTemp+5, pEntry->iStarttime[1]);
9512
mng_put_uint32 (pTemp+9, pEntry->iLayernr);
9513
mng_put_uint32 (pTemp+13, pEntry->iFramenr);
9514
9515
pTemp += 17;
9516
}
9517
9518
if (pEntry->iNamesize)
9519
{
9520
MNG_COPY (pTemp, pEntry->zName, pEntry->iNamesize);
9521
pTemp += pEntry->iNamesize;
9522
}
9523
9524
pEntry++;
9525
}
9526
/* and write it */
9527
iRetcode = write_raw_chunk (pData, pSAVE->sHeader.iChunkname,
9528
iRawlen, pRawdata);
9529
}
9530
9531
#ifdef MNG_SUPPORT_TRACE
9532
MNG_TRACE (pData, MNG_FN_WRITE_SAVE, MNG_LC_END);
9533
#endif
9534
9535
return iRetcode;
9536
}
9537
#endif
9538
9539
/* ************************************************************************** */
9540
9541
#ifndef MNG_SKIPCHUNK_SEEK
9542
WRITE_CHUNK (mng_write_seek)
9543
{
9544
mng_seekp pSEEK;
9545
mng_uint8p pRawdata;
9546
mng_uint32 iRawlen;
9547
mng_retcode iRetcode;
9548
9549
#ifdef MNG_SUPPORT_TRACE
9550
MNG_TRACE (pData, MNG_FN_WRITE_SEEK, MNG_LC_START);
9551
#endif
9552
9553
pSEEK = (mng_seekp)pChunk; /* address the proper chunk */
9554
9555
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9556
iRawlen = pSEEK->iNamesize;
9557
9558
if (iRawlen) /* fill the output buffer */
9559
MNG_COPY (pRawdata, pSEEK->zName, iRawlen);
9560
/* and write it */
9561
iRetcode = write_raw_chunk (pData, pSEEK->sHeader.iChunkname,
9562
iRawlen, pRawdata);
9563
9564
#ifdef MNG_SUPPORT_TRACE
9565
MNG_TRACE (pData, MNG_FN_WRITE_SEEK, MNG_LC_END);
9566
#endif
9567
9568
return iRetcode;
9569
}
9570
#endif
9571
9572
/* ************************************************************************** */
9573
9574
#ifndef MNG_SKIPCHUNK_eXPI
9575
WRITE_CHUNK (mng_write_expi)
9576
{
9577
mng_expip pEXPI;
9578
mng_uint8p pRawdata;
9579
mng_uint32 iRawlen;
9580
mng_retcode iRetcode;
9581
9582
#ifdef MNG_SUPPORT_TRACE
9583
MNG_TRACE (pData, MNG_FN_WRITE_EXPI, MNG_LC_START);
9584
#endif
9585
9586
pEXPI = (mng_expip)pChunk; /* address the proper chunk */
9587
9588
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9589
iRawlen = 2 + pEXPI->iNamesize;
9590
/* fill the output buffer */
9591
mng_put_uint16 (pRawdata, pEXPI->iSnapshotid);
9592
9593
if (pEXPI->iNamesize)
9594
MNG_COPY (pRawdata+2, pEXPI->zName, pEXPI->iNamesize);
9595
/* and write it */
9596
iRetcode = write_raw_chunk (pData, pEXPI->sHeader.iChunkname,
9597
iRawlen, pRawdata);
9598
9599
#ifdef MNG_SUPPORT_TRACE
9600
MNG_TRACE (pData, MNG_FN_WRITE_EXPI, MNG_LC_END);
9601
#endif
9602
9603
return iRetcode;
9604
}
9605
#endif
9606
9607
/* ************************************************************************** */
9608
9609
#ifndef MNG_SKIPCHUNK_fPRI
9610
WRITE_CHUNK (mng_write_fpri)
9611
{
9612
mng_fprip pFPRI;
9613
mng_uint8p pRawdata;
9614
mng_uint32 iRawlen;
9615
mng_retcode iRetcode;
9616
9617
#ifdef MNG_SUPPORT_TRACE
9618
MNG_TRACE (pData, MNG_FN_WRITE_FPRI, MNG_LC_START);
9619
#endif
9620
9621
pFPRI = (mng_fprip)pChunk; /* address the proper chunk */
9622
9623
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9624
iRawlen = 2;
9625
9626
*pRawdata = pFPRI->iDeltatype; /* fill the output buffer */
9627
*(pRawdata+1) = pFPRI->iPriority;
9628
/* and write it */
9629
iRetcode = write_raw_chunk (pData, pFPRI->sHeader.iChunkname,
9630
iRawlen, pRawdata);
9631
9632
#ifdef MNG_SUPPORT_TRACE
9633
MNG_TRACE (pData, MNG_FN_WRITE_FPRI, MNG_LC_END);
9634
#endif
9635
9636
return iRetcode;
9637
}
9638
#endif
9639
9640
/* ************************************************************************** */
9641
9642
#ifndef MNG_SKIPCHUNK_nEED
9643
WRITE_CHUNK (mng_write_need)
9644
{
9645
mng_needp pNEED;
9646
mng_uint8p pRawdata;
9647
mng_uint32 iRawlen;
9648
mng_retcode iRetcode;
9649
9650
#ifdef MNG_SUPPORT_TRACE
9651
MNG_TRACE (pData, MNG_FN_WRITE_NEED, MNG_LC_START);
9652
#endif
9653
9654
pNEED = (mng_needp)pChunk; /* address the proper chunk */
9655
9656
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9657
iRawlen = pNEED->iKeywordssize;
9658
/* fill the output buffer */
9659
if (pNEED->iKeywordssize)
9660
MNG_COPY (pRawdata, pNEED->zKeywords, pNEED->iKeywordssize);
9661
/* and write it */
9662
iRetcode = write_raw_chunk (pData, pNEED->sHeader.iChunkname,
9663
iRawlen, pRawdata);
9664
9665
#ifdef MNG_SUPPORT_TRACE
9666
MNG_TRACE (pData, MNG_FN_WRITE_NEED, MNG_LC_END);
9667
#endif
9668
9669
return iRetcode;
9670
}
9671
#endif
9672
9673
/* ************************************************************************** */
9674
9675
#ifndef MNG_SKIPCHUNK_pHYg
9676
WRITE_CHUNK (mng_write_phyg)
9677
{
9678
mng_phygp pPHYG;
9679
mng_uint8p pRawdata;
9680
mng_uint32 iRawlen;
9681
mng_retcode iRetcode;
9682
9683
#ifdef MNG_SUPPORT_TRACE
9684
MNG_TRACE (pData, MNG_FN_WRITE_PHYG, MNG_LC_START);
9685
#endif
9686
9687
pPHYG = (mng_phygp)pChunk; /* address the proper chunk */
9688
9689
if (pPHYG->bEmpty) /* write empty ? */
9690
iRetcode = write_raw_chunk (pData, pPHYG->sHeader.iChunkname, 0, 0);
9691
else
9692
{
9693
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9694
iRawlen = 9;
9695
/* fill the output buffer */
9696
mng_put_uint32 (pRawdata, pPHYG->iSizex);
9697
mng_put_uint32 (pRawdata+4, pPHYG->iSizey);
9698
9699
*(pRawdata+8) = pPHYG->iUnit;
9700
/* and write it */
9701
iRetcode = write_raw_chunk (pData, pPHYG->sHeader.iChunkname,
9702
iRawlen, pRawdata);
9703
}
9704
9705
#ifdef MNG_SUPPORT_TRACE
9706
MNG_TRACE (pData, MNG_FN_WRITE_PHYG, MNG_LC_END);
9707
#endif
9708
9709
return iRetcode;
9710
}
9711
#endif
9712
9713
/* ************************************************************************** */
9714
9715
/* B004 */
9716
#ifdef MNG_INCLUDE_JNG
9717
/* B004 */
9718
WRITE_CHUNK (mng_write_jhdr)
9719
{
9720
mng_jhdrp pJHDR;
9721
mng_uint8p pRawdata;
9722
mng_uint32 iRawlen;
9723
mng_retcode iRetcode;
9724
9725
#ifdef MNG_SUPPORT_TRACE
9726
MNG_TRACE (pData, MNG_FN_WRITE_JHDR, MNG_LC_START);
9727
#endif
9728
9729
pJHDR = (mng_jhdrp)pChunk; /* address the proper chunk */
9730
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9731
iRawlen = 16;
9732
/* fill the output buffer */
9733
mng_put_uint32 (pRawdata, pJHDR->iWidth);
9734
mng_put_uint32 (pRawdata+4, pJHDR->iHeight);
9735
9736
*(pRawdata+8) = pJHDR->iColortype;
9737
*(pRawdata+9) = pJHDR->iImagesampledepth;
9738
*(pRawdata+10) = pJHDR->iImagecompression;
9739
*(pRawdata+11) = pJHDR->iImageinterlace;
9740
*(pRawdata+12) = pJHDR->iAlphasampledepth;
9741
*(pRawdata+13) = pJHDR->iAlphacompression;
9742
*(pRawdata+14) = pJHDR->iAlphafilter;
9743
*(pRawdata+15) = pJHDR->iAlphainterlace;
9744
/* and write it */
9745
iRetcode = write_raw_chunk (pData, pJHDR->sHeader.iChunkname, iRawlen, pRawdata);
9746
9747
#ifdef MNG_SUPPORT_TRACE
9748
MNG_TRACE (pData, MNG_FN_WRITE_JHDR, MNG_LC_END);
9749
#endif
9750
9751
return iRetcode;
9752
}
9753
#else
9754
#define write_jhdr 0
9755
/* B004 */
9756
#endif /* MNG_INCLUDE_JNG */
9757
/* B004 */
9758
9759
/* ************************************************************************** */
9760
9761
#ifdef MNG_INCLUDE_JNG
9762
WRITE_CHUNK (mng_write_jdaa)
9763
{
9764
mng_jdatp pJDAA;
9765
mng_retcode iRetcode;
9766
9767
#ifdef MNG_SUPPORT_TRACE
9768
MNG_TRACE (pData, MNG_FN_WRITE_JDAA, MNG_LC_START);
9769
#endif
9770
9771
pJDAA = (mng_jdaap)pChunk; /* address the proper chunk */
9772
9773
if (pJDAA->bEmpty) /* and write it */
9774
iRetcode = write_raw_chunk (pData, pJDAA->sHeader.iChunkname, 0, 0);
9775
else
9776
iRetcode = write_raw_chunk (pData, pJDAA->sHeader.iChunkname,
9777
pJDAA->iDatasize, pJDAA->pData);
9778
9779
#ifdef MNG_SUPPORT_TRACE
9780
MNG_TRACE (pData, MNG_FN_WRITE_JDAA, MNG_LC_END);
9781
#endif
9782
9783
return iRetcode;
9784
}
9785
#else
9786
#define write_jdaa 0
9787
#endif /* MNG_INCLUDE_JNG */
9788
9789
/* ************************************************************************** */
9790
9791
/* B004 */
9792
#ifdef MNG_INCLUDE_JNG
9793
/* B004 */
9794
WRITE_CHUNK (mng_write_jdat)
9795
{
9796
mng_jdatp pJDAT;
9797
mng_retcode iRetcode;
9798
9799
#ifdef MNG_SUPPORT_TRACE
9800
MNG_TRACE (pData, MNG_FN_WRITE_JDAT, MNG_LC_START);
9801
#endif
9802
9803
pJDAT = (mng_jdatp)pChunk; /* address the proper chunk */
9804
9805
if (pJDAT->bEmpty) /* and write it */
9806
iRetcode = write_raw_chunk (pData, pJDAT->sHeader.iChunkname, 0, 0);
9807
else
9808
iRetcode = write_raw_chunk (pData, pJDAT->sHeader.iChunkname,
9809
pJDAT->iDatasize, pJDAT->pData);
9810
9811
#ifdef MNG_SUPPORT_TRACE
9812
MNG_TRACE (pData, MNG_FN_WRITE_JDAT, MNG_LC_END);
9813
#endif
9814
9815
return iRetcode;
9816
}
9817
#else
9818
#define write_jdat 0
9819
/* B004 */
9820
#endif /* MNG_INCLUDE_JNG */
9821
/* B004 */
9822
9823
/* ************************************************************************** */
9824
9825
/* B004 */
9826
#ifdef MNG_INCLUDE_JNG
9827
/* B004 */
9828
WRITE_CHUNK (mng_write_jsep)
9829
{
9830
mng_jsepp pJSEP;
9831
mng_retcode iRetcode;
9832
9833
#ifdef MNG_SUPPORT_TRACE
9834
MNG_TRACE (pData, MNG_FN_WRITE_JSEP, MNG_LC_START);
9835
#endif
9836
9837
pJSEP = (mng_jsepp)pChunk; /* address the proper chunk */
9838
/* and write it */
9839
iRetcode = write_raw_chunk (pData, pJSEP->sHeader.iChunkname, 0, 0);
9840
9841
#ifdef MNG_SUPPORT_TRACE
9842
MNG_TRACE (pData, MNG_FN_WRITE_JSEP, MNG_LC_END);
9843
#endif
9844
9845
return iRetcode;
9846
}
9847
#else
9848
#define write_jsep 0
9849
/* B004 */
9850
#endif /* MNG_INCLUDE_JNG */
9851
/* B004 */
9852
9853
/* ************************************************************************** */
9854
9855
#ifndef MNG_NO_DELTA_PNG
9856
WRITE_CHUNK (mng_write_dhdr)
9857
{
9858
mng_dhdrp pDHDR;
9859
mng_uint8p pRawdata;
9860
mng_uint32 iRawlen;
9861
mng_retcode iRetcode;
9862
9863
#ifdef MNG_SUPPORT_TRACE
9864
MNG_TRACE (pData, MNG_FN_WRITE_DHDR, MNG_LC_START);
9865
#endif
9866
9867
pDHDR = (mng_dhdrp)pChunk; /* address the proper chunk */
9868
9869
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9870
iRawlen = 4;
9871
/* fill the output buffer */
9872
mng_put_uint16 (pRawdata, pDHDR->iObjectid);
9873
9874
*(pRawdata+2) = pDHDR->iImagetype;
9875
*(pRawdata+3) = pDHDR->iDeltatype;
9876
9877
if (pDHDR->iDeltatype != 7)
9878
{
9879
iRawlen += 8;
9880
mng_put_uint32 (pRawdata+4, pDHDR->iBlockwidth);
9881
mng_put_uint32 (pRawdata+8, pDHDR->iBlockheight);
9882
9883
if (pDHDR->iDeltatype != 0)
9884
{
9885
iRawlen += 8;
9886
mng_put_uint32 (pRawdata+12, pDHDR->iBlockx);
9887
mng_put_uint32 (pRawdata+16, pDHDR->iBlocky);
9888
}
9889
}
9890
/* and write it */
9891
iRetcode = write_raw_chunk (pData, pDHDR->sHeader.iChunkname,
9892
iRawlen, pRawdata);
9893
9894
#ifdef MNG_SUPPORT_TRACE
9895
MNG_TRACE (pData, MNG_FN_WRITE_DHDR, MNG_LC_END);
9896
#endif
9897
9898
return iRetcode;
9899
}
9900
#endif
9901
9902
/* ************************************************************************** */
9903
9904
#ifndef MNG_NO_DELTA_PNG
9905
WRITE_CHUNK (mng_write_prom)
9906
{
9907
mng_promp pPROM;
9908
mng_uint8p pRawdata;
9909
mng_uint32 iRawlen;
9910
mng_retcode iRetcode;
9911
9912
#ifdef MNG_SUPPORT_TRACE
9913
MNG_TRACE (pData, MNG_FN_WRITE_PROM, MNG_LC_START);
9914
#endif
9915
9916
pPROM = (mng_promp)pChunk; /* address the proper chunk */
9917
9918
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9919
iRawlen = 3;
9920
9921
*pRawdata = pPROM->iColortype; /* fill the output buffer */
9922
*(pRawdata+1) = pPROM->iSampledepth;
9923
*(pRawdata+2) = pPROM->iFilltype;
9924
/* and write it */
9925
iRetcode = write_raw_chunk (pData, pPROM->sHeader.iChunkname,
9926
iRawlen, pRawdata);
9927
9928
#ifdef MNG_SUPPORT_TRACE
9929
MNG_TRACE (pData, MNG_FN_WRITE_PROM, MNG_LC_END);
9930
#endif
9931
9932
return iRetcode;
9933
}
9934
#endif
9935
9936
/* ************************************************************************** */
9937
9938
#ifndef MNG_NO_DELTA_PNG
9939
WRITE_CHUNK (mng_write_ipng)
9940
{
9941
mng_ipngp pIPNG;
9942
mng_retcode iRetcode;
9943
9944
#ifdef MNG_SUPPORT_TRACE
9945
MNG_TRACE (pData, MNG_FN_WRITE_IPNG, MNG_LC_START);
9946
#endif
9947
9948
pIPNG = (mng_ipngp)pChunk; /* address the proper chunk */
9949
/* and write it */
9950
iRetcode = write_raw_chunk (pData, pIPNG->sHeader.iChunkname, 0, 0);
9951
9952
#ifdef MNG_SUPPORT_TRACE
9953
MNG_TRACE (pData, MNG_FN_WRITE_IPNG, MNG_LC_END);
9954
#endif
9955
9956
return iRetcode;
9957
}
9958
#endif
9959
9960
/* ************************************************************************** */
9961
9962
#ifndef MNG_NO_DELTA_PNG
9963
WRITE_CHUNK (mng_write_pplt)
9964
{
9965
mng_ppltp pPPLT;
9966
mng_uint8p pRawdata;
9967
mng_uint32 iRawlen;
9968
mng_retcode iRetcode;
9969
mng_pplt_entryp pEntry;
9970
mng_uint8p pTemp;
9971
mng_uint32 iX;
9972
mng_bool bHasgroup;
9973
mng_uint8p pLastid = 0;
9974
9975
#ifdef MNG_SUPPORT_TRACE
9976
MNG_TRACE (pData, MNG_FN_WRITE_PPLT, MNG_LC_START);
9977
#endif
9978
9979
pPPLT = (mng_ppltp)pChunk; /* address the proper chunk */
9980
9981
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
9982
iRawlen = 1;
9983
9984
*pRawdata = pPPLT->iDeltatype; /* fill the output buffer */
9985
9986
pTemp = pRawdata+1;
9987
bHasgroup = MNG_FALSE;
9988
9989
for (iX = 0; iX < pPPLT->iCount; iX++)
9990
{
9991
pEntry = &pPPLT->aEntries[iX];
9992
9993
if (pEntry->bUsed) /* valid entry ? */
9994
{
9995
if (!bHasgroup) /* start a new group ? */
9996
{
9997
bHasgroup = MNG_TRUE;
9998
pLastid = pTemp+1;
9999
10000
*pTemp = (mng_uint8)iX;
10001
*(pTemp+1) = 0;
10002
10003
pTemp += 2;
10004
iRawlen += 2;
10005
}
10006
10007
switch (pPPLT->iDeltatype) /* add group-entry depending on type */
10008
{
10009
case 0: ;
10010
case 1: {
10011
*pTemp = pEntry->iRed;
10012
*(pTemp+1) = pEntry->iGreen;
10013
*(pTemp+2) = pEntry->iBlue;
10014
10015
pTemp += 3;
10016
iRawlen += 3;
10017
10018
break;
10019
}
10020
10021
case 2: ;
10022
case 3: {
10023
*pTemp = pEntry->iAlpha;
10024
10025
pTemp++;
10026
iRawlen++;
10027
10028
break;
10029
}
10030
10031
case 4: ;
10032
case 5: {
10033
*pTemp = pEntry->iRed;
10034
*(pTemp+1) = pEntry->iGreen;
10035
*(pTemp+2) = pEntry->iBlue;
10036
*(pTemp+3) = pEntry->iAlpha;
10037
10038
pTemp += 4;
10039
iRawlen += 4;
10040
10041
break;
10042
}
10043
10044
}
10045
}
10046
else
10047
{
10048
if (bHasgroup) /* finish off a group ? */
10049
*pLastid = (mng_uint8)(iX-1);
10050
10051
bHasgroup = MNG_FALSE;
10052
}
10053
}
10054
10055
if (bHasgroup) /* last group unfinished ? */
10056
*pLastid = (mng_uint8)(pPPLT->iCount-1);
10057
/* write the output buffer */
10058
iRetcode = write_raw_chunk (pData, pPPLT->sHeader.iChunkname,
10059
iRawlen, pRawdata);
10060
10061
#ifdef MNG_SUPPORT_TRACE
10062
MNG_TRACE (pData, MNG_FN_WRITE_PPLT, MNG_LC_END);
10063
#endif
10064
10065
return iRetcode;
10066
}
10067
#endif
10068
10069
/* ************************************************************************** */
10070
10071
#ifndef MNG_NO_DELTA_PNG
10072
#ifdef MNG_INCLUDE_JNG
10073
WRITE_CHUNK (mng_write_ijng)
10074
{
10075
mng_ijngp pIJNG;
10076
mng_retcode iRetcode;
10077
10078
#ifdef MNG_SUPPORT_TRACE
10079
MNG_TRACE (pData, MNG_FN_WRITE_IJNG, MNG_LC_START);
10080
#endif
10081
10082
pIJNG = (mng_ijngp)pChunk; /* address the proper chunk */
10083
/* and write it */
10084
iRetcode = write_raw_chunk (pData, pIJNG->sHeader.iChunkname, 0, 0);
10085
10086
#ifdef MNG_SUPPORT_TRACE
10087
MNG_TRACE (pData, MNG_FN_WRITE_IJNG, MNG_LC_END);
10088
#endif
10089
10090
return iRetcode;
10091
}
10092
#endif
10093
#endif
10094
10095
/* ************************************************************************** */
10096
10097
#ifndef MNG_NO_DELTA_PNG
10098
WRITE_CHUNK (mng_write_drop)
10099
{
10100
mng_dropp pDROP;
10101
mng_uint8p pRawdata;
10102
mng_uint32 iRawlen;
10103
mng_retcode iRetcode;
10104
mng_uint32 iX;
10105
mng_uint8p pTemp1;
10106
mng_chunkidp pTemp2;
10107
10108
#ifdef MNG_SUPPORT_TRACE
10109
MNG_TRACE (pData, MNG_FN_WRITE_DROP, MNG_LC_START);
10110
#endif
10111
10112
pDROP = (mng_dropp)pChunk; /* address the proper chunk */
10113
10114
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
10115
iRawlen = pDROP->iCount << 2;
10116
10117
pTemp1 = pRawdata; /* fill the output buffer */
10118
pTemp2 = pDROP->pChunknames;
10119
10120
for (iX = 0; iX < pDROP->iCount; iX++)
10121
{
10122
mng_put_uint32 (pTemp1, (mng_uint32)*pTemp2);
10123
10124
pTemp2++;
10125
pTemp1 += 4;
10126
}
10127
/* and write it */
10128
iRetcode = write_raw_chunk (pData, pDROP->sHeader.iChunkname,
10129
iRawlen, pRawdata);
10130
10131
#ifdef MNG_SUPPORT_TRACE
10132
MNG_TRACE (pData, MNG_FN_WRITE_DROP, MNG_LC_END);
10133
#endif
10134
10135
return iRetcode;
10136
}
10137
#endif
10138
10139
/* ************************************************************************** */
10140
10141
#ifndef MNG_NO_DELTA_PNG
10142
#ifndef MNG_SKIPCHUNK_DBYK
10143
WRITE_CHUNK (mng_write_dbyk)
10144
{
10145
mng_dbykp pDBYK;
10146
mng_uint8p pRawdata;
10147
mng_uint32 iRawlen;
10148
mng_retcode iRetcode;
10149
10150
#ifdef MNG_SUPPORT_TRACE
10151
MNG_TRACE (pData, MNG_FN_WRITE_DBYK, MNG_LC_START);
10152
#endif
10153
10154
pDBYK = (mng_dbykp)pChunk; /* address the proper chunk */
10155
10156
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
10157
iRawlen = 5 + pDBYK->iKeywordssize;
10158
/* fill the output buffer */
10159
mng_put_uint32 (pRawdata, pDBYK->iChunkname);
10160
*(pRawdata+4) = pDBYK->iPolarity;
10161
10162
if (pDBYK->iKeywordssize)
10163
MNG_COPY (pRawdata+5, pDBYK->zKeywords, pDBYK->iKeywordssize);
10164
/* and write it */
10165
iRetcode = write_raw_chunk (pData, pDBYK->sHeader.iChunkname,
10166
iRawlen, pRawdata);
10167
10168
#ifdef MNG_SUPPORT_TRACE
10169
MNG_TRACE (pData, MNG_FN_WRITE_DBYK, MNG_LC_END);
10170
#endif
10171
10172
return iRetcode;
10173
}
10174
#endif
10175
#endif
10176
10177
/* ************************************************************************** */
10178
10179
#ifndef MNG_NO_DELTA_PNG
10180
#ifndef MNG_SKIPCHUNK_ORDR
10181
WRITE_CHUNK (mng_write_ordr)
10182
{
10183
mng_ordrp pORDR;
10184
mng_uint8p pRawdata;
10185
mng_uint32 iRawlen;
10186
mng_retcode iRetcode;
10187
mng_uint8p pTemp;
10188
mng_ordr_entryp pEntry;
10189
mng_uint32 iX;
10190
10191
#ifdef MNG_SUPPORT_TRACE
10192
MNG_TRACE (pData, MNG_FN_WRITE_ORDR, MNG_LC_START);
10193
#endif
10194
10195
pORDR = (mng_ordrp)pChunk; /* address the proper chunk */
10196
10197
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
10198
iRawlen = pORDR->iCount * 5;
10199
10200
pTemp = pRawdata; /* fill the output buffer */
10201
pEntry = pORDR->pEntries;
10202
10203
for (iX = 0; iX < pORDR->iCount; iX++)
10204
{
10205
mng_put_uint32 (pTemp, pEntry->iChunkname);
10206
*(pTemp+4) = pEntry->iOrdertype;
10207
pTemp += 5;
10208
pEntry++;
10209
}
10210
/* and write it */
10211
iRetcode = write_raw_chunk (pData, pORDR->sHeader.iChunkname,
10212
iRawlen, pRawdata);
10213
10214
#ifdef MNG_SUPPORT_TRACE
10215
MNG_TRACE (pData, MNG_FN_WRITE_ORDR, MNG_LC_END);
10216
#endif
10217
10218
return iRetcode;
10219
}
10220
#endif
10221
#endif
10222
10223
/* ************************************************************************** */
10224
10225
WRITE_CHUNK (mng_write_magn)
10226
{
10227
mng_magnp pMAGN;
10228
mng_uint8p pRawdata;
10229
mng_uint32 iRawlen;
10230
mng_retcode iRetcode;
10231
10232
#ifdef MNG_SUPPORT_TRACE
10233
MNG_TRACE (pData, MNG_FN_WRITE_MAGN, MNG_LC_START);
10234
#endif
10235
10236
pMAGN = (mng_magnp)pChunk; /* address the proper chunk */
10237
10238
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
10239
iRawlen = 18;
10240
/* fill the output buffer */
10241
mng_put_uint16 (pRawdata, pMAGN->iFirstid);
10242
mng_put_uint16 (pRawdata+2, pMAGN->iLastid);
10243
*(pRawdata+4) = pMAGN->iMethodX;
10244
mng_put_uint16 (pRawdata+5, pMAGN->iMX);
10245
mng_put_uint16 (pRawdata+7, pMAGN->iMY);
10246
mng_put_uint16 (pRawdata+9, pMAGN->iML);
10247
mng_put_uint16 (pRawdata+11, pMAGN->iMR);
10248
mng_put_uint16 (pRawdata+13, pMAGN->iMT);
10249
mng_put_uint16 (pRawdata+15, pMAGN->iMB);
10250
*(pRawdata+17) = pMAGN->iMethodY;
10251
/* optimize length */
10252
if (pMAGN->iMethodY == pMAGN->iMethodX)
10253
{
10254
iRawlen--;
10255
10256
if (pMAGN->iMB == pMAGN->iMY)
10257
{
10258
iRawlen -= 2;
10259
10260
if (pMAGN->iMT == pMAGN->iMY)
10261
{
10262
iRawlen -= 2;
10263
10264
if (pMAGN->iMR == pMAGN->iMX)
10265
{
10266
iRawlen -= 2;
10267
10268
if (pMAGN->iML == pMAGN->iMX)
10269
{
10270
iRawlen -= 2;
10271
10272
if (pMAGN->iMY == pMAGN->iMX)
10273
{
10274
iRawlen -= 2;
10275
10276
if (pMAGN->iMX == 1)
10277
{
10278
iRawlen -= 2;
10279
10280
if (pMAGN->iMethodX == 0)
10281
{
10282
iRawlen--;
10283
10284
if (pMAGN->iLastid == pMAGN->iFirstid)
10285
{
10286
iRawlen -= 2;
10287
10288
if (pMAGN->iFirstid == 0)
10289
iRawlen = 0;
10290
10291
}
10292
}
10293
}
10294
}
10295
}
10296
}
10297
}
10298
}
10299
}
10300
/* and write it */
10301
iRetcode = write_raw_chunk (pData, pMAGN->sHeader.iChunkname,
10302
iRawlen, pRawdata);
10303
10304
#ifdef MNG_SUPPORT_TRACE
10305
MNG_TRACE (pData, MNG_FN_WRITE_MAGN, MNG_LC_END);
10306
#endif
10307
10308
return iRetcode;
10309
}
10310
10311
/* ************************************************************************** */
10312
10313
#ifndef MNG_SKIPCHUNK_evNT
10314
WRITE_CHUNK (mng_write_evnt)
10315
{
10316
mng_evntp pEVNT;
10317
mng_uint8p pRawdata;
10318
mng_uint32 iRawlen;
10319
mng_retcode iRetcode;
10320
mng_evnt_entryp pEntry;
10321
mng_uint8p pTemp;
10322
mng_uint32 iX;
10323
mng_uint32 iNamesize;
10324
10325
#ifdef MNG_SUPPORT_TRACE
10326
MNG_TRACE (pData, MNG_FN_WRITE_EVNT, MNG_LC_START);
10327
#endif
10328
10329
pEVNT = (mng_evntp)pChunk; /* address the proper chunk */
10330
10331
if (!pEVNT->iCount) /* empty ? */
10332
iRetcode = write_raw_chunk (pData, pEVNT->sHeader.iChunkname, 0, 0);
10333
else
10334
{
10335
pRawdata = pData->pWritebuf+8; /* init output buffer & size */
10336
iRawlen = 0;
10337
pTemp = pRawdata;
10338
pEntry = pEVNT->pEntries;
10339
10340
for (iX = 0; iX < pEVNT->iCount; iX++)
10341
{
10342
if (iX) /* put separator null-byte, except the first */
10343
{
10344
*pTemp = 0;
10345
pTemp++;
10346
iRawlen++;
10347
}
10348
10349
*pTemp = pEntry->iEventtype;
10350
*(pTemp+1) = pEntry->iMasktype;
10351
pTemp += 2;
10352
iRawlen += 2;
10353
10354
switch (pEntry->iMasktype)
10355
{
10356
case 1 :
10357
{
10358
mng_put_int32 (pTemp, pEntry->iLeft);
10359
mng_put_int32 (pTemp+4, pEntry->iRight);
10360
mng_put_int32 (pTemp+8, pEntry->iTop);
10361
mng_put_int32 (pTemp+12, pEntry->iBottom);
10362
pTemp += 16;
10363
iRawlen += 16;
10364
break;
10365
}
10366
case 2 :
10367
{
10368
mng_put_uint16 (pTemp, pEntry->iObjectid);
10369
pTemp += 2;
10370
iRawlen += 2;
10371
break;
10372
}
10373
case 3 :
10374
{
10375
mng_put_uint16 (pTemp, pEntry->iObjectid);
10376
*(pTemp+2) = pEntry->iIndex;
10377
pTemp += 3;
10378
iRawlen += 3;
10379
break;
10380
}
10381
case 4 :
10382
{
10383
mng_put_int32 (pTemp, pEntry->iLeft);
10384
mng_put_int32 (pTemp+4, pEntry->iRight);
10385
mng_put_int32 (pTemp+8, pEntry->iTop);
10386
mng_put_int32 (pTemp+12, pEntry->iBottom);
10387
mng_put_uint16 (pTemp+16, pEntry->iObjectid);
10388
pTemp += 18;
10389
iRawlen += 18;
10390
break;
10391
}
10392
case 5 :
10393
{
10394
mng_put_int32 (pTemp, pEntry->iLeft);
10395
mng_put_int32 (pTemp+4, pEntry->iRight);
10396
mng_put_int32 (pTemp+8, pEntry->iTop);
10397
mng_put_int32 (pTemp+12, pEntry->iBottom);
10398
mng_put_uint16 (pTemp+16, pEntry->iObjectid);
10399
*(pTemp+18) = pEntry->iIndex;
10400
pTemp += 19;
10401
iRawlen += 19;
10402
break;
10403
}
10404
}
10405
10406
iNamesize = pEntry->iSegmentnamesize;
10407
10408
if (iNamesize)
10409
{
10410
MNG_COPY (pTemp, pEntry->zSegmentname, iNamesize);
10411
pTemp += iNamesize;
10412
iRawlen += iNamesize;
10413
}
10414
10415
pEntry++;
10416
}
10417
/* and write it */
10418
iRetcode = write_raw_chunk (pData, pEVNT->sHeader.iChunkname,
10419
iRawlen, pRawdata);
10420
}
10421
10422
#ifdef MNG_SUPPORT_TRACE
10423
MNG_TRACE (pData, MNG_FN_WRITE_EVNT, MNG_LC_END);
10424
#endif
10425
10426
return iRetcode;
10427
}
10428
#endif
10429
10430
/* ************************************************************************** */
10431
10432
WRITE_CHUNK (mng_write_unknown)
10433
{
10434
mng_unknown_chunkp pUnknown;
10435
mng_retcode iRetcode;
10436
10437
#ifdef MNG_SUPPORT_TRACE
10438
MNG_TRACE (pData, MNG_FN_WRITE_UNKNOWN, MNG_LC_START);
10439
#endif
10440
/* address the proper chunk */
10441
pUnknown = (mng_unknown_chunkp)pChunk;
10442
/* and write it */
10443
iRetcode = write_raw_chunk (pData, pUnknown->sHeader.iChunkname,
10444
pUnknown->iDatasize, pUnknown->pData);
10445
10446
#ifdef MNG_SUPPORT_TRACE
10447
MNG_TRACE (pData, MNG_FN_WRITE_UNKNOWN, MNG_LC_END);
10448
#endif
10449
10450
return iRetcode;
10451
}
10452
10453
/* ************************************************************************** */
10454
10455
#endif /* MNG_INCLUDE_WRITE_PROCS */
10456
10457
/* ************************************************************************** */
10458
/* * end of file * */
10459
/* ************************************************************************** */
10460
Loggerhead is a web-based interface for Breezy
Version: 2.0.1