/*

% Copyright (C) 2003-2021 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

% Copyright 1991-1999 E. I. du Pont de Nemours and Company

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                             GGGG  IIIII  FFFFF                              %

%                            G        I    F                                  %

%                            G  GG    I    FFF                                %

%                            G   G    I    F                                  %

%                             GGG   IIIII  F                                  %

%                                                                             %

%                                                                             %

%            Read/Write Compuserv Graphics Interchange Format.                %

%                                                                             %

%                                                                             %

%                              Software Design                                %

%                                John Cristy                                  %

%                                 July 1992                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/attribute.h"

#include "magick/blob.h"

#include "magick/color.h"

#include "magick/colormap.h"

#include "magick/enum_strings.h"

#include "magick/log.h"

#include "magick/magick.h"

#include "magick/monitor.h"

#include "magick/pixel_cache.h"

#include "magick/quantize.h"

#include "magick/utility.h"

/*

  Forward declarations.

*/

static size_t

  ReadBlobBlock(Image *,unsigned char *);

static unsigned int

  WriteGIFImage(const ImageInfo *,Image *);

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   D e c o d e I m a g e                                                     %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method DecodeImage uncompresses an image via GIF-coding.

%

%  The format of the DecodeImage method is:

%

%      MagickPassFail DecodeImage(Image *image,const long opacity)

%

%  A description of each parameter follows:

%

%    o status:  Method DecodeImage returns MagickPass if all the pixels are

%      uncompressed without error, otherwise MagickFail.

%

%    o image: The address of a structure of type Image.

%

%    o opacity:  The colormap index associated with the transparent

%      color.

%

%

*/

#define MaxStackSize  4096

#define NullCode (~0U)

static MagickPassFail DecodeImage(Image *image,const long opacity)

