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