← Back to branch summary

~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/LibMNG/libmng_object_prc.c

  • Committer: Bazaar Package Importer
  • Author(s): Cosme Domínguez Díaz
  • Date: 2010-07-20 13:42:15 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100720134215-xt1454zaedv3b604
Tags: 3.13.1-0ubuntu1
https://launchpad.net/bugs/607800
* New upstream release. Closes: (LP: #607800)
 - Updated debian/freeimage-get-orig-source script.
 - Removing no longer necessary debian/patches/* and
   the patch system in debian/rules.
 - Updated debian/rules to work with the new Makefiles.
 - Drop from -O3 to -O2 and use lzma compression saves
   ~10 MB of free space. 
* lintian stuff
 - fixed debhelper-but-no-misc-depends
 - fixed ldconfig-symlink-missing-for-shlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/LibMNG/libmng_object_prc.c
4
4
/* ************************************************************************** */
5
5
/* *                                                                        * */
6
6
/* * project   : libmng                                                     * */
7
 
/* * file      : libmng_object_prc.c       copyright (c) 2000-2004 G.Juyn   * */
8
 
/* * version   : 1.0.9                                                      * */
 
7
/* * file      : libmng_object_prc.c       copyright (c) 2000-2007 G.Juyn   * */
 
8
/* * version   : 1.0.10                                                     * */
9
9
/* *                                                                        * */
10
10
/* * purpose   : Object processing routines (implementation)                * */
11
11
/* *                                                                        * */
138
138
/* *             1.0.9 - 01/02/2005 - G.Juyn                                * */
139
139
/* *             - fixing some compiler-warnings                            * */
140
140
/* *                                                                        * */
 
141
/* *             1.0.10 - 02/07/2005 - G.Juyn                               * */
 
142
/* *             - fixed some compiler-warnings                             * */
 
143
/* *             1.0.10 - 07/30/2005 - G.Juyn                               * */
 
144
/* *             - fixed problem with CLON object during readdisplay()      * */
 
145
/* *             1.0.10 - 04/08/2007 - G.Juyn                               * */
 
146
/* *             - added support for mPNG proposal                          * */
 
147
/* *             1.0.10 - 04/12/2007 - G.Juyn                               * */
 
148
/* *             - added support for ANG proposal                           * */
 
149
/* *                                                                        * */
141
150
/* ************************************************************************** */
142
151
 
143
152
#include "libmng.h"
252
261
                                        mng_uint8      iInterlace,
253
262
                                        mng_imagedatap *ppObject)
254
263
{
255
 
  mng_ptr pTemp;
256
264
  mng_imagedatap pImagedata;
257
265
  mng_uint32 iSamplesize = 0;
258
266
 
262
270
                                       /* get a buffer */
263
271
#ifdef MNG_OPTIMIZE_OBJCLEANUP
264
272
  {
 
273
    mng_ptr pTemp;
265
274
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_imagedata),
266
275
                                               (mng_cleanupobject)mng_free_imagedataobject,
267
276
                                               MNG_NULL, &pTemp);
672
681
  }
673
682
                                       /* unlink the image-data buffer */
674
683
  iRetcode = mng_free_imagedataobject (pData, pImgbuf);
675
 
                                       /* drop it's own buffer */
 
684
                                       /* drop its own buffer */
676
685
  MNG_FREEX (pData, pImage, sizeof (mng_image));
677
686
 
678
687
#ifdef MNG_SUPPORT_TRACE
696
705
  while ((pImage) && (pImage->iId != iId))
697
706
    pImage = (mng_imagep)pImage->sHeader.pNext;
698
707
 
 
708
#ifdef MNG_INCLUDE_MPNG_PROPOSAL
 
709
  if ((!pImage) && (pData->eImagetype == mng_it_mpng))
 
710
    pImage = pData->pObjzero;
 
711
#endif
 
712
 
699
713
#ifdef MNG_SUPPORT_TRACE
700
714
  MNG_TRACEX (pData, MNG_FN_FIND_IMGOBJECT, MNG_LC_END);
701
715
#endif
717
731
                                   mng_imagep pSource,
718
732
                                   mng_imagep *ppClone)
719
733
{
720
 
  mng_ptr        pTemp;
721
734
  mng_imagep     pNew;
722
735
  mng_imagep     pPrev, pNext;
723
736
  mng_retcode    iRetcode;
740
753
                                       /* get a buffer */
741
754
#ifdef MNG_OPTIMIZE_OBJCLEANUP
742
755
  {
 
756
    mng_ptr     pTemp;
743
757
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_image),
744
758
                                               (mng_cleanupobject)mng_free_imageobject,
745
759
                                               MNG_NULL, &pTemp);
2406
2420
#endif
2407
2421
                                       /* unlink the image-data buffer */
2408
2422
  iRetcode = mng_free_imagedataobject (pData, pImgbuf);
2409
 
                                       /* drop it's own buffer */
 
2423
                                       /* drop its own buffer */
2410
2424
  MNG_FREEX (pData, pImage, sizeof (mng_ani_image));
2411
2425
 