{

  int

    bits,

    code_size;

  unsigned int

    available,

    clear,

    code,

    code_mask,

    end_of_information,

    in_code,

    old_code,

    pass;

  unsigned long

    y,

    offset;

  register IndexPacket

    *indexes;

  register unsigned long

    x;

  register PixelPacket

    *q;

  register unsigned char

    *c;

  register unsigned int

    datum;

  size_t

    count;

  unsigned short

    *prefix;

  unsigned char

    data_size,

    first,

    index,

    *packet,

    *pixel_stack,

    *suffix,

    *top_stack;

  MagickPassFail

    status=MagickPass;

  assert(image != (Image *) NULL);

  data_size=ReadBlobByte(image);

  if (data_size > 8U) /* 256 */

    ThrowBinaryException(CorruptImageError,CorruptImage,image->filename);

  /*

    Allocate decoder tables.

  */

  packet=MagickAllocateClearedMemory(unsigned char *,256);

  prefix=MagickAllocateClearedArray(unsigned short *,MaxStackSize,sizeof(short));

  suffix=MagickAllocateClearedMemory(unsigned char *,MaxStackSize);

  pixel_stack=MagickAllocateClearedMemory(unsigned char *,MaxStackSize+1);

  if ((packet == (unsigned char *) NULL) ||

      (prefix == (unsigned short *) NULL) ||

      (suffix == (unsigned char *) NULL) ||

      (pixel_stack == (unsigned char *) NULL))

    {

      MagickFreeMemory(pixel_stack);

      MagickFreeMemory(suffix);

      MagickFreeMemory(prefix);

      MagickFreeMemory(packet);

      ThrowBinaryException(ResourceLimitError,MemoryAllocationFailed,

                           image->filename);

    }

  /*

    Initialize GIF data stream decoder.

  */

  clear=1U << data_size;

  end_of_information=clear+1;

  available=clear+2;

  old_code=NullCode;

  code_size=data_size+1;

  code_mask=(1U << code_size)-1;

  for (code=0; code < clear; code++)

    {

      prefix[code]=0;

      suffix[code]=(unsigned char) code;

    }

  /*

    Decode GIF pixel stream.

  */

  datum=0;

  bits=0;

  c=0;

  count=0;

  first=0;

  offset=0;

  pass=0;

  top_stack=pixel_stack;

  for (y=0; y < image->rows; y++)

    {

      q=SetImagePixels(image,0,offset,image->columns,1);

      if (q == (PixelPacket *) NULL)

        {

          status=MagickFail;

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Breaking");

          break;

        }

      indexes=AccessMutableIndexes(image);

      for (x=0; x < image->columns; )

        {

          if (top_stack == pixel_stack)

            {

              if (bits < code_size)

                {

                  /*

                    Load bytes until there is enough bits for a code.

                  */

                  if (count == 0)

                    {

                      /*

                        Read a new data block.

                      */

                      count=ReadBlobBlock(image,packet);

                      if (count == 0)

                        break;

                      c=packet;

                    }

                  datum+=((unsigned int) *c) << bits;

                  bits+=8;

                  c++;

                  count--;

                  continue;

                }

              /*

                Get the next code.

              */

              code=datum & code_mask;

              datum>>=code_size;

              bits-=code_size;

              /*

                Interpret the code

              */

              if (code == end_of_information)

                break;

              if (code == clear)

                {

                  /*

                    Reset decoder.

                  */

                  code_size=data_size+1;

                  code_mask=(1U << code_size)-1;

                  available=clear+2;

                  old_code=NullCode;

                  continue;

                }

              if (old_code == NullCode)

                {

                  *top_stack++=suffix[code];

                  old_code=code;

                  first=(unsigned char) code;

                  continue;

                }

              in_code=code;

              if (code >= available)

                {

                  *top_stack++=first;

                  code=old_code;

                }

              while (code >= clear)

                {

                  if (code >= MaxStackSize)

                    {

                      if (image->logging)

                        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                              "Suffix index (%u) is outside of"

                                              " bounds (0-%u)", code, MaxStackSize);

                      status=MagickFail;

                      break;

                    }

                  if ((top_stack-pixel_stack) >= MaxStackSize)

                    {

                      if (image->logging)

                        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                              "Attempted overrun of pixel stack bounds");

                      status=MagickFail;

                      break;

                    }

                  *top_stack++=suffix[code];

                  code=prefix[code];

                }

              if (status == MagickFail)

                break;

              first=suffix[code];

              /*

                Add a new string to the string table,

              */

              if (available < MaxStackSize)

                {

                  prefix[available]=(short) old_code;

                  suffix[available]=first;

                  available++;

                  if (available >= (code_mask + 1) && code_size < 12)

                    {

                      code_size++;

                      code_mask+=available;

                    }

                }

              *top_stack++=first;

              old_code=in_code;

            }

          if (status == MagickFail)

            break;

          /*

            Pop a pixel off the pixel stack.

          */

          top_stack--;

          index=(*top_stack);

          VerifyColormapIndex(image,index);

          indexes[x]=index;

          *q=image->colormap[index];

          q->opacity=(Quantum)

            (index == opacity ? TransparentOpacity : OpaqueOpacity);

          x++;

          q++;

        }

      if (image->interlace == NoInterlace)

        {

          offset++;

        }

      else

        switch (pass)

          {

          case 0:

          default:

            {

              offset+=8;

              if (offset >= image->rows)

                {

                  pass++;

                  offset=4;

                }

              break;

            }

          case 1:

            {

              offset+=8;

              if (offset >= image->rows)

                {

                  pass++;

                  offset=2;

                }

              break;

            }

          case 2:

            {

              offset+=4;

              if (offset >= image->rows)

                {

                  pass++;

                  offset=1;

                }

              break;

            }

          case 3:

            {

              offset+=2;

              break;

            }

          }

      if (!SyncImagePixels(image))

        {

          status=MagickFail;

          if (image->logging)

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "Failed to sync image pixels");

          break;

        }

      if (x < image->columns)

        {

          status=MagickFail;

          if (image->logging)

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "Quitting, LZW decode."

                                  " Decoded only %lu columns out of %lu.",

                                  x, image->columns);

          break;

        }

      if (image->previous == (Image *) NULL)

        if (QuantumTick(y,image->rows))

          if (!MagickMonitorFormatted(y,image->rows,&image->exception,

                                      LoadImageText,image->filename,

                                      image->columns,image->rows))

            {

              status=MagickFail;

              break;

            }

    }

  MagickFreeMemory(pixel_stack);

  MagickFreeMemory(suffix);

  MagickFreeMemory(prefix);

  MagickFreeMemory(packet);

  if ((status == MagickFail) || (y < image->rows))

    {

      if ((image->logging) && (y < image->rows))

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Decoded only %lu rows out of %lu.",

                              y, image->rows);

      if (image->exception.severity < ErrorException)

        ThrowException(&image->exception,CorruptImageError,CorruptImage,image->filename);

      return MagickFail;

    }

  return(MagickPass);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   E n c o d e I m a g e                                                     %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method EncodeImage compresses an image via GIF-coding.

