workbench/classes/datatypes/gifanim/dispatch.c

   1
   2 /*
   3 **
   4 **  $VER: dispatch.c 2.4 (24.5.98)
   5 **  gifanim.datatype 2.4
   6 **
   7 **  Dispatch routine for a DataTypes class
   8 **
   9 **  Written 1997/1998 by Roland 'Gizzy' Mainz
  10 **  Original example source from David N. Junod
  11 **
  12 */
  13
  14 #ifndef DEBUG
  15 #   define DEBUG 0
  16 #endif
  17 #include <aros/debug.h>
  18
  19 struct MyStackSwapStruct;
  20 struct GIFAnimInstData;
  21 struct GIFEncoder;
  22
  23 /* main includes */
  24 #include "classbase.h"
  25 #include "classdata.h"
  26
  27 #include "dispatch.h"
  28
  29 /* ansi includes */
  30 #include <limits.h>
  31 #include <stdio.h>
  32
  33 /*****************************************************************************/
  34
  35 /* decoder related local prototypes */
  36 static BOOL                 ReadColorMap( struct ClassBase *, struct GIFAnimInstData *, UWORD, struct ColorRegister * );
  37 static int                  DoExtension( struct ClassBase *, Object *, struct GIFAnimInstData *, TEXT );
  38 static int                  GetDataBlock( struct ClassBase *, struct GIFAnimInstData *, UBYTE * );
  39 static int                  GetCode( struct ClassBase *, struct GIFAnimInstData *, int, BOOL );
  40 static int                  LWZReadByte( struct ClassBase *, struct GIFAnimInstData *, BOOL, int );
  41 static int                  getbase2( int );
  42
  43 /*****************************************************************************/
  44
  45 /* local prototypes */
  46 static struct FrameNode    *AllocFrameNode( struct ClassBase *, APTR );
  47 static struct BitMap       *AllocBitMapPooled( struct ClassBase *, ULONG, ULONG, ULONG, APTR );
  48 static void                 AttachSample( struct ClassBase *, struct GIFAnimInstData * );
  49
  50 /*****************************************************************************/
  51
  52 #if !defined (__AROS__)
  53 /* Create "gifanim.datatype" BOOPSI class */
  54 struct IClass *initClass( struct ClassBase *cb )
  55 {
  56     struct IClass *cl;
  57
  58     /* Create our class... */
  59     if( cl = MakeClass( GIFANIMDTCLASS, ANIMATIONDTCLASS, NULL, (ULONG)sizeof( struct GIFAnimInstData ), 0UL ) )
  60     {
  61       cl -> cl_Dispatcher . h_Entry = (HOOKFUNC)Dispatch;
  62 #define DTSTACKSIZE (16384UL)
  63       cl -> cl_Dispatcher . h_Entry    = (HOOKFUNC)StackSwapDispatch; /* see stackswap.c */
  64       cl -> cl_Dispatcher . h_SubEntry = (HOOKFUNC)Dispatch;          /* see stackswap.c */
  65       cl -> cl_Dispatcher . h_Data     = (APTR)DTSTACKSIZE;           /* see stackswap.c */
  66       cl -> cl_UserData                = cb;
  67       AddClass( cl );
  68     }
  69
  70     return( cl );
  71 }
  72
  73 #include "methods.h"
  74
  75 /* class dispatcher */
  76 DISPATCHERFLAGS
  77 ULONG Dispatch( REGA0 struct IClass *cl, REGA2 Object *o, REGA1 Msg msg )
  78 {
  79     struct ClassBase        *cb = (struct ClassBase *)(cl -> cl_UserData);
  80     struct GIFAnimInstData  *gaid;
  81     ULONG                    retval = 0UL;
  82
  83     switch( msg -> MethodID )
  84     {
  85       case OM_NEW:
  86           retval = DT_NewMethod( cl, o, msg );
  87           break;
  88
  89       case OM_DISPOSE:
  90           retval = DT_DisposeMethod( cl, o, msg );
  91           break;
  92
  93 /* TEST TEST / Support for format change "on-the-fly" disabled here / TEST TEST
  94  * DO NOT make any assumptions on this EXPERIMENTAL code !
  95  */
  96 #ifdef COMMENTED_OUT
  97       case DTM_FRAMEBOX:
  98           retval = DT_FrameBoxMethod( cl, o, msg );
  99           break;
 100 #endif /* COMMENTED_OUT */
 101
 102       case OM_UPDATE:
 103       case OM_SET:
 104           retval = DT_SetMethod( cl, o, msg );
 105           break;
 106
 107       case DTM_WRITE:
 108           retval = DT_WriteMethod( cl, o, msg );
 109           break;
 110
 111       case ADTM_LOADFRAME:
 112           retval = DT_LoadFrameMethod( cl, o, msg );
 113           break;
 114
 115       case ADTM_UNLOADFRAME:
 116           retval = DT_UnLoadFrameMethod( cl, o, msg );
 117           break;
 118
 119       /* Let the superclass handle everything else */
 120       default:
 121       {
 122           retval = DoSuperMethodA( cl, o, msg );
 123       }
 124           break;
 125     }
 126
 127     return( retval );
 128 }
 129 #endif
 130
 131 BOOL ScanFrames( struct ClassBase *cb, Object *o )
 132 {
 133     struct GIFAnimInstData *gaid    = (struct GIFAnimInstData *)INST_DATA( (cb -> cb_Lib . cl_Class), o );
 134     LONG                    error   = 0L;
 135     BOOL                    success = FALSE;
 136
 137     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
 138
 139     InitSemaphore( (&(gaid -> gaid_SigSem)) );
 140     NewList( (struct List *)(&(gaid -> gaid_FrameList)) );
 141
 142     /* Create a memory pool for frame nodes */
 143     if ((gaid -> gaid_Pool = CreatePool( MEMF_PUBLIC, 8192UL, 8192UL ) ) != NULL)
 144     {
 145       BPTR                 fh;                             /* handle (file handle)      */
 146       IPTR                 sourcetype;                     /* type of stream (either DTST_FILE or DTST_RAM) */
 147       ULONG                modeid /*= (ULONG)INVALID_ID*/; /* anim view mode                  */
 148       ULONG                animwidth,                      /* anim width                      */
 149                            animheight,                     /* anim height                     */
 150                            animdepth;                      /* anim depth                      */
 151       ULONG                timestamp  = 0UL;               /* timestamp                       */
 152
 153         D(bug("[gifanim.datatype] %s: pool @ 0x%p\n", __PRETTY_FUNCTION__, gaid -> gaid_Pool));
 154
 155       /* Prefs defaults */
 156       gaid -> gaid_LoadAll = TRUE;              /* The decoder is too slow to allow realtime decoding of a
 157                                                  * 576 * 124 * 8 GIF Image, even on a mc68040 :-((
 158                                                  */
 159       gaid -> gaid_ModeID  = (ULONG)INVALID_ID; /* no screen mode selected yet */
 160       gaid -> gaid_Volume  = 64UL;
 161
 162       /* Read prefs */
 163       ReadENVPrefs( cb, gaid, NULL );
 164
 165       /* Get file handle, handle type and BitMapHeader */
 166       if( GetDTAttrs( o, DTA_SourceType,    (&sourcetype),
 167                          DTA_Handle,        (&fh),
 168                          DTA_Name,          (&(gaid -> gaid_ProjectName)),
 169                          TAG_DONE ) == 3UL )
 170       {
 171         switch( sourcetype )
 172         {
 173           case DTST_FILE:
 174           {
 175               D(bug("[gifanim.datatype] %s: DTST_FILE (0x%p)\n", __PRETTY_FUNCTION__, fh));
 176
 177               if( fh )
 178               {
 179                 BPTR lock;
 180
 181                 if ((lock = DupLockFromFH( fh ) ) != BNULL)
 182                 {
 183                   /* Set up a filehandle for disk-based loading (random loading) */
 184                   if ((gaid -> gaid_FH = (BPTR)OpenFromLock( lock ) ) != BNULL)
 185                   {
 186                     success = TRUE;
 187                   }
 188                   else
 189                   {
 190                     /* failure */
 191                     UnLock( lock );
 192                   }
 193                 }
 194               }
 195
 196               /* OpenFromLock failed ? - Then open by name :-( */
 197               if( (gaid -> gaid_FH) == BNULL )
 198               {
 199                 /* Set up a filehandle for disk-based loading (random loading) */
 200                 if ((gaid -> gaid_FH = (BPTR)Open( (gaid -> gaid_ProjectName), MODE_OLDFILE ) ) != BNULL)
 201                 {
 202                   success = TRUE;
 203                 }
 204                 else
 205                 {
 206                   /* Can't open file */
 207                   error = IoErr();
 208                 }
 209               }
 210           }
 211               break;
 212
 213           case DTST_RAM: /* empty object */
 214           {
 215               D(bug("[gifanim.datatype] %s: DTST_RAM\n", __PRETTY_FUNCTION__));
 216
 217               success = TRUE;
 218           }
 219               break;
 220
 221           default:
 222           {
 223               /* unsupported source type */
 224               error = ERROR_NOT_IMPLEMENTED;
 225           }
 226               break;
 227         }
 228
 229         /* Any error ? */
 230         if( success )
 231         {
 232           /* Now we enter the next stage of testing... */
 233           success = FALSE;
 234
 235           if( fh )
 236           {
 237             struct GIFDecoder    *gifdec                           = (&(gaid -> gaid_GIFDec));
 238             struct FrameNode     *fn;
 239             ULONG                 numcmaps                         = 0UL; /* number of created cmaps */
 240             UBYTE                 buf[ 16 ];
 241             struct ColorRegister  localColorMap[ MAXCOLORMAPSIZE ] = { 0 };
 242             struct ColorRegister  savedTransparentColor            = { 0 };
 243             UBYTE                 c;
 244             BOOL                  useGlobalColormap;
 245             UWORD                 bitPixel;
 246
 247             gifdec -> file                = fh;
 248             gifdec -> Gif89 . transparent = (UWORD)~0U; /* means: no transparent color */
 249
 250             D(bug("[gifanim.datatype] %s: checking sig..\n", __PRETTY_FUNCTION__));
 251
 252             /* Read "GIF" indentifer and version */
 253             if( ReadOK( cb, gifdec, buf, 6 ) )
 254             {
 255               /* Is there the GIF signature ? */
 256               if( !strncmp( (char *)buf, "GIF", 3 ) )
 257               {
 258                 STRPTR version = (STRPTR)(buf + 3);
 259
 260                   D(bug("[gifanim.datatype] %s: checking gif version..\n", __PRETTY_FUNCTION__));
 261
 262                 /* Check if we support this GIF version */
 263                 if( (!strncmp( version, "87a", 3 )) ||
 264                     (!strncmp( version, "89a", 3 )) )
 265                 {
 266                         D(bug("[gifanim.datatype]: %s: read gif screen..\n", __PRETTY_FUNCTION__));
 267
 268                   /* Read GIF Screen */
 269                   if( ReadOK( cb, gifdec, buf, 7 ) )
 270                   {
 271                     struct FrameNode *prevnode = NULL;
 272                     UBYTE            *deltamap = NULL;
 273
 274                     gifdec -> GifScreen . Width           = LOHI2UINT16( buf[ 0 ], buf[ 1 ] );
 275                     gifdec -> GifScreen . Height          = LOHI2UINT16( buf[ 2 ], buf[ 3 ] );
 276                     gifdec -> GifScreen . BitPixel        = 2 << (buf[ 4 ] & 0x07);
 277                     gifdec -> GifScreen . ColorResolution = (((buf[ 4 ] & 0x70) >> 3) + 1);
 278                     gifdec -> GifScreen . Background      = buf[ 5 ];
 279                     gifdec -> GifScreen . AspectRatio     = buf[ 6 ];
 280
 281                                  gaid -> gaid_Width        = gifdec -> GifScreen . Width;
 282                     animwidth  = gaid -> gaid_PaddedWidth  = (gaid -> gaid_UseChunkyMap)?(gaid -> gaid_Width):(((gaid -> gaid_Width) + 15UL) & ~15UL); /* align for c2p-wpa (c2c does not need padding) */
 283                     animheight = gaid -> gaid_Height       = gifdec -> GifScreen . Height;
 284                     animdepth  = gaid -> gaid_Depth        = (gaid -> gaid_UseChunkyMap)?(DIRECTRGB_DEPTH):((ULONG)getbase2( (gifdec -> GifScreen . BitPixel) ));
 285
 286                     D(bug("[gifanim.datatype] %s: %dx%dx%d\n", __PRETTY_FUNCTION__, animwidth, animheight, animdepth));
 287
 288                     /* Global Colormap ? */
 289                     if( BitSet( buf[ 4 ], LOCALCOLORMAP ) )
 290                     {
 291                         D(bug("[gifanim.datatype]: %s: reading global colormap..\n", __PRETTY_FUNCTION__));
 292
 293                       numcmaps++;
 294
 295                       if( ReadColorMap( cb, gaid, (gifdec -> GifScreen . BitPixel), (gifdec -> GifScreen . ColorMap) ) )
 296                       {
 297                           D(bug("[gifanim.datatype]: %s:   failed!\n", __PRETTY_FUNCTION__));
 298                         error = IoErr();
 299                         error_printf( cb, gaid, "error %d reading global colormap\n", error);
 300                       }
 301                     }
 302                     else
 303                     {
 304                       /* No global colormap ? - Then the background color in the GifScreen is a NOP */
 305                       gifdec -> GifScreen . Background = 0U;
 306                     }
 307
 308                     while (TRUE)
 309                     {
 310                         D(bug("[gifanim.datatype]: %s: reading chunk..\n", __PRETTY_FUNCTION__));
 311                       /* Read chunk ID char */
 312                       if( !ReadOK( cb, gifdec, (&c), 1 ) )
 313                       {
 314                         error = IoErr();
 315                         error_printf( cb, gaid, "EOF / read error on image data (%x)\n", error);
 316                         break;
 317                       }
 318
 319                       switch( c )
 320                       {
 321                         case ';': /* GIF terminator ? */
 322                         {
 323                         D(bug("[gifanim.datatype]: %s: ## terminator\n", __PRETTY_FUNCTION__));
 324
 325                             goto scandone;
 326                         }
 327
 328                         case '!': /* Extension ? */
 329                         {
 330                         D(bug("[gifanim.datatype]: %s: ## extension\n", __PRETTY_FUNCTION__));
 331
 332                             if( ReadOK( cb, gifdec, (&c), 1 ) )
 333                             {
 334                               if( DoExtension( cb, o, gaid, c ) == -1 )
 335                               {
 336                                 error = IoErr();
 337                                 error_printf( cb, gaid, "error %x in extension\n", error);
 338                                 goto scandone;
 339                               }
 340                             }
 341                             else
 342                             {
 343                               error = IoErr();
 344                               error_printf( cb, gaid, "OF / read error on extension function code (%x)\n", error);
 345                               goto scandone;
 346                             }
 347                         }
 348                             break;
 349
 350                         case ',': /* Raster data start ? */
 351                         {
 352                         D(bug("[gifanim.datatype]: %s: ## rast data\n", __PRETTY_FUNCTION__));
 353
 354                             /* Create an prepare a new frame node */
 355                             if ((fn = AllocFrameNode( cb, (gaid -> gaid_Pool) )) != NULL)
 356                             {
 357                                 D(bug("[gifanim.datatype]: %s:    frame node @ 0x%p\n", __PRETTY_FUNCTION__, fn));
 358                               if( (gaid -> gaid_LoadAll) || (timestamp == 0UL) )
 359                               {
 360                                 if( !(fn -> fn_BitMap = AllocFrameBitMap( cb, gaid ) ) )
 361                                 {
 362                                     D(bug("[gifanim.datatype]: %s: failed to allocate bitmap!\n", __PRETTY_FUNCTION__));
 363                                   error = ERROR_NO_FREE_STORE;
 364                                 }
 365
 366                                 /* Allocate array for chunkypixel data */
 367                                 if ((fn -> fn_ChunkyMap = (UBYTE *)AllocPooledVec( cb, (gaid -> gaid_Pool), ((animwidth * animheight) + 256) )) != NULL)
 368                                 {
 369                                   /* Get a clean background to avoid that rubbish shows througth transparent parts */
 370                                   memset( (fn -> fn_ChunkyMap), 0, (size_t)(animwidth * animheight) );
 371                                 }
 372                                 else
 373                                 {
 374                                     D(bug("[gifanim.datatype]: %s: failed to allocate chunky data!\n", __PRETTY_FUNCTION__));
 375                                   error = ERROR_NO_FREE_STORE;
 376                                 }
 377                               }
 378
 379                               if( error == 0L )
 380                               {
 381                                 ULONG duration;
 382
 383                                 /* Get position of bitmap */
 384                                 fn -> fn_BMOffset = Seek( fh, 0L, OFFSET_CURRENT ); /* BUG: does not check for failure */
 385
 386                                 D(bug("[gifanim.datatype]: %s:    bitmap offset %lu\n", __PRETTY_FUNCTION__, fn->fn_BMOffset));
 387
 388                                 if( !ReadOK( cb, gifdec, buf, 9 ) )
 389                                 {
 390                                   error = IoErr();
 391                                   error_printf( cb, gaid, "couldn't read left/top/width/height (%x)\n", error);
 392                                   goto scandone;
 393                                 }
 394
 395                                 /* Local color map ? */
 396                                 useGlobalColormap = !BitSet( buf[ 8 ], LOCALCOLORMAP );
 397
 398                                 /* Size of local color map */
 399                                 bitPixel = 1 << ((buf[ 8 ] & 0x07) + 1);
 400
 401                                 /* Store GIF89a related attributes */
 402                                 fn -> fn_GIF89aDisposal    = gifdec -> Gif89 . disposal;    /* Store disposal mode for current frame  */
 403                                 fn -> fn_GIF89aTransparent = gifdec -> Gif89 . transparent; /* Store currents frame transparent color */
 404
 405                                 if( fn -> fn_ChunkyMap )
 406                                 {
 407                                 D(bug("[gifanim.datatype]: %s:    chunky\n", __PRETTY_FUNCTION__));
 408
 409                                   /* disposal method */
 410                                   switch( fn -> fn_GIF89aDisposal )
 411                                   {
 412                                     case GIF89A_DISPOSE_NOP:
 413                                     {
 414                                         D(bug("[gifanim.datatype]: %s:    GIF89A_DISPOSE_NOP\n", __PRETTY_FUNCTION__));
 415                                         /* Background not transparent ? */
 416                                         if( ((fn -> fn_GIF89aTransparent) == ~0U) ||
 417                                             ((fn -> fn_GIF89aTransparent) != 0U) )
 418                                         {
 419                                           /* restore to color 0 */
 420                                           memset( (fn -> fn_ChunkyMap), 0, (size_t)(animwidth * animheight) );
 421                                         }
 422                                     }
 423                                         break;
 424
 425                                     case GIF89A_DISPOSE_NODISPOSE:
 426                                     {
 427                                         D(bug("[gifanim.datatype]: %s:    GIF89A_DISPOSE_NODISPOSE\n", __PRETTY_FUNCTION__));
 428                                         /* do not dispose prev image */
 429
 430                                         /* If we have a previous frame, copy it  */
 431                                         if( prevnode )
 432                                         {
 433                                           CopyMem( (prevnode -> fn_ChunkyMap), (fn -> fn_ChunkyMap), (animwidth * animheight) );
 434 #ifdef DELTAWPA8
 435                                           CopyBitMap( cb, (fn -> fn_BitMap), (prevnode -> fn_BitMap), animwidth, animheight );
 436                                           deltamap = prevnode -> fn_ChunkyMap;
 437 #endif /* DELTAWPA8 */
 438                                         }
 439                                         else
 440                                         {
 441                                           /* Background not transparent ? */
 442                                           if( ((fn -> fn_GIF89aTransparent) == ~0U) ||
 443                                               ((fn -> fn_GIF89aTransparent) != 0U) )
 444                                           {
 445                                             /* restore to color 0 */
 446                                             memset( (fn -> fn_ChunkyMap), 0, (size_t)(animwidth * animheight) );
 447                                           }
 448 #ifdef DELTAWPA8
 449                                           deltamap = NULL;
 450 #endif /* DELTAWPA8 */
 451                                         }
 452                                     }
 453                                         break;
 454
 455                                     case GIF89A_DISPOSE_RESTOREBACKGROUND:
 456                                     {
 457                                         D(bug("[gifanim.datatype]: %s:    GIF89A_DISPOSE_RESTOREBACKGROUND\n", __PRETTY_FUNCTION__));
 458                                         /* Background not transparent ? */
 459                                         if( ((fn -> fn_GIF89aTransparent) == ~0U) ||
 460                                             ((fn -> fn_GIF89aTransparent) != (gaid -> gaid_GIFDec . GifScreen . Background)) )
 461                                         {
 462                                           /* Restore to background color */
 463                                           memset( (fn -> fn_ChunkyMap), (gifdec -> GifScreen . Background), (size_t)(animwidth * animheight) );
 464                                         }
 465                                     }
 466                                         break;
 467
 468                                     case GIF89A_DISPOSE_RESTOREPREVIOUS:
 469                                     {
 470                                         D(bug("[gifanim.datatype]: %s:    GIF89A_DISPOSE_RESTOREPREVIOUS\n", __PRETTY_FUNCTION__));
 471                                         /* restore previous image  */
 472
 473                                         /* If we have a previous frame, copy it  */
 474                                         if( prevnode )
 475                                         {
 476                                           CopyMem( (prevnode -> fn_ChunkyMap), (fn -> fn_ChunkyMap), (animwidth * animheight) );
 477 #ifdef DELTAWPA8
 478                                           CopyBitMap( cb, (fn -> fn_BitMap), (prevnode -> fn_BitMap), animwidth, animheight );
 479                                           deltamap = prevnode -> fn_ChunkyMap;
 480 #endif /* DELTAWPA8 */
 481                                         }
 482                                         else
 483                                         {
 484                                           /* restore to color 0 */
 485                                           memset( (fn -> fn_ChunkyMap), 0, (size_t)(animwidth * animheight) );
 486 #ifdef DELTAWPA8
 487                                           deltamap = NULL;
 488 #endif /* DELTAWPA8 */
 489                                         }
 490                                     }
 491                                         break;
 492
 493                                     default: /* GIF89A_DISPOSE_RESERVED4 - GIF89A_DISPOSE_RESERVED7 */
 494                                     {
 495                                         error_printf( cb, gaid, "unsupported disposal method %lu\n", (ULONG)(gifdec -> Gif89 . disposal) );
 496                                     }
 497                                         break;
 498                                   }
 499                                 }
 500
 501                                 /* Save transparent color (if we have one) */
 502                                 if( ((fn -> fn_GIF89aTransparent) != ~0U) && (timestamp != 0UL) )
 503                                 {
 504                                     D(bug("[gifanim.datatype]: %s:    save transp\n", __PRETTY_FUNCTION__));
 505                                   savedTransparentColor = localColorMap[ (fn -> fn_GIF89aTransparent) ];
 506                                 }
 507
 508                                 /* Get colormap */
 509                                 if( useGlobalColormap )
 510                                 {
 511                                   /* use global colormap and depth */
 512                                   bitPixel = gifdec -> GifScreen . BitPixel;
 513                                   memcpy( localColorMap, (gifdec -> GifScreen . ColorMap), (sizeof( struct ColorRegister ) * bitPixel) );
 514                                 }
 515                                 else
 516                                 {
 517                                     D(bug("[gifanim.datatype]: %s:    reading colormap...\n", __PRETTY_FUNCTION__));
 518                                   numcmaps++;
 519
 520                                   if( ReadColorMap( cb, gaid, bitPixel, localColorMap ) )
 521                                   {
 522                                     error = IoErr();
 523                                     error_printf( cb, gaid, "error %x reading local colormap\n", error);
 524                                     goto scandone;
 525                                   }
 526                                 }
 527
 528                                 /* Restore transparent color (if we have one) */
 529                                 if( (fn -> fn_GIF89aTransparent) != ~0U )
 530                                 {
 531                                     D(bug("[gifanim.datatype]: %s:    restore transp\n", __PRETTY_FUNCTION__));
 532                                   localColorMap[ (fn -> fn_GIF89aTransparent) ] = savedTransparentColor;
 533                                 }
 534
 535                                 if( !(gaid -> gaid_UseChunkyMap) )
 536                                 {
 537                                   /* The first palette must be moved to the object's palette */
 538                                   if( timestamp == 0UL )
 539                                   {
 540                                     if( !CMAP2Object( cb, o, (UBYTE *)localColorMap, (ULONG)(bitPixel * 3UL) ) )
 541                                     {
 542                                         D(bug("[gifanim.datatype]: %s: failed to allocate object cmap!\n", __PRETTY_FUNCTION__));
 543                                       /* can't alloc object's color table */
 544                                       error = ERROR_NO_FREE_STORE;
 545                                     }
 546                                   }
 547
 548                                   /* Create a palette-per-frame colormap here */
 549                                   if( !(fn -> fn_CMap = CMAP2ColorMap( cb, (1UL << (ULONG)(gaid -> gaid_Depth)), (UBYTE *)localColorMap, (ULONG)(bitPixel * 3UL) )) )
 550                                   {
 551                                       D(bug("[gifanim.datatype]: %s: failed to allocate frame cmap!\n", __PRETTY_FUNCTION__));
 552                                     /* can't alloc colormap */
 553                                     error = ERROR_NO_FREE_STORE;
 554                                   }
 555                                 }
 556
 557                                 D(bug("[gifanim.datatype]: %s:    copying colormap\n", __PRETTY_FUNCTION__));
 558                                 /* Copy colormap for 24 bit output */
 559                                 memcpy( (void *)(fn -> fn_ColorMap), (void *)localColorMap, (size_t)(sizeof( struct ColorRegister ) * bitPixel) );
 560
 561                                 D(bug("[gifanim.datatype]: %s:    reading image ...\n", __PRETTY_FUNCTION__));
 562                                 (void)ReadImage( cb, gaid,
 563                                                  (fn -> fn_ChunkyMap),
 564                                                  (UWORD)animwidth,
 565                                                  LOHI2UINT16( buf[ 0 ], buf[ 1 ] ),
 566                                                  LOHI2UINT16( buf[ 2 ], buf[ 3 ] ),
 567                                                  LOHI2UINT16( buf[ 4 ], buf[ 5 ] ),
 568                                                  LOHI2UINT16( buf[ 6 ], buf[ 7 ] ),
 569                                                  BitSet( buf[ 8 ], INTERLACE ),
 570                                                  ((fn -> fn_BitMap) == NULL),
 571                                                  (fn -> fn_GIF89aTransparent) );
 572
 573                                 /* Get size of bitmap (curr_pos - start_of_bm) */
 574                                 fn -> fn_BMSize = Seek( fh, 0L, OFFSET_CURRENT ) - (fn -> fn_BMOffset); /* BUG: does not check for failure */
 575
 576                                 D(bug("[gifanim.datatype]: %s:    bitmap = %d bytes\n", __PRETTY_FUNCTION__, fn->fn_BMSize));
 577
 578                                 if( fn -> fn_BitMap )
 579                                 {
 580                                     D(bug("[gifanim.datatype]: %s:    rendering to bitmap @ 0x%p\n", __PRETTY_FUNCTION__, fn->fn_BitMap));
 581                                   if( gaid -> gaid_UseChunkyMap )
 582                                   {
 583                                     WriteRGBPixelArray8( cb, (fn -> fn_BitMap), animwidth, animheight, (fn -> fn_ColorMap), (fn -> fn_ChunkyMap) );
 584                                   }
 585                                   else
 586                                   {
 587                                     WriteDeltaPixelArray8Fast( (fn -> fn_BitMap), (fn -> fn_ChunkyMap), deltamap );
 588                                   }
 589                                 }
 590
 591                                 /* Bump timestamp... */
 592                                 if( ((gifdec -> Gif89 . delayTime) != ~0U) &&
 593                                     ((gifdec -> Gif89 . delayTime) > 1U)   &&
 594                                     ((gifdec -> Gif89 . delayTime) < 2000U) )
 595                                 {
 596                                   duration = (gifdec -> Gif89 . delayTime);
 597                                 }
 598                                 else
 599                                 {
 600                                   duration = 0;
 601                                 }
 602
 603                                 fn -> fn_TimeStamp = timestamp;
 604                                 fn -> fn_Frame     = timestamp;
 605                                 fn -> fn_Duration  = duration;
 606
 607                                 D(bug("[gifanim.datatype]: %s:    %08p:%08p\n", __PRETTY_FUNCTION__, fn->fn_TimeStamp, fn->fn_Duration));
 608
 609                                 AddTail( (struct List *)(&(gaid -> gaid_FrameList)), (struct Node *)(&(fn -> fn_Node)) );
 610
 611                                 prevnode = fn;
 612
 613                                 /* Next frame starts at timestamp... */
 614                                 timestamp += (fn -> fn_Duration) + 1UL;
 615                               }
 616                             }
 617                         }
 618                             break;
 619
 620                         case 0x00: /* padding byte ? */
 621                         {
 622                             /* Padding bytes are not part of the Compuserve documents, but... */
 623                             if( !(gaid -> gaid_StrictSyntax) )
 624                             {
 625                               break;
 626                             }
 627                         }
 628                         /* fall througth */
 629                         default: /* Not a valid raster data start character ? */
 630                         {
 631                             error_printf( cb, gaid, "invalid character 0x%02x, ignoring\n", (int)c );
 632                         }
 633                             break;
 634                       }
 635
 636                       /* on error break */
 637                       if( error )
 638                       {
 639                           D(bug("[gifanim.datatype]: %s: ERROR!\n", __PRETTY_FUNCTION__));
 640                         break;
 641                       }
 642                     }
 643
 644 scandone:
 645                     D(bug("[gifanim.datatype]: %s: scan done\n", __PRETTY_FUNCTION__));
 646
 647                     /* Any frames ? */
 648                     if( timestamp && (error == 0L) && numcmaps )
 649                     {
 650                       if( numcmaps == 1UL )
 651                       {
 652                         /* We only have a global colormap and no colormap changes (or a direct RGB bitmap),
 653                          * delete first colormap (a colormap in the first frames indicates following colormap
 654                          * changes)
 655                          */
 656                         struct FrameNode *firstnode = (struct FrameNode *)(gaid -> gaid_FrameList . mlh_Head);
 657
 658                         if( firstnode -> fn_CMap )
 659                         {
 660                           FreeColorMap( (firstnode -> fn_CMap) );
 661                           firstnode -> fn_CMap = NULL;
 662                         }
 663                       }
 664                       else
 665                       {
 666                         /* All frames must have a colormap, therefore we replicate the colormap
 667                          * from the previous colormap if one is missing
 668                          */
 669                         struct FrameNode *worknode,
 670                                          *nextnode;
 671                         struct ColorMap  *currcm = NULL;
 672
 673                         verbose_printf( cb, gaid, "Animation has palette changes per frame\n" );
 674
 675                         worknode = (struct FrameNode *)(gaid -> gaid_FrameList . mlh_Head);
 676
 677                         while ((nextnode = (struct FrameNode *)(worknode -> fn_Node . mln_Succ) ) != NULL)
 678                         {
 679                           if( worknode -> fn_CMap )
 680                           {
 681                             /* Current node contains colormap, this are the colors for the following frames... */
 682                             currcm = worknode -> fn_CMap;
 683                           }
 684                           else
 685                           {
 686                             if( currcm )
 687                             {
 688                               /* Copy colormap from previous one... */
 689                               if( !(worknode -> fn_CMap = CopyColorMap( cb, currcm )) )
 690                               {
 691                                 /* Can't copy/alloc colormap */
 692                                 error = ERROR_NO_FREE_STORE;
 693                               }
 694                             }
 695                             else
 696                             {
 697                               verbose_printf( cb, gaid, "scan/load: no colormap, can't copy it\n" );
 698                             }
 699                           }
 700
 701                           worknode = nextnode;
 702                         }
 703                       }
 704                     }
 705
 706                     /* Check for required information */
 707                     if( error == 0L )
 708                     {
 709                       /* Any frames loaded ? */
 710                       if( timestamp == 0UL )
 711                       {
 712                         /* not enougth frames (at least one required) */
 713                         error = DTERROR_NOT_ENOUGH_DATA;
 714                       }
 715                     }
 716
 717                     /* Any error ? */
 718                     if( error == 0L )
 719                     {
 720                       struct FrameNode *firstfn = (struct FrameNode *)(gaid -> gaid_FrameList . mlh_Head); /* short cut to the first FrameNode */
 721
 722                       /* Alloc bitmap as key bitmap */
 723                       if( gaid -> gaid_UseChunkyMap )
 724                       {
 725                         gaid -> gaid_KeyBitMap = AllocBitMap( animwidth, animheight, animdepth, (BMF_SPECIALFMT | SHIFT_PIXFMT( DIRECTRGB_PIXFMT )), NULL );
 726                       }
 727                       else
 728                       {
 729                         gaid -> gaid_KeyBitMap = AllocBitMap( animwidth, animheight, animdepth, BMF_CLEAR, NULL );
 730                       }
 731
 732                       if( gaid -> gaid_KeyBitMap )
 733                       {
 734                         if( (firstfn -> fn_BitMap) == NULL )
 735                         {
 736                           /* can't alloc first bitmap */
 737                           error = ERROR_NO_FREE_STORE;
 738                         }
 739
 740                         if( error == 0L )
 741                         {
 742                           /* Copy first frame into key bitmap */
 743                           CopyBitMap( cb, (gaid -> gaid_KeyBitMap), (firstfn -> fn_BitMap), animwidth, animheight );
 744
 745                           /* No screen mode id set by prefs ? */
 746                           if( (gaid -> gaid_ModeID) != (ULONG)INVALID_ID )
 747                           {
 748                             modeid = gaid -> gaid_ModeID;
 749                           }
 750                           else
 751                           {
 752                             if( gaid -> gaid_UseChunkyMap )
 753                             {
 754                               /* We don't have fixed values for cybergfx mode id's, therefore we have to ask for them */
 755                               if( (modeid = BestCModeIDTags( CYBRBIDTG_NominalWidth,  animwidth,
 756                                                              CYBRBIDTG_NominalHeight, animheight,
 757                                                              CYBRBIDTG_Depth,         animdepth,
 758                                                              TAG_DONE )) == INVALID_ID )
 759                               {
 760 #if 0
 761                                 error = 1L; /* inducate an error here :-( */
 762 #else
 763                                 /* Workaround for CyberGFX bug :-( */
 764                                 if( (modeid = BestCModeIDTags( CYBRBIDTG_NominalWidth,  640UL,
 765                                                                CYBRBIDTG_NominalHeight, 480UL,
 766                                                                CYBRBIDTG_Depth,         animdepth,
 767                                                                TAG_DONE )) == INVALID_ID )
 768                                 {
 769                                   modeid = 0UL;
 770
 771                                   error_printf( cb, gaid, "'CyberGFX bug' workaround failed, too ! Using modeid=%x.\n", modeid);
 772                                 }
 773 #endif
 774
 775                                 error_printf( cb, gaid, "No screenmode available for %lu/%lu/%lu\n", animwidth, animheight, animdepth );
 776                               }
 777                             }
 778                             else
 779                             {
 780                               /* BUG: Does currently not support SUPERHIRES modes */
 781                               if( animwidth >= 640UL )
 782                               {
 783                                 if( animheight >= 400 )
 784                                 {
 785                                   modeid = HIRESLACE_KEY;
 786                                 }
 787                                 else
 788                                 {
 789                                   modeid = HIRES_KEY;
 790                                 }
 791                               }
 792                               else
 793                               {
 794                                 if( animheight >= 400 )
 795                                 {
 796                                   modeid = LORESLACE_KEY;
 797                                 }
 798                                 else
 799                                 {
 800                                   modeid = LORES_KEY;
 801                                 }
 802                               }
 803                             }
 804                           }
 805
 806                           /* No fps set by prefs ? */
 807                           if( (gaid -> gaid_FPS) == 0UL )
 808                           {
 809                             gaid -> gaid_FPS = 100; /* defaults to 100 fps. GIF 89a delay values counts in
 810                                                      * 1/100 sec steps. We set the alf_Duration field
 811                                                      * to this value (got from the GIF 89a extension).
 812                                                      */
 813                           }
 814
 815                           AttachSample( cb, gaid );
 816
 817                           verbose_printf( cb, gaid, "width %lu height %lu depth %lu frames %lu fps %lu\n",
 818                                           animwidth,
 819                                           animheight,
 820                                           animdepth,
 821                                           timestamp,
 822                                           (gaid -> gaid_FPS) );
 823
 824                           /* Set misc. attributes */
 825                           SetDTAttrs( o, NULL, NULL,
 826                                       DTA_ObjName,                                       (gaid -> gaid_ProjectName),
 827                                       DTA_TotalHoriz,                                    animwidth,
 828                                       DTA_TotalVert,                                     animheight,
 829                                       ADTA_Width,                                        (gaid -> gaid_Width),
 830                                       ADTA_Height,                                       animheight,
 831                                       ADTA_Depth,                                        animdepth,
 832                                       ADTA_Frames,                                       timestamp,
 833                                       ADTA_FramesPerSecond,                              (gaid -> gaid_FPS),
 834                                       ADTA_ModeID,                                       modeid,
 835                                       ADTA_KeyFrame,                                     (gaid -> gaid_KeyBitMap),
 836                                       XTAG( (firstfn -> fn_Sample), ADTA_Sample       ), (firstfn -> fn_Sample),
 837                                       XTAG( (firstfn -> fn_Sample), ADTA_SampleLength ), ((firstfn -> fn_SampleLength) / ((firstfn -> fn_Duration) + 1UL)),
 838                                       XTAG( (firstfn -> fn_Sample), ADTA_Period       ), (firstfn -> fn_Period),
 839                                       XTAG( (firstfn -> fn_Sample), ADTA_Volume       ), (gaid -> gaid_Volume),
 840                                       TAG_DONE );
 841
 842                           /* All done for now... */
 843                           success = TRUE;
 844                         }
 845                       }
 846                       else
 847                       {
 848                         /* can't alloc key bitmap */
 849                         error = ERROR_NO_FREE_STORE;
 850                       }
 851                     }
 852                   }
 853                   else
 854                   {
 855                     error = IoErr();
 856                     error_printf( cb, gaid, "failed to read gif screen descriptor (%x)\n", error);
 857                   }
 858                 }
 859                 else
 860                 {
 861                   /* unsupported GIF version number */
 862                   error = DTERROR_UNKNOWN_COMPRESSION;
 863                   error_printf( cb, gaid, "error %x bad version number, not '87a' or '89a'\n", error);
 864                 }
 865               }
 866               else
 867               {
 868                 /* no GIF signature */
 869                 error = ERROR_OBJECT_WRONG_TYPE;
 870                 error_printf( cb, gaid, "error %x not a GIF file\n", error);
 871               }
 872             }
 873             else
 874             {
 875               error = IoErr();
 876               error_printf( cb, gaid, "error %x reading magic number\n", error);
 877             }
 878
 879             /* Prepare decoder for dynamic frame access */
 880             gifdec -> file = gaid -> gaid_FH;
 881           }
 882           else
 883           {
 884             /* No file handle ? - Be sure we got a DTST_RAM sourcetype */
 885             if( sourcetype == DTST_RAM )
 886             {
 887               /* The object is used without any input file.
 888                * This "empty" object is used to run the encoder only...
 889                */
 890               success = TRUE;
 891             }
 892             else
 893             {
 894               /* No handle ! */
 895               error = ERROR_REQUIRED_ARG_MISSING;
 896             }
 897           }
 898         }
 899       }
 900       else
 901       {
 902         /* can't get required attributes from superclass */
 903         error = ERROR_OBJECT_WRONG_TYPE;
 904       }
 905     }
 906     else
 907     {
 908       /* no memory pool */
 909       error = ERROR_NO_FREE_STORE;
 910     }
 911
 912     SetIoErr( error );
 913
 914     return( success );
 915 }
 916
 917
 918 static
 919 struct FrameNode *AllocFrameNode( struct ClassBase *cb, APTR pool )
 920 {
 921     struct FrameNode *fn;
 922
 923     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
 924
 925     if ((fn = (struct FrameNode *)AllocPooled( pool, (ULONG)sizeof( struct FrameNode ) ) ) != NULL)
 926     {
 927       memset( fn, 0, sizeof( struct FrameNode ) );
 928     }
 929
 930     return( fn );
 931 }
 932
 933
 934 struct FrameNode *FindFrameNode( struct MinList *fnl, ULONG timestamp )
 935 {
 936
 937     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
 938
 939     if( fnl )
 940     {
 941       struct FrameNode *worknode,
 942                        *nextnode,
 943                        *prevnode;
 944
 945       prevnode = worknode = (struct FrameNode *)(fnl -> mlh_Head);
 946
 947       while ((nextnode = (struct FrameNode *)(worknode -> fn_Node . mln_Succ) ) != NULL)
 948       {
 949         if( (worknode -> fn_TimeStamp) > timestamp )
 950         {
 951           return( prevnode );
 952         }
 953
 954         prevnode = worknode;
 955         worknode = nextnode;
 956       }
 957
 958       if( !IsListEmpty( ((struct List *)fnl) ) )
 959       {
 960         return( prevnode );
 961       }
 962     }
 963
 964     return( NULL );
 965 }
 966
 967
 968 void FreeFrameNodeResources( struct ClassBase *cb, struct GIFAnimInstData *gaid )
 969 {
 970     struct FrameNode *worknode;
 971
 972     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
 973
 974 /* The follwoing was used for debugging */
 975 /* #define FREE_LIST_IN_REVERSE_ORDER 1 */
 976
 977 #ifdef FREE_LIST_IN_REVERSE_ORDER
 978     struct FrameNode *nextnode;
 979
 980     worknode = (struct FrameNode *)(gaid -> gaid_FrameList . mlh_Head);
 981
 982     while ((nextnode = (struct FrameNode *)(worknode -> fn_Node . mln_Succ) ) != NULL)
 983 #else
 984     while ((worknode = (struct FrameNode *)RemTail( (struct List *)(&(gaid -> gaid_FrameList)) ) ) != NULL)
 985 #endif /* FREE_LIST_IN_REVERSE_ORDER */
 986     {
 987       if( worknode -> fn_CMap )
 988       {
 989         FreeColorMap( (worknode -> fn_CMap) );
 990         worknode -> fn_CMap = NULL;
 991       }
 992
 993       if( worknode -> fn_BitMap )
 994       {
 995         FreeFrameBitMap( cb, gaid, (worknode -> fn_BitMap) );
 996         worknode -> fn_BitMap = NULL;
 997       }
 998
 999 #ifdef FREE_LIST_IN_REVERSE_ORDER
1000       worknode = nextnode;
1001 #endif /* FREE_LIST_IN_REVERSE_ORDER */
1002     }
1003 }
1004
1005
1006 struct BitMap *AllocFrameBitMap( struct ClassBase *cb, struct GIFAnimInstData *gaid )
1007 {
1008     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1009
1010     if( gaid -> gaid_UseChunkyMap )
1011     {
1012       return( AllocBitMap( (ULONG)(gaid -> gaid_PaddedWidth), (ULONG)(gaid -> gaid_Height), (ULONG)(gaid -> gaid_Depth),
1013                            (BMF_SPECIALFMT | SHIFT_PIXFMT( DIRECTRGB_PIXFMT )), NULL ) );
1014     }
1015     else
1016     {
1017       return( AllocBitMapPooled( cb, (ULONG)(gaid -> gaid_PaddedWidth), (ULONG)(gaid -> gaid_Height), (ULONG)(gaid -> gaid_Depth), (gaid -> gaid_Pool) ) );
1018     }
1019 }
1020
1021
1022 void FreeFrameBitMap( struct ClassBase *cb, struct GIFAnimInstData *gaid, struct BitMap *bm )
1023 {
1024     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1025
1026     if( bm )
1027     {
1028       if( gaid -> gaid_UseChunkyMap )
1029       {
1030         FreeBitMap( bm );
1031       }
1032       else
1033       {
1034         FreePooledVec( cb, (gaid -> gaid_Pool), bm );
1035       }
1036     }
1037 }
1038
1039
1040 /* This function assumes (0UL < depth) && (depth <= 8UL) */
1041 static
1042 struct BitMap *AllocBitMapPooled( struct ClassBase *cb, ULONG width, ULONG height, ULONG depth, APTR pool )
1043 {
1044     struct BitMap *bm;
1045
1046     ULONG          planesize,
1047                    size;
1048
1049     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1050
1051     planesize = (ULONG)RASSIZE( width, height ) + 16UL;
1052     size      = ((ULONG)sizeof( struct BitMap )) + (planesize * depth) + width;
1053
1054     if ((bm = (struct BitMap *)AllocPooledVec( cb, pool, size ) ) != NULL)
1055     {
1056       UWORD    pl;
1057       PLANEPTR plane;
1058
1059       InitBitMap( bm, depth, width, height );
1060
1061       plane = (PLANEPTR)(bm + 1); /* First plane follows struct BitMap */
1062
1063       /* Set up plane data */
1064       pl = 0U;
1065
1066       /* Set up plane ptrs */
1067       while( pl < depth )
1068       {
1069         bm -> Planes[ pl ] = plane;
1070
1071         plane = (PLANEPTR)(((UBYTE *)plane) + planesize + 8);
1072         pl++;
1073       }
1074
1075       /* Clear the remaining plane ptrs */
1076       while( pl < 8U )
1077       {
1078         bm -> Planes[ pl ] = NULL;
1079
1080         pl++;
1081       }
1082     }
1083
1084     return( bm );
1085 }
1086
1087
1088 void OpenLogfile( struct ClassBase *cb, struct GIFAnimInstData *gaid )
1089 {
1090     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1091
1092     if( ((gaid -> gaid_VerboseOutput) == NULL) || ((gaid -> gaid_VerboseOutput) == (APTR)-1L) )
1093     {
1094       STRPTR confile;
1095
1096       if ((confile = (STRPTR)AllocVec( (((gaid -> gaid_ProjectName)?(strlen( (gaid -> gaid_ProjectName) )):(0UL)) + 100UL), MEMF_PUBLIC ) ) != NULL)
1097       {
1098         mysprintf( cb, confile, "CON:////GIF Anim DataType %s/auto/wait/close/inactive",
1099                    ((gaid -> gaid_ProjectName)?(FilePart( (gaid -> gaid_ProjectName) )):(NULL)) );
1100
1101         gaid -> gaid_VerboseOutput = Open( confile, MODE_READWRITE );
1102
1103         FreeVec( confile );
1104       }
1105     }
1106 }
1107
1108
1109 #if !defined(__AROS__)
1110 void error_printf( struct ClassBase *cb, struct GIFAnimInstData *gaid, STRPTR format, ... )
1111 {
1112     va_list args;
1113
1114     if( (gaid -> gaid_VerboseOutput) != (BPTR)-1L )
1115     {
1116         OpenLogfile( cb, gaid );
1117
1118         if( gaid -> gaid_VerboseOutput )
1119         {
1120             va_start (args, format);
1121             VFPrintf( (gaid -> gaid_VerboseOutput), format, args);
1122             va_end (args);
1123         }
1124     }
1125 }
1126
1127
1128 void verbose_printf( struct ClassBase *cb, struct GIFAnimInstData *gaid, STRPTR format, ... )
1129 {
1130     va_list args;
1131
1132     if( (gaid -> gaid_VerboseOutput) && ((gaid -> gaid_VerboseOutput) != (BPTR)-1L) )
1133     {
1134         va_start (args, format);
1135         VFPrintf( (gaid -> gaid_VerboseOutput), format, args);
1136         va_end (args);
1137     }
1138 }
1139 #endif
1140
1141 static
1142 void AttachSample( struct ClassBase *cb, struct GIFAnimInstData *gaid )
1143 {
1144     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1145
1146     if( gaid -> gaid_Sample )
1147     {
1148       struct FrameNode *worknode,
1149                        *nextnode;
1150
1151       ULONG             period          = gaid -> gaid_Period;
1152       ULONG             samplesperframe;
1153       BYTE             *sample          = gaid -> gaid_Sample;
1154
1155       samplesperframe = (((SysBase -> ex_EClockFrequency) * 10UL) / (period * (gaid -> gaid_FPS) * 2UL));
1156
1157       if( gaid -> gaid_SamplesPerFrame )
1158       {
1159         period = (period * samplesperframe) / (gaid -> gaid_SamplesPerFrame);
1160
1161         samplesperframe = gaid -> gaid_SamplesPerFrame;
1162
1163         verbose_printf( cb, gaid, "period corrected from %lu to %lu to match spf=%lu with fps=%lu\n",
1164                         (gaid -> gaid_Period), period, samplesperframe, (gaid -> gaid_FPS) );
1165       }
1166
1167       verbose_printf( cb, gaid, "Attching samples (sysclock %lu period %lu fps %lu length %lu samplesperframe %lu)...\n",
1168                       (SysBase -> ex_EClockFrequency), period, (gaid -> gaid_FPS), (gaid -> gaid_SampleLength), samplesperframe );
1169
1170       worknode = (struct FrameNode *)(gaid -> gaid_FrameList . mlh_Head);
1171
1172       while ((nextnode = (struct FrameNode *)(worknode -> fn_Node . mln_Succ) ) != NULL)
1173       {
1174         worknode -> fn_Sample       = sample;
1175         worknode -> fn_SampleLength = samplesperframe * ((worknode -> fn_Duration) + 1UL);
1176         worknode -> fn_Period       = period;
1177
1178         sample += worknode -> fn_SampleLength;
1179
1180         /* End of sample reached ? */
1181         if( (IPTR)(sample - (gaid -> gaid_Sample)) > (gaid -> gaid_SampleLength) )
1182         {
1183           /* Cut last size of sample to fit */
1184           worknode -> fn_SampleLength -= (IPTR)(sample - (gaid -> gaid_Sample));
1185
1186           break;
1187         }
1188
1189         worknode = nextnode;
1190       }
1191     }
1192 }
1193
1194
1195 /* Read a GIF colormap info a struct ColorRegister */
1196 static
1197 BOOL ReadColorMap( struct ClassBase *cb, struct GIFAnimInstData *gaid, UWORD numcolors, struct ColorRegister *color )
1198 {
1199     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1200
1201     return( (BOOL)(!ReadOK( cb, (&(gaid -> gaid_GIFDec)), color, (ULONG)(GIFCMAPENTRYSIZE * numcolors) )) );
1202 }
1203
1204
1205 static
1206 int DoExtension( struct ClassBase *cb, Object *o, struct GIFAnimInstData *gaid, TEXT label )
1207 {
1208     struct GIFDecoder *gifdec     = (&(gaid -> gaid_GIFDec));
1209     UBYTE              buf[ 257 ] = { 0 };
1210     STRPTR             str;
1211     int                count;
1212
1213     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1214
1215     switch( (int)label )
1216     {
1217       case 0x01:              /* Plain Text Extension */
1218       {
1219           UWORD lpos,
1220                 tpos,
1221                 width,
1222                 height,
1223                 cellw,
1224                 cellh,
1225                 foreground,
1226                 background;
1227
1228           error_printf( cb, gaid, "'Plain text extension' (%d) not supported yet. Please send this animation to the author that"
1229                                   "this can be implemented\n", (int)label );
1230
1231           if( GetDataBlock( cb, gaid, buf ) == -1 )
1232           {
1233             return( -1 );
1234           }
1235
1236           lpos       = LOHI2UINT16( buf[ 0 ], buf[ 1 ] );
1237           tpos       = LOHI2UINT16( buf[ 2 ], buf[ 3 ] );
1238           width      = LOHI2UINT16( buf[ 4 ], buf[ 5 ] );
1239           height     = LOHI2UINT16( buf[ 6 ], buf[ 7 ] );
1240           cellw      = buf[ 8 ];
1241           cellh      = buf[ 9 ];
1242           foreground = buf[ 10 ];
1243           background = buf[ 11 ];
1244
1245           verbose_printf( cb, gaid, "Plain text: "
1246                                     "left %lu top %lu width %lu height %lu "
1247                                     "cell width %lu cell height %lu"
1248                                     "foreground %lu background %lu", lpos, tpos, width, height, cellw, cellh, foreground, background );
1249
1250           while( (count = GetDataBlock( cb, gaid, buf )), ((count != 0) && (count != -1)) )
1251           {
1252 #if 0
1253             PPM_ASSIGN( image[ ypos ][ xpos ], cmap[ CM_RED ][ v ], cmap[ CM_GREEN ][ v ], cmap[ CM_BLUE ][ v ] );
1254
1255             index++;
1256 #endif
1257
1258             /* Clear buffer for next cycle */
1259             memset( (void *)buf, 0, sizeof( buf ) );
1260           }
1261
1262           return( 0 );
1263       }
1264
1265       case 0xf9:              /* Graphic Control Extension */
1266       {
1267           STRPTR fmt; /* Format string for verbose output (fmt changes if transparent color is set) */
1268
1269           if( GetDataBlock( cb, gaid, buf ) == -1 )
1270           {
1271             return( -1 );
1272           }
1273
1274           /* Get "delta" mode (disposal of previous frame), input flag and the delay time in 1/100 sec) */
1275           gifdec -> Gif89 . disposal    = (buf[ 0 ] >> 2) & 0x7;
1276           gifdec -> Gif89 . inputFlag   = (buf[ 0 ] >> 1) & 0x1;
1277           gifdec -> Gif89 . delayTime   = LOHI2UINT16( buf[ 1 ], buf[ 2 ] );
1278
1279           /* Any transparent color ? */
1280           if( buf[ 0 ] & 0x01 )
1281           {
1282             gifdec -> Gif89 . transparent = buf[ 3 ];
1283
1284             fmt = "Graphic Control Extension: disposal %s (%lu)%s transparent %lu\n";
1285           }
1286           else
1287           {
1288             fmt = "Graphic Control Extension: disposal %s (%lu)%s\n";
1289           }
1290
1291           /* Verbose output ? */
1292           if( (gaid -> gaid_VerboseOutput) && ((gaid -> gaid_VerboseOutput) != (BPTR)-1L) )
1293           {
1294             STRPTR user_input = ((gifdec -> Gif89 . inputFlag)?(" user input requested"):(""));
1295             STRPTR disposal;
1296
1297             switch( gifdec -> Gif89 . disposal )
1298             {
1299               case GIF89A_DISPOSE_NOP:                  disposal = "nop";                break;
1300               case GIF89A_DISPOSE_NODISPOSE:            disposal = "no dispose";         break;
1301               case GIF89A_DISPOSE_RESTOREBACKGROUND:    disposal = "restore background"; break;
1302               case GIF89A_DISPOSE_RESTOREPREVIOUS:      disposal = "restore previous";   break;
1303               default:                                  disposal = "reserved";           break;
1304             }
1305
1306             verbose_printf( cb, gaid, fmt,
1307                                       disposal,
1308                                       (ULONG)(gifdec -> Gif89 . disposal),
1309                                       user_input,
1310                                       (gifdec -> Gif89 . transparent) );
1311           }
1312
1313           /* Ignore remaining data... */
1314           while( (count = GetDataBlock( cb, gaid, (UBYTE *)buf )), ((count != 0) && (count != -1)) )
1315                   ;
1316
1317           /* Return 0 (success) or -1 (error) */
1318           return( count );
1319       }
1320
1321       case 0xfe:              /* Comment Extension */
1322       {
1323           STRPTR annotation;
1324
1325           /* Get all comment extension chunks, and append them on the DTA_ObjAnnotation string we've created before */
1326           while( (count = GetDataBlock( cb, gaid, buf )), ((count != 0) && (count != -1)) )
1327           {
1328             ULONG  size;
1329             STRPTR oldannotation;
1330
1331             buf[ 255 ] = '\0'; /* terminate explicitly */
1332
1333             size = (ULONG)strlen( buf ) + 2UL;
1334
1335             (void)GetDTAttrs( o, DTA_ObjAnnotation, (&oldannotation), TAG_DONE );
1336
1337             if( oldannotation )
1338             {
1339               size += (ULONG)strlen( oldannotation ) + 2UL;
1340             }
1341
1342             /* Allocate a temp. buffer */
1343             if ((annotation = (STRPTR)AllocMem( size, MEMF_ANY ) ) != NULL)
1344             {
1345               if( oldannotation )
1346               {
1347                 strcpy( annotation, oldannotation );
1348               }
1349               else
1350               {
1351                 annotation[ 0 ] = '\0'; /* terminate */
1352               }
1353
1354               /* Append the new buffer */
1355               IBMPC2ISOLatin1( buf, (annotation + strlen( annotation )) );
1356
1357               /* Store the comment */
1358               SetDTAttrs( o, NULL, NULL, DTA_ObjAnnotation, annotation, TAG_DONE );
1359
1360               /* Free temp string */
1361               FreeMem( annotation, size );
1362             }
1363
1364             /* Clear buffer for next cycle */
1365             memset( (void *)buf, 0, sizeof( buf ) );
1366           }
1367
1368           /* After all, prompt the annotation to the user */
1369           (void)GetDTAttrs( o, DTA_ObjAnnotation, (&annotation), TAG_DONE );
1370
1371           verbose_printf( cb, gaid, "Comment Extension: '%s'\n", annotation );
1372
1373           return( 0 );
1374       }
1375
1376       case 0xff:              /* Application Extension */
1377       {
1378           str = "Application Extension";
1379       }
1380           break;
1381
1382       default:
1383       {
1384           mysprintf( cb, buf, "UNKNOWN (0x%02lx)", (long)label );
1385           str = buf;
1386       }
1387           break;
1388     }
1389
1390     verbose_printf( cb, gaid, "got a '%s' extension\n", ((str)?(str):(STRPTR)"") );
1391
1392     /* skip extension data */
1393     while( (count = GetDataBlock( cb, gaid, buf )), ((count != 0) && (count != -1)) )
1394       ;
1395
1396     /* Returns 0 (success) or -1 (error) */
1397     return( count );
1398 }
1399
1400
1401 static
1402 int GetDataBlock( struct ClassBase *cb, struct GIFAnimInstData *gaid, UBYTE *buf )
1403 {
1404     struct GIFDecoder *gifdec = (&(gaid -> gaid_GIFDec));
1405     UBYTE              count;
1406
1407     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1408
1409     if( !ReadOK( cb, gifdec, &count, 1 ) )
1410     {
1411       error_printf( cb, gaid, "error %d in getting DataBlock size\n", -1);
1412
1413       return( -1 );
1414     }
1415
1416     gifdec -> ZeroDataBlock = (count == 0);
1417
1418     if( (count != 0) && (!ReadOK( cb, gifdec, buf, (ULONG)count ) ) )
1419     {
1420       error_printf( cb, gaid, "error %d in reading DataBlock\n", -1);
1421
1422       return( -1 );
1423     }
1424
1425     return( count );
1426 }
1427
1428
1429 /* returns -1 for error */
1430 static
1431 int GetCode( struct ClassBase *cb, struct GIFAnimInstData *gaid, int code_size, BOOL flag )
1432 {
1433     struct GIFDecoder *gifdec = (&(gaid -> gaid_GIFDec));
1434     int                i,
1435                        j,
1436                        ret;
1437     UBYTE              count;
1438
1439     if( flag )
1440     {
1441       gifdec -> GetCode . curbit  = 0;
1442       gifdec -> GetCode . lastbit = 0;
1443       gifdec -> GetCode . done    = FALSE;
1444
1445       return( 0 );
1446     }
1447
1448     if( (gifdec -> GetCode . curbit + code_size) >= (gifdec -> GetCode . lastbit) )
1449     {
1450       if( gifdec -> GetCode . done )
1451       {
1452         if( (gifdec -> GetCode . curbit) >= (gifdec -> GetCode . lastbit) )
1453           error_printf( cb, gaid, "GetCode: ran past the end of code bits (%d)\n", gifdec->GetCode.lastbit);
1454
1455         return( -1 );
1456       }
1457
1458       gifdec -> GetCode . buf[ 0 ] = gifdec -> GetCode . buf[ gifdec -> GetCode . last_byte - 2 ];
1459       gifdec -> GetCode . buf[ 1 ] = gifdec -> GetCode . buf[ gifdec -> GetCode . last_byte - 1 ];
1460
1461       if( (count = GetDataBlock( cb, gaid, (&(gifdec -> GetCode . buf[ 2 ])) )) == 0 )
1462         gifdec -> GetCode . done = TRUE;
1463
1464       gifdec -> GetCode . last_byte = 2 + count;
1465       gifdec -> GetCode . curbit    = (gifdec -> GetCode . curbit - gifdec -> GetCode . lastbit) + 16;
1466       gifdec -> GetCode . lastbit   = (2 + count) * 8 ;
1467     }
1468
1469     ret = 0;
1470
1471     for( i = gifdec -> GetCode . curbit, j = 0; j < code_size ; i++, j++ )
1472       ret |= ((gifdec -> GetCode . buf[ i / 8 ] & (1 << (i % 8))) != 0) << j;
1473
1474     gifdec -> GetCode . curbit += code_size;
1475
1476     return( ret );
1477 }
1478
1479
1480 static
1481 int LWZReadByte( struct ClassBase *cb, struct GIFAnimInstData *gaid, BOOL flag, int input_code_size )
1482 {
1483              struct GIFDecoder *gifdec = (&(gaid -> gaid_GIFDec)); /* shortcut */
1484              int                code,
1485                                 incode;
1486     register int                i;
1487
1488     if( flag )
1489     {
1490       gifdec -> LWZReadByte . set_code_size = input_code_size;
1491       gifdec -> LWZReadByte . code_size     = gifdec -> LWZReadByte . set_code_size + 1;
1492       gifdec -> LWZReadByte . clear_code    = 1 << gifdec -> LWZReadByte . set_code_size ;
1493       gifdec -> LWZReadByte . end_code      = gifdec -> LWZReadByte . clear_code + 1;
1494       gifdec -> LWZReadByte . max_code_size = 2 * gifdec -> LWZReadByte . clear_code;
1495       gifdec -> LWZReadByte . max_code      = gifdec -> LWZReadByte . clear_code + 2;
1496
1497       (void)GetCode( cb, gaid, 0, TRUE );
1498
1499       gifdec -> LWZReadByte . fresh = TRUE;
1500
1501       /* Fill table with the codes... */
1502       for( i = 0 ; i < (gifdec -> LWZReadByte . clear_code) ; i++ )
1503       {
1504         gifdec -> LWZReadByte . table[ 0 ][ i ] = 0;
1505         gifdec -> LWZReadByte . table[ 1 ][ i ] = i;
1506       }
1507
1508       /* ... and clear the remaining part  */
1509       for( ; i < (1 << MAX_LWZ_BITS) ; i++ )
1510       {
1511         gifdec -> LWZReadByte . table[ 0 ][ i ] = 0;
1512       }
1513
1514       gifdec -> LWZReadByte . table[ 1 ][ 0 ] = 0;
1515
1516       /* Reset stack ptr */
1517       gifdec -> LWZReadByte . sp = gifdec -> LWZReadByte . stack;
1518
1519       return( 0 );
1520     }
1521     else
1522     {
1523       if( gifdec -> LWZReadByte . fresh )
1524       {
1525         gifdec -> LWZReadByte . fresh = FALSE;
1526
1527         do
1528         {
1529           gifdec -> LWZReadByte . firstcode = gifdec -> LWZReadByte . oldcode = GetCode( cb, gaid, gifdec -> LWZReadByte . code_size, FALSE );
1530         } while( (gifdec -> LWZReadByte . firstcode) == (gifdec -> LWZReadByte . clear_code) );
1531
1532         return( gifdec -> LWZReadByte . firstcode );
1533       }
1534     }
1535
1536     if( (gifdec -> LWZReadByte . sp) > (gifdec -> LWZReadByte . stack) )
1537     {
1538       return( *--gifdec -> LWZReadByte . sp );
1539     }
1540
1541     while( (code = GetCode( cb, gaid, gifdec -> LWZReadByte . code_size, FALSE )) >= 0 )
1542     {
1543       if( code == gifdec -> LWZReadByte . clear_code )
1544       {
1545         for( i = 0 ; i < gifdec -> LWZReadByte . clear_code ; i++ )
1546         {
1547           gifdec -> LWZReadByte . table[ 0 ][ i ] = 0;
1548           gifdec -> LWZReadByte . table[ 1 ][ i ] = i;
1549         }
1550
1551         for( ; i < (1 << MAX_LWZ_BITS) ; i++ )
1552         {
1553           gifdec -> LWZReadByte . table[ 0 ][ i ] =
1554             gifdec -> LWZReadByte . table[ 1 ][ i ] = 0;
1555         }
1556
1557         gifdec -> LWZReadByte . code_size       = gifdec -> LWZReadByte . set_code_size + 1;
1558         gifdec -> LWZReadByte . max_code_size   = 2 * gifdec -> LWZReadByte . clear_code;
1559         gifdec -> LWZReadByte . max_code        = gifdec -> LWZReadByte . clear_code + 2;
1560         gifdec -> LWZReadByte . sp              = gifdec -> LWZReadByte . stack;
1561         gifdec -> LWZReadByte . firstcode       =
1562           gifdec -> LWZReadByte . oldcode       = GetCode( cb, gaid, gifdec -> LWZReadByte . code_size, FALSE );
1563
1564         return( gifdec -> LWZReadByte . firstcode );
1565       }
1566       else
1567       {
1568         if( code == gifdec -> LWZReadByte . end_code )
1569         {
1570           int   count;
1571           UBYTE buf[ 260 ];
1572
1573           if( gifdec -> ZeroDataBlock )
1574             return( -2 );
1575
1576           while( (count = GetDataBlock( cb, gaid, buf )) > 0 )
1577             ;
1578
1579           if( count != 0 )
1580             error_printf( cb, gaid, "missing EOD in data stream (common occurence) (count=%d)\n", count);
1581
1582           return( -2 );
1583         }
1584       }
1585
1586       incode = code;
1587
1588       if( code >= (gifdec -> LWZReadByte . max_code) )
1589       {
1590         *gifdec -> LWZReadByte . sp++ = gifdec -> LWZReadByte . firstcode;
1591         code = gifdec -> LWZReadByte . oldcode;
1592       }
1593
1594       while( code >= gifdec -> LWZReadByte . clear_code )
1595       {
1596         *gifdec -> LWZReadByte . sp++ = gifdec -> LWZReadByte . table[ 1 ][ code ];
1597
1598         if( code == gifdec -> LWZReadByte . table[ 0 ][ code ] )
1599           error_printf( cb, gaid, "circular table entry (code=%d) BIG ERROR\n", code);
1600
1601         code = gifdec -> LWZReadByte . table[ 0 ][ code ];
1602       }
1603
1604       *gifdec -> LWZReadByte . sp++ = gifdec -> LWZReadByte . firstcode = gifdec -> LWZReadByte . table[ 1 ][ code ];
1605
1606       if( (code = gifdec -> LWZReadByte . max_code) < (1 << MAX_LWZ_BITS ) )
1607       {
1608         gifdec -> LWZReadByte . table[ 0 ][ code ] = gifdec -> LWZReadByte . oldcode;
1609         gifdec -> LWZReadByte . table[ 1 ][ code ] = gifdec -> LWZReadByte . firstcode;
1610         gifdec -> LWZReadByte . max_code++;
1611
1612         if( (gifdec -> LWZReadByte . max_code >= gifdec -> LWZReadByte . max_code_size) && (gifdec -> LWZReadByte . max_code_size < (1 << MAX_LWZ_BITS)) )
1613         {
1614           gifdec -> LWZReadByte . max_code_size *= 2;
1615           gifdec -> LWZReadByte . code_size++;
1616         }
1617       }
1618
1619       gifdec -> LWZReadByte . oldcode = incode;
1620
1621       if( gifdec -> LWZReadByte . sp > gifdec -> LWZReadByte . stack )
1622       {
1623         return( *--gifdec -> LWZReadByte . sp );
1624       }
1625     }
1626
1627     return( code );
1628 }
1629
1630
1631 int ReadImage( struct ClassBase *cb, struct GIFAnimInstData *gaid, UBYTE *image,
1632                UWORD imagewidth, UWORD left, UWORD top, UWORD len, UWORD height,
1633                BOOL interlace, BOOL ignore, UWORD transparent )
1634 {
1635     struct GIFDecoder *gifdec = (&(gaid -> gaid_GIFDec)); /* shortcut */
1636     UBYTE              c;
1637
1638     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1639
1640     /* Initialize the Compression routines */
1641     if( !ReadOK( cb, gifdec, &c, 1 ) )
1642     {
1643       return( -1 );
1644     }
1645
1646     /* If this is an "uninteresting picture" ignore it. */
1647     if( ignore )
1648     {
1649       D(bug("[gifanim.datatype]: %s: skipping gif image...\n", __PRETTY_FUNCTION__ ) );
1650
1651       /* Loop until end of raster data */
1652       while(TRUE)
1653       {
1654         if( !ReadOK( cb, gifdec, &c, 1 ) )
1655         {
1656           error_printf( cb, gaid, "EOF (%d) / reading block byte count\n", -1);
1657           return( -1 );
1658         }
1659
1660         if( c == 0 )
1661         {
1662           D(bug("[gifanim.datatype]: %s: gif image done\n", __PRETTY_FUNCTION__ ) );
1663           break;
1664         }
1665
1666         /* Skip... */
1667         if( Seek( (gifdec -> file), (long)c, OFFSET_CURRENT ) == -1L )
1668         {
1669           return( -1 );
1670         }
1671       }
1672     }
1673     else
1674     {
1675        WORD v;
1676       ULONG xpos    = 0UL,
1677             ypos    = 0UL,
1678             offset  = (top * imagewidth) + left, /* "ypos" position in image (byte offset) */
1679             pass    = 0UL;                       /* interlace pass */
1680
1681       if( LWZReadByte( cb, gaid, TRUE, c ) < 0 )
1682         error_printf( cb, gaid, "error (<%d) reading image\n", 0);
1683
1684       D(bug("[gifanim.datatype]: %s: reading %lx %ld.%ld / %ld by %ld%s GIF image\n", __PRETTY_FUNCTION__, image, left, top, len, height, interlace ? " interlaced" : "" ) );
1685
1686       while( (v = LWZReadByte( cb, gaid, FALSE, c )) >= 0 )
1687       {
1688         /* Pixel transparent ? */
1689         if( (transparent == ~0U) || (transparent != v) )
1690         {
1691           /* Store pixel */
1692           image[ offset + xpos ] = v;
1693         }
1694
1695         xpos++;
1696
1697         if( xpos == len )
1698         {
1699           xpos = 0UL;
1700
1701           if( interlace )
1702           {
1703             switch( pass )
1704             {
1705               case 0UL:
1706               case 1UL: ypos += 8UL; break;
1707               case 2UL: ypos += 4UL; break;
1708               case 3UL: ypos += 2UL; break;
1709             }
1710
1711             if( ypos >= height )
1712             {
1713               pass++;
1714
1715               switch( pass )
1716               {
1717                 case 1UL: ypos = 4UL;  break;
1718                 case 2UL: ypos = 2UL;  break;
1719                 case 3UL: ypos = 1UL;  break;
1720                 default: goto fini;
1721               }
1722             }
1723           }
1724           else
1725           {
1726             ypos++;
1727           }
1728
1729           offset = ((ypos + top) * imagewidth) + left;
1730         }
1731
1732         if( ypos >= height )
1733           break;
1734       }
1735
1736 fini:
1737       if( (v = LWZReadByte( cb, gaid, FALSE, c )) >= 0 )
1738       {
1739         /* 0x00-bytes are treated here as padding bytes unless the STRICTSYNTAX option is set... */
1740         if( (v != 0) || (gaid -> gaid_StrictSyntax) )
1741         {
1742           verbose_printf( cb, gaid, "too much input data %ld, ignoring extra...\n", (long)v );
1743         }
1744       }
1745     }
1746
1747     return( 0 );
1748 }
1749
1750
1751 /* got from my anim.datatype (IFF ANIM) */
1752 struct FrameNode *GetPrevFrameNode( struct FrameNode *currfn, ULONG interleave )
1753 {
1754     struct FrameNode *worknode,
1755                      *prevnode;
1756
1757     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1758
1759     /* Get previous frame */
1760     worknode = currfn;
1761
1762     while ((prevnode = (struct FrameNode *)(worknode -> fn_Node . mln_Pred) ) != NULL)
1763     {
1764       if( (interleave-- == 0U) || ((prevnode -> fn_Node . mln_Pred) == NULL) )
1765       {
1766         break;
1767       }
1768
1769       worknode = prevnode;
1770     }
1771
1772     return( worknode );
1773 }
1774
1775
1776 /* WritePixelArray8 replacement by Peter McGavin (p.mcgavin@irl.cri.nz),
1777  * slightly adapted to fit here...
1778  */
1779
1780 void WriteDeltaPixelArray8Fast( struct BitMap *dest, UBYTE *source, UBYTE *prev )
1781 {
1782              ULONG *plane[ 8 ] = { 0 };
1783     register ULONG *chunky     = (ULONG *)source, /* fetch 32 bits per cycle */
1784                    *prevchunky = (ULONG *)prev;
1785              ULONG  numcycles  = ((dest -> Rows) * (dest -> BytesPerRow)) / sizeof( ULONG ),
1786                     i;
1787
1788     D(bug("[gifanim.datatype]: %s()\n", __PRETTY_FUNCTION__));
1789
1790     /* Copy plane ptrs */
1791     for( i = 0UL ; i < (dest -> Depth) ; i++ )
1792     {
1793         D(bug("[gifanim.datatype] %s: plane %d @ 0x%p\n", __PRETTY_FUNCTION__, i, dest -> Planes[ i ]));
1794       plane[ i ] = (ULONG *)(dest -> Planes[ i ]);
1795     }
1796
1797     /* Fill unused planes with plane 0, which will be written last, all previous accesses
1798      * will be droped (assumes that a cache hides this "dummy" writes)
1799      */
1800     for( ; i < 8UL ; i++ )
1801     {
1802       plane[ i ] = (ULONG *)(dest -> Planes[ 0 ]);
1803     }
1804
1805 #define merge( a, b, mask, shift ) \
1806       tmp = mask & (a ^ (b >> shift));   \
1807       a ^= tmp;                          \
1808       b ^= (tmp << shift)
1809
1810     /* Check if we have to do the "delta" test */
1811     if( prevchunky )
1812     {
1813         /* Process bitmaps */
1814       for( i = 0UL ; i < numcycles ; i++ )
1815       {
1816         ULONG curr0, curr1, curr2, curr3, curr4, curr5, curr6, curr7;
1817         ULONG prev0, prev1, prev2, prev3, prev4, prev5, prev6, prev7;
1818         ULONG tmp;
1819
1820         /* process 32 pixels */
1821
1822         curr0 =  AROS_BE2LONG(*chunky++);  curr4 =  AROS_BE2LONG(*chunky++);
1823         curr1 =  AROS_BE2LONG(*chunky++);  curr5 =  AROS_BE2LONG(*chunky++);
1824         curr2 =  AROS_BE2LONG(*chunky++);  curr6 =  AROS_BE2LONG(*chunky++);
1825         curr3 =  AROS_BE2LONG(*chunky++);  curr7 =  AROS_BE2LONG(*chunky++);
1826
1827         prev0 =  AROS_BE2LONG(*prevchunky++);  prev4 =  AROS_BE2LONG(*prevchunky++);
1828         prev1 =  AROS_BE2LONG(*prevchunky++);  prev5 =  AROS_BE2LONG(*prevchunky++);
1829         prev2 =  AROS_BE2LONG(*prevchunky++);  prev6 =  AROS_BE2LONG(*prevchunky++);
1830         prev3 =  AROS_BE2LONG(*prevchunky++);  prev7 =  AROS_BE2LONG(*prevchunky++);
1831
1832         /* I use the '+' here to avoid that the compiler skips an expression.
1833          * WARNING: The code assumes that the code is executed in the sequence as it occurs here
1834          */
1835         if ( (curr0 != prev0) || (curr4 != prev4) ||
1836             (curr1 != prev1) || (curr5 != prev5) ||
1837             (curr2 != prev2) || (curr6 != prev6) ||
1838             (curr3 != prev3) || (curr7 != prev7))
1839         {
1840           merge( curr0, curr2, 0x0000ffff, 16 );
1841           merge( curr1, curr3, 0x0000ffff, 16 );
1842           merge( curr4, curr6, 0x0000ffff, 16 );
1843           merge( curr5, curr7, 0x0000ffff, 16 );
1844
1845           merge( curr0, curr1, 0x00ff00ff,  8 );
1846           merge( curr2, curr3, 0x00ff00ff,  8 );
1847           merge( curr4, curr5, 0x00ff00ff,  8 );
1848           merge( curr6, curr7, 0x00ff00ff,  8 );
1849
1850           merge( curr0, curr4, 0x0f0f0f0f,  4 );
1851           merge( curr1, curr5, 0x0f0f0f0f,  4 );
1852           merge( curr2, curr6, 0x0f0f0f0f,  4 );
1853           merge( curr3, curr7, 0x0f0f0f0f,  4 );
1854
1855           merge( curr0, curr2, 0x33333333,  2 );
1856           merge( curr1, curr3, 0x33333333,  2 );
1857           merge( curr4, curr6, 0x33333333,  2 );
1858           merge( curr5, curr7, 0x33333333,  2 );
1859
1860           merge( curr0, curr1, 0x55555555,  1 );
1861           merge( curr2, curr3, 0x55555555,  1 );
1862           merge( curr4, curr5, 0x55555555,  1 );
1863           merge( curr6, curr7, 0x55555555,  1 );
1864
1865           *plane[ 7 ]++ = AROS_LONG2BE(curr0);
1866           *plane[ 6 ]++ = AROS_LONG2BE(curr1);
1867           *plane[ 5 ]++ = AROS_LONG2BE(curr2);
1868           *plane[ 4 ]++ = AROS_LONG2BE(curr3);
1869           *plane[ 3 ]++ = AROS_LONG2BE(curr4);
1870           *plane[ 2 ]++ = AROS_LONG2BE(curr5);
1871           *plane[ 1 ]++ = AROS_LONG2BE(curr6);
1872           *plane[ 0 ]++ = AROS_LONG2BE(curr7);
1873         }
1874         else
1875         {
1876           plane[ 7 ]++;
1877           plane[ 6 ]++;
1878           plane[ 5 ]++;
1879           plane[ 4 ]++;
1880           plane[ 3 ]++;
1881           plane[ 2 ]++;
1882           plane[ 1 ]++;
1883           plane[ 0 ]++;
1884         }
1885       }
1886     }
1887     else
1888     {
1889       /* Process bitmaps */
1890       for( i = 0UL ; i < numcycles ; i++ )
1891       {
1892         register ULONG b0, b1, b2, b3, b4, b5, b6, b7,
1893                        tmp;
1894
1895         /* process 32 pixels */
1896         b0 = AROS_BE2LONG(*chunky++);  b4 = AROS_BE2LONG(*chunky++);
1897         b1 = AROS_BE2LONG(*chunky++);  b5 = AROS_BE2LONG(*chunky++);
1898         b2 = AROS_BE2LONG(*chunky++);  b6 = AROS_BE2LONG(*chunky++);
1899         b3 = AROS_BE2LONG(*chunky++);  b7 = AROS_BE2LONG(*chunky++);
1900
1901         merge( b0, b2, 0x0000ffff, 16 );
1902         merge( b1, b3, 0x0000ffff, 16 );
1903         merge( b4, b6, 0x0000ffff, 16 );
1904         merge( b5, b7, 0x0000ffff, 16 );
1905
1906         merge( b0, b1, 0x00ff00ff,  8 );
1907         merge( b2, b3, 0x00ff00ff,  8 );
1908         merge( b4, b5, 0x00ff00ff,  8 );
1909         merge( b6, b7, 0x00ff00ff,  8 );
1910
1911         merge( b0, b4, 0x0f0f0f0f,  4 );
1912         merge( b1, b5, 0x0f0f0f0f,  4 );
1913         merge( b2, b6, 0x0f0f0f0f,  4 );
1914         merge( b3, b7, 0x0f0f0f0f,  4 );
1915
1916         merge( b0, b2, 0x33333333,  2 );
1917         merge( b1, b3, 0x33333333,  2 );
1918         merge( b4, b6, 0x33333333,  2 );
1919         merge( b5, b7, 0x33333333,  2 );
1920
1921         merge( b0, b1, 0x55555555,  1 );
1922         merge( b2, b3, 0x55555555,  1 );
1923         merge( b4, b5, 0x55555555,  1 );
1924         merge( b6, b7, 0x55555555,  1 );
1925
1926         *plane[ 7 ]++ = AROS_LONG2BE(b0);
1927         *plane[ 6 ]++ = AROS_LONG2BE(b1);
1928         *plane[ 5 ]++ = AROS_LONG2BE(b2);
1929         *plane[ 4 ]++ = AROS_LONG2BE(b3);
1930         *plane[ 3 ]++ = AROS_LONG2BE(b4);
1931         *plane[ 2 ]++ = AROS_LONG2BE(b5);
1932         *plane[ 1 ]++ = AROS_LONG2BE(b6);
1933         *plane[ 0 ]++ = AROS_LONG2BE(b7);
1934       }
1935     }
1936 }
1937
1938
1939 static
1940 int getbase2( int x )
1941 {
1942     int i = 0,
1943         j = 1;
1944
1945     while( x > j )
1946     {
1947       j *= 2;
1948       i++;
1949     }
1950
1951     return( i );
1952 }
1953
1954
1955
1956 /* Read and test */
1957 BOOL ReadOK( struct ClassBase *cb, struct GIFDecoder *gifdec, void *buffer, ULONG len )
1958 {
1959     if( (gifdec -> which_fh) == WHICHFH_FILE )
1960     {
1961       return( (BOOL)(Read( (gifdec -> file), buffer, len ) == len) );
1962     }
1963     else
1964     {
1965       /* Check if the request fit in out buffer... */
1966       if( (((gifdec -> buffer) - (gifdec -> file_buffer)) + len) <= (gifdec -> buffersize) )
1967       {
1968         CopyMem( (gifdec -> buffer), buffer, len );
1969         gifdec -> buffer += len;
1970
1971         return( TRUE );
1972       }
1973     }
1974
1975     return( FALSE );
1976 }
1977
1978
1979
1980