2412
2426
#ifdef MNG_SUPPORT_TRACE
2556
2570
mng_retcode mng_create_ani_plte (mng_datap      pData)
2557
2571
#endif
2558
2572
{
2559
 
  mng_ptr       pTemp;
2560
2573
  mng_ani_pltep pPLTE;
2561
2574
 
2562
2575
#ifdef MNG_SUPPORT_TRACE
2566
2579
  if (pData->bCacheplayback)           /* caching playback info ? */
2567
2580
  {
2568
2581
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
2582
    mng_ptr     pTemp;
2569
2583
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_plte),
2570
2584
                                               mng_free_obj_general,
2571
2585
                                               mng_process_ani_plte,
2652
2666
mng_retcode mng_create_ani_trns (mng_datap    pData)
2653
2667
#endif
2654
2668
{
2655
 
  mng_ptr       pTemp;
2656
2669
  mng_ani_trnsp pTRNS;
2657
2670
 
2658
2671
#ifdef MNG_SUPPORT_TRACE
2662
2675
  if (pData->bCacheplayback)           /* caching playback info ? */
2663
2676
  {
2664
2677
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
2678
    mng_ptr     pTemp;
2665
2679
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_trns),
2666
2680
                                               mng_free_obj_general,
2667
2681
                                               mng_process_ani_trns,
2750
2764
                                 mng_chunkp pChunk)
2751
2765
#endif
2752
2766
{
2753
 
  mng_ptr       pTemp;
2754
2767
  mng_ani_gamap pGAMA;
2755
2768
 
2756
2769
#ifdef MNG_SUPPORT_TRACE
2760
2773
  if (pData->bCacheplayback)           /* caching playback info ? */
2761
2774
  {
2762
2775
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
2776
    mng_ptr     pTemp;
2763
2777
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_gama),
2764
2778
                                               mng_free_obj_general,
2765
2779
                                               mng_process_ani_gama,
2995
3009
                                 mng_chunkp pChunk)
2996
3010
#endif
2997
3011
{
2998
 
  mng_ptr       pTemp;
2999
3012
  mng_ani_srgbp pSRGB;
3000
3013
 
3001
3014
#ifdef MNG_SUPPORT_TRACE
3005
3018
  if (pData->bCacheplayback)           /* caching playback info ? */
3006
3019
  {
3007
3020
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
3021
    mng_ptr     pTemp;
3008
3022
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_srgb),
3009
3023
                                               mng_free_obj_general,
3010
3024
                                               mng_process_ani_srgb,
3344
3358
                                 mng_chunkp  pChunk)
3345
3359
#endif
3346
3360
{
3347
 
  mng_ptr       pTemp;
3348
3361
  mng_ani_loopp pLOOP;
3349
3362
 
3350
3363
#ifdef MNG_SUPPORT_TRACE
3354
3367
  if (pData->bCacheplayback)           /* caching playback info ? */
3355
3368
  {
3356
3369
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
3370
    mng_ptr     pTemp;
3357
3371
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
3358
3372
                                               mng_free_ani_loop,
3359
3373
                                               mng_process_ani_loop,
3474
3488
mng_retcode mng_create_ani_endl (mng_datap pData,
3475
3489
                                 mng_uint8 iLevel)
3476
3490
{
3477
 
  mng_ptr       pTemp;
3478
3491
  mng_ani_endlp pENDL;
3479
3492
 
3480
3493
#ifdef MNG_SUPPORT_TRACE
3485
3498
  {
3486
3499
    mng_retcode iRetcode;
3487
3500
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
3501
    mng_ptr     pTemp;
3488
3502
    iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
3489
3503
                                               mng_free_obj_general,
3490
3504
                                               mng_process_ani_endl,
3617
3631
#ifndef MNG_SKIPCHUNK_DEFI
3618
3632
mng_retcode mng_create_ani_defi (mng_datap pData)
3619
3633
{               
3620
 
  mng_ptr       pTemp;
3621
3634
  mng_ani_defip pDEFI;
3622
3635
 
3623
3636
#ifdef MNG_SUPPORT_TRACE
3627
3640
  if (pData->bCacheplayback)           /* caching playback info ? */
3628
3641
  {
3629
3642
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
3643
    mng_ptr     pTemp;
3630
3644
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_defi),
3631
3645
                                               mng_free_obj_general,
3632
3646
                                               mng_process_ani_defi,
3741
3755
                                 mng_chunkp pChunk)
3742
3756
#endif
3743
3757
{
3744
 
  mng_ptr       pTemp;
3745
3758
  mng_ani_basip pBASI;
3746
3759
  mng_retcode   iRetcode;
3747
3760
 
3752
3765
  if (pData->bCacheplayback)           /* caching playback info ? */
3753
3766
  {
3754
3767
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
3768
    mng_ptr pTemp;
3755
3769
    iRetcode = create_obj_general (pData, sizeof (mng_ani_basi),
3756
3770
                                   mng_free_obj_general,
3757
3771
                                   mng_process_ani_basi,
3884
3898
#ifndef MNG_SKIPCHUNK_CLON
3885
3899
#ifndef MNG_OPTIMIZE_CHUNKREADER
3886
3900
mng_retcode mng_create_ani_clon (mng_datap  pData,
 
3901
                                 mng_uint16 iSourceid,
3887
3902
                                 mng_uint16 iCloneid,
3888
 
                                 mng_uint16 iSourceid,
3889
3903
                                 mng_uint8  iClonetype,
3890
3904
                                 mng_bool   bHasdonotshow,
3891
3905
                                 mng_uint8  iDonotshow,
3899
3913
                                 mng_chunkp pChunk)
3900
3914
#endif
3901
3915
{
3902
 
  mng_ptr       pTemp;
3903
3916
  mng_ani_clonp pCLON;
3904
3917
  mng_retcode   iRetcode;
3905
3918
 
3910
3923
  if (pData->bCacheplayback)           /* caching playback info ? */
3911
3924
  {
3912
3925
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
3926
    mng_ptr pTemp;
3913
3927
    iRetcode = create_obj_general (pData, sizeof (mng_ani_clon),
3914
3928
                                   mng_free_obj_general,
3915
3929
                                   mng_process_ani_clon,
3927
3941
    mng_add_ani_object (pData, (mng_object_headerp)pCLON);
3928
3942
 
3929
3943
#ifndef MNG_OPTIMIZE_CHUNKREADER
 
3944
    pCLON->iSourceid     = iSourceid;
3930
3945
    pCLON->iCloneid      = iCloneid;
3931
 
    pCLON->iSourceid     = iSourceid;
3932
3946
    pCLON->iClonetype    = iClonetype;
3933
3947
    pCLON->bHasdonotshow = bHasdonotshow;
3934
3948
    pCLON->iDonotshow    = iDonotshow;
3938
3952
    pCLON->iLocax        = iLocax;
3939
3953
    pCLON->iLocay        = iLocay;
3940
3954
#else
 
3955
    pCLON->iSourceid     = ((mng_clonp)pChunk)->iSourceid;
3941
3956
    pCLON->iCloneid      = ((mng_clonp)pChunk)->iCloneid;
3942
 
    pCLON->iSourceid     = ((mng_clonp)pChunk)->iSourceid;
3943
3957
    pCLON->iClonetype    = ((mng_clonp)pChunk)->iClonetype;
3944
3958
    pCLON->bHasdonotshow = ((mng_clonp)pChunk)->bHasdonotshow;
3945
3959
    pCLON->iDonotshow    = ((mng_clonp)pChunk)->iDonotshow;
3971
3985
#endif
3972
3986
#else
3973
3987
#ifndef MNG_OPTIMIZE_CHUNKREADER
 
3988
  pData->iCLONsourceid     = iSourceid;
3974
3989
  pData->iCLONcloneid      = iCloneid;
3975
 
  pData->iCLONsourceid     = iSourceid;
3976
3990
  pData->iCLONclonetype    = iClonetype;
3977
3991
  pData->bCLONhasdonotshow = bHasdonotshow;
3978
3992
  pData->iCLONdonotshow    = iDonotshow;
3982
3996
  pData->iCLONlocationx    = iLocax;
3983
3997
  pData->iCLONlocationy    = iLocay;
3984
3998
#else
 
3999
  pData->iCLONsourceid     = ((mng_clonp)pChunk)->iSourceid;
3985
4000
  pData->iCLONcloneid      = ((mng_clonp)pChunk)->iCloneid;
3986
 
  pData->iCLONsourceid     = ((mng_clonp)pChunk)->iSourceid;
3987
4001
  pData->iCLONclonetype    = ((mng_clonp)pChunk)->iClonetype;
3988
4002
  pData->bCLONhasdonotshow = ((mng_clonp)pChunk)->bHasdonotshow;
3989
4003
  pData->iCLONdonotshow    = ((mng_clonp)pChunk)->iDonotshow;
4080
4094
mng_retcode mng_create_ani_back (mng_datap  pData)
4081
4095
#endif
4082
4096
{
4083
 
  mng_ptr       pTemp;
4084
4097
  mng_ani_backp pBACK;
4085
4098
 
4086
4099
#ifdef MNG_SUPPORT_TRACE
4090
4103
  if (pData->bCacheplayback)           /* caching playback info ? */
4091
4104
  {
4092
4105
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
4106
    mng_ptr     pTemp;
4093
4107
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_back),
4094
4108
                                               mng_free_obj_general,
4095
4109
                                               mng_process_ani_back,
4197
4211
                                 mng_chunkp pChunk)
4198
4212
#endif
4199
4213
{
4200
 
  mng_ptr       pTemp;
4201
4214
  mng_ani_framp pFRAM;
4202
4215
  mng_retcode   iRetcode;
4203
4216
 
4208
4221
  if (pData->bCacheplayback)           /* caching playback info ? */
4209
4222
  {
4210
4223
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
4224
    mng_ptr pTemp;
4211
4225
    iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
4212
4226
                                   mng_free_obj_general,
4213
4227
                                   mng_process_ani_fram,
4396
4410
                                 mng_chunkp pChunk)
4397
4411
#endif
4398
4412
{
4399
 
  mng_ptr       pTemp;
4400
4413
  mng_ani_movep pMOVE;
4401
4414
  mng_retcode   iRetcode;
4402
4415
 
4407
4420
  if (pData->bCacheplayback)           /* caching playback info ? */
4408
4421
  {
4409
4422
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
4423
    mng_ptr pTemp;
4410
4424
    iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
4411
4425
                                   mng_free_obj_general,
4412
4426
                                   mng_process_ani_move,
4545
4559
                                 mng_chunkp pChunk)
4546
4560
#endif
4547
4561
{
4548
 
  mng_ptr       pTemp;
4549
4562
  mng_ani_clipp pCLIP;
4550
4563
  mng_retcode   iRetcode;
4551
4564
 
4556
4569
  if (pData->bCacheplayback)           /* caching playback info ? */
4557
4570
  {
4558
4571
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
4572
    mng_ptr pTemp;
4559
4573
    iRetcode = create_obj_general (pData, sizeof (mng_ani_clip),
4560
4574
                                   mng_free_obj_general,
4561
4575
                                   mng_process_ani_clip,
4703
4717
mng_retcode mng_create_ani_show (mng_datap  pData)
4704
4718
#endif
4705
4719
{
4706
 
  mng_ptr       pTemp;
4707
4720
  mng_ani_showp pSHOW;
4708
4721
 
4709
4722
#ifdef MNG_SUPPORT_TRACE
4713
4726
  if (pData->bCacheplayback)           /* caching playback info ? */
4714
4727
  {
4715
4728
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
4729
    mng_ptr     pTemp;
4716
4730
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
4717
4731
                                               mng_free_obj_general,
4718
4732
                                               mng_process_ani_show,
4814
4828
                                 mng_chunkp pChunk)
4815
4829
#endif
4816
4830
{
4817
 
  mng_ptr       pTemp;
4818
4831
  mng_ani_termp pTERM;
4819
4832
 
4820
4833
#ifdef MNG_SUPPORT_TRACE
4824
4837
  if (pData->bCacheplayback)           /* caching playback info ? */
4825
4838
  {
4826
4839
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
4840
    mng_ptr     pTemp;
4827
4841
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_term),
4828
4842
                                               mng_free_obj_general,
4829
4843
                                               mng_process_ani_term,
5143
5157
                                 mng_chunkp pChunk)
5144
5158
#endif
5145
5159
{
5146
 
  mng_ptr       pTemp;
5147
5160
  mng_ani_dhdrp pDHDR;
5148
5161
  mng_retcode   iRetcode;
5149
5162
 
5154
5167
  if (pData->bCacheplayback)           /* caching playback info ? */
5155
5168
  {
5156
5169
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5170
    mng_ptr pTemp;
5157
5171
    iRetcode = create_obj_general (pData, sizeof (mng_ani_dhdr),
5158
5172
                                   mng_free_obj_general,
5159
5173
                                   mng_process_ani_dhdr,
5306
5320
                                 mng_chunkp pChunk)
5307
5321
#endif
5308
5322
{
5309
 
  mng_ptr       pTemp;
5310
5323
  mng_ani_promp pPROM=NULL;
5311
5324
  mng_retcode   iRetcode;
5312
5325
 
5317
5330
  if (pData->bCacheplayback)           /* caching playback info ? */
5318
5331
  {
5319
5332
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5333
    mng_ptr pTemp;
5320
5334
    iRetcode = create_obj_general (pData, sizeof (mng_ani_prom),
5321
5335
                                   mng_free_obj_general,
5322
5336
                                   mng_process_ani_prom,
5431
5445
#ifndef MNG_NO_DELTA_PNG
5432
5446
mng_retcode mng_create_ani_ipng (mng_datap pData)
5433
5447
{
5434
 
  mng_ptr       pTemp;
5435
5448
  mng_ani_ipngp pIPNG;
5436
5449
 
5437
5450
#ifdef MNG_SUPPORT_TRACE
5441
5454
  if (pData->bCacheplayback)           /* caching playback info ? */
5442
5455
  {
5443
5456
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5457
    mng_ptr     pTemp;
5444
5458
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_ipng),
5445
5459
                                               mng_free_obj_general,
5446
5460
                                               mng_process_ani_ipng,
5515
5529
#ifdef MNG_INCLUDE_JNG
5516
5530
mng_retcode mng_create_ani_ijng (mng_datap pData)
5517
5531
{
5518
 
  mng_ptr       pTemp;
5519
5532
  mng_ani_ijngp pIJNG;
5520
5533
 
5521
5534
#ifdef MNG_SUPPORT_TRACE
5525
5538
  if (pData->bCacheplayback)           /* caching playback info ? */
5526
5539
  {
5527
5540
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5541
    mng_ptr     pTemp;
5528
5542
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_ani_ijng),
5529
5543
                                               mng_free_obj_general,
5530
5544
                                               mng_process_ani_ijng,
5604
5618
                                 mng_uint8p     paAlphaentries,
5605
5619
                                 mng_uint8p     paUsedentries)
5606
5620
{
5607
 
  mng_ptr       pTemp;
5608
5621
  mng_ani_ppltp pPPLT;
5609
5622
  mng_retcode   iRetcode;
5610
5623
 
5615
5628
  if (pData->bCacheplayback)           /* caching playback info ? */
5616
5629
  {
5617
5630
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5631
    mng_ptr pTemp;
5618
5632
    iRetcode = create_obj_general (pData, sizeof (mng_ani_pplt),
5619
5633
                                   mng_free_obj_general,
5620
5634
                                   mng_process_ani_pplt,
5733
5747
                                 mng_chunkp pChunk)
5734
5748
#endif
5735
5749
{
5736
 
  mng_ptr       pTemp;
5737
5750
  mng_ani_magnp pMAGN=NULL;
5738
5751
  mng_retcode   iRetcode;
5739
5752
 
5744
5757
  if (pData->bCacheplayback)           /* caching playback info ? */
5745
5758
  {
5746
5759
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5760
    mng_ptr pTemp;
5747
5761
    iRetcode = create_obj_general (pData, sizeof (mng_ani_magn),
5748
5762
                                   mng_free_obj_general,
5749
5763
                                   mng_process_ani_magn,
5915
5929
                                 mng_chunkp pChunk)
5916
5930
#endif
5917
5931
{
5918
 
  mng_ptr       pTemp;
5919
5932
  mng_ani_pastp pPAST;
5920
5933
  mng_retcode   iRetcode;
5921
5934
 
5926
5939
  if (pData->bCacheplayback)           /* caching playback info ? */
5927
5940
  {
5928
5941
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
5942
    mng_ptr pTemp;
5929
5943
    iRetcode = create_obj_general (pData, sizeof (mng_ani_past),
5930
5944
                                   mng_free_ani_past,
5931
5945
                                   mng_process_ani_past,
6091
6105
                                 mng_chunkp  pChunk)
6092
6106
#endif
6093
6107
{
6094
 
  mng_ptr       pTemp;
6095
6108
  mng_ani_discp pDISC;
6096
6109
  mng_retcode   iRetcode;
6097
6110
 
6102
6115
  if (pData->bCacheplayback)           /* caching playback info ? */
6103
6116
  {
6104
6117
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6118
    mng_ptr pTemp;
6105
6119
    iRetcode = create_obj_general (pData, sizeof (mng_ani_disc),
6106
6120
                                   mng_free_ani_disc,
6107
6121
                                   mng_process_ani_disc,
6247
6261
                              mng_ptr    pEntry)
6248
6262
#endif
6249
6263
{
6250
 
  mng_ptr    pTemp;
6251
6264
  mng_eventp pEvent;
6252
6265
 
6253
6266
#ifdef MNG_SUPPORT_TRACE
6259
6272
    mng_object_headerp pLast;
6260
6273
 
6261
6274
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6275
    mng_ptr     pTemp;
6262
6276
    mng_retcode iRetcode = create_obj_general (pData, sizeof (mng_event),
6263
6277
                                               mng_free_event,
6264
6278
                                               mng_process_event,
6420
6434
#endif /* MNG_SUPPORT_DYNAMICMNG */
6421
6435
 
6422
6436
/* ************************************************************************** */
 
6437
/* ************************************************************************** */
 
6438
 
 
6439
#ifdef MNG_INCLUDE_MPNG_PROPOSAL
 
6440
 
 
6441
/* ************************************************************************** */
 
6442
 
 
6443
#ifndef MNG_OPTIMIZE_CHUNKREADER
 
6444
mng_retcode mng_create_mpng_obj (mng_datap  pData,
 
6445
                                 mng_uint32 iFramewidth,
 
6446
                                 mng_uint32 iFrameheight,
 
6447
                                 mng_uint16 iNumplays,
 
6448
                                 mng_uint16 iTickspersec,
 
6449
                                 mng_uint32 iFramessize,
 
6450
                                 mng_ptr    pFrames)
 
6451
#else
 
6452
mng_retcode mng_create_mpng_obj (mng_datap  pData,
 
6453
                                 mng_ptr    pEntry)
 
6454
#endif
 
6455
{
 
6456
  mng_mpng_objp pMPNG;
 
6457
  mng_ptr       pTemp;
 
6458
  mng_retcode   iRetcode;
 
6459
  mng_uint8p    pFrame;
 
6460
  mng_int32     iCnt, iMax;
 
6461
  mng_uint32    iX, iY, iWidth, iHeight;
 
6462
  mng_int32     iXoffset, iYoffset;
 
6463
  mng_uint16    iTicks;
 
6464
  mng_uint16    iDelay;
 
6465
  mng_bool      bNewframe;
 
6466
  mng_ani_loopp pLOOP;
 
6467
  mng_ani_endlp pENDL;
 
6468
  mng_ani_framp pFRAM;
 
6469
  mng_ani_movep pMOVE;
 
6470
  mng_ani_clipp pCLIP;
 
6471
  mng_ani_showp pSHOW;
 
6472
 
 
6473
#ifdef MNG_SUPPORT_TRACE
 
6474
  MNG_TRACE (pData, MNG_FN_CREATE_MPNG_OBJ, MNG_LC_START);
 
6475
#endif
 
6476
 
 
6477
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6478
  iRetcode = create_obj_general (pData, sizeof (mng_mpng_obj), mng_free_mpng_obj,
 
6479
                                 mng_process_mpng_obj, &pTemp);
 
6480
  if (iRetcode)
 
6481
    return iRetcode;
 
6482
  pMPNG = (mng_mpng_objp)pTemp;
 
6483
#else
 
6484
  MNG_ALLOC (pData, pMPNG, sizeof (mng_mpng_obj));
 
6485
 
 
6486
  pMPNG->sHeader.fCleanup = mng_free_mpng_obj;
 
6487
  pMPNG->sHeader.fProcess = mng_process_mpng_obj;
 
6488
#endif
 
6489
 
 
6490
#ifndef MNG_OPTIMIZE_CHUNKREADER
 
6491
  pMPNG->iFramewidth  = iFramewidth;
 
6492
  pMPNG->iFrameheight = iFrameheight;
 
6493
  pMPNG->iNumplays    = iNumplays;
 
6494
  pMPNG->iTickspersec = iTickspersec;
 
6495
  pMPNG->iFramessize  = iFramessize;
 
6496
 
 
6497
  if (iFramessize)
 
6498
  {
 
6499
    MNG_ALLOC (pData, pMPNG->pFrames, iFramessize);
 
6500
    MNG_COPY (pMPNG->pFrames, pFrames, iFramessize);
 
6501
  }
 
6502
#else
 
6503
  pMPNG->iFramewidth  = ((mng_mpngp)pEntry)->iFramewidth;
 
6504
  pMPNG->iFrameheight = ((mng_mpngp)pEntry)->iFrameheight;
 
6505
  pMPNG->iNumplays    = ((mng_mpngp)pEntry)->iNumplays;
 
6506
  pMPNG->iTickspersec = ((mng_mpngp)pEntry)->iTickspersec;
 
6507
  pMPNG->iFramessize  = ((mng_mpngp)pEntry)->iFramessize;
 
6508
 
 
6509
  if (pMPNG->iFramessize)
 
6510
  {
 
6511
    MNG_ALLOC (pData, pMPNG->pFrames, pMPNG->iFramessize);
 
6512
    MNG_COPY (pMPNG->pFrames, ((mng_mpngp)pEntry)->pFrames, pMPNG->iFramessize);
 
6513
  }
 
6514
#endif
 
6515
 
 
6516
  pData->pMPNG      = pMPNG;
 
6517
  pData->eImagetype = mng_it_mpng;
 
6518
 
 
6519
  iRetcode = mng_process_display_mpng (pData);
 
6520
  if (iRetcode)
 
6521
    return iRetcode;
 
6522
 
 
6523
  /* now let's create the MNG animation directives from this */
 
6524
 
 
6525
  pFrame = (mng_uint8p)pMPNG->pFrames;
 
6526
  iMax   = pMPNG->iFramessize / 26;
 
6527
                                       /* set up MNG impersonation */
 
6528
  pData->iTicks      = pMPNG->iTickspersec;
 
6529
  pData->iLayercount = iMax;
 
6530
 
 
6531
  if (pMPNG->iNumplays != 1)           /* create a LOOP/ENDL pair ? */
 
6532
  {
 
6533
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6534
    iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
 
6535
                                   mng_free_ani_loop, mng_process_ani_loop,
 
6536
                                   &((mng_ptr)pLOOP));
 
6537
    if (iRetcode)
 
6538
      return iRetcode;
 
6539
#else
 
6540
    MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
 
6541
 
 
6542
    pLOOP->sHeader.fCleanup = mng_free_ani_loop;
 
6543
    pLOOP->sHeader.fProcess = mng_process_ani_loop;
 
6544
#endif
 
6545
 
 
6546
    pLOOP->iLevel = 1;
 
6547
    if (pMPNG->iNumplays)
 
6548
      pLOOP->iRepeatcount = pMPNG->iNumplays;
 
6549
    else
 
6550
      pLOOP->iRepeatcount = 0xFFFFFFFFl;
 
6551
 
 
6552
    mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
 
6553
  }
 
6554
 
 
6555
  bNewframe = MNG_TRUE;                /* create the frame display objects */
 
6556
 
 
6557
  for (iCnt = 0; iCnt < iMax; iCnt++)
 
6558
  {
 
6559
    iX       = mng_get_uint32 (pFrame);
 
6560
    iY       = mng_get_uint32 (pFrame+4);
 
6561
    iWidth   = mng_get_uint32 (pFrame+8);
 
6562
    iHeight  = mng_get_uint32 (pFrame+12);
 
6563
    iXoffset = mng_get_int32  (pFrame+16);
 
6564
    iYoffset = mng_get_int32  (pFrame+20);
 
6565
    iTicks   = mng_get_uint16 (pFrame+24);
 
6566
 
 
6567
    iDelay = iTicks;
 
6568
    if (!iDelay)
 
6569
    {
 
6570
      mng_uint8p pTemp = pFrame+26;
 
6571
      mng_int32  iTemp = iCnt+1;
 
6572
 
 
6573
      while ((iTemp < iMax) && (!iDelay))
 
6574
      {
 
6575
        iDelay = mng_get_uint16 (pTemp+24);
 
6576
        pTemp += 26;
 
6577
        iTemp++;
 
6578
      }
 
6579
    }
 
6580
 
 
6581
    if (bNewframe)
 
6582
    {
 
6583
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6584
      iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
 
6585
                                     mng_free_obj_general, mng_process_ani_fram,
 
6586
                                     &((mng_ptr)pFRAM));
 
6587
      if (iRetcode)
 
6588
        return iRetcode;
 
6589
#else
 
6590
      MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
 
6591
 
 
6592
      pFRAM->sHeader.fCleanup = mng_free_ani_fram;
 
6593
      pFRAM->sHeader.fProcess = mng_process_ani_fram;
 
6594
#endif
 
6595
 
 
6596
      pFRAM->iFramemode   = 4;
 
6597
      pFRAM->iChangedelay = 1;
 
6598
      pFRAM->iDelay       = iDelay;
 
6599
 
 
6600
      mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
 
6601
    }
 
6602
 
 
6603
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6604
    iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
 
6605
                                   mng_free_obj_general,
 
6606
                                   mng_process_ani_move,
 
6607
                                   &((mng_ptr)pMOVE));
 
6608
    if (iRetcode)
 
6609
      return iRetcode;
 
6610
#else
 
6611
    MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
 
6612
 
 
6613
    pMOVE->sHeader.fCleanup = mng_free_ani_move;
 
6614
    pMOVE->sHeader.fProcess = mng_process_ani_move;
 
6615
#endif
 
6616
 
 
6617
    pMOVE->iLocax   = iXoffset - (mng_int32)iX;
 
6618
    pMOVE->iLocay   = iYoffset - (mng_int32)iY;
 
6619
 
 
6620
    mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
 
6621
 
 
6622
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6623
    iRetcode = create_obj_general (pData, sizeof (mng_ani_clip),
 
6624
                                   mng_free_obj_general,
 
6625
                                   mng_process_ani_clip,
 
6626
                                   &((mng_ptr)pCLIP));
 
6627
    if (iRetcode)
 
6628
      return iRetcode;
 
6629
#else
 
6630
    MNG_ALLOC (pData, pCLIP, sizeof (mng_ani_clip));
 
6631
 
 
6632
    pCLIP->sHeader.fCleanup = mng_free_ani_clip;
 
6633
    pCLIP->sHeader.fProcess = mng_process_ani_clip;
 
6634
#endif
 
6635
 
 
6636
    pCLIP->iClipl = iXoffset;
 
6637
    pCLIP->iClipr = iXoffset + (mng_int32)iWidth;
 
6638
    pCLIP->iClipt = iYoffset;
 
6639
    pCLIP->iClipb = iYoffset + (mng_int32)iHeight;
 
6640
 
 
6641
    mng_add_ani_object (pData, (mng_object_headerp)pCLIP);
 
6642
 
 
6643
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6644
    iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
 
6645
                                   mng_free_obj_general, mng_process_ani_show,
 
6646
                                   &((mng_ptr)pSHOW));
 
6647
    if (iRetcode)
 
6648
      return iRetcode;
 
6649
#else
 
6650
    MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
 
6651
 
 
6652
    pSHOW->sHeader.fCleanup = mng_free_ani_show;
 
6653
    pSHOW->sHeader.fProcess = mng_process_ani_show;
 
6654
#endif
 
6655
 
 
6656
    mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
 
6657
 
 
6658
    bNewframe = (mng_bool)iTicks;
 
6659
    pFrame += 26;
 
6660
  }
 
6661
 
 
6662
  if (pMPNG->iNumplays != 1)           /* create a LOOP/ENDL pair ? */
 
6663
  {
 
6664
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6665
    iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
 
6666
                                   mng_free_obj_general, mng_process_ani_endl,
 
6667
                                   &((mng_ptr)pENDL));
 
6668
    if (iRetcode)
 
6669
      return iRetcode;
 
6670
#else
 
6671
    MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
 
6672
 
 
6673
    pENDL->sHeader.fCleanup = mng_free_ani_endl;
 
6674
    pENDL->sHeader.fProcess = mng_process_ani_endl;
 
6675
#endif
 
6676
 
 
6677
    pENDL->iLevel = 1;
 
6678
 
 
6679
    mng_add_ani_object (pData, (mng_object_headerp)pENDL);
 
6680
  }
 
6681
 
 
6682
#ifdef MNG_SUPPORT_TRACE
 
6683
  MNG_TRACE (pData, MNG_FN_CREATE_MPNG_OBJ, MNG_LC_END);
 
6684
#endif
 
6685
 
 
6686
  return MNG_NOERROR;
 
6687
}
 
6688
 
 
6689
/* ************************************************************************** */
 
6690
 
 
6691
mng_retcode mng_free_mpng_obj (mng_datap   pData,
 
6692
                               mng_objectp pObject)
 
6693
{
 
6694
  mng_mpng_objp pMPNG = (mng_mpng_objp)pObject;
 
6695
 
 
6696
#ifdef MNG_SUPPORT_TRACE
 
6697
  MNG_TRACE (pData, MNG_FN_FREE_MPNG_OBJ, MNG_LC_START);
 
6698
#endif
 
6699
 
 
6700
  if (pMPNG->iFramessize)
 
6701
    MNG_FREEX (pData, pMPNG->pFrames, pMPNG->iFramessize);
 
6702
 
 
6703
#ifndef MNG_OPTIMIZE_OBJCLEANUP
 
6704
  MNG_FREEX (pData, pMPNG, sizeof (mng_mpng_obj));
 
6705
#endif
 
6706
 
 
6707
#ifdef MNG_SUPPORT_TRACE
 
6708
  MNG_TRACE (pData, MNG_FN_FREE_MPNG_OBJ, MNG_LC_END);
 
6709
#endif
 
6710
 
 
6711
#ifndef MNG_OPTIMIZE_OBJCLEANUP
 
6712
  return MNG_NOERROR;
 
6713
#else
 
6714
  return mng_free_obj_general(pData, pObject);
 
6715
#endif
 
6716
}
 
6717
 
 
6718
/* ************************************************************************** */
 
6719
 
 
6720
mng_retcode mng_process_mpng_obj (mng_datap   pData,
 
6721
                                  mng_objectp pObject)
 
6722
{
 
6723
  return MNG_NOERROR;
 
6724
}
 
6725
 
 
6726
/* ************************************************************************** */
 
6727
 
 
6728
#endif /* MNG_INCLUDE_MPNG_PROPOSAL */
 
6729
 
 
6730
/* ************************************************************************** */
 
6731
/* ************************************************************************** */
 
6732
 
 
6733
#ifdef MNG_INCLUDE_ANG_PROPOSAL
 
6734
 
 
6735
/* ************************************************************************** */
 
6736
 
 
6737
#ifndef MNG_OPTIMIZE_CHUNKREADER
 
6738
mng_retcode mng_create_ang_obj (mng_datap  pData,
 
6739
                                mng_uint32 iNumframes,
 
6740
                                mng_uint32 iTickspersec,
 
6741
                                mng_uint32 iNumplays,
 
6742
                                mng_uint32 iTilewidth,
 
6743
                                mng_uint32 iTileheight,
 
6744
                                mng_uint8  iInterlace,
 
6745
                                mng_uint8  iStillused)
 
6746
#else
 
6747
mng_retcode mng_create_ang_obj (mng_datap  pData,
 
6748
                                mng_ptr    pEntry)
 
6749
#endif
 
6750
{
 
6751
  mng_ang_objp  pANG;
 
6752
  mng_ptr       pTemp;
 
6753
  mng_retcode   iRetcode;
 
6754
 
 
6755
#ifdef MNG_SUPPORT_TRACE
 
6756
  MNG_TRACE (pData, MNG_FN_CREATE_ANG_OBJ, MNG_LC_START);
 
6757
#endif
 
6758
 
 
6759
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6760
  iRetcode = create_obj_general (pData, sizeof (mng_ang_obj), mng_free_ang_obj,
 
6761
                                 mng_process_ang_obj, &pTemp);
 
6762
  if (iRetcode)
 
6763
    return iRetcode;
 
6764
  pANG = (mng_ang_objp)pTemp;
 
6765
#else
 
6766
  MNG_ALLOC (pData, pANG, sizeof (mng_ang_obj));
 
6767
 
 
6768
  pANG->sHeader.fCleanup = mng_free_ang_obj;
 
6769
  pANG->sHeader.fProcess = mng_process_ang_obj;
 
6770
#endif
 
6771
 
 
6772
#ifndef MNG_OPTIMIZE_CHUNKREADER
 
6773
  pANG->iNumframes   = iNumframes;
 
6774
  pANG->iTickspersec = iTickspersec;
 
6775
  pANG->iNumplays    = iNumplays;
 
6776
  pANG->iTilewidth   = iTilewidth;
 
6777
  pANG->iTileheight  = iTileheight;
 
6778
  pANG->iInterlace   = iInterlace;
 
6779
  pANG->iStillused   = iStillused;
 
6780
#else
 
6781
  pANG->iNumframes   = ((mng_ahdrp)pEntry)->iNumframes;
 
6782
  pANG->iTickspersec = ((mng_ahdrp)pEntry)->iTickspersec;
 
6783
  pANG->iNumplays    = ((mng_ahdrp)pEntry)->iNumplays;
 
6784
  pANG->iTilewidth   = ((mng_ahdrp)pEntry)->iTilewidth;
 
6785
  pANG->iTileheight  = ((mng_ahdrp)pEntry)->iTileheight;
 
6786
  pANG->iInterlace   = ((mng_ahdrp)pEntry)->iInterlace;
 
6787
  pANG->iStillused   = ((mng_ahdrp)pEntry)->iStillused;
 
6788
#endif
 
6789
 
 
6790
  pData->pANG       = pANG;
 
6791
  pData->eImagetype = mng_it_ang;
 
6792
 
 
6793
  iRetcode = mng_process_display_ang (pData);
 
6794
  if (iRetcode)
 
6795
    return iRetcode;
 
6796
 
 
6797
#ifdef MNG_SUPPORT_TRACE
 
6798
  MNG_TRACE (pData, MNG_FN_CREATE_ANG_OBJ, MNG_LC_END);
 
6799
#endif
 
6800
 
 
6801
  return MNG_NOERROR;
 
6802
}
 
6803
 
 
6804
/* ************************************************************************** */
 
6805
 
 
6806
mng_retcode mng_free_ang_obj (mng_datap   pData,
 
6807
                              mng_objectp pObject)
 
6808
{
 
6809
  mng_ang_objp pANG = (mng_ang_objp)pObject;
 
6810
 
 
6811
#ifdef MNG_SUPPORT_TRACE
 
6812
  MNG_TRACE (pData, MNG_FN_FREE_ANG_OBJ, MNG_LC_START);
 
6813
#endif
 
6814
 
 
6815
  if (pANG->iTilessize)
 
6816
    MNG_FREEX (pData, pANG->pTiles, pANG->iTilessize);
 
6817
 
 
6818
#ifndef MNG_OPTIMIZE_OBJCLEANUP
 
6819
  MNG_FREEX (pData, pANG, sizeof (mng_ang_obj));
 
6820
#endif
 
6821
 
 
6822
#ifdef MNG_SUPPORT_TRACE
 
6823
  MNG_TRACE (pData, MNG_FN_FREE_ANG_OBJ, MNG_LC_END);
 
6824
#endif
 
6825
 
 
6826
#ifndef MNG_OPTIMIZE_OBJCLEANUP
 
6827
  return MNG_NOERROR;
 
6828
#else
 
6829
  return mng_free_obj_general(pData, pObject);
 
6830
#endif
 
6831
}
 
6832
 
 
6833
/* ************************************************************************** */
 
6834
 
 
6835
mng_retcode mng_process_ang_obj (mng_datap   pData,
 
6836
                                 mng_objectp pObject)
 
6837
{
 
6838
  mng_ang_objp  pANG  = (mng_ang_objp)pObject;
 
6839
  mng_uint8p    pTile = (mng_uint8p)pANG->pTiles;
 
6840
  mng_retcode   iRetcode;
 
6841
  mng_int32     iCnt, iMax;
 
6842
  mng_uint32    iTicks;
 
6843
  mng_int32     iXoffset, iYoffset;
 
6844
  mng_uint8     iSource;
 
6845
  mng_ani_loopp pLOOP;
 
6846
  mng_ani_endlp pENDL;
 
6847
  mng_ani_framp pFRAM;
 
6848
  mng_ani_movep pMOVE;
 
6849
  mng_ani_showp pSHOW;
 
6850
 
 
6851
#ifdef MNG_SUPPORT_TRACE
 
6852
  MNG_TRACE (pData, MNG_FN_PROCESS_ANG_OBJ, MNG_LC_START);
 
6853
#endif
 
6854
 
 
6855
  /* let's create the MNG animation directives from this */
 
6856
 
 
6857
  iMax = pANG->iNumframes;
 
6858
                                       /* set up MNG impersonation */
 
6859
  pData->iTicks      = pANG->iTickspersec;
 
6860
  pData->iLayercount = iMax;
 
6861
 
 
6862
  if (pANG->iNumplays != 1)            /* create a LOOP/ENDL pair ? */
 
6863
  {
 
6864
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6865
    iRetcode = create_obj_general (pData, sizeof (mng_ani_loop),
 
6866
                                   mng_free_ani_loop, mng_process_ani_loop,
 
6867
                                   &((mng_ptr)pLOOP));
 
6868
    if (iRetcode)
 
6869
      return iRetcode;
 
6870
#else
 
6871
    MNG_ALLOC (pData, pLOOP, sizeof (mng_ani_loop));
 
6872
 
 
6873
    pLOOP->sHeader.fCleanup = mng_free_ani_loop;
 
6874
    pLOOP->sHeader.fProcess = mng_process_ani_loop;
 
6875
#endif
 
6876
 
 
6877
    pLOOP->iLevel = 1;
 
6878
    if (pANG->iNumplays)
 
6879
      pLOOP->iRepeatcount = pANG->iNumplays;
 
6880
    else
 
6881
      pLOOP->iRepeatcount = 0xFFFFFFFFl;
 
6882
 
 
6883
    mng_add_ani_object (pData, (mng_object_headerp)pLOOP);
 
6884
  }
 
6885
 
 
6886
  for (iCnt = 0; iCnt < iMax; iCnt++)
 
6887
  {
 
6888
    iTicks   = mng_get_uint32 (pTile);
 
6889
    iXoffset = mng_get_int32  (pTile+4);
 
6890
    iYoffset = mng_get_int32  (pTile+8);
 
6891
    iSource  = *(pTile+12);
 
6892
 
 
6893
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6894
    iRetcode = create_obj_general (pData, sizeof (mng_ani_fram),
 
6895
                                   mng_free_obj_general, mng_process_ani_fram,
 
6896
                                   &((mng_ptr)pFRAM));
 
6897
    if (iRetcode)
 
6898
      return iRetcode;
 
6899
#else
 
6900
    MNG_ALLOC (pData, pFRAM, sizeof (mng_ani_fram));
 
6901
 
 
6902
    pFRAM->sHeader.fCleanup = mng_free_ani_fram;
 
6903
    pFRAM->sHeader.fProcess = mng_process_ani_fram;
 
6904
#endif
 
6905
 
 
6906
    pFRAM->iFramemode   = 4;
 
6907
    pFRAM->iChangedelay = 1;
 
6908
    pFRAM->iDelay       = iTicks;
 
6909
 
 
6910
    mng_add_ani_object (pData, (mng_object_headerp)pFRAM);
 
6911
 
 
6912
    if (!iSource)
 
6913
    {
 
6914
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6915
      iRetcode = create_obj_general (pData, sizeof (mng_ani_move),
 
6916
                                     mng_free_obj_general,
 
6917
                                     mng_process_ani_move,
 
6918
                                     &((mng_ptr)pMOVE));
 
6919
      if (iRetcode)
 
6920
        return iRetcode;
 
6921
#else
 
6922
      MNG_ALLOC (pData, pMOVE, sizeof (mng_ani_move));
 
6923
 
 
6924
      pMOVE->sHeader.fCleanup = mng_free_ani_move;
 
6925
      pMOVE->sHeader.fProcess = mng_process_ani_move;
 
6926
#endif
 
6927
 
 
6928
      pMOVE->iFirstid = 1;
 
6929
      pMOVE->iLastid  = 1;
 
6930
      pMOVE->iLocax   = -iXoffset;
 
6931
      pMOVE->iLocay   = -iYoffset;
 
6932
 
 
6933
      mng_add_ani_object (pData, (mng_object_headerp)pMOVE);
 
6934
    }
 
6935
 
 
6936
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6937
    iRetcode = create_obj_general (pData, sizeof (mng_ani_show),
 
6938
                                   mng_free_obj_general, mng_process_ani_show,
 
6939
                                   &((mng_ptr)pSHOW));
 
6940
    if (iRetcode)
 
6941
      return iRetcode;
 
6942
#else
 
6943
    MNG_ALLOC (pData, pSHOW, sizeof (mng_ani_show));
 
6944
 
 
6945
    pSHOW->sHeader.fCleanup = mng_free_ani_show;
 
6946
    pSHOW->sHeader.fProcess = mng_process_ani_show;
 
6947
#endif
 
6948
 
 
6949
    if (iSource)
 
6950
      pSHOW->iFirstid = 0;
 
6951
    else
 
6952
      pSHOW->iFirstid = 1;
 
6953
    pSHOW->iLastid    = pSHOW->iFirstid;
 
6954
 
 
6955
    mng_add_ani_object (pData, (mng_object_headerp)pSHOW);
 
6956
 
 
6957
    pTile += sizeof(mng_adat_tile);
 
6958
  }
 
6959
 
 
6960
  if (pANG->iNumplays != 1)            /* create a LOOP/ENDL pair ? */
 
6961
  {
 
6962
#ifdef MNG_OPTIMIZE_OBJCLEANUP
 
6963
    iRetcode = create_obj_general (pData, sizeof (mng_ani_endl),
 
6964
                                   mng_free_obj_general, mng_process_ani_endl,
 
6965
                                   &((mng_ptr)pENDL));
 
6966
    if (iRetcode)
 
6967
      return iRetcode;
 
6968
#else
 
6969
    MNG_ALLOC (pData, pENDL, sizeof (mng_ani_endl));
 
6970
 
 
6971
    pENDL->sHeader.fCleanup = mng_free_ani_endl;
 
6972
    pENDL->sHeader.fProcess = mng_process_ani_endl;
 
6973
#endif
 
6974
 
 
6975
    pENDL->iLevel = 1;
 
6976
 
 
6977
    mng_add_ani_object (pData, (mng_object_headerp)pENDL);
 
6978
  }
 
6979
 
 
6980
#ifdef MNG_SUPPORT_TRACE
 
6981
  MNG_TRACE (pData, MNG_FN_PROCESS_ANG_OBJ, MNG_LC_END);
 
6982
#endif
 
6983
 
 
6984
  return MNG_NOERROR;
 
6985
}
 
6986
 
 
6987
/* ************************************************************************** */
 
6988
 
 
6989
#endif /* MNG_INCLUDE_ANG_PROPOSAL */
 
6990
 
 
6991
/* ************************************************************************** */
6423
6992
 
6424
6993
#endif /* MNG_INCLUDE_DISPLAY_PROCS */
6425
6994