/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%                             GGGG  IIIII  FFFFF                              %

%                            G        I    F                                  %

%                            G  GG    I    FFF                                %

%                            G   G    I    F                                  %

%                             GGG   IIIII  F                                  %

%                                                                             %

%                                                                             %

%            Read/Write Compuserve Graphics Interchange Format                %

%                                                                             %

%                              Software Design                                %

%                                   Cristy                                    %

%                                 July 1992                                   %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization         %

%  dedicated to making software imaging solutions freely available.           %

%                                                                             %

%  You may not use this file except in compliance with the License.  You may  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

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

%

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/attribute.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/color.h"

#include "MagickCore/color-private.h"

#include "MagickCore/colormap.h"

#include "MagickCore/colormap-private.h"

#include "MagickCore/colorspace.h"

#include "MagickCore/colorspace-private.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/image.h"

#include "MagickCore/image-private.h"

#include "MagickCore/list.h"

#include "MagickCore/profile.h"

#include "MagickCore/magick.h"

#include "MagickCore/memory_.h"

#include "MagickCore/memory-private.h"

#include "MagickCore/monitor.h"

#include "MagickCore/monitor-private.h"

#include "MagickCore/option.h"

#include "MagickCore/pixel.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/profile-private.h"

#include "MagickCore/property.h"

#include "MagickCore/quantize.h"

#include "MagickCore/quantum-private.h"

#include "MagickCore/resource_.h"

#include "MagickCore/static.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "MagickCore/module.h"

/*

  Define declarations.

*/

#define MaximumLZWBits  12

#define MaximumLZWCode  (1UL << MaximumLZWBits)

/*

  Typedef declarations.

*/

typedef struct _LZWCodeInfo

{

  unsigned char

    buffer[280];

  size_t

    count,

    bit;

  MagickBooleanType

    eof;

} LZWCodeInfo;

typedef struct _LZWStack

{

  size_t

    *codes,

    *index,

    *top;

} LZWStack;

typedef struct _LZWInfo

{

  Image

    *image;

  LZWStack

    *stack;

  MagickBooleanType

    genesis;

  size_t

    data_size,

    maximum_data_value,

    clear_code,

    end_code,

    bits,

    first_code,

    last_code,

    maximum_code,

    slot,

    *table[2];

  LZWCodeInfo

    code_info;

} LZWInfo;

/*

  Forward declarations.

*/

static inline int

  GetNextLZWCode(LZWInfo *,const size_t);

static MagickBooleanType

  WriteGIFImage(const ImageInfo *,Image *,ExceptionInfo *);

static ssize_t

  ReadBlobBlock(Image *,unsigned char *);

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  DecodeImage uncompresses an image via GIF-coding.

%

%  The format of the DecodeImage method is:

%

%      MagickBooleanType DecodeImage(Image *image,const ssize_t opacity)

%

%  A description of each parameter follows:

%

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

%

%    o opacity:  The colormap index associated with the transparent color.

%

*/

static LZWInfo *RelinquishLZWInfo(LZWInfo *lzw_info)

{

  if (lzw_info->table[0] != (size_t *) NULL)

    lzw_info->table[0]=(size_t *) RelinquishMagickMemory(

      lzw_info->table[0]);

  if (lzw_info->table[1] != (size_t *) NULL)

    lzw_info->table[1]=(size_t *) RelinquishMagickMemory(

      lzw_info->table[1]);

  if (lzw_info->stack != (LZWStack *) NULL)

    {

      if (lzw_info->stack->codes != (size_t *) NULL)

        lzw_info->stack->codes=(size_t *) RelinquishMagickMemory(

          lzw_info->stack->codes);

      lzw_info->stack=(LZWStack *) RelinquishMagickMemory(lzw_info->stack);

    }

  lzw_info=(LZWInfo *) RelinquishMagickMemory(lzw_info);

  return((LZWInfo *) NULL);

}

static inline void ResetLZWInfo(LZWInfo *lzw_info)

{

  size_t

    one;

  lzw_info->bits=lzw_info->data_size+1;

  one=1;

  lzw_info->maximum_code=one << lzw_info->bits;

  lzw_info->slot=lzw_info->maximum_data_value+3;

  lzw_info->genesis=MagickTrue;

}

static LZWInfo *AcquireLZWInfo(Image *image,const size_t data_size)