%

%  The format of the EncodeImage method is:

%

%      MagickPassFail EncodeImage(const ImageInfo *image_info,Image *image,

%        const unsigned int data_size)

%

%  A description of each parameter follows:

%

%    o status:  Method EncodeImage returns MagickPass if all the pixels are

%      compressed without error, otherwise MagickFail.

%

%    o image_info: Specifies a pointer to a ImageInfo structure.

%

%    o image: The address of a structure of type Image.

%

%    o data_size:  The number of bits in the compressed packet.

%

%

*/

#define MaxCode(number_bits)  ((short) ((1U << (number_bits))-1))

#define MaxHashTable  5003

#define MaxGIFBits  12

#define MaxGIFTable  ((short) (1U << MaxGIFBits))

#define GIFOutputCode(code) \

{ \

  /*  \

    Emit a code. \

  */ \

  if (bits > 0) \

    datum|=((unsigned int) code << bits); \

  else \

    datum=(unsigned int) code; \

  bits+=number_bits; \

  while (bits >= 8) \

  { \

    /*  \

      Add a character to current packet. \

    */ \

    packet[byte_count++]=(unsigned char) (datum & 0xff); \

    if (byte_count >= 254) \

      { \

        (void) WriteBlobByte(image,byte_count); \

        (void) WriteBlob(image,byte_count,(char *) packet); \

        byte_count=0; \

      } \

    datum>>=8; \

    bits-=8; \

  } \

  if (free_code > max_code)  \

    { \

      number_bits++; \

      if (number_bits == MaxGIFBits) \

        max_code=MaxGIFTable; \

      else \

        max_code=MaxCode(number_bits); \

    } \

}

static MagickPassFail EncodeImage(const ImageInfo *image_info,Image *image,

  const unsigned int data_size)

