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

Last change on this file was 2, checked in by dmik, 20 years ago

Imported xplatform parts of the official release 3.3.1 from Trolltech
  • Property svn:keywords set to Id
File size: 123.6 KB
Line 
1/* ************************************************************************** */
2/* * For conditions of distribution and use, * */
3/* * see copyright notice in libmng.h * */
4/* ************************************************************************** */
5/* * * */
6/* * project : libmng * */
7/* * file : libmng_object_prc.c copyright (c) 2000 G.Juyn * */
8/* * version : 1.0.2 * */
9/* * * */
10/* * purpose : Object processing routines (implementation) * */
11/* * * */
12/* * author : G.Juyn * */
13/* * web : http://www.3-t.com * */
14/* * email : mailto:info@3-t.com * */
15/* * * */
16/* * comment : implementation of the internal object processing routines * */
17/* * * */
18/* * changes : 0.5.1 - 05/08/2000 - G.Juyn * */
19/* * - changed strict-ANSI stuff * */
20/* * 0.5.1 - 05/12/2000 - G.Juyn * */
21/* * - changed trace to macro for callback error-reporting * */
22/* * * */
23/* * 0.5.2 - 05/20/2000 - G.Juyn * */
24/* * - fixed to support JNG objects * */
25/* * 0.5.2 - 05/24/2000 - G.Juyn * */
26/* * - added support for global color-chunks in animation * */
27/* * - added support for global PLTE,tRNS,bKGD in animation * */
28/* * - added SAVE & SEEK animation objects * */
29/* * 0.5.2 - 05/29/2000 - G.Juyn * */
30/* * - added initialization of framenr/layernr/playtime * */
31/* * - changed ani_object create routines not to return the * */
32/* * created object (wasn't necessary) * */
33/* * 0.5.2 - 05/30/2000 - G.Juyn * */
34/* * - added object promotion routine (PROM handling) * */
35/* * - added ani-object routines for delta-image processing * */
36/* * - added compression/filter/interlace fields to * */
37/* * object-buffer for delta-image processing * */
38/* * * */
39/* * 0.5.3 - 06/17/2000 - G.Juyn * */
40/* * - changed support for delta-image processing * */
41/* * 0.5.3 - 06/20/2000 - G.Juyn * */
42/* * - fixed some small things (as precaution) * */
43/* * 0.5.3 - 06/21/2000 - G.Juyn * */
44/* * - added processing of PLTE/tRNS & color-info for * */
45/* * delta-images in the ani_objects chain * */
46/* * 0.5.3 - 06/22/2000 - G.Juyn * */
47/* * - added support for PPLT chunk * */
48/* * * */
49/* * 0.9.1 - 07/07/2000 - G.Juyn * */
50/* * - added support for freeze/restart/resume & go_xxxx * */
51/* * 0.9.1 - 07/16/2000 - G.Juyn * */
52/* * - fixed support for mng_display() after mng_read() * */
53/* * * */
54/* * 0.9.2 - 07/29/2000 - G.Juyn * */
55/* * - fixed small bugs in display processing * */
56/* * 0.9.2 - 08/05/2000 - G.Juyn * */
57/* * - changed file-prefixes * */
58/* * * */
59/* * 0.9.3 - 08/07/2000 - G.Juyn * */
60/* * - B111300 - fixup for improved portability * */
61/* * 0.9.3 - 08/26/2000 - G.Juyn * */
62/* * - added MAGN chunk * */
63/* * 0.9.3 - 09/10/2000 - G.Juyn * */
64/* * - fixed DEFI behavior * */
65/* * 0.9.3 - 10/17/2000 - G.Juyn * */
66/* * - added valid-flag to stored objects for read() / display()* */
67/* * - added routine to discard "invalid" objects * */
68/* * 0.9.3 - 10/18/2000 - G.Juyn * */
69/* * - fixed delta-processing behavior * */
70/* * 0.9.3 - 10/19/2000 - G.Juyn * */
71/* * - added storage for pixel-/alpha-sampledepth for delta's * */
72/* * * */
73/* * 0.9.4 - 1/18/2001 - G.Juyn * */
74/* * - removed "old" MAGN methods 3 & 4 * */
75/* * - added "new" MAGN methods 3, 4 & 5 * */
76/* * * */
77/* * 0.9.5 - 1/22/2001 - G.Juyn * */
78/* * - B129681 - fixed compiler warnings SGI/Irix * */
79/* * * */
80/* * 1.0.2 - 06/23/2001 - G.Juyn * */
81/* * - added optimization option for MNG-video playback * */
82/* * * */
83/* ************************************************************************** */
84
85#include "libmng.h"
86#include "libmng_data.h"
87#include "libmng_error.h"
88#include "libmng_trace.h"
89#ifdef __BORLANDC__
90#pragma hdrstop
91#endif
92#include "libmng_memory.h"
93#include "libmng_objects.h"
94#include "libmng_display.h"
95#include "libmng_pixels.h"
96#include "libmng_object_prc.h"
97
98#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
99#pragma option -A /* force ANSI-C */
100#endif
101
102/* ************************************************************************** */
103
104#ifdef MNG_INCLUDE_DISPLAY_PROCS
105
106/* ************************************************************************** */
107/* * * */
108/* * Generic object routines * */
109/* * * */
110/* ************************************************************************** */
111
112mng_retcode drop_invalid_objects (mng_datap pData)
113{
114 mng_objectp pObject;
115 mng_objectp pNext;
116 mng_cleanupobject fCleanup;
117
118#ifdef MNG_SUPPORT_TRACE
119 MNG_TRACE (pData, MNG_FN_DROP_INVALID_OBJECTS, MNG_LC_START)
120#endif
121
122 pObject = pData->pFirstimgobj; /* get first stored image-object (if any) */
123
124 while (pObject) /* more objects to check ? */
125 {
126 pNext = ((mng_object_headerp)pObject)->pNext;
127 /* invalid ? */
128 if (!((mng_imagep)pObject)->bValid)
129 { /* call appropriate cleanup */
130 fCleanup = ((mng_object_headerp)pObject)->fCleanup;
131 fCleanup (pData, pObject);
132 }
133
134 pObject = pNext; /* neeeext */
135 }
136
137#ifdef MNG_SUPPORT_TRACE
138 MNG_TRACE (pData, MNG_FN_DROP_INVALID_OBJECTS, MNG_LC_END)
139#endif
140
141 return MNG_NOERROR;
142}
143
144/* ************************************************************************** */
145/* * * */
146/* * Image-data-object routines * */
147/* * * */
148/* * these handle the "object buffer" as defined by the MNG specification * */
149/* * * */
150/* ************************************************************************** */
151
152mng_retcode create_imagedataobject (mng_datap pData,
153 mng_bool bConcrete,
154 mng_bool bViewable,
155 mng_uint32 iWidth,
156 mng_uint32 iHeight,
157 mng_uint8 iBitdepth,
158 mng_uint8 iColortype,
159 mng_uint8 iCompression,
160 mng_uint8 iFilter,
161 mng_uint8 iInterlace,
162 mng_imagedatap *ppObject)
163{
164 mng_imagedatap pImagedata;
165 mng_uint32 iSamplesize = 0;
166
167#ifdef MNG_SUPPORT_TRACE
168 MNG_TRACE (pData, MNG_FN_CREATE_IMGDATAOBJECT, MNG_LC_START)
169#endif
170 /* get a buffer */
171 MNG_ALLOC (pData, pImagedata, sizeof (mng_imagedata))
172 /* fill the appropriate fields */
173 pImagedata->sHeader.fCleanup = (mng_cleanupobject)free_imagedataobject;
174 pImagedata->sHeader.fProcess = 0;
175 pImagedata->iRefcount = 1;
176 pImagedata->bFrozen = MNG_FALSE;
177 pImagedata->bConcrete = bConcrete;
178 pImagedata->bViewable = bViewable;
179 pImagedata->iWidth = iWidth;
180 pImagedata->iHeight = iHeight;
181 pImagedata->iBitdepth = iBitdepth;
182 pImagedata->iColortype = iColortype;
183 pImagedata->iCompression = iCompression;
184 pImagedata->iFilter = iFilter;
185 pImagedata->iInterlace = iInterlace;
186 pImagedata->iAlphabitdepth = 0;
187 pImagedata->iJHDRcompression = 0;
188 pImagedata->iJHDRinterlace = 0;
189 pImagedata->iPixelsampledepth = iBitdepth;
190 pImagedata->iAlphasampledepth = iBitdepth;
191 /* determine samplesize from color_type/bit_depth */
192 switch (iColortype) /* for < 8-bit samples we just reserve 8 bits */
193 {
194 case 0 : ; /* gray */
195 case 8 : { /* JPEG gray */
196 if (iBitdepth > 8)
197 iSamplesize = 2;
198 else
199 iSamplesize = 1;
200
201 break;
202 }
203 case 2 : ; /* rgb */
204 case 10 : { /* JPEG rgb */
205 if (iBitdepth > 8)
206 iSamplesize = 6;
207 else
208 iSamplesize = 3;
209
210 break;
211 }
212 case 3 : { /* indexed */
213 iSamplesize = 1;
214 break;
215 }
216 case 4 : ; /* gray+alpha */
217 case 12 : { /* JPEG gray+alpha */
218 if (iBitdepth > 8)
219 iSamplesize = 4;
220 else
221 iSamplesize = 2;
222
223 break;
224 }
225 case 6 : ; /* rgb+alpha */
226 case 14 : { /* JPEG rgb+alpha */
227 if (iBitdepth > 8)
228 iSamplesize = 8;
229 else
230 iSamplesize = 4;
231
232 break;
233 }
234 }
235 /* make sure we remember all this */
236 pImagedata->iSamplesize = iSamplesize;
237 pImagedata->iRowsize = iSamplesize * iWidth;
238 pImagedata->iImgdatasize = pImagedata->iRowsize * iHeight;
239
240 if (pImagedata->iImgdatasize) /* need a buffer ? */
241 { /* so allocate it */
242 MNG_ALLOCX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize)
243
244 if (!pImagedata->pImgdata) /* enough memory ? */
245 {
246 MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata))
247 MNG_ERROR (pData, MNG_OUTOFMEMORY)
248 }
249 }
250 /* check global stuff */
251 pImagedata->bHasGAMA = pData->bHasglobalGAMA;
252 pImagedata->bHasCHRM = pData->bHasglobalCHRM;
253 pImagedata->bHasSRGB = pData->bHasglobalSRGB;
254 pImagedata->bHasICCP = pData->bHasglobalICCP;
255 pImagedata->bHasBKGD = pData->bHasglobalBKGD;
256
257 if (pData->bHasglobalGAMA) /* global gAMA present ? */
258 pImagedata->iGamma = pData->iGlobalGamma;
259
260 if (pData->bHasglobalCHRM) /* global cHRM present ? */
261 {
262 pImagedata->iWhitepointx = pData->iGlobalWhitepointx;
263 pImagedata->iWhitepointy = pData->iGlobalWhitepointy;
264 pImagedata->iPrimaryredx = pData->iGlobalPrimaryredx;
265 pImagedata->iPrimaryredy = pData->iGlobalPrimaryredy;
266 pImagedata->iPrimarygreenx = pData->iGlobalPrimarygreenx;
267 pImagedata->iPrimarygreeny = pData->iGlobalPrimarygreeny;
268 pImagedata->iPrimarybluex = pData->iGlobalPrimarybluex;
269 pImagedata->iPrimarybluey = pData->iGlobalPrimarybluey;
270 }
271
272 if (pData->bHasglobalSRGB) /* glbal sRGB present ? */
273 pImagedata->iRenderingintent = pData->iGlobalRendintent;
274
275 if (pData->bHasglobalICCP) /* glbal iCCP present ? */
276 {
277 pImagedata->iProfilesize = pData->iGlobalProfilesize;
278
279 if (pImagedata->iProfilesize)
280 {
281 MNG_ALLOCX (pData, pImagedata->pProfile, pImagedata->iProfilesize)
282
283 if (!pImagedata->pProfile) /* enough memory ? */
284 {
285 MNG_FREEX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize)
286 MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata))
287 MNG_ERROR (pData, MNG_OUTOFMEMORY)
288 }
289
290 MNG_COPY (pImagedata->pProfile, pData->pGlobalProfile, pImagedata->iProfilesize)
291 }
292 }
293
294 if (pData->bHasglobalBKGD) /* global bKGD present ? */
295 {
296 pImagedata->iBKGDred = pData->iGlobalBKGDred;
297 pImagedata->iBKGDgreen = pData->iGlobalBKGDgreen;
298 pImagedata->iBKGDblue = pData->iGlobalBKGDblue;
299 }
300
301 *ppObject = pImagedata; /* return it */
302
303#ifdef MNG_SUPPORT_TRACE
304 MNG_TRACE (pData, MNG_FN_CREATE_IMGDATAOBJECT, MNG_LC_END)
305#endif
306
307 return MNG_NOERROR;
308}
309
310/* ************************************************************************** */
311
312mng_retcode free_imagedataobject (mng_datap pData,
313 mng_imagedatap pImagedata)
314{
315#ifdef MNG_SUPPORT_TRACE
316 MNG_TRACE (pData, MNG_FN_FREE_IMGDATAOBJECT, MNG_LC_START)
317#endif
318
319 if (pImagedata->iRefcount) /* decrease reference count */
320 pImagedata->iRefcount--;
321
322 if (!pImagedata->iRefcount) /* reached zero ? */
323 {
324 if (pImagedata->iProfilesize) /* stored an iCCP profile ? */
325 MNG_FREEX (pData, pImagedata->pProfile, pImagedata->iProfilesize)
326
327 if (pImagedata->iImgdatasize) /* sample-buffer present ? */
328 MNG_FREEX (pData, pImagedata->pImgdata, pImagedata->iImgdatasize)
329 /* drop the buffer */
330 MNG_FREEX (pData, pImagedata, sizeof (mng_imagedata))
331 }
332
333#ifdef MNG_SUPPORT_TRACE
334 MNG_TRACE (pData, MNG_FN_FREE_IMGDATAOBJECT, MNG_LC_END)
335#endif
336
337 return MNG_NOERROR;
338}
339
340/* ************************************************************************** */
341
342mng_retcode clone_imagedataobject (mng_datap pData,
343 mng_bool bConcrete,
344 mng_imagedatap pSource,
345 mng_imagedatap *ppClone)
346{
347 mng_imagedatap pNewdata;
348
349#ifdef MNG_SUPPORT_TRACE
350 MNG_TRACE (pData, MNG_FN_CLONE_IMGDATAOBJECT, MNG_LC_START)
351#endif
352 /* get a buffer */
353 MNG_ALLOC (pData, pNewdata, sizeof (mng_imagedata))
354 /* blatently copy the original buffer */
355 MNG_COPY (pNewdata, pSource, sizeof (mng_imagedata))
356
357 pNewdata->iRefcount = 1; /* only the reference count */
358 pNewdata->bConcrete = bConcrete; /* and concrete-flag are different */
359
360 if (pNewdata->iImgdatasize) /* sample buffer present ? */
361 {
362 MNG_ALLOCX (pData, pNewdata->pImgdata, pNewdata->iImgdatasize)
363
364 if (!pNewdata->pImgdata) /* not enough memory ? */
365 {
366 MNG_FREEX (pData, pNewdata, sizeof (mng_imagedata))
367 MNG_ERROR (pData, MNG_OUTOFMEMORY)
368 }
369 /* make a copy */
370 MNG_COPY (pNewdata->pImgdata, pSource->pImgdata, pNewdata->iImgdatasize)
371 }
372
373 if (pNewdata->iProfilesize) /* iCCP profile present ? */
374 {
375 MNG_ALLOCX (pData, pNewdata->pProfile, pNewdata->iProfilesize)
376
377 if (!pNewdata->pProfile) /* enough memory ? */
378 {
379 MNG_FREEX (pData, pNewdata, sizeof (mng_imagedata))
380 MNG_ERROR (pData, MNG_OUTOFMEMORY)
381 }
382 /* make a copy */
383 MNG_COPY (pNewdata->pProfile, pSource->pProfile, pNewdata->iProfilesize)
384 }
385
386 *ppClone = pNewdata; /* return the clone */
387
388#ifdef MNG_SUPPORT_TRACE
389 MNG_TRACE (pData, MNG_FN_CLONE_IMGDATAOBJECT, MNG_LC_END)
390#endif
391
392 return MNG_NOERROR;
393}
394
395/* ************************************************************************** */
396/* * * */
397/* * Image-object routines * */
398/* * * */
399/* * these handle the "object" as defined by the MNG specification * */
400/* * * */
401/* ************************************************************************** */
402
403mng_retcode create_imageobject (mng_datap pData,
404 mng_uint16 iId,
405 mng_bool bConcrete,
406 mng_bool bVisible,
407 mng_bool bViewable,
408 mng_uint32 iWidth,
409 mng_uint32 iHeight,
410 mng_uint8 iBitdepth,
411 mng_uint8 iColortype,
412 mng_uint8 iCompression,
413 mng_uint8 iFilter,
414 mng_uint8 iInterlace,
415 mng_int32 iPosx,
416 mng_int32 iPosy,
417 mng_bool bClipped,
418 mng_int32 iClipl,
419 mng_int32 iClipr,
420 mng_int32 iClipt,
421 mng_int32 iClipb,
422 mng_imagep *ppObject)
423{
424 mng_imagep pImage;
425 mng_imagep pPrev, pNext;
426 mng_retcode iRetcode;
427 mng_imagedatap pImgbuf;
428
429#ifdef MNG_SUPPORT_TRACE
430 MNG_TRACE (pData, MNG_FN_CREATE_IMGOBJECT, MNG_LC_START)
431#endif
432 /* get a buffer */
433 MNG_ALLOC (pData, pImage, sizeof (mng_image))
434 /* now get a new "object buffer" */
435 iRetcode = create_imagedataobject (pData, bConcrete, bViewable,
436 iWidth, iHeight, iBitdepth, iColortype,
437 iCompression, iFilter, iInterlace,
438 &pImgbuf);
439
440 if (iRetcode) /* on error bail out */
441 {
442 MNG_FREEX (pData, pImage, sizeof (mng_image))
443 return iRetcode;
444 }
445 /* fill the appropriate fields */
446 pImage->sHeader.fCleanup = (mng_cleanupobject)free_imageobject;
447 pImage->sHeader.fProcess = 0;
448 pImage->iId = iId;
449 pImage->bFrozen = MNG_FALSE;
450 pImage->bVisible = bVisible;
451 pImage->bViewable = bViewable;
452 pImage->bValid = (mng_bool)((pData->bDisplaying) &&
453 (pData->bRunning ) &&
454 (!pData->bFreezing ) );
455 pImage->iPosx = iPosx;
456 pImage->iPosy = iPosy;
457 pImage->bClipped = bClipped;
458 pImage->iClipl = iClipl;
459 pImage->iClipr = iClipr;
460 pImage->iClipt = iClipt;
461 pImage->iClipb = iClipb;
462 pImage->iMAGN_MethodX = 0;
463 pImage->iMAGN_MethodY = 0;
464 pImage->iMAGN_MX = 0;
465 pImage->iMAGN_MY = 0;
466 pImage->iMAGN_ML = 0;
467 pImage->iMAGN_MR = 0;
468 pImage->iMAGN_MT = 0;
469 pImage->iMAGN_MB = 0;
470 pImage->pImgbuf = pImgbuf;
471
472 if (iId) /* only if not object 0 ! */
473 { /* find previous lower object-id */
474 pPrev = (mng_imagep)pData->pLastimgobj;
475
476 while ((pPrev) && (pPrev->iId > iId))
477 pPrev = (mng_imagep)pPrev->sHeader.pPrev;
478
479 if (pPrev) /* found it ? */
480 {
481 pImage->sHeader.pPrev = pPrev; /* than link it in place */
482 pImage->sHeader.pNext = pPrev->sHeader.pNext;
483 pPrev->sHeader.pNext = pImage;
484 }
485 else /* if not found, it becomes the first ! */
486 {
487 pImage->sHeader.pNext = pData->pFirstimgobj;
488 pData->pFirstimgobj = pImage;
489 }
490
491 pNext = (mng_imagep)pImage->sHeader.pNext;
492
493 if (pNext)
494 pNext->sHeader.pPrev = pImage;
495 else
496 pData->pLastimgobj = pImage;
497
498 }
499
500 *ppObject = pImage; /* and return the new buffer */
501
502#ifdef MNG_SUPPORT_TRACE
503 MNG_TRACE (pData, MNG_FN_CREATE_IMGOBJECT, MNG_LC_END)
504#endif
505
506 return MNG_NOERROR; /* okido */
507}
508
509/* ************************************************************************** */
510
511mng_retcode free_imageobject (mng_datap pData,
512 mng_imagep pImage)
513{
514 mng_retcode iRetcode;
515 mng_imagep pPrev = pImage->sHeader.pPrev;
516 mng_imagep pNext = pImage->sHeader.pNext;
517 mng_imagedatap pImgbuf = pImage->pImgbuf;
518
519#ifdef MNG_SUPPORT_TRACE
520 MNG_TRACE (pData, MNG_FN_FREE_IMGOBJECT, MNG_LC_START)
521#endif
522
523 if (pImage->iId) /* not for object 0 */
524 {
525 if (pPrev) /* unlink from the list first ! */
526 pPrev->sHeader.pNext = pImage->sHeader.pNext;
527 else
528 pData->pFirstimgobj = pImage->sHeader.pNext;
529
530 if (pNext)
531 pNext->sHeader.pPrev = pImage->sHeader.pPrev;
532 else
533 pData->pLastimgobj = pImage->sHeader.pPrev;
534
535 }
536 /* unlink the image-data buffer */
537 iRetcode = free_imagedataobject (pData, pImgbuf);
538 /* drop it's own buffer */
539 MNG_FREEX (pData, pImage, sizeof (mng_image))
540
541#ifdef MNG_SUPPORT_TRACE
542 MNG_TRACE (pData, MNG_FN_FREE_IMGOBJECT, MNG_LC_END)
543#endif
544
545 return iRetcode;
546}
547
548/* ************************************************************************** */
549
550mng_imagep find_imageobject (mng_datap pData,
551 mng_uint16 iId)
552{
553 mng_imagep pImage = (mng_imagep)pData->pFirstimgobj;
554
555#ifdef MNG_SUPPORT_TRACE
556 MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_START)
557#endif
558 /* look up the right id */
559 while ((pImage) && (pImage->iId != iId))
560 pImage = (mng_imagep)pImage->sHeader.pNext;
561
562#ifdef MNG_SUPPORT_TRACE
563 MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_END)
564#endif
565
566 return pImage;
567}
568
569/* ************************************************************************** */
570
571mng_retcode clone_imageobject (mng_datap pData,
572 mng_uint16 iId,
573 mng_bool bPartial,
574 mng_bool bVisible,
575 mng_bool bAbstract,
576 mng_bool bHasloca,
577 mng_uint8 iLocationtype,
578 mng_int32 iLocationx,
579 mng_int32 iLocationy,
580 mng_imagep pSource,
581 mng_imagep *ppClone)
582{
583 mng_imagep pNew;
584 mng_imagep pPrev, pNext;
585 mng_retcode iRetcode;
586 mng_imagedatap pImgbuf;
587
588#ifdef MNG_SUPPORT_TRACE
589 MNG_TRACE (pData, MNG_FN_CLONE_IMGOBJECT, MNG_LC_START)
590#endif
591
592 if ((pSource->iId) && /* needs magnification ? */
593 ((pSource->iMAGN_MethodX) || (pSource->iMAGN_MethodY)))
594 {
595 iRetcode = magnify_imageobject (pData, pSource);
596
597 if (iRetcode) /* on error bail out */
598 return iRetcode;
599 }
600 /* get a buffer */
601 MNG_ALLOC (pData, pNew, sizeof (mng_image))
602 /* fill or copy the appropriate fields */
603 pNew->sHeader.fCleanup = (mng_cleanupobject)free_imageobject;
604 pNew->sHeader.fProcess = 0;
605 pNew->iId = iId;
606 pNew->bFrozen = MNG_FALSE;
607 pNew->bVisible = bVisible;
608 pNew->bViewable = pSource->bViewable;
609
610 if (bHasloca) /* location info available ? */
611 {
612 if (iLocationtype == 0) /* absolute position ? */
613 {
614 pNew->iPosx = iLocationx;
615 pNew->iPosy = iLocationy;
616 }
617 else /* relative */
618 {
619 pNew->iPosx = pSource->iPosx + iLocationx;
620 pNew->iPosy = pSource->iPosy + iLocationy;
621 }
622 }
623 else /* copy from source */
624 {
625 pNew->iPosx = pSource->iPosx;
626 pNew->iPosy = pSource->iPosy;
627 }
628 /* copy clipping info */
629 pNew->bClipped = pSource->bClipped;
630 pNew->iClipl = pSource->iClipl;
631 pNew->iClipr = pSource->iClipr;
632 pNew->iClipt = pSource->iClipt;
633 pNew->iClipb = pSource->iClipb;
634 /* copy magnification info */
635 pNew->iMAGN_MethodX = pSource->iMAGN_MethodX;
636 pNew->iMAGN_MethodY = pSource->iMAGN_MethodY;
637 pNew->iMAGN_MX = pSource->iMAGN_MX;
638 pNew->iMAGN_MY = pSource->iMAGN_MY;
639 pNew->iMAGN_ML = pSource->iMAGN_ML;
640 pNew->iMAGN_MR = pSource->iMAGN_MR;
641 pNew->iMAGN_MT = pSource->iMAGN_MT;
642 pNew->iMAGN_MB = pSource->iMAGN_MB;
643
644 if (iId) /* not for object 0 */
645 { /* find previous lower object-id */
646 pPrev = (mng_imagep)pData->pLastimgobj;
647 while ((pPrev) && (pPrev->iId > iId))
648 pPrev = (mng_imagep)pPrev->sHeader.pPrev;
649
650 if (pPrev) /* found it ? */
651 {
652 pNew->sHeader.pPrev = pPrev; /* than link it in place */
653 pNew->sHeader.pNext = pPrev->sHeader.pNext;
654 pPrev->sHeader.pNext = pNew;
655 }
656 else /* if not found, it becomes the first ! */
657 {
658 pNew->sHeader.pNext = pData->pFirstimgobj;
659 pData->pFirstimgobj = pNew;
660 }
661
662 pNext = (mng_imagep)pNew->sHeader.pNext;
663
664 if (pNext)
665 pNext->sHeader.pPrev = pNew;
666 else
667 pData->pLastimgobj = pNew;
668
669 }
670
671 if (bPartial) /* partial clone ? */
672 {
673 pNew->pImgbuf = pSource->pImgbuf; /* use the same object buffer */
674 pNew->pImgbuf->iRefcount++; /* and increase the reference count */
675 }
676 else /* create a full clone ! */
677 {
678 mng_bool bConcrete = MNG_FALSE; /* it's abstract by default (?) */
679
680 if (!bAbstract) /* determine concreteness from source ? */
681 bConcrete = pSource->pImgbuf->bConcrete;
682 /* create a full clone ! */
683 iRetcode = clone_imagedataobject (pData, bConcrete, pSource->pImgbuf, &pImgbuf);
684
685 if (iRetcode) /* on error bail out */
686 {
687 MNG_FREEX (pData, pNew, sizeof (mng_image))
688 return iRetcode;
689 }
690
691 pNew->pImgbuf = pImgbuf; /* and remember it */
692 }
693
694 *ppClone = pNew; /* return it */
695
696#ifdef MNG_SUPPORT_TRACE
697 MNG_TRACE (pData, MNG_FN_CLONE_IMGOBJECT, MNG_LC_END)
698#endif
699
700 return MNG_NOERROR;
701}
702
703/* ************************************************************************** */
704
705mng_retcode renum_imageobject (mng_datap pData,
706 mng_imagep pSource,
707 mng_uint16 iId,
708 mng_bool bVisible,
709 mng_bool bAbstract,
710 mng_bool bHasloca,
711 mng_uint8 iLocationtype,
712 mng_int32 iLocationx,
713 mng_int32 iLocationy)
714{
715 mng_imagep pPrev, pNext;
716
717#ifdef MNG_SUPPORT_TRACE
718 MNG_TRACE (pData, MNG_FN_RENUM_IMGOBJECT, MNG_LC_START)
719#endif
720
721 pSource->bVisible = bVisible; /* store the new visibility */
722
723 if (bHasloca) /* location info available ? */
724 {
725 if (iLocationtype == 0) /* absolute position ? */
726 {
727 pSource->iPosx = iLocationx;
728 pSource->iPosy = iLocationy;
729 }
730 else /* relative */
731 {
732 pSource->iPosx = pSource->iPosx + iLocationx;
733 pSource->iPosy = pSource->iPosy + iLocationy;
734 }
735 }
736
737 if (iId) /* not for object 0 */
738 { /* find previous lower object-id */
739 pPrev = (mng_imagep)pData->pLastimgobj;
740 while ((pPrev) && (pPrev->iId > iId))
741 pPrev = (mng_imagep)pPrev->sHeader.pPrev;
742 /* different from current ? */
743 if (pPrev != (mng_imagep)pSource->sHeader.pPrev)
744 {
745 if (pSource->sHeader.pPrev) /* unlink from current position !! */
746 ((mng_imagep)pSource->sHeader.pPrev)->sHeader.pNext = pSource->sHeader.pNext;
747 else
748 pData->pFirstimgobj = pSource->sHeader.pNext;
749
750 if (pSource->sHeader.pNext)
751 ((mng_imagep)pSource->sHeader.pNext)->sHeader.pPrev = pSource->sHeader.pPrev;
752 else
753 pData->pLastimgobj = pSource->sHeader.pPrev;
754
755 if (pPrev) /* found the previous ? */
756 { /* than link it in place */
757 pSource->sHeader.pPrev = pPrev;
758 pSource->sHeader.pNext = pPrev->sHeader.pNext;
759 pPrev->sHeader.pNext = pSource;
760 }
761 else /* if not found, it becomes the first ! */
762 {
763 pSource->sHeader.pNext = pData->pFirstimgobj;
764 pData->pFirstimgobj = pSource;
765 }
766
767 pNext = (mng_imagep)pSource->sHeader.pNext;
768
769 if (pNext)
770 pNext->sHeader.pPrev = pSource;
771 else
772 pData->pLastimgobj = pSource;
773
774 }
775 }
776
777 pSource->iId = iId; /* now set the new id! */
778
779 if (bAbstract) /* force it to abstract ? */
780 pSource->pImgbuf->bConcrete = MNG_FALSE;
781
782#ifdef MNG_SUPPORT_TRACE
783 MNG_TRACE (pData, MNG_FN_RENUM_IMGOBJECT, MNG_LC_END)
784#endif
785
786 return MNG_NOERROR;
787}
788
789/* ************************************************************************** */
790
791mng_retcode reset_object_details (mng_datap pData,
792 mng_imagep pImage,
793 mng_uint32 iWidth,
794 mng_uint32 iHeight,
795 mng_uint8 iBitdepth,
796 mng_uint8 iColortype,
797 mng_uint8 iCompression,
798 mng_uint8 iFilter,
799 mng_uint8 iInterlace,
800 mng_bool bResetall)
801{
802 mng_imagedatap pBuf = pImage->pImgbuf;
803 mng_uint32 iSamplesize = 0;
804 mng_uint32 iRowsize;
805 mng_uint32 iImgdatasize;
806
807#ifdef MNG_SUPPORT_TRACE
808 MNG_TRACE (pData, MNG_FN_RESET_OBJECTDETAILS, MNG_LC_START)
809#endif
810
811 pBuf->iWidth = iWidth; /* set buffer characteristics */
812 pBuf->iHeight = iHeight;
813 pBuf->iBitdepth = iBitdepth;
814 pBuf->iColortype = iColortype;
815 pBuf->iCompression = iCompression;
816 pBuf->iFilter = iFilter;
817 pBuf->iInterlace = iInterlace;
818 pBuf->iAlphabitdepth = 0;
819 /* determine samplesize from color_type/bit_depth */
820 switch (iColortype) /* for < 8-bit samples we just reserve 8 bits */
821 {
822 case 0 : ; /* gray */
823 case 8 : { /* JPEG gray */
824 if (iBitdepth > 8)
825 iSamplesize = 2;
826 else
827 iSamplesize = 1;
828
829 break;
830 }
831 case 2 : ; /* rgb */
832 case 10 : { /* JPEG rgb */
833 if (iBitdepth > 8)
834 iSamplesize = 6;
835 else
836 iSamplesize = 3;
837
838 break;
839 }
840 case 3 : { /* indexed */
841 iSamplesize = 1;
842 break;
843 }
844 case 4 : ; /* gray+alpha */
845 case 12 : { /* JPEG gray+alpha */
846 if (iBitdepth > 8)
847 iSamplesize = 4;
848 else
849 iSamplesize = 2;
850
851 break;
852 }
853 case 6 : ; /* rgb+alpha */
854 case 14 : { /* JPEG rgb+alpha */
855 if (iBitdepth > 8)
856 iSamplesize = 8;
857 else
858 iSamplesize = 4;
859
860 break;
861 }
862 }
863
864 iRowsize = iSamplesize * iWidth;
865 iImgdatasize = iRowsize * iHeight;
866 /* buffer size changed ? */
867 if (iImgdatasize != pBuf->iImgdatasize)
868 { /* drop the old one */
869 MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize)
870
871 if (iImgdatasize) /* allocate new sample-buffer ? */
872 MNG_ALLOC (pData, pBuf->pImgdata, iImgdatasize)
873 }
874
875 pBuf->iSamplesize = iSamplesize; /* remember new sizes */
876 pBuf->iRowsize = iRowsize;
877 pBuf->iImgdatasize = iImgdatasize;
878 /* dimension set and clipping not ? */
879 if ((iWidth) && (iHeight) && (!pImage->bClipped))
880 {
881 pImage->iClipl = 0; /* set clipping to dimension by default */
882 pImage->iClipr = iWidth;
883 pImage->iClipt = 0;
884 pImage->iClipb = iHeight;
885 }
886
887 if (pImage->iId) /* reset magnification info ? */
888 {
889 pImage->iMAGN_MethodX = 0;
890 pImage->iMAGN_MethodY = 0;
891 pImage->iMAGN_MX = 0;
892 pImage->iMAGN_MY = 0;
893 pImage->iMAGN_ML = 0;
894 pImage->iMAGN_MR = 0;
895 pImage->iMAGN_MT = 0;
896 pImage->iMAGN_MB = 0;
897 }
898
899 if (bResetall) /* reset the other characteristics ? */
900 {
901 pBuf->bHasPLTE = MNG_FALSE;
902 pBuf->bHasTRNS = MNG_FALSE;
903 pBuf->bHasGAMA = pData->bHasglobalGAMA;
904 pBuf->bHasCHRM = pData->bHasglobalCHRM;
905 pBuf->bHasSRGB = pData->bHasglobalSRGB;
906 pBuf->bHasICCP = pData->bHasglobalICCP;
907 pBuf->bHasBKGD = pData->bHasglobalBKGD;
908
909 if (pBuf->iProfilesize) /* drop possibly old ICC profile */
910 {
911 MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize)
912 pBuf->iProfilesize = 0;
913 }
914
915 if (pData->bHasglobalGAMA) /* global gAMA present ? */
916 pBuf->iGamma = pData->iGlobalGamma;
917
918 if (pData->bHasglobalCHRM) /* global cHRM present ? */
919 {
920 pBuf->iWhitepointx = pData->iGlobalWhitepointx;
921 pBuf->iWhitepointy = pData->iGlobalWhitepointy;
922 pBuf->iPrimaryredx = pData->iGlobalPrimaryredx;
923 pBuf->iPrimaryredy = pData->iGlobalPrimaryredy;
924 pBuf->iPrimarygreenx = pData->iGlobalPrimarygreenx;
925 pBuf->iPrimarygreeny = pData->iGlobalPrimarygreeny;
926 pBuf->iPrimarybluex = pData->iGlobalPrimarybluex;
927 pBuf->iPrimarybluey = pData->iGlobalPrimarybluey;
928 }
929
930 if (pData->bHasglobalSRGB) /* global sRGB present ? */
931 pBuf->iRenderingintent = pData->iGlobalRendintent;
932
933 if (pData->bHasglobalICCP) /* global iCCP present ? */
934 {
935 if (pData->iGlobalProfilesize)
936 {
937 MNG_ALLOC (pData, pBuf->pProfile, pData->iGlobalProfilesize)
938 MNG_COPY (pBuf->pProfile, pData->pGlobalProfile, pData->iGlobalProfilesize)
939 }
940
941 pBuf->iProfilesize = pData->iGlobalProfilesize;
942 }
943
944 if (pData->bHasglobalBKGD) /* global bKGD present ? */
945 {
946 pBuf->iBKGDred = pData->iGlobalBKGDred;
947 pBuf->iBKGDgreen = pData->iGlobalBKGDgreen;
948 pBuf->iBKGDblue = pData->iGlobalBKGDblue;
949 }
950 }
951
952#ifdef MNG_SUPPORT_TRACE
953 MNG_TRACE (pData, MNG_FN_RESET_OBJECTDETAILS, MNG_LC_END)
954#endif
955
956 return MNG_NOERROR;
957}
958
959/* ************************************************************************** */
960
961mng_retcode promote_imageobject (mng_datap pData,
962 mng_imagep pImage,
963 mng_uint8 iBitdepth,
964 mng_uint8 iColortype,
965 mng_uint8 iFilltype)
966{
967 mng_uint8p pNewbuf;
968 mng_uint32 iNewbufsize;
969 mng_uint32 iNewrowsize;
970 mng_uint32 iNewsamplesize;
971 mng_uint32 iX, iY;
972 mng_uint8p pSrcline, pDstline;
973 mng_uint8 iB;
974 mng_imagedatap pBuf = pImage->pImgbuf;
975 mng_uint32 iW = pBuf->iWidth;
976 mng_uint32 iH = pBuf->iHeight;
977
978#ifdef MNG_SUPPORT_TRACE
979 MNG_TRACE (pData, MNG_FN_PROMOTE_IMGOBJECT, MNG_LC_START)
980#endif
981
982 if ((pBuf->iColortype == 3) && (iColortype == 2))
983 { /* indexed -> rgb */
984 iNewsamplesize = 3;
985 iNewrowsize = iW * iNewsamplesize;
986 iNewbufsize = iH * iNewrowsize;
987
988 MNG_ALLOC (pData, pNewbuf, iNewbufsize)
989
990 pSrcline = pBuf->pImgdata;
991 pDstline = pNewbuf;
992
993 for (iY = 0; iY < iH; iY++)
994 {
995 for (iX = 0; iX < iW; iX++)
996 {
997 iB = *pSrcline;
998
999 if ((mng_uint32)iB < pBuf->iPLTEcount)
1000 {
1001 *pDstline = pBuf->aPLTEentries [iB].iRed;
1002 *(pDstline+1) = pBuf->aPLTEentries [iB].iGreen;
1003 *(pDstline+2) = pBuf->aPLTEentries [iB].iBlue;
1004 }
1005
1006 pSrcline++;
1007 pDstline += 3;
1008 }
1009 }
1010
1011 MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize)
1012
1013 pBuf->iBitdepth = iBitdepth;
1014 pBuf->iColortype = iColortype;
1015 pBuf->iSamplesize = iNewsamplesize;
1016 pBuf->iRowsize = iNewrowsize;
1017 pBuf->iImgdatasize = iNewbufsize;
1018 pBuf->pImgdata = pNewbuf;
1019 pBuf->bHasPLTE = MNG_FALSE;
1020 pBuf->bHasTRNS = MNG_FALSE;
1021 }
1022 else
1023 if ((pBuf->iColortype == 3) && (iColortype == 6))
1024 { /* indexed -> rgba */
1025 iNewsamplesize = 4;
1026 iNewrowsize = iW * iNewsamplesize;
1027 iNewbufsize = iH * iNewrowsize;
1028
1029 MNG_ALLOC (pData, pNewbuf, iNewbufsize)
1030
1031 pSrcline = pBuf->pImgdata;
1032 pDstline = pNewbuf;
1033
1034 for (iY = 0; iY < iH; iY++)
1035 {
1036 for (iX = 0; iX < iW; iX++)
1037 {
1038 iB = *pSrcline;
1039
1040 if ((mng_uint32)iB < pBuf->iPLTEcount)
1041 {
1042 *pDstline = pBuf->aPLTEentries [iB].iRed;
1043 *(pDstline+1) = pBuf->aPLTEentries [iB].iGreen;
1044 *(pDstline+2) = pBuf->aPLTEentries [iB].iBlue;
1045
1046 if ((mng_uint32)iB < pBuf->iTRNScount)
1047 *(pDstline+3) = pBuf->aTRNSentries [iB];
1048 else
1049 *(pDstline+3) = 255;
1050 }
1051
1052 pSrcline++;
1053 pDstline += 4;
1054 }
1055 }
1056
1057 MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize)
1058
1059 pBuf->iBitdepth = iBitdepth;
1060 pBuf->iColortype = iColortype;
1061 pBuf->iSamplesize = iNewsamplesize;
1062 pBuf->iRowsize = iNewrowsize;
1063 pBuf->iImgdatasize = iNewbufsize;
1064 pBuf->pImgdata = pNewbuf;
1065 pBuf->bHasPLTE = MNG_FALSE;
1066 pBuf->bHasTRNS = MNG_FALSE;
1067 }
1068 else
1069 {
1070
1071 /* TODO: other promotion */
1072
1073 }
1074
1075#ifdef MNG_SUPPORT_TRACE
1076 MNG_TRACE (pData, MNG_FN_PROMOTE_IMGOBJECT, MNG_LC_END)
1077#endif
1078
1079 return MNG_NOERROR;
1080}
1081
1082/* ************************************************************************** */
1083
1084mng_retcode magnify_imageobject (mng_datap pData,
1085 mng_imagep pImage)
1086{
1087 mng_uint8p pNewdata;
1088 mng_uint8p pSrcline1;
1089 mng_uint8p pSrcline2;
1090 mng_uint8p pTempline;
1091 mng_uint8p pDstline;
1092 mng_uint32 iNewrowsize;
1093 mng_uint32 iNewsize;
1094 mng_uint32 iY;
1095 mng_int32 iS, iM;
1096 mng_retcode iRetcode;
1097
1098 mng_imagedatap pBuf = pImage->pImgbuf;
1099 mng_uint32 iNewW = pBuf->iWidth;
1100 mng_uint32 iNewH = pBuf->iHeight;
1101 mng_magnify_x fMagnifyX = MNG_NULL;
1102 mng_magnify_y fMagnifyY = MNG_NULL;
1103
1104#ifdef MNG_SUPPORT_TRACE
1105 MNG_TRACE (pData, MNG_FN_MAGNIFY_IMGOBJECT, MNG_LC_START)
1106#endif
1107
1108 if (pBuf->iColortype == 3) /* indexed color ? */
1109 { /* concrete buffer ? */
1110 if ((pBuf->bConcrete) && (pImage->iId))
1111 MNG_ERROR (pData, MNG_INVALIDCOLORTYPE)
1112
1113 if (pBuf->iTRNScount) /* with transparency ? */
1114 iRetcode = promote_imageobject (pData, pImage, 8, 6, 0);
1115 else
1116 iRetcode = promote_imageobject (pData, pImage, 8, 2, 0);
1117
1118 if (iRetcode) /* on error bail out */
1119 return iRetcode;
1120 }
1121
1122 if (pImage->iMAGN_MethodX) /* determine new width */
1123 {
1124 if (pImage->iMAGN_MethodX == 1)
1125 {
1126 iNewW = pImage->iMAGN_ML;
1127 if (pBuf->iWidth > 1)
1128 iNewW = iNewW + pImage->iMAGN_MR;
1129 if (pBuf->iWidth > 2)
1130 iNewW = iNewW + (pBuf->iWidth - 2) * (pImage->iMAGN_MX);
1131 }
1132 else
1133 {
1134 iNewW = pBuf->iWidth + pImage->iMAGN_ML - 1;
1135 if (pBuf->iWidth > 2)
1136 iNewW = iNewW + pImage->iMAGN_MR - 1;
1137 if (pBuf->iWidth > 3)
1138 iNewW = iNewW + (pBuf->iWidth - 3) * (pImage->iMAGN_MX - 1);
1139 }
1140 }
1141
1142 if (pImage->iMAGN_MethodY) /* determine new height */
1143 {
1144 if (pImage->iMAGN_MethodY == 1)
1145 {
1146 iNewH = pImage->iMAGN_MT;
1147 if (pBuf->iHeight > 1)
1148 iNewH = iNewH + pImage->iMAGN_ML;
1149 if (pBuf->iHeight > 2)
1150 iNewH = iNewH + (pBuf->iHeight - 2) * (pImage->iMAGN_MY);
1151 }
1152 else
1153 {
1154 iNewH = pBuf->iHeight + pImage->iMAGN_MT - 1;
1155 if (pBuf->iHeight > 2)
1156 iNewH = iNewH + pImage->iMAGN_MB - 1;
1157 if (pBuf->iHeight > 3)
1158 iNewH = iNewH + (pBuf->iHeight - 3) * (pImage->iMAGN_MY - 1);
1159 }
1160 }
1161 /* get new buffer */
1162 iNewrowsize = iNewW * pBuf->iSamplesize;
1163 iNewsize = iNewH * iNewrowsize;
1164
1165 MNG_ALLOC (pData, pNewdata, iNewsize);
1166
1167 switch (pBuf->iColortype) /* determine magnification routines */
1168 {
1169 case 0 : ;
1170 case 8 : {
1171 if (pBuf->iBitdepth <= 8)
1172 {
1173 switch (pImage->iMAGN_MethodX)
1174 {
1175 case 1 : { fMagnifyX = magnify_g8_x1; break; }
1176 case 2 : { fMagnifyX = magnify_g8_x2; break; }
1177 case 3 : { fMagnifyX = magnify_g8_x3; break; }
1178 case 4 : { fMagnifyX = magnify_g8_x2; break; }
1179 case 5 : { fMagnifyX = magnify_g8_x3; break; }
1180 }
1181
1182 switch (pImage->iMAGN_MethodY)
1183 {
1184 case 1 : { fMagnifyY = magnify_g8_y1; break; }
1185 case 2 : { fMagnifyY = magnify_g8_y2; break; }
1186 case 3 : { fMagnifyY = magnify_g8_y3; break; }
1187 case 4 : { fMagnifyY = magnify_g8_y2; break; }
1188 case 5 : { fMagnifyY = magnify_g8_y3; break; }
1189 }
1190 }
1191 else
1192 {
1193
1194 /* TODO: magnify 16-bit */
1195
1196 }
1197
1198 break;
1199 }
1200
1201 case 2 : ;
1202 case 10 : {
1203 if (pBuf->iBitdepth <= 8)
1204 {
1205 switch (pImage->iMAGN_MethodX)
1206 {
1207 case 1 : { fMagnifyX = magnify_rgb8_x1; break; }
1208 case 2 : { fMagnifyX = magnify_rgb8_x2; break; }
1209 case 3 : { fMagnifyX = magnify_rgb8_x3; break; }
1210 case 4 : { fMagnifyX = magnify_rgb8_x2; break; }
1211 case 5 : { fMagnifyX = magnify_rgb8_x3; break; }
1212 }
1213
1214 switch (pImage->iMAGN_MethodY)
1215 {
1216 case 1 : { fMagnifyY = magnify_rgb8_y1; break; }
1217 case 2 : { fMagnifyY = magnify_rgb8_y2; break; }
1218 case 3 : { fMagnifyY = magnify_rgb8_y3; break; }
1219 case 4 : { fMagnifyY = magnify_rgb8_y2; break; }
1220 case 5 : { fMagnifyY = magnify_rgb8_y3; break; }
1221 }
1222 }
1223 else
1224 {
1225
1226 /* TODO: magnify 16-bit */
1227
1228 }
1229
1230 break;
1231 }
1232
1233 case 4 : ;
1234 case 12 : {
1235 if (pBuf->iBitdepth <= 8)
1236 {
1237 switch (pImage->iMAGN_MethodX)
1238 {
1239 case 1 : { fMagnifyX = magnify_ga8_x1; break; }
1240 case 2 : { fMagnifyX = magnify_ga8_x2; break; }
1241 case 3 : { fMagnifyX = magnify_ga8_x3; break; }
1242 case 4 : { fMagnifyX = magnify_ga8_x4; break; }
1243 case 5 : { fMagnifyX = magnify_ga8_x5; break; }
1244 }
1245
1246 switch (pImage->iMAGN_MethodY)
1247 {
1248 case 1 : { fMagnifyY = magnify_ga8_y1; break; }
1249 case 2 : { fMagnifyY = magnify_ga8_y2; break; }
1250 case 3 : { fMagnifyY = magnify_ga8_y3; break; }
1251 case 4 : { fMagnifyY = magnify_ga8_y4; break; }
1252 case 5 : { fMagnifyY = magnify_ga8_y5; break; }
1253 }
1254 }
1255 else
1256 {
1257
1258 /* TODO: magnify 16-bit */
1259
1260 }
1261
1262 break;
1263 }
1264
1265 case 6 : ;
1266 case 14 : {
1267 if (pBuf->iBitdepth <= 8)
1268 {
1269 switch (pImage->iMAGN_MethodX)
1270 {
1271 case 1 : { fMagnifyX = magnify_rgba8_x1; break; }
1272 case 2 : { fMagnifyX = magnify_rgba8_x2; break; }
1273 case 3 : { fMagnifyX = magnify_rgba8_x3; break; }
1274 case 4 : { fMagnifyX = magnify_rgba8_x4; break; }
1275 case 5 : { fMagnifyX = magnify_rgba8_x5; break; }
1276 }
1277
1278 switch (pImage->iMAGN_MethodY)
1279 {
1280 case 1 : { fMagnifyY = magnify_rgba8_y1; break; }
1281 case 2 : { fMagnifyY = magnify_rgba8_y2; break; }
1282 case 3 : { fMagnifyY = magnify_rgba8_y3; break; }
1283 case 4 : { fMagnifyY = magnify_rgba8_y4; break; }
1284 case 5 : { fMagnifyY = magnify_rgba8_y5; break; }
1285 }
1286 }
1287 else
1288 {
1289
1290 /* TODO: magnify 16-bit */
1291
1292 }
1293
1294 break;
1295 }
1296 }
1297
1298 pSrcline1 = pBuf->pImgdata; /* initialize row-loop variables */
1299 pDstline = pNewdata;
1300 /* allocate temporary row */
1301 MNG_ALLOC (pData, pTempline, iNewrowsize)
1302
1303 for (iY = 0; iY < pBuf->iHeight; iY++)
1304 {
1305 pSrcline2 = pSrcline1 + pBuf->iRowsize;
1306
1307 if (fMagnifyX) /* magnifying in X-direction ? */
1308 {
1309 iRetcode = fMagnifyX (pData, pImage->iMAGN_MX,
1310 pImage->iMAGN_ML, pImage->iMAGN_MR,
1311 pBuf->iWidth, pSrcline1, pDstline);
1312
1313 if (iRetcode) /* on error bail out */
1314 {
1315 MNG_FREEX (pData, pTempline, iNewrowsize)
1316 MNG_FREEX (pData, pNewdata, iNewsize)
1317 return iRetcode;
1318 }
1319 }
1320 else
1321 {
1322 MNG_COPY (pDstline, pSrcline1, iNewrowsize)
1323 }
1324
1325 pDstline += iNewrowsize;
1326 /* magnifying in Y-direction ? */
1327 if ((fMagnifyY) &&
1328 ((iY < pBuf->iHeight - 1) || (pBuf->iHeight == 1) || (pImage->iMAGN_MethodY == 1)))
1329 {
1330 if (iY == 0) /* first interval ? */
1331 {
1332 if (pBuf->iHeight == 1) /* single row ? */
1333 pSrcline2 = MNG_NULL;
1334
1335 iM = (mng_int32)pImage->iMAGN_MT;
1336 }
1337 else /* last interval ? */
1338 if (((pImage->iMAGN_MethodY == 1) && (iY == (pBuf->iHeight - 1))) ||
1339 ((pImage->iMAGN_MethodY != 1) && (iY == (pBuf->iHeight - 2))) )
1340 iM = (mng_int32)pImage->iMAGN_MB;
1341 else /* middle interval */
1342 iM = (mng_int32)pImage->iMAGN_MY;
1343
1344 for (iS = 1; iS < iM; iS++)
1345 {
1346 iRetcode = fMagnifyY (pData, iS, iM, pBuf->iWidth,
1347 pSrcline1, pSrcline2, pTempline);
1348
1349 if (iRetcode) /* on error bail out */
1350 {
1351 MNG_FREEX (pData, pTempline, iNewrowsize)
1352 MNG_FREEX (pData, pNewdata, iNewsize)
1353 return iRetcode;
1354 }
1355
1356 if (fMagnifyX) /* magnifying in X-direction ? */
1357 {
1358 iRetcode = fMagnifyX (pData, pImage->iMAGN_MX,
1359 pImage->iMAGN_ML, pImage->iMAGN_MR,
1360 pBuf->iWidth, pTempline, pDstline);
1361
1362 if (iRetcode) /* on error bail out */
1363 {
1364 MNG_FREEX (pData, pTempline, iNewrowsize)
1365 MNG_FREEX (pData, pNewdata, iNewsize)
1366 return iRetcode;
1367 }
1368 }
1369 else
1370 {
1371 MNG_COPY (pDstline, pTempline, iNewrowsize)
1372 }
1373
1374 pDstline += iNewrowsize;
1375 }
1376 }
1377
1378 pSrcline1 += pBuf->iRowsize;
1379 }
1380 /* drop temporary row */
1381 MNG_FREEX (pData, pTempline, iNewrowsize)
1382 /* drop old pixel-data */
1383 MNG_FREEX (pData, pBuf->pImgdata, pBuf->iImgdatasize)
1384
1385 pBuf->pImgdata = pNewdata; /* save new buffer dimensions */
1386 pBuf->iRowsize = iNewrowsize;
1387 pBuf->iImgdatasize = iNewsize;
1388 pBuf->iWidth = iNewW;
1389 pBuf->iHeight = iNewH;
1390
1391 if (pImage->iId) /* real object ? */
1392 {
1393 pImage->iMAGN_MethodX = 0; /* it's done; don't do it again !!! */
1394 pImage->iMAGN_MethodY = 0;
1395 pImage->iMAGN_MX = 0;
1396 pImage->iMAGN_MY = 0;
1397 pImage->iMAGN_ML = 0;
1398 pImage->iMAGN_MR = 0;
1399 pImage->iMAGN_MT = 0;
1400 pImage->iMAGN_MB = 0;
1401 }
1402
1403#ifdef MNG_SUPPORT_TRACE
1404 MNG_TRACE (pData, MNG_FN_MAGNIFY_IMGOBJECT, MNG_LC_END)
1405#endif
1406
1407 return MNG_NOERROR;
1408}
1409
1410/* ************************************************************************** */
1411/* * * */
1412/* * Animation-object routines * */
1413/* * * */
1414/* * these handle the animation objects used to re-run parts of a MNG. * */
1415/* * eg. during LOOP or TERM processing * */
1416/* * * */
1417/* ************************************************************************** */
1418
1419void add_ani_object (mng_datap pData,
1420 mng_object_headerp pObject)
1421{
1422 mng_object_headerp pLast = (mng_object_headerp)pData->pLastaniobj;
1423
1424 if (pLast) /* link it as last in the chain */
1425 {
1426 pObject->pPrev = pLast;
1427 pLast->pNext = pObject;
1428 }
1429 else
1430 {
1431 pObject->pPrev = MNG_NULL; /* be on the safe side */
1432 pData->pFirstaniobj = pObject;
1433 }
1434
1435 pObject->pNext = MNG_NULL; /* be on the safe side */
1436 pData->pLastaniobj = pObject;
1437 /* keep track for jumping */
1438 pObject->iFramenr = pData->iFrameseq;
1439 pObject->iLayernr = pData->iLayerseq;
1440 pObject->iPlaytime = pData->iFrametime;
1441 /* save restart object ? */
1442 if ((pData->bDisplaying) && (!pData->bRunning) && (!pData->pCurraniobj))
1443 pData->pCurraniobj = pObject;
1444
1445 return;
1446}
1447
1448/* ************************************************************************** */
1449/* ************************************************************************** */
1450
1451mng_retcode create_ani_image (mng_datap pData)
1452{
1453 mng_ani_imagep pImage;
1454 mng_imagep pCurrent;
1455 mng_retcode iRetcode;
1456
1457#ifdef MNG_SUPPORT_TRACE
1458 MNG_TRACE (pData, MNG_FN_CREATE_ANI_IMAGE, MNG_LC_START)
1459#endif
1460
1461 if (pData->bCacheplayback) /* caching playback info ? */
1462 {
1463 if (pData->bHasDHDR) /* processing delta-image ? */
1464 pCurrent = (mng_imagep)pData->pObjzero;
1465 else /* get the current object */
1466 pCurrent = (mng_imagep)pData->pCurrentobj;
1467
1468 if (!pCurrent) /* otherwise object 0 */
1469 pCurrent = (mng_imagep)pData->pObjzero;
1470 /* now just clone the object !!! */
1471 iRetcode = clone_imageobject (pData, 0, MNG_FALSE, pCurrent->bVisible,
1472 MNG_FALSE, MNG_FALSE, 0, 0, 0, pCurrent, &pImage);
1473
1474 if (iRetcode) /* on error bail out */
1475 return iRetcode;
1476
1477 pImage->sHeader.fCleanup = free_ani_image;
1478 pImage->sHeader.fProcess = process_ani_image;
1479
1480 add_ani_object (pData, (mng_object_headerp)pImage);
1481 }
1482
1483#ifdef MNG_SUPPORT_TRACE
1484 MNG_TRACE (pData, MNG_FN_CREATE_ANI_IMAGE, MNG_LC_END)
1485#endif
1486
1487 return MNG_NOERROR; /* okido */
1488}
1489
1490/* ************************************************************************** */
1491
1492mng_retcode free_ani_image (mng_datap pData,
1493 mng_objectp pObject)
1494{
1495 mng_ani_imagep pImage = (mng_ani_imagep)pObject;
1496 mng_imagedatap pImgbuf = pImage->pImgbuf;
1497 mng_retcode iRetcode;
1498
1499#ifdef MNG_SUPPORT_TRACE
1500 MNG_TRACE (pData, MNG_FN_FREE_ANI_IMAGE, MNG_LC_START)
1501#endif
1502 /* unlink the image-data buffer */
1503 iRetcode = free_imagedataobject (pData, pImgbuf);
1504 /* drop it's own buffer */
1505 MNG_FREEX (pData, pImage, sizeof (mng_ani_image))
1506
1507#ifdef MNG_SUPPORT_TRACE
1508 MNG_TRACE (pData, MNG_FN_FREE_ANI_IMAGE, MNG_LC_END)
1509#endif
1510
1511 return iRetcode;
1512}
1513
1514/* ************************************************************************** */
1515
1516mng_retcode process_ani_image (mng_datap pData,
1517 mng_objectp pObject)
1518{
1519 mng_retcode iRetcode = MNG_NOERROR;
1520 mng_ani_imagep pImage = (mng_imagep)pObject;
1521
1522#ifdef MNG_SUPPORT_TRACE
1523 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IMAGE, MNG_LC_START)
1524#endif
1525
1526 if (pData->bHasDHDR) /* processing delta-image ? */
1527 {
1528 mng_imagep pDelta = (mng_imagep)pData->pDeltaImage;
1529
1530 if (!pData->iBreakpoint) /* only execute if not broken before */
1531 { /* make sure to process pixels as well */
1532 pData->bDeltaimmediate = MNG_FALSE;
1533 /* execute the delta process */
1534 iRetcode = execute_delta_image (pData, pDelta, (mng_imagep)pObject);
1535
1536 if (iRetcode) /* on error bail out */
1537 return iRetcode;
1538 }
1539 /* now go and shoot it off (if required) */
1540 if ((pDelta->bVisible) && (pDelta->bViewable))
1541 iRetcode = display_image (pData, pDelta, MNG_FALSE);
1542
1543 if (!pData->bTimerset)
1544 pData->bHasDHDR = MNG_FALSE; /* this image signifies IEND !! */
1545
1546 }
1547 else
1548 if (pData->pCurrentobj) /* active object ? */
1549 {
1550 mng_imagep pCurrent = (mng_imagep)pData->pCurrentobj;
1551 mng_imagedatap pBuf = pCurrent->pImgbuf;
1552
1553 if (!pData->iBreakpoint) /* don't copy it again ! */
1554 {
1555 if (pBuf->iImgdatasize) /* buffer present in active object ? */
1556 /* then drop it */
1557 MNG_FREE (pData, pBuf->pImgdata, pBuf->iImgdatasize)
1558
1559 if (pBuf->iProfilesize) /* iCCP profile present ? */
1560 /* then drop it */
1561 MNG_FREE (pData, pBuf->pProfile, pBuf->iProfilesize)
1562 /* now blatently copy the animation buffer */
1563 MNG_COPY (pBuf, pImage->pImgbuf, sizeof (mng_imagedata))
1564 /* copy viewability */
1565 pCurrent->bViewable = pImage->bViewable;
1566
1567 if (pBuf->iImgdatasize) /* sample buffer present ? */
1568 { /* then make a copy */
1569 MNG_ALLOC (pData, pBuf->pImgdata, pBuf->iImgdatasize)
1570 MNG_COPY (pBuf->pImgdata, pImage->pImgbuf->pImgdata, pBuf->iImgdatasize)
1571 }
1572
1573 if (pBuf->iProfilesize) /* iCCP profile present ? */
1574 { /* then make a copy */
1575 MNG_ALLOC (pData, pBuf->pProfile, pBuf->iProfilesize)
1576 MNG_COPY (pBuf->pProfile, pImage->pImgbuf->pProfile, pBuf->iProfilesize)
1577 }
1578 }
1579 /* now go and shoot it off (if required) */
1580 if ((pCurrent->bVisible) && (pCurrent->bViewable))
1581 iRetcode = display_image (pData, pCurrent, MNG_FALSE);
1582 }
1583 else
1584 {
1585 mng_imagep pObjzero = (mng_imagep)pData->pObjzero;
1586 /* overlay with object 0 status */
1587 pImage->bVisible = pObjzero->bVisible;
1588 pImage->bViewable = pObjzero->bViewable;
1589 pImage->iPosx = pObjzero->iPosx;
1590 pImage->iPosy = pObjzero->iPosy;
1591 pImage->bClipped = pObjzero->bClipped;
1592 pImage->iClipl = pObjzero->iClipl;
1593 pImage->iClipr = pObjzero->iClipr;
1594 pImage->iClipt = pObjzero->iClipt;
1595 pImage->iClipb = pObjzero->iClipb;
1596 /* now this should do the trick */
1597 if ((pImage->bVisible) && (pImage->bViewable))
1598 iRetcode = display_image (pData, pImage, MNG_FALSE);
1599 }
1600
1601 if (!iRetcode) /* all's well ? */
1602 {
1603 if (pData->bTimerset) /* timer break ? */
1604 pData->iBreakpoint = 99; /* fictive number; no more processing needed! */
1605 else
1606 pData->iBreakpoint = 0; /* else clear it */
1607 }
1608
1609#ifdef MNG_SUPPORT_TRACE
1610 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IMAGE, MNG_LC_END)
1611#endif
1612
1613 return iRetcode;
1614}
1615
1616/* ************************************************************************** */
1617/* ************************************************************************** */
1618
1619mng_retcode create_ani_plte (mng_datap pData,
1620 mng_uint32 iEntrycount,
1621 mng_palette8ep paEntries)
1622{
1623 mng_ani_pltep pPLTE;
1624
1625#ifdef MNG_SUPPORT_TRACE
1626 MNG_TRACE (pData, MNG_FN_CREATE_ANI_PLTE, MNG_LC_START)
1627#endif
1628
1629 if (pData->bCacheplayback) /* caching playback info ? */
1630 {
1631 MNG_ALLOC (pData, pPLTE, sizeof (mng_ani_plte))
1632
1633 pPLTE->sHeader.fCleanup = free_ani_plte;
1634 pPLTE->sHeader.fProcess = process_ani_plte;
1635
1636 add_ani_object (pData, (mng_object_headerp)pPLTE);
1637
1638 pPLTE->iEntrycount = iEntrycount;
1639
1640 MNG_COPY (pPLTE->aEntries, paEntries, sizeof (pPLTE->aEntries))
1641 }
1642
1643#ifdef MNG_SUPPORT_TRACE
1644 MNG_TRACE (pData, MNG_FN_CREATE_ANI_PLTE, MNG_LC_END)
1645#endif
1646
1647 return MNG_NOERROR;
1648}
1649
1650/* ************************************************************************** */
1651
1652mng_retcode free_ani_plte (mng_datap pData,
1653 mng_objectp pObject)
1654{
1655#ifdef MNG_SUPPORT_TRACE
1656 MNG_TRACE (pData, MNG_FN_FREE_ANI_PLTE, MNG_LC_START)
1657#endif
1658
1659 MNG_FREEX (pData, pObject, sizeof (mng_ani_plte))
1660
1661#ifdef MNG_SUPPORT_TRACE
1662 MNG_TRACE (pData, MNG_FN_FREE_ANI_PLTE, MNG_LC_END)
1663#endif
1664
1665 return MNG_NOERROR;
1666}
1667
1668/* ************************************************************************** */
1669
1670mng_retcode process_ani_plte (mng_datap pData,
1671 mng_objectp pObject)
1672{
1673 mng_ani_pltep pPLTE = (mng_ani_pltep)pObject;
1674
1675#ifdef MNG_SUPPORT_TRACE
1676 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PLTE, MNG_LC_START)
1677#endif
1678
1679 pData->bHasglobalPLTE = MNG_TRUE;
1680 pData->iGlobalPLTEcount = pPLTE->iEntrycount;
1681
1682 MNG_COPY (pData->aGlobalPLTEentries, pPLTE->aEntries, sizeof (pPLTE->aEntries))
1683
1684#ifdef MNG_SUPPORT_TRACE
1685 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PLTE, MNG_LC_END)
1686#endif
1687
1688 return MNG_NOERROR;
1689}
1690
1691/* ************************************************************************** */
1692/* ************************************************************************** */
1693
1694mng_retcode create_ani_trns (mng_datap pData,
1695 mng_uint32 iRawlen,
1696 mng_uint8p pRawdata)
1697{
1698 mng_ani_trnsp pTRNS;
1699
1700#ifdef MNG_SUPPORT_TRACE
1701 MNG_TRACE (pData, MNG_FN_CREATE_ANI_TRNS, MNG_LC_START)
1702#endif
1703
1704 if (pData->bCacheplayback) /* caching playback info ? */
1705 {
1706 MNG_ALLOC (pData, pTRNS, sizeof (mng_ani_trns))
1707
1708 pTRNS->sHeader.fCleanup = free_ani_trns;
1709 pTRNS->sHeader.fProcess = process_ani_trns;
1710
1711 add_ani_object (pData, (mng_object_headerp)pTRNS);
1712
1713 pTRNS->iRawlen = iRawlen;
1714
1715 MNG_COPY (pTRNS->aRawdata, pRawdata, sizeof (pTRNS->aRawdata))
1716 }
1717
1718#ifdef MNG_SUPPORT_TRACE
1719 MNG_TRACE (pData, MNG_FN_CREATE_ANI_TRNS, MNG_LC_END)
1720#endif
1721
1722 return MNG_NOERROR;
1723}
1724
1725/* ************************************************************************** */
1726
1727mng_retcode free_ani_trns (mng_datap pData,
1728 mng_objectp pObject)
1729{
1730#ifdef MNG_SUPPORT_TRACE
1731 MNG_TRACE (pData, MNG_FN_FREE_ANI_TRNS, MNG_LC_START)
1732#endif
1733
1734 MNG_FREEX (pData, pObject, sizeof (mng_ani_trns))
1735
1736#ifdef MNG_SUPPORT_TRACE
1737 MNG_TRACE (pData, MNG_FN_FREE_ANI_TRNS, MNG_LC_END)
1738#endif
1739
1740 return MNG_NOERROR;
1741}
1742
1743/* ************************************************************************** */
1744
1745mng_retcode process_ani_trns (mng_datap pData,
1746 mng_objectp pObject)
1747{
1748 mng_ani_trnsp pTRNS = (mng_ani_trnsp)pObject;
1749
1750#ifdef MNG_SUPPORT_TRACE
1751 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TRNS, MNG_LC_START)
1752#endif
1753
1754 pData->bHasglobalTRNS = MNG_TRUE;
1755 pData->iGlobalTRNSrawlen = pTRNS->iRawlen;
1756
1757 MNG_COPY (pData->aGlobalTRNSrawdata, pTRNS->aRawdata, sizeof (pTRNS->aRawdata))
1758
1759#ifdef MNG_SUPPORT_TRACE
1760 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TRNS, MNG_LC_END)
1761#endif
1762
1763 return MNG_NOERROR;
1764}
1765
1766/* ************************************************************************** */
1767/* ************************************************************************** */
1768
1769mng_retcode create_ani_gama (mng_datap pData,
1770 mng_bool bEmpty,
1771 mng_uint32 iGamma)
1772{
1773 mng_ani_gamap pGAMA;
1774
1775#ifdef MNG_SUPPORT_TRACE
1776 MNG_TRACE (pData, MNG_FN_CREATE_ANI_GAMA, MNG_LC_START)
1777#endif
1778
1779 if (pData->bCacheplayback) /* caching playback info ? */
1780 {
1781 MNG_ALLOC (pData, pGAMA, sizeof (mng_ani_gama))
1782
1783 pGAMA->sHeader.fCleanup = free_ani_gama;
1784 pGAMA->sHeader.fProcess = process_ani_gama;
1785
1786 add_ani_object (pData, (mng_object_headerp)pGAMA);
1787
1788 pGAMA->bEmpty = bEmpty;
1789 pGAMA->iGamma = iGamma;
1790 }
1791
1792#ifdef MNG_SUPPORT_TRACE
1793 MNG_TRACE (pData, MNG_FN_CREATE_ANI_GAMA, MNG_LC_END)
1794#endif
1795
1796 return MNG_NOERROR;
1797}
1798
1799/* ************************************************************************** */
1800
1801mng_retcode free_ani_gama (mng_datap pData,
1802 mng_objectp pObject)
1803{
1804#ifdef MNG_SUPPORT_TRACE
1805 MNG_TRACE (pData, MNG_FN_FREE_ANI_GAMA, MNG_LC_START)
1806#endif
1807
1808 MNG_FREEX (pData, pObject, sizeof (mng_ani_gama))
1809
1810#ifdef MNG_SUPPORT_TRACE
1811 MNG_TRACE (pData, MNG_FN_FREE_ANI_GAMA, MNG_LC_END)
1812#endif
1813
1814 return MNG_NOERROR;
1815}
1816
1817/* ************************************************************************** */
1818
1819mng_retcode process_ani_gama (mng_datap pData,
1820 mng_objectp pObject)
1821{
1822 mng_ani_gamap pGAMA = (mng_ani_gamap)pObject;
1823
1824#ifdef MNG_SUPPORT_TRACE
1825 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_GAMA, MNG_LC_START)
1826#endif
1827
1828 if (pGAMA->bEmpty) /* empty chunk ? */
1829 { /* clear global gAMA */
1830 pData->bHasglobalGAMA = MNG_FALSE;
1831 pData->iGlobalGamma = 0;
1832 }
1833 else
1834 { /* set global gAMA */
1835 pData->bHasglobalGAMA = MNG_TRUE;
1836 pData->iGlobalGamma = pGAMA->iGamma;
1837 }
1838
1839#ifdef MNG_SUPPORT_TRACE
1840 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_GAMA, MNG_LC_END)
1841#endif
1842
1843 return MNG_NOERROR;
1844}
1845
1846/* ************************************************************************** */
1847/* ************************************************************************** */
1848
1849mng_retcode create_ani_chrm (mng_datap pData,
1850 mng_bool bEmpty,
1851 mng_uint32 iWhitepointx,
1852 mng_uint32 iWhitepointy,
1853 mng_uint32 iRedx,
1854 mng_uint32 iRedy,
1855 mng_uint32 iGreenx,
1856 mng_uint32 iGreeny,
1857 mng_uint32 iBluex,
1858 mng_uint32 iBluey)
1859{
1860 mng_ani_chrmp pCHRM;
1861
1862#ifdef MNG_SUPPORT_TRACE
1863 MNG_TRACE (pData, MNG_FN_CREATE_ANI_CHRM, MNG_LC_START)
1864#endif
1865
1866 if (pData->bCacheplayback) /* caching playback info ? */
1867 {
1868 MNG_ALLOC (pData, pCHRM, sizeof (mng_ani_chrm))
1869
1870 pCHRM->sHeader.fCleanup = free_ani_chrm;
1871 pCHRM->sHeader.fProcess = process_ani_chrm;
1872
1873 add_ani_object (pData, (mng_object_headerp)pCHRM);
1874
1875 pCHRM->bEmpty = bEmpty;
1876 pCHRM->iWhitepointx = iWhitepointx;
1877 pCHRM->iWhitepointy = iWhitepointy;
1878 pCHRM->iRedx = iRedx;
1879 pCHRM->iRedy = iRedy;
1880 pCHRM->iGreenx = iGreenx;
1881 pCHRM->iGreeny = iGreeny;
1882 pCHRM->iBluex = iBluex;
1883 pCHRM->iBluey = iBluey;
1884 }
1885
1886#ifdef MNG_SUPPORT_TRACE
1887 MNG_TRACE (pData, MNG_FN_CREATE_ANI_CHRM, MNG_LC_END)
1888#endif
1889
1890 return MNG_NOERROR;
1891}
1892
1893/* ************************************************************************** */
1894
1895mng_retcode free_ani_chrm (mng_datap pData,
1896 mng_objectp pObject)
1897{
1898#ifdef MNG_SUPPORT_TRACE
1899 MNG_TRACE (pData, MNG_FN_FREE_ANI_CHRM, MNG_LC_START)
1900#endif
1901
1902 MNG_FREEX (pData, pObject, sizeof (mng_ani_chrm))
1903
1904#ifdef MNG_SUPPORT_TRACE
1905 MNG_TRACE (pData, MNG_FN_FREE_ANI_CHRM, MNG_LC_END)
1906#endif
1907
1908 return MNG_NOERROR;
1909}
1910
1911/* ************************************************************************** */
1912
1913mng_retcode process_ani_chrm (mng_datap pData,
1914 mng_objectp pObject)
1915{
1916 mng_ani_chrmp pCHRM = (mng_ani_chrmp)pObject;
1917
1918#ifdef MNG_SUPPORT_TRACE
1919 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CHRM, MNG_LC_START)
1920#endif
1921
1922 if (pCHRM->bEmpty) /* empty chunk ? */
1923 { /* clear global cHRM */
1924 pData->bHasglobalCHRM = MNG_FALSE;
1925 pData->iGlobalWhitepointx = 0;
1926 pData->iGlobalWhitepointy = 0;
1927 pData->iGlobalPrimaryredx = 0;
1928 pData->iGlobalPrimaryredy = 0;
1929 pData->iGlobalPrimarygreenx = 0;
1930 pData->iGlobalPrimarygreeny = 0;
1931 pData->iGlobalPrimarybluex = 0;
1932 pData->iGlobalPrimarybluey = 0;
1933 }
1934 else
1935 { /* set global cHRM */
1936 pData->bHasglobalCHRM = MNG_TRUE;
1937 pData->iGlobalWhitepointx = pCHRM->iWhitepointx;
1938 pData->iGlobalWhitepointy = pCHRM->iWhitepointy;
1939 pData->iGlobalPrimaryredx = pCHRM->iRedx;
1940 pData->iGlobalPrimaryredy = pCHRM->iRedy;
1941 pData->iGlobalPrimarygreenx = pCHRM->iGreenx;
1942 pData->iGlobalPrimarygreeny = pCHRM->iGreeny;
1943 pData->iGlobalPrimarybluex = pCHRM->iBluex;
1944 pData->iGlobalPrimarybluey = pCHRM->iBluey;
1945 }
1946
1947#ifdef MNG_SUPPORT_TRACE
1948 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CHRM, MNG_LC_END)
1949#endif
1950
1951 return MNG_NOERROR;
1952}
1953
1954/* ************************************************************************** */
1955/* ************************************************************************** */
1956
1957mng_retcode create_ani_srgb (mng_datap pData,
1958 mng_bool bEmpty,
1959 mng_uint8 iRenderingintent)
1960{
1961 mng_ani_srgbp pSRGB;
1962
1963#ifdef MNG_SUPPORT_TRACE
1964 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SRGB, MNG_LC_START)
1965#endif
1966
1967 if (pData->bCacheplayback) /* caching playback info ? */
1968 {
1969 MNG_ALLOC (pData, pSRGB, sizeof (mng_ani_srgb))
1970
1971 pSRGB->sHeader.fCleanup = free_ani_srgb;
1972 pSRGB->sHeader.fProcess = process_ani_srgb;
1973
1974 add_ani_object (pData, (mng_object_headerp)pSRGB);
1975
1976 pSRGB->bEmpty = bEmpty;
1977 pSRGB->iRenderingintent = iRenderingintent;
1978 }
1979
1980#ifdef MNG_SUPPORT_TRACE
1981 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SRGB, MNG_LC_END)
1982#endif
1983
1984 return MNG_NOERROR;
1985}
1986
1987/* ************************************************************************** */
1988
1989mng_retcode free_ani_srgb (mng_datap pData,
1990 mng_objectp pObject)
1991{
1992#ifdef MNG_SUPPORT_TRACE
1993 MNG_TRACE (pData, MNG_FN_FREE_ANI_SRGB, MNG_LC_START)
1994#endif
1995
1996 MNG_FREEX (pData, pObject, sizeof (mng_ani_srgb))
1997
1998#ifdef MNG_SUPPORT_TRACE
1999 MNG_TRACE (pData, MNG_FN_FREE_ANI_SRGB, MNG_LC_END)
2000#endif
2001
2002 return MNG_NOERROR;
2003}
2004
2005/* ************************************************************************** */
2006
2007mng_retcode process_ani_srgb (mng_datap pData,
2008 mng_objectp pObject)
2009{
2010 mng_ani_srgbp pSRGB = (mng_ani_srgbp)pObject;
2011
2012#ifdef MNG_SUPPORT_TRACE
2013 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SRGB, MNG_LC_START)
2014#endif
2015
2016 if (pSRGB->bEmpty) /* empty chunk ? */
2017 { /* clear global sRGB */
2018 pData->bHasglobalSRGB = MNG_FALSE;
2019 pData->iGlobalRendintent = 0;
2020 }
2021 else
2022 { /* set global sRGB */
2023 pData->bHasglobalSRGB = MNG_TRUE;
2024 pData->iGlobalRendintent = pSRGB->iRenderingintent;
2025 }
2026
2027#ifdef MNG_SUPPORT_TRACE
2028 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SRGB, MNG_LC_END)
2029#endif
2030
2031 return MNG_NOERROR;
2032}
2033
2034/* ************************************************************************** */
2035/* ************************************************************************** */
2036
2037mng_retcode create_ani_iccp (mng_datap pData,
2038 mng_bool bEmpty,
2039 mng_uint32 iProfilesize,
2040 mng_ptr pProfile)
2041{
2042 mng_ani_iccpp pICCP;
2043
2044#ifdef MNG_SUPPORT_TRACE
2045 MNG_TRACE (pData, MNG_FN_CREATE_ANI_ICCP, MNG_LC_START)
2046#endif
2047
2048 if (pData->bCacheplayback) /* caching playback info ? */
2049 {
2050 MNG_ALLOC (pData, pICCP, sizeof (mng_ani_iccp))
2051
2052 pICCP->sHeader.fCleanup = free_ani_iccp;
2053 pICCP->sHeader.fProcess = process_ani_iccp;
2054
2055 add_ani_object (pData, (mng_object_headerp)pICCP);
2056
2057 pICCP->bEmpty = bEmpty;
2058 pICCP->iProfilesize = iProfilesize;
2059
2060 if (iProfilesize)
2061 {
2062 MNG_ALLOC (pData, pICCP->pProfile, iProfilesize)
2063 MNG_COPY (pICCP->pProfile, pProfile, iProfilesize)
2064 }
2065 }
2066
2067#ifdef MNG_SUPPORT_TRACE
2068 MNG_TRACE (pData, MNG_FN_CREATE_ANI_ICCP, MNG_LC_END)
2069#endif
2070
2071 return MNG_NOERROR;
2072}
2073
2074/* ************************************************************************** */
2075
2076mng_retcode free_ani_iccp (mng_datap pData,
2077 mng_objectp pObject)
2078{
2079 mng_ani_iccpp pICCP = (mng_ani_iccpp)pObject;
2080
2081#ifdef MNG_SUPPORT_TRACE
2082 MNG_TRACE (pData, MNG_FN_FREE_ANI_ICCP, MNG_LC_START)
2083#endif
2084
2085 if (pICCP->iProfilesize)
2086 MNG_FREEX (pData, pICCP->pProfile, pICCP->iProfilesize)
2087
2088 MNG_FREEX (pData, pObject, sizeof (mng_ani_iccp))
2089
2090#ifdef MNG_SUPPORT_TRACE
2091 MNG_TRACE (pData, MNG_FN_FREE_ANI_ICCP, MNG_LC_END)
2092#endif
2093
2094 return MNG_NOERROR;
2095}
2096
2097/* ************************************************************************** */
2098
2099mng_retcode process_ani_iccp (mng_datap pData,
2100 mng_objectp pObject)
2101{
2102 mng_ani_iccpp pICCP = (mng_ani_iccpp)pObject;
2103
2104#ifdef MNG_SUPPORT_TRACE
2105 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ICCP, MNG_LC_START)
2106#endif
2107
2108 if (pICCP->bEmpty) /* empty chunk ? */
2109 { /* clear global iCCP */
2110 pData->bHasglobalICCP = MNG_FALSE;
2111
2112 if (pData->iGlobalProfilesize)
2113 MNG_FREEX (pData, pData->pGlobalProfile, pData->iGlobalProfilesize)
2114
2115 pData->iGlobalProfilesize = 0;
2116 pData->pGlobalProfile = MNG_NULL;
2117 }
2118 else
2119 { /* set global iCCP */
2120 pData->bHasglobalICCP = MNG_TRUE;
2121 pData->iGlobalProfilesize = pICCP->iProfilesize;
2122
2123 if (pICCP->iProfilesize)
2124 {
2125 MNG_ALLOC (pData, pData->pGlobalProfile, pICCP->iProfilesize)
2126 MNG_COPY (pData->pGlobalProfile, pICCP->pProfile, pICCP->iProfilesize)
2127 }
2128 }
2129
2130#ifdef MNG_SUPPORT_TRACE
2131 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ICCP, MNG_LC_END)
2132#endif
2133
2134 return MNG_NOERROR;
2135}
2136
2137/* ************************************************************************** */
2138/* ************************************************************************** */
2139
2140mng_retcode create_ani_bkgd (mng_datap pData,
2141 mng_uint16 iRed,
2142 mng_uint16 iGreen,
2143 mng_uint16 iBlue)
2144{
2145 mng_ani_bkgdp pBKGD;
2146
2147#ifdef MNG_SUPPORT_TRACE
2148 MNG_TRACE (pData, MNG_FN_CREATE_ANI_BKGD, MNG_LC_START)
2149#endif
2150
2151 if (pData->bCacheplayback) /* caching playback info ? */
2152 {
2153 MNG_ALLOC (pData, pBKGD, sizeof (mng_ani_bkgd))
2154
2155 pBKGD->sHeader.fCleanup = free_ani_bkgd;
2156 pBKGD->sHeader.fProcess = process_ani_bkgd;
2157
2158 add_ani_object (pData, (mng_object_headerp)pBKGD);
2159
2160 pBKGD->iRed = iRed;
2161 pBKGD->iGreen = iGreen;
2162 pBKGD->iBlue = iBlue;
2163 }
2164
2165#ifdef MNG_SUPPORT_TRACE
2166 MNG_TRACE (pData, MNG_FN_CREATE_ANI_BKGD, MNG_LC_END)
2167#endif
2168
2169 return MNG_NOERROR;
2170}
2171
2172/* ************************************************************************** */
2173
2174mng_retcode free_ani_bkgd (mng_datap pData,
2175 mng_objectp pObject)
2176{
2177#ifdef MNG_SUPPORT_TRACE
2178 MNG_TRACE (pData, MNG_FN_FREE_ANI_BKGD, MNG_LC_START)
2179#endif
2180
2181 MNG_FREEX (pData, pObject, sizeof (mng_ani_bkgd))
2182
2183#ifdef MNG_SUPPORT_TRACE
2184 MNG_TRACE (pData, MNG_FN_FREE_ANI_BKGD, MNG_LC_END)
2185#endif
2186
2187 return MNG_NOERROR;
2188}
2189
2190/* ************************************************************************** */
2191
2192mng_retcode process_ani_bkgd (mng_datap pData,
2193 mng_objectp pObject)
2194{
2195 mng_ani_bkgdp pBKGD = (mng_ani_bkgdp)pObject;
2196
2197#ifdef MNG_SUPPORT_TRACE
2198 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BKGD, MNG_LC_START)
2199#endif
2200
2201 pData->bHasglobalBKGD = MNG_TRUE;
2202 pData->iGlobalBKGDred = pBKGD->iRed;
2203 pData->iGlobalBKGDgreen = pBKGD->iGreen;
2204 pData->iGlobalBKGDblue = pBKGD->iBlue;
2205
2206#ifdef MNG_SUPPORT_TRACE
2207 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BKGD, MNG_LC_END)
2208#endif
2209
2210 return MNG_NOERROR;
2211}
2212
2213/* ************************************************************************** */
2214/* ************************************************************************** */
2215
2216mng_retcode create_ani_loop (mng_datap pData,
2217 mng_uint8 iLevel,
2218 mng_uint32 iRepeatcount,
2219 mng_uint8 iTermcond,
2220 mng_uint32 iItermin,
2221 mng_uint32 iItermax,
2222 mng_uint32 iCount,
2223 mng_uint32p pSignals)
2224{
2225 mng_ani_loopp pLOOP;
2226
2227#ifdef MNG_SUPPORT_TRACE
2228 MNG_TRACE (pData, MNG_FN_CREATE_ANI_LOOP, MNG_LC_START)
2229#endif
2230
2231 if (pData->bCacheplayback) /* caching playback info ? */
2232 {
2233 MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop))
2234
2235 pLOOP->sHeader.fCleanup = free_ani_loop;
2236 pLOOP->sHeader.fProcess = process_ani_loop;
2237
2238 add_ani_object (pData, (mng_object_headerp)pLOOP);
2239
2240 pLOOP->iLevel = iLevel;
2241 pLOOP->iRepeatcount = iRepeatcount;
2242 pLOOP->iTermcond = iTermcond;
2243 pLOOP->iItermin = iItermin;
2244 pLOOP->iItermax = iItermax;
2245 pLOOP->iCount = iCount;
2246 /* running counter starts with repeat_count */
2247 pLOOP->iRunningcount = iRepeatcount;
2248
2249 if (iCount)
2250 {
2251 MNG_ALLOC (pData, pLOOP->pSignals, (iCount << 1))
2252 MNG_COPY (pLOOP->pSignals, pSignals, (iCount << 1))
2253 }
2254 }
2255
2256#ifdef MNG_SUPPORT_TRACE
2257 MNG_TRACE (pData, MNG_FN_CREATE_ANI_LOOP, MNG_LC_END)
2258#endif
2259
2260 return MNG_NOERROR;
2261}
2262
2263/* ************************************************************************** */
2264
2265mng_retcode free_ani_loop (mng_datap pData,
2266 mng_objectp pObject)
2267{
2268 mng_ani_loopp pLOOP = (mng_ani_loopp)pObject;
2269
2270#ifdef MNG_SUPPORT_TRACE
2271 MNG_TRACE (pData, MNG_FN_FREE_ANI_LOOP, MNG_LC_START)
2272#endif
2273
2274 if (pLOOP->iCount) /* drop signal buffer ? */
2275 MNG_FREEX (pData, pLOOP->pSignals, (pLOOP->iCount << 1))
2276
2277 MNG_FREEX (pData, pObject, sizeof (mng_ani_loop))
2278
2279#ifdef MNG_SUPPORT_TRACE
2280 MNG_TRACE (pData, MNG_FN_FREE_ANI_LOOP, MNG_LC_END)
2281#endif
2282
2283 return MNG_NOERROR;
2284}
2285
2286/* ************************************************************************** */
2287
2288mng_retcode process_ani_loop (mng_datap pData,
2289 mng_objectp pObject)
2290{
2291 mng_ani_loopp pLOOP = (mng_ani_loopp)pObject;
2292
2293#ifdef MNG_SUPPORT_TRACE
2294 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_LOOP, MNG_LC_START)
2295#endif
2296 /* just reset the running counter */
2297 pLOOP->iRunningcount = pLOOP->iRepeatcount;
2298
2299#ifdef MNG_SUPPORT_TRACE
2300 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_LOOP, MNG_LC_END)
2301#endif
2302
2303 return MNG_NOERROR;
2304}
2305
2306/* ************************************************************************** */
2307/* ************************************************************************** */
2308
2309mng_retcode create_ani_endl (mng_datap pData,
2310 mng_uint8 iLevel)
2311{
2312 mng_ani_endlp pENDL;
2313
2314#ifdef MNG_SUPPORT_TRACE
2315 MNG_TRACE (pData, MNG_FN_CREATE_ANI_ENDL, MNG_LC_START)
2316#endif
2317
2318 if (pData->bCacheplayback) /* caching playback info ? */
2319 {
2320 MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl))
2321
2322 pENDL->sHeader.fCleanup = free_ani_endl;
2323 pENDL->sHeader.fProcess = process_ani_endl;
2324
2325 add_ani_object (pData, (mng_object_headerp)pENDL);
2326
2327 pENDL->iLevel = iLevel;
2328 }
2329
2330#ifdef MNG_SUPPORT_TRACE
2331 MNG_TRACE (pData, MNG_FN_CREATE_ANI_ENDL, MNG_LC_END)
2332#endif
2333
2334 return MNG_NOERROR;
2335}
2336
2337/* ************************************************************************** */
2338
2339mng_retcode free_ani_endl (mng_datap pData,
2340 mng_objectp pObject)
2341{
2342#ifdef MNG_SUPPORT_TRACE
2343 MNG_TRACE (pData, MNG_FN_FREE_ANI_ENDL, MNG_LC_START)
2344#endif
2345
2346 MNG_FREEX (pData, pObject, sizeof (mng_ani_endl))
2347
2348#ifdef MNG_SUPPORT_TRACE
2349 MNG_TRACE (pData, MNG_FN_FREE_ANI_ENDL, MNG_LC_END)
2350#endif
2351
2352 return MNG_NOERROR;
2353}
2354
2355/* ************************************************************************** */
2356
2357mng_retcode process_ani_endl (mng_datap pData,
2358 mng_objectp pObject)
2359{
2360 mng_ani_endlp pENDL = (mng_ani_endlp)pObject;
2361 mng_ani_loopp pLOOP;
2362
2363#ifdef MNG_SUPPORT_TRACE
2364 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ENDL, MNG_LC_START)
2365#endif
2366
2367 if ((pData->bDisplaying) && (pData->bRunning))
2368 {
2369 pLOOP = pENDL->pLOOP; /* determine matching LOOP */
2370
2371 if (!pLOOP) /* haven't got it yet ? */
2372 { /* go and look back in the list */
2373 pLOOP = (mng_ani_loopp)pENDL->sHeader.pPrev;
2374
2375 while ((pLOOP) &&
2376 ((pLOOP->sHeader.fCleanup != free_ani_loop) ||
2377 (pLOOP->iLevel != pENDL->iLevel) ))
2378 pLOOP = pLOOP->sHeader.pPrev;
2379 }
2380 /* got it now ? */
2381 if ((pLOOP) && (pLOOP->iLevel == pENDL->iLevel))
2382 {
2383 pENDL->pLOOP = pLOOP; /* save for next time ! */
2384 /* decrease running counter ? */
2385 if ((pLOOP->iRunningcount) && (pLOOP->iRunningcount < 0x7fffffffL))
2386 pLOOP->iRunningcount--;
2387
2388 /* TODO: we're cheating out on the termination_condition,
2389 iteration_min, iteration_max and possible signals;
2390 the code is just not ready for that can of worms.... */
2391
2392 if (!pLOOP->iRunningcount) /* reached zero ? */
2393 { /* was this the outer LOOP ? */
2394 if (pData->pFirstaniobj == (mng_objectp)pLOOP)
2395 pData->bHasLOOP = MNG_FALSE;
2396 }
2397 else
2398 {
2399 if (pData->pCurraniobj) /* was we processing objects ? */
2400 pData->pCurraniobj = pLOOP; /* then restart with LOOP */
2401 else /* else restart behind LOOP !!! */
2402 pData->pCurraniobj = pLOOP->sHeader.pNext;
2403 }
2404 }
2405 else
2406 {
2407 MNG_ERROR (pData, 1234);
2408 /* TODO: error abort ??? */
2409
2410 }
2411 }
2412
2413#ifdef MNG_SUPPORT_TRACE
2414 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_ENDL, MNG_LC_END)
2415#endif
2416
2417 return MNG_NOERROR;
2418}
2419
2420/* ************************************************************************** */
2421/* ************************************************************************** */
2422
2423mng_retcode create_ani_defi (mng_datap pData)
2424{
2425 mng_ani_defip pDEFI;
2426
2427#ifdef MNG_SUPPORT_TRACE
2428 MNG_TRACE (pData, MNG_FN_CREATE_ANI_DEFI, MNG_LC_START)
2429#endif
2430
2431 if (pData->bCacheplayback) /* caching playback info ? */
2432 {
2433 MNG_ALLOC (pData, pDEFI, sizeof (mng_ani_defi))
2434
2435 pDEFI->sHeader.fCleanup = free_ani_defi;
2436 pDEFI->sHeader.fProcess = process_ani_defi;
2437
2438 add_ani_object (pData, (mng_object_headerp)pDEFI);
2439
2440 pDEFI->iId = pData->iDEFIobjectid;
2441 pDEFI->bHasdonotshow = pData->bDEFIhasdonotshow;
2442 pDEFI->iDonotshow = pData->iDEFIdonotshow;
2443 pDEFI->bHasconcrete = pData->bDEFIhasconcrete;
2444 pDEFI->iConcrete = pData->iDEFIconcrete;
2445 pDEFI->bHasloca = pData->bDEFIhasloca;
2446 pDEFI->iLocax = pData->iDEFIlocax;
2447 pDEFI->iLocay = pData->iDEFIlocay;
2448 pDEFI->bHasclip = pData->bDEFIhasclip;
2449 pDEFI->iClipl = pData->iDEFIclipl;
2450 pDEFI->iClipr = pData->iDEFIclipr;
2451 pDEFI->iClipt = pData->iDEFIclipt;
2452 pDEFI->iClipb = pData->iDEFIclipb;
2453 }
2454
2455#ifdef MNG_SUPPORT_TRACE
2456 MNG_TRACE (pData, MNG_FN_CREATE_ANI_DEFI, MNG_LC_END)
2457#endif
2458
2459 return MNG_NOERROR;
2460}
2461
2462/* ************************************************************************** */
2463
2464mng_retcode free_ani_defi (mng_datap pData,
2465 mng_objectp pObject)
2466{
2467#ifdef MNG_SUPPORT_TRACE
2468 MNG_TRACE (pData, MNG_FN_FREE_ANI_DEFI, MNG_LC_START)
2469#endif
2470
2471 MNG_FREEX (pData, pObject, sizeof (mng_ani_defi))
2472
2473#ifdef MNG_SUPPORT_TRACE
2474 MNG_TRACE (pData, MNG_FN_FREE_ANI_DEFI, MNG_LC_END)
2475#endif
2476
2477 return MNG_NOERROR;
2478}
2479
2480/* ************************************************************************** */
2481
2482mng_retcode process_ani_defi (mng_datap pData,
2483 mng_objectp pObject)
2484{
2485 mng_ani_defip pDEFI = (mng_ani_defip)pObject;
2486 mng_retcode iRetcode;
2487
2488#ifdef MNG_SUPPORT_TRACE
2489 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DEFI, MNG_LC_START)
2490#endif
2491
2492 pData->iDEFIobjectid = pDEFI->iId;
2493 pData->bDEFIhasdonotshow = pDEFI->bHasdonotshow;
2494 pData->iDEFIdonotshow = pDEFI->iDonotshow;
2495 pData->bDEFIhasconcrete = pDEFI->bHasconcrete;
2496 pData->iDEFIconcrete = pDEFI->iConcrete;
2497 pData->bDEFIhasloca = pDEFI->bHasloca;
2498 pData->iDEFIlocax = pDEFI->iLocax;
2499 pData->iDEFIlocay = pDEFI->iLocay;
2500 pData->bDEFIhasclip = pDEFI->bHasclip;
2501 pData->iDEFIclipl = pDEFI->iClipl;
2502 pData->iDEFIclipr = pDEFI->iClipr;
2503 pData->iDEFIclipt = pDEFI->iClipt;
2504 pData->iDEFIclipb = pDEFI->iClipb;
2505
2506 iRetcode = process_display_defi (pData);
2507
2508 if (iRetcode) /* on error bail out */
2509 return iRetcode;
2510
2511#ifdef MNG_SUPPORT_TRACE
2512 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DEFI, MNG_LC_END)
2513#endif
2514
2515 return MNG_NOERROR;
2516}
2517
2518/* ************************************************************************** */
2519/* ************************************************************************** */
2520
2521mng_retcode create_ani_basi (mng_datap pData,
2522 mng_uint16 iRed,
2523 mng_uint16 iGreen,
2524 mng_uint16 iBlue,
2525 mng_bool bHasalpha,
2526 mng_uint16 iAlpha,
2527 mng_uint8 iViewable)
2528{
2529 mng_ani_basip pBASI;
2530
2531#ifdef MNG_SUPPORT_TRACE
2532 MNG_TRACE (pData, MNG_FN_CREATE_ANI_BASI, MNG_LC_START)
2533#endif
2534
2535 if (pData->bCacheplayback) /* caching playback info ? */
2536 {
2537 MNG_ALLOC (pData, pBASI, sizeof (mng_ani_basi))
2538
2539 pBASI->sHeader.fCleanup = free_ani_basi;
2540 pBASI->sHeader.fProcess = process_ani_basi;
2541
2542 add_ani_object (pData, (mng_object_headerp)pBASI);
2543
2544 pBASI->iRed = iRed;
2545 pBASI->iGreen = iGreen;
2546 pBASI->iBlue = iBlue;
2547 pBASI->bHasalpha = bHasalpha;
2548 pBASI->iAlpha = iAlpha;
2549 pBASI->iViewable = iViewable;
2550 }
2551
2552#ifdef MNG_SUPPORT_TRACE
2553 MNG_TRACE (pData, MNG_FN_CREATE_ANI_BASI, MNG_LC_END)
2554#endif
2555
2556 return MNG_NOERROR;
2557}
2558
2559/* ************************************************************************** */
2560
2561mng_retcode free_ani_basi (mng_datap pData,
2562 mng_objectp pObject)
2563{
2564#ifdef MNG_SUPPORT_TRACE
2565 MNG_TRACE (pData, MNG_FN_FREE_ANI_BASI, MNG_LC_START)
2566#endif
2567
2568 MNG_FREEX (pData, pObject, sizeof (mng_ani_basi))
2569
2570#ifdef MNG_SUPPORT_TRACE
2571 MNG_TRACE (pData, MNG_FN_FREE_ANI_BASI, MNG_LC_END)
2572#endif
2573
2574 return MNG_NOERROR;
2575}
2576
2577/* ************************************************************************** */
2578
2579mng_retcode process_ani_basi (mng_datap pData,
2580 mng_objectp pObject)
2581{
2582 mng_ani_basip pBASI = (mng_ani_basip)pObject;
2583 mng_retcode iRetcode;
2584
2585#ifdef MNG_SUPPORT_TRACE
2586 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BASI, MNG_LC_START)
2587#endif
2588
2589 iRetcode = process_display_basi (pData, pBASI->iRed, pBASI->iGreen, pBASI->iBlue,
2590 pBASI->bHasalpha, pBASI->iAlpha, pBASI->iViewable);
2591
2592#ifdef MNG_SUPPORT_TRACE
2593 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BASI, MNG_LC_END)
2594#endif
2595
2596 return iRetcode;
2597}
2598
2599/* ************************************************************************** */
2600/* ************************************************************************** */
2601
2602mng_retcode create_ani_clon (mng_datap pData,
2603 mng_uint16 iCloneid,
2604 mng_uint16 iSourceid,
2605 mng_uint8 iClonetype,
2606 mng_bool bHasdonotshow,
2607 mng_uint8 iDonotshow,
2608 mng_uint8 iConcrete,
2609 mng_bool bHasloca,
2610 mng_uint8 iLocatype,
2611 mng_int32 iLocax,
2612 mng_int32 iLocay)
2613{
2614 mng_ani_clonp pCLON;
2615
2616#ifdef MNG_SUPPORT_TRACE
2617 MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLON, MNG_LC_START)
2618#endif
2619
2620 if (pData->bCacheplayback) /* caching playback info ? */
2621 {
2622 MNG_ALLOC (pData, pCLON, sizeof (mng_ani_clon))
2623
2624 pCLON->sHeader.fCleanup = free_ani_clon;
2625 pCLON->sHeader.fProcess = process_ani_clon;
2626
2627 add_ani_object (pData, (mng_object_headerp)pCLON);
2628
2629 pCLON->iCloneid = iCloneid;
2630 pCLON->iSourceid = iSourceid;
2631 pCLON->iClonetype = iClonetype;
2632 pCLON->bHasdonotshow = bHasdonotshow;
2633 pCLON->iDonotshow = iDonotshow;
2634 pCLON->iConcrete = iConcrete;
2635 pCLON->bHasloca = bHasloca;
2636 pCLON->iLocatype = iLocatype;
2637 pCLON->iLocax = iLocax;
2638 pCLON->iLocay = iLocay;
2639 }
2640
2641#ifdef MNG_SUPPORT_TRACE
2642 MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLON, MNG_LC_END)
2643#endif
2644
2645 return MNG_NOERROR;
2646}
2647
2648/* ************************************************************************** */
2649
2650mng_retcode free_ani_clon (mng_datap pData,
2651 mng_objectp pObject)
2652{
2653#ifdef MNG_SUPPORT_TRACE
2654 MNG_TRACE (pData, MNG_FN_FREE_ANI_CLON, MNG_LC_START)
2655#endif
2656
2657 MNG_FREEX (pData, pObject, sizeof (mng_ani_clon))
2658
2659#ifdef MNG_SUPPORT_TRACE
2660 MNG_TRACE (pData, MNG_FN_FREE_ANI_CLON, MNG_LC_END)
2661#endif
2662
2663 return MNG_NOERROR;
2664}
2665
2666/* ************************************************************************** */
2667
2668mng_retcode process_ani_clon (mng_datap pData,
2669 mng_objectp pObject)
2670{
2671 mng_ani_clonp pCLON = (mng_ani_clonp)pObject;
2672 mng_retcode iRetcode;
2673
2674#ifdef MNG_SUPPORT_TRACE
2675 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLON, MNG_LC_START)
2676#endif
2677
2678 iRetcode = process_display_clon (pData, pCLON->iCloneid, pCLON->iSourceid,
2679 pCLON->iClonetype, pCLON->bHasdonotshow,
2680 pCLON->iDonotshow, pCLON->iConcrete,
2681 pCLON->bHasloca, pCLON->iLocatype,
2682 pCLON->iLocax, pCLON->iLocay);
2683
2684#ifdef MNG_SUPPORT_TRACE
2685 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLON, MNG_LC_END)
2686#endif
2687
2688 return iRetcode;
2689}
2690
2691/* ************************************************************************** */
2692/* ************************************************************************** */
2693
2694mng_retcode create_ani_back (mng_datap pData,
2695 mng_uint16 iRed,
2696 mng_uint16 iGreen,
2697 mng_uint16 iBlue,
2698 mng_uint8 iMandatory,
2699 mng_uint16 iImageid,
2700 mng_uint8 iTile)
2701{
2702 mng_ani_backp pBACK;
2703
2704#ifdef MNG_SUPPORT_TRACE
2705 MNG_TRACE (pData, MNG_FN_CREATE_ANI_BACK, MNG_LC_START)
2706#endif
2707
2708 if (pData->bCacheplayback) /* caching playback info ? */
2709 {
2710 MNG_ALLOC (pData, pBACK, sizeof (mng_ani_back))
2711
2712 pBACK->sHeader.fCleanup = free_ani_back;
2713 pBACK->sHeader.fProcess = process_ani_back;
2714
2715 add_ani_object (pData, (mng_object_headerp)pBACK);
2716
2717 pBACK->iRed = iRed;
2718 pBACK->iGreen = iGreen;
2719 pBACK->iBlue = iBlue;
2720 pBACK->iMandatory = iMandatory;
2721 pBACK->iImageid = iImageid;
2722 pBACK->iTile = iTile;
2723 }
2724
2725#ifdef MNG_SUPPORT_TRACE
2726 MNG_TRACE (pData, MNG_FN_CREATE_ANI_BACK, MNG_LC_END)
2727#endif
2728
2729 return MNG_NOERROR;
2730}
2731
2732/* ************************************************************************** */
2733
2734mng_retcode free_ani_back (mng_datap pData,
2735 mng_objectp pObject)
2736{
2737#ifdef MNG_SUPPORT_TRACE
2738 MNG_TRACE (pData, MNG_FN_FREE_ANI_BACK, MNG_LC_START)
2739#endif
2740
2741 MNG_FREEX (pData, pObject, sizeof (mng_ani_back))
2742
2743#ifdef MNG_SUPPORT_TRACE
2744 MNG_TRACE (pData, MNG_FN_FREE_ANI_BACK, MNG_LC_END)
2745#endif
2746
2747 return MNG_NOERROR;
2748}
2749
2750/* ************************************************************************** */
2751
2752mng_retcode process_ani_back (mng_datap pData,
2753 mng_objectp pObject)
2754{
2755 mng_ani_backp pBACK = (mng_ani_backp)pObject;
2756
2757#ifdef MNG_SUPPORT_TRACE
2758 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BACK, MNG_LC_START)
2759#endif
2760
2761 pData->iBACKred = pBACK->iRed;
2762 pData->iBACKgreen = pBACK->iGreen;
2763 pData->iBACKblue = pBACK->iBlue;
2764 pData->iBACKmandatory = pBACK->iMandatory;
2765 pData->iBACKimageid = pBACK->iImageid;
2766 pData->iBACKtile = pBACK->iTile;
2767
2768#ifdef MNG_SUPPORT_TRACE
2769 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_BACK, MNG_LC_END)
2770#endif
2771
2772 return MNG_NOERROR;
2773}
2774
2775/* ************************************************************************** */
2776/* ************************************************************************** */
2777
2778mng_retcode create_ani_fram (mng_datap pData,
2779 mng_uint8 iFramemode,
2780 mng_uint8 iChangedelay,
2781 mng_uint32 iDelay,
2782 mng_uint8 iChangetimeout,
2783 mng_uint32 iTimeout,
2784 mng_uint8 iChangeclipping,
2785 mng_uint8 iCliptype,
2786 mng_int32 iClipl,
2787 mng_int32 iClipr,
2788 mng_int32 iClipt,
2789 mng_int32 iClipb)
2790{
2791 mng_ani_framp pFRAM;
2792
2793#ifdef MNG_SUPPORT_TRACE
2794 MNG_TRACE (pData, MNG_FN_CREATE_ANI_FRAM, MNG_LC_START)
2795#endif
2796
2797 if (pData->bCacheplayback) /* caching playback info ? */
2798 {
2799 MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram))
2800
2801 pFRAM->sHeader.fCleanup = free_ani_fram;
2802 pFRAM->sHeader.fProcess = process_ani_fram;
2803
2804 add_ani_object (pData, (mng_object_headerp)pFRAM);
2805
2806 pFRAM->iFramemode = iFramemode;
2807 pFRAM->iChangedelay = iChangedelay;
2808 pFRAM->iDelay = iDelay;
2809 pFRAM->iChangetimeout = iChangetimeout;
2810 pFRAM->iTimeout = iTimeout;
2811 pFRAM->iChangeclipping = iChangeclipping;
2812 pFRAM->iCliptype = iCliptype;
2813 pFRAM->iClipl = iClipl;
2814 pFRAM->iClipr = iClipr;
2815 pFRAM->iClipt = iClipt;
2816 pFRAM->iClipb = iClipb;
2817 }
2818
2819#ifdef MNG_SUPPORT_TRACE
2820 MNG_TRACE (pData, MNG_FN_CREATE_ANI_FRAM, MNG_LC_END)
2821#endif
2822
2823 return MNG_NOERROR;
2824}
2825
2826/* ************************************************************************** */
2827
2828mng_retcode free_ani_fram (mng_datap pData,
2829 mng_objectp pObject)
2830{
2831#ifdef MNG_SUPPORT_TRACE
2832 MNG_TRACE (pData, MNG_FN_FREE_ANI_FRAM, MNG_LC_START)
2833#endif
2834
2835 MNG_FREEX (pData, pObject, sizeof (mng_ani_fram))
2836
2837#ifdef MNG_SUPPORT_TRACE
2838 MNG_TRACE (pData, MNG_FN_FREE_ANI_FRAM, MNG_LC_END)
2839#endif
2840
2841 return MNG_NOERROR;
2842}
2843
2844/* ************************************************************************** */
2845
2846mng_retcode process_ani_fram (mng_datap pData,
2847 mng_objectp pObject)
2848{
2849 mng_ani_framp pFRAM = (mng_ani_framp)pObject;
2850 mng_retcode iRetcode;
2851
2852#ifdef MNG_SUPPORT_TRACE
2853 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_FRAM, MNG_LC_START)
2854#endif
2855
2856 if (pData->iBreakpoint) /* previously broken ? */
2857 {
2858 iRetcode = process_display_fram2 (pData);
2859 pData->iBreakpoint = 0; /* not again */
2860 }
2861 else
2862 iRetcode = process_display_fram (pData, pFRAM->iFramemode,
2863 pFRAM->iChangedelay, pFRAM->iDelay,
2864 pFRAM->iChangetimeout, pFRAM->iTimeout,
2865 pFRAM->iChangeclipping, pFRAM->iCliptype,
2866 pFRAM->iClipl, pFRAM->iClipr,
2867 pFRAM->iClipt, pFRAM->iClipb);
2868
2869#ifdef MNG_SUPPORT_TRACE
2870 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_FRAM, MNG_LC_END)
2871#endif
2872
2873 return iRetcode;
2874}
2875
2876/* ************************************************************************** */
2877/* ************************************************************************** */
2878
2879mng_retcode create_ani_move (mng_datap pData,
2880 mng_uint16 iFirstid,
2881 mng_uint16 iLastid,
2882 mng_uint8 iType,
2883 mng_int32 iLocax,
2884 mng_int32 iLocay)
2885{
2886 mng_ani_movep pMOVE;
2887
2888#ifdef MNG_SUPPORT_TRACE
2889 MNG_TRACE (pData, MNG_FN_CREATE_ANI_MOVE, MNG_LC_START)
2890#endif
2891
2892 if (pData->bCacheplayback) /* caching playback info ? */
2893 {
2894 MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move))
2895
2896 pMOVE->sHeader.fCleanup = free_ani_move;
2897 pMOVE->sHeader.fProcess = process_ani_move;
2898
2899 add_ani_object (pData, (mng_object_headerp)pMOVE);
2900
2901 pMOVE->iFirstid = iFirstid;
2902 pMOVE->iLastid = iLastid;
2903 pMOVE->iType = iType;
2904 pMOVE->iLocax = iLocax;
2905 pMOVE->iLocay = iLocay;
2906 }
2907
2908#ifdef MNG_SUPPORT_TRACE
2909 MNG_TRACE (pData, MNG_FN_CREATE_ANI_MOVE, MNG_LC_END)
2910#endif
2911
2912 return MNG_NOERROR;
2913}
2914
2915/* ************************************************************************** */
2916
2917mng_retcode free_ani_move (mng_datap pData,
2918 mng_objectp pObject)
2919{
2920#ifdef MNG_SUPPORT_TRACE
2921 MNG_TRACE (pData, MNG_FN_FREE_ANI_MOVE, MNG_LC_START)
2922#endif
2923
2924 MNG_FREEX (pData, pObject, sizeof (mng_ani_move))
2925
2926#ifdef MNG_SUPPORT_TRACE
2927 MNG_TRACE (pData, MNG_FN_FREE_ANI_MOVE, MNG_LC_END)
2928#endif
2929
2930 return MNG_NOERROR;
2931}
2932
2933/* ************************************************************************** */
2934
2935mng_retcode process_ani_move (mng_datap pData,
2936 mng_objectp pObject)
2937{
2938 mng_retcode iRetcode;
2939 mng_ani_movep pMOVE = (mng_ani_movep)pObject;
2940
2941#ifdef MNG_SUPPORT_TRACE
2942 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MOVE, MNG_LC_START)
2943#endif
2944 /* re-process the MOVE chunk */
2945 iRetcode = process_display_move (pData, pMOVE->iFirstid, pMOVE->iLastid,
2946 pMOVE->iType,
2947 pMOVE->iLocax, pMOVE->iLocay);
2948
2949#ifdef MNG_SUPPORT_TRACE
2950 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MOVE, MNG_LC_END)
2951#endif
2952
2953 return iRetcode;
2954}
2955
2956/* ************************************************************************** */
2957/* ************************************************************************** */
2958
2959mng_retcode create_ani_clip (mng_datap pData,
2960 mng_uint16 iFirstid,
2961 mng_uint16 iLastid,
2962 mng_uint8 iType,
2963 mng_int32 iClipl,
2964 mng_int32 iClipr,
2965 mng_int32 iClipt,
2966 mng_int32 iClipb)
2967{
2968 mng_ani_clipp pCLIP;
2969
2970#ifdef MNG_SUPPORT_TRACE
2971 MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLIP, MNG_LC_START)
2972#endif
2973
2974 if (pData->bCacheplayback) /* caching playback info ? */
2975 {
2976 MNG_ALLOC (pData, pCLIP, sizeof (mng_ani_clip))
2977
2978 pCLIP->sHeader.fCleanup = free_ani_clip;
2979 pCLIP->sHeader.fProcess = process_ani_clip;
2980
2981 add_ani_object (pData, (mng_object_headerp)pCLIP);
2982
2983 pCLIP->iFirstid = iFirstid;
2984 pCLIP->iLastid = iLastid;
2985 pCLIP->iType = iType;
2986 pCLIP->iClipl = iClipl;
2987 pCLIP->iClipr = iClipr;
2988 pCLIP->iClipt = iClipt;
2989 pCLIP->iClipb = iClipb;
2990 }
2991
2992#ifdef MNG_SUPPORT_TRACE
2993 MNG_TRACE (pData, MNG_FN_CREATE_ANI_CLIP, MNG_LC_END)
2994#endif
2995
2996 return MNG_NOERROR;
2997}
2998
2999/* ************************************************************************** */
3000
3001mng_retcode free_ani_clip (mng_datap pData,
3002 mng_objectp pObject)
3003{
3004#ifdef MNG_SUPPORT_TRACE
3005 MNG_TRACE (pData, MNG_FN_FREE_ANI_CLIP, MNG_LC_START)
3006#endif
3007
3008 MNG_FREEX (pData, pObject, sizeof (mng_ani_clip))
3009
3010#ifdef MNG_SUPPORT_TRACE
3011 MNG_TRACE (pData, MNG_FN_FREE_ANI_CLIP, MNG_LC_END)
3012#endif
3013
3014 return MNG_NOERROR;
3015}
3016
3017/* ************************************************************************** */
3018
3019mng_retcode process_ani_clip (mng_datap pData,
3020 mng_objectp pObject)
3021{
3022 mng_retcode iRetcode;
3023 mng_ani_clipp pCLIP = (mng_ani_clipp)pObject;
3024
3025#ifdef MNG_SUPPORT_TRACE
3026 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLIP, MNG_LC_START)
3027#endif
3028 /* re-process the CLIP chunk */
3029 iRetcode = process_display_clip (pData, pCLIP->iFirstid, pCLIP->iLastid,
3030 pCLIP->iType,
3031 pCLIP->iClipl, pCLIP->iClipr,
3032 pCLIP->iClipt, pCLIP->iClipb);
3033
3034#ifdef MNG_SUPPORT_TRACE
3035 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_CLIP, MNG_LC_END)
3036#endif
3037
3038 return iRetcode;
3039}
3040
3041/* ************************************************************************** */
3042/* ************************************************************************** */
3043
3044mng_retcode create_ani_show (mng_datap pData,
3045 mng_uint16 iFirstid,
3046 mng_uint16 iLastid,
3047 mng_uint8 iMode)
3048{
3049 mng_ani_showp pSHOW;
3050
3051#ifdef MNG_SUPPORT_TRACE
3052 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SHOW, MNG_LC_START)
3053#endif
3054
3055 if (pData->bCacheplayback) /* caching playback info ? */
3056 {
3057 MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show))
3058
3059 pSHOW->sHeader.fCleanup = free_ani_show;
3060 pSHOW->sHeader.fProcess = process_ani_show;
3061
3062 add_ani_object (pData, (mng_object_headerp)pSHOW);
3063
3064 pSHOW->iFirstid = iFirstid;
3065 pSHOW->iLastid = iLastid;
3066 pSHOW->iMode = iMode;
3067 }
3068
3069#ifdef MNG_SUPPORT_TRACE
3070 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SHOW, MNG_LC_END)
3071#endif
3072
3073 return MNG_NOERROR;
3074}
3075
3076/* ************************************************************************** */
3077
3078mng_retcode free_ani_show (mng_datap pData,
3079 mng_objectp pObject)
3080{
3081#ifdef MNG_SUPPORT_TRACE
3082 MNG_TRACE (pData, MNG_FN_FREE_ANI_SHOW, MNG_LC_START)
3083#endif
3084
3085 MNG_FREEX (pData, pObject, sizeof (mng_ani_show))
3086
3087#ifdef MNG_SUPPORT_TRACE
3088 MNG_TRACE (pData, MNG_FN_FREE_ANI_SHOW, MNG_LC_END)
3089#endif
3090
3091 return MNG_NOERROR;
3092}
3093
3094/* ************************************************************************** */
3095
3096mng_retcode process_ani_show (mng_datap pData,
3097 mng_objectp pObject)
3098{
3099 mng_retcode iRetcode;
3100 mng_ani_showp pSHOW = (mng_ani_showp)pObject;
3101
3102#ifdef MNG_SUPPORT_TRACE
3103 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SHOW, MNG_LC_START)
3104#endif
3105
3106 if (pData->iBreakpoint) /* returning from breakpoint ? */
3107 {
3108 iRetcode = process_display_show (pData);
3109 }
3110 else
3111 { /* "re-run" SHOW chunk */
3112 pData->iSHOWmode = pSHOW->iMode;
3113 pData->iSHOWfromid = pSHOW->iFirstid;
3114 pData->iSHOWtoid = pSHOW->iLastid;
3115
3116 iRetcode = process_display_show (pData);
3117 }
3118
3119#ifdef MNG_SUPPORT_TRACE
3120 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SHOW, MNG_LC_END)
3121#endif
3122
3123 return iRetcode;
3124}
3125
3126/* ************************************************************************** */
3127/* ************************************************************************** */
3128
3129mng_retcode create_ani_term (mng_datap pData,
3130 mng_uint8 iTermaction,
3131 mng_uint8 iIteraction,
3132 mng_uint32 iDelay,
3133 mng_uint32 iItermax)
3134{
3135 mng_ani_termp pTERM;
3136
3137#ifdef MNG_SUPPORT_TRACE
3138 MNG_TRACE (pData, MNG_FN_CREATE_ANI_TERM, MNG_LC_START)
3139#endif
3140
3141 if (pData->bCacheplayback) /* caching playback info ? */
3142 {
3143 MNG_ALLOC (pData, pTERM, sizeof (mng_ani_term))
3144
3145 pTERM->sHeader.fCleanup = free_ani_term;
3146 pTERM->sHeader.fProcess = process_ani_term;
3147
3148 add_ani_object (pData, (mng_object_headerp)pTERM);
3149
3150 pTERM->iTermaction = iTermaction;
3151 pTERM->iIteraction = iIteraction;
3152 pTERM->iDelay = iDelay;
3153 pTERM->iItermax = iItermax;
3154 }
3155
3156#ifdef MNG_SUPPORT_TRACE
3157 MNG_TRACE (pData, MNG_FN_CREATE_ANI_TERM, MNG_LC_END)
3158#endif
3159
3160 return MNG_NOERROR;
3161}
3162
3163/* ************************************************************************** */
3164
3165mng_retcode free_ani_term (mng_datap pData,
3166 mng_objectp pObject)
3167{
3168#ifdef MNG_SUPPORT_TRACE
3169 MNG_TRACE (pData, MNG_FN_FREE_ANI_TERM, MNG_LC_START)
3170#endif
3171
3172 MNG_FREEX (pData, pObject, sizeof (mng_ani_term))
3173
3174#ifdef MNG_SUPPORT_TRACE
3175 MNG_TRACE (pData, MNG_FN_FREE_ANI_TERM, MNG_LC_END)
3176#endif
3177
3178 return MNG_NOERROR;
3179}
3180
3181/* ************************************************************************** */
3182
3183mng_retcode process_ani_term (mng_datap pData,
3184 mng_objectp pObject)
3185{
3186#ifdef MNG_SUPPORT_TRACE
3187 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TERM, MNG_LC_START)
3188#endif
3189
3190 /* dummy: no action required! */
3191
3192#ifdef MNG_SUPPORT_TRACE
3193 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_TERM, MNG_LC_END)
3194#endif
3195
3196 return MNG_NOERROR;
3197}
3198
3199/* ************************************************************************** */
3200/* ************************************************************************** */
3201
3202mng_retcode create_ani_save (mng_datap pData)
3203{
3204 mng_ani_savep pSAVE;
3205
3206#ifdef MNG_SUPPORT_TRACE
3207 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SAVE, MNG_LC_START)
3208#endif
3209
3210 if (pData->bCacheplayback) /* caching playback info ? */
3211 {
3212 MNG_ALLOC (pData, pSAVE, sizeof (mng_ani_save))
3213
3214 pSAVE->sHeader.fCleanup = free_ani_save;
3215 pSAVE->sHeader.fProcess = process_ani_save;
3216
3217 add_ani_object (pData, (mng_object_headerp)pSAVE);
3218 }
3219
3220#ifdef MNG_SUPPORT_TRACE
3221 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SAVE, MNG_LC_END)
3222#endif
3223
3224 return MNG_NOERROR;
3225}
3226
3227/* ************************************************************************** */
3228
3229mng_retcode free_ani_save (mng_datap pData,
3230 mng_objectp pObject)
3231{
3232#ifdef MNG_SUPPORT_TRACE
3233 MNG_TRACE (pData, MNG_FN_FREE_ANI_SAVE, MNG_LC_START)
3234#endif
3235
3236 MNG_FREEX (pData, pObject, sizeof (mng_ani_save))
3237
3238#ifdef MNG_SUPPORT_TRACE
3239 MNG_TRACE (pData, MNG_FN_FREE_ANI_SAVE, MNG_LC_END)
3240#endif
3241
3242 return MNG_NOERROR;
3243}
3244
3245/* ************************************************************************** */
3246
3247mng_retcode process_ani_save (mng_datap pData,
3248 mng_objectp pObject)
3249{
3250 mng_retcode iRetcode;
3251
3252#ifdef MNG_SUPPORT_TRACE
3253 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SAVE, MNG_LC_START)
3254#endif
3255
3256 iRetcode = process_display_save (pData);
3257
3258 if (iRetcode) /* on error bail out */
3259 return iRetcode;
3260
3261#ifdef MNG_SUPPORT_TRACE
3262 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SAVE, MNG_LC_END)
3263#endif
3264
3265 return MNG_NOERROR;
3266}
3267
3268/* ************************************************************************** */
3269/* ************************************************************************** */
3270
3271mng_retcode create_ani_seek (mng_datap pData)
3272{
3273 mng_ani_seekp pSEEK;
3274
3275#ifdef MNG_SUPPORT_TRACE
3276 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SEEK, MNG_LC_START)
3277#endif
3278
3279 if (pData->bCacheplayback) /* caching playback info ? */
3280 {
3281 MNG_ALLOC (pData, pSEEK, sizeof (mng_ani_seek))
3282
3283 pSEEK->sHeader.fCleanup = free_ani_seek;
3284 pSEEK->sHeader.fProcess = process_ani_seek;
3285
3286 add_ani_object (pData, (mng_object_headerp)pSEEK);
3287 }
3288
3289#ifdef MNG_SUPPORT_TRACE
3290 MNG_TRACE (pData, MNG_FN_CREATE_ANI_SEEK, MNG_LC_END)
3291#endif
3292
3293 return MNG_NOERROR;
3294}
3295
3296/* ************************************************************************** */
3297
3298mng_retcode free_ani_seek (mng_datap pData,
3299 mng_objectp pObject)
3300{
3301#ifdef MNG_SUPPORT_TRACE
3302 MNG_TRACE (pData, MNG_FN_FREE_ANI_SEEK, MNG_LC_START)
3303#endif
3304
3305 MNG_FREEX (pData, pObject, sizeof (mng_ani_seek))
3306
3307#ifdef MNG_SUPPORT_TRACE
3308 MNG_TRACE (pData, MNG_FN_FREE_ANI_SEEK, MNG_LC_END)
3309#endif
3310
3311 return MNG_NOERROR;
3312}
3313
3314/* ************************************************************************** */
3315
3316mng_retcode process_ani_seek (mng_datap pData,
3317 mng_objectp pObject)
3318{
3319 mng_retcode iRetcode;
3320
3321#ifdef MNG_SUPPORT_TRACE
3322 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SEEK, MNG_LC_START)
3323#endif
3324
3325 iRetcode = process_display_seek (pData);
3326
3327 if (iRetcode) /* on error bail out */
3328 return iRetcode;
3329
3330#ifdef MNG_SUPPORT_TRACE
3331 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_SEEK, MNG_LC_END)
3332#endif
3333
3334 return MNG_NOERROR;
3335}
3336
3337/* ************************************************************************** */
3338/* ************************************************************************** */
3339
3340mng_retcode create_ani_dhdr (mng_datap pData,
3341 mng_uint16 iObjectid,
3342 mng_uint8 iImagetype,
3343 mng_uint8 iDeltatype,
3344 mng_uint32 iBlockwidth,
3345 mng_uint32 iBlockheight,
3346 mng_uint32 iBlockx,
3347 mng_uint32 iBlocky)
3348{
3349 mng_ani_dhdrp pDHDR;
3350
3351#ifdef MNG_SUPPORT_TRACE
3352 MNG_TRACE (pData, MNG_FN_CREATE_ANI_DHDR, MNG_LC_START)
3353#endif
3354
3355 if (pData->bCacheplayback) /* caching playback info ? */
3356 {
3357 MNG_ALLOC (pData, pDHDR, sizeof (mng_ani_dhdr))
3358
3359 pDHDR->sHeader.fCleanup = free_ani_dhdr;
3360 pDHDR->sHeader.fProcess = process_ani_dhdr;
3361
3362 pDHDR->iObjectid = iObjectid;
3363 pDHDR->iImagetype = iImagetype;
3364 pDHDR->iDeltatype = iDeltatype;
3365 pDHDR->iBlockwidth = iBlockwidth;
3366 pDHDR->iBlockheight = iBlockheight;
3367 pDHDR->iBlockx = iBlockx;
3368 pDHDR->iBlocky = iBlocky;
3369
3370 add_ani_object (pData, (mng_object_headerp)pDHDR);
3371 }
3372
3373#ifdef MNG_SUPPORT_TRACE
3374 MNG_TRACE (pData, MNG_FN_CREATE_ANI_DHDR, MNG_LC_END)
3375#endif
3376
3377 return MNG_NOERROR;
3378}
3379
3380/* ************************************************************************** */
3381
3382mng_retcode free_ani_dhdr (mng_datap pData,
3383 mng_objectp pObject)
3384{
3385#ifdef MNG_SUPPORT_TRACE
3386 MNG_TRACE (pData, MNG_FN_FREE_ANI_DHDR, MNG_LC_START)
3387#endif
3388
3389 MNG_FREEX (pData, pObject, sizeof (mng_ani_dhdr))
3390
3391#ifdef MNG_SUPPORT_TRACE
3392 MNG_TRACE (pData, MNG_FN_FREE_ANI_DHDR, MNG_LC_END)
3393#endif
3394
3395 return MNG_NOERROR;
3396}
3397
3398/* ************************************************************************** */
3399
3400mng_retcode process_ani_dhdr (mng_datap pData,
3401 mng_objectp pObject)
3402{
3403 mng_ani_dhdrp pDHDR = (mng_ani_dhdrp)pObject;
3404 mng_retcode iRetcode;
3405
3406#ifdef MNG_SUPPORT_TRACE
3407 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DHDR, MNG_LC_START)
3408#endif
3409
3410 pData->bHasDHDR = MNG_TRUE; /* let everyone know we're inside a DHDR */
3411
3412 iRetcode = process_display_dhdr (pData, pDHDR->iObjectid,
3413 pDHDR->iImagetype, pDHDR->iDeltatype,
3414 pDHDR->iBlockwidth, pDHDR->iBlockheight,
3415 pDHDR->iBlockx, pDHDR->iBlocky);
3416
3417 if (iRetcode) /* on error bail out */
3418 return iRetcode;
3419
3420#ifdef MNG_SUPPORT_TRACE
3421 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_DHDR, MNG_LC_END)
3422#endif
3423
3424 return MNG_NOERROR;
3425}
3426
3427/* ************************************************************************** */
3428/* ************************************************************************** */
3429
3430mng_retcode create_ani_prom (mng_datap pData,
3431 mng_uint8 iBitdepth,
3432 mng_uint8 iColortype,
3433 mng_uint8 iFilltype)
3434{
3435 mng_ani_promp pPROM;
3436
3437#ifdef MNG_SUPPORT_TRACE
3438 MNG_TRACE (pData, MNG_FN_CREATE_ANI_PROM, MNG_LC_START)
3439#endif
3440
3441 if (pData->bCacheplayback) /* caching playback info ? */
3442 {
3443 MNG_ALLOC (pData, pPROM, sizeof (mng_ani_prom))
3444
3445 pPROM->sHeader.fCleanup = free_ani_prom;
3446 pPROM->sHeader.fProcess = process_ani_prom;
3447
3448 pPROM->iBitdepth = iBitdepth;
3449 pPROM->iColortype = iColortype;
3450 pPROM->iFilltype = iFilltype;
3451
3452 add_ani_object (pData, (mng_object_headerp)pPROM);
3453 }
3454
3455#ifdef MNG_SUPPORT_TRACE
3456 MNG_TRACE (pData, MNG_FN_CREATE_ANI_PROM, MNG_LC_END)
3457#endif
3458
3459 return MNG_NOERROR;
3460}
3461
3462/* ************************************************************************** */
3463
3464mng_retcode free_ani_prom (mng_datap pData,
3465 mng_objectp pObject)
3466{
3467#ifdef MNG_SUPPORT_TRACE
3468 MNG_TRACE (pData, MNG_FN_FREE_ANI_PROM, MNG_LC_START)
3469#endif
3470
3471 MNG_FREEX (pData, pObject, sizeof (mng_ani_prom))
3472
3473#ifdef MNG_SUPPORT_TRACE
3474 MNG_TRACE (pData, MNG_FN_FREE_ANI_PROM, MNG_LC_END)
3475#endif
3476
3477 return MNG_NOERROR;
3478}
3479
3480/* ************************************************************************** */
3481
3482mng_retcode process_ani_prom (mng_datap pData,
3483 mng_objectp pObject)
3484{
3485 mng_ani_promp pPROM = (mng_ani_promp)pObject;
3486 mng_retcode iRetcode;
3487
3488#ifdef MNG_SUPPORT_TRACE
3489 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PROM, MNG_LC_START)
3490#endif
3491
3492 iRetcode = process_display_prom (pData, pPROM->iBitdepth,
3493 pPROM->iColortype, pPROM->iFilltype);
3494
3495 if (iRetcode) /* on error bail out */
3496 return iRetcode;
3497
3498#ifdef MNG_SUPPORT_TRACE
3499 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PROM, MNG_LC_END)
3500#endif
3501
3502 return MNG_NOERROR;
3503}
3504
3505/* ************************************************************************** */
3506/* ************************************************************************** */
3507
3508mng_retcode create_ani_ipng (mng_datap pData)
3509{
3510 mng_ani_ipngp pIPNG;
3511
3512#ifdef MNG_SUPPORT_TRACE
3513 MNG_TRACE (pData, MNG_FN_CREATE_ANI_IPNG, MNG_LC_START)
3514#endif
3515
3516 if (pData->bCacheplayback) /* caching playback info ? */
3517 {
3518 MNG_ALLOC (pData, pIPNG, sizeof (mng_ani_ipng))
3519
3520 pIPNG->sHeader.fCleanup = free_ani_ipng;
3521 pIPNG->sHeader.fProcess = process_ani_ipng;
3522
3523 add_ani_object (pData, (mng_object_headerp)pIPNG);
3524 }
3525
3526#ifdef MNG_SUPPORT_TRACE
3527 MNG_TRACE (pData, MNG_FN_CREATE_ANI_IPNG, MNG_LC_END)
3528#endif
3529
3530 return MNG_NOERROR;
3531}
3532
3533/* ************************************************************************** */
3534
3535mng_retcode free_ani_ipng (mng_datap pData,
3536 mng_objectp pObject)
3537{
3538#ifdef MNG_SUPPORT_TRACE
3539 MNG_TRACE (pData, MNG_FN_FREE_ANI_IPNG, MNG_LC_START)
3540#endif
3541
3542 MNG_FREEX (pData, pObject, sizeof (mng_ani_ipng))
3543
3544#ifdef MNG_SUPPORT_TRACE
3545 MNG_TRACE (pData, MNG_FN_FREE_ANI_IPNG, MNG_LC_END)
3546#endif
3547
3548 return MNG_NOERROR;
3549}
3550
3551/* ************************************************************************** */
3552
3553mng_retcode process_ani_ipng (mng_datap pData,
3554 mng_objectp pObject)
3555{
3556 mng_retcode iRetcode;
3557
3558#ifdef MNG_SUPPORT_TRACE
3559 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IPNG, MNG_LC_START)
3560#endif
3561
3562 iRetcode = process_display_ipng (pData);
3563
3564 if (iRetcode) /* on error bail out */
3565 return iRetcode;
3566
3567#ifdef MNG_SUPPORT_TRACE
3568 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IPNG, MNG_LC_END)
3569#endif
3570
3571 return MNG_NOERROR;
3572}
3573
3574/* ************************************************************************** */
3575/* ************************************************************************** */
3576
3577mng_retcode create_ani_ijng (mng_datap pData)
3578{
3579 mng_ani_ijngp pIJNG;
3580
3581#ifdef MNG_SUPPORT_TRACE
3582 MNG_TRACE (pData, MNG_FN_CREATE_ANI_IJNG, MNG_LC_START)
3583#endif
3584
3585 if (pData->bCacheplayback) /* caching playback info ? */
3586 {
3587 MNG_ALLOC (pData, pIJNG, sizeof (mng_ani_ijng))
3588
3589 pIJNG->sHeader.fCleanup = free_ani_ijng;
3590 pIJNG->sHeader.fProcess = process_ani_ijng;
3591
3592 add_ani_object (pData, (mng_object_headerp)pIJNG);
3593 }
3594
3595#ifdef MNG_SUPPORT_TRACE
3596 MNG_TRACE (pData, MNG_FN_CREATE_ANI_IJNG, MNG_LC_END)
3597#endif
3598
3599 return MNG_NOERROR;
3600}
3601
3602/* ************************************************************************** */
3603
3604mng_retcode free_ani_ijng (mng_datap pData,
3605 mng_objectp pObject)
3606{
3607#ifdef MNG_SUPPORT_TRACE
3608 MNG_TRACE (pData, MNG_FN_FREE_ANI_IJNG, MNG_LC_START)
3609#endif
3610
3611 MNG_FREEX (pData, pObject, sizeof (mng_ani_ijng))
3612
3613#ifdef MNG_SUPPORT_TRACE
3614 MNG_TRACE (pData, MNG_FN_FREE_ANI_IJNG, MNG_LC_END)
3615#endif
3616
3617 return MNG_NOERROR;
3618}
3619
3620/* ************************************************************************** */
3621
3622mng_retcode process_ani_ijng (mng_datap pData,
3623 mng_objectp pObject)
3624{
3625 mng_retcode iRetcode;
3626
3627#ifdef MNG_SUPPORT_TRACE
3628 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IJNG, MNG_LC_START)
3629#endif
3630
3631 iRetcode = process_display_ijng (pData);
3632
3633 if (iRetcode) /* on error bail out */
3634 return iRetcode;
3635
3636#ifdef MNG_SUPPORT_TRACE
3637 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_IJNG, MNG_LC_END)
3638#endif
3639
3640 return MNG_NOERROR;
3641}
3642
3643/* ************************************************************************** */
3644/* ************************************************************************** */
3645
3646mng_retcode create_ani_pplt (mng_datap pData,
3647 mng_uint8 iType,
3648 mng_uint32 iCount,
3649 mng_palette8ep paIndexentries,
3650 mng_uint8p paAlphaentries,
3651 mng_uint8p paUsedentries)
3652{
3653 mng_ani_ppltp pPPLT;
3654
3655#ifdef MNG_SUPPORT_TRACE
3656 MNG_TRACE (pData, MNG_FN_CREATE_ANI_PPLT, MNG_LC_START)
3657#endif
3658
3659 if (pData->bCacheplayback) /* caching playback info ? */
3660 {
3661 MNG_ALLOC (pData, pPPLT, sizeof (mng_ani_pplt))
3662
3663 pPPLT->sHeader.fCleanup = free_ani_pplt;
3664 pPPLT->sHeader.fProcess = process_ani_pplt;
3665
3666 pPPLT->iType = iType;
3667 pPPLT->iCount = iCount;
3668
3669 MNG_COPY (pPPLT->aIndexentries, paIndexentries, sizeof (pPPLT->aIndexentries))
3670 MNG_COPY (pPPLT->aAlphaentries, paAlphaentries, sizeof (pPPLT->aAlphaentries))
3671 MNG_COPY (pPPLT->aUsedentries, paUsedentries, sizeof (pPPLT->aUsedentries ))
3672
3673 add_ani_object (pData, (mng_object_headerp)pPPLT);
3674 }
3675
3676#ifdef MNG_SUPPORT_TRACE
3677 MNG_TRACE (pData, MNG_FN_CREATE_ANI_PPLT, MNG_LC_END)
3678#endif
3679
3680 return MNG_NOERROR;
3681}
3682
3683/* ************************************************************************** */
3684
3685mng_retcode free_ani_pplt (mng_datap pData,
3686 mng_objectp pObject)
3687{
3688#ifdef MNG_SUPPORT_TRACE
3689 MNG_TRACE (pData, MNG_FN_FREE_ANI_PPLT, MNG_LC_START)
3690#endif
3691
3692 MNG_FREEX (pData, pObject, sizeof (mng_ani_pplt))
3693
3694#ifdef MNG_SUPPORT_TRACE
3695 MNG_TRACE (pData, MNG_FN_FREE_ANI_PPLT, MNG_LC_END)
3696#endif
3697
3698 return MNG_NOERROR;
3699}
3700
3701/* ************************************************************************** */
3702
3703mng_retcode process_ani_pplt (mng_datap pData,
3704 mng_objectp pObject)
3705{
3706 mng_ani_ppltp pPPLT = (mng_ani_ppltp)pObject;
3707 mng_retcode iRetcode;
3708
3709#ifdef MNG_SUPPORT_TRACE
3710 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PPLT, MNG_LC_START)
3711#endif
3712
3713 iRetcode = process_display_pplt (pData, pPPLT->iType, pPPLT->iCount,
3714 pPPLT->aIndexentries, pPPLT->aAlphaentries,
3715 pPPLT->aUsedentries);
3716
3717 if (iRetcode) /* on error bail out */
3718 return iRetcode;
3719
3720#ifdef MNG_SUPPORT_TRACE
3721 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_PPLT, MNG_LC_END)
3722#endif
3723
3724 return MNG_NOERROR;
3725}
3726
3727/* ************************************************************************** */
3728/* ************************************************************************** */
3729
3730mng_retcode create_ani_magn (mng_datap pData,
3731 mng_uint16 iFirstid,
3732 mng_uint16 iLastid,
3733 mng_uint16 iMethodX,
3734 mng_uint16 iMX,
3735 mng_uint16 iMY,
3736 mng_uint16 iML,
3737 mng_uint16 iMR,
3738 mng_uint16 iMT,
3739 mng_uint16 iMB,
3740 mng_uint16 iMethodY)
3741{
3742 mng_ani_magnp pMAGN;
3743
3744#ifdef MNG_SUPPORT_TRACE
3745 MNG_TRACE (pData, MNG_FN_CREATE_ANI_MAGN, MNG_LC_START)
3746#endif
3747
3748 if (pData->bCacheplayback) /* caching playback info ? */
3749 {
3750 MNG_ALLOC (pData, pMAGN, sizeof (mng_ani_magn))
3751
3752 pMAGN->sHeader.fCleanup = free_ani_magn;
3753 pMAGN->sHeader.fProcess = process_ani_magn;
3754
3755 pMAGN->iFirstid = iFirstid;
3756 pMAGN->iLastid = iLastid;
3757 pMAGN->iMethodX = iMethodX;
3758 pMAGN->iMX = iMX;
3759 pMAGN->iMY = iMY;
3760 pMAGN->iML = iML;
3761 pMAGN->iMR = iMR;
3762 pMAGN->iMT = iMT;
3763 pMAGN->iMB = iMB;
3764 pMAGN->iMethodY = iMethodY;
3765
3766 add_ani_object (pData, (mng_object_headerp)pMAGN);
3767 }
3768
3769#ifdef MNG_SUPPORT_TRACE
3770 MNG_TRACE (pData, MNG_FN_CREATE_ANI_MAGN, MNG_LC_END)
3771#endif
3772
3773 return MNG_NOERROR;
3774}
3775
3776/* ************************************************************************** */
3777
3778mng_retcode free_ani_magn (mng_datap pData,
3779 mng_objectp pObject)
3780{
3781#ifdef MNG_SUPPORT_TRACE
3782 MNG_TRACE (pData, MNG_FN_FREE_ANI_MAGN, MNG_LC_START)
3783#endif
3784
3785 MNG_FREEX (pData, pObject, sizeof (mng_ani_magn))
3786
3787#ifdef MNG_SUPPORT_TRACE
3788 MNG_TRACE (pData, MNG_FN_FREE_ANI_MAGN, MNG_LC_END)
3789#endif
3790
3791 return MNG_NOERROR;
3792}
3793
3794/* ************************************************************************** */
3795
3796mng_retcode process_ani_magn (mng_datap pData,
3797 mng_objectp pObject)
3798{
3799 mng_ani_magnp pMAGN = (mng_ani_magnp)pObject;
3800 mng_retcode iRetcode;
3801
3802#ifdef MNG_SUPPORT_TRACE
3803 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MAGN, MNG_LC_START)
3804#endif
3805
3806 iRetcode = process_display_magn (pData, pMAGN->iFirstid, pMAGN->iLastid,
3807 pMAGN->iMethodX, pMAGN->iMX, pMAGN->iMY,
3808 pMAGN->iML, pMAGN->iMR, pMAGN->iMT, pMAGN->iMB,
3809 pMAGN->iMethodY);
3810
3811 if (iRetcode) /* on error bail out */
3812 return iRetcode;
3813
3814#ifdef MNG_SUPPORT_TRACE
3815 MNG_TRACE (pData, MNG_FN_PROCESS_ANI_MAGN, MNG_LC_END)
3816#endif
3817
3818 return MNG_NOERROR;
3819}
3820
3821/* ************************************************************************** */
3822
3823#endif /* MNG_INCLUDE_DISPLAY_PROCS */
3824
3825/* ************************************************************************** */
3826/* * end of file * */
3827/* ************************************************************************** */
3828
Note: See TracBrowser for help on using the repository browser.