{

  LZWInfo

    *lzw_info;

  ssize_t

    i;

  size_t

    one;

  lzw_info=(LZWInfo *) AcquireMagickMemory(sizeof(*lzw_info));

  if (lzw_info == (LZWInfo *) NULL)

    return((LZWInfo *) NULL);

  (void) memset(lzw_info,0,sizeof(*lzw_info));

  lzw_info->image=image;

  lzw_info->data_size=data_size;

  one=1;

  lzw_info->maximum_data_value=(one << data_size)-1;

  lzw_info->clear_code=lzw_info->maximum_data_value+1;

  lzw_info->end_code=lzw_info->maximum_data_value+2;

  lzw_info->table[0]=(size_t *) AcquireQuantumMemory(MaximumLZWCode,

    sizeof(**lzw_info->table));

  lzw_info->table[1]=(size_t *) AcquireQuantumMemory(MaximumLZWCode,

    sizeof(**lzw_info->table));

  if ((lzw_info->table[0] == (size_t *) NULL) ||

      (lzw_info->table[1] == (size_t *) NULL))

    {

      lzw_info=RelinquishLZWInfo(lzw_info);

      return((LZWInfo *) NULL);

    }

  (void) memset(lzw_info->table[0],0,MaximumLZWCode*sizeof(**lzw_info->table));

  (void) memset(lzw_info->table[1],0,MaximumLZWCode*sizeof(**lzw_info->table));

  for (i=0; i <= (ssize_t) lzw_info->maximum_data_value; i++)

  {

    lzw_info->table[0][i]=0;

    lzw_info->table[1][i]=(size_t) i;

  }

  ResetLZWInfo(lzw_info);

  lzw_info->code_info.buffer[0]='\0';

  lzw_info->code_info.buffer[1]='\0';

  lzw_info->code_info.count=2;

  lzw_info->code_info.bit=8*lzw_info->code_info.count;

  lzw_info->code_info.eof=MagickFalse;

  lzw_info->genesis=MagickTrue;

  lzw_info->stack=(LZWStack *) AcquireMagickMemory(sizeof(*lzw_info->stack));

  if (lzw_info->stack == (LZWStack *) NULL)

    {

      lzw_info=RelinquishLZWInfo(lzw_info);

      return((LZWInfo *) NULL);

    }

  lzw_info->stack->codes=(size_t *) AcquireQuantumMemory(2UL*

    MaximumLZWCode,sizeof(*lzw_info->stack->codes));

  if (lzw_info->stack->codes == (size_t *) NULL)

    {

      lzw_info=RelinquishLZWInfo(lzw_info);

      return((LZWInfo *) NULL);

    }

  lzw_info->stack->index=lzw_info->stack->codes;

  lzw_info->stack->top=lzw_info->stack->codes+2*MaximumLZWCode;

  return(lzw_info);

}

static inline int GetNextLZWCode(LZWInfo *lzw_info,const size_t bits)

{

  int

    code;

  ssize_t

    i;

  size_t

    one;

  while (((lzw_info->code_info.bit+bits) > (8*lzw_info->code_info.count)) &&

         (lzw_info->code_info.eof == MagickFalse))

  {

    ssize_t

      count;

    lzw_info->code_info.buffer[0]=lzw_info->code_info.buffer[

      lzw_info->code_info.count-2];

    lzw_info->code_info.buffer[1]=lzw_info->code_info.buffer[

      lzw_info->code_info.count-1];

    lzw_info->code_info.bit-=8*(lzw_info->code_info.count-2);

    lzw_info->code_info.count=2;

    count=ReadBlobBlock(lzw_info->image,&lzw_info->code_info.buffer[

      lzw_info->code_info.count]);

    if (count > 0)

      lzw_info->code_info.count+=(size_t) count;

    else

      lzw_info->code_info.eof=MagickTrue;

  }

  if ((lzw_info->code_info.bit+bits) > (8*lzw_info->code_info.count))

    return(-1);

  code=0;

  one=1;

  for (i=0; i < (ssize_t) bits; i++)

  {

    code|=((lzw_info->code_info.buffer[lzw_info->code_info.bit/8] &

      (one << (lzw_info->code_info.bit % 8))) != 0) << i;

    lzw_info->code_info.bit++;

  }

  return(code);

}

static inline int PopLZWStack(LZWStack *stack_info)

{

  if (stack_info->index <= stack_info->codes)

    return(-1);

  stack_info->index--;

  return((int) *stack_info->index);

}

static inline void PushLZWStack(LZWStack *stack_info,const size_t value)

