Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

libmng_object_prc.c

Last change on this file was 561, checked in by Dmitry A. Kuminov, 15 years ago
trunk: Merged in qt 4.6.1 sources.
File size: 226.3 KB

Line
1	/* ************************************************************************** */
2	/* * For conditions of distribution and use, * */
3	/* * see copyright notice in libmng.h * */
4	/* ************************************************************************** */
5	/* * * */
6	/* * project : libmng * */
7	/* * file : libmng_object_prc.c copyright (c) 2000-2007 G.Juyn * */
8	/* * version : 1.0.10 * */
9	/* * * */
10	/* * purpose : Object processing routines (implementation) * */
11	/* * * */
12	/* * author : G.Juyn * */
13	/* * * */
14	/* * comment : implementation of the internal object processing routines * */
15	/* * * */
16	/* * changes : 0.5.1 - 05/08/2000 - G.Juyn * */
17	/* * - changed strict-ANSI stuff * */
18	/* * 0.5.1 - 05/12/2000 - G.Juyn * */
19	/* * - changed trace to macro for callback error-reporting * */
20	/* * * */
21	/* * 0.5.2 - 05/20/2000 - G.Juyn * */
22	/* * - fixed to support JNG objects * */
23	/* * 0.5.2 - 05/24/2000 - G.Juyn * */
24	/* * - added support for global color-chunks in animation * */
25	/* * - added support for global PLTE,tRNS,bKGD in animation * */
26	/* * - added SAVE & SEEK animation objects * */
27	/* * 0.5.2 - 05/29/2000 - G.Juyn * */
28	/* * - added initialization of framenr/layernr/playtime * */
29	/* * - changed ani_object create routines not to return the * */
30	/* * created object (wasn't necessary) * */
31	/* * 0.5.2 - 05/30/2000 - G.Juyn * */
32	/* * - added object promotion routine (PROM handling) * */
33	/* * - added ani-object routines for delta-image processing * */
34	/* * - added compression/filter/interlace fields to * */
35	/* * object-buffer for delta-image processing * */
36	/* * * */
37	/* * 0.5.3 - 06/17/2000 - G.Juyn * */
38	/* * - changed support for delta-image processing * */
39	/* * 0.5.3 - 06/20/2000 - G.Juyn * */
40	/* * - fixed some small things (as precaution) * */
41	/* * 0.5.3 - 06/21/2000 - G.Juyn * */
42	/* * - added processing of PLTE/tRNS & color-info for * */
43	/* * delta-images in the ani_objects chain * */
44	/* * 0.5.3 - 06/22/2000 - G.Juyn * */
45	/* * - added support for PPLT chunk * */
46	/* * * */
47	/* * 0.9.1 - 07/07/2000 - G.Juyn * */
48	/* * - added support for freeze/restart/resume & go_xxxx * */
49	/* * 0.9.1 - 07/16/2000 - G.Juyn * */
50	/* * - fixed support for mng_display() after mng_read() * */
51	/* * * */
52	/* * 0.9.2 - 07/29/2000 - G.Juyn * */
53	/* * - fixed small bugs in display processing * */
54	/* * 0.9.2 - 08/05/2000 - G.Juyn * */
55	/* * - changed file-prefixes * */
56	/* * * */
57	/* * 0.9.3 - 08/07/2000 - G.Juyn * */
58	/* * - B111300 - fixup for improved portability * */
59	/* * 0.9.3 - 08/26/2000 - G.Juyn * */
60	/* * - added MAGN chunk * */
61	/* * 0.9.3 - 09/10/2000 - G.Juyn * */
62	/* * - fixed DEFI behavior * */
63	/* * 0.9.3 - 10/17/2000 - G.Juyn * */
64	/* * - added valid-flag to stored objects for read() / display()* */
65	/* * - added routine to discard "invalid" objects * */
66	/* * 0.9.3 - 10/18/2000 - G.Juyn * */
67	/* * - fixed delta-processing behavior * */
68	/* * 0.9.3 - 10/19/2000 - G.Juyn * */
69	/* * - added storage for pixel-/alpha-sampledepth for delta's * */
70	/* * * */
71	/* * 0.9.4 - 1/18/2001 - G.Juyn * */
72	/* * - removed "old" MAGN methods 3 & 4 * */
73	/* * - added "new" MAGN methods 3, 4 & 5 * */
74	/* * * */
75	/* * 0.9.5 - 1/22/2001 - G.Juyn * */
76	/* * - B129681 - fixed compiler warnings SGI/Irix * */
77	/* * * */
78	/* * 1.0.2 - 06/23/2001 - G.Juyn * */
79	/* * - added optimization option for MNG-video playback * */
80	/* * * */
81	/* * 1.0.5 - 08/15/2002 - G.Juyn * */
82	/* * - completed PROM support * */
83	/* * 1.0.5 - 08/16/2002 - G.Juyn * */
84	/* * - completed MAGN support (16-bit functions) * */
85	/* * 1.0.5 - 08/19/2002 - G.Juyn * */
86	/* * - B597134 - libmng pollutes the linker namespace * */
87	/* * 1.0.5 - 09/13/2002 - G.Juyn * */
88	/* * - fixed read/write of MAGN chunk * */
89	/* * 1.0.5 - 09/15/2002 - G.Juyn * */
90	/* * - added event handling for dynamic MNG * */
91	/* * 1.0.5 - 09/20/2002 - G.Juyn * */
92	/* * - added support for PAST * */
93	/* * 1.0.5 - 09/23/2002 - G.Juyn * */
94	/* * - fixed reset_object_detail to clear old buffer * */
95	/* * - added in-memory color-correction of abstract images * */
96	/* * 1.0.5 - 10/05/2002 - G.Juyn * */
97	/* * - fixed problem with cloned objects marked as invalid * */
98	/* * - fixed problem cloning frozen object_buffers * */
99	/* * 1.0.5 - 10/07/2002 - G.Juyn * */
100	/* * - fixed DISC support * */
101	/* * 1.0.5 - 11/04/2002 - G.Juyn * */
102	/* * - fixed goframe/golayer/gotime processing * */
103	/* * 1.0.5 - 11/07/2002 - G.Juyn * */
104	/* * - fixed magnification bug with object 0 * */
105	/* * 1.0.5 - 01/19/2003 - G.Juyn * */
106	/* * - B664911 - fixed buffer overflow during init * */
107	/* * * */
108	/* * 1.0.6 - 04/19/2003 - G.Juyn * */
109	/* * - fixed problem with infinite loops during readdisplay() * */
110	/* * 1.0.6 - 05/25/2003 - G.R-P * */
111	/* * - added MNG_SKIPCHUNK_cHNK footprint optimizations * */
112	/* * 1.0.6 - 06/09/2003 - G. R-P * */
113	/* * - added conditionals around 8-bit magn routines * */
114	/* * 1.0.6 - 07/07/2003 - G.R-P * */
115	/* * - added conditionals around some JNG-supporting code * */
116	/* * - removed conditionals around 8-bit magn routines * */
117	/* * - added conditionals around delta-png and 16-bit code * */
118	/* * 1.0.6 - 07/14/2003 - G.R-P * */
119	/* * - added MNG_NO_LOOP_SIGNALS_SUPPORTED conditional * */
120	/* * 1.0.6 - 07/29/2003 - G.Juyn * */
121	/* * - fixed invalid test in promote_imageobject * */
122	/* * 1.0.6 - 07/29/2003 - G.R-P. * */
123	/* * - added conditionals around PAST chunk support * */
124	/* * 1.0.6 - 08/17/2003 - G.R-P. * */
125	/* * - added conditionals around MAGN chunk support * */
126	/* * * */
127	/* * 1.0.7 - 03/21/2004 - G.Juyn * */
128	/* * - fixed some 64-bit platform compiler warnings * */
129	/* * * */
130	/* * 1.0.9 - 10/10/2004 - G.R-P. * */
131	/* * - added MNG_NO_1_2_4BIT_SUPPORT support * */
132	/* * 1.0.9 - 12/05/2004 - G.Juyn * */
133	/* * - added conditional MNG_OPTIMIZE_OBJCLEANUP * */
134	/* * 1.0.9 - 12/11/2004 - G.Juyn * */
135	/* * - added conditional MNG_OPTIMIZE_DISPLAYCALLS * */
136	/* * 1.0.9 - 12/31/2004 - G.R-P. * */
137	/* * - fixed warnings about possible uninitialized pointers * */
138	/* * 1.0.9 - 01/02/2005 - G.Juyn * */
139	/* * - fixing some compiler-warnings * */
140	/* * * */
141	/* * 1.0.10 - 02/07/2005 - G.Juyn * */
142	/* * - fixed some compiler-warnings * */
143	/* * 1.0.10 - 07/30/2005 - G.Juyn * */
144	/* * - fixed problem with CLON object during readdisplay() * */
145	/* * 1.0.10 - 04/08/2007 - G.Juyn * */
146	/* * - added support for mPNG proposal * */
147	/* * 1.0.10 - 04/12/2007 - G.Juyn * */
148	/* * - added support for ANG proposal * */
149	/* * * */
150	/* ************************************************************************** */
151
152	#include "libmng.h"
153	#include "libmng_data.h"
154	#include "libmng_error.h"
155	#include "libmng_trace.h"
156	#ifdef __BORLANDC__
157	#pragma hdrstop
158	#endif
159	#include "libmng_memory.h"
160	#include "libmng_chunks.h"
161	#include "libmng_objects.h"
162	#include "libmng_display.h"
163	#include "libmng_pixels.h"
164	#include "libmng_object_prc.h"
165	#include "libmng_cms.h"
166
167	#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
168	#pragma option -A /* force ANSI-C */
169	#endif
170
171	/* ************************************************************************** */
172
173	#ifdef MNG_INCLUDE_DISPLAY_PROCS
174
175	/* ************************************************************************** */
176	/* * * */
177	/* * Generic object routines * */
178	/* * * */
179	/* ************************************************************************** */
180
181	mng_retcode mng_drop_invalid_objects (mng_datap pData)
182	{
183	mng_objectp pObject;
184	mng_objectp pNext;
185	mng_cleanupobject fCleanup;
186
187	#ifdef MNG_SUPPORT_TRACE
188	MNG_TRACE (pData, MNG_FN_DROP_INVALID_OBJECTS, MNG_LC_START);
189	#endif
190
191	pObject = pData->pFirstimgobj; /* get first stored image-object (if any) */
192
193	while (pObject) /* more objects to check ? */
194	{
195	pNext = ((mng_object_headerp)pObject)->pNext;
196	/* invalid ? */
197	if (!((mng_imagep)pObject)->bValid)
198	{ /* call appropriate cleanup */
199	fCleanup = ((mng_object_headerp)pObject)->fCleanup;
200	fCleanup (pData, pObject);
201	}
202
203	pObject = pNext; /* neeeext */
204	}
205
206	#ifdef MNG_SUPPORT_TRACE
207	MNG_TRACE (pData, MNG_FN_DROP_INVALID_OBJECTS, MNG_LC_END);
208	#endif
209
210	return MNG_NOERROR;
211	}
212
213	/* ************************************************************************** */
214
215	#ifdef MNG_OPTIMIZE_OBJCLEANUP
216	MNG_LOCAL mng_retcode create_obj_general (mng_datap pData,
217	mng_size_t iObjsize,
218	mng_cleanupobject fCleanup,
219	mng_processobject fProcess,
220	mng_ptr *ppObject)
221	{
222	mng_object_headerp pWork;
223
224	MNG_ALLOC (pData, pWork, iObjsize);
225
226	pWork->fCleanup = fCleanup;
227	pWork->fProcess = fProcess;
228	pWork->iObjsize = iObjsize;
229	*ppObject = (mng_ptr)pWork;
230
231	return MNG_NOERROR;
232	}
233
234	/* ************************************************************************** */
235
236	MNG_LOCAL mng_retcode mng_free_obj_general (mng_datap pData,
237	mng_objectp pObject)
238	{
239	MNG_FREEX (pData, pObject, ((mng_object_headerp)pObject)->iObjsize);
240	return MNG_NOERROR;
241	}
242	#endif
243
244	/* ************************************************************************** */
245	/* * * */
246	/* * Image-data-object routines * */
247	/* * * */
248	/* * these handle the "object buffer" as defined by the MNG specification * */
249	/* * * */
250	/* ************************************************************************** */
251
252	mng_retcode mng_create_imagedataobject (mng_datap pData,
253	mng_bool bConcrete,
254	mng_bool bViewable,
255	mng_uint32 iWidth,
256	mng_uint32 iHeight,
257	mng_uint8 iBitdepth,
258	mng_uint8 iColortype,
259	mng_uint8 iCompression,
260	mng_uint8 iFilter,
261	mng_uint8 iInterlace,
262	mng_imagedatap *ppObject)
263	{
264	mng_imagedatap pImagedata;
265	mng_uint32 iSamplesize = 0;
266
267	#ifdef MNG_SUPPORT_TRACE
268	MNG_TRACE (pData, MNG_FN_CREATE_IMGDATAOBJECT, MNG_LC_START);
269	#endif
270	/* get a buffer */
271	#ifdef MNG_OPTIMIZE_OBJCLEANUP
272	{
273	mng_ptr pTemp;
274	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_imagedata),
275	(mng_cleanupobject)mng_free_imagedataobject,
276	MNG_NULL, &pTemp);
277	if (iRetcode)
278	return iRetcode;
279	pImagedata = (mng_imagedatap)pTemp;
280	}
281	#else
282	MNG_ALLOC (pData, pImagedata, sizeof (mng_imagedata));
283	/* fill the appropriate fields */
284	pImagedata->sHeader.fCleanup = (mng_cleanupobject)mng_free_imagedataobject;
285	pImagedata->sHeader.fProcess = MNG_NULL;
286	#endif
287	pImagedata->iRefcount = 1;
288	pImagedata->bFrozen = MNG_FALSE;
289	pImagedata->bConcrete = bConcrete;
290	pImagedata->bViewable = bViewable;
291	pImagedata->iWidth = iWidth;
292	pImagedata->iHeight = iHeight;
293	pImagedata->iBitdepth = iBitdepth;
294	pImagedata->iColortype = iColortype;
295	pImagedata->iCompression = iCompression;
296	pImagedata->iFilter = iFilter;
297	pImagedata->iInterlace = iInterlace;
298	pImagedata->bCorrected = MNG_FALSE;
299	pImagedata->iAlphabitdepth = 0;
300	pImagedata->iJHDRcompression = 0;
301	pImagedata->iJHDRinterlace = 0;
302	pImagedata->iPixelsampledepth = iBitdepth;
303	pImagedata->iAlphasampledepth = iBitdepth;
304	/* determine samplesize from color_type/bit_depth */
305	switch (iColortype) /* for < 8-bit samples we just reserve 8 bits */
306	{
307	case 0 : ; /* gray */
308	case 8 : { /* JPEG gray */
309	#ifndef MNG_NO_16BIT_SUPPORT
310	if (iBitdepth > 8)
311	iSamplesize = 2;
312	else
313	#endif
314	iSamplesize = 1;
315
316	break;
317	}
318	case 2 : ; /* rgb */
319	case 10 : { /* JPEG rgb */
320	#ifndef MNG_NO_16BIT_SUPPORT
321	if (iBitdepth > 8)
322	iSamplesize = 6;
323	else
324	#endif
325	iSamplesize = 3;
326
327	break;
328	}
329	case 3 : { /* indexed */
330	iSamplesize = 1;
331	break;
332	}
333	case 4 : ; /* gray+alpha */
334	case 12 : { /* JPEG gray+alpha */
335	#ifndef MNG_NO_16BIT_SUPPORT
336	if (iBitdepth > 8)
337	iSamplesize = 4;
338	else
339	#endif
340	iSamplesize = 2;
341
342	break;
343	}
344	case 6 : ; /* rgb+alpha */
345	case 14 : { /* JPEG rgb+alpha */
346	#ifndef MNG_NO_16BIT_SUPPORT
347	if (iBitdepth > 8)
348	iSamplesize = 8;
349	else
350	#endif
351	iSamplesize = 4;
352
353	break;
354	}
355	}
356	/* make sure we remember all this */
357	pImagedata->iSamplesize = iSamplesize;
358	pImagedata->iRowsize = iSamplesize * iWidth;
359	pImagedata->iImgdatasize = pImagedata->iRowsize * iHeight;
360
361	if (pImagedata->iImgdatasize) /* need a buffer ? */
362	{ /* so allocate it */
363	MNG_ALLOCX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize);
364
365	if (!pImagedata->pImgdata) /* enough memory ? */
366	{
367	MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata));
368	MNG_ERROR (pData, MNG_OUTOFMEMORY);
369	}
370	}
371	/* check global stuff */
372	pImagedata->bHasGAMA = pData->bHasglobalGAMA;
373	#ifndef MNG_SKIPCHUNK_cHRM
374	pImagedata->bHasCHRM = pData->bHasglobalCHRM;
375	#endif
376	pImagedata->bHasSRGB = pData->bHasglobalSRGB;
377	#ifndef MNG_SKIPCHUNK_iCCP
378	pImagedata->bHasICCP = pData->bHasglobalICCP;
379	#endif
380	#ifndef MNG_SKIPCHUNK_bKGD
381	pImagedata->bHasBKGD = pData->bHasglobalBKGD;
382	#endif
383
384	if (pData->bHasglobalGAMA) /* global gAMA present ? */
385	pImagedata->iGamma = pData->iGlobalGamma;
386
387	#ifndef MNG_SKIPCHUNK_cHRM
388	if (pData->bHasglobalCHRM) /* global cHRM present ? */
389	{
390	pImagedata->iWhitepointx = pData->iGlobalWhitepointx;
391	pImagedata->iWhitepointy = pData->iGlobalWhitepointy;
392	pImagedata->iPrimaryredx = pData->iGlobalPrimaryredx;
393	pImagedata->iPrimaryredy = pData->iGlobalPrimaryredy;
394	pImagedata->iPrimarygreenx = pData->iGlobalPrimarygreenx;
395	pImagedata->iPrimarygreeny = pData->iGlobalPrimarygreeny;
396	pImagedata->iPrimarybluex = pData->iGlobalPrimarybluex;
397	pImagedata->iPrimarybluey = pData->iGlobalPrimarybluey;
398	}
399	#endif
400
401	if (pData->bHasglobalSRGB) /* glbal sRGB present ? */
402	pImagedata->iRenderingintent = pData->iGlobalRendintent;
403
404	#ifndef MNG_SKIPCHUNK_iCCP
405	if (pData->bHasglobalICCP) /* glbal iCCP present ? */
406	{
407	pImagedata->iProfilesize = pData->iGlobalProfilesize;
408
409	if (pImagedata->iProfilesize)
410	{
411	MNG_ALLOCX (pData, pImagedata->pProfile, pImagedata->iProfilesize);
412
413	if (!pImagedata->pProfile) /* enough memory ? */
414	{
415	MNG_FREEX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize);
416	MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata));
417	MNG_ERROR (pData, MNG_OUTOFMEMORY);
418	}
419
420	MNG_COPY (pImagedata->pProfile, pData->pGlobalProfile, pImagedata->iProfilesize);
421	}
422	}
423	#endif
424
425	#ifndef MNG_SKIPCHUNK_bKGD
426	if (pData->bHasglobalBKGD) /* global bKGD present ? */
427	{
428	pImagedata->iBKGDred = pData->iGlobalBKGDred;
429	pImagedata->iBKGDgreen = pData->iGlobalBKGDgreen;
430	pImagedata->iBKGDblue = pData->iGlobalBKGDblue;
431	}
432	#endif
433
434	ppObject = pImagedata; / return it */
435
436	#ifdef MNG_SUPPORT_TRACE
437	MNG_TRACE (pData, MNG_FN_CREATE_IMGDATAOBJECT, MNG_LC_END);
438	#endif
439
440	return MNG_NOERROR;
441	}
442
443	/* ************************************************************************** */
444
445	mng_retcode mng_free_imagedataobject (mng_datap pData,
446	mng_imagedatap pImagedata)
447	{
448	#ifdef MNG_SUPPORT_TRACE
449	MNG_TRACE (pData, MNG_FN_FREE_IMGDATAOBJECT, MNG_LC_START);
450	#endif
451
452	if (pImagedata->iRefcount) /* decrease reference count */
453	pImagedata->iRefcount--;
454
455	if (!pImagedata->iRefcount) /* reached zero ? */
456	{
457	#ifndef MNG_SKIPCHUNK_iCCP
458	if (pImagedata->iProfilesize) /* stored an iCCP profile ? */
459	MNG_FREEX (pData, pImagedata->pProfile, pImagedata->iProfilesize);
460	#endif
461	if (pImagedata->iImgdatasize) /* sample-buffer present ? */
462	MNG_FREEX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize);
463	/* drop the buffer */
464	MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata));
465	}
466
467	#ifdef MNG_SUPPORT_TRACE
468	MNG_TRACE (pData, MNG_FN_FREE_IMGDATAOBJECT, MNG_LC_END);
469	#endif
470
471	return MNG_NOERROR;
472	}
473
474	/* ************************************************************************** */
475
476	mng_retcode mng_clone_imagedataobject (mng_datap pData,
477	mng_bool bConcrete,
478	mng_imagedatap pSource,
479	mng_imagedatap *ppClone)
480	{
481	mng_imagedatap pNewdata;
482
483	#ifdef MNG_SUPPORT_TRACE
484	MNG_TRACE (pData, MNG_FN_CLONE_IMGDATAOBJECT, MNG_LC_START);
485	#endif
486	/* get a buffer */
487	MNG_ALLOC (pData, pNewdata, sizeof (mng_imagedata));
488	/* blatently copy the original buffer */
489	MNG_COPY (pNewdata, pSource, sizeof (mng_imagedata));
490
491	pNewdata->iRefcount = 1; /* only the reference count */
492	pNewdata->bConcrete = bConcrete; /* and concrete-flag are different */
493	pNewdata->bFrozen = MNG_FALSE;
494
495	if (pNewdata->iImgdatasize) /* sample buffer present ? */
496	{
497	MNG_ALLOCX (pData, pNewdata->pImgdata, pNewdata->iImgdatasize);
498
499	if (!pNewdata->pImgdata) /* not enough memory ? */
500	{
501	MNG_FREEX (pData, pNewdata, sizeof (mng_imagedata));
502	MNG_ERROR (pData, MNG_OUTOFMEMORY);
503	}
504	/* make a copy */
505	MNG_COPY (pNewdata->pImgdata, pSource->pImgdata, pNewdata->iImgdatasize);
506	}
507
508	#ifndef MNG_SKIPCHUNK_iCCP
509	if (pNewdata->iProfilesize) /* iCCP profile present ? */
510	{
511	MNG_ALLOCX (pData, pNewdata->pProfile, pNewdata->iProfilesize);
512
513	if (!pNewdata->pProfile) /* enough memory ? */
514	{
515	MNG_FREEX (pData, pNewdata, sizeof (mng_imagedata));
516	MNG_ERROR (pData, MNG_OUTOFMEMORY);
517	}
518	/* make a copy */
519	MNG_COPY (pNewdata->pProfile, pSource->pProfile, pNewdata->iProfilesize);
520	}
521	#endif
522
523	ppClone = pNewdata; / return the clone */
524
525	#ifdef MNG_SUPPORT_TRACE
526	MNG_TRACE (pData, MNG_FN_CLONE_IMGDATAOBJECT, MNG_LC_END);
527	#endif
528
529	return MNG_NOERROR;
530	}
531
532	/* ************************************************************************** */
533	/* * * */
534	/* * Image-object routines * */
535	/* * * */
536	/* * these handle the "object" as defined by the MNG specification * */
537	/* * * */
538	/* ************************************************************************** */
539
540	mng_retcode mng_create_imageobject (mng_datap pData,
541	mng_uint16 iId,
542	mng_bool bConcrete,
543	mng_bool bVisible,
544	mng_bool bViewable,
545	mng_uint32 iWidth,
546	mng_uint32 iHeight,
547	mng_uint8 iBitdepth,
548	mng_uint8 iColortype,
549	mng_uint8 iCompression,
550	mng_uint8 iFilter,
551	mng_uint8 iInterlace,
552	mng_int32 iPosx,
553	mng_int32 iPosy,
554	mng_bool bClipped,
555	mng_int32 iClipl,
556	mng_int32 iClipr,
557	mng_int32 iClipt,
558	mng_int32 iClipb,
559	mng_imagep *ppObject)
560	{
561	mng_imagep pImage;
562	mng_imagep pPrev, pNext;
563	mng_retcode iRetcode;
564	mng_imagedatap pImgbuf;
565
566	#ifdef MNG_SUPPORT_TRACE
567	MNG_TRACE (pData, MNG_FN_CREATE_IMGOBJECT, MNG_LC_START);
568	#endif
569	/* get a buffer */
570	MNG_ALLOC (pData, pImage, sizeof (mng_image));
571	/* now get a new "object buffer" */
572	iRetcode = mng_create_imagedataobject (pData, bConcrete, bViewable,
573	iWidth, iHeight, iBitdepth, iColortype,
574	iCompression, iFilter, iInterlace,
575	&pImgbuf);
576
577	if (iRetcode) /* on error bail out */
578	{
579	MNG_FREEX (pData, pImage, sizeof (mng_image));
580	return iRetcode;
581	}
582	/* fill the appropriate fields */
583	pImage->sHeader.fCleanup = (mng_cleanupobject)mng_free_imageobject;
584	pImage->sHeader.fProcess = MNG_NULL;
585	#ifdef MNG_OPTIMIZE_OBJCLEANUP
586	pImage->sHeader.iObjsize = sizeof (mng_image);
587	#endif
588	pImage->iId = iId;
589	pImage->bFrozen = MNG_FALSE;
590	pImage->bVisible = bVisible;
591	pImage->bViewable = bViewable;
592	pImage->bValid = (mng_bool)((pData->bDisplaying) &&
593	((pData->bRunning) \|\| (pData->bSearching)) &&
594	(!pData->bFreezing));
595	pImage->iPosx = iPosx;
596	pImage->iPosy = iPosy;
597	pImage->bClipped = bClipped;
598	pImage->iClipl = iClipl;
599	pImage->iClipr = iClipr;
600	pImage->iClipt = iClipt;
601	pImage->iClipb = iClipb;
602	#ifndef MNG_SKIPCHUNK_MAGN
603	pImage->iMAGN_MethodX = 0;
604	pImage->iMAGN_MethodY = 0;
605	pImage->iMAGN_MX = 0;
606	pImage->iMAGN_MY = 0;
607	pImage->iMAGN_ML = 0;
608	pImage->iMAGN_MR = 0;
609	pImage->iMAGN_MT = 0;
610	pImage->iMAGN_MB = 0;
611	#endif
612	#ifndef MNG_SKIPCHUNK_PAST
613	pImage->iPastx = 0;
614	pImage->iPasty = 0;
615	#endif
616	pImage->pImgbuf = pImgbuf;
617
618	if (iId) /* only if not object 0 ! */
619	{ /* find previous lower object-id */
620	pPrev = (mng_imagep)pData->pLastimgobj;
621
622	while ((pPrev) && (pPrev->iId > iId))
623	pPrev = (mng_imagep)pPrev->sHeader.pPrev;
624
625	if (pPrev) /* found it ? */
626	{
627	pImage->sHeader.pPrev = pPrev; /* than link it in place */
628	pImage->sHeader.pNext = pPrev->sHeader.pNext;
629	pPrev->sHeader.pNext = pImage;
630	}
631	else /* if not found, it becomes the first ! */
632	{
633	pImage->sHeader.pNext = pData->pFirstimgobj;
634	pData->pFirstimgobj = pImage;
635	}
636
637	pNext = (mng_imagep)pImage->sHeader.pNext;
638
639	if (pNext)
640	pNext->sHeader.pPrev = pImage;
641	else
642	pData->pLastimgobj = pImage;
643
644	}
645
646	ppObject = pImage; / and return the new buffer */
647
648	#ifdef MNG_SUPPORT_TRACE
649	MNG_TRACE (pData, MNG_FN_CREATE_IMGOBJECT, MNG_LC_END);
650	#endif
651
652	return MNG_NOERROR; /* okido */
653	}
654
655	/* ************************************************************************** */
656
657	mng_retcode mng_free_imageobject (mng_datap pData,
658	mng_imagep pImage)
659	{
660	mng_retcode iRetcode;
661	mng_imagep pPrev = pImage->sHeader.pPrev;
662	mng_imagep pNext = pImage->sHeader.pNext;
663	mng_imagedatap pImgbuf = pImage->pImgbuf;
664
665	#ifdef MNG_SUPPORT_TRACE
666	MNG_TRACE (pData, MNG_FN_FREE_IMGOBJECT, MNG_LC_START);
667	#endif
668
669	if (pImage->iId) /* not for object 0 */
670	{
671	if (pPrev) /* unlink from the list first ! */
672	pPrev->sHeader.pNext = pImage->sHeader.pNext;
673	else
674	pData->pFirstimgobj = pImage->sHeader.pNext;
675
676	if (pNext)
677	pNext->sHeader.pPrev = pImage->sHeader.pPrev;
678	else
679	pData->pLastimgobj = pImage->sHeader.pPrev;
680
681	}
682	/* unlink the image-data buffer */
683	iRetcode = mng_free_imagedataobject (pData, pImgbuf);
684	/* drop its own buffer */
685	MNG_FREEX (pData, pImage, sizeof (mng_image));
686
687	#ifdef MNG_SUPPORT_TRACE
688	MNG_TRACE (pData, MNG_FN_FREE_IMGOBJECT, MNG_LC_END);
689	#endif
690
691	return iRetcode;
692	}
693
694	/* ************************************************************************** */
695
696	mng_imagep mng_find_imageobject (mng_datap pData,
697	mng_uint16 iId)
698	{
699	mng_imagep pImage = (mng_imagep)pData->pFirstimgobj;
700
701	#ifdef MNG_SUPPORT_TRACE
702	MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_START);
703	#endif
704	/* look up the right id */
705	while ((pImage) && (pImage->iId != iId))
706	pImage = (mng_imagep)pImage->sHeader.pNext;
707
708	#ifdef MNG_INCLUDE_MPNG_PROPOSAL
709	if ((!pImage) && (pData->eImagetype == mng_it_mpng))
710	pImage = pData->pObjzero;
711	#endif
712
713	#ifdef MNG_SUPPORT_TRACE
714	MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_END);
715	#endif
716
717	return pImage;
718	}
719
720	/* ************************************************************************** */
721
722	mng_retcode mng_clone_imageobject (mng_datap pData,
723	mng_uint16 iId,
724	mng_bool bPartial,
725	mng_bool bVisible,
726	mng_bool bAbstract,
727	mng_bool bHasloca,
728	mng_uint8 iLocationtype,
729	mng_int32 iLocationx,
730	mng_int32 iLocationy,
731	mng_imagep pSource,
732	mng_imagep *ppClone)
733	{
734	mng_imagep pNew;
735	mng_imagep pPrev, pNext;
736	mng_retcode iRetcode;
737	mng_imagedatap pImgbuf;
738
739	#ifdef MNG_SUPPORT_TRACE
740	MNG_TRACE (pData, MNG_FN_CLONE_IMGOBJECT, MNG_LC_START);
741	#endif
742
743	#ifndef MNG_SKIPCHUNK_MAGN
744	if ((pSource->iId) && /* needs magnification ? */
745	((pSource->iMAGN_MethodX) \|\| (pSource->iMAGN_MethodY)))
746	{
747	iRetcode = mng_magnify_imageobject (pData, pSource);
748
749	if (iRetcode) /* on error bail out */
750	return iRetcode;
751	}
752	#endif
753	/* get a buffer */
754	#ifdef MNG_OPTIMIZE_OBJCLEANUP
755	{
756	mng_ptr pTemp;
757	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_image),
758	(mng_cleanupobject)mng_free_imageobject,
759	MNG_NULL, &pTemp);
760	if (iRetcode)
761	return iRetcode;
762	pNew = (mng_imagep)pTemp;
763	}
764	#else
765	MNG_ALLOC (pData, pNew, sizeof (mng_image));
766	/* fill or copy the appropriate fields */
767	pNew->sHeader.fCleanup = (mng_cleanupobject)mng_free_imageobject;
768	pNew->sHeader.fProcess = MNG_NULL;
769	#endif
770	pNew->iId = iId;
771	pNew->bFrozen = MNG_FALSE;
772	pNew->bVisible = bVisible;
773	pNew->bViewable = pSource->bViewable;
774	pNew->bValid = MNG_TRUE;
775
776	if (bHasloca) /* location info available ? */
777	{
778	if (iLocationtype == 0) /* absolute position ? */
779	{
780	pNew->iPosx = iLocationx;
781	pNew->iPosy = iLocationy;
782	}
783	else /* relative */
784	{
785	pNew->iPosx = pSource->iPosx + iLocationx;
786	pNew->iPosy = pSource->iPosy + iLocationy;
787	}
788	}
789	else /* copy from source */
790	{
791	pNew->iPosx = pSource->iPosx;
792	pNew->iPosy = pSource->iPosy;
793	}
794	/* copy clipping info */
795	pNew->bClipped = pSource->bClipped;
796	pNew->iClipl = pSource->iClipl;
797	pNew->iClipr = pSource->iClipr;
798	pNew->iClipt = pSource->iClipt;
799	pNew->iClipb = pSource->iClipb;
800	#ifndef MNG_SKIPCHUNK_MAGN
801	/* copy magnification info */
802	/* pNew->iMAGN_MethodX = pSource->iMAGN_MethodX; LET'S NOT !!!!!!
803	pNew->iMAGN_MethodY = pSource->iMAGN_MethodY;
804	pNew->iMAGN_MX = pSource->iMAGN_MX;
805	pNew->iMAGN_MY = pSource->iMAGN_MY;
806	pNew->iMAGN_ML = pSource->iMAGN_ML;
807	pNew->iMAGN_MR = pSource->iMAGN_MR;
808	pNew->iMAGN_MT = pSource->iMAGN_MT;
809	pNew->iMAGN_MB = pSource->iMAGN_MB; */
810	#endif
811
812	#ifndef MNG_SKIPCHUNK_PAST
813	pNew->iPastx = 0; /* initialize PAST info */
814	pNew->iPasty = 0;
815	#endif
816
817	if (iId) /* not for object 0 */
818	{ /* find previous lower object-id */
819	pPrev = (mng_imagep)pData->pLastimgobj;
820	while ((pPrev) && (pPrev->iId > iId))
821	pPrev = (mng_imagep)pPrev->sHeader.pPrev;
822
823	if (pPrev) /* found it ? */
824	{
825	pNew->sHeader.pPrev = pPrev; /* than link it in place */
826	pNew->sHeader.pNext = pPrev->sHeader.pNext;
827	pPrev->sHeader.pNext = pNew;
828	}
829	else /* if not found, it becomes the first ! */
830	{
831	pNew->sHeader.pNext = pData->pFirstimgobj;
832	pData->pFirstimgobj = pNew;
833	}
834
835	pNext = (mng_imagep)pNew->sHeader.pNext;
836
837	if (pNext)
838	pNext->sHeader.pPrev = pNew;
839	else
840	pData->pLastimgobj = pNew;
841
842	}
843
844	if (bPartial) /* partial clone ? */
845	{
846	pNew->pImgbuf = pSource->pImgbuf; /* use the same object buffer */
847	pNew->pImgbuf->iRefcount++; /* and increase the reference count */
848	}
849	else /* create a full clone ! */
850	{
851	mng_bool bConcrete = MNG_FALSE; /* it's abstract by default (?) */
852
853	if (!bAbstract) /* determine concreteness from source ? */
854	bConcrete = pSource->pImgbuf->bConcrete;
855	/* create a full clone ! */
856	iRetcode = mng_clone_imagedataobject (pData, bConcrete, pSource->pImgbuf, &pImgbuf);
857
858	if (iRetcode) /* on error bail out */
859	{
860	MNG_FREEX (pData, pNew, sizeof (mng_image));
861	return iRetcode;
862	}
863
864	pNew->pImgbuf = pImgbuf; /* and remember it */
865	}
866
867	ppClone = pNew; / return it */
868
869	#ifdef MNG_SUPPORT_TRACE
870	MNG_TRACE (pData, MNG_FN_CLONE_IMGOBJECT, MNG_LC_END);
871	#endif
872
873	return MNG_NOERROR;
874	}
875
876	/* ************************************************************************** */
877
878	mng_retcode mng_renum_imageobject (mng_datap pData,
879	mng_imagep pSource,
880	mng_uint16 iId,
881	mng_bool bVisible,
882	mng_bool bAbstract,
883	mng_bool bHasloca,
884	mng_uint8 iLocationtype,
885	mng_int32 iLocationx,
886	mng_int32 iLocationy)
887	{
888	mng_imagep pPrev, pNext;
889
890	#ifdef MNG_SUPPORT_TRACE
891	MNG_TRACE (pData, MNG_FN_RENUM_IMGOBJECT, MNG_LC_START);
892	#endif
893
894	pSource->bVisible = bVisible; /* store the new visibility */
895
896	if (bHasloca) /* location info available ? */
897	{
898	if (iLocationtype == 0) /* absolute position ? */
899	{
900	pSource->iPosx = iLocationx;
901	pSource->iPosy = iLocationy;
902	}
903	else /* relative */
904	{
905	pSource->iPosx = pSource->iPosx + iLocationx;
906	pSource->iPosy = pSource->iPosy + iLocationy;
907	}
908	}
909
910	if (iId) /* not for object 0 */
911	{ /* find previous lower object-id */
912	pPrev = (mng_imagep)pData->pLastimgobj;
913	while ((pPrev) && (pPrev->iId > iId))
914	pPrev = (mng_imagep)pPrev->sHeader.pPrev;
915	/* different from current ? */
916	if (pPrev != (mng_imagep)pSource->sHeader.pPrev)
917	{
918	if (pSource->sHeader.pPrev) /* unlink from current position !! */
919	((mng_imagep)pSource->sHeader.pPrev)->sHeader.pNext = pSource->sHeader.pNext;
920	else
921	pData->pFirstimgobj = pSource->sHeader.pNext;
922
923	if (pSource->sHeader.pNext)
924	((mng_imagep)pSource->sHeader.pNext)->sHeader.pPrev = pSource->sHeader.pPrev;
925	else
926	pData->pLastimgobj = pSource->sHeader.pPrev;
927
928	if (pPrev) /* found the previous ? */
929	{ /* than link it in place */
930	pSource->sHeader.pPrev = pPrev;
931	pSource->sHeader.pNext = pPrev->sHeader.pNext;
932	pPrev->sHeader.pNext = pSource;
933	}
934	else /* if not found, it becomes the first ! */
935	{
936	pSource->sHeader.pNext = pData->pFirstimgobj;
937	pData->pFirstimgobj = pSource;
938	}
939
940	pNext = (mng_imagep)pSource->sHeader.pNext;
941
942	if (pNext)
943	pNext->sHeader.pPrev = pSource;
944	else
945	pData->pLastimgobj = pSource;
946
947	}
948	}
949
950	pSource->iId = iId; /* now set the new id! */
951
952	if (bAbstract) /* force it to abstract ? */
953	pSource->pImgbuf->bConcrete = MNG_FALSE;
954
955	#ifdef MNG_SUPPORT_TRACE
956	MNG_TRACE (pData, MNG_FN_RENUM_IMGOBJECT, MNG_LC_END);
957	#endif
958
959	return MNG_NOERROR;
960	}
961
962	/* ************************************************************************** */
963
964	mng_retcode mng_reset_object_details (mng_datap pData,
965	mng_imagep pImage,
966	mng_uint32 iWidth,
967	mng_uint32 iHeight,
968	mng_uint8 iBitdepth,
969	mng_uint8 iColortype,
970	mng_uint8 iCompression,
971	mng_uint8 iFilter,
972	mng_uint8 iInterlace,
973	mng_bool bResetall)
974	{
975	mng_imagedatap pBuf = pImage->pImgbuf;
976	mng_uint32 iSamplesize = 0;
977	mng_uint32 iRowsize;
978	mng_uint32 iImgdatasize;
979
980	#ifdef MNG_SUPPORT_TRACE
981	MNG_TRACE (pData, MNG_FN_RESET_OBJECTDETAILS, MNG_LC_START);
982	#endif
983
984	pBuf->iWidth = iWidth; /* set buffer characteristics */
985	pBuf->iHeight = iHeight;
986	pBuf->iBitdepth = iBitdepth;
987	pBuf->iColortype = iColortype;
988	pBuf->iCompression = iCompression;
989	pBuf->iFilter = iFilter;
990	pBuf->iInterlace = iInterlace;
991	pBuf->bCorrected = MNG_FALSE;
992	pBuf->iAlphabitdepth = 0;
993	/* determine samplesize from color_type/bit_depth */
994	switch (iColortype) /* for < 8-bit samples we just reserve 8 bits */
995	{
996	case 0 : ; /* gray */
997	case 8 : { /* JPEG gray */
998	#ifndef MNG_NO_16BIT_SUPPORT
999	if (iBitdepth > 8)
1000	iSamplesize = 2;
1001	else
1002	#endif
1003	iSamplesize = 1;
1004
1005	break;
1006	}
1007	case 2 : ; /* rgb */
1008	case 10 : { /* JPEG rgb */
1009	#ifndef MNG_NO_16BIT_SUPPORT
1010	if (iBitdepth > 8)
1011	iSamplesize = 6;
1012	else
1013	#endif
1014	iSamplesize = 3;
1015
1016	break;
1017	}
1018	case 3 : { /* indexed */
1019	iSamplesize = 1;
1020	break;
1021	}
1022	case 4 : ; /* gray+alpha */
1023	case 12 : { /* JPEG gray+alpha */
1024	#ifndef MNG_NO_16BIT_SUPPORT
1025	if (iBitdepth > 8)
1026	iSamplesize = 4;
1027	else
1028	#endif
1029	iSamplesize = 2;
1030
1031	break;
1032	}
1033	case 6 : ; /* rgb+alpha */
1034	case 14 : { /* JPEG rgb+alpha */
1035	#ifndef MNG_NO_16BIT_SUPPORT
1036	if (iBitdepth > 8)
1037	iSamplesize = 8;
1038	else
1039	#endif
1040	iSamplesize = 4;
1041
1042	break;
1043	}
1044	}
1045
1046	iRowsize = iSamplesize * iWidth;
1047	iImgdatasize = iRowsize * iHeight;
1048	/* buffer size changed ? */
1049	if (iImgdatasize != pBuf->iImgdatasize)
1050	{ /* drop the old one */
1051	MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize);
1052
1053	if (iImgdatasize) /* allocate new sample-buffer ? */
1054	MNG_ALLOC (pData, pBuf->pImgdata, iImgdatasize);
1055	}
1056	else
1057	{
1058	if (iImgdatasize) /* clear old buffer */
1059	{
1060	mng_uint8p pTemp = pBuf->pImgdata;
1061	mng_uint32 iX;
1062
1063	for (iX = 0; iX < (iImgdatasize & (mng_uint32)(~3L)); iX += 4)
1064	{
1065	*((mng_uint32p)pTemp) = 0x00000000l;
1066	pTemp += 4;
1067	}
1068
1069	while (pTemp < (pBuf->pImgdata + iImgdatasize))
1070	{
1071	*pTemp = 0;
1072	pTemp++;
1073	}
1074	}
1075	}
1076
1077	pBuf->iSamplesize = iSamplesize; /* remember new sizes */
1078	pBuf->iRowsize = iRowsize;
1079	pBuf->iImgdatasize = iImgdatasize;
1080
1081	if (!pBuf->iPixelsampledepth) /* set delta sampledepths if empty */
1082	pBuf->iPixelsampledepth = iBitdepth;
1083	if (!pBuf->iAlphasampledepth)
1084	pBuf->iAlphasampledepth = iBitdepth;
1085	/* dimension set and clipping not ? */
1086	if ((iWidth) && (iHeight) && (!pImage->bClipped))
1087	{
1088	pImage->iClipl = 0; /* set clipping to dimension by default */
1089	pImage->iClipr = iWidth;
1090	pImage->iClipt = 0;
1091	pImage->iClipb = iHeight;
1092	}
1093
1094	#ifndef MNG_SKIPCHUNK_MAGN
1095	if (pImage->iId) /* reset magnification info ? */
1096	{
1097	pImage->iMAGN_MethodX = 0;
1098	pImage->iMAGN_MethodY = 0;
1099	pImage->iMAGN_MX = 0;
1100	pImage->iMAGN_MY = 0;
1101	pImage->iMAGN_ML = 0;
1102	pImage->iMAGN_MR = 0;
1103	pImage->iMAGN_MT = 0;
1104	pImage->iMAGN_MB = 0;
1105	}
1106	#endif
1107
1108	if (bResetall) /* reset the other characteristics ? */
1109	{
1110	#ifndef MNG_SKIPCHUNK_PAST
1111	pImage->iPastx = 0;
1112	pImage->iPasty = 0;
1113	#endif
1114
1115	pBuf->bHasPLTE = MNG_FALSE;
1116	pBuf->bHasTRNS = MNG_FALSE;
1117	pBuf->bHasGAMA = pData->bHasglobalGAMA;
1118	#ifndef MNG_SKIPCHUNK_cHRM
1119	pBuf->bHasCHRM = pData->bHasglobalCHRM;
1120	#endif
1121	pBuf->bHasSRGB = pData->bHasglobalSRGB;
1122	#ifndef MNG_SKIPCHUNK_iCCP
1123	pBuf->bHasICCP = pData->bHasglobalICCP;
1124	#endif
1125	#ifndef MNG_SKIPCHUNK_bKGD
1126	pBuf->bHasBKGD = pData->bHasglobalBKGD;
1127	#endif
1128
1129	#ifndef MNG_SKIPCHUNK_iCCP
1130	if (pBuf->iProfilesize) /* drop possibly old ICC profile */
1131	{
1132	MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize);
1133	pBuf->iProfilesize = 0;
1134	}
1135	#endif
1136
1137	if (pData->bHasglobalGAMA) /* global gAMA present ? */
1138	pBuf->iGamma = pData->iGlobalGamma;
1139
1140	#ifndef MNG_SKIPCHUNK_cHRM
1141	if (pData->bHasglobalCHRM) /* global cHRM present ? */
1142	{
1143	pBuf->iWhitepointx = pData->iGlobalWhitepointx;
1144	pBuf->iWhitepointy = pData->iGlobalWhitepointy;
1145	pBuf->iPrimaryredx = pData->iGlobalPrimaryredx;
1146	pBuf->iPrimaryredy = pData->iGlobalPrimaryredy;
1147	pBuf->iPrimarygreenx = pData->iGlobalPrimarygreenx;
1148	pBuf->iPrimarygreeny = pData->iGlobalPrimarygreeny;
1149	pBuf->iPrimarybluex = pData->iGlobalPrimarybluex;
1150	pBuf->iPrimarybluey = pData->iGlobalPrimarybluey;
1151	}
1152	#endif
1153
1154	if (pData->bHasglobalSRGB) /* global sRGB present ? */
1155	pBuf->iRenderingintent = pData->iGlobalRendintent;
1156
1157	#ifndef MNG_SKIPCHUNK_iCCP
1158	if (pData->bHasglobalICCP) /* global iCCP present ? */
1159	{
1160	if (pData->iGlobalProfilesize)
1161	{
1162	MNG_ALLOC (pData, pBuf->pProfile, pData->iGlobalProfilesize);
1163	MNG_COPY (pBuf->pProfile, pData->pGlobalProfile, pData->iGlobalProfilesize);
1164	}
1165
1166	pBuf->iProfilesize = pData->iGlobalProfilesize;
1167	}
1168	#endif
1169
1170	#ifndef MNG_SKIPCHUNK_bKGD
1171	if (pData->bHasglobalBKGD) /* global bKGD present ? */
1172	{
1173	pBuf->iBKGDred = pData->iGlobalBKGDred;
1174	pBuf->iBKGDgreen = pData->iGlobalBKGDgreen;
1175	pBuf->iBKGDblue = pData->iGlobalBKGDblue;
1176	}
1177	#endif
1178	}
1179
1180	#ifdef MNG_SUPPORT_TRACE
1181	MNG_TRACE (pData, MNG_FN_RESET_OBJECTDETAILS, MNG_LC_END);
1182	#endif
1183
1184	return MNG_NOERROR;
1185	}
1186
1187	/* ************************************************************************** */
1188
1189	#if !defined(MNG_NO_DELTA_PNG) \|\| !defined(MNG_SKIPCHUNK_PAST) \|\| !defined(MNG_SKIPCHUNK_MAGN)
1190	mng_retcode mng_promote_imageobject (mng_datap pData,
1191	mng_imagep pImage,
1192	mng_uint8 iBitdepth,
1193	mng_uint8 iColortype,
1194	mng_uint8 iFilltype)
1195	{
1196	mng_retcode iRetcode = MNG_NOERROR;
1197	mng_imagedatap pBuf = pImage->pImgbuf;
1198	mng_uint32 iW = pBuf->iWidth;
1199	mng_uint32 iH = pBuf->iHeight;
1200	mng_uint8p pNewbuf;
1201	mng_uint32 iNewbufsize;
1202	mng_uint32 iNewrowsize;
1203	mng_uint32 iNewsamplesize = pBuf->iSamplesize;
1204	mng_uint32 iY;
1205	mng_uint8 iTempdepth;
1206
1207	#ifdef MNG_SUPPORT_TRACE
1208	MNG_TRACE (pData, MNG_FN_PROMOTE_IMGOBJECT, MNG_LC_START);
1209	#endif
1210
1211	#ifdef MNG_NO_1_2_4BIT_SUPPORT
1212	if (iBitdepth < 8)
1213	iBitdepth=8;
1214	if (pBuf->iBitdepth < 8)
1215	pBuf->iBitdepth=8;
1216	#endif
1217	#ifdef MNG_NO_16BIT_SUPPORT
1218	if (iBitdepth > 8)
1219	iBitdepth=8;
1220	if (pBuf->iBitdepth > 8)
1221	pBuf->iBitdepth=8;
1222	#endif
1223
1224	pData->fPromoterow = MNG_NULL; /* init promotion fields */
1225	pData->fPromBitdepth = MNG_NULL;
1226	pData->iPromColortype = iColortype;
1227	pData->iPromBitdepth = iBitdepth;
1228	pData->iPromFilltype = iFilltype;
1229
1230	if (iBitdepth != pBuf->iBitdepth) /* determine bitdepth promotion */
1231	{
1232	if (pBuf->iColortype == MNG_COLORTYPE_INDEXED)
1233	iTempdepth = 8;
1234	else
1235	iTempdepth = pBuf->iBitdepth;
1236
1237	#ifndef MNG_NO_DELTA_PNG
1238	if (iFilltype == MNG_FILLMETHOD_ZEROFILL)
1239	{
1240	switch (iTempdepth)
1241	{
1242	#ifndef MNG_NO_1_2_4BIT_SUPPORT
1243	case 1 : {
1244	switch (iBitdepth)
1245	{
1246	case 2 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_2; break; }
1247	case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_4; break; }
1248	case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_8; break; }
1249	#ifndef MNG_NO_16BIT_SUPPORT
1250	case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_1_16; break; }
1251	#endif
1252	}
1253	break;
1254	}
1255	case 2 : {
1256	switch (iBitdepth)
1257	{
1258	case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_2_4; break; }
1259	case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_2_8; break; }
1260	#ifndef MNG_NO_16BIT_SUPPORT
1261	case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_2_16; break; }
1262	#endif
1263	}
1264	break;
1265	}
1266	case 4 : {
1267	switch (iBitdepth)
1268	{
1269	case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_4_8; break; }
1270	#ifndef MNG_NO_16BIT_SUPPORT
1271	case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_4_16; break; }
1272	#endif
1273	}
1274	break;
1275	}
1276	#endif /* MNG_NO_1_2_4BIT_SUPPORT */
1277	case 8 : {
1278	#ifndef MNG_NO_16BIT_SUPPORT
1279	if (iBitdepth == 16)
1280	pData->fPromBitdepth = (mng_fptr)mng_promote_zerofill_8_16;
1281	#endif
1282	break;
1283	}
1284	}
1285	}
1286	else
1287	#endif
1288	{
1289	switch (iTempdepth)
1290	{
1291	#ifndef MNG_NO_1_2_4BIT_SUPPORT
1292	case 1 : {
1293	switch (iBitdepth)
1294	{
1295	case 2 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_2; break; }
1296	case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_4; break; }
1297	case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_8; break; }
1298	#ifndef MNG_NO_16BIT_SUPPORT
1299	case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_1_16; break; }
1300	#endif
1301	}
1302	break;
1303	}
1304	case 2 : {
1305	switch (iBitdepth)
1306	{
1307	case 4 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_2_4; break; }
1308	case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_2_8; break; }
1309	#ifndef MNG_NO_16BIT_SUPPORT
1310	case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_2_16; break; }
1311	#endif
1312	}
1313	break;
1314	}
1315	case 4 : {
1316	switch (iBitdepth)
1317	{
1318	case 8 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_4_8; break; }
1319	#ifndef MNG_NO_16BIT_SUPPORT
1320	case 16 : { pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_4_16; break; }
1321	#endif
1322	}
1323	break;
1324	}
1325	#endif /* MNG_NO_1_2_4BIT_SUPPORT */
1326	case 8 : {
1327	#ifndef MNG_NO_16BIT_SUPPORT
1328	if (iBitdepth == 16)
1329	pData->fPromBitdepth = (mng_fptr)mng_promote_replicate_8_16;
1330	#endif
1331	break;
1332	}
1333	}
1334	}
1335	}
1336	/* g -> g */
1337	if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
1338	(iColortype == MNG_COLORTYPE_GRAY))
1339	{
1340	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1341	{
1342	#ifndef MNG_NO_16BIT_SUPPORT
1343	if (iBitdepth == 16)
1344	pData->fPromoterow = (mng_fptr)mng_promote_g8_g16;
1345	else
1346	#endif
1347	pData->fPromoterow = (mng_fptr)mng_promote_g8_g8;
1348	}
1349
1350	iNewsamplesize = 1;
1351
1352	#ifndef MNG_NO_16BIT_SUPPORT
1353	if (iBitdepth == 16) /* 16-bit wide ? */
1354	iNewsamplesize = 2;
1355	#endif
1356	}
1357	else /* g -> ga */
1358	if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
1359	(iColortype == MNG_COLORTYPE_GRAYA))
1360	{
1361	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1362	{
1363	#ifndef MNG_NO_16BIT_SUPPORT
1364	if (iBitdepth == 16)
1365	pData->fPromoterow = (mng_fptr)mng_promote_g8_ga16;
1366	else
1367	#endif
1368	pData->fPromoterow = (mng_fptr)mng_promote_g8_ga8;
1369	}
1370	#ifndef MNG_NO_16BIT_SUPPORT
1371	else /* source = 16 bits */
1372	pData->fPromoterow = (mng_fptr)mng_promote_g16_ga16;
1373	#endif
1374
1375	iNewsamplesize = 2;
1376
1377	#ifndef MNG_NO_16BIT_SUPPORT
1378	if (iBitdepth == 16) /* 16-bit wide ? */
1379	iNewsamplesize = 4;
1380	#endif
1381	}
1382	else /* g -> rgb */
1383	if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
1384	(iColortype == MNG_COLORTYPE_RGB))
1385	{
1386	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1387	{
1388	#ifndef MNG_NO_16BIT_SUPPORT
1389	if (iBitdepth == 16)
1390	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb16;
1391	else
1392	#endif
1393	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb8;
1394	}
1395	#ifndef MNG_NO_16BIT_SUPPORT
1396	else /* source = 16 bits */
1397	pData->fPromoterow = (mng_fptr)mng_promote_g16_rgb16;
1398	#endif
1399
1400	iNewsamplesize = 3;
1401
1402	#ifndef MNG_NO_16BIT_SUPPORT
1403	if (iBitdepth == 16) /* 16-bit wide ? */
1404	iNewsamplesize = 6;
1405	#endif
1406	}
1407	else /* g -> rgba */
1408	if ((pBuf->iColortype == MNG_COLORTYPE_GRAY) &&
1409	(iColortype == MNG_COLORTYPE_RGBA))
1410	{
1411	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1412	{
1413	#ifndef MNG_NO_16BIT_SUPPORT
1414	if (iBitdepth == 16)
1415	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba16;
1416	else
1417	#endif
1418	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba8;
1419	}
1420	#ifndef MNG_NO_16BIT_SUPPORT
1421	else /* source = 16 bits */
1422	pData->fPromoterow = (mng_fptr)mng_promote_g16_rgba16;
1423	#endif
1424
1425	iNewsamplesize = 4;
1426
1427	#ifndef MNG_NO_16BIT_SUPPORT
1428	if (iBitdepth == 16) /* 16-bit wide ? */
1429	iNewsamplesize = 8;
1430	#endif
1431	}
1432	else /* ga -> ga */
1433	if ((pBuf->iColortype == MNG_COLORTYPE_GRAYA) &&
1434	(iColortype == MNG_COLORTYPE_GRAYA))
1435	{
1436	iNewsamplesize = 2;
1437	#ifndef MNG_NO_16BIT_SUPPORT
1438	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1439	if (iBitdepth == 16)
1440	pData->fPromoterow = (mng_fptr)mng_promote_ga8_ga16;
1441	if (iBitdepth == 16)
1442	iNewsamplesize = 4;
1443	#endif
1444	}
1445	else /* ga -> rgba */
1446	if ((pBuf->iColortype == MNG_COLORTYPE_GRAYA) &&
1447	(iColortype == MNG_COLORTYPE_RGBA))
1448	{
1449	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1450	{
1451	#ifndef MNG_NO_16BIT_SUPPORT
1452	if (iBitdepth == 16)
1453	pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba16;
1454	else
1455	#endif
1456	pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba8;
1457	}
1458	#ifndef MNG_NO_16BIT_SUPPORT
1459	else /* source = 16 bits */
1460	pData->fPromoterow = (mng_fptr)mng_promote_ga16_rgba16;
1461	#endif
1462
1463	iNewsamplesize = 4;
1464
1465	#ifndef MNG_NO_16BIT_SUPPORT
1466	if (iBitdepth == 16) /* 16-bit wide ? */
1467	iNewsamplesize = 8;
1468	#endif
1469	}
1470	else /* rgb -> rgb */
1471	if ((pBuf->iColortype == MNG_COLORTYPE_RGB) &&
1472	(iColortype == MNG_COLORTYPE_RGB))
1473	{
1474	iNewsamplesize = 3;
1475	#ifndef MNG_NO_16BIT_SUPPORT
1476	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1477	if (iBitdepth == 16)
1478	pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgb16;
1479	if (iBitdepth == 16)
1480	iNewsamplesize = 6;
1481	#endif
1482	}
1483	else /* rgb -> rgba */
1484	if ((pBuf->iColortype == MNG_COLORTYPE_RGB) &&
1485	(iColortype == MNG_COLORTYPE_RGBA))
1486	{
1487	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1488	{
1489	#ifndef MNG_NO_16BIT_SUPPORT
1490	if (iBitdepth == 16)
1491	pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba16;
1492	else
1493	#endif
1494	pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba8;
1495	}
1496	#ifndef MNG_NO_16BIT_SUPPORT
1497	else /* source = 16 bits */
1498	pData->fPromoterow = (mng_fptr)mng_promote_rgb16_rgba16;
1499	#endif
1500
1501	iNewsamplesize = 4;
1502	#ifndef MNG_NO_16BIT_SUPPORT
1503	if (iBitdepth == 16) /* 16-bit wide ? */
1504	iNewsamplesize = 8;
1505	#endif
1506	}
1507	else /* indexed -> rgb */
1508	if ((pBuf->iColortype == MNG_COLORTYPE_INDEXED) &&
1509	(iColortype == MNG_COLORTYPE_RGB))
1510	{
1511	#ifndef MNG_NO_16BIT_SUPPORT
1512	if (iBitdepth == 16)
1513	pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgb16;
1514	else
1515	#endif
1516	pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgb8;
1517
1518	iNewsamplesize = 3;
1519
1520	#ifndef MNG_NO_16BIT_SUPPORT
1521	if (iBitdepth == 16) /* 16-bit wide ? */
1522	iNewsamplesize = 6;
1523	#endif
1524	}
1525	else /* indexed -> rgba */
1526	if ((pBuf->iColortype == MNG_COLORTYPE_INDEXED) &&
1527	(iColortype == MNG_COLORTYPE_RGBA))
1528	{
1529	#ifndef MNG_NO_16BIT_SUPPORT
1530	if (iBitdepth == 16)
1531	pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgba16;
1532	else
1533	#endif
1534	pData->fPromoterow = (mng_fptr)mng_promote_idx8_rgba8;
1535
1536	iNewsamplesize = 4;
1537
1538	#ifndef MNG_NO_16BIT_SUPPORT
1539	if (iBitdepth == 16) /* 16-bit wide ? */
1540	iNewsamplesize = 8;
1541	#endif
1542	}
1543	else /* rgba -> rgba */
1544	if ((pBuf->iColortype == MNG_COLORTYPE_RGBA) &&
1545	(iColortype == MNG_COLORTYPE_RGBA))
1546	{
1547	iNewsamplesize = 4;
1548	#ifndef MNG_NO_16BIT_SUPPORT
1549	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1550	{
1551	if (iBitdepth == 16)
1552	pData->fPromoterow = (mng_fptr)mng_promote_rgba8_rgba16;
1553	}
1554	if (iBitdepth == 16) /* 16-bit wide ? */
1555	iNewsamplesize = 8;
1556	#endif
1557	}
1558	#ifdef MNG_INCLUDE_JNG
1559	else /* JPEG g -> g */
1560	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
1561	(iColortype == MNG_COLORTYPE_JPEGGRAY))
1562	{
1563	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1564	{
1565	#ifndef MNG_NO_16BIT_SUPPORT
1566	if (iBitdepth == 16)
1567	pData->fPromoterow = (mng_fptr)mng_promote_g8_g16;
1568	else
1569	#endif
1570	pData->fPromoterow = (mng_fptr)mng_promote_g8_g8;
1571	}
1572
1573	iNewsamplesize = 1;
1574
1575	#ifndef MNG_NO_16BIT_SUPPORT
1576	if (iBitdepth == 16) /* 16-bit wide ? */
1577	iNewsamplesize = 2;
1578	#endif
1579	}
1580	else /* JPEG g -> ga */
1581	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
1582	(iColortype == MNG_COLORTYPE_JPEGGRAYA))
1583	{
1584	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1585	{
1586	#ifndef MNG_NO_16BIT_SUPPORT
1587	if (iBitdepth == 16)
1588	pData->fPromoterow = (mng_fptr)mng_promote_g8_ga16;
1589	else
1590	#endif
1591	pData->fPromoterow = (mng_fptr)mng_promote_g8_ga8;
1592	}
1593	#ifndef MNG_NO_16BIT_SUPPORT
1594	else /* source = 16 bits */
1595	pData->fPromoterow = (mng_fptr)mng_promote_g16_ga16;
1596	#endif
1597
1598	iNewsamplesize = 2;
1599
1600	#ifndef MNG_NO_16BIT_SUPPORT
1601	if (iBitdepth == 16) /* 16-bit wide ? */
1602	iNewsamplesize = 4;
1603	#endif
1604	}
1605	else /* JPEG g -> rgb */
1606	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
1607	(iColortype == MNG_COLORTYPE_JPEGCOLOR))
1608	{
1609	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1610	{
1611	#ifndef MNG_NO_16BIT_SUPPORT
1612	if (iBitdepth == 16)
1613	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb16;
1614	else
1615	#endif
1616	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgb8;
1617	}
1618	#ifndef MNG_NO_16BIT_SUPPORT
1619	else /* source = 16 bits */
1620	pData->fPromoterow = (mng_fptr)mng_promote_g16_rgb16;
1621	#endif
1622
1623	iNewsamplesize = 3;
1624
1625	#ifndef MNG_NO_16BIT_SUPPORT
1626	if (iBitdepth == 16) /* 16-bit wide ? */
1627	iNewsamplesize = 6;
1628	#endif
1629	}
1630	else /* JPEG g -> rgba */
1631	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAY) &&
1632	(iColortype == MNG_COLORTYPE_JPEGCOLORA))
1633	{
1634	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1635	{
1636	#ifndef MNG_NO_16BIT_SUPPORT
1637	if (iBitdepth == 16)
1638	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba16;
1639	else
1640	#endif
1641	pData->fPromoterow = (mng_fptr)mng_promote_g8_rgba8;
1642	}
1643	#ifndef MNG_NO_16BIT_SUPPORT
1644	else /* source = 16 bits */
1645	pData->fPromoterow = (mng_fptr)mng_promote_g16_rgba16;
1646	#endif
1647
1648	iNewsamplesize = 4;
1649
1650	#ifndef MNG_NO_16BIT_SUPPORT
1651	if (iBitdepth == 16) /* 16-bit wide ? */
1652	iNewsamplesize = 8;
1653	#endif
1654	}
1655	else /* JPEG ga -> ga */
1656	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAYA) &&
1657	(iColortype == MNG_COLORTYPE_JPEGGRAYA))
1658	{
1659	iNewsamplesize = 2;
1660	#ifndef MNG_NO_16BIT_SUPPORT
1661	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1662	if (iBitdepth == 16)
1663	pData->fPromoterow = (mng_fptr)mng_promote_ga8_ga16;
1664	if (iBitdepth == 16)
1665	iNewsamplesize = 4;
1666	#endif
1667
1668	}
1669	else /* JPEG ga -> rgba */
1670	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGGRAYA) &&
1671	(iColortype == MNG_COLORTYPE_JPEGCOLORA))
1672	{
1673	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1674	{
1675	#ifndef MNG_NO_16BIT_SUPPORT
1676	if (iBitdepth == 16)
1677	pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba16;
1678	else
1679	#endif
1680	pData->fPromoterow = (mng_fptr)mng_promote_ga8_rgba8;
1681	}
1682	#ifndef MNG_NO_16BIT_SUPPORT
1683	else /* source = 16 bits */
1684	pData->fPromoterow = (mng_fptr)mng_promote_ga16_rgba16;
1685	#endif
1686
1687	iNewsamplesize = 4;
1688
1689	#ifndef MNG_NO_16BIT_SUPPORT
1690	if (iBitdepth == 16) /* 16-bit wide ? */
1691	iNewsamplesize = 8;
1692	#endif
1693	}
1694	else /* JPEG rgb -> rgb */
1695	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGCOLOR) &&
1696	(iColortype == MNG_COLORTYPE_JPEGCOLOR))
1697	{
1698	iNewsamplesize = 3;
1699	#ifndef MNG_NO_16BIT_SUPPORT
1700	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1701	if (iBitdepth == 16)
1702	pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgb16;
1703	if (iBitdepth == 16)
1704	iNewsamplesize = 6;
1705	#endif
1706
1707	}
1708	else /* JPEG rgb -> rgba */
1709	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGCOLOR) &&
1710	(iColortype == MNG_COLORTYPE_JPEGCOLORA))
1711	{
1712	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1713	{
1714	#ifndef MNG_NO_16BIT_SUPPORT
1715	if (iBitdepth == 16)
1716	pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba16;
1717	else
1718	#endif
1719	pData->fPromoterow = (mng_fptr)mng_promote_rgb8_rgba8;
1720	}
1721	#ifndef MNG_NO_16BIT_SUPPORT
1722	else /* source = 16 bits */
1723	pData->fPromoterow = (mng_fptr)mng_promote_rgb16_rgba16;
1724	#endif
1725
1726	iNewsamplesize = 4;
1727
1728	#ifndef MNG_NO_16BIT_SUPPORT
1729	if (iBitdepth == 16) /* 16-bit wide ? */
1730	iNewsamplesize = 8;
1731	#endif
1732	}
1733	else /* JPEG rgba -> rgba */
1734	if ((pBuf->iColortype == MNG_COLORTYPE_JPEGCOLORA) &&
1735	(iColortype == MNG_COLORTYPE_JPEGCOLORA))
1736	{
1737	iNewsamplesize = 4;
1738	#ifndef MNG_NO_16BIT_SUPPORT
1739	if (pBuf->iBitdepth <= 8) /* source <= 8 bits */
1740	if (iBitdepth == 16)
1741	pData->fPromoterow = (mng_fptr)mng_promote_rgba8_rgba16;
1742	if (iBitdepth == 16)
1743	iNewsamplesize = 8;
1744	#endif
1745	}
1746	#endif /* JNG */
1747
1748	/* found a proper promotion ? */
1749	if (pData->fPromoterow)
1750	{
1751	pData->pPromBuf = (mng_ptr)pBuf;
1752	pData->iPromWidth = pBuf->iWidth;
1753	iNewrowsize = iW * iNewsamplesize;
1754	iNewbufsize = iH * iNewrowsize;
1755
1756	MNG_ALLOC (pData, pNewbuf, iNewbufsize);
1757
1758	pData->pPromSrc = (mng_ptr)pBuf->pImgdata;
1759	pData->pPromDst = (mng_ptr)pNewbuf;
1760	iY = 0;
1761
1762	while ((!iRetcode) && (iY < iH))
1763	{
1764	iRetcode = ((mng_promoterow)pData->fPromoterow) (pData);
1765	pData->pPromSrc = (mng_uint8p)pData->pPromSrc + pBuf->iRowsize;
1766	pData->pPromDst = (mng_uint8p)pData->pPromDst + iNewrowsize;
1767	/* pData->pPromSrc = (mng_ptr)((mng_uint32)pData->pPromSrc + pBuf->iRowsize); */
1768	/* pData->pPromDst = (mng_ptr)((mng_uint32)pData->pPromDst + iNewrowsize); */
1769	iY++;
1770	}
1771
1772	MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize);
1773
1774	pBuf->iBitdepth = iBitdepth;
1775	pBuf->iColortype = iColortype;
1776	pBuf->iSamplesize = iNewsamplesize;
1777	pBuf->iRowsize = iNewrowsize;
1778	pBuf->iImgdatasize = iNewbufsize;
1779	pBuf->pImgdata = pNewbuf;
1780	pBuf->bHasPLTE = MNG_FALSE;
1781	pBuf->iPLTEcount = 0;
1782	pBuf->bHasTRNS = MNG_FALSE;
1783	pBuf->iTRNScount = 0;
1784
1785	if (iRetcode) /* on error bail out */
1786	return iRetcode;
1787	}
1788
1789	#ifdef MNG_SUPPORT_TRACE
1790	MNG_TRACE (pData, MNG_FN_PROMOTE_IMGOBJECT, MNG_LC_END);
1791	#endif
1792
1793	return MNG_NOERROR;
1794	}
1795	#endif
1796
1797	/* ************************************************************************** */
1798
1799	#ifndef MNG_SKIPCHUNK_MAGN
1800	mng_retcode mng_magnify_imageobject (mng_datap pData,
1801	mng_imagep pImage)
1802	{
1803	mng_uint8p pNewdata;
1804	mng_uint8p pSrcline1;
1805	mng_uint8p pSrcline2;
1806	mng_uint8p pTempline;
1807	mng_uint8p pDstline;
1808	mng_uint32 iNewrowsize;
1809	mng_uint32 iNewsize;
1810	mng_uint32 iY;
1811	mng_int32 iS, iM;
1812	mng_retcode iRetcode;
1813
1814	mng_imagedatap pBuf = pImage->pImgbuf;
1815	mng_uint32 iNewW = pBuf->iWidth;
1816	mng_uint32 iNewH = pBuf->iHeight;
1817	mng_magnify_x fMagnifyX = MNG_NULL;
1818	mng_magnify_y fMagnifyY = MNG_NULL;
1819
1820	#ifdef MNG_SUPPORT_TRACE
1821	MNG_TRACE (pData, MNG_FN_MAGNIFY_IMGOBJECT, MNG_LC_START);
1822	#endif
1823
1824	if (pBuf->iColortype == MNG_COLORTYPE_INDEXED) /* indexed color ? */
1825	{ /* concrete buffer ? */
1826	if ((pBuf->bConcrete) && (pImage->iId))
1827	MNG_ERROR (pData, MNG_INVALIDCOLORTYPE);
1828
1829	#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
1830	if (pBuf->iTRNScount) /* with transparency ? */
1831	iRetcode = mng_promote_imageobject (pData, pImage, 8, 6, 0);
1832	else
1833	iRetcode = mng_promote_imageobject (pData, pImage, 8, 2, 0);
1834
1835	if (iRetcode) /* on error bail out */
1836	return iRetcode;
1837	#endif
1838	}
1839
1840	#ifdef MNG_OPTIMIZE_FOOTPRINT_MAGN
1841	/* Promote everything to RGBA, using fill method 0 (LBR) */
1842	iRetcode = mng_promote_imageobject (pData, pImage, 8, 6, 0);
1843	if (iRetcode) /* on error bail out */
1844	return iRetcode;
1845	#endif
1846
1847	if (pImage->iMAGN_MethodX) /* determine new width */
1848	{
1849	if (pImage->iMAGN_MethodX == 1)
1850	{
1851	iNewW = pImage->iMAGN_ML;
1852	if (pBuf->iWidth > 1)
1853	iNewW = iNewW + pImage->iMAGN_MR;
1854	if (pBuf->iWidth > 2)
1855	iNewW = iNewW + (pBuf->iWidth - 2) * (pImage->iMAGN_MX);
1856	}
1857	else
1858	{
1859	iNewW = pBuf->iWidth + pImage->iMAGN_ML - 1;
1860	if (pBuf->iWidth > 2)
1861	iNewW = iNewW + pImage->iMAGN_MR - 1;
1862	if (pBuf->iWidth > 3)
1863	iNewW = iNewW + (pBuf->iWidth - 3) * (pImage->iMAGN_MX - 1);
1864	}
1865	}
1866
1867	if (pImage->iMAGN_MethodY) /* determine new height */
1868	{
1869	if (pImage->iMAGN_MethodY == 1)
1870	{
1871	iNewH = pImage->iMAGN_MT;
1872	if (pBuf->iHeight > 1)
1873	iNewH = iNewH + pImage->iMAGN_ML;
1874	if (pBuf->iHeight > 2)
1875	iNewH = iNewH + (pBuf->iHeight - 2) * (pImage->iMAGN_MY);
1876	}
1877	else
1878	{
1879	iNewH = pBuf->iHeight + pImage->iMAGN_MT - 1;
1880	if (pBuf->iHeight > 2)
1881	iNewH = iNewH + pImage->iMAGN_MB - 1;
1882	if (pBuf->iHeight > 3)
1883	iNewH = iNewH + (pBuf->iHeight - 3) * (pImage->iMAGN_MY - 1);
1884	}
1885	}
1886	/* get new buffer */
1887	iNewrowsize = iNewW * pBuf->iSamplesize;
1888	iNewsize = iNewH * iNewrowsize;
1889
1890	MNG_ALLOC (pData, pNewdata, iNewsize);
1891
1892	switch (pBuf->iColortype) /* determine magnification routines */
1893	{
1894	#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
1895	case 0 : ;
1896	case 8 : {
1897	if (pBuf->iBitdepth <= 8)
1898	{
1899	switch (pImage->iMAGN_MethodX)
1900	{
1901	case 1 : { fMagnifyX = mng_magnify_g8_x1; break; }
1902	case 2 : { fMagnifyX = mng_magnify_g8_x2; break; }
1903	case 3 : { fMagnifyX = mng_magnify_g8_x3; break; }
1904	case 4 : { fMagnifyX = mng_magnify_g8_x2; break; }
1905	case 5 : { fMagnifyX = mng_magnify_g8_x3; break; }
1906	}
1907
1908	switch (pImage->iMAGN_MethodY)
1909	{
1910	case 1 : { fMagnifyY = mng_magnify_g8_y1; break; }
1911	case 2 : { fMagnifyY = mng_magnify_g8_y2; break; }
1912	case 3 : { fMagnifyY = mng_magnify_g8_y3; break; }
1913	case 4 : { fMagnifyY = mng_magnify_g8_y2; break; }
1914	case 5 : { fMagnifyY = mng_magnify_g8_y3; break; }
1915	}
1916	}
1917	#ifndef MNG_NO_16BIT_SUPPORT
1918	else
1919	{
1920	switch (pImage->iMAGN_MethodX)
1921	{
1922	case 1 : { fMagnifyX = mng_magnify_g16_x1; break; }
1923	case 2 : { fMagnifyX = mng_magnify_g16_x2; break; }
1924	case 3 : { fMagnifyX = mng_magnify_g16_x3; break; }
1925	case 4 : { fMagnifyX = mng_magnify_g16_x2; break; }
1926	case 5 : { fMagnifyX = mng_magnify_g16_x3; break; }
1927	}
1928
1929	switch (pImage->iMAGN_MethodY)
1930	{
1931	case 1 : { fMagnifyY = mng_magnify_g16_y1; break; }
1932	case 2 : { fMagnifyY = mng_magnify_g16_y2; break; }
1933	case 3 : { fMagnifyY = mng_magnify_g16_y3; break; }
1934	case 4 : { fMagnifyY = mng_magnify_g16_y2; break; }
1935	case 5 : { fMagnifyY = mng_magnify_g16_y3; break; }
1936	}
1937	}
1938	#endif
1939
1940	break;
1941	}
1942
1943	case 2 : ;
1944	case 10 : {
1945	if (pBuf->iBitdepth <= 8)
1946	{
1947	switch (pImage->iMAGN_MethodX)
1948	{
1949	case 1 : { fMagnifyX = mng_magnify_rgb8_x1; break; }
1950	case 2 : { fMagnifyX = mng_magnify_rgb8_x2; break; }
1951	case 3 : { fMagnifyX = mng_magnify_rgb8_x3; break; }
1952	case 4 : { fMagnifyX = mng_magnify_rgb8_x2; break; }
1953	case 5 : { fMagnifyX = mng_magnify_rgb8_x3; break; }
1954	}
1955
1956	switch (pImage->iMAGN_MethodY)
1957	{
1958	case 1 : { fMagnifyY = mng_magnify_rgb8_y1; break; }
1959	case 2 : { fMagnifyY = mng_magnify_rgb8_y2; break; }
1960	case 3 : { fMagnifyY = mng_magnify_rgb8_y3; break; }
1961	case 4 : { fMagnifyY = mng_magnify_rgb8_y2; break; }
1962	case 5 : { fMagnifyY = mng_magnify_rgb8_y3; break; }
1963	}
1964	}
1965	#ifndef MNG_NO_16BIT_SUPPORT
1966	else
1967	{
1968	switch (pImage->iMAGN_MethodX)
1969	{
1970	case 1 : { fMagnifyX = mng_magnify_rgb16_x1; break; }
1971	case 2 : { fMagnifyX = mng_magnify_rgb16_x2; break; }
1972	case 3 : { fMagnifyX = mng_magnify_rgb16_x3; break; }
1973	case 4 : { fMagnifyX = mng_magnify_rgb16_x2; break; }
1974	case 5 : { fMagnifyX = mng_magnify_rgb16_x3; break; }
1975	}
1976
1977	switch (pImage->iMAGN_MethodY)
1978	{
1979	case 1 : { fMagnifyY = mng_magnify_rgb16_y1; break; }
1980	case 2 : { fMagnifyY = mng_magnify_rgb16_y2; break; }
1981	case 3 : { fMagnifyY = mng_magnify_rgb16_y3; break; }
1982	case 4 : { fMagnifyY = mng_magnify_rgb16_y2; break; }
1983	case 5 : { fMagnifyY = mng_magnify_rgb16_y3; break; }
1984	}
1985	}
1986	#endif
1987
1988	break;
1989	}
1990
1991	case 4 : ;
1992	case 12 : {
1993	if (pBuf->iBitdepth <= 8)
1994	{
1995	switch (pImage->iMAGN_MethodX)
1996	{
1997	case 1 : { fMagnifyX = mng_magnify_ga8_x1; break; }
1998	case 2 : { fMagnifyX = mng_magnify_ga8_x2; break; }
1999	case 3 : { fMagnifyX = mng_magnify_ga8_x3; break; }
2000	case 4 : { fMagnifyX = mng_magnify_ga8_x4; break; }
2001	case 5 : { fMagnifyX = mng_magnify_ga8_x5; break; }
2002	}
2003
2004	switch (pImage->iMAGN_MethodY)
2005	{
2006	case 1 : { fMagnifyY = mng_magnify_ga8_y1; break; }
2007	case 2 : { fMagnifyY = mng_magnify_ga8_y2; break; }
2008	case 3 : { fMagnifyY = mng_magnify_ga8_y3; break; }
2009	case 4 : { fMagnifyY = mng_magnify_ga8_y4; break; }
2010	case 5 : { fMagnifyY = mng_magnify_ga8_y5; break; }
2011	}
2012	}
2013	#ifndef MNG_NO_16BIT_SUPPORT
2014	else
2015	{
2016	switch (pImage->iMAGN_MethodX)
2017	{
2018	case 1 : { fMagnifyX = mng_magnify_ga16_x1; break; }
2019	case 2 : { fMagnifyX = mng_magnify_ga16_x2; break; }
2020	case 3 : { fMagnifyX = mng_magnify_ga16_x3; break; }
2021	case 4 : { fMagnifyX = mng_magnify_ga16_x4; break; }
2022	case 5 : { fMagnifyX = mng_magnify_ga16_x5; break; }
2023	}
2024
2025	switch (pImage->iMAGN_MethodY)
2026	{
2027	case 1 : { fMagnifyY = mng_magnify_ga16_y1; break; }
2028	case 2 : { fMagnifyY = mng_magnify_ga16_y2; break; }
2029	case 3 : { fMagnifyY = mng_magnify_ga16_y3; break; }
2030	case 4 : { fMagnifyY = mng_magnify_ga16_y4; break; }
2031	case 5 : { fMagnifyY = mng_magnify_ga16_y5; break; }
2032	}
2033	}
2034	#endif
2035
2036	break;
2037	}
2038	#endif
2039
2040	case 6 : ;
2041	case 14 : {
2042	if (pBuf->iBitdepth <= 8)
2043	{
2044	switch (pImage->iMAGN_MethodX)
2045	{
2046	case 1 : { fMagnifyX = mng_magnify_rgba8_x1; break; }
2047	case 2 : { fMagnifyX = mng_magnify_rgba8_x2; break; }
2048	case 3 : { fMagnifyX = mng_magnify_rgba8_x3; break; }
2049	case 4 : { fMagnifyX = mng_magnify_rgba8_x4; break; }
2050	case 5 : { fMagnifyX = mng_magnify_rgba8_x5; break; }
2051	}
2052
2053	switch (pImage->iMAGN_MethodY)
2054	{
2055	case 1 : { fMagnifyY = mng_magnify_rgba8_y1; break; }
2056	case 2 : { fMagnifyY = mng_magnify_rgba8_y2; break; }
2057	case 3 : { fMagnifyY = mng_magnify_rgba8_y3; break; }
2058	case 4 : { fMagnifyY = mng_magnify_rgba8_y4; break; }
2059	case 5 : { fMagnifyY = mng_magnify_rgba8_y5; break; }
2060	}
2061	}
2062	#ifndef MNG_NO_16BIT_SUPPORT
2063	#ifndef MNG_OPTIMIZE_FOOTPRINT_MAGN
2064	else
2065	{
2066	switch (pImage->iMAGN_MethodX)
2067	{
2068	case 1 : { fMagnifyX = mng_magnify_rgba16_x1; break; }
2069	case 2 : { fMagnifyX = mng_magnify_rgba16_x2; break; }
2070	case 3 : { fMagnifyX = mng_magnify_rgba16_x3; break; }
2071	case 4 : { fMagnifyX = mng_magnify_rgba16_x4; break; }
2072	case 5 : { fMagnifyX = mng_magnify_rgba16_x5; break; }
2073	}
2074
2075	switch (pImage->iMAGN_MethodY)
2076	{
2077	case 1 : { fMagnifyY = mng_magnify_rgba16_y1; break; }
2078	case 2 : { fMagnifyY = mng_magnify_rgba16_y2; break; }
2079	case 3 : { fMagnifyY = mng_magnify_rgba16_y3; break; }
2080	case 4 : { fMagnifyY = mng_magnify_rgba16_y4; break; }
2081	case 5 : { fMagnifyY = mng_magnify_rgba16_y5; break; }
2082	}
2083	}
2084	#endif
2085	#endif
2086	break;
2087	}
2088	}
2089
2090	pSrcline1 = pBuf->pImgdata; /* initialize row-loop variables */
2091	pDstline = pNewdata;
2092	/* allocate temporary row */
2093	MNG_ALLOC (pData, pTempline, iNewrowsize);
2094
2095	for (iY = 0; iY < pBuf->iHeight; iY++)
2096	{
2097	pSrcline2 = pSrcline1 + pBuf->iRowsize;
2098
2099	if (fMagnifyX) /* magnifying in X-direction ? */
2100	{
2101	iRetcode = fMagnifyX (pData, pImage->iMAGN_MX,
2102	pImage->iMAGN_ML, pImage->iMAGN_MR,
2103	pBuf->iWidth, pSrcline1, pDstline);
2104
2105	if (iRetcode) /* on error bail out */
2106	{
2107	MNG_FREEX (pData, pTempline, iNewrowsize);
2108	MNG_FREEX (pData, pNewdata, iNewsize);
2109	return iRetcode;
2110	}
2111	}
2112	else
2113	{
2114	MNG_COPY (pDstline, pSrcline1, iNewrowsize);
2115	}
2116
2117	pDstline += iNewrowsize;
2118	/* magnifying in Y-direction ? */
2119	if ((fMagnifyY) &&
2120	((iY < pBuf->iHeight - 1) \|\| (pBuf->iHeight == 1) \|\| (pImage->iMAGN_MethodY == 1)))
2121	{
2122	if (iY == 0) /* first interval ? */
2123	{
2124	if (pBuf->iHeight == 1) /* single row ? */
2125	pSrcline2 = MNG_NULL;
2126
2127	iM = (mng_int32)pImage->iMAGN_MT;
2128	}
2129	else /* last interval ? */
2130	if (((pImage->iMAGN_MethodY == 1) && (iY == (pBuf->iHeight - 1))) \|\|
2131	((pImage->iMAGN_MethodY != 1) && (iY == (pBuf->iHeight - 2))) )
2132	iM = (mng_int32)pImage->iMAGN_MB;
2133	else /* middle interval */
2134	iM = (mng_int32)pImage->iMAGN_MY;
2135
2136	for (iS = 1; iS < iM; iS++)
2137	{
2138	iRetcode = fMagnifyY (pData, iS, iM, pBuf->iWidth,
2139	pSrcline1, pSrcline2, pTempline);
2140
2141	if (iRetcode) /* on error bail out */
2142	{
2143	MNG_FREEX (pData, pTempline, iNewrowsize);
2144	MNG_FREEX (pData, pNewdata, iNewsize);
2145	return iRetcode;
2146	}
2147
2148	if (fMagnifyX) /* magnifying in X-direction ? */
2149	{
2150	iRetcode = fMagnifyX (pData, pImage->iMAGN_MX,
2151	pImage->iMAGN_ML, pImage->iMAGN_MR,
2152	pBuf->iWidth, pTempline, pDstline);
2153
2154	if (iRetcode) /* on error bail out */
2155	{
2156	MNG_FREEX (pData, pTempline, iNewrowsize);
2157	MNG_FREEX (pData, pNewdata, iNewsize);
2158	return iRetcode;
2159	}
2160	}
2161	else
2162	{
2163	MNG_COPY (pDstline, pTempline, iNewrowsize);
2164	}
2165
2166	pDstline += iNewrowsize;
2167	}
2168	}
2169
2170	pSrcline1 += pBuf->iRowsize;
2171	}
2172	/* drop temporary row */
2173	MNG_FREEX (pData, pTempline, iNewrowsize);
2174	/* drop old pixel-data */
2175	MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize);
2176
2177	pBuf->pImgdata = pNewdata; /* save new buffer dimensions */
2178	pBuf->iRowsize = iNewrowsize;
2179	pBuf->iImgdatasize = iNewsize;
2180	pBuf->iWidth = iNewW;
2181	pBuf->iHeight = iNewH;
2182
2183	if (pImage->iId) /* real object ? */
2184	{
2185	pImage->iMAGN_MethodX = 0; /* it's done; don't do it again !!! */
2186	pImage->iMAGN_MethodY = 0;
2187	pImage->iMAGN_MX = 0;
2188	pImage->iMAGN_MY = 0;
2189	pImage->iMAGN_ML = 0;
2190	pImage->iMAGN_MR = 0;
2191	pImage->iMAGN_MT = 0;
2192	pImage->iMAGN_MB = 0;
2193	}
2194
2195	#ifdef MNG_SUPPORT_TRACE
2196	MNG_TRACE (pData, MNG_FN_MAGNIFY_IMGOBJECT, MNG_LC_END);
2197	#endif
2198
2199	return MNG_NOERROR;
2200	}
2201	#endif
2202
2203	/* ************************************************************************** */
2204
2205	mng_retcode mng_colorcorrect_object (mng_datap pData,
2206	mng_imagep pImage)
2207	{
2208	mng_imagedatap pBuf = pImage->pImgbuf;
2209	mng_retcode iRetcode;
2210	mng_uint32 iY;
2211
2212	#ifdef MNG_SUPPORT_TRACE
2213	MNG_TRACE (pData, MNG_FN_COLORCORRECT_OBJECT, MNG_LC_START);
2214	#endif
2215
2216	#ifdef MNG_INCLUDE_JNG
2217	if ((pBuf->iBitdepth < 8) \|\| /* we need 8- or 16-bit RGBA !!! */
2218	((pBuf->iColortype != MNG_COLORTYPE_RGBA ) &&
2219	(pBuf->iColortype != MNG_COLORTYPE_JPEGCOLORA) ))
2220	#else
2221	if (pBuf->iBitdepth < 8) /* we need 8- or 16-bit RGBA !!! */
2222	#endif
2223	MNG_ERROR (pData, MNG_OBJNOTABSTRACT);
2224
2225	if (!pBuf->bCorrected) /* only if not already done ! */
2226	{ /* so the row routines now to find it */
2227	pData->pRetrieveobj = (mng_objectp)pImage;
2228	pData->pStoreobj = (mng_objectp)pImage;
2229	pData->pStorebuf = (mng_objectp)pImage->pImgbuf;
2230
2231	#ifndef MNG_NO_16BIT_SUPPORT
2232	if (pBuf->iBitdepth > 8)
2233	{
2234	pData->fRetrieverow = (mng_fptr)mng_retrieve_rgba16;
2235	pData->fStorerow = (mng_fptr)mng_store_rgba16;
2236	}
2237	else
2238	#endif
2239	{
2240	pData->fRetrieverow = (mng_fptr)mng_retrieve_rgba8;
2241	pData->fStorerow = (mng_fptr)mng_store_rgba8;
2242	}
2243
2244	pData->bIsOpaque = MNG_FALSE;
2245
2246	pData->iPass = -1; /* these are the object's dimensions now */
2247	pData->iRow = 0;
2248	pData->iRowinc = 1;
2249	pData->iCol = 0;
2250	pData->iColinc = 1;
2251	pData->iRowsamples = pBuf->iWidth;
2252	pData->iRowsize = pData->iRowsamples << 2;
2253	pData->iPixelofs = 0;
2254	pData->bIsRGBA16 = MNG_FALSE;
2255	/* adjust for 16-bit object ? */
2256	#ifndef MNG_NO_16BIT_SUPPORT
2257	if (pBuf->iBitdepth > 8)
2258	{
2259	pData->bIsRGBA16 = MNG_TRUE;
2260	pData->iRowsize = pData->iRowsamples << 3;
2261	}
2262	#endif
2263
2264	pData->fCorrectrow = MNG_NULL; /* default no color-correction */
2265
2266	#ifdef MNG_NO_CMS
2267	iRetcode = MNG_NOERROR;
2268	#else
2269	#if defined(MNG_FULL_CMS) /* determine color-management routine */
2270	iRetcode = mng_init_full_cms (pData, MNG_FALSE, MNG_FALSE, MNG_TRUE);
2271	#elif defined(MNG_GAMMA_ONLY)
2272	iRetcode = mng_init_gamma_only (pData, MNG_FALSE, MNG_FALSE, MNG_TRUE);
2273	#elif defined(MNG_APP_CMS)
2274	iRetcode = mng_init_app_cms (pData, MNG_FALSE, MNG_FALSE, MNG_TRUE);
2275	#endif
2276	if (iRetcode) /* on error bail out */
2277	return iRetcode;
2278	#endif /* MNG_NO_CMS */
2279
2280	if (pData->fCorrectrow) /* really correct something ? */
2281	{ /* get a temporary row-buffer */
2282	MNG_ALLOC (pData, pData->pRGBArow, pData->iRowsize);
2283
2284	pData->pWorkrow = pData->pRGBArow;
2285	iY = 0; /* start from the top */
2286
2287	while ((!iRetcode) && (iY < pBuf->iHeight))
2288	{ /* get a row */
2289	iRetcode = ((mng_retrieverow)pData->fRetrieverow) (pData);
2290
2291	if (!iRetcode) /* color correct it */
2292	iRetcode = ((mng_correctrow)pData->fCorrectrow) (pData);
2293
2294	if (!iRetcode) /* store it back ! */
2295	iRetcode = ((mng_storerow)pData->fStorerow) (pData);
2296
2297	if (!iRetcode) /* adjust variables for next row */
2298	iRetcode = mng_next_row (pData);
2299
2300	iY++; /* and next line */
2301	}
2302	/* drop the temporary row-buffer */
2303	MNG_FREEX (pData, pData->pRGBArow, pData->iRowsize);
2304
2305	if (iRetcode) /* on error bail out */
2306	return iRetcode;
2307
2308	#if defined(MNG_FULL_CMS) /* cleanup cms stuff */
2309	iRetcode = mng_clear_cms (pData);
2310
2311	if (iRetcode) /* on error bail out */
2312	return iRetcode;
2313	#endif
2314	}
2315
2316	pBuf->bCorrected = MNG_TRUE; /* let's not go through that again ! */
2317	}
2318
2319	#ifdef MNG_SUPPORT_TRACE
2320	MNG_TRACE (pData, MNG_FN_COLORCORRECT_OBJECT, MNG_LC_END);
2321	#endif
2322
2323	return MNG_NOERROR;
2324	}
2325
2326	/* ************************************************************************** */
2327	/* * * */
2328	/* * Animation-object routines * */
2329	/* * * */
2330	/* * these handle the animation objects used to re-run parts of a MNG. * */
2331	/* * eg. during LOOP or TERM processing * */
2332	/* * * */
2333	/* ************************************************************************** */
2334
2335	void mng_add_ani_object (mng_datap pData,
2336	mng_object_headerp pObject)
2337	{
2338	mng_object_headerp pLast = (mng_object_headerp)pData->pLastaniobj;
2339
2340	if (pLast) /* link it as last in the chain */
2341	{
2342	pObject->pPrev = pLast;
2343	pLast->pNext = pObject;
2344	}
2345	else
2346	{
2347	pObject->pPrev = MNG_NULL; /* be on the safe side */
2348	pData->pFirstaniobj = pObject;
2349	}
2350
2351	pObject->pNext = MNG_NULL; /* be on the safe side */
2352	pData->pLastaniobj = pObject;
2353	/* keep track for jumping */
2354	pObject->iFramenr = pData->iFrameseq;
2355	pObject->iLayernr = pData->iLayerseq;
2356	pObject->iPlaytime = pData->iFrametime;
2357	/* save restart object ? */
2358	if ((pData->bDisplaying) && (!pData->bRunning) && (!pData->pCurraniobj))
2359	pData->pCurraniobj = pObject;
2360
2361	return;
2362	}
2363
2364	/* ************************************************************************** */
2365	/* ************************************************************************** */
2366
2367	mng_retcode mng_create_ani_image (mng_datap pData)
2368	{
2369	mng_ani_imagep pImage;
2370	mng_imagep pCurrent;
2371	mng_retcode iRetcode;
2372
2373	#ifdef MNG_SUPPORT_TRACE
2374	MNG_TRACE (pData, MNG_FN_CREATE_ANI_IMAGE, MNG_LC_START);
2375	#endif
2376
2377	if (pData->bCacheplayback) /* caching playback info ? */
2378	{
2379	#ifndef MNG_NO_DELTA_PNG
2380	if (pData->bHasDHDR) /* processing delta-image ? */
2381	pCurrent = (mng_imagep)pData->pObjzero;
2382	else /* get the current object */
2383	#endif
2384	pCurrent = (mng_imagep)pData->pCurrentobj;
2385
2386	if (!pCurrent) /* otherwise object 0 */
2387	pCurrent = (mng_imagep)pData->pObjzero;
2388	/* now just clone the object !!! */
2389	iRetcode = mng_clone_imageobject (pData, 0, MNG_FALSE, pCurrent->bVisible,
2390	MNG_FALSE, MNG_FALSE, 0, 0, 0, pCurrent,
2391	&pImage);
2392
2393	if (iRetcode) /* on error bail out */
2394	return iRetcode;
2395
2396	pImage->sHeader.fCleanup = mng_free_ani_image;
2397	pImage->sHeader.fProcess = mng_process_ani_image;
2398
2399	mng_add_ani_object (pData, (mng_object_headerp)pImage);
2400	}
2401
2402	#ifdef MNG_SUPPORT_TRACE
2403	MNG_TRACE (pData, MNG_FN_CREATE_ANI_IMAGE, MNG_LC_END);
2404	#endif
2405
2406	return MNG_NOERROR; /* okido */
2407	}
2408
2409	/* ************************************************************************** */
2410
2411	mng_retcode mng_free_ani_image (mng_datap pData,
2412	mng_objectp pObject)
2413	{
2414	mng_ani_imagep pImage = (mng_ani_imagep)pObject;
2415	mng_imagedatap pImgbuf = pImage->pImgbuf;
2416	mng_retcode iRetcode;
2417
2418	#ifdef MNG_SUPPORT_TRACE
2419	MNG_TRACE (pData, MNG_FN_FREE_ANI_IMAGE, MNG_LC_START);
2420	#endif
2421	/* unlink the image-data buffer */
2422	iRetcode = mng_free_imagedataobject (pData, pImgbuf);
2423	/* drop its own buffer */
2424	MNG_FREEX (pData, pImage, sizeof (mng_ani_image));
2425
2426	#ifdef MNG_SUPPORT_TRACE
2427	MNG_TRACE (pData, MNG_FN_FREE_ANI_IMAGE, MNG_LC_END);
2428	#endif
2429
2430	return iRetcode;
2431	}
2432
2433	/* ************************************************************************** */
2434
2435	mng_retcode mng_process_ani_image (mng_datap pData,
2436	mng_objectp pObject)
2437	{
2438	mng_retcode iRetcode = MNG_NOERROR;
2439	mng_ani_imagep pImage = (mng_imagep)pObject;
2440
2441	#ifdef MNG_SUPPORT_TRACE
2442	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IMAGE, MNG_LC_START);
2443	#endif
2444
2445	#ifndef MNG_NO_DELTA_PNG
2446	if (pData->bHasDHDR) /* processing delta-image ? */
2447	{
2448	mng_imagep pDelta = (mng_imagep)pData->pDeltaImage;
2449
2450	if (!pData->iBreakpoint) /* only execute if not broken before */
2451	{ /* make sure to process pixels as well */
2452	pData->bDeltaimmediate = MNG_FALSE;
2453	/* execute the delta process */
2454	iRetcode = mng_execute_delta_image (pData, pDelta, (mng_imagep)pObject);
2455
2456	if (iRetcode) /* on error bail out */
2457	return iRetcode;
2458	}
2459	/* now go and shoot it off (if required) */
2460	if ((pDelta->bVisible) && (pDelta->bViewable))
2461	iRetcode = mng_display_image (pData, pDelta, MNG_FALSE);
2462
2463	if (!pData->bTimerset)
2464	pData->bHasDHDR = MNG_FALSE; /* this image signifies IEND !! */
2465
2466	}
2467	else
2468	#endif
2469	if (pData->pCurrentobj) /* active object ? */
2470	{
2471	mng_imagep pCurrent = (mng_imagep)pData->pCurrentobj;
2472	mng_imagedatap pBuf = pCurrent->pImgbuf;
2473
2474	if (!pData->iBreakpoint) /* don't copy it again ! */
2475	{
2476	if (pBuf->iImgdatasize) /* buffer present in active object ? */
2477	/* then drop it */
2478	MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize);
2479
2480	#ifndef MNG_SKIPCHUNK_iCCP
2481	if (pBuf->iProfilesize) /* iCCP profile present ? */
2482	/* then drop it */
2483	MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize);
2484	#endif
2485	/* now blatently copy the animation buffer */
2486	MNG_COPY (pBuf, pImage->pImgbuf, sizeof (mng_imagedata));
2487	/* copy viewability */
2488	pCurrent->bViewable = pImage->bViewable;
2489
2490	if (pBuf->iImgdatasize) /* sample buffer present ? */
2491	{ /* then make a copy */
2492	MNG_ALLOC (pData, pBuf->pImgdata, pBuf->iImgdatasize);
2493	MNG_COPY (pBuf->pImgdata, pImage->pImgbuf->pImgdata, pBuf->iImgdatasize);
2494	}
2495
2496	#ifndef MNG_SKIPCHUNK_iCCP
2497	if (pBuf->iProfilesize) /* iCCP profile present ? */
2498	{ /* then make a copy */
2499	MNG_ALLOC (pData, pBuf->pProfile, pBuf->iProfilesize);
2500	MNG_COPY (pBuf->pProfile, pImage->pImgbuf->pProfile, pBuf->iProfilesize);
2501	}
2502	#endif
2503	}
2504	/* now go and shoot it off (if required) */
2505	if ((pCurrent->bVisible) && (pCurrent->bViewable))
2506	iRetcode = mng_display_image (pData, pCurrent, MNG_FALSE);
2507	}
2508	else
2509	{
2510	mng_imagep pObjzero = (mng_imagep)pData->pObjzero;
2511	mng_imagedatap pBuf = pObjzero->pImgbuf;
2512
2513	if (!pData->iBreakpoint) /* don't copy it again ! */
2514	{
2515	if (pBuf->iImgdatasize) /* buffer present in active object ? */
2516	/* then drop it */
2517	MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize);
2518
2519	#ifndef MNG_SKIPCHUNK_iCCP
2520	if (pBuf->iProfilesize) /* iCCP profile present ? */
2521	/* then drop it */
2522	MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize);
2523	#endif
2524	/* now blatently copy the animation buffer */
2525	MNG_COPY (pBuf, pImage->pImgbuf, sizeof (mng_imagedata));
2526	/* copy viewability */
2527	pObjzero->bViewable = pImage->bViewable;
2528
2529	if (pBuf->iImgdatasize) /* sample buffer present ? */
2530	{ /* then make a copy */
2531	MNG_ALLOC (pData, pBuf->pImgdata, pBuf->iImgdatasize);
2532	MNG_COPY (pBuf->pImgdata, pImage->pImgbuf->pImgdata, pBuf->iImgdatasize);
2533	}
2534
2535	#ifndef MNG_SKIPCHUNK_iCCP
2536	if (pBuf->iProfilesize) /* iCCP profile present ? */
2537	{ /* then make a copy */
2538	MNG_ALLOC (pData, pBuf->pProfile, pBuf->iProfilesize);
2539	MNG_COPY (pBuf->pProfile, pImage->pImgbuf->pProfile, pBuf->iProfilesize);
2540	}
2541	#endif
2542	}
2543	/* now go and show it */
2544	iRetcode = mng_display_image (pData, pObjzero, MNG_FALSE);
2545	}
2546
2547	if (!iRetcode) /* all's well ? */
2548	{
2549	if (pData->bTimerset) /* timer break ? */
2550	pData->iBreakpoint = 99; /* fictive number; no more processing needed! */
2551	else
2552	pData->iBreakpoint = 0; /* else clear it */
2553	}
2554
2555	#ifdef MNG_SUPPORT_TRACE
2556	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IMAGE, MNG_LC_END);
2557	#endif
2558
2559	return iRetcode;
2560	}
2561
2562	/* ************************************************************************** */
2563	/* ************************************************************************** */
2564
2565	#ifndef MNG_OPTIMIZE_CHUNKREADER
2566	mng_retcode mng_create_ani_plte (mng_datap pData,
2567	mng_uint32 iEntrycount,
2568	mng_palette8ep paEntries)
2569	#else
2570	mng_retcode mng_create_ani_plte (mng_datap pData)
2571	#endif
2572	{
2573	mng_ani_pltep pPLTE;
2574
2575	#ifdef MNG_SUPPORT_TRACE
2576	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PLTE, MNG_LC_START);
2577	#endif
2578
2579	if (pData->bCacheplayback) /* caching playback info ? */
2580	{
2581	#ifdef MNG_OPTIMIZE_OBJCLEANUP
2582	mng_ptr pTemp;
2583	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_plte),
2584	mng_free_obj_general,
2585	mng_process_ani_plte,
2586	&pTemp);
2587	if (iRetcode)
2588	return iRetcode;
2589	pPLTE = (mng_ani_pltep)pTemp;
2590	#else
2591	MNG_ALLOC (pData, pPLTE, sizeof (mng_ani_plte));
2592
2593	pPLTE->sHeader.fCleanup = mng_free_ani_plte;
2594	pPLTE->sHeader.fProcess = mng_process_ani_plte;
2595	#endif
2596
2597	mng_add_ani_object (pData, (mng_object_headerp)pPLTE);
2598
2599	#ifndef MNG_OPTIMIZE_CHUNKREADER
2600	pPLTE->iEntrycount = iEntrycount;
2601	MNG_COPY (pPLTE->aEntries, paEntries, sizeof (pPLTE->aEntries));
2602	#else
2603	pPLTE->iEntrycount = pData->iGlobalPLTEcount;
2604	MNG_COPY (pPLTE->aEntries, pData->aGlobalPLTEentries, sizeof (pPLTE->aEntries));
2605	#endif
2606	}
2607
2608	#ifdef MNG_SUPPORT_TRACE
2609	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PLTE, MNG_LC_END);
2610	#endif
2611
2612	return MNG_NOERROR;
2613	}
2614
2615	/* ************************************************************************** */
2616
2617	#ifndef MNG_OPTIMIZE_OBJCLEANUP
2618	mng_retcode mng_free_ani_plte (mng_datap pData,
2619	mng_objectp pObject)
2620	{
2621	#ifdef MNG_SUPPORT_TRACE
2622	MNG_TRACE (pData, MNG_FN_FREE_ANI_PLTE, MNG_LC_START);
2623	#endif
2624
2625	MNG_FREEX (pData, pObject, sizeof (mng_ani_plte));
2626
2627	#ifdef MNG_SUPPORT_TRACE
2628	MNG_TRACE (pData, MNG_FN_FREE_ANI_PLTE, MNG_LC_END);
2629	#endif
2630
2631	return MNG_NOERROR;
2632	}
2633	#endif
2634
2635	/* ************************************************************************** */
2636
2637	mng_retcode mng_process_ani_plte (mng_datap pData,
2638	mng_objectp pObject)
2639	{
2640	mng_ani_pltep pPLTE = (mng_ani_pltep)pObject;
2641
2642	#ifdef MNG_SUPPORT_TRACE
2643	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PLTE, MNG_LC_START);
2644	#endif
2645
2646	pData->bHasglobalPLTE = MNG_TRUE;
2647	pData->iGlobalPLTEcount = pPLTE->iEntrycount;
2648
2649	MNG_COPY (pData->aGlobalPLTEentries, pPLTE->aEntries, sizeof (pPLTE->aEntries));
2650
2651	#ifdef MNG_SUPPORT_TRACE
2652	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PLTE, MNG_LC_END);
2653	#endif
2654
2655	return MNG_NOERROR;
2656	}
2657
2658	/* ************************************************************************** */
2659	/* ************************************************************************** */
2660
2661	#ifndef MNG_OPTIMIZE_CHUNKREADER
2662	mng_retcode mng_create_ani_trns (mng_datap pData,
2663	mng_uint32 iRawlen,
2664	mng_uint8p pRawdata)
2665	#else
2666	mng_retcode mng_create_ani_trns (mng_datap pData)
2667	#endif
2668	{
2669	mng_ani_trnsp pTRNS;
2670
2671	#ifdef MNG_SUPPORT_TRACE
2672	MNG_TRACE (pData, MNG_FN_CREATE_ANI_TRNS, MNG_LC_START);
2673	#endif
2674
2675	if (pData->bCacheplayback) /* caching playback info ? */
2676	{
2677	#ifdef MNG_OPTIMIZE_OBJCLEANUP
2678	mng_ptr pTemp;
2679	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_trns),
2680	mng_free_obj_general,
2681	mng_process_ani_trns,
2682	&pTemp);
2683	if (iRetcode)
2684	return iRetcode;
2685	pTRNS = (mng_ani_trnsp)pTemp;
2686	#else
2687	MNG_ALLOC (pData, pTRNS, sizeof (mng_ani_trns));
2688
2689	pTRNS->sHeader.fCleanup = mng_free_ani_trns;
2690	pTRNS->sHeader.fProcess = mng_process_ani_trns;
2691	#endif
2692
2693	mng_add_ani_object (pData, (mng_object_headerp)pTRNS);
2694
2695	#ifndef MNG_OPTIMIZE_CHUNKREADER
2696	pTRNS->iRawlen = iRawlen;
2697	MNG_COPY (pTRNS->aRawdata, pRawdata, sizeof (pTRNS->aRawdata));
2698	#else
2699	pTRNS->iRawlen = pData->iGlobalTRNSrawlen;
2700	MNG_COPY (pTRNS->aRawdata, pData->aGlobalTRNSrawdata, sizeof (pTRNS->aRawdata));
2701	#endif
2702	}
2703
2704	#ifdef MNG_SUPPORT_TRACE
2705	MNG_TRACE (pData, MNG_FN_CREATE_ANI_TRNS, MNG_LC_END);
2706	#endif
2707
2708	return MNG_NOERROR;
2709	}
2710
2711	/* ************************************************************************** */
2712
2713	#ifndef MNG_OPTIMIZE_OBJCLEANUP
2714	mng_retcode mng_free_ani_trns (mng_datap pData,
2715	mng_objectp pObject)
2716	{
2717	#ifdef MNG_SUPPORT_TRACE
2718	MNG_TRACE (pData, MNG_FN_FREE_ANI_TRNS, MNG_LC_START);
2719	#endif
2720
2721	MNG_FREEX (pData, pObject, sizeof (mng_ani_trns));
2722
2723	#ifdef MNG_SUPPORT_TRACE
2724	MNG_TRACE (pData, MNG_FN_FREE_ANI_TRNS, MNG_LC_END);
2725	#endif
2726
2727	return MNG_NOERROR;
2728	}
2729	#endif
2730
2731	/* ************************************************************************** */
2732
2733	mng_retcode mng_process_ani_trns (mng_datap pData,
2734	mng_objectp pObject)
2735	{
2736	mng_ani_trnsp pTRNS = (mng_ani_trnsp)pObject;
2737
2738	#ifdef MNG_SUPPORT_TRACE
2739	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TRNS, MNG_LC_START);
2740	#endif
2741
2742	pData->bHasglobalTRNS = MNG_TRUE;
2743	pData->iGlobalTRNSrawlen = pTRNS->iRawlen;
2744
2745	MNG_COPY (pData->aGlobalTRNSrawdata, pTRNS->aRawdata, sizeof (pTRNS->aRawdata));
2746
2747	#ifdef MNG_SUPPORT_TRACE
2748	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TRNS, MNG_LC_END);
2749	#endif
2750
2751	return MNG_NOERROR;
2752	}
2753
2754	/* ************************************************************************** */
2755	/* ************************************************************************** */
2756
2757	#ifndef MNG_SKIPCHUNK_gAMA
2758	#ifndef MNG_OPTIMIZE_CHUNKREADER
2759	mng_retcode mng_create_ani_gama (mng_datap pData,
2760	mng_bool bEmpty,
2761	mng_uint32 iGamma)
2762	#else
2763	mng_retcode mng_create_ani_gama (mng_datap pData,
2764	mng_chunkp pChunk)
2765	#endif
2766	{
2767	mng_ani_gamap pGAMA;
2768
2769	#ifdef MNG_SUPPORT_TRACE
2770	MNG_TRACE (pData, MNG_FN_CREATE_ANI_GAMA, MNG_LC_START);
2771	#endif
2772
2773	if (pData->bCacheplayback) /* caching playback info ? */
2774	{
2775	#ifdef MNG_OPTIMIZE_OBJCLEANUP
2776	mng_ptr pTemp;
2777	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_gama),
2778	mng_free_obj_general,
2779	mng_process_ani_gama,
2780	&pTemp);
2781	if (iRetcode)
2782	return iRetcode;
2783	pGAMA = (mng_ani_gamap)pTemp;
2784	#else
2785	MNG_ALLOC (pData, pGAMA, sizeof (mng_ani_gama));
2786
2787	pGAMA->sHeader.fCleanup = mng_free_ani_gama;
2788	pGAMA->sHeader.fProcess = mng_process_ani_gama;
2789	#endif
2790
2791	mng_add_ani_object (pData, (mng_object_headerp)pGAMA);
2792
2793	#ifndef MNG_OPTIMIZE_CHUNKREADER
2794	pGAMA->bEmpty = bEmpty;
2795	pGAMA->iGamma = iGamma;
2796	#else
2797	pGAMA->bEmpty = ((mng_gamap)pChunk)->bEmpty;
2798	pGAMA->iGamma = ((mng_gamap)pChunk)->iGamma;
2799	#endif
2800	}
2801
2802	#ifdef MNG_SUPPORT_TRACE
2803	MNG_TRACE (pData, MNG_FN_CREATE_ANI_GAMA, MNG_LC_END);
2804	#endif
2805
2806	return MNG_NOERROR;
2807	}
2808
2809	/* ************************************************************************** */
2810
2811	#ifndef MNG_OPTIMIZE_OBJCLEANUP
2812	mng_retcode mng_free_ani_gama (mng_datap pData,
2813	mng_objectp pObject)
2814	{
2815	#ifdef MNG_SUPPORT_TRACE
2816	MNG_TRACE (pData, MNG_FN_FREE_ANI_GAMA, MNG_LC_START);
2817	#endif
2818
2819	MNG_FREEX (pData, pObject, sizeof (mng_ani_gama));
2820
2821	#ifdef MNG_SUPPORT_TRACE
2822	MNG_TRACE (pData, MNG_FN_FREE_ANI_GAMA, MNG_LC_END);
2823	#endif
2824
2825	return MNG_NOERROR;
2826	}
2827	#endif
2828
2829	/* ************************************************************************** */
2830
2831	mng_retcode mng_process_ani_gama (mng_datap pData,
2832	mng_objectp pObject)
2833	{
2834	mng_ani_gamap pGAMA = (mng_ani_gamap)pObject;
2835
2836	#ifdef MNG_SUPPORT_TRACE
2837	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_GAMA, MNG_LC_START);
2838	#endif
2839
2840	if (pGAMA->bEmpty) /* empty chunk ? */
2841	{ /* clear global gAMA */
2842	pData->bHasglobalGAMA = MNG_FALSE;
2843	pData->iGlobalGamma = 0;
2844	}
2845	else
2846	{ /* set global gAMA */
2847	pData->bHasglobalGAMA = MNG_TRUE;
2848	pData->iGlobalGamma = pGAMA->iGamma;
2849	}
2850
2851	#ifdef MNG_SUPPORT_TRACE
2852	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_GAMA, MNG_LC_END);
2853	#endif
2854
2855	return MNG_NOERROR;
2856	}
2857	#endif
2858
2859	/* ************************************************************************** */
2860	/* ************************************************************************** */
2861
2862	#ifndef MNG_SKIPCHUNK_cHRM
2863	#ifndef MNG_OPTIMIZE_CHUNKREADER
2864	mng_retcode mng_create_ani_chrm (mng_datap pData,
2865	mng_bool bEmpty,
2866	mng_uint32 iWhitepointx,
2867	mng_uint32 iWhitepointy,
2868	mng_uint32 iRedx,
2869	mng_uint32 iRedy,
2870	mng_uint32 iGreenx,
2871	mng_uint32 iGreeny,
2872	mng_uint32 iBluex,
2873	mng_uint32 iBluey)
2874	#else
2875	mng_retcode mng_create_ani_chrm (mng_datap pData,
2876	mng_chunkp pChunk)
2877	#endif
2878	{
2879	mng_ani_chrmp pCHRM;
2880
2881	#ifdef MNG_SUPPORT_TRACE
2882	MNG_TRACE (pData, MNG_FN_CREATE_ANI_CHRM, MNG_LC_START);
2883	#endif
2884
2885	if (pData->bCacheplayback) /* caching playback info ? */
2886	{
2887	#ifdef MNG_OPTIMIZE_OBJCLEANUP
2888	mng_ptr pTemp;
2889	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_chrm),
2890	mng_free_obj_general,
2891	mng_process_ani_chrm,
2892	&pTemp);
2893	if (iRetcode)
2894	return iRetcode;
2895	pCHRM = (mng_ani_chrmp)pTemp;
2896	#else
2897	MNG_ALLOC (pData, pCHRM, sizeof (mng_ani_chrm));
2898
2899	pCHRM->sHeader.fCleanup = mng_free_ani_chrm;
2900	pCHRM->sHeader.fProcess = mng_process_ani_chrm;
2901	#endif
2902
2903	mng_add_ani_object (pData, (mng_object_headerp)pCHRM);
2904
2905	#ifndef MNG_OPTIMIZE_CHUNKREADER
2906	pCHRM->bEmpty = bEmpty;
2907	pCHRM->iWhitepointx = iWhitepointx;
2908	pCHRM->iWhitepointy = iWhitepointy;
2909	pCHRM->iRedx = iRedx;
2910	pCHRM->iRedy = iRedy;
2911	pCHRM->iGreenx = iGreenx;
2912	pCHRM->iGreeny = iGreeny;
2913	pCHRM->iBluex = iBluex;
2914	pCHRM->iBluey = iBluey;
2915	#else
2916	pCHRM->bEmpty = ((mng_chrmp)pChunk)->bEmpty;
2917	pCHRM->iWhitepointx = ((mng_chrmp)pChunk)->iWhitepointx;
2918	pCHRM->iWhitepointy = ((mng_chrmp)pChunk)->iWhitepointy;
2919	pCHRM->iRedx = ((mng_chrmp)pChunk)->iRedx;
2920	pCHRM->iRedy = ((mng_chrmp)pChunk)->iRedy;
2921	pCHRM->iGreenx = ((mng_chrmp)pChunk)->iGreenx;
2922	pCHRM->iGreeny = ((mng_chrmp)pChunk)->iGreeny;
2923	pCHRM->iBluex = ((mng_chrmp)pChunk)->iBluex;
2924	pCHRM->iBluey = ((mng_chrmp)pChunk)->iBluey;
2925	#endif
2926	}
2927
2928	#ifdef MNG_SUPPORT_TRACE
2929	MNG_TRACE (pData, MNG_FN_CREATE_ANI_CHRM, MNG_LC_END);
2930	#endif
2931
2932	return MNG_NOERROR;
2933	}
2934
2935	/* ************************************************************************** */
2936
2937	#ifndef MNG_OPTIMIZE_OBJCLEANUP
2938	mng_retcode mng_free_ani_chrm (mng_datap pData,
2939	mng_objectp pObject)
2940	{
2941	#ifdef MNG_SUPPORT_TRACE
2942	MNG_TRACE (pData, MNG_FN_FREE_ANI_CHRM, MNG_LC_START);
2943	#endif
2944
2945	MNG_FREEX (pData, pObject, sizeof (mng_ani_chrm));
2946
2947	#ifdef MNG_SUPPORT_TRACE
2948	MNG_TRACE (pData, MNG_FN_FREE_ANI_CHRM, MNG_LC_END);
2949	#endif
2950
2951	return MNG_NOERROR;
2952	}
2953	#endif
2954
2955	/* ************************************************************************** */
2956
2957	mng_retcode mng_process_ani_chrm (mng_datap pData,
2958	mng_objectp pObject)
2959	{
2960	mng_ani_chrmp pCHRM = (mng_ani_chrmp)pObject;
2961
2962	#ifdef MNG_SUPPORT_TRACE
2963	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CHRM, MNG_LC_START);
2964	#endif
2965
2966	if (pCHRM->bEmpty) /* empty chunk ? */
2967	{ /* clear global cHRM */
2968	pData->bHasglobalCHRM = MNG_FALSE;
2969	pData->iGlobalWhitepointx = 0;
2970	pData->iGlobalWhitepointy = 0;
2971	pData->iGlobalPrimaryredx = 0;
2972	pData->iGlobalPrimaryredy = 0;
2973	pData->iGlobalPrimarygreenx = 0;
2974	pData->iGlobalPrimarygreeny = 0;
2975	pData->iGlobalPrimarybluex = 0;
2976	pData->iGlobalPrimarybluey = 0;
2977	}
2978	else
2979	{ /* set global cHRM */
2980	pData->bHasglobalCHRM = MNG_TRUE;
2981	pData->iGlobalWhitepointx = pCHRM->iWhitepointx;
2982	pData->iGlobalWhitepointy = pCHRM->iWhitepointy;
2983	pData->iGlobalPrimaryredx = pCHRM->iRedx;
2984	pData->iGlobalPrimaryredy = pCHRM->iRedy;
2985	pData->iGlobalPrimarygreenx = pCHRM->iGreenx;
2986	pData->iGlobalPrimarygreeny = pCHRM->iGreeny;
2987	pData->iGlobalPrimarybluex = pCHRM->iBluex;
2988	pData->iGlobalPrimarybluey = pCHRM->iBluey;
2989	}
2990
2991	#ifdef MNG_SUPPORT_TRACE
2992	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CHRM, MNG_LC_END);
2993	#endif
2994
2995	return MNG_NOERROR;
2996	}
2997	#endif
2998
2999	/* ************************************************************************** */
3000	/* ************************************************************************** */
3001
3002	#ifndef MNG_SKIPCHUNK_sRGB
3003	#ifndef MNG_OPTIMIZE_CHUNKREADER
3004	mng_retcode mng_create_ani_srgb (mng_datap pData,
3005	mng_bool bEmpty,
3006	mng_uint8 iRenderingintent)
3007	#else
3008	mng_retcode mng_create_ani_srgb (mng_datap pData,
3009	mng_chunkp pChunk)
3010	#endif
3011	{
3012	mng_ani_srgbp pSRGB;
3013
3014	#ifdef MNG_SUPPORT_TRACE
3015	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SRGB, MNG_LC_START);
3016	#endif
3017
3018	if (pData->bCacheplayback) /* caching playback info ? */
3019	{
3020	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3021	mng_ptr pTemp;
3022	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_srgb),
3023	mng_free_obj_general,
3024	mng_process_ani_srgb,
3025	&pTemp);
3026	if (iRetcode)
3027	return iRetcode;
3028	pSRGB = (mng_ani_srgbp)pTemp;
3029	#else
3030	MNG_ALLOC (pData, pSRGB, sizeof (mng_ani_srgb));
3031
3032	pSRGB->sHeader.fCleanup = mng_free_ani_srgb;
3033	pSRGB->sHeader.fProcess = mng_process_ani_srgb;
3034	#endif
3035
3036	mng_add_ani_object (pData, (mng_object_headerp)pSRGB);
3037
3038	#ifndef MNG_OPTIMIZE_CHUNKREADER
3039	pSRGB->bEmpty = bEmpty;
3040	pSRGB->iRenderingintent = iRenderingintent;
3041	#else
3042	pSRGB->bEmpty = ((mng_srgbp)pChunk)->bEmpty;
3043	pSRGB->iRenderingintent = ((mng_srgbp)pChunk)->iRenderingintent;
3044	#endif
3045	}
3046
3047	#ifdef MNG_SUPPORT_TRACE
3048	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SRGB, MNG_LC_END);
3049	#endif
3050
3051	return MNG_NOERROR;
3052	}
3053
3054	/* ************************************************************************** */
3055
3056	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3057	mng_retcode mng_free_ani_srgb (mng_datap pData,
3058	mng_objectp pObject)
3059	{
3060	#ifdef MNG_SUPPORT_TRACE
3061	MNG_TRACE (pData, MNG_FN_FREE_ANI_SRGB, MNG_LC_START);
3062	#endif
3063
3064	MNG_FREEX (pData, pObject, sizeof (mng_ani_srgb));
3065
3066	#ifdef MNG_SUPPORT_TRACE
3067	MNG_TRACE (pData, MNG_FN_FREE_ANI_SRGB, MNG_LC_END);
3068	#endif
3069
3070	return MNG_NOERROR;
3071	}
3072	#endif
3073
3074	/* ************************************************************************** */
3075
3076	mng_retcode mng_process_ani_srgb (mng_datap pData,
3077	mng_objectp pObject)
3078	{
3079	mng_ani_srgbp pSRGB = (mng_ani_srgbp)pObject;
3080
3081	#ifdef MNG_SUPPORT_TRACE
3082	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SRGB, MNG_LC_START);
3083	#endif
3084
3085	if (pSRGB->bEmpty) /* empty chunk ? */
3086	{ /* clear global sRGB */
3087	pData->bHasglobalSRGB = MNG_FALSE;
3088	pData->iGlobalRendintent = 0;
3089	}
3090	else
3091	{ /* set global sRGB */
3092	pData->bHasglobalSRGB = MNG_TRUE;
3093	pData->iGlobalRendintent = pSRGB->iRenderingintent;
3094	}
3095
3096	#ifdef MNG_SUPPORT_TRACE
3097	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SRGB, MNG_LC_END);
3098	#endif
3099
3100	return MNG_NOERROR;
3101	}
3102	#endif
3103
3104	/* ************************************************************************** */
3105	/* ************************************************************************** */
3106
3107	#ifndef MNG_SKIPCHUNK_iCCP
3108	#ifndef MNG_OPTIMIZE_CHUNKREADER
3109	mng_retcode mng_create_ani_iccp (mng_datap pData,
3110	mng_bool bEmpty,
3111	mng_uint32 iProfilesize,
3112	mng_ptr pProfile)
3113	#else
3114	mng_retcode mng_create_ani_iccp (mng_datap pData,
3115	mng_chunkp pChunk)
3116	#endif
3117	{
3118	mng_ani_iccpp pICCP;
3119
3120	#ifdef MNG_SUPPORT_TRACE
3121	MNG_TRACE (pData, MNG_FN_CREATE_ANI_ICCP, MNG_LC_START);
3122	#endif
3123
3124	if (pData->bCacheplayback) /* caching playback info ? */
3125	{
3126	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3127	mng_ptr pTemp;
3128	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_iccp),
3129	mng_free_ani_iccp,
3130	mng_process_ani_iccp,
3131	&pTemp);
3132	if (iRetcode)
3133	return iRetcode;
3134	pICCP = (mng_ani_iccpp)pTemp;
3135	#else
3136	MNG_ALLOC (pData, pICCP, sizeof (mng_ani_iccp));
3137
3138	pICCP->sHeader.fCleanup = mng_free_ani_iccp;
3139	pICCP->sHeader.fProcess = mng_process_ani_iccp;
3140	#endif
3141
3142	mng_add_ani_object (pData, (mng_object_headerp)pICCP);
3143
3144	#ifndef MNG_OPTIMIZE_CHUNKREADER
3145	pICCP->bEmpty = bEmpty;
3146	pICCP->iProfilesize = iProfilesize;
3147
3148	if (iProfilesize)
3149	{
3150	MNG_ALLOC (pData, pICCP->pProfile, iProfilesize);
3151	MNG_COPY (pICCP->pProfile, pProfile, iProfilesize);
3152	}
3153	#else
3154	pICCP->bEmpty = ((mng_iccpp)pChunk)->bEmpty;
3155	pICCP->iProfilesize = ((mng_iccpp)pChunk)->iProfilesize;
3156
3157	if (pICCP->iProfilesize)
3158	{
3159	MNG_ALLOC (pData, pICCP->pProfile, pICCP->iProfilesize);
3160	MNG_COPY (pICCP->pProfile, ((mng_iccpp)pChunk)->pProfile, pICCP->iProfilesize);
3161	}
3162	#endif
3163	}
3164
3165	#ifdef MNG_SUPPORT_TRACE
3166	MNG_TRACE (pData, MNG_FN_CREATE_ANI_ICCP, MNG_LC_END);
3167	#endif
3168
3169	return MNG_NOERROR;
3170	}
3171
3172	/* ************************************************************************** */
3173
3174	mng_retcode mng_free_ani_iccp (mng_datap pData,
3175	mng_objectp pObject)
3176	{
3177	mng_ani_iccpp pICCP = (mng_ani_iccpp)pObject;
3178
3179	#ifdef MNG_SUPPORT_TRACE
3180	MNG_TRACE (pData, MNG_FN_FREE_ANI_ICCP, MNG_LC_START);
3181	#endif
3182
3183	if (pICCP->iProfilesize)
3184	MNG_FREEX (pData, pICCP->pProfile, pICCP->iProfilesize);
3185
3186	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3187	MNG_FREEX (pData, pObject, sizeof (mng_ani_iccp));
3188	#endif
3189
3190	#ifdef MNG_SUPPORT_TRACE
3191	MNG_TRACE (pData, MNG_FN_FREE_ANI_ICCP, MNG_LC_END);
3192	#endif
3193
3194	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3195	return MNG_NOERROR;
3196	#else
3197	return mng_free_obj_general(pData, pObject);
3198	#endif
3199	}
3200
3201	/* ************************************************************************** */
3202
3203	mng_retcode mng_process_ani_iccp (mng_datap pData,
3204	mng_objectp pObject)
3205	{
3206	mng_ani_iccpp pICCP = (mng_ani_iccpp)pObject;
3207
3208	#ifdef MNG_SUPPORT_TRACE
3209	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ICCP, MNG_LC_START);
3210	#endif
3211
3212	if (pICCP->bEmpty) /* empty chunk ? */
3213	{ /* clear global iCCP */
3214	pData->bHasglobalICCP = MNG_FALSE;
3215
3216	if (pData->iGlobalProfilesize)
3217	MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize);
3218
3219	pData->iGlobalProfilesize = 0;
3220	pData->pGlobalProfile = MNG_NULL;
3221	}
3222	else
3223	{ /* set global iCCP */
3224	pData->bHasglobalICCP = MNG_TRUE;
3225	pData->iGlobalProfilesize = pICCP->iProfilesize;
3226
3227	if (pICCP->iProfilesize)
3228	{
3229	MNG_ALLOC (pData, pData->pGlobalProfile, pICCP->iProfilesize);
3230	MNG_COPY (pData->pGlobalProfile, pICCP->pProfile, pICCP->iProfilesize);
3231	}
3232	}
3233
3234	#ifdef MNG_SUPPORT_TRACE
3235	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ICCP, MNG_LC_END);
3236	#endif
3237
3238	return MNG_NOERROR;
3239	}
3240	#endif
3241
3242	/* ************************************************************************** */
3243	/* ************************************************************************** */
3244
3245	#ifndef MNG_SKIPCHUNK_bKGD
3246	#ifndef MNG_OPTIMIZE_CHUNKREADER
3247	mng_retcode mng_create_ani_bkgd (mng_datap pData,
3248	mng_uint16 iRed,
3249	mng_uint16 iGreen,
3250	mng_uint16 iBlue)
3251	#else
3252	mng_retcode mng_create_ani_bkgd (mng_datap pData)
3253	#endif
3254	{
3255	mng_ani_bkgdp pBKGD;
3256
3257	#ifdef MNG_SUPPORT_TRACE
3258	MNG_TRACE (pData, MNG_FN_CREATE_ANI_BKGD, MNG_LC_START);
3259	#endif
3260
3261	if (pData->bCacheplayback) /* caching playback info ? */
3262	{
3263	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3264	mng_ptr pTemp;
3265	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_bkgd),
3266	mng_free_obj_general,
3267	mng_process_ani_bkgd,
3268	&pTemp);
3269	if (iRetcode)
3270	return iRetcode;
3271	pBKGD = (mng_ani_bkgdp)pTemp;
3272	#else
3273	MNG_ALLOC (pData, pBKGD, sizeof (mng_ani_bkgd));
3274
3275	pBKGD->sHeader.fCleanup = mng_free_ani_bkgd;
3276	pBKGD->sHeader.fProcess = mng_process_ani_bkgd;
3277	#endif
3278
3279	mng_add_ani_object (pData, (mng_object_headerp)pBKGD);
3280
3281	#ifndef MNG_OPTIMIZE_CHUNKREADER
3282	pBKGD->iRed = iRed;
3283	pBKGD->iGreen = iGreen;
3284	pBKGD->iBlue = iBlue;
3285	#else
3286	pBKGD->iRed = pData->iGlobalBKGDred;
3287	pBKGD->iGreen = pData->iGlobalBKGDgreen;
3288	pBKGD->iBlue = pData->iGlobalBKGDblue;
3289	#endif
3290	}
3291
3292	#ifdef MNG_SUPPORT_TRACE
3293	MNG_TRACE (pData, MNG_FN_CREATE_ANI_BKGD, MNG_LC_END);
3294	#endif
3295
3296	return MNG_NOERROR;
3297	}
3298
3299	/* ************************************************************************** */
3300
3301	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3302	mng_retcode mng_free_ani_bkgd (mng_datap pData,
3303	mng_objectp pObject)
3304	{
3305	#ifdef MNG_SUPPORT_TRACE
3306	MNG_TRACE (pData, MNG_FN_FREE_ANI_BKGD, MNG_LC_START);
3307	#endif
3308
3309	MNG_FREEX (pData, pObject, sizeof (mng_ani_bkgd));
3310
3311	#ifdef MNG_SUPPORT_TRACE
3312	MNG_TRACE (pData, MNG_FN_FREE_ANI_BKGD, MNG_LC_END);
3313	#endif
3314
3315	return MNG_NOERROR;
3316	}
3317	#endif
3318
3319	/* ************************************************************************** */
3320
3321	mng_retcode mng_process_ani_bkgd (mng_datap pData,
3322	mng_objectp pObject)
3323	{
3324	mng_ani_bkgdp pBKGD = (mng_ani_bkgdp)pObject;
3325
3326	#ifdef MNG_SUPPORT_TRACE
3327	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BKGD, MNG_LC_START);
3328	#endif
3329
3330	pData->bHasglobalBKGD = MNG_TRUE;
3331	pData->iGlobalBKGDred = pBKGD->iRed;
3332	pData->iGlobalBKGDgreen = pBKGD->iGreen;
3333	pData->iGlobalBKGDblue = pBKGD->iBlue;
3334
3335	#ifdef MNG_SUPPORT_TRACE
3336	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BKGD, MNG_LC_END);
3337	#endif
3338
3339	return MNG_NOERROR;
3340	}
3341	#endif
3342
3343	/* ************************************************************************** */
3344	/* ************************************************************************** */
3345
3346	#ifndef MNG_SKIPCHUNK_LOOP
3347	#ifndef MNG_OPTIMIZE_CHUNKREADER
3348	mng_retcode mng_create_ani_loop (mng_datap pData,
3349	mng_uint8 iLevel,
3350	mng_uint32 iRepeatcount,
3351	mng_uint8 iTermcond,
3352	mng_uint32 iItermin,
3353	mng_uint32 iItermax,
3354	mng_uint32 iCount,
3355	mng_uint32p pSignals)
3356	#else
3357	mng_retcode mng_create_ani_loop (mng_datap pData,
3358	mng_chunkp pChunk)
3359	#endif
3360	{
3361	mng_ani_loopp pLOOP;
3362
3363	#ifdef MNG_SUPPORT_TRACE
3364	MNG_TRACE (pData, MNG_FN_CREATE_ANI_LOOP, MNG_LC_START);
3365	#endif
3366
3367	if (pData->bCacheplayback) /* caching playback info ? */
3368	{
3369	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3370	mng_ptr pTemp;
3371	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
3372	mng_free_ani_loop,
3373	mng_process_ani_loop,
3374	&pTemp);
3375	if (iRetcode)
3376	return iRetcode;
3377	pLOOP = (mng_ani_loopp)pTemp;
3378	#else
3379	MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
3380
3381	pLOOP->sHeader.fCleanup = mng_free_ani_loop;
3382	pLOOP->sHeader.fProcess = mng_process_ani_loop;
3383	#endif
3384
3385	mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
3386
3387	#ifndef MNG_OPTIMIZE_CHUNKREADER
3388	pLOOP->iLevel = iLevel;
3389	pLOOP->iRepeatcount = iRepeatcount;
3390	pLOOP->iTermcond = iTermcond;
3391	pLOOP->iItermin = iItermin;
3392	pLOOP->iItermax = iItermax;
3393	pLOOP->iCount = iCount;
3394
3395	#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
3396	if (iCount)
3397	{
3398	MNG_ALLOC (pData, pLOOP->pSignals, (iCount << 1));
3399	MNG_COPY (pLOOP->pSignals, pSignals, (iCount << 1));
3400	}
3401	#endif
3402	#else /* MNG_OPTIMIZE_CHUNKREADER */
3403	pLOOP->iLevel = ((mng_loopp)pChunk)->iLevel;
3404	pLOOP->iRepeatcount = ((mng_loopp)pChunk)->iRepeat;
3405	pLOOP->iTermcond = ((mng_loopp)pChunk)->iTermination;
3406	pLOOP->iItermin = ((mng_loopp)pChunk)->iItermin;
3407	pLOOP->iItermax = ((mng_loopp)pChunk)->iItermax;
3408	pLOOP->iCount = ((mng_loopp)pChunk)->iCount;
3409
3410	#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
3411	if (pLOOP->iCount)
3412	{
3413	MNG_ALLOC (pData, pLOOP->pSignals, (pLOOP->iCount << 1));
3414	MNG_COPY (pLOOP->pSignals, ((mng_loopp)pChunk)->pSignals, (pLOOP->iCount << 1));
3415	}
3416	#endif
3417	#endif /* MNG_OPTIMIZE_CHUNKREADER */
3418	/* running counter starts with repeat_count */
3419	pLOOP->iRunningcount = pLOOP->iRepeatcount;
3420	}
3421
3422	#ifdef MNG_SUPPORT_TRACE
3423	MNG_TRACE (pData, MNG_FN_CREATE_ANI_LOOP, MNG_LC_END);
3424	#endif
3425
3426	return MNG_NOERROR;
3427	}
3428
3429	/* ************************************************************************** */
3430
3431	mng_retcode mng_free_ani_loop (mng_datap pData,
3432	mng_objectp pObject)
3433	{
3434	#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
3435	mng_ani_loopp pLOOP = (mng_ani_loopp)pObject;
3436	#endif
3437
3438	#ifdef MNG_SUPPORT_TRACE
3439	MNG_TRACE (pData, MNG_FN_FREE_ANI_LOOP, MNG_LC_START);
3440	#endif
3441
3442	#ifndef MNG_NO_LOOP_SIGNALS_SUPPORTED
3443	if (pLOOP->iCount) /* drop signal buffer ? */
3444	MNG_FREEX (pData, pLOOP->pSignals, (pLOOP->iCount << 1));
3445	#endif
3446
3447	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3448	MNG_FREEX (pData, pObject, sizeof (mng_ani_loop));
3449	#endif
3450
3451	#ifdef MNG_SUPPORT_TRACE
3452	MNG_TRACE (pData, MNG_FN_FREE_ANI_LOOP, MNG_LC_END);
3453	#endif
3454
3455	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3456	return MNG_NOERROR;
3457	#else
3458	return mng_free_obj_general(pData, pObject);
3459	#endif
3460	}
3461
3462	/* ************************************************************************** */
3463
3464	mng_retcode mng_process_ani_loop (mng_datap pData,
3465	mng_objectp pObject)
3466	{
3467	mng_ani_loopp pLOOP = (mng_ani_loopp)pObject;
3468
3469	#ifdef MNG_SUPPORT_TRACE
3470	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_LOOP, MNG_LC_START);
3471	#endif
3472	/* just reset the running counter */
3473	pLOOP->iRunningcount = pLOOP->iRepeatcount;
3474	/* iteration=0 means we're skipping ! */
3475	if ((!pData->bSkipping) && (pLOOP->iRepeatcount == 0))
3476	pData->bSkipping = MNG_TRUE;
3477
3478	#ifdef MNG_SUPPORT_TRACE
3479	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_LOOP, MNG_LC_END);
3480	#endif
3481
3482	return MNG_NOERROR;
3483	}
3484
3485	/* ************************************************************************** */
3486	/* ************************************************************************** */
3487
3488	mng_retcode mng_create_ani_endl (mng_datap pData,
3489	mng_uint8 iLevel)
3490	{
3491	mng_ani_endlp pENDL;
3492
3493	#ifdef MNG_SUPPORT_TRACE
3494	MNG_TRACE (pData, MNG_FN_CREATE_ANI_ENDL, MNG_LC_START);
3495	#endif
3496
3497	if (pData->bCacheplayback) /* caching playback info ? */
3498	{
3499	mng_retcode iRetcode;
3500	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3501	mng_ptr pTemp;
3502	iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
3503	mng_free_obj_general,
3504	mng_process_ani_endl,
3505	&pTemp);
3506	if (iRetcode)
3507	return iRetcode;
3508	pENDL = (mng_ani_endlp)pTemp;
3509	#else
3510	MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
3511
3512	pENDL->sHeader.fCleanup = mng_free_ani_endl;
3513	pENDL->sHeader.fProcess = mng_process_ani_endl;
3514	#endif
3515
3516	mng_add_ani_object (pData, (mng_object_headerp)pENDL);
3517
3518	pENDL->iLevel = iLevel;
3519
3520	iRetcode = mng_process_ani_endl (pData, (mng_objectp)pENDL);
3521	if (iRetcode)
3522	return iRetcode;
3523	}
3524
3525	#ifdef MNG_SUPPORT_TRACE
3526	MNG_TRACE (pData, MNG_FN_CREATE_ANI_ENDL, MNG_LC_END);
3527	#endif
3528
3529	return MNG_NOERROR;
3530	}
3531
3532	/* ************************************************************************** */
3533
3534	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3535	mng_retcode mng_free_ani_endl (mng_datap pData,
3536	mng_objectp pObject)
3537	{
3538	#ifdef MNG_SUPPORT_TRACE
3539	MNG_TRACE (pData, MNG_FN_FREE_ANI_ENDL, MNG_LC_START);
3540	#endif
3541
3542	MNG_FREEX (pData, pObject, sizeof (mng_ani_endl));
3543
3544	#ifdef MNG_SUPPORT_TRACE
3545	MNG_TRACE (pData, MNG_FN_FREE_ANI_ENDL, MNG_LC_END);
3546	#endif
3547
3548	return MNG_NOERROR;
3549	}
3550	#endif
3551
3552	/* ************************************************************************** */
3553
3554	mng_retcode mng_process_ani_endl (mng_datap pData,
3555	mng_objectp pObject)
3556	{
3557	mng_ani_endlp pENDL = (mng_ani_endlp)pObject;
3558	mng_ani_loopp pLOOP;
3559
3560	#ifdef MNG_SUPPORT_TRACE
3561	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ENDL, MNG_LC_START);
3562	#endif
3563
3564	if (((pData->bDisplaying) && ((pData->bRunning) \|\| (pData->bSearching))) \|\|
3565	(pData->bReading) )
3566	{
3567	pLOOP = pENDL->pLOOP; /* determine matching LOOP */
3568
3569	if (!pLOOP) /* haven't got it yet ? */
3570	{ /* go and look back in the list */
3571	pLOOP = (mng_ani_loopp)pENDL->sHeader.pPrev;
3572
3573	while ((pLOOP) &&
3574	((pLOOP->sHeader.fCleanup != mng_free_ani_loop) \|\|
3575	(pLOOP->iLevel != pENDL->iLevel) ))
3576	pLOOP = pLOOP->sHeader.pPrev;
3577	}
3578	/* got it now ? */
3579	if ((pLOOP) && (pLOOP->iLevel == pENDL->iLevel))
3580	{
3581	pENDL->pLOOP = pLOOP; /* save for next time ! */
3582	/* decrease running counter ? */
3583	if ((pLOOP->iRunningcount) && (pLOOP->iRunningcount < 0x7fffffffL))
3584	pLOOP->iRunningcount--;
3585
3586	if ((!pData->bDisplaying) && (pData->bReading) &&
3587	(pLOOP->iRunningcount >= 0x7fffffffL))
3588	{
3589	pData->iTotalframes = 0x7fffffffL;
3590	pData->iTotallayers = 0x7fffffffL;
3591	pData->iTotalplaytime = 0x7fffffffL;
3592	}
3593	else
3594	{
3595	/* TODO: we're cheating out on the termination_condition,
3596	iteration_min, iteration_max and possible signals;
3597	the code is just not ready for that can of worms.... */
3598
3599	if (!pLOOP->iRunningcount) /* reached zero ? */
3600	{ /* was this the outer LOOP ? */
3601	if (pData->pFirstaniobj == (mng_objectp)pLOOP) /* TODO: THIS IS WRONG!! */
3602	pData->bHasLOOP = MNG_FALSE;
3603	}
3604	else
3605	{
3606	if (pData->pCurraniobj) /* was we processing objects ? */
3607	pData->pCurraniobj = pLOOP;/* then restart with LOOP */
3608	else /* else restart behind LOOP !!! */
3609	pData->pCurraniobj = pLOOP->sHeader.pNext;
3610	}
3611	}
3612	/* does this match a 'skipping' LOOP? */
3613	if ((pData->bSkipping) && (pLOOP->iRepeatcount == 0))
3614	pData->bSkipping = MNG_FALSE;
3615	}
3616	else
3617	MNG_ERROR (pData, MNG_NOMATCHINGLOOP);
3618
3619	}
3620
3621	#ifdef MNG_SUPPORT_TRACE
3622	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ENDL, MNG_LC_END);
3623	#endif
3624
3625	return MNG_NOERROR;
3626	}
3627	#endif
3628
3629	/* ************************************************************************** */
3630
3631	#ifndef MNG_SKIPCHUNK_DEFI
3632	mng_retcode mng_create_ani_defi (mng_datap pData)
3633	{
3634	mng_ani_defip pDEFI;
3635
3636	#ifdef MNG_SUPPORT_TRACE
3637	MNG_TRACE (pData, MNG_FN_CREATE_ANI_DEFI, MNG_LC_START);
3638	#endif
3639
3640	if (pData->bCacheplayback) /* caching playback info ? */
3641	{
3642	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3643	mng_ptr pTemp;
3644	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_defi),
3645	mng_free_obj_general,
3646	mng_process_ani_defi,
3647	&pTemp);
3648	if (iRetcode)
3649	return iRetcode;
3650	pDEFI = (mng_ani_defip)pTemp;
3651	#else
3652	MNG_ALLOC (pData, pDEFI, sizeof (mng_ani_defi));
3653
3654	pDEFI->sHeader.fCleanup = mng_free_ani_defi;
3655	pDEFI->sHeader.fProcess = mng_process_ani_defi;
3656	#endif
3657
3658	mng_add_ani_object (pData, (mng_object_headerp)pDEFI);
3659
3660	pDEFI->iId = pData->iDEFIobjectid;
3661	pDEFI->bHasdonotshow = pData->bDEFIhasdonotshow;
3662	pDEFI->iDonotshow = pData->iDEFIdonotshow;
3663	pDEFI->bHasconcrete = pData->bDEFIhasconcrete;
3664	pDEFI->iConcrete = pData->iDEFIconcrete;
3665	pDEFI->bHasloca = pData->bDEFIhasloca;
3666	pDEFI->iLocax = pData->iDEFIlocax;
3667	pDEFI->iLocay = pData->iDEFIlocay;
3668	pDEFI->bHasclip = pData->bDEFIhasclip;
3669	pDEFI->iClipl = pData->iDEFIclipl;
3670	pDEFI->iClipr = pData->iDEFIclipr;
3671	pDEFI->iClipt = pData->iDEFIclipt;
3672	pDEFI->iClipb = pData->iDEFIclipb;
3673	}
3674
3675	#ifdef MNG_SUPPORT_TRACE
3676	MNG_TRACE (pData, MNG_FN_CREATE_ANI_DEFI, MNG_LC_END);
3677	#endif
3678
3679	return MNG_NOERROR;
3680	}
3681
3682	/* ************************************************************************** */
3683
3684	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3685	mng_retcode mng_free_ani_defi (mng_datap pData,
3686	mng_objectp pObject)
3687	{
3688	#ifdef MNG_SUPPORT_TRACE
3689	MNG_TRACE (pData, MNG_FN_FREE_ANI_DEFI, MNG_LC_START);
3690	#endif
3691
3692	MNG_FREEX (pData, pObject, sizeof (mng_ani_defi));
3693
3694	#ifdef MNG_SUPPORT_TRACE
3695	MNG_TRACE (pData, MNG_FN_FREE_ANI_DEFI, MNG_LC_END);
3696	#endif
3697
3698	return MNG_NOERROR;
3699	}
3700	#endif
3701
3702	/* ************************************************************************** */
3703
3704	mng_retcode mng_process_ani_defi (mng_datap pData,
3705	mng_objectp pObject)
3706	{
3707	mng_ani_defip pDEFI = (mng_ani_defip)pObject;
3708	mng_retcode iRetcode;
3709
3710	#ifdef MNG_SUPPORT_TRACE
3711	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DEFI, MNG_LC_START);
3712	#endif
3713
3714	pData->iDEFIobjectid = pDEFI->iId;
3715	pData->bDEFIhasdonotshow = pDEFI->bHasdonotshow;
3716	pData->iDEFIdonotshow = pDEFI->iDonotshow;
3717	pData->bDEFIhasconcrete = pDEFI->bHasconcrete;
3718	pData->iDEFIconcrete = pDEFI->iConcrete;
3719	pData->bDEFIhasloca = pDEFI->bHasloca;
3720	pData->iDEFIlocax = pDEFI->iLocax;
3721	pData->iDEFIlocay = pDEFI->iLocay;
3722	pData->bDEFIhasclip = pDEFI->bHasclip;
3723	pData->iDEFIclipl = pDEFI->iClipl;
3724	pData->iDEFIclipr = pDEFI->iClipr;
3725	pData->iDEFIclipt = pDEFI->iClipt;
3726	pData->iDEFIclipb = pDEFI->iClipb;
3727
3728	iRetcode = mng_process_display_defi (pData);
3729
3730	if (iRetcode) /* on error bail out */
3731	return iRetcode;
3732
3733	#ifdef MNG_SUPPORT_TRACE
3734	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DEFI, MNG_LC_END);
3735	#endif
3736
3737	return MNG_NOERROR;
3738	}
3739	#endif
3740
3741	/* ************************************************************************** */
3742	/* ************************************************************************** */
3743
3744	#ifndef MNG_SKIPCHUNK_BASI
3745	#ifndef MNG_OPTIMIZE_CHUNKREADER
3746	mng_retcode mng_create_ani_basi (mng_datap pData,
3747	mng_uint16 iRed,
3748	mng_uint16 iGreen,
3749	mng_uint16 iBlue,
3750	mng_bool bHasalpha,
3751	mng_uint16 iAlpha,
3752	mng_uint8 iViewable)
3753	#else
3754	mng_retcode mng_create_ani_basi (mng_datap pData,
3755	mng_chunkp pChunk)
3756	#endif
3757	{
3758	mng_ani_basip pBASI;
3759	mng_retcode iRetcode;
3760
3761	#ifdef MNG_SUPPORT_TRACE
3762	MNG_TRACE (pData, MNG_FN_CREATE_ANI_BASI, MNG_LC_START);
3763	#endif
3764
3765	if (pData->bCacheplayback) /* caching playback info ? */
3766	{
3767	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3768	mng_ptr pTemp;
3769	iRetcode = create_obj_general (pData, sizeof (mng_ani_basi),
3770	mng_free_obj_general,
3771	mng_process_ani_basi,
3772	&pTemp);
3773	if (iRetcode)
3774	return iRetcode;
3775	pBASI = (mng_ani_basip)pTemp;
3776	#else
3777	MNG_ALLOC (pData, pBASI, sizeof (mng_ani_basi));
3778
3779	pBASI->sHeader.fCleanup = mng_free_ani_basi;
3780	pBASI->sHeader.fProcess = mng_process_ani_basi;
3781	#endif
3782
3783	mng_add_ani_object (pData, (mng_object_headerp)pBASI);
3784
3785	#ifndef MNG_OPTIMIZE_CHUNKREADER
3786	pBASI->iRed = iRed;
3787	pBASI->iGreen = iGreen;
3788	pBASI->iBlue = iBlue;
3789	pBASI->bHasalpha = bHasalpha;
3790	pBASI->iAlpha = iAlpha;
3791	pBASI->iViewable = iViewable;
3792	#else
3793	pBASI->iRed = ((mng_basip)pChunk)->iRed;
3794	pBASI->iGreen = ((mng_basip)pChunk)->iGreen;
3795	pBASI->iBlue = ((mng_basip)pChunk)->iBlue;
3796	pBASI->bHasalpha = ((mng_basip)pChunk)->bHasalpha;
3797	pBASI->iAlpha = ((mng_basip)pChunk)->iAlpha;
3798	pBASI->iViewable = ((mng_basip)pChunk)->iViewable;
3799	#endif
3800	}
3801
3802	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
3803	#ifndef MNG_OPTIMIZE_CHUNKREADER
3804	iRetcode = mng_process_display_basi (pData, iRed, iGreen, iBlue,
3805	bHasalpha, iAlpha, iViewable);
3806	#else
3807	iRetcode = mng_process_display_basi (pData,
3808	((mng_basip)pChunk)->iRed,
3809	((mng_basip)pChunk)->iGreen,
3810	((mng_basip)pChunk)->iBlue,
3811	((mng_basip)pChunk)->bHasalpha,
3812	((mng_basip)pChunk)->iAlpha,
3813	((mng_basip)pChunk)->iViewable);
3814	#endif
3815	#else
3816	#ifndef MNG_OPTIMIZE_CHUNKREADER
3817	pData->iBASIred = iRed;
3818	pData->iBASIgreen = iGreen;
3819	pData->iBASIblue = iBlue;
3820	pData->bBASIhasalpha = bHasalpha;
3821	pData->iBASIalpha = iAlpha;
3822	pData->iBASIviewable = iViewable;
3823	#else
3824	pData->iBASIred = ((mng_basip)pChunk)->iRed;
3825	pData->iBASIgreen = ((mng_basip)pChunk)->iGreen;
3826	pData->iBASIblue = ((mng_basip)pChunk)->iBlue;
3827	pData->bBASIhasalpha = ((mng_basip)pChunk)->bHasalpha;
3828	pData->iBASIalpha = ((mng_basip)pChunk)->iAlpha;
3829	pData->iBASIviewable = ((mng_basip)pChunk)->iViewable;
3830	#endif
3831
3832	iRetcode = mng_process_display_basi (pData);
3833	#endif
3834
3835	#ifdef MNG_SUPPORT_TRACE
3836	MNG_TRACE (pData, MNG_FN_CREATE_ANI_BASI, MNG_LC_END);
3837	#endif
3838
3839	return iRetcode;
3840	}
3841
3842	/* ************************************************************************** */
3843
3844	#ifndef MNG_OPTIMIZE_OBJCLEANUP
3845	mng_retcode mng_free_ani_basi (mng_datap pData,
3846	mng_objectp pObject)
3847	{
3848	#ifdef MNG_SUPPORT_TRACE
3849	MNG_TRACE (pData, MNG_FN_FREE_ANI_BASI, MNG_LC_START);
3850	#endif
3851
3852	MNG_FREEX (pData, pObject, sizeof (mng_ani_basi));
3853
3854	#ifdef MNG_SUPPORT_TRACE
3855	MNG_TRACE (pData, MNG_FN_FREE_ANI_BASI, MNG_LC_END);
3856	#endif
3857
3858	return MNG_NOERROR;
3859	}
3860	#endif
3861
3862	/* ************************************************************************** */
3863
3864	mng_retcode mng_process_ani_basi (mng_datap pData,
3865	mng_objectp pObject)
3866	{
3867	mng_ani_basip pBASI = (mng_ani_basip)pObject;
3868	mng_retcode iRetcode;
3869
3870	#ifdef MNG_SUPPORT_TRACE
3871	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BASI, MNG_LC_START);
3872	#endif
3873
3874	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
3875	iRetcode = mng_process_display_basi (pData, pBASI->iRed, pBASI->iGreen, pBASI->iBlue,
3876	pBASI->bHasalpha, pBASI->iAlpha, pBASI->iViewable);
3877	#else
3878	pData->iBASIred = pBASI->iRed;
3879	pData->iBASIgreen = pBASI->iGreen;
3880	pData->iBASIblue = pBASI->iBlue;
3881	pData->bBASIhasalpha = pBASI->bHasalpha;
3882	pData->iBASIalpha = pBASI->iAlpha;
3883	pData->iBASIviewable = pBASI->iViewable;
3884
3885	iRetcode = mng_process_display_basi (pData);
3886	#endif
3887
3888	#ifdef MNG_SUPPORT_TRACE
3889	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BASI, MNG_LC_END);
3890	#endif
3891
3892	return iRetcode;
3893	}
3894	#endif
3895
3896	/* ************************************************************************** */
3897
3898	#ifndef MNG_SKIPCHUNK_CLON
3899	#ifndef MNG_OPTIMIZE_CHUNKREADER
3900	mng_retcode mng_create_ani_clon (mng_datap pData,
3901	mng_uint16 iSourceid,
3902	mng_uint16 iCloneid,
3903	mng_uint8 iClonetype,
3904	mng_bool bHasdonotshow,
3905	mng_uint8 iDonotshow,
3906	mng_uint8 iConcrete,
3907	mng_bool bHasloca,
3908	mng_uint8 iLocatype,
3909	mng_int32 iLocax,
3910	mng_int32 iLocay)
3911	#else
3912	mng_retcode mng_create_ani_clon (mng_datap pData,
3913	mng_chunkp pChunk)
3914	#endif
3915	{
3916	mng_ani_clonp pCLON;
3917	mng_retcode iRetcode;
3918
3919	#ifdef MNG_SUPPORT_TRACE
3920	MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLON, MNG_LC_START);
3921	#endif
3922
3923	if (pData->bCacheplayback) /* caching playback info ? */
3924	{
3925	#ifdef MNG_OPTIMIZE_OBJCLEANUP
3926	mng_ptr pTemp;
3927	iRetcode = create_obj_general (pData, sizeof (mng_ani_clon),
3928	mng_free_obj_general,
3929	mng_process_ani_clon,
3930	&pTemp);
3931	if (iRetcode)
3932	return iRetcode;
3933	pCLON = (mng_ani_clonp)pTemp;
3934	#else
3935	MNG_ALLOC (pData, pCLON, sizeof (mng_ani_clon));
3936
3937	pCLON->sHeader.fCleanup = mng_free_ani_clon;
3938	pCLON->sHeader.fProcess = mng_process_ani_clon;
3939	#endif
3940
3941	mng_add_ani_object (pData, (mng_object_headerp)pCLON);
3942
3943	#ifndef MNG_OPTIMIZE_CHUNKREADER
3944	pCLON->iSourceid = iSourceid;
3945	pCLON->iCloneid = iCloneid;
3946	pCLON->iClonetype = iClonetype;
3947	pCLON->bHasdonotshow = bHasdonotshow;
3948	pCLON->iDonotshow = iDonotshow;
3949	pCLON->iConcrete = iConcrete;
3950	pCLON->bHasloca = bHasloca;
3951	pCLON->iLocatype = iLocatype;
3952	pCLON->iLocax = iLocax;
3953	pCLON->iLocay = iLocay;
3954	#else
3955	pCLON->iSourceid = ((mng_clonp)pChunk)->iSourceid;
3956	pCLON->iCloneid = ((mng_clonp)pChunk)->iCloneid;
3957	pCLON->iClonetype = ((mng_clonp)pChunk)->iClonetype;
3958	pCLON->bHasdonotshow = ((mng_clonp)pChunk)->bHasdonotshow;
3959	pCLON->iDonotshow = ((mng_clonp)pChunk)->iDonotshow;
3960	pCLON->iConcrete = ((mng_clonp)pChunk)->iConcrete;
3961	pCLON->bHasloca = ((mng_clonp)pChunk)->bHasloca;
3962	pCLON->iLocatype = ((mng_clonp)pChunk)->iLocationtype;
3963	pCLON->iLocax = ((mng_clonp)pChunk)->iLocationx;
3964	pCLON->iLocay = ((mng_clonp)pChunk)->iLocationy;
3965	#endif
3966	}
3967
3968	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
3969	#ifndef MNG_OPTIMIZE_CHUNKREADER
3970	iRetcode = mng_process_display_clon (pData, iSourceid, iCloneid, iClonetype,
3971	bHasdonotshow, iDonotshow, iConcrete,
3972	bHasloca, iLocatype, iLocax, iLocay);
3973	#else
3974	iRetcode = mng_process_display_clon (pData,
3975	((mng_clonp)pChunk)->iSourceid,
3976	((mng_clonp)pChunk)->iCloneid,
3977	((mng_clonp)pChunk)->iClonetype,
3978	((mng_clonp)pChunk)->bHasdonotshow,
3979	((mng_clonp)pChunk)->iDonotshow,
3980	((mng_clonp)pChunk)->iConcrete,
3981	((mng_clonp)pChunk)->bHasloca,
3982	((mng_clonp)pChunk)->iLocationtype,
3983	((mng_clonp)pChunk)->iLocationx,
3984	((mng_clonp)pChunk)->iLocationy);
3985	#endif
3986	#else
3987	#ifndef MNG_OPTIMIZE_CHUNKREADER
3988	pData->iCLONsourceid = iSourceid;
3989	pData->iCLONcloneid = iCloneid;
3990	pData->iCLONclonetype = iClonetype;
3991	pData->bCLONhasdonotshow = bHasdonotshow;
3992	pData->iCLONdonotshow = iDonotshow;
3993	pData->iCLONconcrete = iConcrete;
3994	pData->bCLONhasloca = bHasloca;
3995	pData->iCLONlocationtype = iLocatype;
3996	pData->iCLONlocationx = iLocax;
3997	pData->iCLONlocationy = iLocay;
3998	#else
3999	pData->iCLONsourceid = ((mng_clonp)pChunk)->iSourceid;
4000	pData->iCLONcloneid = ((mng_clonp)pChunk)->iCloneid;
4001	pData->iCLONclonetype = ((mng_clonp)pChunk)->iClonetype;
4002	pData->bCLONhasdonotshow = ((mng_clonp)pChunk)->bHasdonotshow;
4003	pData->iCLONdonotshow = ((mng_clonp)pChunk)->iDonotshow;
4004	pData->iCLONconcrete = ((mng_clonp)pChunk)->iConcrete;
4005	pData->bCLONhasloca = ((mng_clonp)pChunk)->bHasloca;
4006	pData->iCLONlocationtype = ((mng_clonp)pChunk)->iLocationtype;
4007	pData->iCLONlocationx = ((mng_clonp)pChunk)->iLocationx;
4008	pData->iCLONlocationy = ((mng_clonp)pChunk)->iLocationy;
4009	#endif
4010
4011	iRetcode = mng_process_display_clon (pData);
4012	#endif
4013
4014	#ifdef MNG_SUPPORT_TRACE
4015	MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLON, MNG_LC_END);
4016	#endif
4017
4018	return iRetcode;
4019	}
4020
4021	/* ************************************************************************** */
4022
4023	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4024	mng_retcode mng_free_ani_clon (mng_datap pData,
4025	mng_objectp pObject)
4026	{
4027	#ifdef MNG_SUPPORT_TRACE
4028	MNG_TRACE (pData, MNG_FN_FREE_ANI_CLON, MNG_LC_START);
4029	#endif
4030
4031	MNG_FREEX (pData, pObject, sizeof (mng_ani_clon));
4032
4033	#ifdef MNG_SUPPORT_TRACE
4034	MNG_TRACE (pData, MNG_FN_FREE_ANI_CLON, MNG_LC_END);
4035	#endif
4036
4037	return MNG_NOERROR;
4038	}
4039	#endif
4040
4041	/* ************************************************************************** */
4042
4043	mng_retcode mng_process_ani_clon (mng_datap pData,
4044	mng_objectp pObject)
4045	{
4046	mng_ani_clonp pCLON = (mng_ani_clonp)pObject;
4047	mng_retcode iRetcode;
4048
4049	#ifdef MNG_SUPPORT_TRACE
4050	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLON, MNG_LC_START);
4051	#endif
4052
4053	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4054	iRetcode = mng_process_display_clon (pData, pCLON->iSourceid, pCLON->iCloneid,
4055	pCLON->iClonetype, pCLON->bHasdonotshow,
4056	pCLON->iDonotshow, pCLON->iConcrete,
4057	pCLON->bHasloca, pCLON->iLocatype,
4058	pCLON->iLocax, pCLON->iLocay);
4059	#else
4060	pData->iCLONcloneid = pCLON->iCloneid;
4061	pData->iCLONsourceid = pCLON->iSourceid;
4062	pData->iCLONclonetype = pCLON->iClonetype;
4063	pData->bCLONhasdonotshow = pCLON->bHasdonotshow;
4064	pData->iCLONdonotshow = pCLON->iDonotshow;
4065	pData->iCLONconcrete = pCLON->iConcrete;
4066	pData->bCLONhasloca = pCLON->bHasloca;
4067	pData->iCLONlocationtype = pCLON->iLocatype;
4068	pData->iCLONlocationx = pCLON->iLocax;
4069	pData->iCLONlocationy = pCLON->iLocay;
4070
4071	iRetcode = mng_process_display_clon (pData);
4072	#endif
4073
4074	#ifdef MNG_SUPPORT_TRACE
4075	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLON, MNG_LC_END);
4076	#endif
4077
4078	return iRetcode;
4079	}
4080	#endif
4081
4082	/* ************************************************************************** */
4083
4084	#ifndef MNG_SKIPCHUNK_BACK
4085	#ifndef MNG_OPTIMIZE_CHUNKREADER
4086	mng_retcode mng_create_ani_back (mng_datap pData,
4087	mng_uint16 iRed,
4088	mng_uint16 iGreen,
4089	mng_uint16 iBlue,
4090	mng_uint8 iMandatory,
4091	mng_uint16 iImageid,
4092	mng_uint8 iTile)
4093	#else
4094	mng_retcode mng_create_ani_back (mng_datap pData)
4095	#endif
4096	{
4097	mng_ani_backp pBACK;
4098
4099	#ifdef MNG_SUPPORT_TRACE
4100	MNG_TRACE (pData, MNG_FN_CREATE_ANI_BACK, MNG_LC_START);
4101	#endif
4102
4103	if (pData->bCacheplayback) /* caching playback info ? */
4104	{
4105	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4106	mng_ptr pTemp;
4107	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_back),
4108	mng_free_obj_general,
4109	mng_process_ani_back,
4110	&pTemp);
4111	if (iRetcode)
4112	return iRetcode;
4113	pBACK = (mng_ani_backp)pTemp;
4114	#else
4115	MNG_ALLOC (pData, pBACK, sizeof (mng_ani_back));
4116
4117	pBACK->sHeader.fCleanup = mng_free_ani_back;
4118	pBACK->sHeader.fProcess = mng_process_ani_back;
4119	#endif
4120
4121	mng_add_ani_object (pData, (mng_object_headerp)pBACK);
4122
4123	#ifndef MNG_OPTIMIZE_CHUNKREADER
4124	pBACK->iRed = iRed;
4125	pBACK->iGreen = iGreen;
4126	pBACK->iBlue = iBlue;
4127	pBACK->iMandatory = iMandatory;
4128	pBACK->iImageid = iImageid;
4129	pBACK->iTile = iTile;
4130	#else
4131	pBACK->iRed = pData->iBACKred;
4132	pBACK->iGreen = pData->iBACKgreen;
4133	pBACK->iBlue = pData->iBACKblue;
4134	pBACK->iMandatory = pData->iBACKmandatory;
4135	pBACK->iImageid = pData->iBACKimageid;
4136	pBACK->iTile = pData->iBACKtile;
4137	#endif
4138	}
4139
4140	#ifdef MNG_SUPPORT_TRACE
4141	MNG_TRACE (pData, MNG_FN_CREATE_ANI_BACK, MNG_LC_END);
4142	#endif
4143
4144	return MNG_NOERROR;
4145	}
4146
4147	/* ************************************************************************** */
4148
4149	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4150	mng_retcode mng_free_ani_back (mng_datap pData,
4151	mng_objectp pObject)
4152	{
4153	#ifdef MNG_SUPPORT_TRACE
4154	MNG_TRACE (pData, MNG_FN_FREE_ANI_BACK, MNG_LC_START);
4155	#endif
4156
4157	MNG_FREEX (pData, pObject, sizeof (mng_ani_back));
4158
4159	#ifdef MNG_SUPPORT_TRACE
4160	MNG_TRACE (pData, MNG_FN_FREE_ANI_BACK, MNG_LC_END);
4161	#endif
4162
4163	return MNG_NOERROR;
4164	}
4165	#endif
4166
4167	/* ************************************************************************** */
4168
4169	mng_retcode mng_process_ani_back (mng_datap pData,
4170	mng_objectp pObject)
4171	{
4172	mng_ani_backp pBACK = (mng_ani_backp)pObject;
4173
4174	#ifdef MNG_SUPPORT_TRACE
4175	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BACK, MNG_LC_START);
4176	#endif
4177
4178	pData->iBACKred = pBACK->iRed;
4179	pData->iBACKgreen = pBACK->iGreen;
4180	pData->iBACKblue = pBACK->iBlue;
4181	pData->iBACKmandatory = pBACK->iMandatory;
4182	pData->iBACKimageid = pBACK->iImageid;
4183	pData->iBACKtile = pBACK->iTile;
4184
4185	#ifdef MNG_SUPPORT_TRACE
4186	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BACK, MNG_LC_END);
4187	#endif
4188
4189	return MNG_NOERROR;
4190	}
4191	#endif
4192
4193	/* ************************************************************************** */
4194
4195	#ifndef MNG_SKIPCHUNK_FRAM
4196	#ifndef MNG_OPTIMIZE_CHUNKREADER
4197	mng_retcode mng_create_ani_fram (mng_datap pData,
4198	mng_uint8 iFramemode,
4199	mng_uint8 iChangedelay,
4200	mng_uint32 iDelay,
4201	mng_uint8 iChangetimeout,
4202	mng_uint32 iTimeout,
4203	mng_uint8 iChangeclipping,
4204	mng_uint8 iCliptype,
4205	mng_int32 iClipl,
4206	mng_int32 iClipr,
4207	mng_int32 iClipt,
4208	mng_int32 iClipb)
4209	#else
4210	mng_retcode mng_create_ani_fram (mng_datap pData,
4211	mng_chunkp pChunk)
4212	#endif
4213	{
4214	mng_ani_framp pFRAM;
4215	mng_retcode iRetcode;
4216
4217	#ifdef MNG_SUPPORT_TRACE
4218	MNG_TRACE (pData, MNG_FN_CREATE_ANI_FRAM, MNG_LC_START);
4219	#endif
4220
4221	if (pData->bCacheplayback) /* caching playback info ? */
4222	{
4223	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4224	mng_ptr pTemp;
4225	iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
4226	mng_free_obj_general,
4227	mng_process_ani_fram,
4228	&pTemp);
4229	if (iRetcode)
4230	return iRetcode;
4231	pFRAM = (mng_ani_framp)pTemp;
4232	#else
4233	MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
4234
4235	pFRAM->sHeader.fCleanup = mng_free_ani_fram;
4236	pFRAM->sHeader.fProcess = mng_process_ani_fram;
4237	#endif
4238
4239	mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
4240
4241	#ifndef MNG_OPTIMIZE_CHUNKREADER
4242	pFRAM->iFramemode = iFramemode;
4243	pFRAM->iChangedelay = iChangedelay;
4244	pFRAM->iDelay = iDelay;
4245	pFRAM->iChangetimeout = iChangetimeout;
4246	pFRAM->iTimeout = iTimeout;
4247	pFRAM->iChangeclipping = iChangeclipping;
4248	pFRAM->iCliptype = iCliptype;
4249	pFRAM->iClipl = iClipl;
4250	pFRAM->iClipr = iClipr;
4251	pFRAM->iClipt = iClipt;
4252	pFRAM->iClipb = iClipb;
4253	#else
4254	pFRAM->iFramemode = ((mng_framp)pChunk)->iMode;
4255	pFRAM->iChangedelay = ((mng_framp)pChunk)->iChangedelay;
4256	pFRAM->iDelay = ((mng_framp)pChunk)->iDelay;
4257	pFRAM->iChangetimeout = ((mng_framp)pChunk)->iChangetimeout;
4258	pFRAM->iTimeout = ((mng_framp)pChunk)->iTimeout;
4259	pFRAM->iChangeclipping = ((mng_framp)pChunk)->iChangeclipping;
4260	pFRAM->iCliptype = ((mng_framp)pChunk)->iBoundarytype;
4261	pFRAM->iClipl = ((mng_framp)pChunk)->iBoundaryl;
4262	pFRAM->iClipr = ((mng_framp)pChunk)->iBoundaryr;
4263	pFRAM->iClipt = ((mng_framp)pChunk)->iBoundaryt;
4264	pFRAM->iClipb = ((mng_framp)pChunk)->iBoundaryb;
4265	#endif
4266	}
4267
4268	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4269	#ifndef MNG_OPTIMIZE_CHUNKREADER
4270	iRetcode = mng_process_display_fram (pData, iFramemode,
4271	iChangedelay, iDelay,
4272	iChangetimeout, iTimeout,
4273	iChangeclipping, iCliptype,
4274	iClipl, iClipr,
4275	iClipt, iClipb);
4276	#else
4277	iRetcode = mng_process_display_fram (pData,
4278	((mng_framp)pChunk)->iMode,
4279	((mng_framp)pChunk)->iChangedelay,
4280	((mng_framp)pChunk)->iDelay,
4281	((mng_framp)pChunk)->iChangetimeout,
4282	((mng_framp)pChunk)->iTimeout,
4283	((mng_framp)pChunk)->iChangeclipping,
4284	((mng_framp)pChunk)->iBoundarytype,
4285	((mng_framp)pChunk)->iBoundaryl,
4286	((mng_framp)pChunk)->iBoundaryr,
4287	((mng_framp)pChunk)->iBoundaryt,
4288	((mng_framp)pChunk)->iBoundaryb);
4289	#endif
4290	#else
4291	#ifndef MNG_OPTIMIZE_CHUNKREADER
4292	pData->iTempFramemode = iFramemode;
4293	pData->iTempChangedelay = iChangedelay;
4294	pData->iTempDelay = iDelay;
4295	pData->iTempChangetimeout = iChangetimeout;
4296	pData->iTempTimeout = iTimeout;
4297	pData->iTempChangeclipping = iChangeclipping;
4298	pData->iTempCliptype = iCliptype;
4299	pData->iTempClipl = iClipl;
4300	pData->iTempClipr = iClipr;
4301	pData->iTempClipt = iClipt;
4302	pData->iTempClipb = iClipb;
4303	#else
4304	pData->iTempFramemode = ((mng_framp)pChunk)->iMode;
4305	pData->iTempChangedelay = ((mng_framp)pChunk)->iChangedelay;
4306	pData->iTempDelay = ((mng_framp)pChunk)->iDelay;
4307	pData->iTempChangetimeout = ((mng_framp)pChunk)->iChangetimeout;
4308	pData->iTempTimeout = ((mng_framp)pChunk)->iTimeout;
4309	pData->iTempChangeclipping = ((mng_framp)pChunk)->iChangeclipping;
4310	pData->iTempCliptype = ((mng_framp)pChunk)->iBoundarytype;
4311	pData->iTempClipl = ((mng_framp)pChunk)->iBoundaryl;
4312	pData->iTempClipr = ((mng_framp)pChunk)->iBoundaryr;
4313	pData->iTempClipt = ((mng_framp)pChunk)->iBoundaryt;
4314	pData->iTempClipb = ((mng_framp)pChunk)->iBoundaryb;
4315	#endif
4316
4317	iRetcode = mng_process_display_fram (pData);
4318	#endif
4319
4320	#ifdef MNG_SUPPORT_TRACE
4321	MNG_TRACE (pData, MNG_FN_CREATE_ANI_FRAM, MNG_LC_END);
4322	#endif
4323
4324	return iRetcode;
4325	}
4326
4327	/* ************************************************************************** */
4328
4329	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4330	mng_retcode mng_free_ani_fram (mng_datap pData,
4331	mng_objectp pObject)
4332	{
4333	#ifdef MNG_SUPPORT_TRACE
4334	MNG_TRACE (pData, MNG_FN_FREE_ANI_FRAM, MNG_LC_START);
4335	#endif
4336
4337	MNG_FREEX (pData, pObject, sizeof (mng_ani_fram));
4338
4339	#ifdef MNG_SUPPORT_TRACE
4340	MNG_TRACE (pData, MNG_FN_FREE_ANI_FRAM, MNG_LC_END);
4341	#endif
4342
4343	return MNG_NOERROR;
4344	}
4345	#endif
4346
4347	/* ************************************************************************** */
4348
4349	mng_retcode mng_process_ani_fram (mng_datap pData,
4350	mng_objectp pObject)
4351	{
4352	mng_ani_framp pFRAM = (mng_ani_framp)pObject;
4353	mng_retcode iRetcode;
4354
4355	#ifdef MNG_SUPPORT_TRACE
4356	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_FRAM, MNG_LC_START);
4357	#endif
4358
4359	if (pData->iBreakpoint) /* previously broken ? */
4360	{
4361	iRetcode = mng_process_display_fram2 (pData);
4362	pData->iBreakpoint = 0; /* not again */
4363	}
4364	else
4365	{
4366	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4367	iRetcode = mng_process_display_fram (pData, pFRAM->iFramemode,
4368	pFRAM->iChangedelay, pFRAM->iDelay,
4369	pFRAM->iChangetimeout, pFRAM->iTimeout,
4370	pFRAM->iChangeclipping, pFRAM->iCliptype,
4371	pFRAM->iClipl, pFRAM->iClipr,
4372	pFRAM->iClipt, pFRAM->iClipb);
4373	#else
4374	pData->iTempFramemode = pFRAM->iFramemode;
4375	pData->iTempChangedelay = pFRAM->iChangedelay;
4376	pData->iTempDelay = pFRAM->iDelay;
4377	pData->iTempChangetimeout = pFRAM->iChangetimeout;
4378	pData->iTempTimeout = pFRAM->iTimeout;
4379	pData->iTempChangeclipping = pFRAM->iChangeclipping;
4380	pData->iTempCliptype = pFRAM->iCliptype;
4381	pData->iTempClipl = pFRAM->iClipl;
4382	pData->iTempClipr = pFRAM->iClipr;
4383	pData->iTempClipt = pFRAM->iClipt;
4384	pData->iTempClipb = pFRAM->iClipb;
4385
4386	iRetcode = mng_process_display_fram (pData);
4387	#endif
4388	}
4389
4390	#ifdef MNG_SUPPORT_TRACE
4391	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_FRAM, MNG_LC_END);
4392	#endif
4393
4394	return iRetcode;
4395	}
4396	#endif
4397
4398	/* ************************************************************************** */
4399
4400	#ifndef MNG_SKIPCHUNK_MOVE
4401	#ifndef MNG_OPTIMIZE_CHUNKREADER
4402	mng_retcode mng_create_ani_move (mng_datap pData,
4403	mng_uint16 iFirstid,
4404	mng_uint16 iLastid,
4405	mng_uint8 iType,
4406	mng_int32 iLocax,
4407	mng_int32 iLocay)
4408	#else
4409	mng_retcode mng_create_ani_move (mng_datap pData,
4410	mng_chunkp pChunk)
4411	#endif
4412	{
4413	mng_ani_movep pMOVE;
4414	mng_retcode iRetcode;
4415
4416	#ifdef MNG_SUPPORT_TRACE
4417	MNG_TRACE (pData, MNG_FN_CREATE_ANI_MOVE, MNG_LC_START);
4418	#endif
4419
4420	if (pData->bCacheplayback) /* caching playback info ? */
4421	{
4422	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4423	mng_ptr pTemp;
4424	iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
4425	mng_free_obj_general,
4426	mng_process_ani_move,
4427	&pTemp);
4428	if (iRetcode)
4429	return iRetcode;
4430	pMOVE = (mng_ani_movep)pTemp;
4431	#else
4432	MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
4433
4434	pMOVE->sHeader.fCleanup = mng_free_ani_move;
4435	pMOVE->sHeader.fProcess = mng_process_ani_move;
4436	#endif
4437
4438	mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
4439
4440	#ifndef MNG_OPTIMIZE_CHUNKREADER
4441	pMOVE->iFirstid = iFirstid;
4442	pMOVE->iLastid = iLastid;
4443	pMOVE->iType = iType;
4444	pMOVE->iLocax = iLocax;
4445	pMOVE->iLocay = iLocay;
4446	#else
4447	pMOVE->iFirstid = ((mng_movep)pChunk)->iFirstid;
4448	pMOVE->iLastid = ((mng_movep)pChunk)->iLastid;
4449	pMOVE->iType = ((mng_movep)pChunk)->iMovetype;
4450	pMOVE->iLocax = ((mng_movep)pChunk)->iMovex;
4451	pMOVE->iLocay = ((mng_movep)pChunk)->iMovey;
4452	#endif
4453	}
4454
4455	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4456	#ifndef MNG_OPTIMIZE_CHUNKREADER
4457	iRetcode = mng_process_display_move (pData, iFirstid, iLastid,
4458	iType, iLocax, iLocay);
4459	#else
4460	iRetcode = mng_process_display_move (pData,
4461	((mng_movep)pChunk)->iFirstid,
4462	((mng_movep)pChunk)->iLastid,
4463	((mng_movep)pChunk)->iMovetype,
4464	((mng_movep)pChunk)->iMovex,
4465	((mng_movep)pChunk)->iMovey);
4466	#endif
4467	#else
4468	#ifndef MNG_OPTIMIZE_CHUNKREADER
4469	pData->iMOVEfromid = iFirstid;
4470	pData->iMOVEtoid = iLastid;
4471	pData->iMOVEmovetype = iType;
4472	pData->iMOVEmovex = iLocax;
4473	pData->iMOVEmovey = iLocay;
4474	#else
4475	pData->iMOVEfromid = ((mng_movep)pChunk)->iFirstid;
4476	pData->iMOVEtoid = ((mng_movep)pChunk)->iLastid;
4477	pData->iMOVEmovetype = ((mng_movep)pChunk)->iMovetype;
4478	pData->iMOVEmovex = ((mng_movep)pChunk)->iMovex;
4479	pData->iMOVEmovey = ((mng_movep)pChunk)->iMovey;
4480	#endif
4481
4482	iRetcode = mng_process_display_move (pData);
4483	#endif
4484
4485	#ifdef MNG_SUPPORT_TRACE
4486	MNG_TRACE (pData, MNG_FN_CREATE_ANI_MOVE, MNG_LC_END);
4487	#endif
4488
4489	return iRetcode;
4490	}
4491
4492	/* ************************************************************************** */
4493
4494	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4495	mng_retcode mng_free_ani_move (mng_datap pData,
4496	mng_objectp pObject)
4497	{
4498	#ifdef MNG_SUPPORT_TRACE
4499	MNG_TRACE (pData, MNG_FN_FREE_ANI_MOVE, MNG_LC_START);
4500	#endif
4501
4502	MNG_FREEX (pData, pObject, sizeof (mng_ani_move));
4503
4504	#ifdef MNG_SUPPORT_TRACE
4505	MNG_TRACE (pData, MNG_FN_FREE_ANI_MOVE, MNG_LC_END);
4506	#endif
4507
4508	return MNG_NOERROR;
4509	}
4510	#endif
4511
4512	/* ************************************************************************** */
4513
4514	mng_retcode mng_process_ani_move (mng_datap pData,
4515	mng_objectp pObject)
4516	{
4517	mng_retcode iRetcode;
4518	mng_ani_movep pMOVE = (mng_ani_movep)pObject;
4519
4520	#ifdef MNG_SUPPORT_TRACE
4521	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MOVE, MNG_LC_START);
4522	#endif
4523	/* re-process the MOVE chunk */
4524	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4525	iRetcode = mng_process_display_move (pData, pMOVE->iFirstid, pMOVE->iLastid,
4526	pMOVE->iType, pMOVE->iLocax, pMOVE->iLocay);
4527	#else
4528	pData->iMOVEfromid = pMOVE->iFirstid;
4529	pData->iMOVEtoid = pMOVE->iLastid;
4530	pData->iMOVEmovetype = pMOVE->iType;
4531	pData->iMOVEmovex = pMOVE->iLocax;
4532	pData->iMOVEmovey = pMOVE->iLocay;
4533
4534	iRetcode = mng_process_display_move (pData);
4535	#endif
4536
4537	#ifdef MNG_SUPPORT_TRACE
4538	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MOVE, MNG_LC_END);
4539	#endif
4540
4541	return iRetcode;
4542	}
4543	#endif
4544
4545	/* ************************************************************************** */
4546
4547	#ifndef MNG_SKIPCHUNK_CLIP
4548	#ifndef MNG_OPTIMIZE_CHUNKREADER
4549	mng_retcode mng_create_ani_clip (mng_datap pData,
4550	mng_uint16 iFirstid,
4551	mng_uint16 iLastid,
4552	mng_uint8 iType,
4553	mng_int32 iClipl,
4554	mng_int32 iClipr,
4555	mng_int32 iClipt,
4556	mng_int32 iClipb)
4557	#else
4558	mng_retcode mng_create_ani_clip (mng_datap pData,
4559	mng_chunkp pChunk)
4560	#endif
4561	{
4562	mng_ani_clipp pCLIP;
4563	mng_retcode iRetcode;
4564
4565	#ifdef MNG_SUPPORT_TRACE
4566	MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLIP, MNG_LC_START);
4567	#endif
4568
4569	if (pData->bCacheplayback) /* caching playback info ? */
4570	{
4571	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4572	mng_ptr pTemp;
4573	iRetcode = create_obj_general (pData, sizeof (mng_ani_clip),
4574	mng_free_obj_general,
4575	mng_process_ani_clip,
4576	&pTemp);
4577	if (iRetcode)
4578	return iRetcode;
4579	pCLIP = (mng_ani_clipp)pTemp;
4580	#else
4581	MNG_ALLOC (pData, pCLIP, sizeof (mng_ani_clip));
4582
4583	pCLIP->sHeader.fCleanup = mng_free_ani_clip;
4584	pCLIP->sHeader.fProcess = mng_process_ani_clip;
4585	#endif
4586
4587	mng_add_ani_object (pData, (mng_object_headerp)pCLIP);
4588
4589	#ifndef MNG_OPTIMIZE_CHUNKREADER
4590	pCLIP->iFirstid = iFirstid;
4591	pCLIP->iLastid = iLastid;
4592	pCLIP->iType = iType;
4593	pCLIP->iClipl = iClipl;
4594	pCLIP->iClipr = iClipr;
4595	pCLIP->iClipt = iClipt;
4596	pCLIP->iClipb = iClipb;
4597	#else
4598	pCLIP->iFirstid = ((mng_clipp)pChunk)->iFirstid;
4599	pCLIP->iLastid = ((mng_clipp)pChunk)->iLastid;
4600	pCLIP->iType = ((mng_clipp)pChunk)->iCliptype;
4601	pCLIP->iClipl = ((mng_clipp)pChunk)->iClipl;
4602	pCLIP->iClipr = ((mng_clipp)pChunk)->iClipr;
4603	pCLIP->iClipt = ((mng_clipp)pChunk)->iClipt;
4604	pCLIP->iClipb = ((mng_clipp)pChunk)->iClipb;
4605	#endif
4606	}
4607
4608	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4609	#ifndef MNG_OPTIMIZE_CHUNKREADER
4610	iRetcode = mng_process_display_clip (pData, iFirstid, iLastid,
4611	iType, iClipl, iClipr,
4612	iClipt, iClipb);
4613	#else
4614	iRetcode = mng_process_display_clip (pData,
4615	((mng_clipp)pChunk)->iFirstid,
4616	((mng_clipp)pChunk)->iLastid,
4617	((mng_clipp)pChunk)->iCliptype,
4618	((mng_clipp)pChunk)->iClipl,
4619	((mng_clipp)pChunk)->iClipr,
4620	((mng_clipp)pChunk)->iClipt,
4621	((mng_clipp)pChunk)->iClipb);
4622	#endif
4623	#else
4624	#ifndef MNG_OPTIMIZE_CHUNKREADER
4625	pData->iCLIPfromid = iFirstid;
4626	pData->iCLIPtoid = iLastid;
4627	pData->iCLIPcliptype = iType;
4628	pData->iCLIPclipl = iClipl;
4629	pData->iCLIPclipr = iClipr;
4630	pData->iCLIPclipt = iClipt;
4631	pData->iCLIPclipb = iClipb;
4632	#else
4633	pData->iCLIPfromid = ((mng_clipp)pChunk)->iFirstid;
4634	pData->iCLIPtoid = ((mng_clipp)pChunk)->iLastid;
4635	pData->iCLIPcliptype = ((mng_clipp)pChunk)->iCliptype;
4636	pData->iCLIPclipl = ((mng_clipp)pChunk)->iClipl;
4637	pData->iCLIPclipr = ((mng_clipp)pChunk)->iClipr;
4638	pData->iCLIPclipt = ((mng_clipp)pChunk)->iClipt;
4639	pData->iCLIPclipb = ((mng_clipp)pChunk)->iClipb;
4640	#endif
4641
4642	iRetcode = mng_process_display_clip (pData);
4643	#endif
4644
4645	#ifdef MNG_SUPPORT_TRACE
4646	MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLIP, MNG_LC_END);
4647	#endif
4648
4649	return iRetcode;
4650	}
4651
4652	/* ************************************************************************** */
4653
4654	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4655	mng_retcode mng_free_ani_clip (mng_datap pData,
4656	mng_objectp pObject)
4657	{
4658	#ifdef MNG_SUPPORT_TRACE
4659	MNG_TRACE (pData, MNG_FN_FREE_ANI_CLIP, MNG_LC_START);
4660	#endif
4661
4662	MNG_FREEX (pData, pObject, sizeof (mng_ani_clip));
4663
4664	#ifdef MNG_SUPPORT_TRACE
4665	MNG_TRACE (pData, MNG_FN_FREE_ANI_CLIP, MNG_LC_END);
4666	#endif
4667
4668	return MNG_NOERROR;
4669	}
4670	#endif
4671
4672	/* ************************************************************************** */
4673
4674	mng_retcode mng_process_ani_clip (mng_datap pData,
4675	mng_objectp pObject)
4676	{
4677	mng_retcode iRetcode;
4678	mng_ani_clipp pCLIP = (mng_ani_clipp)pObject;
4679
4680	#ifdef MNG_SUPPORT_TRACE
4681	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLIP, MNG_LC_START);
4682	#endif
4683	/* re-process the CLIP chunk */
4684	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
4685	iRetcode = mng_process_display_clip (pData, pCLIP->iFirstid, pCLIP->iLastid,
4686	pCLIP->iType, pCLIP->iClipl, pCLIP->iClipr,
4687	pCLIP->iClipt, pCLIP->iClipb);
4688	#else
4689	pData->iCLIPfromid = pCLIP->iFirstid;
4690	pData->iCLIPtoid = pCLIP->iLastid;
4691	pData->iCLIPcliptype = pCLIP->iType;
4692	pData->iCLIPclipl = pCLIP->iClipl;
4693	pData->iCLIPclipr = pCLIP->iClipr;
4694	pData->iCLIPclipt = pCLIP->iClipt;
4695	pData->iCLIPclipb = pCLIP->iClipb;
4696
4697	iRetcode = mng_process_display_clip (pData);
4698	#endif
4699
4700	#ifdef MNG_SUPPORT_TRACE
4701	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLIP, MNG_LC_END);
4702	#endif
4703
4704	return iRetcode;
4705	}
4706	#endif
4707
4708	/* ************************************************************************** */
4709
4710	#ifndef MNG_SKIPCHUNK_SHOW
4711	#ifndef MNG_OPTIMIZE_CHUNKREADER
4712	mng_retcode mng_create_ani_show (mng_datap pData,
4713	mng_uint16 iFirstid,
4714	mng_uint16 iLastid,
4715	mng_uint8 iMode)
4716	#else
4717	mng_retcode mng_create_ani_show (mng_datap pData)
4718	#endif
4719	{
4720	mng_ani_showp pSHOW;
4721
4722	#ifdef MNG_SUPPORT_TRACE
4723	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SHOW, MNG_LC_START);
4724	#endif
4725
4726	if (pData->bCacheplayback) /* caching playback info ? */
4727	{
4728	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4729	mng_ptr pTemp;
4730	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
4731	mng_free_obj_general,
4732	mng_process_ani_show,
4733	&pTemp);
4734	if (iRetcode)
4735	return iRetcode;
4736	pSHOW = (mng_ani_showp)pTemp;
4737	#else
4738	MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
4739
4740	pSHOW->sHeader.fCleanup = mng_free_ani_show;
4741	pSHOW->sHeader.fProcess = mng_process_ani_show;
4742	#endif
4743
4744	mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
4745
4746	#ifndef MNG_OPTIMIZE_CHUNKREADER
4747	pSHOW->iFirstid = iFirstid;
4748	pSHOW->iLastid = iLastid;
4749	pSHOW->iMode = iMode;
4750	#else
4751	pSHOW->iFirstid = pData->iSHOWfromid;
4752	pSHOW->iLastid = pData->iSHOWtoid;
4753	pSHOW->iMode = pData->iSHOWmode;
4754	#endif
4755	}
4756
4757	#ifdef MNG_SUPPORT_TRACE
4758	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SHOW, MNG_LC_END);
4759	#endif
4760
4761	return MNG_NOERROR;
4762	}
4763
4764	/* ************************************************************************** */
4765
4766	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4767	mng_retcode mng_free_ani_show (mng_datap pData,
4768	mng_objectp pObject)
4769	{
4770	#ifdef MNG_SUPPORT_TRACE
4771	MNG_TRACE (pData, MNG_FN_FREE_ANI_SHOW, MNG_LC_START);
4772	#endif
4773
4774	MNG_FREEX (pData, pObject, sizeof (mng_ani_show));
4775
4776	#ifdef MNG_SUPPORT_TRACE
4777	MNG_TRACE (pData, MNG_FN_FREE_ANI_SHOW, MNG_LC_END);
4778	#endif
4779
4780	return MNG_NOERROR;
4781	}
4782	#endif
4783
4784	/* ************************************************************************** */
4785
4786	mng_retcode mng_process_ani_show (mng_datap pData,
4787	mng_objectp pObject)
4788	{
4789	mng_retcode iRetcode;
4790	mng_ani_showp pSHOW = (mng_ani_showp)pObject;
4791
4792	#ifdef MNG_SUPPORT_TRACE
4793	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SHOW, MNG_LC_START);
4794	#endif
4795
4796	if (pData->iBreakpoint) /* returning from breakpoint ? */
4797	{
4798	iRetcode = mng_process_display_show (pData);
4799	}
4800	else
4801	{ /* "re-run" SHOW chunk */
4802	pData->iSHOWmode = pSHOW->iMode;
4803	pData->iSHOWfromid = pSHOW->iFirstid;
4804	pData->iSHOWtoid = pSHOW->iLastid;
4805
4806	iRetcode = mng_process_display_show (pData);
4807	}
4808
4809	#ifdef MNG_SUPPORT_TRACE
4810	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SHOW, MNG_LC_END);
4811	#endif
4812
4813	return iRetcode;
4814	}
4815	#endif
4816
4817	/* ************************************************************************** */
4818
4819	#ifndef MNG_SKIPCHUNK_TERM
4820	#ifndef MNG_OPTIMIZE_CHUNKREADER
4821	mng_retcode mng_create_ani_term (mng_datap pData,
4822	mng_uint8 iTermaction,
4823	mng_uint8 iIteraction,
4824	mng_uint32 iDelay,
4825	mng_uint32 iItermax)
4826	#else
4827	mng_retcode mng_create_ani_term (mng_datap pData,
4828	mng_chunkp pChunk)
4829	#endif
4830	{
4831	mng_ani_termp pTERM;
4832
4833	#ifdef MNG_SUPPORT_TRACE
4834	MNG_TRACE (pData, MNG_FN_CREATE_ANI_TERM, MNG_LC_START);
4835	#endif
4836
4837	if (pData->bCacheplayback) /* caching playback info ? */
4838	{
4839	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4840	mng_ptr pTemp;
4841	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_term),
4842	mng_free_obj_general,
4843	mng_process_ani_term,
4844	&pTemp);
4845	if (iRetcode)
4846	return iRetcode;
4847	pTERM = (mng_ani_termp)pTemp;
4848	#else
4849	MNG_ALLOC (pData, pTERM, sizeof (mng_ani_term));
4850
4851	pTERM->sHeader.fCleanup = mng_free_ani_term;
4852	pTERM->sHeader.fProcess = mng_process_ani_term;
4853	#endif
4854
4855	mng_add_ani_object (pData, (mng_object_headerp)pTERM);
4856
4857	#ifndef MNG_OPTIMIZE_CHUNKREADER
4858	pTERM->iTermaction = iTermaction;
4859	pTERM->iIteraction = iIteraction;
4860	pTERM->iDelay = iDelay;
4861	pTERM->iItermax = iItermax;
4862	#else
4863	pTERM->iTermaction = ((mng_termp)pChunk)->iTermaction;
4864	pTERM->iIteraction = ((mng_termp)pChunk)->iIteraction;
4865	pTERM->iDelay = ((mng_termp)pChunk)->iDelay;
4866	pTERM->iItermax = ((mng_termp)pChunk)->iItermax;
4867	#endif
4868	}
4869
4870	#ifdef MNG_SUPPORT_TRACE
4871	MNG_TRACE (pData, MNG_FN_CREATE_ANI_TERM, MNG_LC_END);
4872	#endif
4873
4874	return MNG_NOERROR;
4875	}
4876
4877	/* ************************************************************************** */
4878
4879	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4880	mng_retcode mng_free_ani_term (mng_datap pData,
4881	mng_objectp pObject)
4882	{
4883	#ifdef MNG_SUPPORT_TRACE
4884	MNG_TRACE (pData, MNG_FN_FREE_ANI_TERM, MNG_LC_START);
4885	#endif
4886
4887	MNG_FREEX (pData, pObject, sizeof (mng_ani_term));
4888
4889	#ifdef MNG_SUPPORT_TRACE
4890	MNG_TRACE (pData, MNG_FN_FREE_ANI_TERM, MNG_LC_END);
4891	#endif
4892
4893	return MNG_NOERROR;
4894	}
4895	#endif
4896
4897	/* ************************************************************************** */
4898
4899	mng_retcode mng_process_ani_term (mng_datap pData,
4900	mng_objectp pObject)
4901	{
4902	#ifdef MNG_SUPPORT_TRACE
4903	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TERM, MNG_LC_START);
4904	#endif
4905
4906	/* dummy: no action required! */
4907
4908	#ifdef MNG_SUPPORT_TRACE
4909	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TERM, MNG_LC_END);
4910	#endif
4911
4912	return MNG_NOERROR;
4913	}
4914	#endif
4915
4916	/* ************************************************************************** */
4917
4918	#ifndef MNG_SKIPCHUNK_SAVE
4919	mng_retcode mng_create_ani_save (mng_datap pData)
4920	{
4921	mng_ani_savep pSAVE;
4922
4923	#ifdef MNG_SUPPORT_TRACE
4924	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SAVE, MNG_LC_START);
4925	#endif
4926
4927	if (pData->bCacheplayback) /* caching playback info ? */
4928	{
4929	#ifdef MNG_OPTIMIZE_OBJCLEANUP
4930	mng_ptr pTemp;
4931	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_save),
4932	mng_free_obj_general,
4933	mng_process_ani_save,
4934	&pTemp);
4935	if (iRetcode)
4936	return iRetcode;
4937	pSAVE = (mng_ani_savep)pTemp;
4938	#else
4939	MNG_ALLOC (pData, pSAVE, sizeof (mng_ani_save));
4940
4941	pSAVE->sHeader.fCleanup = mng_free_ani_save;
4942	pSAVE->sHeader.fProcess = mng_process_ani_save;
4943	#endif
4944
4945	mng_add_ani_object (pData, (mng_object_headerp)pSAVE);
4946	}
4947
4948	#ifdef MNG_SUPPORT_TRACE
4949	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SAVE, MNG_LC_END);
4950	#endif
4951
4952	return MNG_NOERROR;
4953	}
4954
4955	/* ************************************************************************** */
4956
4957	#ifndef MNG_OPTIMIZE_OBJCLEANUP
4958	mng_retcode mng_free_ani_save (mng_datap pData,
4959	mng_objectp pObject)
4960	{
4961	#ifdef MNG_SUPPORT_TRACE
4962	MNG_TRACE (pData, MNG_FN_FREE_ANI_SAVE, MNG_LC_START);
4963	#endif
4964
4965	MNG_FREEX (pData, pObject, sizeof (mng_ani_save));
4966
4967	#ifdef MNG_SUPPORT_TRACE
4968	MNG_TRACE (pData, MNG_FN_FREE_ANI_SAVE, MNG_LC_END);
4969	#endif
4970
4971	return MNG_NOERROR;
4972	}
4973	#endif
4974
4975	/* ************************************************************************** */
4976
4977	mng_retcode mng_process_ani_save (mng_datap pData,
4978	mng_objectp pObject)
4979	{
4980	mng_retcode iRetcode;
4981
4982	#ifdef MNG_SUPPORT_TRACE
4983	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SAVE, MNG_LC_START);
4984	#endif
4985
4986	iRetcode = mng_process_display_save (pData);
4987
4988	if (iRetcode) /* on error bail out */
4989	return iRetcode;
4990
4991	#ifdef MNG_SUPPORT_TRACE
4992	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SAVE, MNG_LC_END);
4993	#endif
4994
4995	return MNG_NOERROR;
4996	}
4997	#endif
4998
4999	/* ************************************************************************** */
5000	/* ************************************************************************** */
5001
5002	#ifndef MNG_SKIPCHUNK_SEEK
5003	#ifndef MNG_OPTIMIZE_CHUNKREADER
5004	mng_retcode mng_create_ani_seek (mng_datap pData,
5005	mng_uint32 iSegmentnamesize,
5006	mng_pchar zSegmentname)
5007	#else
5008	mng_retcode mng_create_ani_seek (mng_datap pData,
5009	mng_chunkp pChunk)
5010	#endif
5011	{
5012	mng_ani_seekp pSEEK;
5013
5014	#ifdef MNG_SUPPORT_TRACE
5015	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SEEK, MNG_LC_START);
5016	#endif
5017
5018	if (pData->bCacheplayback) /* caching playback info ? */
5019	{
5020	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5021	mng_ptr pTemp;
5022	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_seek),
5023	mng_free_ani_seek,
5024	mng_process_ani_seek,
5025	&pTemp);
5026	if (iRetcode)
5027	return iRetcode;
5028	pSEEK = (mng_ani_seekp)pTemp;
5029	#else
5030	MNG_ALLOC (pData, pSEEK, sizeof (mng_ani_seek));
5031
5032	pSEEK->sHeader.fCleanup = mng_free_ani_seek;
5033	pSEEK->sHeader.fProcess = mng_process_ani_seek;
5034	#endif
5035
5036	mng_add_ani_object (pData, (mng_object_headerp)pSEEK);
5037
5038	pData->pLastseek = (mng_objectp)pSEEK;
5039
5040	#ifndef MNG_OPTIMIZE_CHUNKREADER
5041	pSEEK->iSegmentnamesize = iSegmentnamesize;
5042	if (iSegmentnamesize)
5043	{
5044	MNG_ALLOC (pData, pSEEK->zSegmentname, iSegmentnamesize + 1);
5045	MNG_COPY (pSEEK->zSegmentname, zSegmentname, iSegmentnamesize);
5046	}
5047	#else
5048	pSEEK->iSegmentnamesize = ((mng_seekp)pChunk)->iNamesize;
5049	if (pSEEK->iSegmentnamesize)
5050	{
5051	MNG_ALLOC (pData, pSEEK->zSegmentname, pSEEK->iSegmentnamesize + 1);
5052	MNG_COPY (pSEEK->zSegmentname, ((mng_seekp)pChunk)->zName, pSEEK->iSegmentnamesize);
5053	}
5054	#endif
5055	}
5056
5057	#ifdef MNG_SUPPORT_TRACE
5058	MNG_TRACE (pData, MNG_FN_CREATE_ANI_SEEK, MNG_LC_END);
5059	#endif
5060
5061	return MNG_NOERROR;
5062	}
5063
5064	/* ************************************************************************** */
5065
5066	mng_retcode mng_free_ani_seek (mng_datap pData,
5067	mng_objectp pObject)
5068	{
5069	mng_ani_seekp pSEEK = (mng_ani_seekp)pObject;
5070
5071	#ifdef MNG_SUPPORT_TRACE
5072	MNG_TRACE (pData, MNG_FN_FREE_ANI_SEEK, MNG_LC_START);
5073	#endif
5074
5075	if (pSEEK->iSegmentnamesize)
5076	MNG_FREEX (pData, pSEEK->zSegmentname, pSEEK->iSegmentnamesize + 1);
5077
5078	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5079	MNG_FREEX (pData, pObject, sizeof (mng_ani_seek));
5080	#endif
5081
5082	#ifdef MNG_SUPPORT_TRACE
5083	MNG_TRACE (pData, MNG_FN_FREE_ANI_SEEK, MNG_LC_END);
5084	#endif
5085
5086	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5087	return MNG_NOERROR;
5088	#else
5089	return mng_free_obj_general(pData, pObject);
5090	#endif
5091	}
5092
5093	/* ************************************************************************** */
5094
5095	mng_retcode mng_process_ani_seek (mng_datap pData,
5096	mng_objectp pObject)
5097	{
5098	mng_ani_seekp pSEEK = (mng_ani_seekp)pObject;
5099	mng_retcode iRetcode;
5100
5101	#ifdef MNG_SUPPORT_TRACE
5102	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SEEK, MNG_LC_START);
5103	#endif
5104
5105	#ifdef MNG_SUPPORT_DYNAMICMNG
5106	if (!pData->bStopafterseek) /* can we really process this one ? */
5107	#endif
5108	{
5109	pData->pLastseek = pObject;
5110
5111	if (pData->fProcessseek) /* inform the app ? */
5112	{
5113	mng_bool bOke;
5114	mng_pchar zName;
5115
5116	MNG_ALLOC (pData, zName, pSEEK->iSegmentnamesize + 1);
5117
5118	if (pSEEK->iSegmentnamesize)
5119	MNG_COPY (zName, pSEEK->zSegmentname, pSEEK->iSegmentnamesize);
5120
5121	bOke = pData->fProcessseek ((mng_handle)pData, zName);
5122
5123	MNG_FREEX (pData, zName, pSEEK->iSegmentnamesize + 1);
5124
5125	if (!bOke)
5126	MNG_ERROR (pData, MNG_APPMISCERROR);
5127	}
5128	}
5129
5130	iRetcode = mng_process_display_seek (pData);
5131
5132	if (iRetcode) /* on error bail out */
5133	return iRetcode;
5134
5135	#ifdef MNG_SUPPORT_TRACE
5136	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SEEK, MNG_LC_END);
5137	#endif
5138
5139	return MNG_NOERROR;
5140	}
5141	#endif
5142
5143	/* ************************************************************************** */
5144
5145	#ifndef MNG_NO_DELTA_PNG
5146	#ifndef MNG_OPTIMIZE_CHUNKREADER
5147	mng_retcode mng_create_ani_dhdr (mng_datap pData,
5148	mng_uint16 iObjectid,
5149	mng_uint8 iImagetype,
5150	mng_uint8 iDeltatype,
5151	mng_uint32 iBlockwidth,
5152	mng_uint32 iBlockheight,
5153	mng_uint32 iBlockx,
5154	mng_uint32 iBlocky)
5155	#else
5156	mng_retcode mng_create_ani_dhdr (mng_datap pData,
5157	mng_chunkp pChunk)
5158	#endif
5159	{
5160	mng_ani_dhdrp pDHDR;
5161	mng_retcode iRetcode;
5162
5163	#ifdef MNG_SUPPORT_TRACE
5164	MNG_TRACE (pData, MNG_FN_CREATE_ANI_DHDR, MNG_LC_START);
5165	#endif
5166
5167	if (pData->bCacheplayback) /* caching playback info ? */
5168	{
5169	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5170	mng_ptr pTemp;
5171	iRetcode = create_obj_general (pData, sizeof (mng_ani_dhdr),
5172	mng_free_obj_general,
5173	mng_process_ani_dhdr,
5174	&pTemp);
5175	if (iRetcode)
5176	return iRetcode;
5177	pDHDR = (mng_ani_dhdrp)pTemp;
5178	#else
5179	MNG_ALLOC (pData, pDHDR, sizeof (mng_ani_dhdr));
5180
5181	pDHDR->sHeader.fCleanup = mng_free_ani_dhdr;
5182	pDHDR->sHeader.fProcess = mng_process_ani_dhdr;
5183	#endif
5184
5185	mng_add_ani_object (pData, (mng_object_headerp)pDHDR);
5186
5187	#ifndef MNG_OPTIMIZE_CHUNKREADER
5188	pDHDR->iObjectid = iObjectid;
5189	pDHDR->iImagetype = iImagetype;
5190	pDHDR->iDeltatype = iDeltatype;
5191	pDHDR->iBlockwidth = iBlockwidth;
5192	pDHDR->iBlockheight = iBlockheight;
5193	pDHDR->iBlockx = iBlockx;
5194	pDHDR->iBlocky = iBlocky;
5195	#else
5196	pDHDR->iObjectid = ((mng_dhdrp)pChunk)->iObjectid;
5197	pDHDR->iImagetype = ((mng_dhdrp)pChunk)->iImagetype;
5198	pDHDR->iDeltatype = ((mng_dhdrp)pChunk)->iDeltatype;
5199	pDHDR->iBlockwidth = ((mng_dhdrp)pChunk)->iBlockwidth;
5200	pDHDR->iBlockheight = ((mng_dhdrp)pChunk)->iBlockheight;
5201	pDHDR->iBlockx = ((mng_dhdrp)pChunk)->iBlockx;
5202	pDHDR->iBlocky = ((mng_dhdrp)pChunk)->iBlocky;
5203	#endif
5204	}
5205
5206	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5207	#ifndef MNG_OPTIMIZE_CHUNKREADER
5208	iRetcode = mng_process_display_dhdr (pData, iObjectid,
5209	iImagetype, iDeltatype,
5210	iBlockwidth, iBlockheight,
5211	iBlockx, iBlocky);
5212	#else
5213	iRetcode = mng_process_display_dhdr (pData,
5214	((mng_dhdrp)pChunk)->iObjectid,
5215	((mng_dhdrp)pChunk)->iImagetype,
5216	((mng_dhdrp)pChunk)->iDeltatype,
5217	((mng_dhdrp)pChunk)->iBlockwidth,
5218	((mng_dhdrp)pChunk)->iBlockheight,
5219	((mng_dhdrp)pChunk)->iBlockx,
5220	((mng_dhdrp)pChunk)->iBlocky);
5221	#endif
5222	#else
5223	#ifndef MNG_OPTIMIZE_CHUNKREADER
5224	pData->iDHDRobjectid = iObjectid;
5225	pData->iDHDRimagetype = iImagetype;
5226	pData->iDHDRdeltatype = iDeltatype;
5227	pData->iDHDRblockwidth = iBlockwidth;
5228	pData->iDHDRblockheight = iBlockheight;
5229	pData->iDHDRblockx = iBlockx;
5230	pData->iDHDRblocky = iBlocky;
5231	#else
5232	pData->iDHDRobjectid = ((mng_dhdrp)pChunk)->iObjectid;
5233	pData->iDHDRimagetype = ((mng_dhdrp)pChunk)->iImagetype;
5234	pData->iDHDRdeltatype = ((mng_dhdrp)pChunk)->iDeltatype;
5235	pData->iDHDRblockwidth = ((mng_dhdrp)pChunk)->iBlockwidth;
5236	pData->iDHDRblockheight = ((mng_dhdrp)pChunk)->iBlockheight;
5237	pData->iDHDRblockx = ((mng_dhdrp)pChunk)->iBlockx;
5238	pData->iDHDRblocky = ((mng_dhdrp)pChunk)->iBlocky;
5239	#endif
5240
5241	iRetcode = mng_process_display_dhdr (pData);
5242	#endif
5243
5244	#ifdef MNG_SUPPORT_TRACE
5245	MNG_TRACE (pData, MNG_FN_CREATE_ANI_DHDR, MNG_LC_END);
5246	#endif
5247
5248	return iRetcode;
5249	}
5250
5251	/* ************************************************************************** */
5252
5253	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5254	mng_retcode mng_free_ani_dhdr (mng_datap pData,
5255	mng_objectp pObject)
5256	{
5257	#ifdef MNG_SUPPORT_TRACE
5258	MNG_TRACE (pData, MNG_FN_FREE_ANI_DHDR, MNG_LC_START);
5259	#endif
5260
5261	MNG_FREEX (pData, pObject, sizeof (mng_ani_dhdr));
5262
5263	#ifdef MNG_SUPPORT_TRACE
5264	MNG_TRACE (pData, MNG_FN_FREE_ANI_DHDR, MNG_LC_END);
5265	#endif
5266
5267	return MNG_NOERROR;
5268	}
5269	#endif
5270
5271	/* ************************************************************************** */
5272
5273	mng_retcode mng_process_ani_dhdr (mng_datap pData,
5274	mng_objectp pObject)
5275	{
5276	mng_ani_dhdrp pDHDR = (mng_ani_dhdrp)pObject;
5277	mng_retcode iRetcode;
5278
5279	#ifdef MNG_SUPPORT_TRACE
5280	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DHDR, MNG_LC_START);
5281	#endif
5282
5283	pData->bHasDHDR = MNG_TRUE; /* let everyone know we're inside a DHDR */
5284
5285	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5286	iRetcode = mng_process_display_dhdr (pData, pDHDR->iObjectid,
5287	pDHDR->iImagetype, pDHDR->iDeltatype,
5288	pDHDR->iBlockwidth, pDHDR->iBlockheight,
5289	pDHDR->iBlockx, pDHDR->iBlocky);
5290	#else
5291	pData->iDHDRobjectid = pDHDR->iObjectid;
5292	pData->iDHDRimagetype = pDHDR->iImagetype;
5293	pData->iDHDRdeltatype = pDHDR->iDeltatype;
5294	pData->iDHDRblockwidth = pDHDR->iBlockwidth;
5295	pData->iDHDRblockheight = pDHDR->iBlockheight;
5296	pData->iDHDRblockx = pDHDR->iBlockx;
5297	pData->iDHDRblocky = pDHDR->iBlocky;
5298
5299	iRetcode = mng_process_display_dhdr (pData);
5300	#endif
5301
5302	#ifdef MNG_SUPPORT_TRACE
5303	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DHDR, MNG_LC_END);
5304	#endif
5305
5306	return iRetcode;
5307	}
5308	#endif
5309
5310	/* ************************************************************************** */
5311
5312	#ifndef MNG_NO_DELTA_PNG
5313	#ifndef MNG_OPTIMIZE_CHUNKREADER
5314	mng_retcode mng_create_ani_prom (mng_datap pData,
5315	mng_uint8 iBitdepth,
5316	mng_uint8 iColortype,
5317	mng_uint8 iFilltype)
5318	#else
5319	mng_retcode mng_create_ani_prom (mng_datap pData,
5320	mng_chunkp pChunk)
5321	#endif
5322	{
5323	mng_ani_promp pPROM=NULL;
5324	mng_retcode iRetcode;
5325
5326	#ifdef MNG_SUPPORT_TRACE
5327	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PROM, MNG_LC_START);
5328	#endif
5329
5330	if (pData->bCacheplayback) /* caching playback info ? */
5331	{
5332	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5333	mng_ptr pTemp;
5334	iRetcode = create_obj_general (pData, sizeof (mng_ani_prom),
5335	mng_free_obj_general,
5336	mng_process_ani_prom,
5337	&pTemp);
5338	if (iRetcode)
5339	return iRetcode;
5340	pPROM = (mng_ani_promp)pTemp;
5341	#else
5342	MNG_ALLOC (pData, pPROM, sizeof (mng_ani_prom));
5343
5344	pPROM->sHeader.fCleanup = mng_free_ani_prom;
5345	pPROM->sHeader.fProcess = mng_process_ani_prom;
5346	#endif
5347
5348	mng_add_ani_object (pData, (mng_object_headerp)pPROM);
5349
5350	#ifndef MNG_OPTIMIZE_CHUNKREADER
5351	pPROM->iBitdepth = iBitdepth;
5352	pPROM->iColortype = iColortype;
5353	pPROM->iFilltype = iFilltype;
5354	#else
5355	pPROM->iBitdepth = ((mng_promp)pChunk)->iSampledepth;
5356	pPROM->iColortype = ((mng_promp)pChunk)->iColortype;
5357	pPROM->iFilltype = ((mng_promp)pChunk)->iFilltype;
5358	#endif
5359	}
5360
5361	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5362	#ifndef MNG_OPTIMIZE_CHUNKREADER
5363	iRetcode = mng_process_display_prom (pData, iBitdepth,
5364	iColortype, iFilltype);
5365	#else
5366	iRetcode = mng_process_display_prom (pData,
5367	((mng_promp)pChunk)->iSampledepth,
5368	((mng_promp)pChunk)->iColortype,
5369	((mng_promp)pChunk)->iFilltype);
5370	#endif
5371	#else
5372	#ifndef MNG_OPTIMIZE_CHUNKREADER
5373	pData->iPROMbitdepth = iBitdepth;
5374	pData->iPROMcolortype = iColortype;
5375	pData->iPROMfilltype = iFilltype;
5376	#else
5377	pData->iPROMbitdepth = ((mng_promp)pChunk)->iSampledepth;
5378	pData->iPROMcolortype = ((mng_promp)pChunk)->iColortype;
5379	pData->iPROMfilltype = ((mng_promp)pChunk)->iFilltype;
5380	#endif
5381
5382	iRetcode = mng_process_display_prom (pData);
5383	#endif
5384
5385	#ifdef MNG_SUPPORT_TRACE
5386	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PROM, MNG_LC_END);
5387	#endif
5388
5389	return iRetcode;
5390	}
5391
5392	/* ************************************************************************** */
5393
5394	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5395	mng_retcode mng_free_ani_prom (mng_datap pData,
5396	mng_objectp pObject)
5397	{
5398	#ifdef MNG_SUPPORT_TRACE
5399	MNG_TRACE (pData, MNG_FN_FREE_ANI_PROM, MNG_LC_START);
5400	#endif
5401
5402	MNG_FREEX (pData, pObject, sizeof (mng_ani_prom));
5403
5404	#ifdef MNG_SUPPORT_TRACE
5405	MNG_TRACE (pData, MNG_FN_FREE_ANI_PROM, MNG_LC_END);
5406	#endif
5407
5408	return MNG_NOERROR;
5409	}
5410	#endif
5411
5412	/* ************************************************************************** */
5413
5414	mng_retcode mng_process_ani_prom (mng_datap pData,
5415	mng_objectp pObject)
5416	{
5417	mng_ani_promp pPROM = (mng_ani_promp)pObject;
5418	mng_retcode iRetcode;
5419
5420	#ifdef MNG_SUPPORT_TRACE
5421	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PROM, MNG_LC_START);
5422	#endif
5423
5424	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5425	iRetcode = mng_process_display_prom (pData, pPROM->iBitdepth,
5426	pPROM->iColortype, pPROM->iFilltype);
5427	#else
5428	pData->iPROMbitdepth = pPROM->iBitdepth;
5429	pData->iPROMcolortype = pPROM->iColortype;
5430	pData->iPROMfilltype = pPROM->iFilltype;
5431
5432	iRetcode = mng_process_display_prom (pData);
5433	#endif
5434
5435	#ifdef MNG_SUPPORT_TRACE
5436	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PROM, MNG_LC_END);
5437	#endif
5438
5439	return iRetcode;
5440	}
5441	#endif
5442
5443	/* ************************************************************************** */
5444
5445	#ifndef MNG_NO_DELTA_PNG
5446	mng_retcode mng_create_ani_ipng (mng_datap pData)
5447	{
5448	mng_ani_ipngp pIPNG;
5449
5450	#ifdef MNG_SUPPORT_TRACE
5451	MNG_TRACE (pData, MNG_FN_CREATE_ANI_IPNG, MNG_LC_START);
5452	#endif
5453
5454	if (pData->bCacheplayback) /* caching playback info ? */
5455	{
5456	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5457	mng_ptr pTemp;
5458	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_ipng),
5459	mng_free_obj_general,
5460	mng_process_ani_ipng,
5461	&pTemp);
5462	if (iRetcode)
5463	return iRetcode;
5464	pIPNG = (mng_ani_ipngp)pTemp;
5465	#else
5466	MNG_ALLOC (pData, pIPNG, sizeof (mng_ani_ipng));
5467
5468	pIPNG->sHeader.fCleanup = mng_free_ani_ipng;
5469	pIPNG->sHeader.fProcess = mng_process_ani_ipng;
5470	#endif
5471
5472	mng_add_ani_object (pData, (mng_object_headerp)pIPNG);
5473	}
5474
5475	#ifdef MNG_SUPPORT_TRACE
5476	MNG_TRACE (pData, MNG_FN_CREATE_ANI_IPNG, MNG_LC_END);
5477	#endif
5478
5479	return MNG_NOERROR;
5480	}
5481
5482	/* ************************************************************************** */
5483
5484	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5485	mng_retcode mng_free_ani_ipng (mng_datap pData,
5486	mng_objectp pObject)
5487	{
5488	#ifdef MNG_SUPPORT_TRACE
5489	MNG_TRACE (pData, MNG_FN_FREE_ANI_IPNG, MNG_LC_START);
5490	#endif
5491
5492	MNG_FREEX (pData, pObject, sizeof (mng_ani_ipng));
5493
5494	#ifdef MNG_SUPPORT_TRACE
5495	MNG_TRACE (pData, MNG_FN_FREE_ANI_IPNG, MNG_LC_END);
5496	#endif
5497
5498	return MNG_NOERROR;
5499	}
5500	#endif
5501
5502	/* ************************************************************************** */
5503
5504	mng_retcode mng_process_ani_ipng (mng_datap pData,
5505	mng_objectp pObject)
5506	{
5507	mng_retcode iRetcode;
5508
5509	#ifdef MNG_SUPPORT_TRACE
5510	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IPNG, MNG_LC_START);
5511	#endif
5512
5513	iRetcode = mng_process_display_ipng (pData);
5514
5515	if (iRetcode) /* on error bail out */
5516	return iRetcode;
5517
5518	#ifdef MNG_SUPPORT_TRACE
5519	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IPNG, MNG_LC_END);
5520	#endif
5521
5522	return MNG_NOERROR;
5523	}
5524	#endif
5525
5526	/* ************************************************************************** */
5527
5528	#ifndef MNG_NO_DELTA_PNG
5529	#ifdef MNG_INCLUDE_JNG
5530	mng_retcode mng_create_ani_ijng (mng_datap pData)
5531	{
5532	mng_ani_ijngp pIJNG;
5533
5534	#ifdef MNG_SUPPORT_TRACE
5535	MNG_TRACE (pData, MNG_FN_CREATE_ANI_IJNG, MNG_LC_START);
5536	#endif
5537
5538	if (pData->bCacheplayback) /* caching playback info ? */
5539	{
5540	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5541	mng_ptr pTemp;
5542	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_ijng),
5543	mng_free_obj_general,
5544	mng_process_ani_ijng,
5545	&pTemp);
5546	if (iRetcode)
5547	return iRetcode;
5548	pIJNG = (mng_ani_ijngp)pTemp;
5549	#else
5550	MNG_ALLOC (pData, pIJNG, sizeof (mng_ani_ijng));
5551
5552	pIJNG->sHeader.fCleanup = mng_free_ani_ijng;
5553	pIJNG->sHeader.fProcess = mng_process_ani_ijng;
5554	#endif
5555
5556	mng_add_ani_object (pData, (mng_object_headerp)pIJNG);
5557	}
5558
5559	#ifdef MNG_SUPPORT_TRACE
5560	MNG_TRACE (pData, MNG_FN_CREATE_ANI_IJNG, MNG_LC_END);
5561	#endif
5562
5563	return MNG_NOERROR;
5564	}
5565
5566	/* ************************************************************************** */
5567
5568	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5569	mng_retcode mng_free_ani_ijng (mng_datap pData,
5570	mng_objectp pObject)
5571	{
5572	#ifdef MNG_SUPPORT_TRACE
5573	MNG_TRACE (pData, MNG_FN_FREE_ANI_IJNG, MNG_LC_START);
5574	#endif
5575
5576	MNG_FREEX (pData, pObject, sizeof (mng_ani_ijng));
5577
5578	#ifdef MNG_SUPPORT_TRACE
5579	MNG_TRACE (pData, MNG_FN_FREE_ANI_IJNG, MNG_LC_END);
5580	#endif
5581
5582	return MNG_NOERROR;
5583	}
5584	#endif
5585
5586	/* ************************************************************************** */
5587
5588	mng_retcode mng_process_ani_ijng (mng_datap pData,
5589	mng_objectp pObject)
5590	{
5591	mng_retcode iRetcode;
5592
5593	#ifdef MNG_SUPPORT_TRACE
5594	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IJNG, MNG_LC_START);
5595	#endif
5596
5597	iRetcode = mng_process_display_ijng (pData);
5598
5599	if (iRetcode) /* on error bail out */
5600	return iRetcode;
5601
5602	#ifdef MNG_SUPPORT_TRACE
5603	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IJNG, MNG_LC_END);
5604	#endif
5605
5606	return MNG_NOERROR;
5607	}
5608	#endif
5609	#endif
5610
5611	/* ************************************************************************** */
5612
5613	#ifndef MNG_NO_DELTA_PNG
5614	mng_retcode mng_create_ani_pplt (mng_datap pData,
5615	mng_uint8 iType,
5616	mng_uint32 iCount,
5617	mng_palette8ep paIndexentries,
5618	mng_uint8p paAlphaentries,
5619	mng_uint8p paUsedentries)
5620	{
5621	mng_ani_ppltp pPPLT;
5622	mng_retcode iRetcode;
5623
5624	#ifdef MNG_SUPPORT_TRACE
5625	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PPLT, MNG_LC_START);
5626	#endif
5627
5628	if (pData->bCacheplayback) /* caching playback info ? */
5629	{
5630	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5631	mng_ptr pTemp;
5632	iRetcode = create_obj_general (pData, sizeof (mng_ani_pplt),
5633	mng_free_obj_general,
5634	mng_process_ani_pplt,
5635	&pTemp);
5636	if (iRetcode)
5637	return iRetcode;
5638	pPPLT = (mng_ani_ppltp)pTemp;
5639	#else
5640	MNG_ALLOC (pData, pPPLT, sizeof (mng_ani_pplt));
5641
5642	pPPLT->sHeader.fCleanup = mng_free_ani_pplt;
5643	pPPLT->sHeader.fProcess = mng_process_ani_pplt;
5644	#endif
5645
5646	pPPLT->iType = iType;
5647	pPPLT->iCount = iCount;
5648
5649	MNG_COPY (pPPLT->aIndexentries, paIndexentries, sizeof (pPPLT->aIndexentries));
5650	MNG_COPY (pPPLT->aAlphaentries, paAlphaentries, sizeof (pPPLT->aAlphaentries));
5651	MNG_COPY (pPPLT->aUsedentries, paUsedentries, sizeof (pPPLT->aUsedentries ));
5652
5653	mng_add_ani_object (pData, (mng_object_headerp)pPPLT);
5654	}
5655
5656	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5657	iRetcode = mng_process_display_pplt (pData, iType, iCount,
5658	paIndexentries, paAlphaentries, paUsedentries);
5659	#else
5660	pData->iPPLTtype = iType;
5661	pData->iPPLTcount = iCount;
5662	pData->paPPLTindexentries = paIndexentries;
5663	pData->paPPLTalphaentries = paAlphaentries;
5664	pData->paPPLTusedentries = paUsedentries;
5665
5666	iRetcode = mng_process_display_pplt (pData);
5667	#endif
5668
5669	#ifdef MNG_SUPPORT_TRACE
5670	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PPLT, MNG_LC_END);
5671	#endif
5672
5673	return iRetcode;
5674	}
5675
5676	/* ************************************************************************** */
5677
5678	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5679	mng_retcode mng_free_ani_pplt (mng_datap pData,
5680	mng_objectp pObject)
5681	{
5682	#ifdef MNG_SUPPORT_TRACE
5683	MNG_TRACE (pData, MNG_FN_FREE_ANI_PPLT, MNG_LC_START);
5684	#endif
5685
5686	MNG_FREEX (pData, pObject, sizeof (mng_ani_pplt));
5687
5688	#ifdef MNG_SUPPORT_TRACE
5689	MNG_TRACE (pData, MNG_FN_FREE_ANI_PPLT, MNG_LC_END);
5690	#endif
5691
5692	return MNG_NOERROR;
5693	}
5694	#endif
5695
5696	/* ************************************************************************** */
5697
5698	mng_retcode mng_process_ani_pplt (mng_datap pData,
5699	mng_objectp pObject)
5700	{
5701	mng_ani_ppltp pPPLT = (mng_ani_ppltp)pObject;
5702	mng_retcode iRetcode;
5703
5704	#ifdef MNG_SUPPORT_TRACE
5705	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PPLT, MNG_LC_START);
5706	#endif
5707
5708	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5709	iRetcode = mng_process_display_pplt (pData, pPPLT->iType, pPPLT->iCount,
5710	pPPLT->aIndexentries, pPPLT->aAlphaentries,
5711	pPPLT->aUsedentries);
5712	#else
5713	pData->iPPLTtype = pPPLT->iType;
5714	pData->iPPLTcount = pPPLT->iCount;
5715	pData->paPPLTindexentries = &pPPLT->aIndexentries;
5716	pData->paPPLTalphaentries = &pPPLT->aAlphaentries;
5717	pData->paPPLTusedentries = &pPPLT->aUsedentries;
5718
5719	iRetcode = mng_process_display_pplt (pData);
5720	#endif
5721
5722	#ifdef MNG_SUPPORT_TRACE
5723	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PPLT, MNG_LC_END);
5724	#endif
5725
5726	return iRetcode;
5727	}
5728	#endif
5729
5730	/* ************************************************************************** */
5731
5732	#ifndef MNG_SKIPCHUNK_MAGN
5733	#ifndef MNG_OPTIMIZE_CHUNKREADER
5734	mng_retcode mng_create_ani_magn (mng_datap pData,
5735	mng_uint16 iFirstid,
5736	mng_uint16 iLastid,
5737	mng_uint8 iMethodX,
5738	mng_uint16 iMX,
5739	mng_uint16 iMY,
5740	mng_uint16 iML,
5741	mng_uint16 iMR,
5742	mng_uint16 iMT,
5743	mng_uint16 iMB,
5744	mng_uint8 iMethodY)
5745	#else
5746	mng_retcode mng_create_ani_magn (mng_datap pData,
5747	mng_chunkp pChunk)
5748	#endif
5749	{
5750	mng_ani_magnp pMAGN=NULL;
5751	mng_retcode iRetcode;
5752
5753	#ifdef MNG_SUPPORT_TRACE
5754	MNG_TRACE (pData, MNG_FN_CREATE_ANI_MAGN, MNG_LC_START);
5755	#endif
5756
5757	if (pData->bCacheplayback) /* caching playback info ? */
5758	{
5759	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5760	mng_ptr pTemp;
5761	iRetcode = create_obj_general (pData, sizeof (mng_ani_magn),
5762	mng_free_obj_general,
5763	mng_process_ani_magn,
5764	&pTemp);
5765	if (iRetcode)
5766	return iRetcode;
5767	pMAGN = (mng_ani_magnp)pTemp;
5768	#else
5769	MNG_ALLOC (pData, pMAGN, sizeof (mng_ani_magn));
5770
5771	pMAGN->sHeader.fCleanup = mng_free_ani_magn;
5772	pMAGN->sHeader.fProcess = mng_process_ani_magn;
5773	#endif
5774
5775	mng_add_ani_object (pData, (mng_object_headerp)pMAGN);
5776
5777	#ifndef MNG_OPTIMIZE_CHUNKREADER
5778	pMAGN->iFirstid = iFirstid;
5779	pMAGN->iLastid = iLastid;
5780	pMAGN->iMethodX = iMethodX;
5781	pMAGN->iMX = iMX;
5782	pMAGN->iMY = iMY;
5783	pMAGN->iML = iML;
5784	pMAGN->iMR = iMR;
5785	pMAGN->iMT = iMT;
5786	pMAGN->iMB = iMB;
5787	pMAGN->iMethodY = iMethodY;
5788	#else
5789	pMAGN->iFirstid = ((mng_magnp)pChunk)->iFirstid;
5790	pMAGN->iLastid = ((mng_magnp)pChunk)->iLastid;
5791	pMAGN->iMethodX = ((mng_magnp)pChunk)->iMethodX;
5792	pMAGN->iMX = ((mng_magnp)pChunk)->iMX;
5793	pMAGN->iMY = ((mng_magnp)pChunk)->iMY;
5794	pMAGN->iML = ((mng_magnp)pChunk)->iML;
5795	pMAGN->iMR = ((mng_magnp)pChunk)->iMR;
5796	pMAGN->iMT = ((mng_magnp)pChunk)->iMT;
5797	pMAGN->iMB = ((mng_magnp)pChunk)->iMB;
5798	pMAGN->iMethodY = ((mng_magnp)pChunk)->iMethodY;
5799	#endif
5800	}
5801
5802	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5803	#ifndef MNG_OPTIMIZE_CHUNKREADER
5804	iRetcode = mng_process_display_magn (pData, pMAGN->iFirstid, pMAGN->iLastid,
5805	pMAGN->iMethodX, pMAGN->iMX, pMAGN->iMY,
5806	pMAGN->iML, pMAGN->iMR, pMAGN->iMT,
5807	pMAGN->iMB, pMAGN->iMethodY);
5808	#else
5809	iRetcode = mng_process_display_magn (pData,
5810	((mng_magnp)pChunk)->iFirstid,
5811	((mng_magnp)pChunk)->iLastid,
5812	((mng_magnp)pChunk)->iMethodX,
5813	((mng_magnp)pChunk)->iMX,
5814	((mng_magnp)pChunk)->iMY,
5815	((mng_magnp)pChunk)->iML,
5816	((mng_magnp)pChunk)->iMR,
5817	((mng_magnp)pChunk)->iMT,
5818	((mng_magnp)pChunk)->iMB,
5819	((mng_magnp)pChunk)->iMethodY);
5820	#endif
5821	#else
5822	#ifndef MNG_OPTIMIZE_CHUNKREADER
5823	pData->iMAGNfirstid = iFirstid;
5824	pData->iMAGNlastid = iLastid;
5825	pData->iMAGNmethodX = iMethodX;
5826	pData->iMAGNmX = iMX;
5827	pData->iMAGNmY = iMY;
5828	pData->iMAGNmL = iML;
5829	pData->iMAGNmR = iMR;
5830	pData->iMAGNmT = iMT;
5831	pData->iMAGNmB = iMB;
5832	pData->iMAGNmethodY = iMethodY;
5833	#else
5834	pData->iMAGNfirstid = ((mng_magnp)pChunk)->iFirstid;
5835	pData->iMAGNlastid = ((mng_magnp)pChunk)->iLastid;
5836	pData->iMAGNmethodX = ((mng_magnp)pChunk)->iMethodX;
5837	pData->iMAGNmX = ((mng_magnp)pChunk)->iMX;
5838	pData->iMAGNmY = ((mng_magnp)pChunk)->iMY;
5839	pData->iMAGNmL = ((mng_magnp)pChunk)->iML;
5840	pData->iMAGNmR = ((mng_magnp)pChunk)->iMR;
5841	pData->iMAGNmT = ((mng_magnp)pChunk)->iMT;
5842	pData->iMAGNmB = ((mng_magnp)pChunk)->iMB;
5843	pData->iMAGNmethodY = ((mng_magnp)pChunk)->iMethodY;
5844	#endif
5845
5846	iRetcode = mng_process_display_magn (pData);
5847	#endif
5848
5849	#ifdef MNG_SUPPORT_TRACE
5850	MNG_TRACE (pData, MNG_FN_CREATE_ANI_MAGN, MNG_LC_END);
5851	#endif
5852
5853	return iRetcode;
5854	}
5855
5856	/* ************************************************************************** */
5857
5858	#ifndef MNG_OPTIMIZE_OBJCLEANUP
5859	mng_retcode mng_free_ani_magn (mng_datap pData,
5860	mng_objectp pObject)
5861	{
5862	#ifdef MNG_SUPPORT_TRACE
5863	MNG_TRACE (pData, MNG_FN_FREE_ANI_MAGN, MNG_LC_START);
5864	#endif
5865
5866	MNG_FREEX (pData, pObject, sizeof (mng_ani_magn));
5867
5868	#ifdef MNG_SUPPORT_TRACE
5869	MNG_TRACE (pData, MNG_FN_FREE_ANI_MAGN, MNG_LC_END);
5870	#endif
5871
5872	return MNG_NOERROR;
5873	}
5874	#endif
5875
5876	/* ************************************************************************** */
5877
5878	mng_retcode mng_process_ani_magn (mng_datap pData,
5879	mng_objectp pObject)
5880	{
5881	mng_ani_magnp pMAGN = (mng_ani_magnp)pObject;
5882	mng_retcode iRetcode;
5883
5884	#ifdef MNG_SUPPORT_TRACE
5885	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MAGN, MNG_LC_START);
5886	#endif
5887
5888	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5889	iRetcode = mng_process_display_magn (pData, pMAGN->iFirstid, pMAGN->iLastid,
5890	pMAGN->iMethodX, pMAGN->iMX, pMAGN->iMY,
5891	pMAGN->iML, pMAGN->iMR, pMAGN->iMT,
5892	pMAGN->iMB, pMAGN->iMethodY);
5893	#else
5894	pData->iMAGNfirstid = pMAGN->iFirstid;
5895	pData->iMAGNlastid = pMAGN->iLastid;
5896	pData->iMAGNmethodX = pMAGN->iMethodX;
5897	pData->iMAGNmX = pMAGN->iMX;
5898	pData->iMAGNmY = pMAGN->iMY;
5899	pData->iMAGNmL = pMAGN->iML;
5900	pData->iMAGNmR = pMAGN->iMR;
5901	pData->iMAGNmT = pMAGN->iMT;
5902	pData->iMAGNmB = pMAGN->iMB;
5903	pData->iMAGNmethodY = pMAGN->iMethodY;
5904
5905	iRetcode = mng_process_display_magn (pData);
5906	#endif
5907
5908	#ifdef MNG_SUPPORT_TRACE
5909	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MAGN, MNG_LC_END);
5910	#endif
5911
5912	return iRetcode;
5913	}
5914	#endif
5915
5916	/* ************************************************************************** */
5917
5918	#ifndef MNG_SKIPCHUNK_PAST
5919	#ifndef MNG_OPTIMIZE_CHUNKREADER
5920	mng_retcode mng_create_ani_past (mng_datap pData,
5921	mng_uint16 iTargetid,
5922	mng_uint8 iTargettype,
5923	mng_int32 iTargetx,
5924	mng_int32 iTargety,
5925	mng_uint32 iCount,
5926	mng_ptr pSources)
5927	#else
5928	mng_retcode mng_create_ani_past (mng_datap pData,
5929	mng_chunkp pChunk)
5930	#endif
5931	{
5932	mng_ani_pastp pPAST;
5933	mng_retcode iRetcode;
5934
5935	#ifdef MNG_SUPPORT_TRACE
5936	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PAST, MNG_LC_START);
5937	#endif
5938
5939	if (pData->bCacheplayback) /* caching playback info ? */
5940	{
5941	#ifdef MNG_OPTIMIZE_OBJCLEANUP
5942	mng_ptr pTemp;
5943	iRetcode = create_obj_general (pData, sizeof (mng_ani_past),
5944	mng_free_ani_past,
5945	mng_process_ani_past,
5946	&pTemp);
5947	if (iRetcode)
5948	return iRetcode;
5949	pPAST = (mng_ani_pastp)pTemp;
5950	#else
5951	MNG_ALLOC (pData, pPAST, sizeof (mng_ani_past));
5952
5953	pPAST->sHeader.fCleanup = mng_free_ani_past;
5954	pPAST->sHeader.fProcess = mng_process_ani_past;
5955	#endif
5956
5957	mng_add_ani_object (pData, (mng_object_headerp)pPAST);
5958
5959	#ifndef MNG_OPTIMIZE_CHUNKREADER
5960	pPAST->iTargetid = iTargetid;
5961	pPAST->iTargettype = iTargettype;
5962	pPAST->iTargetx = iTargetx;
5963	pPAST->iTargety = iTargety;
5964	pPAST->iCount = iCount;
5965
5966	if (iCount)
5967	{
5968	MNG_ALLOC (pData, pPAST->pSources, (iCount * sizeof (mng_past_source)));
5969	MNG_COPY (pPAST->pSources, pSources, (iCount * sizeof (mng_past_source)));
5970	}
5971	#else
5972	pPAST->iTargetid = ((mng_pastp)pChunk)->iDestid;
5973	pPAST->iTargettype = ((mng_pastp)pChunk)->iTargettype;
5974	pPAST->iTargetx = ((mng_pastp)pChunk)->iTargetx;
5975	pPAST->iTargety = ((mng_pastp)pChunk)->iTargety;
5976	pPAST->iCount = ((mng_pastp)pChunk)->iCount;
5977
5978	if (pPAST->iCount)
5979	{
5980	mng_size_t iSize = (mng_size_t)(pPAST->iCount * sizeof (mng_past_source));
5981	MNG_ALLOC (pData, pPAST->pSources, iSize);
5982	MNG_COPY (pPAST->pSources, ((mng_pastp)pChunk)->pSources, iSize);
5983	}
5984	#endif
5985	}
5986
5987	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
5988	#ifndef MNG_OPTIMIZE_CHUNKREADER
5989	iRetcode = mng_process_display_past (pData, iTargetid, iTargettype,
5990	iTargetx, iTargety,
5991	iCount, pSources);
5992	#else
5993	iRetcode = mng_process_display_past (pData,
5994	((mng_pastp)pChunk)->iDestid,
5995	((mng_pastp)pChunk)->iTargettype,
5996	((mng_pastp)pChunk)->iTargetx,
5997	((mng_pastp)pChunk)->iTargety,
5998	((mng_pastp)pChunk)->iCount,
5999	((mng_pastp)pChunk)->pSources);
6000	#endif
6001	#else
6002	#ifndef MNG_OPTIMIZE_CHUNKREADER
6003	pData->iPASTtargetid = iTargetid;
6004	pData->iPASTtargettype = iTargettype;
6005	pData->iPASTtargetx = iTargetx;
6006	pData->iPASTtargety = iTargety;
6007	pData->iPASTcount = iCount;
6008	pData->pPASTsources = pSources;
6009	#else
6010	pData->iPASTtargetid = ((mng_pastp)pChunk)->iDestid;
6011	pData->iPASTtargettype = ((mng_pastp)pChunk)->iTargettype;
6012	pData->iPASTtargetx = ((mng_pastp)pChunk)->iTargetx;
6013	pData->iPASTtargety = ((mng_pastp)pChunk)->iTargety;
6014	pData->iPASTcount = ((mng_pastp)pChunk)->iCount;
6015	pData->pPASTsources = ((mng_pastp)pChunk)->pSources;
6016	#endif
6017
6018	iRetcode = mng_process_display_past (pData);
6019	#endif
6020
6021	#ifdef MNG_SUPPORT_TRACE
6022	MNG_TRACE (pData, MNG_FN_CREATE_ANI_PAST, MNG_LC_END);
6023	#endif
6024
6025	return iRetcode;
6026	}
6027	#endif
6028
6029	/* ************************************************************************** */
6030
6031	#ifndef MNG_SKIPCHUNK_PAST
6032	mng_retcode mng_free_ani_past (mng_datap pData,
6033	mng_objectp pObject)
6034	{
6035	mng_ani_pastp pPAST = (mng_ani_pastp)pObject;
6036
6037	#ifdef MNG_SUPPORT_TRACE
6038	MNG_TRACE (pData, MNG_FN_FREE_ANI_PAST, MNG_LC_START);
6039	#endif
6040
6041	if (pPAST->iCount)
6042	MNG_FREEX (pData, pPAST->pSources, (pPAST->iCount * sizeof (mng_past_source)));
6043
6044	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6045	MNG_FREEX (pData, pObject, sizeof (mng_ani_past));
6046	#endif
6047
6048	#ifdef MNG_SUPPORT_TRACE
6049	MNG_TRACE (pData, MNG_FN_FREE_ANI_PAST, MNG_LC_END);
6050	#endif
6051
6052	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6053	return MNG_NOERROR;
6054	#else
6055	return mng_free_obj_general(pData, pObject);
6056	#endif
6057	}
6058	#endif
6059
6060	/* ************************************************************************** */
6061
6062	#ifndef MNG_SKIPCHUNK_PAST
6063	mng_retcode mng_process_ani_past (mng_datap pData,
6064	mng_objectp pObject)
6065	{
6066	mng_ani_pastp pPAST = (mng_ani_pastp)pObject;
6067	mng_retcode iRetcode;
6068
6069	#ifdef MNG_SUPPORT_TRACE
6070	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PAST, MNG_LC_START);
6071	#endif
6072
6073	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
6074	iRetcode = mng_process_display_past (pData, pPAST->iTargetid, pPAST->iTargettype,
6075	pPAST->iTargetx, pPAST->iTargety,
6076	pPAST->iCount, pPAST->pSources);
6077	#else
6078	pData->iPASTtargetid = pPAST->iTargetid;
6079	pData->iPASTtargettype = pPAST->iTargettype;
6080	pData->iPASTtargetx = pPAST->iTargetx;
6081	pData->iPASTtargety = pPAST->iTargety;
6082	pData->iPASTcount = pPAST->iCount;
6083	pData->pPASTsources = pPAST->pSources;
6084
6085	iRetcode = mng_process_display_past (pData);
6086	#endif
6087
6088	#ifdef MNG_SUPPORT_TRACE
6089	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PAST, MNG_LC_END);
6090	#endif
6091
6092	return iRetcode;
6093	}
6094	#endif
6095
6096	/* ************************************************************************** */
6097
6098	#ifndef MNG_SKIPCHUNK_DISC
6099	#ifndef MNG_OPTIMIZE_CHUNKREADER
6100	mng_retcode mng_create_ani_disc (mng_datap pData,
6101	mng_uint32 iCount,
6102	mng_uint16p pIds)
6103	#else
6104	mng_retcode mng_create_ani_disc (mng_datap pData,
6105	mng_chunkp pChunk)
6106	#endif
6107	{
6108	mng_ani_discp pDISC;
6109	mng_retcode iRetcode;
6110
6111	#ifdef MNG_SUPPORT_TRACE
6112	MNG_TRACE (pData, MNG_FN_CREATE_ANI_DISC, MNG_LC_START);
6113	#endif
6114
6115	if (pData->bCacheplayback) /* caching playback info ? */
6116	{
6117	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6118	mng_ptr pTemp;
6119	iRetcode = create_obj_general (pData, sizeof (mng_ani_disc),
6120	mng_free_ani_disc,
6121	mng_process_ani_disc,
6122	&pTemp);
6123	if (iRetcode)
6124	return iRetcode;
6125	pDISC = (mng_ani_discp)pTemp;
6126	#else
6127	MNG_ALLOC (pData, pDISC, sizeof (mng_ani_disc));
6128
6129	pDISC->sHeader.fCleanup = mng_free_ani_disc;
6130	pDISC->sHeader.fProcess = mng_process_ani_disc;
6131	#endif
6132
6133	mng_add_ani_object (pData, (mng_object_headerp)pDISC);
6134
6135	#ifndef MNG_OPTIMIZE_CHUNKREADER
6136	pDISC->iCount = iCount;
6137
6138	if (iCount)
6139	{
6140	MNG_ALLOC (pData, pDISC->pIds, (iCount << 1));
6141	MNG_COPY (pDISC->pIds, pIds, (iCount << 1));
6142	}
6143	#else
6144	pDISC->iCount = ((mng_discp)pChunk)->iCount;
6145
6146	if (pDISC->iCount)
6147	{
6148	mng_size_t iSize = (mng_size_t)(pDISC->iCount << 1);
6149	MNG_ALLOC (pData, pDISC->pIds, iSize);
6150	MNG_COPY (pDISC->pIds, ((mng_discp)pChunk)->pObjectids, iSize);
6151	}
6152	#endif
6153	}
6154
6155	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
6156	#ifndef MNG_OPTIMIZE_CHUNKREADER
6157	iRetcode = mng_process_display_disc (pData, iCount, pIds);
6158	#else
6159	iRetcode = mng_process_display_disc (pData,
6160	((mng_discp)pChunk)->iCount,
6161	((mng_discp)pChunk)->pObjectids);
6162	#endif
6163	#else
6164	#ifndef MNG_OPTIMIZE_CHUNKREADER
6165	pData->iDISCcount = iCount;
6166	pData->pDISCids = pIds;
6167	#else
6168	pData->iDISCcount = ((mng_discp)pChunk)->iCount;
6169	pData->pDISCids = ((mng_discp)pChunk)->pObjectids;
6170	#endif
6171
6172	iRetcode = mng_process_display_disc (pData);
6173	#endif
6174
6175	#ifdef MNG_SUPPORT_TRACE
6176	MNG_TRACE (pData, MNG_FN_CREATE_ANI_DISC, MNG_LC_END);
6177	#endif
6178
6179	return MNG_NOERROR;
6180	}
6181
6182	/* ************************************************************************** */
6183
6184	mng_retcode mng_free_ani_disc (mng_datap pData,
6185	mng_objectp pObject)
6186	{
6187	mng_ani_discp pDISC = (mng_ani_discp)pObject;
6188
6189	#ifdef MNG_SUPPORT_TRACE
6190	MNG_TRACE (pData, MNG_FN_FREE_ANI_DISC, MNG_LC_START);
6191	#endif
6192
6193	if (pDISC->iCount)
6194	MNG_FREEX (pData, pDISC->pIds, (pDISC->iCount << 1));
6195
6196	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6197	MNG_FREEX (pData, pObject, sizeof (mng_ani_disc));
6198	#endif
6199
6200	#ifdef MNG_SUPPORT_TRACE
6201	MNG_TRACE (pData, MNG_FN_FREE_ANI_DISC, MNG_LC_END);
6202	#endif
6203
6204	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6205	return MNG_NOERROR;
6206	#else
6207	return mng_free_obj_general(pData, pObject);
6208	#endif
6209	}
6210
6211	/* ************************************************************************** */
6212
6213	mng_retcode mng_process_ani_disc (mng_datap pData,
6214	mng_objectp pObject)
6215	{
6216	mng_ani_discp pDISC = (mng_ani_discp)pObject;
6217	mng_retcode iRetcode;
6218
6219	#ifdef MNG_SUPPORT_TRACE
6220	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DISC, MNG_LC_START);
6221	#endif
6222
6223	#ifndef MNG_OPTIMIZE_DISPLAYCALLS
6224	iRetcode = mng_process_display_disc (pData, pDISC->iCount, pDISC->pIds);
6225	#else
6226	pData->iDISCcount = pDISC->iCount;
6227	pData->pDISCids = pDISC->pIds;
6228
6229	iRetcode = mng_process_display_disc (pData);
6230	#endif
6231
6232	#ifdef MNG_SUPPORT_TRACE
6233	MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DISC, MNG_LC_END);
6234	#endif
6235
6236	return iRetcode;
6237	}
6238	#endif
6239
6240	/* ************************************************************************** */
6241	/* ************************************************************************** */
6242
6243	#ifdef MNG_SUPPORT_DYNAMICMNG
6244
6245	/* ************************************************************************** */
6246
6247	#ifndef MNG_OPTIMIZE_CHUNKREADER
6248	mng_retcode mng_create_event (mng_datap pData,
6249	mng_uint8 iEventtype,
6250	mng_uint8 iMasktype,
6251	mng_int32 iLeft,
6252	mng_int32 iRight,
6253	mng_int32 iTop,
6254	mng_int32 iBottom,
6255	mng_uint16 iObjectid,
6256	mng_uint8 iIndex,
6257	mng_uint32 iSegmentnamesize,
6258	mng_pchar zSegmentname)
6259	#else
6260	mng_retcode mng_create_event (mng_datap pData,
6261	mng_ptr pEntry)
6262	#endif
6263	{
6264	mng_eventp pEvent;
6265
6266	#ifdef MNG_SUPPORT_TRACE
6267	MNG_TRACE (pData, MNG_FN_CREATE_EVENT, MNG_LC_START);
6268	#endif
6269
6270	if (pData->bCacheplayback) /* caching playback info ? */
6271	{
6272	mng_object_headerp pLast;
6273
6274	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6275	mng_ptr pTemp;
6276	mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_event),
6277	mng_free_event,
6278	mng_process_event,
6279	&pTemp);
6280	if (iRetcode)
6281	return iRetcode;
6282	pEvent = (mng_eventp)pTemp;
6283	#else
6284	MNG_ALLOC (pData, pEvent, sizeof (mng_event));
6285
6286	pEvent->sHeader.fCleanup = mng_free_event;
6287	pEvent->sHeader.fProcess = mng_process_event;
6288	#endif
6289
6290	#ifndef MNG_OPTIMIZE_CHUNKREADER
6291	pEvent->iEventtype = iEventtype;
6292	pEvent->iMasktype = iMasktype;
6293	pEvent->iLeft = iLeft;
6294	pEvent->iRight = iRight;
6295	pEvent->iTop = iTop;
6296	pEvent->iBottom = iBottom;
6297	pEvent->iObjectid = iObjectid;
6298	pEvent->iIndex = iIndex;
6299	pEvent->iSegmentnamesize = iSegmentnamesize;
6300
6301	if (iSegmentnamesize)
6302	{
6303	MNG_ALLOC (pData, pEvent->zSegmentname, iSegmentnamesize+1);
6304	MNG_COPY (pEvent->zSegmentname, zSegmentname, iSegmentnamesize);
6305	}
6306	#else
6307	pEvent->iEventtype = ((mng_evnt_entryp)pEntry)->iEventtype;
6308	pEvent->iMasktype = ((mng_evnt_entryp)pEntry)->iMasktype;
6309	pEvent->iLeft = ((mng_evnt_entryp)pEntry)->iLeft;
6310	pEvent->iRight = ((mng_evnt_entryp)pEntry)->iRight;
6311	pEvent->iTop = ((mng_evnt_entryp)pEntry)->iTop;
6312	pEvent->iBottom = ((mng_evnt_entryp)pEntry)->iBottom;
6313	pEvent->iObjectid = ((mng_evnt_entryp)pEntry)->iObjectid;
6314	pEvent->iIndex = ((mng_evnt_entryp)pEntry)->iIndex;
6315	pEvent->iSegmentnamesize = ((mng_evnt_entryp)pEntry)->iSegmentnamesize;
6316
6317	if (pEvent->iSegmentnamesize)
6318	{
6319	MNG_ALLOC (pData, pEvent->zSegmentname, pEvent->iSegmentnamesize+1);
6320	MNG_COPY (pEvent->zSegmentname, ((mng_evnt_entryp)pEntry)->zSegmentname, pEvent->iSegmentnamesize);
6321	}
6322	#endif
6323	/* fixup the double-linked list */
6324	pLast = (mng_object_headerp)pData->pLastevent;
6325
6326	if (pLast) /* link it as last in the chain */
6327	{
6328	pEvent->sHeader.pPrev = pLast;
6329	pLast->pNext = pEvent;
6330	}
6331	else
6332	{
6333	pData->pFirstevent = pEvent;
6334	}
6335
6336	pData->pLastevent = pEvent;
6337	pData->bDynamic = MNG_TRUE;
6338	}
6339
6340	#ifdef MNG_SUPPORT_TRACE
6341	MNG_TRACE (pData, MNG_FN_CREATE_EVENT, MNG_LC_END);
6342	#endif
6343
6344	return MNG_NOERROR;
6345	}
6346
6347	/* ************************************************************************** */
6348
6349	mng_retcode mng_free_event (mng_datap pData,
6350	mng_objectp pObject)
6351	{
6352	mng_eventp pEvent = (mng_eventp)pObject;
6353
6354	#ifdef MNG_SUPPORT_TRACE
6355	MNG_TRACE (pData, MNG_FN_FREE_EVENT, MNG_LC_START);
6356	#endif
6357
6358	if (pEvent->iSegmentnamesize)
6359	MNG_FREEX (pData, pEvent->zSegmentname, pEvent->iSegmentnamesize + 1);
6360
6361	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6362	MNG_FREEX (pData, pEvent, sizeof (mng_event));
6363	#endif
6364
6365	#ifdef MNG_SUPPORT_TRACE
6366	MNG_TRACE (pData, MNG_FN_FREE_EVENT, MNG_LC_END);
6367	#endif
6368
6369	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6370	return MNG_NOERROR;
6371	#else
6372	return mng_free_obj_general(pData, pObject);
6373	#endif
6374	}
6375
6376	/* ************************************************************************** */
6377
6378	mng_retcode mng_process_event (mng_datap pData,
6379	mng_objectp pObject)
6380	{
6381	#ifndef MNG_SKIPCHUNK_SEEK
6382	mng_eventp pEvent = (mng_eventp)pObject;
6383	mng_object_headerp pAni;
6384	mng_bool bFound = MNG_FALSE;
6385	#endif
6386
6387	#ifdef MNG_SUPPORT_TRACE
6388	MNG_TRACE (pData, MNG_FN_PROCESS_EVENT, MNG_LC_START);
6389	#endif
6390
6391	#ifndef MNG_SKIPCHUNK_SEEK
6392	if (!pEvent->pSEEK) /* need to find SEEK first ? */
6393	{
6394	pAni = (mng_object_headerp)pData->pFirstaniobj;
6395
6396	while ((pAni) && (!bFound))
6397	{
6398	if ((pAni->fCleanup == mng_free_ani_seek) &&
6399	(strcmp(pEvent->zSegmentname, ((mng_ani_seekp)pAni)->zSegmentname) == 0))
6400	bFound = MNG_TRUE;
6401	else
6402	pAni = (mng_object_headerp)pAni->pNext;
6403	}
6404
6405	if (pAni)
6406	pEvent->pSEEK = (mng_ani_seekp)pAni;
6407	}
6408
6409	if (pEvent->pSEEK) /* anything to do ? */
6410	{
6411	pEvent->iLastx = pData->iEventx;
6412	pEvent->iLasty = pData->iEventy;
6413	/* let's start from this SEEK then */
6414	pData->pCurraniobj = (mng_objectp)pEvent->pSEEK;
6415	pData->bRunningevent = MNG_TRUE;
6416	/* wake-up the app ! */
6417	if (!pData->fSettimer ((mng_handle)pData, 5))
6418	MNG_ERROR (pData, MNG_APPTIMERERROR);
6419
6420	}
6421	else
6422	MNG_ERROR (pData, MNG_SEEKNOTFOUND);
6423	#endif
6424
6425	#ifdef MNG_SUPPORT_TRACE
6426	MNG_TRACE (pData, MNG_FN_PROCESS_EVENT, MNG_LC_END);
6427	#endif
6428
6429	return MNG_NOERROR;
6430	}
6431
6432	/* ************************************************************************** */
6433
6434	#endif /* MNG_SUPPORT_DYNAMICMNG */
6435
6436	/* ************************************************************************** */
6437	/* ************************************************************************** */
6438
6439	#ifdef MNG_INCLUDE_MPNG_PROPOSAL
6440
6441	/* ************************************************************************** */
6442
6443	#ifndef MNG_OPTIMIZE_CHUNKREADER
6444	mng_retcode mng_create_mpng_obj (mng_datap pData,
6445	mng_uint32 iFramewidth,
6446	mng_uint32 iFrameheight,
6447	mng_uint16 iNumplays,
6448	mng_uint16 iTickspersec,
6449	mng_uint32 iFramessize,
6450	mng_ptr pFrames)
6451	#else
6452	mng_retcode mng_create_mpng_obj (mng_datap pData,
6453	mng_ptr pEntry)
6454	#endif
6455	{
6456	mng_mpng_objp pMPNG;
6457	mng_ptr pTemp;
6458	mng_retcode iRetcode;
6459	mng_uint8p pFrame;
6460	mng_int32 iCnt, iMax;
6461	mng_uint32 iX, iY, iWidth, iHeight;
6462	mng_int32 iXoffset, iYoffset;
6463	mng_uint16 iTicks;
6464	mng_uint16 iDelay;
6465	mng_bool bNewframe;
6466	mng_ani_loopp pLOOP;
6467	mng_ani_endlp pENDL;
6468	mng_ani_framp pFRAM;
6469	mng_ani_movep pMOVE;
6470	mng_ani_clipp pCLIP;
6471	mng_ani_showp pSHOW;
6472
6473	#ifdef MNG_SUPPORT_TRACE
6474	MNG_TRACE (pData, MNG_FN_CREATE_MPNG_OBJ, MNG_LC_START);
6475	#endif
6476
6477	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6478	iRetcode = create_obj_general (pData, sizeof (mng_mpng_obj), mng_free_mpng_obj,
6479	mng_process_mpng_obj, &pTemp);
6480	if (iRetcode)
6481	return iRetcode;
6482	pMPNG = (mng_mpng_objp)pTemp;
6483	#else
6484	MNG_ALLOC (pData, pMPNG, sizeof (mng_mpng_obj));
6485
6486	pMPNG->sHeader.fCleanup = mng_free_mpng_obj;
6487	pMPNG->sHeader.fProcess = mng_process_mpng_obj;
6488	#endif
6489
6490	#ifndef MNG_OPTIMIZE_CHUNKREADER
6491	pMPNG->iFramewidth = iFramewidth;
6492	pMPNG->iFrameheight = iFrameheight;
6493	pMPNG->iNumplays = iNumplays;
6494	pMPNG->iTickspersec = iTickspersec;
6495	pMPNG->iFramessize = iFramessize;
6496
6497	if (iFramessize)
6498	{
6499	MNG_ALLOC (pData, pMPNG->pFrames, iFramessize);
6500	MNG_COPY (pMPNG->pFrames, pFrames, iFramessize);
6501	}
6502	#else
6503	pMPNG->iFramewidth = ((mng_mpngp)pEntry)->iFramewidth;
6504	pMPNG->iFrameheight = ((mng_mpngp)pEntry)->iFrameheight;
6505	pMPNG->iNumplays = ((mng_mpngp)pEntry)->iNumplays;
6506	pMPNG->iTickspersec = ((mng_mpngp)pEntry)->iTickspersec;
6507	pMPNG->iFramessize = ((mng_mpngp)pEntry)->iFramessize;
6508
6509	if (pMPNG->iFramessize)
6510	{
6511	MNG_ALLOC (pData, pMPNG->pFrames, pMPNG->iFramessize);
6512	MNG_COPY (pMPNG->pFrames, ((mng_mpngp)pEntry)->pFrames, pMPNG->iFramessize);
6513	}
6514	#endif
6515
6516	pData->pMPNG = pMPNG;
6517	pData->eImagetype = mng_it_mpng;
6518
6519	iRetcode = mng_process_display_mpng (pData);
6520	if (iRetcode)
6521	return iRetcode;
6522
6523	/* now let's create the MNG animation directives from this */
6524
6525	pFrame = (mng_uint8p)pMPNG->pFrames;
6526	iMax = pMPNG->iFramessize / 26;
6527	/* set up MNG impersonation */
6528	pData->iTicks = pMPNG->iTickspersec;
6529	pData->iLayercount = iMax;
6530
6531	if (pMPNG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
6532	{
6533	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6534	iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
6535	mng_free_ani_loop, mng_process_ani_loop,
6536	&((mng_ptr)pLOOP));
6537	if (iRetcode)
6538	return iRetcode;
6539	#else
6540	MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
6541
6542	pLOOP->sHeader.fCleanup = mng_free_ani_loop;
6543	pLOOP->sHeader.fProcess = mng_process_ani_loop;
6544	#endif
6545
6546	pLOOP->iLevel = 1;
6547	if (pMPNG->iNumplays)
6548	pLOOP->iRepeatcount = pMPNG->iNumplays;
6549	else
6550	pLOOP->iRepeatcount = 0xFFFFFFFFl;
6551
6552	mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
6553	}
6554
6555	bNewframe = MNG_TRUE; /* create the frame display objects */
6556
6557	for (iCnt = 0; iCnt < iMax; iCnt++)
6558	{
6559	iX = mng_get_uint32 (pFrame);
6560	iY = mng_get_uint32 (pFrame+4);
6561	iWidth = mng_get_uint32 (pFrame+8);
6562	iHeight = mng_get_uint32 (pFrame+12);
6563	iXoffset = mng_get_int32 (pFrame+16);
6564	iYoffset = mng_get_int32 (pFrame+20);
6565	iTicks = mng_get_uint16 (pFrame+24);
6566
6567	iDelay = iTicks;
6568	if (!iDelay)
6569	{
6570	mng_uint8p pTemp = pFrame+26;
6571	mng_int32 iTemp = iCnt+1;
6572
6573	while ((iTemp < iMax) && (!iDelay))
6574	{
6575	iDelay = mng_get_uint16 (pTemp+24);
6576	pTemp += 26;
6577	iTemp++;
6578	}
6579	}
6580
6581	if (bNewframe)
6582	{
6583	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6584	iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
6585	mng_free_obj_general, mng_process_ani_fram,
6586	&((mng_ptr)pFRAM));
6587	if (iRetcode)
6588	return iRetcode;
6589	#else
6590	MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
6591
6592	pFRAM->sHeader.fCleanup = mng_free_ani_fram;
6593	pFRAM->sHeader.fProcess = mng_process_ani_fram;
6594	#endif
6595
6596	pFRAM->iFramemode = 4;
6597	pFRAM->iChangedelay = 1;
6598	pFRAM->iDelay = iDelay;
6599
6600	mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
6601	}
6602
6603	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6604	iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
6605	mng_free_obj_general,
6606	mng_process_ani_move,
6607	&((mng_ptr)pMOVE));
6608	if (iRetcode)
6609	return iRetcode;
6610	#else
6611	MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
6612
6613	pMOVE->sHeader.fCleanup = mng_free_ani_move;
6614	pMOVE->sHeader.fProcess = mng_process_ani_move;
6615	#endif
6616
6617	pMOVE->iLocax = iXoffset - (mng_int32)iX;
6618	pMOVE->iLocay = iYoffset - (mng_int32)iY;
6619
6620	mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
6621
6622	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6623	iRetcode = create_obj_general (pData, sizeof (mng_ani_clip),
6624	mng_free_obj_general,
6625	mng_process_ani_clip,
6626	&((mng_ptr)pCLIP));
6627	if (iRetcode)
6628	return iRetcode;
6629	#else
6630	MNG_ALLOC (pData, pCLIP, sizeof (mng_ani_clip));
6631
6632	pCLIP->sHeader.fCleanup = mng_free_ani_clip;
6633	pCLIP->sHeader.fProcess = mng_process_ani_clip;
6634	#endif
6635
6636	pCLIP->iClipl = iXoffset;
6637	pCLIP->iClipr = iXoffset + (mng_int32)iWidth;
6638	pCLIP->iClipt = iYoffset;
6639	pCLIP->iClipb = iYoffset + (mng_int32)iHeight;
6640
6641	mng_add_ani_object (pData, (mng_object_headerp)pCLIP);
6642
6643	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6644	iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
6645	mng_free_obj_general, mng_process_ani_show,
6646	&((mng_ptr)pSHOW));
6647	if (iRetcode)
6648	return iRetcode;
6649	#else
6650	MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
6651
6652	pSHOW->sHeader.fCleanup = mng_free_ani_show;
6653	pSHOW->sHeader.fProcess = mng_process_ani_show;
6654	#endif
6655
6656	mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
6657
6658	bNewframe = (mng_bool)iTicks;
6659	pFrame += 26;
6660	}
6661
6662	if (pMPNG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
6663	{
6664	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6665	iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
6666	mng_free_obj_general, mng_process_ani_endl,
6667	&((mng_ptr)pENDL));
6668	if (iRetcode)
6669	return iRetcode;
6670	#else
6671	MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
6672
6673	pENDL->sHeader.fCleanup = mng_free_ani_endl;
6674	pENDL->sHeader.fProcess = mng_process_ani_endl;
6675	#endif
6676
6677	pENDL->iLevel = 1;
6678
6679	mng_add_ani_object (pData, (mng_object_headerp)pENDL);
6680	}
6681
6682	#ifdef MNG_SUPPORT_TRACE
6683	MNG_TRACE (pData, MNG_FN_CREATE_MPNG_OBJ, MNG_LC_END);
6684	#endif
6685
6686	return MNG_NOERROR;
6687	}
6688
6689	/* ************************************************************************** */
6690
6691	mng_retcode mng_free_mpng_obj (mng_datap pData,
6692	mng_objectp pObject)
6693	{
6694	mng_mpng_objp pMPNG = (mng_mpng_objp)pObject;
6695
6696	#ifdef MNG_SUPPORT_TRACE
6697	MNG_TRACE (pData, MNG_FN_FREE_MPNG_OBJ, MNG_LC_START);
6698	#endif
6699
6700	if (pMPNG->iFramessize)
6701	MNG_FREEX (pData, pMPNG->pFrames, pMPNG->iFramessize);
6702
6703	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6704	MNG_FREEX (pData, pMPNG, sizeof (mng_mpng_obj));
6705	#endif
6706
6707	#ifdef MNG_SUPPORT_TRACE
6708	MNG_TRACE (pData, MNG_FN_FREE_MPNG_OBJ, MNG_LC_END);
6709	#endif
6710
6711	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6712	return MNG_NOERROR;
6713	#else
6714	return mng_free_obj_general(pData, pObject);
6715	#endif
6716	}
6717
6718	/* ************************************************************************** */
6719
6720	mng_retcode mng_process_mpng_obj (mng_datap pData,
6721	mng_objectp pObject)
6722	{
6723	return MNG_NOERROR;
6724	}
6725
6726	/* ************************************************************************** */
6727
6728	#endif /* MNG_INCLUDE_MPNG_PROPOSAL */
6729
6730	/* ************************************************************************** */
6731	/* ************************************************************************** */
6732
6733	#ifdef MNG_INCLUDE_ANG_PROPOSAL
6734
6735	/* ************************************************************************** */
6736
6737	#ifndef MNG_OPTIMIZE_CHUNKREADER
6738	mng_retcode mng_create_ang_obj (mng_datap pData,
6739	mng_uint32 iNumframes,
6740	mng_uint32 iTickspersec,
6741	mng_uint32 iNumplays,
6742	mng_uint32 iTilewidth,
6743	mng_uint32 iTileheight,
6744	mng_uint8 iInterlace,
6745	mng_uint8 iStillused)
6746	#else
6747	mng_retcode mng_create_ang_obj (mng_datap pData,
6748	mng_ptr pEntry)
6749	#endif
6750	{
6751	mng_ang_objp pANG;
6752	mng_ptr pTemp;
6753	mng_retcode iRetcode;
6754
6755	#ifdef MNG_SUPPORT_TRACE
6756	MNG_TRACE (pData, MNG_FN_CREATE_ANG_OBJ, MNG_LC_START);
6757	#endif
6758
6759	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6760	iRetcode = create_obj_general (pData, sizeof (mng_ang_obj), mng_free_ang_obj,
6761	mng_process_ang_obj, &pTemp);
6762	if (iRetcode)
6763	return iRetcode;
6764	pANG = (mng_ang_objp)pTemp;
6765	#else
6766	MNG_ALLOC (pData, pANG, sizeof (mng_ang_obj));
6767
6768	pANG->sHeader.fCleanup = mng_free_ang_obj;
6769	pANG->sHeader.fProcess = mng_process_ang_obj;
6770	#endif
6771
6772	#ifndef MNG_OPTIMIZE_CHUNKREADER
6773	pANG->iNumframes = iNumframes;
6774	pANG->iTickspersec = iTickspersec;
6775	pANG->iNumplays = iNumplays;
6776	pANG->iTilewidth = iTilewidth;
6777	pANG->iTileheight = iTileheight;
6778	pANG->iInterlace = iInterlace;
6779	pANG->iStillused = iStillused;
6780	#else
6781	pANG->iNumframes = ((mng_ahdrp)pEntry)->iNumframes;
6782	pANG->iTickspersec = ((mng_ahdrp)pEntry)->iTickspersec;
6783	pANG->iNumplays = ((mng_ahdrp)pEntry)->iNumplays;
6784	pANG->iTilewidth = ((mng_ahdrp)pEntry)->iTilewidth;
6785	pANG->iTileheight = ((mng_ahdrp)pEntry)->iTileheight;
6786	pANG->iInterlace = ((mng_ahdrp)pEntry)->iInterlace;
6787	pANG->iStillused = ((mng_ahdrp)pEntry)->iStillused;
6788	#endif
6789
6790	pData->pANG = pANG;
6791	pData->eImagetype = mng_it_ang;
6792
6793	iRetcode = mng_process_display_ang (pData);
6794	if (iRetcode)
6795	return iRetcode;
6796
6797	#ifdef MNG_SUPPORT_TRACE
6798	MNG_TRACE (pData, MNG_FN_CREATE_ANG_OBJ, MNG_LC_END);
6799	#endif
6800
6801	return MNG_NOERROR;
6802	}
6803
6804	/* ************************************************************************** */
6805
6806	mng_retcode mng_free_ang_obj (mng_datap pData,
6807	mng_objectp pObject)
6808	{
6809	mng_ang_objp pANG = (mng_ang_objp)pObject;
6810
6811	#ifdef MNG_SUPPORT_TRACE
6812	MNG_TRACE (pData, MNG_FN_FREE_ANG_OBJ, MNG_LC_START);
6813	#endif
6814
6815	if (pANG->iTilessize)
6816	MNG_FREEX (pData, pANG->pTiles, pANG->iTilessize);
6817
6818	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6819	MNG_FREEX (pData, pANG, sizeof (mng_ang_obj));
6820	#endif
6821
6822	#ifdef MNG_SUPPORT_TRACE
6823	MNG_TRACE (pData, MNG_FN_FREE_ANG_OBJ, MNG_LC_END);
6824	#endif
6825
6826	#ifndef MNG_OPTIMIZE_OBJCLEANUP
6827	return MNG_NOERROR;
6828	#else
6829	return mng_free_obj_general(pData, pObject);
6830	#endif
6831	}
6832
6833	/* ************************************************************************** */
6834
6835	mng_retcode mng_process_ang_obj (mng_datap pData,
6836	mng_objectp pObject)
6837	{
6838	mng_ang_objp pANG = (mng_ang_objp)pObject;
6839	mng_uint8p pTile = (mng_uint8p)pANG->pTiles;
6840	mng_retcode iRetcode;
6841	mng_int32 iCnt, iMax;
6842	mng_uint32 iTicks;
6843	mng_int32 iXoffset, iYoffset;
6844	mng_uint8 iSource;
6845	mng_ani_loopp pLOOP;
6846	mng_ani_endlp pENDL;
6847	mng_ani_framp pFRAM;
6848	mng_ani_movep pMOVE;
6849	mng_ani_showp pSHOW;
6850
6851	#ifdef MNG_SUPPORT_TRACE
6852	MNG_TRACE (pData, MNG_FN_PROCESS_ANG_OBJ, MNG_LC_START);
6853	#endif
6854
6855	/* let's create the MNG animation directives from this */
6856
6857	iMax = pANG->iNumframes;
6858	/* set up MNG impersonation */
6859	pData->iTicks = pANG->iTickspersec;
6860	pData->iLayercount = iMax;
6861
6862	if (pANG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
6863	{
6864	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6865	iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
6866	mng_free_ani_loop, mng_process_ani_loop,
6867	&((mng_ptr)pLOOP));
6868	if (iRetcode)
6869	return iRetcode;
6870	#else
6871	MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
6872
6873	pLOOP->sHeader.fCleanup = mng_free_ani_loop;
6874	pLOOP->sHeader.fProcess = mng_process_ani_loop;
6875	#endif
6876
6877	pLOOP->iLevel = 1;
6878	if (pANG->iNumplays)
6879	pLOOP->iRepeatcount = pANG->iNumplays;
6880	else
6881	pLOOP->iRepeatcount = 0xFFFFFFFFl;
6882
6883	mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
6884	}
6885
6886	for (iCnt = 0; iCnt < iMax; iCnt++)
6887	{
6888	iTicks = mng_get_uint32 (pTile);
6889	iXoffset = mng_get_int32 (pTile+4);
6890	iYoffset = mng_get_int32 (pTile+8);
6891	iSource = *(pTile+12);
6892
6893	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6894	iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
6895	mng_free_obj_general, mng_process_ani_fram,
6896	&((mng_ptr)pFRAM));
6897	if (iRetcode)
6898	return iRetcode;
6899	#else
6900	MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
6901
6902	pFRAM->sHeader.fCleanup = mng_free_ani_fram;
6903	pFRAM->sHeader.fProcess = mng_process_ani_fram;
6904	#endif
6905
6906	pFRAM->iFramemode = 4;
6907	pFRAM->iChangedelay = 1;
6908	pFRAM->iDelay = iTicks;
6909
6910	mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
6911
6912	if (!iSource)
6913	{
6914	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6915	iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
6916	mng_free_obj_general,
6917	mng_process_ani_move,
6918	&((mng_ptr)pMOVE));
6919	if (iRetcode)
6920	return iRetcode;
6921	#else
6922	MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
6923
6924	pMOVE->sHeader.fCleanup = mng_free_ani_move;
6925	pMOVE->sHeader.fProcess = mng_process_ani_move;
6926	#endif
6927
6928	pMOVE->iFirstid = 1;
6929	pMOVE->iLastid = 1;
6930	pMOVE->iLocax = -iXoffset;
6931	pMOVE->iLocay = -iYoffset;
6932
6933	mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
6934	}
6935
6936	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6937	iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
6938	mng_free_obj_general, mng_process_ani_show,
6939	&((mng_ptr)pSHOW));
6940	if (iRetcode)
6941	return iRetcode;
6942	#else
6943	MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
6944
6945	pSHOW->sHeader.fCleanup = mng_free_ani_show;
6946	pSHOW->sHeader.fProcess = mng_process_ani_show;
6947	#endif
6948
6949	if (iSource)
6950	pSHOW->iFirstid = 0;
6951	else
6952	pSHOW->iFirstid = 1;
6953	pSHOW->iLastid = pSHOW->iFirstid;
6954
6955	mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
6956
6957	pTile += sizeof(mng_adat_tile);
6958	}
6959
6960	if (pANG->iNumplays != 1) /* create a LOOP/ENDL pair ? */
6961	{
6962	#ifdef MNG_OPTIMIZE_OBJCLEANUP
6963	iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
6964	mng_free_obj_general, mng_process_ani_endl,
6965	&((mng_ptr)pENDL));
6966	if (iRetcode)
6967	return iRetcode;
6968	#else
6969	MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
6970
6971	pENDL->sHeader.fCleanup = mng_free_ani_endl;
6972	pENDL->sHeader.fProcess = mng_process_ani_endl;
6973	#endif
6974
6975	pENDL->iLevel = 1;
6976
6977	mng_add_ani_object (pData, (mng_object_headerp)pENDL);
6978	}
6979
6980	#ifdef MNG_SUPPORT_TRACE
6981	MNG_TRACE (pData, MNG_FN_PROCESS_ANG_OBJ, MNG_LC_END);
6982	#endif
6983
6984	return MNG_NOERROR;
6985	}
6986
6987	/* ************************************************************************** */
6988
6989	#endif /* MNG_INCLUDE_ANG_PROPOSAL */
6990
6991	/* ************************************************************************** */
6992
6993	#endif /* MNG_INCLUDE_DISPLAY_PROCS */
6994
6995	/* ************************************************************************** */
6996	/* * end of file * */
6997	/* ************************************************************************** */
6998

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/3rdparty/libmng/libmng_object_prc.c

Download in other formats: