home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / common / gifdecod.cpp < prev    next >
C/C++ Source or Header  |  2002-05-23  |  27KB  |  938 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        gifdecod.cpp
  3. // Purpose:     wxGIFDecoder, GIF reader for wxImage and wxAnimation
  4. // Author:      Guillermo Rodriguez Garcia <guille@iies.es>
  5. // Version:     3.04
  6. // RCS-ID:      $Id: gifdecod.cpp,v 1.27 2002/05/22 23:14:47 VZ Exp $
  7. // Copyright:   (c) Guillermo Rodriguez Garcia
  8. // Licence:     wxWindows licence
  9. /////////////////////////////////////////////////////////////////////////////
  10.  
  11. #ifdef __GNUG__
  12. #pragma implementation "gifdecod.h"
  13. #endif
  14.  
  15. // For compilers that support precompilation, includes "wx.h".
  16. #include "wx/wxprec.h"
  17.  
  18. #ifdef __BORLANDC__
  19. #  pragma hdrstop
  20. #endif
  21.  
  22. #ifndef WX_PRECOMP
  23. #  include "wx/defs.h"
  24. #endif
  25.  
  26. #if wxUSE_STREAMS && wxUSE_GIF
  27.  
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include "wx/gifdecod.h"
  31.  
  32.  
  33. //---------------------------------------------------------------------------
  34. // GIFImage constructor
  35. //---------------------------------------------------------------------------
  36. GIFImage::GIFImage()
  37. {
  38.     w = 0;
  39.     h = 0;
  40.     left = 0;
  41.     top = 0;
  42.     transparent = 0;
  43.     disposal = 0;
  44.     delay = -1;
  45.     p = (unsigned char *) NULL;
  46.     pal = (unsigned char *) NULL;
  47.     next = (GIFImage *) NULL;
  48.     prev = (GIFImage *) NULL;
  49. }
  50.  
  51. //---------------------------------------------------------------------------
  52. // wxGIFDecoder constructor and destructor
  53. //---------------------------------------------------------------------------
  54.  
  55. wxGIFDecoder::wxGIFDecoder(wxInputStream *s, bool anim)
  56. {
  57.     m_f    = s;
  58.     m_anim = anim;
  59.  
  60.     m_background = -1;
  61.     m_screenw = 0;
  62.     m_screenh = 0;
  63.  
  64.     m_pimage  = NULL;
  65.     m_pfirst  = NULL;
  66.     m_plast   = NULL;
  67.     m_image   = 0;
  68.     m_nimages = 0;
  69. }
  70.  
  71. wxGIFDecoder::~wxGIFDecoder()
  72. {
  73.     Destroy();
  74. }
  75.  
  76. void wxGIFDecoder::Destroy()
  77. {
  78.     GIFImage *pimg, *paux;
  79.  
  80.     pimg = m_pfirst;
  81.  
  82.     while (pimg != NULL)
  83.     {
  84.         paux = pimg->next;
  85.         free(pimg->p);
  86.         free(pimg->pal);
  87.         delete pimg;
  88.         pimg = paux;
  89.     }
  90.  
  91.     m_pimage  = NULL;
  92.     m_pfirst  = NULL;
  93.     m_plast   = NULL;
  94.     m_image   = 0;
  95.     m_nimages = 0;
  96. }
  97.  
  98.  
  99. //---------------------------------------------------------------------------
  100. // Convert this image to a wxImage object
  101. //---------------------------------------------------------------------------
  102.  
  103. // This function was designed by Vaclav Slavik
  104.  
  105. bool wxGIFDecoder::ConvertToImage(wxImage *image) const
  106. {
  107.     unsigned char *src, *dst, *pal;
  108.     unsigned long i;
  109.     int      transparent;
  110.  
  111.     /* just in case... */
  112.     image->Destroy();
  113.  
  114.     /* create the image */
  115.     image->Create(GetWidth(), GetHeight());
  116.  
  117.     if (!image->Ok())
  118.         return FALSE;
  119.  
  120.     pal = GetPalette();
  121.     src = GetData();
  122.     dst = image->GetData();
  123.     transparent = GetTransparentColour();
  124.  
  125.     /* set transparent colour mask */
  126.     if (transparent != -1)
  127.     {
  128.         for (i = 0; i < 256; i++)
  129.         {
  130.             if ((pal[3 * i + 0] == 255) &&
  131.                 (pal[3 * i + 1] == 0) &&
  132.                 (pal[3 * i + 2] == 255))
  133.             {
  134.                 pal[3 * i + 2] = 254;
  135.             }
  136.         }
  137.  
  138.         pal[3 * transparent + 0] = 255,
  139.         pal[3 * transparent + 1] = 0,
  140.         pal[3 * transparent + 2] = 255;
  141.  
  142.         image->SetMaskColour(255, 0, 255);
  143.     }
  144.     else
  145.         image->SetMask(FALSE);
  146.  
  147. #if wxUSE_PALETTE
  148.     if (pal)
  149.     {
  150.         unsigned char r[256];
  151.         unsigned char g[256];
  152.         unsigned char b[256];
  153.  
  154.         for (i = 0; i < 256; i++)
  155.         {
  156.             r[i] = pal[3*i + 0];
  157.             g[i] = pal[3*i + 1];
  158.             b[i] = pal[3*i + 2];
  159.         }
  160.  
  161.         image->SetPalette(wxPalette(256, r, g, b));
  162.     }
  163. #endif // wxUSE_PALETTE
  164.  
  165.     /* copy image data */
  166.     for (i = 0; i < (GetWidth() * GetHeight()); i++, src++)
  167.     {
  168.         *(dst++) = pal[3 * (*src) + 0];
  169.         *(dst++) = pal[3 * (*src) + 1];
  170.         *(dst++) = pal[3 * (*src) + 2];
  171.     }
  172.  
  173.     return TRUE;
  174. }
  175.  
  176.  
  177. //---------------------------------------------------------------------------
  178. // Data accessors
  179. //---------------------------------------------------------------------------
  180.  
  181. // Get data for current frame
  182.  
  183. int wxGIFDecoder::GetFrameIndex() const         { return m_image; }
  184. unsigned char* wxGIFDecoder::GetData() const    { return (m_pimage->p); }
  185. unsigned char* wxGIFDecoder::GetPalette() const { return (m_pimage->pal); }
  186. unsigned int wxGIFDecoder::GetWidth() const     { return (m_pimage->w); }
  187. unsigned int wxGIFDecoder::GetHeight() const    { return (m_pimage->h); }
  188. unsigned int wxGIFDecoder::GetTop() const       { return (m_pimage->top); }
  189. unsigned int wxGIFDecoder::GetLeft() const      { return (m_pimage->left); }
  190. int wxGIFDecoder::GetTransparentColour() const  { return (m_pimage->transparent); }
  191. int wxGIFDecoder::GetDisposalMethod() const     { return (m_pimage->disposal); }
  192. long wxGIFDecoder::GetDelay() const             { return (m_pimage->delay); }
  193.  
  194. // Get global data
  195.  
  196. unsigned int wxGIFDecoder::GetLogicalScreenWidth() const    { return m_screenw; }
  197. unsigned int wxGIFDecoder::GetLogicalScreenHeight() const   { return m_screenh; }
  198. int wxGIFDecoder::GetBackgroundColour() const   { return m_background; }
  199. int wxGIFDecoder::GetNumberOfFrames() const     { return m_nimages; }
  200. bool wxGIFDecoder::IsAnimation() const          { return (m_nimages > 1); }
  201.  
  202.  
  203. //---------------------------------------------------------------------------
  204. // Functions to move through the animation
  205. //---------------------------------------------------------------------------
  206.  
  207. bool wxGIFDecoder::GoFirstFrame()
  208. {
  209.     if (!IsAnimation())
  210.         return FALSE;
  211.  
  212.     m_image = 1;
  213.     m_pimage = m_pfirst;
  214.     return TRUE;
  215. }
  216.  
  217. bool wxGIFDecoder::GoLastFrame()
  218. {
  219.     if (!IsAnimation())
  220.         return FALSE;
  221.  
  222.     m_image = m_nimages;
  223.     m_pimage = m_plast;
  224.     return TRUE;
  225. }
  226.  
  227. bool wxGIFDecoder::GoNextFrame(bool cyclic)
  228. {
  229.     if (!IsAnimation())
  230.         return FALSE;
  231.  
  232.     if ((m_image < m_nimages) || (cyclic))
  233.     {
  234.         m_pimage = m_pimage->next;
  235.         m_image++;
  236.  
  237.         if (!m_pimage)
  238.         {
  239.             m_image = 1;
  240.             m_pimage = m_pfirst;
  241.         }
  242.  
  243.         return TRUE;
  244.     }
  245.     else
  246.         return FALSE;
  247. }
  248.  
  249. bool wxGIFDecoder::GoPrevFrame(bool cyclic)
  250. {
  251.     if (!IsAnimation())
  252.         return FALSE;
  253.  
  254.     if ((m_image > 1) || (cyclic))
  255.     {
  256.         m_pimage = m_pimage->prev;
  257.         m_image--;
  258.  
  259.         if (!m_pimage)
  260.         {
  261.             m_image = m_nimages;
  262.             m_pimage = m_plast;
  263.         }
  264.  
  265.         return TRUE;
  266.     }
  267.     else
  268.         return FALSE;
  269. }
  270.  
  271. bool wxGIFDecoder::GoFrame(int which)
  272. {
  273.     int i;
  274.  
  275.     if (!IsAnimation())
  276.         return FALSE;
  277.  
  278.     if ((which >= 1) && (which <= m_nimages))
  279.     {
  280.         m_pimage = m_pfirst;
  281.  
  282.         for (i = 1; i < which; i++)
  283.             m_pimage = m_pimage->next;
  284.  
  285.         return TRUE;
  286.     }
  287.     else
  288.         return FALSE;
  289. }
  290.  
  291.  
  292. //---------------------------------------------------------------------------
  293. // GIF reading and decoding
  294. //---------------------------------------------------------------------------
  295.  
  296. // getcode:
  297. //  Reads the next code from the file stream, with size 'bits'
  298. //
  299. int wxGIFDecoder::getcode(int bits, int ab_fin)
  300. {
  301.     unsigned int mask;          /* bit mask */
  302.     unsigned int code;          /* code (result) */
  303.  
  304.  
  305.     /* get remaining bits from last byte read */
  306.     mask = (1 << bits) - 1;
  307.     code = (m_lastbyte >> (8 - m_restbits)) & mask;
  308.  
  309.     /* keep reading new bytes while needed */
  310.     while (bits > m_restbits)
  311.     {
  312.         /* if no bytes left in this block, read the next block */
  313.         if (m_restbyte == 0)
  314.         {
  315.             m_restbyte = (unsigned char)m_f->GetC();
  316.  
  317.             /* Some encoders are a bit broken: instead of issuing
  318.              * an end-of-image symbol (ab_fin) they come up with
  319.              * a zero-length subblock!! We catch this here so
  320.              * that the decoder sees an ab_fin code.
  321.              */
  322.             if (m_restbyte == 0)
  323.             {
  324.                 code = ab_fin;
  325.                 break;
  326.             }
  327.  
  328.             /* prefetch data */
  329.             m_f->Read((void *) m_buffer, m_restbyte);
  330.             if (m_f->LastRead() != m_restbyte)
  331.             {
  332.                 code = ab_fin;
  333.                 return code;
  334.             }
  335.             m_bufp = m_buffer;
  336.         }
  337.  
  338.         /* read next byte and isolate the bits we need */
  339.         m_lastbyte = (unsigned char) (*m_bufp++);
  340.         mask       = (1 << (bits - m_restbits)) - 1;
  341.         code       = code + ((m_lastbyte & mask) << m_restbits);
  342.         m_restbyte--;
  343.  
  344.         /* adjust total number of bits extracted from the buffer */
  345.         m_restbits = m_restbits + 8;
  346.     }
  347.  
  348.     /* find number of bits remaining for next code */
  349.     m_restbits = (m_restbits - bits);
  350.  
  351.     return code;
  352. }
  353.  
  354.  
  355. // dgif:
  356. //  GIF decoding function. The initial code size (aka root size)
  357. //  is 'bits'. Supports interlaced images (interl == 1).
  358. //  Returns wxGIF_OK (== 0) on success, or an error code if something
  359. // fails (see header file for details)
  360. int wxGIFDecoder::dgif(GIFImage *img, int interl, int bits)
  361. {
  362.     static const int allocSize = 4096 + 1;
  363.     int *ab_prefix = new int[allocSize]; /* alphabet (prefixes) */
  364.     if (ab_prefix == NULL)
  365.     {
  366.         return wxGIF_MEMERR;
  367.     }
  368.  
  369.     int *ab_tail = new int[allocSize];   /* alphabet (tails) */
  370.     if (ab_tail == NULL)
  371.     {
  372.         delete[] ab_prefix;
  373.         return wxGIF_MEMERR;
  374.     }
  375.  
  376.     int *stack = new int[allocSize];     /* decompression stack */
  377.     if (stack == NULL)
  378.     {
  379.         delete[] ab_prefix;
  380.         delete[] ab_tail;
  381.         return wxGIF_MEMERR;
  382.     }
  383.  
  384.     int ab_clr;                     /* clear code */
  385.     int ab_fin;                     /* end of info code */
  386.     int ab_bits;                    /* actual symbol width, in bits */
  387.     int ab_free;                    /* first free position in alphabet */
  388.     int ab_max;                     /* last possible character in alphabet */
  389.     int pass;                       /* pass number in interlaced images */
  390.     int pos;                        /* index into decompresion stack */
  391.     unsigned int x, y;              /* position in image buffer */
  392.  
  393.     int code, readcode, lastcode, abcabca;
  394.  
  395.     /* these won't change */
  396.     ab_clr = (1 << bits);
  397.     ab_fin = (1 << bits) + 1;
  398.  
  399.     /* these will change through the decompression proccess */
  400.     ab_bits  = bits + 1;
  401.     ab_free  = (1 << bits) + 2;
  402.     ab_max   = (1 << ab_bits) - 1;
  403.     lastcode = -1;
  404.     abcabca  = -1;
  405.     pass     = 1;
  406.     pos = x = y = 0;
  407.  
  408.     /* reset decoder vars */
  409.     m_restbits = 0;
  410.     m_restbyte = 0;
  411.     m_lastbyte = 0;
  412.  
  413.     do
  414.     {
  415.         /* get next code */
  416.         readcode = code = getcode(ab_bits, ab_fin);
  417.  
  418.         /* end of image? */
  419.         if (code == ab_fin) break;
  420.  
  421.         /* reset alphabet? */
  422.         if (code == ab_clr)
  423.         {
  424.             /* reset main variables */
  425.             ab_bits  = bits + 1;
  426.             ab_free  = (1 << bits) + 2;
  427.             ab_max   = (1 << ab_bits) - 1;
  428.             lastcode = -1;
  429.             abcabca  = -1;
  430.  
  431.             /* skip to next code */
  432.             continue;
  433.         }
  434.  
  435.         /* unknown code: special case (like in ABCABCA) */
  436.         if (code >= ab_free)
  437.         {
  438.             code = lastcode;            /* take last string */
  439.             stack[pos++] = abcabca;     /* add first character */
  440.         }
  441.  
  442.         /* build the string for this code in the stack */
  443.         while (code > ab_clr)
  444.         {
  445.             stack[pos++] = ab_tail[code];
  446.             code         = ab_prefix[code];
  447.  
  448.             // Don't overflow. This shouldn't happen with normal
  449.             // GIF files, the allocSize of 4096+1 is enough. This
  450.             // will only happen with badly formed GIFs.
  451.             if (pos >= allocSize)
  452.             {
  453.                 delete[] ab_prefix;
  454.                 delete[] ab_tail;
  455.                 delete[] stack;
  456.                 return wxGIF_INVFORMAT;
  457.             }
  458.         }
  459.  
  460.         if (pos >= allocSize)
  461.         {
  462.             delete[] ab_prefix;
  463.             delete[] ab_tail;
  464.             delete[] stack;
  465.             return wxGIF_INVFORMAT;
  466.         }
  467.  
  468.         stack[pos] = code;              /* push last code into the stack */
  469.         abcabca    = code;              /* save for special case */
  470.  
  471.         /* make new entry in alphabet (only if NOT just cleared) */
  472.         if (lastcode != -1)
  473.         {
  474.             ab_prefix[ab_free] = lastcode;
  475.             ab_tail[ab_free]   = code;
  476.             ab_free++;
  477.  
  478.             if ((ab_free > ab_max) && (ab_bits < 12))
  479.             {
  480.                 ab_bits++;
  481.                 ab_max = (1 << ab_bits) - 1;
  482.             }
  483.         }
  484.  
  485.         /* dump stack data to the image buffer */
  486.         while (pos >= 0)
  487.         {
  488.             (img->p)[x + (y * (img->w))] = (char) stack[pos];
  489.             pos--;
  490.  
  491.             if (++x >= (img->w))
  492.             {
  493.                 x = 0;
  494.  
  495.                 if (interl)
  496.                 {
  497.                     /* support for interlaced images */
  498.                     switch (pass)
  499.                     {
  500.                         case 1: y += 8; break;
  501.                         case 2: y += 8; break;
  502.                         case 3: y += 4; break;
  503.                         case 4: y += 2; break;
  504.                     }
  505.  
  506.                     /* loop until a valid y coordinate has been
  507.                     found, Or if the maximum number of passes has
  508.                     been reached, exit the loop, and stop image
  509.                     decoding (At this point the image is succesfully
  510.                     decoded).
  511.                     If we don't loop, but merely set y to some other
  512.                     value, that new value might still be invalid depending
  513.                     on the height of the image. This would cause out of
  514.                     bounds writing.
  515.                     */
  516.                     while (y >= (img->h))
  517.                     {
  518.                         switch (++pass)
  519.                         {
  520.                             case 2: y = 4; break;
  521.                             case 3: y = 2; break;
  522.                             case 4: y = 1; break;
  523.  
  524.                             default:
  525.                                 /*
  526.                                 It's possible we arrive here. For example this
  527.                                 happens when the image is interlaced, and the
  528.                                 height is 1. Looking at the above cases, the
  529.                                 lowest possible y is 1. While the only valid
  530.                                 one would be 0 for an image of height 1. So
  531.                                 'eventually' the loop will arrive here.
  532.                                 This case makes sure this while loop is
  533.                                 exited, as well as the 2 other ones.
  534.                                 */
  535.  
  536.                                 // Set y to a valid coordinate so the local
  537.                                 // while loop will be exited. (y = 0 always
  538.                                 // is >= img->h since if img->h == 0 the
  539.                                 // image is never decoded)
  540.                                 y = 0;
  541.  
  542.                                 // This will exit the other outer while loop
  543.                                 pos = -1;
  544.  
  545.                                 // This will halt image decoding.
  546.                                 code = ab_fin;
  547.  
  548.                                 break;
  549.                         }
  550.                     }
  551.                 }
  552.                 else
  553.                 {
  554.                     /* non-interlaced */
  555.                     y++;
  556. /*
  557. Normally image decoding is finished when an End of Information code is
  558. encountered (code == ab_fin) however some broken encoders write wrong
  559. "block byte counts" (The first byte value after the "code size" byte),
  560. being one value too high. It might very well be possible other variants
  561. of this problem occur as well. The only sensible solution seems to
  562. be to check for clipping.
  563. Example of wrong encoding:
  564. (1 * 1 B/W image, raster data stream follows in hex bytes)
  565.  
  566. 02  << B/W images have a code size of 2
  567. 02  << Block byte count
  568. 44  << LZW packed
  569. 00  << Zero byte count (terminates data stream)
  570.  
  571. Because the block byte count is 2, the zero byte count is used in the
  572. decoding process, and decoding is continued after this byte. (While it
  573. should signal an end of image)
  574.  
  575. It should be:
  576. 02
  577. 02
  578. 44
  579. 01  << When decoded this correctly includes the End of Information code
  580. 00
  581.  
  582. Or (Worse solution):
  583. 02
  584. 01
  585. 44
  586. 00
  587. (The 44 doesn't include an End of Information code, but at least the
  588. decoder correctly skips to 00 now after decoding, and signals this
  589. as an End of Information itself)
  590. */
  591.                     if (y >= img->h)
  592.                     {
  593.                         code = ab_fin;
  594.                         break;
  595.                     }
  596.                 }
  597.             }
  598.         }
  599.  
  600.         pos = 0;
  601.         lastcode = readcode;
  602.     }
  603.     while (code != ab_fin);
  604.  
  605.     delete [] ab_prefix ;
  606.     delete [] ab_tail ;
  607.     delete [] stack ;
  608.  
  609.     return wxGIF_OK;
  610. }
  611.  
  612.  
  613. // CanRead:
  614. //  Returns TRUE if the file looks like a valid GIF, FALSE otherwise.
  615. //
  616. bool wxGIFDecoder::CanRead()
  617. {
  618.     unsigned char buf[3];
  619.  
  620.     if ( !m_f->Read(buf, WXSIZEOF(buf)) )
  621.         return FALSE;
  622.  
  623.     m_f->SeekI(-(off_t)WXSIZEOF(buf), wxFromCurrent);
  624.  
  625.     return memcmp(buf, "GIF", WXSIZEOF(buf)) == 0;
  626. }
  627.  
  628.  
  629. // ReadGIF:
  630. //  Reads and decodes one or more GIF images, depending on whether
  631. //  animated GIF support is enabled. Can read GIFs with any bit
  632. //  size (color depth), but the output images are always expanded
  633. //  to 8 bits per pixel. Also, the image palettes always contain
  634. //  256 colors, although some of them may be unused. Returns wxGIF_OK
  635. //  (== 0) on success, or an error code if something fails (see
  636. //  header file for details)
  637. //
  638. int wxGIFDecoder::ReadGIF()
  639. {
  640.     unsigned int ncolors;
  641.     int           bits, interl, transparent, disposal, i;
  642.     long          size;
  643.     long          delay;
  644.     unsigned char type = 0;
  645.     unsigned char pal[768];
  646.     unsigned char buf[16];
  647.     GIFImage      **ppimg;
  648.     GIFImage      *pimg, *pprev;
  649.  
  650.     /* check GIF signature */
  651.     if (!CanRead())
  652.         return wxGIF_INVFORMAT;
  653.  
  654.     /* check for animated GIF support (ver. >= 89a) */
  655.  
  656.     static const size_t headerSize = (3 + 3);
  657.     m_f->Read(buf, headerSize);
  658.     if (m_f->LastRead() != headerSize)
  659.     {
  660.         return wxGIF_INVFORMAT;
  661.     }
  662.  
  663.     if (memcmp(buf + 3, "89a", 3) < 0)
  664.     {
  665.         m_anim = FALSE;
  666.     }
  667.  
  668.     /* read logical screen descriptor block (LSDB) */
  669.     static const size_t lsdbSize = (2 + 2 + 1 + 1 + 1);
  670.     m_f->Read(buf, lsdbSize);
  671.     if (m_f->LastRead() != lsdbSize)
  672.     {
  673.         return wxGIF_INVFORMAT;
  674.     }
  675.  
  676.     m_screenw = buf[0] + 256 * buf[1];
  677.     m_screenh = buf[2] + 256 * buf[3];
  678.  
  679.     /* load global color map if available */
  680.     if ((buf[4] & 0x80) == 0x80)
  681.     {
  682.         m_background = buf[5];
  683.  
  684.         ncolors = 2 << (buf[4] & 0x07);
  685.         size_t numBytes = 3 * ncolors;
  686.         m_f->Read(pal, numBytes);
  687.         if (m_f->LastRead() != numBytes)
  688.         {
  689.             return wxGIF_INVFORMAT;
  690.         }
  691.     }
  692.  
  693.     /* transparent colour, disposal method and delay default to unused */
  694.     transparent = -1;
  695.     disposal = -1;
  696.     delay = -1;
  697.  
  698.     /* read images */
  699.     ppimg = &m_pfirst;
  700.     pprev = NULL;
  701.     pimg  = NULL;
  702.  
  703.     bool done = FALSE;
  704.  
  705.     while(!done)
  706.     {
  707.         type = (unsigned char)m_f->GetC();
  708.  
  709.         /*
  710.         If the end of file has been reached (or an error) and a ";"
  711.         (0x3B) hasn't been encountered yet, exit the loop. (Without this
  712.         check the while loop would loop endlessly.) Later on, in the next while
  713.         loop, the file will be treated as being truncated (But still
  714.         be decoded as far as possible). returning wxGIF_TRUNCATED is not
  715.         possible here since some init code is done after this loop.
  716.         */
  717.         if (m_f->Eof())// || !m_f->IsOk())
  718.         {
  719.             /*
  720.             type is set to some bogus value, so there's no
  721.             need to continue evaluating it.
  722.             */
  723.             break; // Alternative : "return wxGIF_INVFORMAT;"
  724.         }
  725.  
  726.         /* end of data? */
  727.         if (type == 0x3B)
  728.         {
  729.             done = TRUE;
  730.         }
  731.         else
  732.         /* extension block? */
  733.         if (type == 0x21)
  734.         {
  735.             if (((unsigned char)m_f->GetC()) == 0xF9)
  736.             /* graphics control extension, parse it */
  737.             {
  738.                 static const size_t gceSize = 6;
  739.                 m_f->Read(buf, gceSize);
  740.                 if (m_f->LastRead() != gceSize)
  741.                 {
  742.                     Destroy();
  743.                     return wxGIF_INVFORMAT;
  744.                 }
  745.  
  746.                 /* read delay and convert from 1/100 of a second to ms */
  747.                 delay = 10 * (buf[2] + 256 * buf[3]);
  748.  
  749.                 /* read transparent colour index, if used */
  750.                 if (buf[1] & 0x01)
  751.                     transparent = buf[4];
  752.  
  753.                 /* read disposal method */
  754.                 disposal = (buf[1] & 0x1C) - 1;
  755.             }
  756.             else
  757.             /* other extension, skip */
  758.             {
  759.                 while ((i = (unsigned char)m_f->GetC()) != 0)
  760.                 {
  761.                     m_f->SeekI(i, wxFromCurrent);
  762.                     if (m_f->Eof())
  763.                     {
  764.                         done = TRUE;
  765.                         break;
  766.                     }
  767.                 }
  768.             }
  769.         }
  770.         else
  771.         /* image descriptor block? */
  772.         if (type == 0x2C)
  773.         {
  774.             /* allocate memory for IMAGEN struct */
  775.             pimg = (*ppimg) = new GIFImage();
  776.  
  777.             if (pimg == NULL)
  778.             {
  779.                 Destroy();
  780.                 return wxGIF_MEMERR;
  781.             }
  782.  
  783.             /* fill in the data */
  784.             static const size_t idbSize = (2 + 2 + 2 + 2 + 1);
  785.             m_f->Read(buf, idbSize);
  786.             if (m_f->LastRead() != idbSize)
  787.             {
  788.                 Destroy();
  789.                 return wxGIF_INVFORMAT;
  790.             }
  791.  
  792.             pimg->left = buf[0] + 256 * buf[1];
  793.             pimg->top = buf[2] + 256 * buf[3];
  794. /*
  795.             pimg->left = buf[4] + 256 * buf[5];
  796.             pimg->top = buf[4] + 256 * buf[5];
  797. */
  798.             pimg->w = buf[4] + 256 * buf[5];
  799.             pimg->h = buf[6] + 256 * buf[7];
  800.  
  801.             if (pimg->w == 0 || pimg->h == 0)
  802.             {
  803.                 Destroy();
  804.                 return wxGIF_INVFORMAT;
  805.             }
  806.  
  807.             interl = ((buf[8] & 0x40)? 1 : 0);
  808.             size = pimg->w * pimg->h;
  809.  
  810.             pimg->transparent = transparent;
  811.             pimg->disposal = disposal;
  812.             pimg->delay = delay;
  813.             pimg->next = NULL;
  814.             pimg->prev = pprev;
  815.             pprev = pimg;
  816.             ppimg = &pimg->next;
  817.  
  818.             /* allocate memory for image and palette */
  819.             pimg->p   = (unsigned char *) malloc((size_t)size);
  820.             pimg->pal = (unsigned char *) malloc(768);
  821.  
  822.             if ((!pimg->p) || (!pimg->pal))
  823.             {
  824.                 Destroy();
  825.                 return wxGIF_MEMERR;
  826.             }
  827.  
  828.             /* load local color map if available, else use global map */
  829.             if ((buf[8] & 0x80) == 0x80)
  830.             {
  831.                 ncolors = 2 << (buf[8] & 0x07);
  832.                 size_t numBytes = 3 * ncolors;
  833.                 m_f->Read(pimg->pal, numBytes);
  834.                 if (m_f->LastRead() != numBytes)
  835.                 {
  836.                     Destroy();
  837.                     return wxGIF_INVFORMAT;
  838.                 }
  839.             }
  840.             else
  841.             {
  842.                 memcpy(pimg->pal, pal, 768);
  843.             }
  844.  
  845.             /* get initial code size from first byte in raster data */
  846.             bits = (unsigned char)m_f->GetC();
  847.  
  848.             /* decode image */
  849.             int result = dgif(pimg, interl, bits);
  850.             if (result != wxGIF_OK)
  851.             {
  852.                 Destroy();
  853.                 return result;
  854.             }
  855.             m_nimages++;
  856.  
  857.             /* if this is not an animated GIF, exit after first image */
  858.             if (!m_anim)
  859.                 done = TRUE;
  860.         }
  861.     }
  862.  
  863.     if (m_nimages == 0)
  864.     {
  865.         Destroy();
  866.         return wxGIF_INVFORMAT;
  867.     }
  868.  
  869.     /* setup image pointers */
  870.     m_image = 1;
  871.     m_plast = pimg;
  872.     m_pimage = m_pfirst;
  873.  
  874.     /* try to read to the end of the stream */
  875.     while (type != 0x3B)
  876.     {
  877.         if (!m_f->IsOk())
  878.             return wxGIF_TRUNCATED;
  879.  
  880.         type = (unsigned char)m_f->GetC();
  881.  
  882.         if (type == 0x21)
  883.         {
  884.             /* extension type */
  885.             (void) m_f->GetC();
  886.  
  887.             /* skip all data */
  888.             while ((i = (unsigned char)m_f->GetC()) != 0)
  889.             {
  890.                 m_f->SeekI(i, wxFromCurrent);
  891.             }
  892.         }
  893.         else if (type == 0x2C)
  894.         {
  895.             /* image descriptor block */
  896.             static const size_t idbSize = (2 + 2 + 2 + 2 + 1);
  897.             m_f->Read(buf, idbSize);
  898.             if (m_f->LastRead() != idbSize)
  899.             {
  900.                 Destroy();
  901.                 return wxGIF_INVFORMAT;
  902.             }
  903.  
  904.             /* local color map */
  905.             if ((buf[8] & 0x80) == 0x80)
  906.             {
  907.                 ncolors = 2 << (buf[8] & 0x07);
  908.                 off_t pos = m_f->TellI();
  909.                 off_t numBytes = 3 * ncolors;
  910.                 m_f->SeekI(numBytes, wxFromCurrent);
  911.                 if (m_f->TellI() != (pos + numBytes))
  912.                 {
  913.                     Destroy();
  914.                     return wxGIF_INVFORMAT;
  915.                 }
  916.             }
  917.  
  918.             /* initial code size */
  919.             (void) m_f->GetC();
  920.  
  921.             /* skip all data */
  922.             while ((i = (unsigned char)m_f->GetC()) != 0)
  923.             {
  924.                 m_f->SeekI(i, wxFromCurrent);
  925.             }
  926.         }
  927.         else if ((type != 0x3B) && (type != 00)) /* testing */
  928.         {
  929.             /* images are OK, but couldn't read to the end of the stream */
  930.             return wxGIF_TRUNCATED;
  931.         }
  932.     }
  933.  
  934.     return wxGIF_OK;
  935. }
  936.  
  937. #endif // wxUSE_STREAMS && wxUSE_GIF
  938.