git.oblomov.eu Git - wine/blob - dlls/oleaut32/ungif.c

   1 /*
   2  * Gif extracting routines - derived from libungif
   3  *
   4  * Portions Copyright 2006 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22  * Original copyright notice:
  23  *
  24  * The GIFLIB distribution is Copyright (c) 1997  Eric S. Raymond
  25  *
  26  * Permission is hereby granted, free of charge, to any person obtaining a copy
  27  * of this software and associated documentation files (the "Software"), to deal
  28  * in the Software without restriction, including without limitation the rights
  29  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  30  * copies of the Software, and to permit persons to whom the Software is
  31  * furnished to do so, subject to the following conditions:
  32  *
  33  * The above copyright notice and this permission notice shall be included in
  34  * all copies or substantial portions of the Software.
  35  */
  36
  37
  38 /******************************************************************************
  39  *   "Gif-Lib" - Yet another gif library.
  40  *
  41  * Written by:  Gershon Elber            IBM PC Ver 1.1,    Aug. 1990
  42  ******************************************************************************
  43  * The kernel of the GIF Decoding process can be found here.
  44  ******************************************************************************
  45  * History:
  46  * 16 Jun 89 - Version 1.0 by Gershon Elber.
  47  *  3 Sep 90 - Version 1.1 by Gershon Elber (Support for Gif89, Unique names).
  48  *****************************************************************************/
  49
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include "ungif.h"
  53
  54 #define LZ_MAX_CODE         4095    /* Biggest code possible in 12 bits. */
  55 #define LZ_BITS             12
  56
  57 #define NO_SUCH_CODE        4098    /* Impossible code, to signal empty. */
  58
  59 typedef struct GifFilePrivateType {
  60     GifWord BitsPerPixel,     /* Bits per pixel (Codes uses at least this + 1). */
  61       ClearCode,   /* The CLEAR LZ code. */
  62       EOFCode,     /* The EOF LZ code. */
  63       RunningCode, /* The next code algorithm can generate. */
  64       RunningBits, /* The number of bits required to represent RunningCode. */
  65       MaxCode1,    /* 1 bigger than max. possible code, in RunningBits bits. */
  66       LastCode,    /* The code before the current code. */
  67       CrntCode,    /* Current algorithm code. */
  68       StackPtr,    /* For character stack (see below). */
  69       CrntShiftState;    /* Number of bits in CrntShiftDWord. */
  70     unsigned long CrntShiftDWord;   /* For bytes decomposition into codes. */
  71     unsigned long PixelCount;   /* Number of pixels in image. */
  72     InputFunc Read;     /* function to read gif input (TVT) */
  73     GifByteType Buf[256];   /* Compressed input is buffered here. */
  74     GifByteType Stack[LZ_MAX_CODE]; /* Decoded pixels are stacked here. */
  75     GifByteType Suffix[LZ_MAX_CODE + 1];    /* So we can trace the codes. */
  76     GifPrefixType Prefix[LZ_MAX_CODE + 1];
  77 } GifFilePrivateType;
  78
  79 /* avoid extra function call in case we use fread (TVT) */
  80 #define READ(_gif,_buf,_len) \
  81     ((GifFilePrivateType*)_gif->Private)->Read(_gif,_buf,_len)
  82
  83 static int DGifGetWord(GifFileType *GifFile, GifWord *Word);
  84 static int DGifSetupDecompress(GifFileType *GifFile);
  85 static int DGifDecompressLine(GifFileType *GifFile, GifPixelType *Line, int LineLen);
  86 static int DGifGetPrefixChar(GifPrefixType *Prefix, int Code, int ClearCode);
  87 static int DGifDecompressInput(GifFileType *GifFile, int *Code);
  88 static int DGifBufferedInput(GifFileType *GifFile, GifByteType *Buf,
  89                              GifByteType *NextByte);
  90
  91 static int DGifGetExtensionNext(GifFileType * GifFile, GifByteType ** GifExtension);
  92 static int DGifGetCodeNext(GifFileType * GifFile, GifByteType ** GifCodeBlock);
  93
  94 /******************************************************************************
  95  * Miscellaneous utility functions
  96  *****************************************************************************/
  97
  98 /* return smallest bitfield size n will fit in */
  99 static int
 100 BitSize(int n) {
 101
 102     register int i;
 103
 104     for (i = 1; i <= 8; i++)
 105         if ((1 << i) >= n)
 106             break;
 107     return (i);
 108 }
 109
 110 /******************************************************************************
 111  * Color map object functions
 112  *****************************************************************************/
 113
 114 /*
 115  * Allocate a color map of given size; initialize with contents of
 116  * ColorMap if that pointer is non-NULL.
 117  */
 118 static ColorMapObject *
 119 MakeMapObject(int ColorCount,
 120               const GifColorType * ColorMap) {
 121
 122     ColorMapObject *Object;
 123
 124     /*** FIXME: Our ColorCount has to be a power of two.  Is it necessary to
 125      * make the user know that or should we automatically round up instead? */
 126     if (ColorCount != (1 << BitSize(ColorCount))) {
 127         return ((ColorMapObject *) NULL);
 128     }
 129
 130     Object = malloc(sizeof(ColorMapObject));
 131     if (Object == (ColorMapObject *) NULL) {
 132         return ((ColorMapObject *) NULL);
 133     }
 134
 135     Object->Colors = (GifColorType *)calloc(ColorCount, sizeof(GifColorType));
 136     if (Object->Colors == (GifColorType *) NULL) {
 137         return ((ColorMapObject *) NULL);
 138     }
 139
 140     Object->ColorCount = ColorCount;
 141     Object->BitsPerPixel = BitSize(ColorCount);
 142
 143     if (ColorMap) {
 144         memcpy(Object->Colors, ColorMap, ColorCount * sizeof(GifColorType));
 145     }
 146
 147     return (Object);
 148 }
 149
 150 /*
 151  * Free a color map object
 152  */
 153 static void
 154 FreeMapObject(ColorMapObject * Object) {
 155
 156     if (Object != NULL) {
 157         free(Object->Colors);
 158         free(Object);
 159         /*** FIXME:
 160          * When we are willing to break API we need to make this function
 161          * FreeMapObject(ColorMapObject **Object)
 162          * and do this assignment to NULL here:
 163          * *Object = NULL;
 164          */
 165     }
 166 }
 167
 168 static int
 169 AddExtensionBlock(SavedImage * New,
 170                   int Len,
 171                   unsigned char ExtData[]) {
 172
 173     ExtensionBlock *ep;
 174
 175     if (New->ExtensionBlocks == NULL)
 176         New->ExtensionBlocks = malloc(sizeof(ExtensionBlock));
 177     else
 178         New->ExtensionBlocks = realloc(New->ExtensionBlocks,
 179                                       sizeof(ExtensionBlock) *
 180                                       (New->ExtensionBlockCount + 1));
 181
 182     if (New->ExtensionBlocks == NULL)
 183         return (GIF_ERROR);
 184
 185     ep = &New->ExtensionBlocks[New->ExtensionBlockCount++];
 186
 187     ep->ByteCount=Len;
 188     ep->Bytes = malloc(ep->ByteCount);
 189     if (ep->Bytes == NULL)
 190         return (GIF_ERROR);
 191
 192     if (ExtData) {
 193         memcpy(ep->Bytes, ExtData, Len);
 194         ep->Function = New->Function;
 195     }
 196
 197     return (GIF_OK);
 198 }
 199
 200 static void
 201 FreeExtension(SavedImage * Image)
 202 {
 203     ExtensionBlock *ep;
 204
 205     if ((Image == NULL) || (Image->ExtensionBlocks == NULL)) {
 206         return;
 207     }
 208     for (ep = Image->ExtensionBlocks;
 209          ep < (Image->ExtensionBlocks + Image->ExtensionBlockCount); ep++)
 210         free(ep->Bytes);
 211     free(Image->ExtensionBlocks);
 212     Image->ExtensionBlocks = NULL;
 213 }
 214
 215 /******************************************************************************
 216  * Image block allocation functions
 217 ******************************************************************************/
 218
 219 static void
 220 FreeSavedImages(GifFileType * GifFile) {
 221
 222     SavedImage *sp;
 223
 224     if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
 225         return;
 226     }
 227     for (sp = GifFile->SavedImages;
 228          sp < GifFile->SavedImages + GifFile->ImageCount; sp++) {
 229         if (sp->ImageDesc.ColorMap) {
 230             FreeMapObject(sp->ImageDesc.ColorMap);
 231             sp->ImageDesc.ColorMap = NULL;
 232         }
 233
 234         free(sp->RasterBits);
 235
 236         if (sp->ExtensionBlocks)
 237             FreeExtension(sp);
 238     }
 239     free(GifFile->SavedImages);
 240     GifFile->SavedImages=NULL;
 241 }
 242
 243 /******************************************************************************
 244  * This routine should be called before any other DGif calls. Note that
 245  * this routine is called automatically from DGif file open routines.
 246  *****************************************************************************/
 247 static int
 248 DGifGetScreenDesc(GifFileType * GifFile) {
 249
 250     int i, BitsPerPixel;
 251     GifByteType Buf[3];
 252
 253     /* Put the screen descriptor into the file: */
 254     if (DGifGetWord(GifFile, &GifFile->SWidth) == GIF_ERROR ||
 255         DGifGetWord(GifFile, &GifFile->SHeight) == GIF_ERROR)
 256         return GIF_ERROR;
 257
 258     if (READ(GifFile, Buf, 3) != 3) {
 259         return GIF_ERROR;
 260     }
 261     GifFile->SColorResolution = (((Buf[0] & 0x70) + 1) >> 4) + 1;
 262     BitsPerPixel = (Buf[0] & 0x07) + 1;
 263     GifFile->SBackGroundColor = Buf[1];
 264     if (Buf[0] & 0x80) {    /* Do we have global color map? */
 265
 266         GifFile->SColorMap = MakeMapObject(1 << BitsPerPixel, NULL);
 267         if (GifFile->SColorMap == NULL) {
 268             return GIF_ERROR;
 269         }
 270
 271         /* Get the global color map: */
 272         for (i = 0; i < GifFile->SColorMap->ColorCount; i++) {
 273             if (READ(GifFile, Buf, 3) != 3) {
 274                 FreeMapObject(GifFile->SColorMap);
 275                 GifFile->SColorMap = NULL;
 276                 return GIF_ERROR;
 277             }
 278             GifFile->SColorMap->Colors[i].Red = Buf[0];
 279             GifFile->SColorMap->Colors[i].Green = Buf[1];
 280             GifFile->SColorMap->Colors[i].Blue = Buf[2];
 281         }
 282     } else {
 283         GifFile->SColorMap = NULL;
 284     }
 285
 286     return GIF_OK;
 287 }
 288
 289 /******************************************************************************
 290  * This routine should be called before any attempt to read an image.
 291  *****************************************************************************/
 292 static int
 293 DGifGetRecordType(GifFileType * GifFile,
 294                   GifRecordType * Type) {
 295
 296     GifByteType Buf;
 297
 298     if (READ(GifFile, &Buf, 1) != 1) {
 299         return GIF_ERROR;
 300     }
 301
 302     switch (Buf) {
 303       case ',':
 304           *Type = IMAGE_DESC_RECORD_TYPE;
 305           break;
 306       case '!':
 307           *Type = EXTENSION_RECORD_TYPE;
 308           break;
 309       case ';':
 310           *Type = TERMINATE_RECORD_TYPE;
 311           break;
 312       default:
 313           *Type = UNDEFINED_RECORD_TYPE;
 314           return GIF_ERROR;
 315     }
 316
 317     return GIF_OK;
 318 }
 319
 320 /******************************************************************************
 321  * This routine should be called before any attempt to read an image.
 322  * Note it is assumed the Image desc. header (',') has been read.
 323  *****************************************************************************/
 324 static int
 325 DGifGetImageDesc(GifFileType * GifFile) {
 326
 327     int i, BitsPerPixel;
 328     GifByteType Buf[3];
 329     GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
 330     SavedImage *sp;
 331
 332     if (DGifGetWord(GifFile, &GifFile->Image.Left) == GIF_ERROR ||
 333         DGifGetWord(GifFile, &GifFile->Image.Top) == GIF_ERROR ||
 334         DGifGetWord(GifFile, &GifFile->Image.Width) == GIF_ERROR ||
 335         DGifGetWord(GifFile, &GifFile->Image.Height) == GIF_ERROR)
 336         return GIF_ERROR;
 337     if (READ(GifFile, Buf, 1) != 1) {
 338         return GIF_ERROR;
 339     }
 340     BitsPerPixel = (Buf[0] & 0x07) + 1;
 341     GifFile->Image.Interlace = (Buf[0] & 0x40);
 342     if (Buf[0] & 0x80) {    /* Does this image have local color map? */
 343
 344         /*** FIXME: Why do we check both of these in order to do this?
 345          * Why do we have both Image and SavedImages? */
 346         if (GifFile->Image.ColorMap && GifFile->SavedImages == NULL)
 347             FreeMapObject(GifFile->Image.ColorMap);
 348
 349         GifFile->Image.ColorMap = MakeMapObject(1 << BitsPerPixel, NULL);
 350         if (GifFile->Image.ColorMap == NULL) {
 351             return GIF_ERROR;
 352         }
 353
 354         /* Get the image local color map: */
 355         for (i = 0; i < GifFile->Image.ColorMap->ColorCount; i++) {
 356             if (READ(GifFile, Buf, 3) != 3) {
 357                 FreeMapObject(GifFile->Image.ColorMap);
 358                 GifFile->Image.ColorMap = NULL;
 359                 return GIF_ERROR;
 360             }
 361             GifFile->Image.ColorMap->Colors[i].Red = Buf[0];
 362             GifFile->Image.ColorMap->Colors[i].Green = Buf[1];
 363             GifFile->Image.ColorMap->Colors[i].Blue = Buf[2];
 364         }
 365     } else if (GifFile->Image.ColorMap) {
 366         FreeMapObject(GifFile->Image.ColorMap);
 367         GifFile->Image.ColorMap = NULL;
 368     }
 369
 370     if (GifFile->SavedImages) {
 371         if ((GifFile->SavedImages = realloc(GifFile->SavedImages,
 372                                       sizeof(SavedImage) *
 373                                       (GifFile->ImageCount + 1))) == NULL) {
 374             return GIF_ERROR;
 375         }
 376     } else {
 377         if ((GifFile->SavedImages = malloc(sizeof(SavedImage))) == NULL) {
 378             return GIF_ERROR;
 379         }
 380     }
 381
 382     sp = &GifFile->SavedImages[GifFile->ImageCount];
 383     memcpy(&sp->ImageDesc, &GifFile->Image, sizeof(GifImageDesc));
 384     if (GifFile->Image.ColorMap != NULL) {
 385         sp->ImageDesc.ColorMap = MakeMapObject(
 386                                  GifFile->Image.ColorMap->ColorCount,
 387                                  GifFile->Image.ColorMap->Colors);
 388         if (sp->ImageDesc.ColorMap == NULL) {
 389             return GIF_ERROR;
 390         }
 391     }
 392     sp->RasterBits = (unsigned char *)NULL;
 393     sp->ExtensionBlockCount = 0;
 394     sp->ExtensionBlocks = (ExtensionBlock *) NULL;
 395
 396     GifFile->ImageCount++;
 397
 398     Private->PixelCount = (long)GifFile->Image.Width *
 399        (long)GifFile->Image.Height;
 400
 401     DGifSetupDecompress(GifFile);  /* Reset decompress algorithm parameters. */
 402
 403     return GIF_OK;
 404 }
 405
 406 /******************************************************************************
 407  * Get one full scanned line (Line) of length LineLen from GIF file.
 408  *****************************************************************************/
 409 static int
 410 DGifGetLine(GifFileType * GifFile,
 411             GifPixelType * Line,
 412             int LineLen) {
 413
 414     GifByteType *Dummy;
 415     GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
 416
 417     if (!LineLen)
 418         LineLen = GifFile->Image.Width;
 419
 420     if ((Private->PixelCount -= LineLen) > 0xffff0000UL) {
 421         return GIF_ERROR;
 422     }
 423
 424     if (DGifDecompressLine(GifFile, Line, LineLen) == GIF_OK) {
 425         if (Private->PixelCount == 0) {
 426             /* We probably would not be called any more, so lets clean
 427              * everything before we return: need to flush out all rest of
 428              * image until empty block (size 0) detected. We use GetCodeNext. */
 429             do
 430                 if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR)
 431                     return GIF_ERROR;
 432             while (Dummy != NULL) ;
 433         }
 434         return GIF_OK;
 435     } else
 436         return GIF_ERROR;
 437 }
 438
 439 /******************************************************************************
 440  * Get an extension block (see GIF manual) from gif file. This routine only
 441  * returns the first data block, and DGifGetExtensionNext should be called
 442  * after this one until NULL extension is returned.
 443  * The Extension should NOT be freed by the user (not dynamically allocated).
 444  * Note it is assumed the Extension desc. header ('!') has been read.
 445  *****************************************************************************/
 446 static int
 447 DGifGetExtension(GifFileType * GifFile,
 448                  int *ExtCode,
 449                  GifByteType ** Extension) {
 450
 451     GifByteType Buf;
 452
 453     if (READ(GifFile, &Buf, 1) != 1) {
 454         return GIF_ERROR;
 455     }
 456     *ExtCode = Buf;
 457
 458     return DGifGetExtensionNext(GifFile, Extension);
 459 }
 460
 461 /******************************************************************************
 462  * Get a following extension block (see GIF manual) from gif file. This
 463  * routine should be called until NULL Extension is returned.
 464  * The Extension should NOT be freed by the user (not dynamically allocated).
 465  *****************************************************************************/
 466 static int
 467 DGifGetExtensionNext(GifFileType * GifFile,
 468                      GifByteType ** Extension) {
 469
 470     GifByteType Buf;
 471     GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
 472
 473     if (READ(GifFile, &Buf, 1) != 1) {
 474         return GIF_ERROR;
 475     }
 476     if (Buf > 0) {
 477         *Extension = Private->Buf;    /* Use private unused buffer. */
 478         (*Extension)[0] = Buf;  /* Pascal strings notation (pos. 0 is len.). */
 479         if (READ(GifFile, &((*Extension)[1]), Buf) != Buf) {
 480             return GIF_ERROR;
 481         }
 482     } else
 483         *Extension = NULL;
 484
 485     return GIF_OK;
 486 }
 487
 488 /******************************************************************************
 489  * Get 2 bytes (word) from the given file:
 490  *****************************************************************************/
 491 static int
 492 DGifGetWord(GifFileType * GifFile,
 493             GifWord *Word) {
 494
 495     unsigned char c[2];
 496
 497     if (READ(GifFile, c, 2) != 2) {
 498         return GIF_ERROR;
 499     }
 500
 501     *Word = (((unsigned int)c[1]) << 8) + c[0];
 502     return GIF_OK;
 503 }
 504
 505 /******************************************************************************
 506  * Continue to get the image code in compressed form. This routine should be
 507  * called until NULL block is returned.
 508  * The block should NOT be freed by the user (not dynamically allocated).
 509  *****************************************************************************/
 510 static int
 511 DGifGetCodeNext(GifFileType * GifFile,
 512                 GifByteType ** CodeBlock) {
 513
 514     GifByteType Buf;
 515     GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
 516
 517     if (READ(GifFile, &Buf, 1) != 1) {
 518         return GIF_ERROR;
 519     }
 520
 521     if (Buf > 0) {
 522         *CodeBlock = Private->Buf;    /* Use private unused buffer. */
 523         (*CodeBlock)[0] = Buf;  /* Pascal strings notation (pos. 0 is len.). */
 524         if (READ(GifFile, &((*CodeBlock)[1]), Buf) != Buf) {
 525             return GIF_ERROR;
 526         }
 527     } else {
 528         *CodeBlock = NULL;
 529         Private->Buf[0] = 0;    /* Make sure the buffer is empty! */
 530         Private->PixelCount = 0;    /* And local info. indicate image read. */
 531     }
 532
 533     return GIF_OK;
 534 }
 535
 536 /******************************************************************************
 537  * Setup the LZ decompression for this image:
 538  *****************************************************************************/
 539 static int
 540 DGifSetupDecompress(GifFileType * GifFile) {
 541
 542     int i, BitsPerPixel;
 543     GifByteType CodeSize;
 544     GifPrefixType *Prefix;
 545     GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
 546
 547     READ(GifFile, &CodeSize, 1);    /* Read Code size from file. */
 548     BitsPerPixel = CodeSize;
 549
 550     Private->Buf[0] = 0;    /* Input Buffer empty. */
 551     Private->BitsPerPixel = BitsPerPixel;
 552     Private->ClearCode = (1 << BitsPerPixel);
 553     Private->EOFCode = Private->ClearCode + 1;
 554     Private->RunningCode = Private->EOFCode + 1;
 555     Private->RunningBits = BitsPerPixel + 1;    /* Number of bits per code. */
 556     Private->MaxCode1 = 1 << Private->RunningBits;    /* Max. code + 1. */
 557     Private->StackPtr = 0;    /* No pixels on the pixel stack. */
 558     Private->LastCode = NO_SUCH_CODE;
 559     Private->CrntShiftState = 0;    /* No information in CrntShiftDWord. */
 560     Private->CrntShiftDWord = 0;
 561
 562     Prefix = Private->Prefix;
 563     for (i = 0; i <= LZ_MAX_CODE; i++)
 564         Prefix[i] = NO_SUCH_CODE;
 565
 566     return GIF_OK;
 567 }
 568
 569 /******************************************************************************
 570  * The LZ decompression routine:
 571  * This version decompress the given gif file into Line of length LineLen.
 572  * This routine can be called few times (one per scan line, for example), in
 573  * order the complete the whole image.
 574  *****************************************************************************/
 575 static int
 576 DGifDecompressLine(GifFileType * GifFile,
 577                    GifPixelType * Line,
 578                    int LineLen) {
 579
 580     int i = 0;
 581     int j, CrntCode, EOFCode, ClearCode, CrntPrefix, LastCode, StackPtr;
 582     GifByteType *Stack, *Suffix;
 583     GifPrefixType *Prefix;
 584     GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
 585
 586     StackPtr = Private->StackPtr;
 587     Prefix = Private->Prefix;
 588     Suffix = Private->Suffix;
 589     Stack = Private->Stack;
 590     EOFCode = Private->EOFCode;
 591     ClearCode = Private->ClearCode;
 592     LastCode = Private->LastCode;
 593
 594     if (StackPtr != 0) {
 595         /* Let pop the stack off before continueing to read the gif file: */
 596         while (StackPtr != 0 && i < LineLen)
 597             Line[i++] = Stack[--StackPtr];
 598     }
 599
 600     while (i < LineLen) {    /* Decode LineLen items. */
 601         if (DGifDecompressInput(GifFile, &CrntCode) == GIF_ERROR)
 602             return GIF_ERROR;
 603
 604         if (CrntCode == EOFCode) {
 605             /* Note however that usually we will not be here as we will stop
 606              * decoding as soon as we got all the pixel, or EOF code will
 607              * not be read at all, and DGifGetLine/Pixel clean everything.  */
 608             if (i != LineLen - 1 || Private->PixelCount != 0) {
 609                 return GIF_ERROR;
 610             }
 611             i++;
 612         } else if (CrntCode == ClearCode) {
 613             /* We need to start over again: */
 614             for (j = 0; j <= LZ_MAX_CODE; j++)
 615                 Prefix[j] = NO_SUCH_CODE;
 616             Private->RunningCode = Private->EOFCode + 1;
 617             Private->RunningBits = Private->BitsPerPixel + 1;
 618             Private->MaxCode1 = 1 << Private->RunningBits;
 619             LastCode = Private->LastCode = NO_SUCH_CODE;
 620         } else {
 621             /* Its regular code - if in pixel range simply add it to output
 622              * stream, otherwise trace to codes linked list until the prefix
 623              * is in pixel range: */
 624             if (CrntCode < ClearCode) {
 625                 /* This is simple - its pixel scalar, so add it to output: */
 626                 Line[i++] = CrntCode;
 627             } else {
 628                 /* Its a code to needed to be traced: trace the linked list
 629                  * until the prefix is a pixel, while pushing the suffix
 630                  * pixels on our stack. If we done, pop the stack in reverse
 631                  * (thats what stack is good for!) order to output.  */
 632                 if (Prefix[CrntCode] == NO_SUCH_CODE) {
 633                     /* Only allowed if CrntCode is exactly the running code:
 634                      * In that case CrntCode = XXXCode, CrntCode or the
 635                      * prefix code is last code and the suffix char is
 636                      * exactly the prefix of last code! */
 637                     if (CrntCode == Private->RunningCode - 2) {
 638                         CrntPrefix = LastCode;
 639                         Suffix[Private->RunningCode - 2] =
 640                            Stack[StackPtr++] = DGifGetPrefixChar(Prefix,
 641                                                                  LastCode,
 642                                                                  ClearCode);
 643                     } else {
 644                         return GIF_ERROR;
 645                     }
 646                 } else
 647                     CrntPrefix = CrntCode;
 648
 649                 /* Now (if image is O.K.) we should not get a NO_SUCH_CODE
 650                  * during the trace. As we might loop forever, in case of
 651                  * defective image, we count the number of loops we trace
 652                  * and stop if we got LZ_MAX_CODE. Obviously we cannot
 653                  * loop more than that.  */
 654                 j = 0;
 655                 while (j++ <= LZ_MAX_CODE &&
 656                        CrntPrefix > ClearCode && CrntPrefix <= LZ_MAX_CODE) {
 657                     Stack[StackPtr++] = Suffix[CrntPrefix];
 658                     CrntPrefix = Prefix[CrntPrefix];
 659                 }
 660                 if (j >= LZ_MAX_CODE || CrntPrefix > LZ_MAX_CODE) {
 661                     return GIF_ERROR;
 662                 }
 663                 /* Push the last character on stack: */
 664                 Stack[StackPtr++] = CrntPrefix;
 665
 666                 /* Now lets pop all the stack into output: */
 667                 while (StackPtr != 0 && i < LineLen)
 668                     Line[i++] = Stack[--StackPtr];
 669             }
 670             if (LastCode != NO_SUCH_CODE) {
 671                 Prefix[Private->RunningCode - 2] = LastCode;
 672
 673                 if (CrntCode == Private->RunningCode - 2) {
 674                     /* Only allowed if CrntCode is exactly the running code:
 675                      * In that case CrntCode = XXXCode, CrntCode or the
 676                      * prefix code is last code and the suffix char is
 677                      * exactly the prefix of last code! */
 678                     Suffix[Private->RunningCode - 2] =
 679                        DGifGetPrefixChar(Prefix, LastCode, ClearCode);
 680                 } else {
 681                     Suffix[Private->RunningCode - 2] =
 682                        DGifGetPrefixChar(Prefix, CrntCode, ClearCode);
 683                 }
 684             }
 685             LastCode = CrntCode;
 686         }
 687     }
 688
 689     Private->LastCode = LastCode;
 690     Private->StackPtr = StackPtr;
 691
 692     return GIF_OK;
 693 }
 694
 695 /******************************************************************************
 696  * Routine to trace the Prefixes linked list until we get a prefix which is
 697  * not code, but a pixel value (less than ClearCode). Returns that pixel value.
 698  * If image is defective, we might loop here forever, so we limit the loops to
 699  * the maximum possible if image O.k. - LZ_MAX_CODE times.
 700  *****************************************************************************/
 701 static int
 702 DGifGetPrefixChar(GifPrefixType *Prefix,
 703                   int Code,
 704                   int ClearCode) {
 705
 706     int i = 0;
 707
 708     while (Code > ClearCode && i++ <= LZ_MAX_CODE)
 709         Code = Prefix[Code];
 710     return Code;
 711 }
 712
 713 /******************************************************************************
 714  * The LZ decompression input routine:
 715  * This routine is responsible for the decompression of the bit stream from
 716  * 8 bits (bytes) packets, into the real codes.
 717  * Returns GIF_OK if read successfully.
 718  *****************************************************************************/
 719 static int
 720 DGifDecompressInput(GifFileType * GifFile,
 721                     int *Code) {
 722
 723     GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
 724
 725     GifByteType NextByte;
 726     static unsigned short CodeMasks[] = {
 727         0x0000, 0x0001, 0x0003, 0x0007,
 728         0x000f, 0x001f, 0x003f, 0x007f,
 729         0x00ff, 0x01ff, 0x03ff, 0x07ff,
 730         0x0fff
 731     };
 732     /* The image can't contain more than LZ_BITS per code. */
 733     if (Private->RunningBits > LZ_BITS) {
 734         return GIF_ERROR;
 735     }
 736
 737     while (Private->CrntShiftState < Private->RunningBits) {
 738         /* Needs to get more bytes from input stream for next code: */
 739         if (DGifBufferedInput(GifFile, Private->Buf, &NextByte) == GIF_ERROR) {
 740             return GIF_ERROR;
 741         }
 742         Private->CrntShiftDWord |=
 743            ((unsigned long)NextByte) << Private->CrntShiftState;
 744         Private->CrntShiftState += 8;
 745     }
 746     *Code = Private->CrntShiftDWord & CodeMasks[Private->RunningBits];
 747
 748     Private->CrntShiftDWord >>= Private->RunningBits;
 749     Private->CrntShiftState -= Private->RunningBits;
 750
 751     /* If code cannot fit into RunningBits bits, must raise its size. Note
 752      * however that codes above 4095 are used for special signaling.
 753      * If we're using LZ_BITS bits already and we're at the max code, just
 754      * keep using the table as it is, don't increment Private->RunningCode.
 755      */
 756     if (Private->RunningCode < LZ_MAX_CODE + 2 &&
 757             ++Private->RunningCode > Private->MaxCode1 &&
 758             Private->RunningBits < LZ_BITS) {
 759         Private->MaxCode1 <<= 1;
 760         Private->RunningBits++;
 761     }
 762     return GIF_OK;
 763 }
 764
 765 /******************************************************************************
 766  * This routines read one gif data block at a time and buffers it internally
 767  * so that the decompression routine could access it.
 768  * The routine returns the next byte from its internal buffer (or read next
 769  * block in if buffer empty) and returns GIF_OK if successful.
 770  *****************************************************************************/
 771 static int
 772 DGifBufferedInput(GifFileType * GifFile,
 773                   GifByteType * Buf,
 774                   GifByteType * NextByte) {
 775
 776     if (Buf[0] == 0) {
 777         /* Needs to read the next buffer - this one is empty: */
 778         if (READ(GifFile, Buf, 1) != 1) {
 779             return GIF_ERROR;
 780         }
 781         /* There shouldn't be any empty data blocks here as the LZW spec
 782          * says the LZW termination code should come first.  Therefore we
 783          * shouldn't be inside this routine at that point.
 784          */
 785         if (Buf[0] == 0) {
 786             return GIF_ERROR;
 787         }
 788         if (READ(GifFile, &Buf[1], Buf[0]) != Buf[0]) {
 789             return GIF_ERROR;
 790         }
 791         *NextByte = Buf[1];
 792         Buf[1] = 2;    /* We use now the second place as last char read! */
 793         Buf[0]--;
 794     } else {
 795         *NextByte = Buf[Buf[1]++];
 796         Buf[0]--;
 797     }
 798
 799     return GIF_OK;
 800 }
 801
 802 /******************************************************************************
 803  * This routine reads an entire GIF into core, hanging all its state info off
 804  * the GifFileType pointer.  Call DGifOpenFileName() or DGifOpenFileHandle()
 805  * first to initialize I/O.  Its inverse is EGifSpew().
 806  ******************************************************************************/
 807 int
 808 DGifSlurp(GifFileType * GifFile) {
 809
 810     int ImageSize;
 811     GifRecordType RecordType;
 812     SavedImage *sp;
 813     GifByteType *ExtData;
 814     SavedImage temp_save;
 815
 816     temp_save.ExtensionBlocks = NULL;
 817     temp_save.ExtensionBlockCount = 0;
 818
 819     do {
 820         if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR)
 821             return (GIF_ERROR);
 822
 823         switch (RecordType) {
 824           case IMAGE_DESC_RECORD_TYPE:
 825               if (DGifGetImageDesc(GifFile) == GIF_ERROR)
 826                   return (GIF_ERROR);
 827
 828               sp = &GifFile->SavedImages[GifFile->ImageCount - 1];
 829               ImageSize = sp->ImageDesc.Width * sp->ImageDesc.Height;
 830
 831               sp->RasterBits = malloc(ImageSize * sizeof(GifPixelType));
 832               if (sp->RasterBits == NULL) {
 833                   return GIF_ERROR;
 834               }
 835               if (DGifGetLine(GifFile, sp->RasterBits, ImageSize) ==
 836                   GIF_ERROR)
 837                   return (GIF_ERROR);
 838               if (temp_save.ExtensionBlocks) {
 839                   sp->ExtensionBlocks = temp_save.ExtensionBlocks;
 840                   sp->ExtensionBlockCount = temp_save.ExtensionBlockCount;
 841
 842                   temp_save.ExtensionBlocks = NULL;
 843                   temp_save.ExtensionBlockCount = 0;
 844
 845                   /* FIXME: The following is wrong.  It is left in only for
 846                    * backwards compatibility.  Someday it should go away. Use
 847                    * the sp->ExtensionBlocks->Function variable instead. */
 848                   sp->Function = sp->ExtensionBlocks[0].Function;
 849               }
 850               break;
 851
 852           case EXTENSION_RECORD_TYPE:
 853               if (DGifGetExtension(GifFile, &temp_save.Function, &ExtData) ==
 854                   GIF_ERROR)
 855                   return (GIF_ERROR);
 856               while (ExtData != NULL) {
 857
 858                   /* Create an extension block with our data */
 859                   if (AddExtensionBlock(&temp_save, ExtData[0], &ExtData[1])
 860                       == GIF_ERROR)
 861                       return (GIF_ERROR);
 862
 863                   if (DGifGetExtensionNext(GifFile, &ExtData) == GIF_ERROR)
 864                       return (GIF_ERROR);
 865                   temp_save.Function = 0;
 866               }
 867               break;
 868
 869           case TERMINATE_RECORD_TYPE:
 870               break;
 871
 872           default:    /* Should be trapped by DGifGetRecordType */
 873               break;
 874         }
 875     } while (RecordType != TERMINATE_RECORD_TYPE);
 876
 877     /* Just in case the Gif has an extension block without an associated
 878      * image... (Should we save this into a savefile structure with no image
 879      * instead? Have to check if the present writing code can handle that as
 880      * well.... */
 881     if (temp_save.ExtensionBlocks)
 882         FreeExtension(&temp_save);
 883
 884     return (GIF_OK);
 885 }
 886
 887 /******************************************************************************
 888  * GifFileType constructor with user supplied input function (TVT)
 889  *****************************************************************************/
 890 GifFileType *
 891 DGifOpen(void *userData,
 892          InputFunc readFunc) {
 893
 894     unsigned char Buf[GIF_STAMP_LEN + 1];
 895     GifFileType *GifFile;
 896     GifFilePrivateType *Private;
 897
 898     GifFile = malloc(sizeof(GifFileType));
 899     if (GifFile == NULL) {
 900         return NULL;
 901     }
 902
 903     memset(GifFile, '\0', sizeof(GifFileType));
 904
 905     Private = malloc(sizeof(GifFilePrivateType));
 906     if (!Private) {
 907         free(GifFile);
 908         return NULL;
 909     }
 910
 911     GifFile->Private = (void*)Private;
 912
 913     Private->Read = readFunc;    /* TVT */
 914     GifFile->UserData = userData;    /* TVT */
 915
 916     /* Lets see if this is a GIF file: */
 917     if (READ(GifFile, Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) {
 918         free(Private);
 919         free(GifFile);
 920         return NULL;
 921     }
 922
 923     /* The GIF Version number is ignored at this time. Maybe we should do
 924      * something more useful with it. */
 925     Buf[GIF_STAMP_LEN] = 0;
 926     if (memcmp(GIF_STAMP, Buf, GIF_VERSION_POS) != 0) {
 927         free(Private);
 928         free(GifFile);
 929         return NULL;
 930     }
 931
 932     if (DGifGetScreenDesc(GifFile) == GIF_ERROR) {
 933         free(Private);
 934         free(GifFile);
 935         return NULL;
 936     }
 937
 938     return GifFile;
 939 }
 940
 941 /******************************************************************************
 942  * This routine should be called last, to close the GIF file.
 943  *****************************************************************************/
 944 int
 945 DGifCloseFile(GifFileType * GifFile) {
 946
 947     GifFilePrivateType *Private;
 948
 949     if (GifFile == NULL)
 950         return GIF_ERROR;
 951
 952     Private = (GifFilePrivateType *) GifFile->Private;
 953
 954     if (GifFile->Image.ColorMap) {
 955         FreeMapObject(GifFile->Image.ColorMap);
 956         GifFile->Image.ColorMap = NULL;
 957     }
 958
 959     if (GifFile->SColorMap) {
 960         FreeMapObject(GifFile->SColorMap);
 961         GifFile->SColorMap = NULL;
 962     }
 963
 964     free(Private);
 965     Private = NULL;
 966
 967     if (GifFile->SavedImages) {
 968         FreeSavedImages(GifFile);
 969         GifFile->SavedImages = NULL;
 970     }
 971
 972     free(GifFile);
 973
 974     return GIF_OK;
 975 }