{

  if (stack_info->index >= stack_info->top)

    return;

  *stack_info->index=value;

  stack_info->index++;

}

static int ReadBlobLZWByte(LZWInfo *lzw_info)

{

  int

    code;

  size_t

    one,

    value;

  ssize_t

    count;

  if (lzw_info->stack->index != lzw_info->stack->codes)

    return(PopLZWStack(lzw_info->stack));

  if (lzw_info->genesis != MagickFalse)

    {

      lzw_info->genesis=MagickFalse;

      do

      {

        lzw_info->first_code=(size_t) GetNextLZWCode(lzw_info,lzw_info->bits);

        lzw_info->last_code=lzw_info->first_code;

      } while (lzw_info->first_code == lzw_info->clear_code);

      return((int) lzw_info->first_code);

    }

  code=GetNextLZWCode(lzw_info,lzw_info->bits);

  if (code < 0)

    return(code);

  if ((size_t) code == lzw_info->clear_code)

    {

      ResetLZWInfo(lzw_info);

      return(ReadBlobLZWByte(lzw_info));

    }

  if ((size_t) code == lzw_info->end_code)

    return(-1);

  if ((size_t) code < lzw_info->slot)

    value=(size_t) code;

  else

    {

      PushLZWStack(lzw_info->stack,lzw_info->first_code);

      value=lzw_info->last_code;

    }

  count=0;

  while (value > lzw_info->maximum_data_value)

  {

    if ((size_t) count > MaximumLZWCode)

      return(-1);

    count++;

    if ((size_t) value > MaximumLZWCode)

      return(-1);

    PushLZWStack(lzw_info->stack,lzw_info->table[1][value]);

    value=lzw_info->table[0][value];

  }

  lzw_info->first_code=lzw_info->table[1][value];

  PushLZWStack(lzw_info->stack,lzw_info->first_code);

  one=1;

  if (lzw_info->slot < MaximumLZWCode)

    {

      lzw_info->table[0][lzw_info->slot]=lzw_info->last_code;

      lzw_info->table[1][lzw_info->slot]=lzw_info->first_code;

      lzw_info->slot++;

      if ((lzw_info->slot >= lzw_info->maximum_code) &&

          (lzw_info->bits < MaximumLZWBits))

        {

          lzw_info->bits++;

          lzw_info->maximum_code=one << lzw_info->bits;

        }

    }

  lzw_info->last_code=(size_t) code;

  return(PopLZWStack(lzw_info->stack));

}

static MagickBooleanType DecodeImage(Image *image,const ssize_t opacity,

  ExceptionInfo *exception)

{

  int

    c;

  LZWInfo

    *lzw_info;

  size_t

    pass;

  ssize_t

    index,

    offset,

    y;

  unsigned char

    data_size;

  /*

    Allocate decoder tables.

  */

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

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  data_size=(unsigned char) ReadBlobByte(image);

  if (data_size > MaximumLZWBits)

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

  lzw_info=AcquireLZWInfo(image,data_size);

  if (lzw_info == (LZWInfo *) NULL)

    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",

      image->filename);

  pass=0;

  offset=0;

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

  {

    ssize_t

      x;

    Quantum

      *magick_restrict q;

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

    if (q == (Quantum *) NULL)

      break;

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

    {

      c=ReadBlobLZWByte(lzw_info);

      if (c < 0)

        break;

      index=ConstrainColormapIndex(image,(ssize_t) c,exception);

      SetPixelIndex(image,(Quantum) index,q);

      SetPixelViaPixelInfo(image,image->colormap+index,q);

      SetPixelAlpha(image,index == opacity ? TransparentAlpha : OpaqueAlpha,q);

      x++;

      q+=(ptrdiff_t) GetPixelChannels(image);

    }

    if (SyncAuthenticPixels(image,exception) == MagickFalse)

      break;

    if (x < (ssize_t) image->columns)

      break;

    if (image->interlace == NoInterlace)

      offset++;

    else

      {

        switch (pass)

        {

          case 0:

          default:

          {

            offset+=8;

            break;

          }

          case 1:

          {

            offset+=8;

            break;

          }

          case 2:

          {

            offset+=4;

            break;

          }

          case 3:

          {

            offset+=2;

            break;

          }

        }

      if ((pass == 0) && (offset >= (ssize_t) image->rows))

        {

          pass++;

          offset=4;

        }

      if ((pass == 1) && (offset >= (ssize_t) image->rows))

        {

          pass++;

          offset=2;

        }

      if ((pass == 2) && (offset >= (ssize_t) image->rows))

        {

          pass++;

          offset=1;

        }

    }

  }

  lzw_info=RelinquishLZWInfo(lzw_info);

  if (y < (ssize_t) image->rows)

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

  return(MagickTrue);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  EncodeImage compresses an image via GIF-coding.

