Generate wxEVT_COMMAND_TEXT_ENTER events for generic wxSpinCtrl.

[wxWidgets.git] / src / common / gifdecod.cpp

diff --git a/src/common/gifdecod.cpp b/src/common/gifdecod.cpp
index 3ca73d91a6ce0df85062050b4f8714d7cc2e49df..b853ee97a987f11e9e4eee57b8292318e3927f11 100644 (file)
--- a/src/common/gifdecod.cpp
+++ b/src/common/gifdecod.cpp
@@ -19,13 +19,28 @@
 
 #ifndef WX_PRECOMP
     #include "wx/palette.h"
 
 #ifndef WX_PRECOMP
     #include "wx/palette.h"

+    #include "wx/intl.h"
+    #include "wx/log.h"

 #endif
 
 #include <stdlib.h>
 #include <string.h>
 #include "wx/gifdecod.h"
 #endif
 
 #include <stdlib.h>
 #include <string.h>
 #include "wx/gifdecod.h"

+#include "wx/scopedptr.h"
+#include "wx/scopeguard.h"

 
 

+enum
+{
+    GIF_MARKER_EXT       = '!', // 0x21
+    GIF_MARKER_SEP       = ',', // 0x2C
+    GIF_MARKER_ENDOFDATA = ';', // 0x3B
+
+    GIF_MARKER_EXT_GRAPHICS_CONTROL = 0xF9,
+    GIF_MARKER_EXT_COMMENT          = 0xFE,
+    GIF_MARKER_EXT_APP              = 0xFF
+};

 
 

+#define GetFrame(n)     ((GIFImage*)m_frames[n])

 
 //---------------------------------------------------------------------------
 // GIFImage
 
 //---------------------------------------------------------------------------
 // GIFImage


@@ -38,20 +53,23 @@ public:
     // def ctor
     GIFImage();
 
     // def ctor
     GIFImage();
 

-    unsigned int w;                 /* width */
-    unsigned int h;                 /* height */
-    unsigned int left;              /* x coord (in logical screen) */
-    unsigned int top;               /* y coord (in logical screen) */
-    int transparent;                /* transparent color index (-1 = none) */
-    wxAnimationDisposal disposal;   /* disposal method */
-    long delay;                     /* delay in ms (-1 = unused) */
-    unsigned char *p;               /* bitmap */
-    unsigned char *pal;             /* palette */
-    unsigned int ncolours;          /* number of colours */
-
-    DECLARE_NO_COPY_CLASS(GIFImage)
+    unsigned int w;                 // width
+    unsigned int h;                 // height
+    unsigned int left;              // x coord (in logical screen)
+    unsigned int top;               // y coord (in logical screen)
+    int transparent;                // transparent color index (-1 = none)
+    wxAnimationDisposal disposal;   // disposal method
+    long delay;                     // delay in ms (-1 = unused)
+    unsigned char *p;               // bitmap
+    unsigned char *pal;             // palette
+    unsigned int ncolours;          // number of colours
+    wxString comment;
+
+    wxDECLARE_NO_COPY_CLASS(GIFImage);

 };
 
 };
 

+wxDECLARE_SCOPED_PTR(GIFImage, GIFImagePtr)
+wxDEFINE_SCOPED_PTR(GIFImage, GIFImagePtr)

 
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------


@@ -87,7 +105,7 @@ wxGIFDecoder::~wxGIFDecoder()
 void wxGIFDecoder::Destroy()
 {
     wxASSERT(m_nFrames==m_frames.GetCount());
 void wxGIFDecoder::Destroy()
 {
     wxASSERT(m_nFrames==m_frames.GetCount());

-    for (size_t i=0; i<m_nFrames; i++)
+    for (unsigned int i=0; i<m_nFrames; i++)

     {
         GIFImage *f = (GIFImage*)m_frames[i];
         free(f->p);
     {
         GIFImage *f = (GIFImage*)m_frames[i];
         free(f->p);


@@ -106,20 +124,21 @@ void wxGIFDecoder::Destroy()
 
 // This function was designed by Vaclav Slavik
 
 
 // This function was designed by Vaclav Slavik
 

-bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
+bool wxGIFDecoder::ConvertToImage(unsigned int frame, wxImage *image) const

 {
     unsigned char *src, *dst, *pal;
     unsigned long i;
     int      transparent;
 
 {
     unsigned char *src, *dst, *pal;
     unsigned long i;
     int      transparent;
 

-    /* just in case... */
+    // just in case...

     image->Destroy();
 
     image->Destroy();
 

-    /* create the image */
+    // create the image

     wxSize sz = GetFrameSize(frame);
     image->Create(sz.GetWidth(), sz.GetHeight());
     wxSize sz = GetFrameSize(frame);
     image->Create(sz.GetWidth(), sz.GetHeight());

+    image->SetType(wxBITMAP_TYPE_GIF);

 
 

-    if (!image->Ok())
+    if (!image->IsOk())

         return false;
 
     pal = GetPalette(frame);
         return false;
 
     pal = GetPalette(frame);


@@ -127,7 +146,7 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
     dst = image->GetData();
     transparent = GetTransparentColourIndex(frame);
 
     dst = image->GetData();
     transparent = GetTransparentColourIndex(frame);
 

-    /* set transparent colour mask */
+    // set transparent colour mask

     if (transparent != -1)
     {
         for (i = 0; i < GetNcolours(frame); i++)
     if (transparent != -1)
     {
         for (i = 0; i < GetNcolours(frame); i++)


@@ -164,7 +183,7 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
     image->SetPalette(wxPalette(GetNcolours(frame), r, g, b));
 #endif // wxUSE_PALETTE
 
     image->SetPalette(wxPalette(GetNcolours(frame), r, g, b));
 #endif // wxUSE_PALETTE
 

-    /* copy image data */
+    // copy image data

     unsigned long npixel = sz.GetWidth() * sz.GetHeight();
     for (i = 0; i < npixel; i++, src++)
     {
     unsigned long npixel = sz.GetWidth() * sz.GetHeight();
     for (i = 0; i < npixel; i++, src++)
     {


@@ -173,6 +192,12 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
         *(dst++) = pal[3 * (*src) + 2];
     }
 
         *(dst++) = pal[3 * (*src) + 2];
     }
 

+    wxString comment = GetFrame(frame)->comment;
+    if ( !comment.empty() )
+    {
+        image->SetOption(wxIMAGE_OPTION_GIF_COMMENT, comment);
+    }
+

     return true;
 }
 
     return true;
 }
 


@@ -181,32 +206,29 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
 // Data accessors
 //---------------------------------------------------------------------------
 
 // Data accessors
 //---------------------------------------------------------------------------
 

-#define GetFrame(n)     ((GIFImage*)m_frames[n])
-
-

 // Get data for current frame
 
 // Get data for current frame
 

-wxSize wxGIFDecoder::GetFrameSize(size_t frame) const 
+wxSize wxGIFDecoder::GetFrameSize(unsigned int frame) const

 {
     return wxSize(GetFrame(frame)->w, GetFrame(frame)->h);
 }
 
 {
     return wxSize(GetFrame(frame)->w, GetFrame(frame)->h);
 }
 

-wxPoint wxGIFDecoder::GetFramePosition(size_t frame) const
+wxPoint wxGIFDecoder::GetFramePosition(unsigned int frame) const

 {
     return wxPoint(GetFrame(frame)->left, GetFrame(frame)->top);
 }
 
 {
     return wxPoint(GetFrame(frame)->left, GetFrame(frame)->top);
 }
 

-wxAnimationDisposal wxGIFDecoder::GetDisposalMethod(size_t frame) const
+wxAnimationDisposal wxGIFDecoder::GetDisposalMethod(unsigned int frame) const

 {
     return GetFrame(frame)->disposal;
 }
 
 {
     return GetFrame(frame)->disposal;
 }
 

-long wxGIFDecoder::GetDelay(size_t frame) const
+long wxGIFDecoder::GetDelay(unsigned int frame) const

 {
     return GetFrame(frame)->delay;
 }
 
 {
     return GetFrame(frame)->delay;
 }
 

-wxColour wxGIFDecoder::GetTransparentColour(size_t frame) const
+wxColour wxGIFDecoder::GetTransparentColour(unsigned int frame) const

 {
     unsigned char *pal = GetFrame(frame)->pal;
     int n = GetFrame(frame)->transparent;
 {
     unsigned char *pal = GetFrame(frame)->pal;
     int n = GetFrame(frame)->transparent;


@@ -218,10 +240,10 @@ wxColour wxGIFDecoder::GetTransparentColour(size_t frame) const
                     pal[n*3 + 2]);
 }
 
                     pal[n*3 + 2]);
 }
 

-unsigned char* wxGIFDecoder::GetData(size_t frame) const    { return (GetFrame(frame)->p); }
-unsigned char* wxGIFDecoder::GetPalette(size_t frame) const { return (GetFrame(frame)->pal); }
-unsigned int wxGIFDecoder::GetNcolours(size_t frame) const  { return (GetFrame(frame)->ncolours); }
-int wxGIFDecoder::GetTransparentColourIndex(size_t frame) const  { return (GetFrame(frame)->transparent); }
+unsigned char* wxGIFDecoder::GetData(unsigned int frame) const    { return (GetFrame(frame)->p); }
+unsigned char* wxGIFDecoder::GetPalette(unsigned int frame) const { return (GetFrame(frame)->pal); }
+unsigned int wxGIFDecoder::GetNcolours(unsigned int frame) const  { return (GetFrame(frame)->ncolours); }
+int wxGIFDecoder::GetTransparentColourIndex(unsigned int frame) const  { return (GetFrame(frame)->transparent); }

 
 
 
 
 
 


@@ -234,20 +256,20 @@ int wxGIFDecoder::GetTransparentColourIndex(size_t frame) const  { return (GetFr
 //
 int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
 {
 //
 int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
 {

-    unsigned int mask;          /* bit mask */
-    unsigned int code;          /* code (result) */
+    unsigned int mask;          // bit mask
+    unsigned int code;          // code (result)

 
 

-    /* get remaining bits from last byte read */
+    // get remaining bits from last byte read

     mask = (1 << bits) - 1;
     code = (m_lastbyte >> (8 - m_restbits)) & mask;
 
     mask = (1 << bits) - 1;
     code = (m_lastbyte >> (8 - m_restbits)) & mask;
 

-    /* keep reading new bytes while needed */
+    // keep reading new bytes while needed

     while (bits > m_restbits)
     {
     while (bits > m_restbits)
     {

-        /* if no bytes left in this block, read the next block */
+        // if no bytes left in this block, read the next block

         if (m_restbyte == 0)
         {
         if (m_restbyte == 0)
         {

-            m_restbyte = (unsigned char)stream.GetC();
+            m_restbyte = stream.GetC();

 
             /* Some encoders are a bit broken: instead of issuing
              * an end-of-image symbol (ab_fin) they come up with
 
             /* Some encoders are a bit broken: instead of issuing
              * an end-of-image symbol (ab_fin) they come up with


@@ -260,7 +282,7 @@ int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
                 break;
             }
 
                 break;
             }
 

-            /* prefetch data */
+            // prefetch data

             stream.Read((void *) m_buffer, m_restbyte);
             if (stream.LastRead() != m_restbyte)
             {
             stream.Read((void *) m_buffer, m_restbyte);
             if (stream.LastRead() != m_restbyte)
             {


@@ -270,17 +292,17 @@ int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
             m_bufp = m_buffer;
         }
 
             m_bufp = m_buffer;
         }
 

-        /* read next byte and isolate the bits we need */
+        // read next byte and isolate the bits we need

         m_lastbyte = (unsigned char) (*m_bufp++);
         mask       = (1 << (bits - m_restbits)) - 1;
         code       = code + ((m_lastbyte & mask) << m_restbits);
         m_restbyte--;
 
         m_lastbyte = (unsigned char) (*m_bufp++);
         mask       = (1 << (bits - m_restbits)) - 1;
         code       = code + ((m_lastbyte & mask) << m_restbits);
         m_restbyte--;
 

-        /* adjust total number of bits extracted from the buffer */
+        // adjust total number of bits extracted from the buffer

         m_restbits = m_restbits + 8;
     }
 
         m_restbits = m_restbits + 8;
     }
 

-    /* find number of bits remaining for next code */
+    // find number of bits remaining for next code

     m_restbits = (m_restbits - bits);
 
     return code;
     m_restbits = (m_restbits - bits);
 
     return code;


@@ -292,23 +314,24 @@ int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
 //  is 'bits'. Supports interlaced images (interl == 1).
 //  Returns wxGIF_OK (== 0) on success, or an error code if something
 // fails (see header file for details)
 //  is 'bits'. Supports interlaced images (interl == 1).
 //  Returns wxGIF_OK (== 0) on success, or an error code if something
 // fails (see header file for details)

-wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int interl, int bits)
+wxGIFErrorCode
+wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int interl, int bits)

 {
     static const int allocSize = 4096 + 1;
 {
     static const int allocSize = 4096 + 1;

-    int *ab_prefix = new int[allocSize]; /* alphabet (prefixes) */
+    int *ab_prefix = new int[allocSize]; // alphabet (prefixes)

     if (ab_prefix == NULL)
     {
         return wxGIF_MEMERR;
     }
 
     if (ab_prefix == NULL)
     {
         return wxGIF_MEMERR;
     }
 

-    int *ab_tail = new int[allocSize];   /* alphabet (tails) */
+    int *ab_tail = new int[allocSize];   // alphabet (tails)

     if (ab_tail == NULL)
     {
         delete[] ab_prefix;
         return wxGIF_MEMERR;
     }
 
     if (ab_tail == NULL)
     {
         delete[] ab_prefix;
         return wxGIF_MEMERR;
     }
 

-    int *stack = new int[allocSize];     /* decompression stack */
+    int *stack = new int[allocSize];     // decompression stack

     if (stack == NULL)
     {
         delete[] ab_prefix;
     if (stack == NULL)
     {
         delete[] ab_prefix;


@@ -316,22 +339,22 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
         return wxGIF_MEMERR;
     }
 
         return wxGIF_MEMERR;
     }
 

-    int ab_clr;                     /* clear code */
-    int ab_fin;                     /* end of info code */
-    int ab_bits;                    /* actual symbol width, in bits */
-    int ab_free;                    /* first free position in alphabet */
-    int ab_max;                     /* last possible character in alphabet */
-    int pass;                       /* pass number in interlaced images */
-    int pos;                        /* index into decompresion stack */
-    unsigned int x, y;              /* position in image buffer */
+    int ab_clr;                     // clear code
+    int ab_fin;                     // end of info code
+    int ab_bits;                    // actual symbol width, in bits
+    int ab_free;                    // first free position in alphabet
+    int ab_max;                     // last possible character in alphabet
+    int pass;                       // pass number in interlaced images
+    int pos;                        // index into decompresion stack
+    unsigned int x, y;              // position in image buffer

 
     int code, readcode, lastcode, abcabca;
 
 
     int code, readcode, lastcode, abcabca;
 

-    /* these won't change */
+    // these won't change

     ab_clr = (1 << bits);
     ab_fin = (1 << bits) + 1;
 
     ab_clr = (1 << bits);
     ab_fin = (1 << bits) + 1;
 

-    /* these will change through the decompression proccess */
+    // these will change through the decompression process

     ab_bits  = bits + 1;
     ab_free  = (1 << bits) + 2;
     ab_max   = (1 << ab_bits) - 1;
     ab_bits  = bits + 1;
     ab_free  = (1 << bits) + 2;
     ab_max   = (1 << ab_bits) - 1;


@@ -340,41 +363,41 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
     pass     = 1;
     pos = x = y = 0;
 
     pass     = 1;
     pos = x = y = 0;
 

-    /* reset decoder vars */
+    // reset decoder vars

     m_restbits = 0;
     m_restbyte = 0;
     m_lastbyte = 0;
 
     do
     {
     m_restbits = 0;
     m_restbyte = 0;
     m_lastbyte = 0;
 
     do
     {

-        /* get next code */
+        // get next code

         readcode = code = getcode(stream, ab_bits, ab_fin);
 
         readcode = code = getcode(stream, ab_bits, ab_fin);
 

-        /* end of image? */
+        // end of image?

         if (code == ab_fin) break;
 
         if (code == ab_fin) break;
 

-        /* reset alphabet? */
+        // reset alphabet?

         if (code == ab_clr)
         {
         if (code == ab_clr)
         {

-            /* reset main variables */
+            // reset main variables

             ab_bits  = bits + 1;
             ab_free  = (1 << bits) + 2;
             ab_max   = (1 << ab_bits) - 1;
             lastcode = -1;
             abcabca  = -1;
 
             ab_bits  = bits + 1;
             ab_free  = (1 << bits) + 2;
             ab_max   = (1 << ab_bits) - 1;
             lastcode = -1;
             abcabca  = -1;
 

-            /* skip to next code */
+            // skip to next code

             continue;
         }
 
             continue;
         }
 

-        /* unknown code: special case (like in ABCABCA) */
+        // unknown code: special case (like in ABCABCA)

         if (code >= ab_free)
         {
         if (code >= ab_free)
         {

-            code = lastcode;            /* take last string */
-            stack[pos++] = abcabca;     /* add first character */
+            code = lastcode;            // take last string
+            stack[pos++] = abcabca;     // add first character

         }
 
         }
 

-        /* build the string for this code in the stack */
+        // build the string for this code in the stack

         while (code > ab_clr)
         {
             stack[pos++] = ab_tail[code];
         while (code > ab_clr)
         {
             stack[pos++] = ab_tail[code];


@@ -400,10 +423,10 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
             return wxGIF_INVFORMAT;
         }
 
             return wxGIF_INVFORMAT;
         }
 

-        stack[pos] = code;              /* push last code into the stack */
-        abcabca    = code;              /* save for special case */
+        stack[pos] = code;              // push last code into the stack
+        abcabca    = code;              // save for special case

 
 

-        /* make new entry in alphabet (only if NOT just cleared) */
+        // make new entry in alphabet (only if NOT just cleared)

         if (lastcode != -1)
         {
             // Normally, after the alphabet is full and can't grow any
         if (lastcode != -1)
         {
             // Normally, after the alphabet is full and can't grow any


@@ -436,7 +459,7 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
             }
         }
 
             }
         }
 

-        /* dump stack data to the image buffer */
+        // dump stack data to the image buffer

         while (pos >= 0)
         {
             (img->p)[x + (y * (img->w))] = (char) stack[pos];
         while (pos >= 0)
         {
             (img->p)[x + (y * (img->w))] = (char) stack[pos];


@@ -448,7 +471,7 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
 
                 if (interl)
                 {
 
                 if (interl)
                 {

-                    /* support for interlaced images */
+                    // support for interlaced images

                     switch (pass)
                     {
                         case 1: y += 8; break;
                     switch (pass)
                     {
                         case 1: y += 8; break;


@@ -505,7 +528,7 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
                 }
                 else
                 {
                 }
                 else
                 {

-                    /* non-interlaced */
+                    // non-interlaced

                     y++;
 /*
 Normally image decoding is finished when an End of Information code is
                     y++;
 /*
 Normally image decoding is finished when an End of Information code is


@@ -567,15 +590,13 @@ as an End of Information itself)
 // CanRead:
 //  Returns true if the file looks like a valid GIF, false otherwise.
 //
 // CanRead:
 //  Returns true if the file looks like a valid GIF, false otherwise.
 //

-bool wxGIFDecoder::CanRead(wxInputStream &stream) const
+bool wxGIFDecoder::DoCanRead(wxInputStream &stream) const

 {
     unsigned char buf[3];
 
     if ( !stream.Read(buf, WXSIZEOF(buf)) )
         return false;
 
 {
     unsigned char buf[3];
 
     if ( !stream.Read(buf, WXSIZEOF(buf)) )
         return false;
 

-    stream.SeekI(-(wxFileOffset)WXSIZEOF(buf), wxFromCurrent);
-

     return memcmp(buf, "GIF", WXSIZEOF(buf)) == 0;
 }
 
     return memcmp(buf, "GIF", WXSIZEOF(buf)) == 0;
 }
 


@@ -592,7 +613,7 @@ bool wxGIFDecoder::CanRead(wxInputStream &stream) const
 wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
 {
     unsigned int  global_ncolors = 0;
 wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
 {
     unsigned int  global_ncolors = 0;

-    int           bits, interl, transparent, i;
+    int           bits, interl, i;

     wxAnimationDisposal disposal;
     long          size;
     long          delay;
     wxAnimationDisposal disposal;
     long          size;
     long          delay;


@@ -601,13 +622,13 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
     unsigned char buf[16];
     bool anim = true;
 
     unsigned char buf[16];
     bool anim = true;
 

-    /* check GIF signature */
+    // check GIF signature

     if (!CanRead(stream))
         return wxGIF_INVFORMAT;
 
     if (!CanRead(stream))
         return wxGIF_INVFORMAT;
 

-    /* check for animated GIF support (ver. >= 89a) */
+    // check for animated GIF support (ver. >= 89a)

 
 

-    static const size_t headerSize = (3 + 3);
+    static const unsigned int headerSize = (3 + 3);

     stream.Read(buf, headerSize);
     if (stream.LastRead() != headerSize)
     {
     stream.Read(buf, headerSize);
     if (stream.LastRead() != headerSize)
     {


@@ -619,8 +640,8 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
         anim = false;
     }
 
         anim = false;
     }
 

-    /* read logical screen descriptor block (LSDB) */
-    static const size_t lsdbSize = (2 + 2 + 1 + 1 + 1);
+    // read logical screen descriptor block (LSDB)
+    static const unsigned int lsdbSize = (2 + 2 + 1 + 1 + 1);

     stream.Read(buf, lsdbSize);
     if (stream.LastRead() != lsdbSize)
     {
     stream.Read(buf, lsdbSize);
     if (stream.LastRead() != lsdbSize)
     {


@@ -635,13 +656,13 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
         return wxGIF_INVFORMAT;
     }
 
         return wxGIF_INVFORMAT;
     }
 

-    /* load global color map if available */
+    // load global color map if available

     if ((buf[4] & 0x80) == 0x80)
     {
         int backgroundColIndex = buf[5];
 
         global_ncolors = 2 << (buf[4] & 0x07);
     if ((buf[4] & 0x80) == 0x80)
     {
         int backgroundColIndex = buf[5];
 
         global_ncolors = 2 << (buf[4] & 0x07);

-        size_t numBytes = 3 * global_ncolors;
+        unsigned int numBytes = 3 * global_ncolors;

         stream.Read(pal, numBytes);
         if (stream.LastRead() != numBytes)
         {
         stream.Read(pal, numBytes);
         if (stream.LastRead() != numBytes)
         {


@@ -653,19 +674,20 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
                          pal[backgroundColIndex*3 + 2]);
     }
 
                          pal[backgroundColIndex*3 + 2]);
     }
 

-    /* transparent colour, disposal method and delay default to unused */
-    transparent = -1;
+    // transparent colour, disposal method and delay default to unused
+    int transparent = -1;

     disposal = wxANIM_UNSPECIFIED;
     delay = -1;
     disposal = wxANIM_UNSPECIFIED;
     delay = -1;

+    wxString comment;

 
     bool done = false;
     while (!done)
     {
 
     bool done = false;
     while (!done)
     {

-        type = (unsigned char)stream.GetC();
+        type = stream.GetC();

 
         /*
         If the end of file has been reached (or an error) and a ";"
 
         /*
         If the end of file has been reached (or an error) and a ";"

-        (0x3B) hasn't been encountered yet, exit the loop. (Without this
+        (GIF_MARKER_ENDOFDATA) hasn't been encountered yet, exit the loop. (Without this

         check the while loop would loop endlessly.) Later on, in the next while
         loop, the file will be treated as being truncated (But still
         be decoded as far as possible). returning wxGIF_TRUNCATED is not
         check the while loop would loop endlessly.) Later on, in the next while
         loop, the file will be treated as being truncated (But still
         be decoded as far as possible). returning wxGIF_TRUNCATED is not


@@ -680,147 +702,179 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
             break; // Alternative : "return wxGIF_INVFORMAT;"
         }
 
             break; // Alternative : "return wxGIF_INVFORMAT;"
         }
 

-        /* end of data? */
-        if (type == 0x3B)
+        switch (type)

         {
         {

-            done = true;
-        }
-        else
-        /* extension block? */
-        if (type == 0x21)
-        {
-            if (((unsigned char)stream.GetC()) == 0xF9)
-            /* graphics control extension, parse it */
-            {
-                static const size_t gceSize = 6;
-                stream.Read(buf, gceSize);
-                if (stream.LastRead() != gceSize)
+            case GIF_MARKER_ENDOFDATA:
+                done = true;
+                break;
+            case GIF_MARKER_EXT:
+                switch (stream.GetC())

                 {
                 {

-                    Destroy();
-                    return wxGIF_INVFORMAT;
-                }
+                    case GIF_MARKER_EXT_GRAPHICS_CONTROL:
+                    {
+                        // graphics control extension, parse it

 
 

-                /* read delay and convert from 1/100 of a second to ms */
-                delay = 10 * (buf[2] + 256 * buf[3]);
+                        static const unsigned int gceSize = 6;
+                        stream.Read(buf, gceSize);
+                        if (stream.LastRead() != gceSize)
+                        {
+                            Destroy();
+                            return wxGIF_INVFORMAT;
+                        }

 
 

-                /* read transparent colour index, if used */
-                if (buf[1] & 0x01)
-                    transparent = buf[4];
+                        // read delay and convert from 1/100 of a second to ms
+                        delay = 10 * (buf[2] + 256 * buf[3]);

 
 

-                /* read disposal method */
-                disposal = (wxAnimationDisposal)(((buf[1] & 0x1C) >> 2) - 1);
-            }
-            else
-            /* other extension, skip */
-            {
-                while ((i = (unsigned char)stream.GetC()) != 0)
-                {
-                    if (stream.Eof() || (stream.LastRead() == 0))
+                        // read transparent colour index, if used
+                        transparent = buf[1] & 0x01 ? buf[4] : -1;
+
+                        // read disposal method
+                        disposal = (wxAnimationDisposal)(((buf[1] & 0x1C) >> 2) - 1);
+                        break;
+                    }
+                    case GIF_MARKER_EXT_COMMENT:

                     {
                     {

-                        done = true;
+                        int len = stream.GetC();
+                        while (len)
+                        {
+                            if ( stream.Eof() )
+                            {
+                                done = true;
+                                break;
+                            }
+
+                            wxCharBuffer charbuf(len);
+                            stream.Read(charbuf.data(), len);
+                            if ( (int) stream.LastRead() != len )
+                            {
+                                done = true;
+                                break;
+                            }
+
+                            comment += wxConvertMB2WX(charbuf.data());
+
+                            len = stream.GetC();
+                        }
+

                         break;
                     }
                         break;
                     }

-                    stream.SeekI(i, wxFromCurrent);
+                    default:
+                        // other extension, skip
+                        while ((i = stream.GetC()) != 0)
+                        {
+                            if (stream.Eof() || (stream.LastRead() == 0) ||
+                                stream.SeekI(i, wxFromCurrent) == wxInvalidOffset)
+                            {
+                                done = true;
+                                break;
+                            }
+                        }
+                        break;

                 }
                 }

-            }
-        }
-        else
-        /* image descriptor block? */
-        if (type == 0x2C)
-        {
-            /* allocate memory for IMAGEN struct */
-            GIFImage *pimg = new GIFImage();
-
-            if (pimg == NULL)
+                break;
+            case GIF_MARKER_SEP:

             {
             {

-                Destroy();
-                return wxGIF_MEMERR;
-            }
+                // allocate memory for IMAGEN struct
+                GIFImagePtr pimg(new GIFImage());

 
 

-            /* fill in the data */
-            static const size_t idbSize = (2 + 2 + 2 + 2 + 1);
-            stream.Read(buf, idbSize);
-            if (stream.LastRead() != idbSize)
-            {
-                Destroy();
-                return wxGIF_INVFORMAT;
-            }
+                wxScopeGuard guardDestroy = wxMakeObjGuard(*this, &wxGIFDecoder::Destroy);

 
 

-            pimg->left = buf[0] + 256 * buf[1];
-            pimg->top = buf[2] + 256 * buf[3];
-/*
-            pimg->left = buf[4] + 256 * buf[5];
-            pimg->top = buf[4] + 256 * buf[5];
-*/
-            pimg->w = buf[4] + 256 * buf[5];
-            pimg->h = buf[6] + 256 * buf[7];
+                if ( !pimg.get() )
+                    return wxGIF_MEMERR;

 
 

-            if (anim && ((pimg->w == 0) || (pimg->w > (unsigned int)m_szAnimation.GetWidth()) || 
-                        (pimg->h == 0) || (pimg->h > (unsigned int)m_szAnimation.GetHeight())))
-            {
-                Destroy();
-                return wxGIF_INVFORMAT;
-            }
+                // fill in the data
+                static const unsigned int idbSize = (2 + 2 + 2 + 2 + 1);
+                stream.Read(buf, idbSize);
+                if (stream.LastRead() != idbSize)
+                    return wxGIF_INVFORMAT;
+
+                pimg->comment = comment;
+                comment.clear();
+                pimg->left = buf[0] + 256 * buf[1];
+                pimg->top = buf[2] + 256 * buf[3];
+    /*
+                pimg->left = buf[4] + 256 * buf[5];
+                pimg->top = buf[4] + 256 * buf[5];
+    */
+                pimg->w = buf[4] + 256 * buf[5];
+                pimg->h = buf[6] + 256 * buf[7];
+
+                if ( anim )
+                {
+                    // some GIF images specify incorrect animation size but we can
+                    // still open them if we fix up the animation size, see #9465
+                    if ( m_nFrames == 0 )
+                    {
+                        if ( pimg->w > (unsigned)m_szAnimation.x )
+                            m_szAnimation.x = pimg->w;
+                        if ( pimg->h > (unsigned)m_szAnimation.y )
+                            m_szAnimation.y = pimg->h;
+                    }
+                    else // subsequent frames
+                    {
+                        // check that we have valid size
+                        if ( (!pimg->w || pimg->w > (unsigned)m_szAnimation.x) ||
+                                (!pimg->h || pimg->h > (unsigned)m_szAnimation.y) )
+                        {
+                            wxLogError(_("Incorrect GIF frame size (%u, %d) for "
+                                         "the frame #%u"),
+                                       pimg->w, pimg->h, m_nFrames);
+                            return wxGIF_INVFORMAT;
+                        }
+                    }
+                }

 
 

-            interl = ((buf[8] & 0x40)? 1 : 0);
-            size = pimg->w * pimg->h;
+                interl = ((buf[8] & 0x40)? 1 : 0);
+                size = pimg->w * pimg->h;

 
 

-            pimg->transparent = transparent;
-            pimg->disposal = disposal;
-            pimg->delay = delay;
+                pimg->transparent = transparent;
+                pimg->disposal = disposal;
+                pimg->delay = delay;

 
 

-            /* allocate memory for image and palette */
-            pimg->p   = (unsigned char *) malloc((size_t)size);
-            pimg->pal = (unsigned char *) malloc(768);
+                // allocate memory for image and palette
+                pimg->p   = (unsigned char *) malloc((unsigned int)size);
+                pimg->pal = (unsigned char *) malloc(768);

 
 

-            if ((!pimg->p) || (!pimg->pal))
-            {
-                Destroy();
-                return wxGIF_MEMERR;
-            }
+                if ((!pimg->p) || (!pimg->pal))
+                    return wxGIF_MEMERR;

 
 

-            /* load local color map if available, else use global map */
-            if ((buf[8] & 0x80) == 0x80)
-            {
-                unsigned int local_ncolors = 2 << (buf[8] & 0x07);
-                size_t numBytes = 3 * local_ncolors;
-                stream.Read(pimg->pal, numBytes);
-                pimg->ncolours = local_ncolors;
-                if (stream.LastRead() != numBytes)
+                // load local color map if available, else use global map
+                if ((buf[8] & 0x80) == 0x80)

                 {
                 {

-                    Destroy();
-                    return wxGIF_INVFORMAT;
+                    unsigned int local_ncolors = 2 << (buf[8] & 0x07);
+                    unsigned int numBytes = 3 * local_ncolors;
+                    stream.Read(pimg->pal, numBytes);
+                    pimg->ncolours = local_ncolors;
+                    if (stream.LastRead() != numBytes)
+                        return wxGIF_INVFORMAT;
+                }
+                else
+                {
+                    memcpy(pimg->pal, pal, 768);
+                    pimg->ncolours = global_ncolors;

                 }
                 }

-            }
-            else
-            {
-                memcpy(pimg->pal, pal, 768);
-                pimg->ncolours = global_ncolors;
-            }

 
 

-            /* get initial code size from first byte in raster data */
-            bits = (unsigned char)stream.GetC();
-            if (bits == 0)
-            {
-                Destroy();
-                return wxGIF_INVFORMAT;
-            }
+                // get initial code size from first byte in raster data
+                bits = stream.GetC();
+                if (bits == 0)
+                    return wxGIF_INVFORMAT;

 
 

-            /* decode image */
-            wxGIFErrorCode result = dgif(stream, pimg, interl, bits);
-            if (result != wxGIF_OK)
-            {
-                Destroy();
-                return result;
-            }
+                // decode image
+                wxGIFErrorCode result = dgif(stream, pimg.get(), interl, bits);
+                if (result != wxGIF_OK)
+                    return result;

 
 

-            /* add the image to our frame array */
-            m_frames.Add((void*)pimg);
-            m_nFrames++;
+                guardDestroy.Dismiss();

 
 

-            /* if this is not an animated GIF, exit after first image */
-            if (!anim)
-                done = true;
+                // add the image to our frame array
+                m_frames.Add(pimg.release());
+                m_nFrames++;
+
+                // if this is not an animated GIF, exit after first image
+                if (!anim)
+                    done = true;
+                break;
+            }

         }
     }
 
         }
     }
 


@@ -830,72 +884,81 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
         return wxGIF_INVFORMAT;
     }
 
         return wxGIF_INVFORMAT;
     }
 

-    /* try to read to the end of the stream */
-    while (type != 0x3B)
+    // try to read to the end of the stream
+    while (type != GIF_MARKER_ENDOFDATA)

     {
         if (!stream.IsOk())
             return wxGIF_TRUNCATED;
 
     {
         if (!stream.IsOk())
             return wxGIF_TRUNCATED;
 

-        type = (unsigned char)stream.GetC();
+        type = stream.GetC();

 
 

-        if (type == 0x21)
+        switch (type)

         {
         {

-            /* extension type */
-            (void) stream.GetC();
+            case GIF_MARKER_EXT:
+                // extension type
+                (void) stream.GetC();

 
 

-            /* skip all data */
-            while ((i = (unsigned char)stream.GetC()) != 0)
+                // skip all data
+                while ((i = stream.GetC()) != 0)
+                {
+                    if (stream.Eof() || (stream.LastRead() == 0) ||
+                        stream.SeekI(i, wxFromCurrent) == wxInvalidOffset)
+                    {
+                        Destroy();
+                        return wxGIF_INVFORMAT;
+                    }
+                }
+                break;
+            case GIF_MARKER_SEP:

             {
             {

-                if (stream.Eof() || (stream.LastRead() == 0))
+                // image descriptor block
+                static const unsigned int idbSize = (2 + 2 + 2 + 2 + 1);
+                stream.Read(buf, idbSize);
+                if (stream.LastRead() != idbSize)

                 {
                     Destroy();
                     return wxGIF_INVFORMAT;
                 }
                 {
                     Destroy();
                     return wxGIF_INVFORMAT;
                 }

-                stream.SeekI(i, wxFromCurrent);
-            }
-        }
-        else if (type == 0x2C)
-        {
-            /* image descriptor block */
-            static const size_t idbSize = (2 + 2 + 2 + 2 + 1);
-            stream.Read(buf, idbSize);
-            if (stream.LastRead() != idbSize)
-            {
-                Destroy();
-                return wxGIF_INVFORMAT;
-            }

 
 

-            /* local color map */
-            if ((buf[8] & 0x80) == 0x80)
-            {
-                unsigned int local_ncolors = 2 << (buf[8] & 0x07);
-                wxFileOffset numBytes = 3 * local_ncolors;
-                stream.SeekI(numBytes, wxFromCurrent);
-            }
-
-            /* initial code size */
-            (void) stream.GetC();
-            if (stream.Eof() || (stream.LastRead() == 0))
-            {
-                Destroy();
-                return wxGIF_INVFORMAT;
-            }
+                // local color map
+                if ((buf[8] & 0x80) == 0x80)
+                {
+                    unsigned int local_ncolors = 2 << (buf[8] & 0x07);
+                    wxFileOffset numBytes = 3 * local_ncolors;
+                    if (stream.SeekI(numBytes, wxFromCurrent) == wxInvalidOffset)
+                    {
+                        Destroy();
+                        return wxGIF_INVFORMAT;
+                    }
+                }

 
 

-            /* skip all data */
-            while ((i = (unsigned char)stream.GetC()) != 0)
-            {
+                // initial code size
+                (void) stream.GetC();

                 if (stream.Eof() || (stream.LastRead() == 0))
                 {
                     Destroy();
                     return wxGIF_INVFORMAT;
                 }
                 if (stream.Eof() || (stream.LastRead() == 0))
                 {
                     Destroy();
                     return wxGIF_INVFORMAT;
                 }

-                stream.SeekI(i, wxFromCurrent);
+
+                // skip all data
+                while ((i = stream.GetC()) != 0)
+                {
+                    if (stream.Eof() || (stream.LastRead() == 0) ||
+                        stream.SeekI(i, wxFromCurrent) == wxInvalidOffset)
+                    {
+                        Destroy();
+                        return wxGIF_INVFORMAT;
+                    }
+                }
+                break;

             }
             }

-        }
-        else if ((type != 0x3B) && (type != 00)) /* testing */
-        {
-            /* images are OK, but couldn't read to the end of the stream */
-            return wxGIF_TRUNCATED;
+            default:
+                if ((type != GIF_MARKER_ENDOFDATA) && (type != 00)) // testing
+                {
+                    // images are OK, but couldn't read to the end of the stream
+                    return wxGIF_TRUNCATED;
+                }
+                break;

         }
     }
 
         }
     }