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