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