{

  int

    displacement,

    next_pixel,

    bits,

    byte_count,

    k,

    number_bits,

    offset,

    pass;

  long

    datum,

    y;

  register const PixelPacket

    *p;

  register const IndexPacket

    *indexes;

  register long

    i,

    x;

  short

    clear_code,

    end_of_information_code,

    free_code,

    *hash_code,

    *hash_prefix,

    index,

    max_code,

    waiting_code;

  unsigned char

    *packet,

    *hash_suffix;

  /*

    Allocate encoder tables.

  */

  assert(image != (Image *) NULL);

  packet=MagickAllocateMemory(unsigned char *,256);

  hash_code=MagickAllocateArray(short *,MaxHashTable,sizeof(short));

  hash_prefix=MagickAllocateArray(short *,MaxHashTable,sizeof(short));

  hash_suffix=MagickAllocateMemory(unsigned char *,MaxHashTable);

  if ((packet == (unsigned char *) NULL) || (hash_code == (short *) NULL) ||

      (hash_prefix == (short *) NULL) ||

      (hash_suffix == (unsigned char *) NULL))

    {

      MagickFreeMemory(packet);

      MagickFreeMemory(hash_code);

      MagickFreeMemory(hash_prefix);

      MagickFreeMemory(hash_suffix);

      return(MagickFail);

    }

  /*

    Initialize GIF encoder.

  */

  number_bits=data_size;

  max_code=MaxCode(number_bits);

  clear_code=((short) 1U << (data_size-1));

  end_of_information_code=clear_code+1;

  free_code=clear_code+2;

  byte_count=0;

  datum=0;

  bits=0;

  for (i=0; i < MaxHashTable; i++)

    hash_code[i]=0;

  GIFOutputCode(clear_code);

  /*

    Encode pixels.

  */

  offset=0;

  pass=0;

  waiting_code=0;

  for (y=0; y < (long) image->rows; y++)

  {

    p=AcquireImagePixels(image,0,offset,image->columns,1,&image->exception);

    if (p == (const PixelPacket *) NULL)

      break;

    indexes=AccessImmutableIndexes(image);

    if (y == 0)

      waiting_code=(*indexes);

    for (x=(y == 0) ? 1 : 0; x < (long) image->columns; x++)

    {

      /*

        Probe hash table.

      */

      index=indexes[x] & 0xff;

      p++;

      k=(int) ((unsigned int) index << (MaxGIFBits-8))+waiting_code;

      if (k >= MaxHashTable)

        k-=MaxHashTable;

      next_pixel=False;

      displacement=1;

      if ((image_info->compression != NoCompression) && (hash_code[k] > 0))

        {

          if ((hash_prefix[k] == waiting_code) && (hash_suffix[k] == index))

            {

              waiting_code=hash_code[k];

              continue;

            }

          if (k != 0)

            displacement=MaxHashTable-k;

          for ( ; ; )

          {

            k-=displacement;

            if (k < 0)

              k+=MaxHashTable;

            if (hash_code[k] == 0)

              break;

            if ((hash_prefix[k] == waiting_code) && (hash_suffix[k] == index))

              {

                waiting_code=hash_code[k];

                next_pixel=True;

                break;

              }

          }

          if (next_pixel == True)

            continue;

        }

      GIFOutputCode(waiting_code);

      if (free_code < MaxGIFTable)

        {

          hash_code[k]=free_code++;

          hash_prefix[k]=waiting_code;

          hash_suffix[k]=(unsigned char) index;

        }

      else

        {

          /*

            Fill the hash table with empty entries.

          */

          for (k=0; k < MaxHashTable; k++)

            hash_code[k]=0;

          /*

            Reset compressor and issue a clear code.

          */

          free_code=clear_code+2;

          GIFOutputCode(clear_code);

          number_bits=data_size;

          max_code=MaxCode(number_bits);

        }

      waiting_code=index;

    }

    if ((image_info->interlace == NoInterlace) ||

        (image_info->interlace == UndefinedInterlace))

      offset++;

    else

      switch (pass)

      {

        case 0:

        default:

        {

          offset+=8;

          if (offset >= (long) image->rows)

            {

              pass++;

              offset=4;

            }

          break;

        }

        case 1:

        {

          offset+=8;

          if (offset >= (long) image->rows)

            {

              pass++;

              offset=2;

            }

          break;

        }

        case 2:

        {

          offset+=4;

          if (offset >= (long) image->rows)

            {

              pass++;

              offset=1;

            }

          break;

        }

        case 3:

        {

          offset+=2;

          break;

        }

      }

    if (image->previous == (Image *) NULL)

      if (QuantumTick(y,image->rows))

        if (!MagickMonitorFormatted(y,image->rows,&image->exception,

                                    SaveImageText,image->filename,

                                    image->columns,image->rows))

          break;

  }

  /*

    Flush out the buffered code.

  */

  GIFOutputCode(waiting_code);

  GIFOutputCode(end_of_information_code);

  if (bits > 0)

    {

      /*

        Add a character to current packet.

      */

      packet[byte_count++]=(unsigned char) (datum & 0xff);

      if (byte_count >= 254)

        {

          (void) WriteBlobByte(image,byte_count);

          (void) WriteBlob(image,byte_count,(char *) packet);

          byte_count=0;

        }

    }

  /*

    Flush accumulated data.

  */

  if (byte_count > 0)

    {

      (void) WriteBlobByte(image,byte_count);

      (void) WriteBlob(image,byte_count,(char *) packet);

    }

  /*

    Free encoder memory.

  */

  MagickFreeMemory(hash_suffix);

  MagickFreeMemory(hash_prefix);

  MagickFreeMemory(hash_code);

  MagickFreeMemory(packet);

  return(MagickPass);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I s G I F                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method IsGIF returns MagickTrue if the image format type, identified by

%  the magick string, is GIF.

%

%  The format of the IsGIF method is:

%

%      MagickBool IsGIF(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsGIF returns True if the image format type is GIF.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o length: Specifies the length of the magick string.

%

%

*/

static MagickBool IsGIF(const unsigned char *magick,const size_t length)

{

  if (length < 4)

    return(MagickFalse);

  if (LocaleNCompare((char *) magick,"GIF8",4) == 0)

    return(MagickTrue);

  return(MagickFalse);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+  R e a d B l o b B l o c k                                                  %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method ReadBlobBlock reads data from the image file and returns it.  The

%  amount of data is determined by first reading a count byte.  The number

%  of bytes read is returned.

%

%  The format of the ReadBlobBlock method is:

%

%      size_t ReadBlobBlock(Image *image,unsigned char *data)

%

%  A description of each parameter follows:

%

%    o count:  Method ReadBlobBlock returns the number of bytes read.

%

%    o image: The image.

%

%    o data:  Specifies an area to place the information requested from

%      the file.

%

%

*/

static size_t ReadBlobBlock(Image *image,unsigned char *data)

{

  size_t

    count=0;

  unsigned char

    block_count;

  assert(image != (Image *) NULL);

  assert(image->signature == MagickSignature);

  assert(data != (unsigned char *) NULL);

  if (ReadBlob(image,1,&block_count) == 1)

    {

      if ((count=ReadBlob(image,(size_t) block_count,data)) != (size_t) block_count)

        count=0;

    }

  return count;

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d G I F I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method ReadGIFImage reads a Compuserve Graphics image file and returns it.

%  It allocates the memory necessary for the new Image structure and returns a

%  pointer to the new image.

%

%  The format of the ReadGIFImage method is:

%

%      Image *ReadGIFImage(const ImageInfo *image_info,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image:  Method ReadGIFImage returns a pointer to the image after

%      reading.  A null image is returned if there is a memory shortage or

%      an error occurs.

%

%    o image_info: Specifies a pointer to a ImageInfo structure.

%

%    o exception: return any errors or warnings in this structure.

%

%

*/

#define BitSet(byte,bit)  (((byte) & (bit)) == (bit))

#define LSBFirstOrder(x,y)  (((y) << 8) | (x))

static Image *ReadGIFImage(const ImageInfo *image_info,ExceptionInfo *exception)

{

  Image

    *image;

  int

    status;

  long

    opacity;

  RectangleInfo

    page;

  register unsigned int

    i;

  register unsigned char

    *p;

  size_t

    count;

  unsigned char

    background,

    c,

    flag,

    *global_colormap,

    header[MaxTextExtent],

    magick[12];

  unsigned int

    global_colors=0,

    local_colors=0;

  unsigned long

    delay,

    dispose,

    image_count,

    iterations;

  /*

    Open image file.

  */

  assert(image_info != (const ImageInfo *) NULL);

  assert(image_info->signature == MagickSignature);

  assert(exception != (ExceptionInfo *) NULL);

  assert(exception->signature == MagickSignature);

  image=AllocateImage(image_info);

  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

  if (status == MagickFail)

    ThrowReaderException(FileOpenError,UnableToOpenFile,image);

  /*

    Determine if this is a GIF file.

  */

  (void) memset(magick,0,sizeof(magick));

  count=ReadBlob(image,6,(char *) magick);

  if ((count != 6) || ((LocaleNCompare((char *) magick,"GIF87",5) != 0) &&

      (LocaleNCompare((char *) magick,"GIF89",5) != 0)))

    ThrowReaderException(CorruptImageError,ImproperImageHeader,image);

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "Magick: %.6s",magick);

  global_colormap=(unsigned char *) NULL;

  page.width=ReadBlobLSBShort(image);

  page.height=ReadBlobLSBShort(image);

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "Canvas Page: %lux%lu", page.width, page.height);

  flag=ReadBlobByte(image);

  background=ReadBlobByte(image);

  c=ReadBlobByte(image);  /* reserved */

  global_colors=1 << ((flag & 0x07)+1);

  global_colormap=MagickAllocateClearedArray(unsigned char *,3U,Max(global_colors,256U));

  if (global_colormap == (unsigned char *) NULL)

    ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "Global Colors: %u", global_colors);

  if (BitSet(flag,0x80))

    {

      if (ReadBlob(image,(size_t) 3*global_colors,(char *) global_colormap) != (size_t) 3U*global_colors)

        {

          MagickFreeMemory(global_colormap);

          ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);

        }

    }

  delay=0;

  dispose=0;

  iterations=1;

  opacity=(-1);

  image_count=0;

  for ( ; ; )

  {

    count=ReadBlob(image,1,(char *) &c);

    if (count != 1)

      break;

    if (c == ';')

      break;  /* terminator */

    if (c == '!')

      {

        /*

          GIF Extension block.

        */

        count=ReadBlob(image,1,(char *) &c);

        if (count != 1) {

          MagickFreeMemory(global_colormap);

          ThrowReaderException(CorruptImageError,UnableToReadExtensionBlock,

            image);

        }

        switch (c)

        {

          case 0xf9:

          {

            /*

              Read Graphics Control extension.

            */

            size_t

              ncount;

            count=0;

            while ((ncount = ReadBlobBlock(image,header)) != 0)

              count = ncount;

            if (count < 4)

              break;

            dispose=header[0] >> 2;

            delay=((unsigned int) header[2] << 8) | header[1];

            if ((header[0] & 0x01) == 1)

              opacity=(header[3] & 0xff);

            break;

          }

          case 0xfe:

          {

            /*

              Read Comment extension.

            */

            char

              *comments = (char *) NULL;

            size_t

              allocation_length=0,

              offset=0;

            for ( ; ; )

              {

                count=ReadBlobBlock(image,header);

                if (count == 0)

                  break;

                header[count]='\0';

                if (count+offset+1 >= allocation_length)

                  {

                    char *comments_new;

                    allocation_length=allocation_length+count+1;

                    comments_new=MagickReallocateResourceLimitedMemory(char *,

                                                                       comments,

                                                                       allocation_length);

                    if (comments_new == (char *) NULL)

                      {

                        MagickFreeMemory(global_colormap);

                        MagickFreeResourceLimitedMemory(comments);

                        ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);

                      }

                    comments=comments_new;

                    (void) strlcpy(&comments[offset],(char *)header,allocation_length-offset);

                  }

              }

            (void) SetImageAttribute(image,"comment",NULL);

            (void) SetImageAttribute(image,"comment",comments);

            MagickFreeResourceLimitedMemory(comments);

            break;

          }

          case 0xff:

          {

            size_t

              ncount;

            int

              loop;

            /*

              Read Netscape Loop extension.

            */

            loop=False;

            count=ReadBlobBlock(image,header);

            if (count >= 11)