%

%  The format of the EncodeImage method is:

%

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

%        const size_t data_size)

%

%  A description of each parameter follows:

%

%    o image_info: the image info.

%

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

%

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

%

*/

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

  const size_t data_size,ExceptionInfo *exception)

{

#define MaxCode(number_bits)  ((one << (number_bits))-1)

#define MaxHashTable  5003

#define MaxGIFBits  12UL

#define MaxGIFTable  (1UL << MaxGIFBits)

#define GIFOutputCode(code) \

{ \

  /*  \

    Emit a code. \

  */ \

  if (bits > 0) \

    datum|=(size_t) (code) << bits; \

  else \

    datum=(size_t) (code); \

  bits+=number_bits; \

  while (bits >= 8) \

  { \

    /*  \

      Add a character to current packet.  Maximum packet size is 255.

    */ \

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

    if (length == 255) \

      { \

        (void) WriteBlobByte(image,(unsigned char) length); \

        (void) WriteBlob(image,length,packet); \

        length=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); \

    } \

}

  Quantum

    index;

  short

    *hash_code,

    *hash_prefix,

    waiting_code;

  size_t

    bits,

    clear_code,

    datum,

    end_of_information_code,

    free_code,

    length,

    max_code,

    next_pixel,

    number_bits,

    one,

    pass;

  ssize_t

    displacement,

    offset,

    k,

    y;

  unsigned char

    *packet,

    *hash_suffix;

  /*

    Allocate encoder tables.

  */

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

  one=1;

  packet=(unsigned char *) AcquireQuantumMemory(256,sizeof(*packet));

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

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

  hash_suffix=(unsigned char *) AcquireQuantumMemory(MaxHashTable,

    sizeof(*hash_suffix));

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

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

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

    {

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

        packet=(unsigned char *) RelinquishMagickMemory(packet);

      if (hash_code != (short *) NULL)

        hash_code=(short *) RelinquishMagickMemory(hash_code);

      if (hash_prefix != (short *) NULL)

        hash_prefix=(short *) RelinquishMagickMemory(hash_prefix);

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

        hash_suffix=(unsigned char *) RelinquishMagickMemory(hash_suffix);

      return(MagickFalse);

    }

  /*

    Initialize GIF encoder.

  */

  (void) memset(packet,0,256*sizeof(*packet));

  (void) memset(hash_code,0,MaxHashTable*sizeof(*hash_code));

  (void) memset(hash_prefix,0,MaxHashTable*sizeof(*hash_prefix));

  (void) memset(hash_suffix,0,MaxHashTable*sizeof(*hash_suffix));

  number_bits=data_size;

  max_code=MaxCode(number_bits);

  clear_code=(size_t) ((short) one << (data_size-1));

  end_of_information_code=clear_code+1;

  free_code=clear_code+2;

  length=0;

  datum=0;

  bits=0;

  GIFOutputCode(clear_code);

  /*

    Encode pixels.

  */

  offset=0;

  pass=0;

  waiting_code=0;

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

  {

    const Quantum

      *magick_restrict p;

    ssize_t

      x;

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

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

      break;

    if (y == 0)

      {

        waiting_code=(short) GetPixelIndex(image,p);

        p+=(ptrdiff_t) GetPixelChannels(image);

      }

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

    {

      /*

        Probe hash table.

      */

      next_pixel=MagickFalse;

      displacement=1;

      index=(Quantum) ((size_t) GetPixelIndex(image,p) & 0xff);

      p+=(ptrdiff_t) GetPixelChannels(image);

      k=(ssize_t) (((size_t) index << (MaxGIFBits-8))+(size_t) waiting_code);

      if (k >= MaxHashTable)

        k-=MaxHashTable;

      if (k < 0)

        continue;

      if (hash_code[k] > 0)

        {

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

              (hash_suffix[k] == (unsigned char) 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] == (unsigned char) index))

              {

                waiting_code=hash_code[k];

                next_pixel=MagickTrue;

                break;

              }

          }

          if (next_pixel != MagickFalse)

            continue;

        }

      GIFOutputCode(waiting_code);

      if (free_code < MaxGIFTable)

        {

          hash_code[k]=(short) 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=(short) index;

    }

    if (image_info->interlace == NoInterlace)

      offset++;

    else

      switch (pass)

      {

        case 0:

        default:

        {

          offset+=8;

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

            {

              pass++;

              offset=4;

            }

          break;

        }

        case 1:

        {

          offset+=8;

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

            {

              pass++;

              offset=2;

            }

          break;

        }

        case 2:

        {

          offset+=4;

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

            {

              pass++;

              offset=1;

            }

          break;

        }

        case 3:

        {

          offset+=2;

          break;

        }

      }

  }

  /*

    Flush out the buffered code.

  */

  GIFOutputCode(waiting_code);

  GIFOutputCode(end_of_information_code);

  if (bits > 0)

    {

      /*

        Add a character to current packet.  Maximum packet size is 255.

      */

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

      if (length == 255)

        {

          (void) WriteBlobByte(image,(unsigned char) length);

          (void) WriteBlob(image,length,packet);

          length=0;

        }

    }

  /*

    Flush accumulated data.

  */

  if (length > 0)

    {

      (void) WriteBlobByte(image,(unsigned char) length);

      (void) WriteBlob(image,length,packet);

    }

  /*

    Free encoder memory.

  */

  hash_suffix=(unsigned char *) RelinquishMagickMemory(hash_suffix);

  hash_prefix=(short *) RelinquishMagickMemory(hash_prefix);

  hash_code=(short *) RelinquishMagickMemory(hash_code);

  packet=(unsigned char *) RelinquishMagickMemory(packet);

  return(MagickTrue);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I s G I F                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

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

