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
mng_drop_invalid_objects(mng_datap pData)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
create_obj_general(mng_datap pData,mng_size_t iObjsize,mng_cleanupobject fCleanup,mng_processobject fProcess,mng_ptr * ppObject)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
mng_free_obj_general(mng_datap pData,mng_objectp pObject)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
mng_create_imagedataobject(mng_datap pData,mng_bool bConcrete,mng_bool bViewable,mng_uint32 iWidth,mng_uint32 iHeight,mng_uint8 iBitdepth,mng_uint8 iColortype,mng_uint8 iCompression,mng_uint8 iFilter,mng_uint8 iInterlace,mng_imagedatap * ppObject)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
mng_free_imagedataobject(mng_datap pData,mng_imagedatap pImagedata)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
mng_clone_imagedataobject(mng_datap pData,mng_bool bConcrete,mng_imagedatap pSource,mng_imagedatap * ppClone)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
mng_create_imageobject(mng_datap pData,mng_uint16 iId,mng_bool bConcrete,mng_bool bVisible,mng_bool bViewable,mng_uint32 iWidth,mng_uint32 iHeight,mng_uint8 iBitdepth,mng_uint8 iColortype,mng_uint8 iCompression,mng_uint8 iFilter,mng_uint8 iInterlace,mng_int32 iPosx,mng_int32 iPosy,mng_bool bClipped,mng_int32 iClipl,mng_int32 iClipr,mng_int32 iClipt,mng_int32 iClipb,mng_imagep * ppObject)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
mng_free_imageobject(mng_datap pData,mng_imagep pImage)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
mng_find_imageobject(mng_datap pData,mng_uint16 iId)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
mng_clone_imageobject(mng_datap pData,mng_uint16 iId,mng_bool bPartial,mng_bool bVisible,mng_bool bAbstract,mng_bool bHasloca,mng_uint8 iLocationtype,mng_int32 iLocationx,mng_int32 iLocationy,mng_imagep pSource,mng_imagep * ppClone)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
mng_renum_imageobject(mng_datap pData,mng_imagep pSource,mng_uint16 iId,mng_bool bVisible,mng_bool bAbstract,mng_bool bHasloca,mng_uint8 iLocationtype,mng_int32 iLocationx,mng_int32 iLocationy)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
mng_reset_object_details(mng_datap pData,mng_imagep pImage,mng_uint32 iWidth,mng_uint32 iHeight,mng_uint8 iBitdepth,mng_uint8 iColortype,mng_uint8 iCompression,mng_uint8 iFilter,mng_uint8 iInterlace,mng_bool bResetall)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)
mng_promote_imageobject(mng_datap pData,mng_imagep pImage,mng_uint8 iBitdepth,mng_uint8 iColortype,mng_uint8 iFilltype)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
mng_magnify_imageobject(mng_datap pData,mng_imagep pImage)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
mng_colorcorrect_object(mng_datap pData,mng_imagep pImage)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
mng_add_ani_object(mng_datap pData,mng_object_headerp pObject)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
mng_create_ani_image(mng_datap pData)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
mng_free_ani_image(mng_datap pData,mng_objectp pObject)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
mng_process_ani_image(mng_datap pData,mng_objectp pObject)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
mng_create_ani_plte(mng_datap pData,mng_uint32 iEntrycount,mng_palette8ep paEntries)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
mng_free_ani_plte(mng_datap pData,mng_objectp pObject)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
mng_process_ani_plte(mng_datap pData,mng_objectp pObject)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
mng_create_ani_trns(mng_datap pData,mng_uint32 iRawlen,mng_uint8p pRawdata)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
mng_free_ani_trns(mng_datap pData,mng_objectp pObject)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
mng_process_ani_trns(mng_datap pData,mng_objectp pObject)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
mng_create_ani_gama(mng_datap pData,mng_bool bEmpty,mng_uint32 iGamma)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
mng_free_ani_gama(mng_datap pData,mng_objectp pObject)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
mng_process_ani_gama(mng_datap pData,mng_objectp pObject)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
mng_create_ani_chrm(mng_datap pData,mng_bool bEmpty,mng_uint32 iWhitepointx,mng_uint32 iWhitepointy,mng_uint32 iRedx,mng_uint32 iRedy,mng_uint32 iGreenx,mng_uint32 iGreeny,mng_uint32 iBluex,mng_uint32 iBluey)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
mng_free_ani_chrm(mng_datap pData,mng_objectp pObject)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
mng_process_ani_chrm(mng_datap pData,mng_objectp pObject)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
mng_create_ani_srgb(mng_datap pData,mng_bool bEmpty,mng_uint8 iRenderingintent)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
mng_free_ani_srgb(mng_datap pData,mng_objectp pObject)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
mng_process_ani_srgb(mng_datap pData,mng_objectp pObject)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
mng_create_ani_iccp(mng_datap pData,mng_bool bEmpty,mng_uint32 iProfilesize,mng_ptr pProfile)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
mng_free_ani_iccp(mng_datap pData,mng_objectp pObject)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
mng_process_ani_iccp(mng_datap pData,mng_objectp pObject)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
mng_create_ani_bkgd(mng_datap pData,mng_uint16 iRed,mng_uint16 iGreen,mng_uint16 iBlue)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
mng_free_ani_bkgd(mng_datap pData,mng_objectp pObject)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
mng_process_ani_bkgd(mng_datap pData,mng_objectp pObject)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
mng_create_ani_loop(mng_datap pData,mng_uint8 iLevel,mng_uint32 iRepeatcount,mng_uint8 iTermcond,mng_uint32 iItermin,mng_uint32 iItermax,mng_uint32 iCount,mng_uint32p pSignals)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
mng_free_ani_loop(mng_datap pData,mng_objectp pObject)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
mng_process_ani_loop(mng_datap pData,mng_objectp pObject)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
mng_create_ani_endl(mng_datap pData,mng_uint8 iLevel)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
mng_free_ani_endl(mng_datap pData,mng_objectp pObject)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
mng_process_ani_endl(mng_datap pData,mng_objectp pObject)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
mng_create_ani_defi(mng_datap pData)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
mng_free_ani_defi(mng_datap pData,mng_objectp pObject)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
mng_process_ani_defi(mng_datap pData,mng_objectp pObject)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
mng_create_ani_basi(mng_datap pData,mng_uint16 iRed,mng_uint16 iGreen,mng_uint16 iBlue,mng_bool bHasalpha,mng_uint16 iAlpha,mng_uint8 iViewable)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
mng_free_ani_basi(mng_datap pData,mng_objectp pObject)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
mng_process_ani_basi(mng_datap pData,mng_objectp pObject)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
mng_create_ani_clon(mng_datap pData,mng_uint16 iSourceid,mng_uint16 iCloneid,mng_uint8 iClonetype,mng_bool bHasdonotshow,mng_uint8 iDonotshow,mng_uint8 iConcrete,mng_bool bHasloca,mng_uint8 iLocatype,mng_int32 iLocax,mng_int32 iLocay)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
mng_free_ani_clon(mng_datap pData,mng_objectp pObject)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
mng_process_ani_clon(mng_datap pData,mng_objectp pObject)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
mng_create_ani_back(mng_datap pData,mng_uint16 iRed,mng_uint16 iGreen,mng_uint16 iBlue,mng_uint8 iMandatory,mng_uint16 iImageid,mng_uint8 iTile)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
mng_free_ani_back(mng_datap pData,mng_objectp pObject)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
mng_process_ani_back(mng_datap pData,mng_objectp pObject)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
mng_create_ani_fram(mng_datap pData,mng_uint8 iFramemode,mng_uint8 iChangedelay,mng_uint32 iDelay,mng_uint8 iChangetimeout,mng_uint32 iTimeout,mng_uint8 iChangeclipping,mng_uint8 iCliptype,mng_int32 iClipl,mng_int32 iClipr,mng_int32 iClipt,mng_int32 iClipb)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
mng_free_ani_fram(mng_datap pData,mng_objectp pObject)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
mng_process_ani_fram(mng_datap pData,mng_objectp pObject)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
mng_create_ani_move(mng_datap pData,mng_uint16 iFirstid,mng_uint16 iLastid,mng_uint8 iType,mng_int32 iLocax,mng_int32 iLocay)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
mng_free_ani_move(mng_datap pData,mng_objectp pObject)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
mng_process_ani_move(mng_datap pData,mng_objectp pObject)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
mng_create_ani_clip(mng_datap pData,mng_uint16 iFirstid,mng_uint16 iLastid,mng_uint8 iType,mng_int32 iClipl,mng_int32 iClipr,mng_int32 iClipt,mng_int32 iClipb)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
mng_free_ani_clip(mng_datap pData,mng_objectp pObject)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
mng_process_ani_clip(mng_datap pData,mng_objectp pObject)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
mng_create_ani_show(mng_datap pData,mng_uint16 iFirstid,mng_uint16 iLastid,mng_uint8 iMode)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
mng_free_ani_show(mng_datap pData,mng_objectp pObject)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
mng_process_ani_show(mng_datap pData,mng_objectp pObject)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
mng_create_ani_term(mng_datap pData,mng_uint8 iTermaction,mng_uint8 iIteraction,mng_uint32 iDelay,mng_uint32 iItermax)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
mng_free_ani_term(mng_datap pData,mng_objectp pObject)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
mng_process_ani_term(mng_datap pData,mng_objectp pObject)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
mng_create_ani_save(mng_datap pData)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
mng_free_ani_save(mng_datap pData,mng_objectp pObject)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
mng_process_ani_save(mng_datap pData,mng_objectp pObject)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
mng_create_ani_seek(mng_datap pData,mng_uint32 iSegmentnamesize,mng_pchar zSegmentname)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
mng_free_ani_seek(mng_datap pData,mng_objectp pObject)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
mng_process_ani_seek(mng_datap pData,mng_objectp pObject)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
mng_create_ani_dhdr(mng_datap pData,mng_uint16 iObjectid,mng_uint8 iImagetype,mng_uint8 iDeltatype,mng_uint32 iBlockwidth,mng_uint32 iBlockheight,mng_uint32 iBlockx,mng_uint32 iBlocky)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
mng_free_ani_dhdr(mng_datap pData,mng_objectp pObject)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
mng_process_ani_dhdr(mng_datap pData,mng_objectp pObject)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
mng_create_ani_prom(mng_datap pData,mng_uint8 iBitdepth,mng_uint8 iColortype,mng_uint8 iFilltype)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
mng_free_ani_prom(mng_datap pData,mng_objectp pObject)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
mng_process_ani_prom(mng_datap pData,mng_objectp pObject)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
mng_create_ani_ipng(mng_datap pData)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
mng_free_ani_ipng(mng_datap pData,mng_objectp pObject)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
mng_process_ani_ipng(mng_datap pData,mng_objectp pObject)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
mng_create_ani_ijng(mng_datap pData)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
mng_free_ani_ijng(mng_datap pData,mng_objectp pObject)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
mng_process_ani_ijng(mng_datap pData,mng_objectp pObject)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
mng_create_ani_pplt(mng_datap pData,mng_uint8 iType,mng_uint32 iCount,mng_palette8ep paIndexentries,mng_uint8p paAlphaentries,mng_uint8p paUsedentries)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
mng_free_ani_pplt(mng_datap pData,mng_objectp pObject)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
mng_process_ani_pplt(mng_datap pData,mng_objectp pObject)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
mng_create_ani_magn(mng_datap pData,mng_uint16 iFirstid,mng_uint16 iLastid,mng_uint8 iMethodX,mng_uint16 iMX,mng_uint16 iMY,mng_uint16 iML,mng_uint16 iMR,mng_uint16 iMT,mng_uint16 iMB,mng_uint8 iMethodY)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
mng_free_ani_magn(mng_datap pData,mng_objectp pObject)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
mng_process_ani_magn(mng_datap pData,mng_objectp pObject)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
mng_create_ani_past(mng_datap pData,mng_uint16 iTargetid,mng_uint8 iTargettype,mng_int32 iTargetx,mng_int32 iTargety,mng_uint32 iCount,mng_ptr pSources)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
mng_free_ani_past(mng_datap pData,mng_objectp pObject)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
mng_process_ani_past(mng_datap pData,mng_objectp pObject)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
mng_create_ani_disc(mng_datap pData,mng_uint32 iCount,mng_uint16p pIds)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
mng_free_ani_disc(mng_datap pData,mng_objectp pObject)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
mng_process_ani_disc(mng_datap pData,mng_objectp pObject)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
mng_create_event(mng_datap pData,mng_uint8 iEventtype,mng_uint8 iMasktype,mng_int32 iLeft,mng_int32 iRight,mng_int32 iTop,mng_int32 iBottom,mng_uint16 iObjectid,mng_uint8 iIndex,mng_uint32 iSegmentnamesize,mng_pchar zSegmentname)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
mng_free_event(mng_datap pData,mng_objectp pObject)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
mng_process_event(mng_datap pData,mng_objectp pObject)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
mng_create_mpng_obj(mng_datap pData,mng_uint32 iFramewidth,mng_uint32 iFrameheight,mng_uint16 iNumplays,mng_uint16 iTickspersec,mng_uint32 iFramessize,mng_ptr pFrames)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
mng_free_mpng_obj(mng_datap pData,mng_objectp pObject)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
mng_process_mpng_obj(mng_datap pData,mng_objectp pObject)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
mng_create_ang_obj(mng_datap pData,mng_uint32 iNumframes,mng_uint32 iTickspersec,mng_uint32 iNumplays,mng_uint32 iTilewidth,mng_uint32 iTileheight,mng_uint8 iInterlace,mng_uint8 iStillused)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
mng_free_ang_obj(mng_datap pData,mng_objectp pObject)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
mng_process_ang_obj(mng_datap pData,mng_objectp pObject)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
6999