%  magick string, is GIF.

%

%  The format of the IsGIF method is:

%

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

%

%  A description of each parameter follows:

%

%    o magick: compare image format pattern against these bytes.

%

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

%

*/

static MagickBooleanType 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                                                  %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  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:

%

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

%

%  A description of each parameter follows:

%

%    o image: the image.

%

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

%      the file.

%

*/

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

{

  ssize_t

    count;

  unsigned char

    block_count = 0;

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

  assert(image->signature == MagickCoreSignature);

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

  count=ReadBlob(image,1,&block_count);

  if (count != 1)

    return(0);

  count=ReadBlob(image,(size_t) block_count,data);

  if (count != (ssize_t) block_count)

    return(0);

  return(count);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  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_info: the image info.

%

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

%

*/

static void *DestroyGIFProfile(void *profile)

{

  return((void *) DestroyStringInfo((StringInfo *) profile));

}

static MagickBooleanType PingGIFImage(Image *image,ExceptionInfo *exception)

{

  unsigned char

    buffer[256],

    length,

    data_size;

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

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  if (ReadBlob(image,1,&data_size) != 1)

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

  if (data_size > MaximumLZWBits)

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

  if (ReadBlob(image,1,&length) != 1)

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

  while (length != 0)

  {

    if (ReadBlob(image,length,buffer) != (ssize_t) length)

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

    if (ReadBlob(image,1,&length) != 1)

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

  }

  return(MagickTrue);

}

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

{

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

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

#define ThrowGIFException(exception,message) \

{ \

  if (profiles != (LinkedListInfo *) NULL) \

    profiles=DestroyLinkedList(profiles,DestroyGIFProfile); \

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

    global_colormap=(unsigned char *) RelinquishMagickMemory(global_colormap); \

  if (meta_image != (Image *) NULL) \

    meta_image=DestroyImage(meta_image); \

  ThrowReaderException((exception),(message)); \

}

  Image

    *image,

    *meta_image;

  LinkedListInfo

    *profiles;

  MagickBooleanType

    status;

  ssize_t

    i;

  unsigned char

    *p;

  size_t

    duration,

    global_colors,

    image_count,

    local_colors,

    one;

  ssize_t

    count,

    opacity;

  unsigned char

    background,

    buffer[257],

    c,

    flag,

    *global_colormap;

  /*

    Open image file.

  */

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

  assert(image_info->signature == MagickCoreSignature);

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

  assert(exception->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",

      image_info->filename);

  image=AcquireImage(image_info,exception);

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

  if (status == MagickFalse)

    {

      image=DestroyImageList(image);

      return((Image *) NULL);

    }

  /*

    Determine if this a GIF file.

  */

  count=ReadBlob(image,6,buffer);

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

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

    ThrowReaderException(CorruptImageError,"ImproperImageHeader");