]> git.saurik.com Git - wxWidgets.git/blob - src/common/gifdecod.cpp
fixed typo (IsOK instead of IsOk)
[wxWidgets.git] / src / common / gifdecod.cpp
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$
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 // wxGIFDecoder constructor and destructor
35 //---------------------------------------------------------------------------
36
37 wxGIFDecoder::wxGIFDecoder(wxInputStream *s, bool anim)
38 {
39 m_f = s;
40 m_anim = anim;
41
42 m_background = -1;
43 m_screenw = 0;
44 m_screenh = 0;
45
46 m_pimage = NULL;
47 m_pfirst = NULL;
48 m_plast = NULL;
49 m_image = 0;
50 m_nimages = 0;
51 }
52
53 wxGIFDecoder::~wxGIFDecoder()
54 {
55 Destroy();
56 }
57
58 void wxGIFDecoder::Destroy()
59 {
60 GIFImage *pimg, *paux;
61
62 pimg = m_pfirst;
63
64 while (pimg != NULL)
65 {
66 paux = pimg->next;
67 free(pimg->p);
68 free(pimg->pal);
69 delete pimg;
70 pimg = paux;
71 }
72
73 m_pimage = NULL;
74 m_pfirst = NULL;
75 m_plast = NULL;
76 m_image = 0;
77 m_nimages = 0;
78 }
79
80
81 //---------------------------------------------------------------------------
82 // Convert this image to a wxImage object
83 //---------------------------------------------------------------------------
84
85 // This function was designed by Vaclav Slavik
86
87 bool wxGIFDecoder::ConvertToImage(wxImage *image) const
88 {
89 unsigned char *src, *dst, *pal;
90 unsigned long i;
91 int transparent;
92
93 /* just in case... */
94 image->Destroy();
95
96 /* create the image */
97 image->Create(GetWidth(), GetHeight());
98
99 if (!image->Ok())
100 return FALSE;
101
102 pal = GetPalette();
103 src = GetData();
104 dst = image->GetData();
105 transparent = GetTransparentColour();
106
107 /* set transparent colour mask */
108 if (transparent != -1)
109 {
110 for (i = 0; i < 256; i++)
111 {
112 if ((pal[3 * i + 0] == 255) &&
113 (pal[3 * i + 1] == 0) &&
114 (pal[3 * i + 2] == 255))
115 {
116 pal[3 * i + 2] = 254;
117 }
118 }
119
120 pal[3 * transparent + 0] = 255,
121 pal[3 * transparent + 1] = 0,
122 pal[3 * transparent + 2] = 255;
123
124 image->SetMaskColour(255, 0, 255);
125 }
126 else
127 image->SetMask(FALSE);
128
129 // Set the palette
130 // Palette creation not yet implemented on wxGTK
131 #ifndef __WXGTK__
132 if (pal)
133 {
134 unsigned char* r = new unsigned char[256];
135 unsigned char* g = new unsigned char[256];
136 unsigned char* b = new unsigned char[256];
137 for (i = 0; i < 256; i++)
138 {
139 r[i] = pal[3*i + 0];
140 g[i] = pal[3*i + 1];
141 b[i] = pal[3*i + 2];
142 }
143 image->SetPalette(wxPalette(256, r, g, b));
144 delete[] r; delete[] g; delete[] b;
145 }
146 #endif
147
148 /* copy image data */
149 for (i = 0; i < (GetWidth() * GetHeight()); i++, src++)
150 {
151 *(dst++) = pal[3 * (*src) + 0];
152 *(dst++) = pal[3 * (*src) + 1];
153 *(dst++) = pal[3 * (*src) + 2];
154 }
155
156 return TRUE;
157 }
158
159
160 //---------------------------------------------------------------------------
161 // Data accessors
162 //---------------------------------------------------------------------------
163
164 // Get data for current frame
165
166 int wxGIFDecoder::GetFrameIndex() const { return m_image; }
167 unsigned char* wxGIFDecoder::GetData() const { return (m_pimage->p); }
168 unsigned char* wxGIFDecoder::GetPalette() const { return (m_pimage->pal); }
169 unsigned int wxGIFDecoder::GetWidth() const { return (m_pimage->w); }
170 unsigned int wxGIFDecoder::GetHeight() const { return (m_pimage->h); }
171 unsigned int wxGIFDecoder::GetTop() const { return (m_pimage->top); }
172 unsigned int wxGIFDecoder::GetLeft() const { return (m_pimage->left); }
173 int wxGIFDecoder::GetTransparentColour() const { return (m_pimage->transparent); }
174 int wxGIFDecoder::GetDisposalMethod() const { return (m_pimage->disposal); }
175 long wxGIFDecoder::GetDelay() const { return (m_pimage->delay); }
176
177 // Get global data
178
179 unsigned int wxGIFDecoder::GetLogicalScreenWidth() const { return m_screenw; }
180 unsigned int wxGIFDecoder::GetLogicalScreenHeight() const { return m_screenh; }
181 int wxGIFDecoder::GetBackgroundColour() const { return m_background; }
182 int wxGIFDecoder::GetNumberOfFrames() const { return m_nimages; }
183 bool wxGIFDecoder::IsAnimation() const { return (m_nimages > 1); }
184
185
186 //---------------------------------------------------------------------------
187 // Functions to move through the animation
188 //---------------------------------------------------------------------------
189
190 bool wxGIFDecoder::GoFirstFrame()
191 {
192 if (!IsAnimation())
193 return FALSE;
194
195 m_image = 1;
196 m_pimage = m_pfirst;
197 return TRUE;
198 }
199
200 bool wxGIFDecoder::GoLastFrame()
201 {
202 if (!IsAnimation())
203 return FALSE;
204
205 m_image = m_nimages;
206 m_pimage = m_plast;
207 return TRUE;
208 }
209
210 bool wxGIFDecoder::GoNextFrame(bool cyclic)
211 {
212 if (!IsAnimation())
213 return FALSE;
214
215 if ((m_image < m_nimages) || (cyclic))
216 {
217 m_pimage = m_pimage->next;
218 m_image++;
219
220 if (!m_pimage)
221 {
222 m_image = 1;
223 m_pimage = m_pfirst;
224 }
225
226 return TRUE;
227 }
228 else
229 return FALSE;
230 }
231
232 bool wxGIFDecoder::GoPrevFrame(bool cyclic)
233 {
234 if (!IsAnimation())
235 return FALSE;
236
237 if ((m_image > 1) || (cyclic))
238 {
239 m_pimage = m_pimage->prev;
240 m_image--;
241
242 if (!m_pimage)
243 {
244 m_image = m_nimages;
245 m_pimage = m_plast;
246 }
247
248 return TRUE;
249 }
250 else
251 return FALSE;
252 }
253
254 bool wxGIFDecoder::GoFrame(int which)
255 {
256 int i;
257
258 if (!IsAnimation())
259 return FALSE;
260
261 if ((which >= 1) && (which <= m_nimages))
262 {
263 m_pimage = m_pfirst;
264
265 for (i = 1; i < which; i++)
266 m_pimage = m_pimage->next;
267
268 return TRUE;
269 }
270 else
271 return FALSE;
272 }
273
274
275 //---------------------------------------------------------------------------
276 // GIF reading and decoding
277 //---------------------------------------------------------------------------
278
279 // getcode:
280 // Reads the next code from the file stream, with size 'bits'
281 //
282 int wxGIFDecoder::getcode(int bits, int ab_fin)
283 {
284 unsigned int mask; /* bit mask */
285 unsigned int code; /* code (result) */
286
287
288 /* get remaining bits from last byte read */
289 mask = (1 << bits) - 1;
290 code = (m_lastbyte >> (8 - m_restbits)) & mask;
291
292 /* keep reading new bytes while needed */
293 while (bits > m_restbits)
294 {
295 /* if no bytes left in this block, read the next block */
296 if (m_restbyte == 0)
297 {
298 m_restbyte = (unsigned char)m_f->GetC();
299
300 /* Some encoders are a bit broken: instead of issuing
301 * an end-of-image symbol (ab_fin) they come up with
302 * a zero-length subblock!! We catch this here so
303 * that the decoder sees an ab_fin code.
304 */
305 if (m_restbyte == 0)
306 {
307 code = ab_fin;
308 break;
309 }
310
311 /* prefetch data */
312 m_f->Read((void *) m_buffer, m_restbyte);
313 m_bufp = m_buffer;
314 }
315
316 /* read next byte and isolate the bits we need */
317 m_lastbyte = (unsigned char) (*m_bufp++);
318 mask = (1 << (bits - m_restbits)) - 1;
319 code = code + ((m_lastbyte & mask) << m_restbits);
320 m_restbyte--;
321
322 /* adjust total number of bits extracted from the buffer */
323 m_restbits = m_restbits + 8;
324 }
325
326 /* find number of bits remaining for next code */
327 m_restbits = (m_restbits - bits);
328
329 return code;
330 }
331
332
333 // dgif:
334 // GIF decoding function. The initial code size (aka root size)
335 // is 'bits'. Supports interlaced images (interl == 1).
336 //
337 int wxGIFDecoder::dgif(GIFImage *img, int interl, int bits)
338 {
339 #ifdef __WXMAC__
340 int *ab_prefix = new int[4096]; /* alphabet (prefixes) */
341 int *ab_tail = new int[4096]; /* alphabet (tails) */
342 int *stack = new int[4096]; /* decompression stack */
343 #else
344 int ab_prefix[4096]; /* alphabet (prefixes) */
345 int ab_tail[4096]; /* alphabet (tails) */
346 int stack[4096]; /* decompression stack */
347 #endif
348 int ab_clr; /* clear code */
349 int ab_fin; /* end of info code */
350 int ab_bits; /* actual symbol width, in bits */
351 int ab_free; /* first free position in alphabet */
352 int ab_max; /* last possible character in alphabet */
353 int pass; /* pass number in interlaced images */
354 int pos; /* index into decompresion stack */
355 unsigned int x, y; /* position in image buffer */
356
357 int code, readcode, lastcode, abcabca;
358
359 /* these won't change */
360 ab_clr = (1 << bits);
361 ab_fin = (1 << bits) + 1;
362
363 /* these will change through the decompression proccess */
364 ab_bits = bits + 1;
365 ab_free = (1 << bits) + 2;
366 ab_max = (1 << ab_bits) - 1;
367 lastcode = -1;
368 abcabca = -1;
369 pass = 1;
370 pos = x = y = 0;
371
372 /* reset decoder vars */
373 m_restbits = 0;
374 m_restbyte = 0;
375 m_lastbyte = 0;
376
377 do
378 {
379 /* get next code */
380 readcode = code = getcode(ab_bits, ab_fin);
381
382 /* end of image? */
383 if (code == ab_fin) break;
384
385 /* reset alphabet? */
386 if (code == ab_clr)
387 {
388 /* reset main variables */
389 ab_bits = bits + 1;
390 ab_free = (1 << bits) + 2;
391 ab_max = (1 << ab_bits) - 1;
392 lastcode = -1;
393 abcabca = -1;
394
395 /* skip to next code */
396 continue;
397 }
398
399 /* unknown code: special case (like in ABCABCA) */
400 if (code >= ab_free)
401 {
402 code = lastcode; /* take last string */
403 stack[pos++] = abcabca; /* add first character */
404 }
405
406 /* build the string for this code in the stack */
407 while (code > ab_clr)
408 {
409 stack[pos++] = ab_tail[code];
410 code = ab_prefix[code];
411 }
412 stack[pos] = code; /* push last code into the stack */
413 abcabca = code; /* save for special case */
414
415 /* make new entry in alphabet (only if NOT just cleared) */
416 if (lastcode != -1)
417 {
418 ab_prefix[ab_free] = lastcode;
419 ab_tail[ab_free] = code;
420 ab_free++;
421
422 if ((ab_free > ab_max) && (ab_bits < 12))
423 {
424 ab_bits++;
425 ab_max = (1 << ab_bits) - 1;
426 }
427 }
428
429 /* dump stack data to the buffer */
430 while (pos >= 0)
431 {
432 (img->p)[x + (y * (img->w))] = (char)stack[pos--];
433
434 if (++x >= (img->w))
435 {
436 x = 0;
437
438 if (interl)
439 {
440 /* support for interlaced images */
441 switch (pass)
442 {
443 case 1: y += 8; break;
444 case 2: y += 8; break;
445 case 3: y += 4; break;
446 case 4: y += 2; break;
447 }
448 if (y >= (img->h))
449 {
450 switch (++pass)
451 {
452 case 2: y = 4; break;
453 case 3: y = 2; break;
454 case 4: y = 1; break;
455 }
456 }
457 }
458 else
459 {
460 /* non-interlaced */
461 y++;
462 }
463 }
464 }
465
466 pos = 0;
467 lastcode = readcode;
468 }
469 while (code != ab_fin);
470
471 #ifdef __WXMAC__
472 delete [] ab_prefix ;
473 delete [] ab_tail ;
474 delete [] stack ;
475 #endif
476 return 0;
477 }
478
479
480 // CanRead:
481 // Returns TRUE if the file looks like a valid GIF, FALSE otherwise.
482 //
483 bool wxGIFDecoder::CanRead()
484 {
485 unsigned char buf[3];
486
487 m_f->Read(buf, 3);
488 m_f->SeekI(-3, wxFromCurrent);
489
490 return (memcmp(buf, "GIF", 3) == 0);
491 }
492
493
494 // ReadGIF:
495 // Reads and decodes one or more GIF images, depending on whether
496 // animated GIF support is enabled. Can read GIFs with any bit
497 // size (color depth), but the output images are always expanded
498 // to 8 bits per pixel. Also, the image palettes always contain
499 // 256 colors, although some of them may be unused. Returns wxGIF_OK
500 // (== 0) on success, or an error code if something fails (see
501 // header file for details)
502 //
503 int wxGIFDecoder::ReadGIF()
504 {
505 int ncolors, bits, interl, transparent, disposal, i;
506 long size;
507 long delay;
508 unsigned char type = 0;
509 unsigned char pal[768];
510 unsigned char buf[16];
511 GIFImage **ppimg, *pimg, *pprev;
512
513 /* check GIF signature */
514 if (!CanRead())
515 return wxGIF_INVFORMAT;
516
517 /* check for animated GIF support (ver. >= 89a) */
518 m_f->Read(buf, 6);
519
520 if (memcmp(buf + 3, "89a", 3) < 0)
521 m_anim = FALSE;
522
523 /* read logical screen descriptor block (LSDB) */
524 m_f->Read(buf, 7);
525 m_screenw = buf[0] + 256 * buf[1];
526 m_screenh = buf[2] + 256 * buf[3];
527
528 /* load global color map if available */
529 if ((buf[4] & 0x80) == 0x80)
530 {
531 m_background = buf[5];
532
533 ncolors = 2 << (buf[4] & 0x07);
534 m_f->Read(pal, 3 * ncolors);
535 }
536
537 /* transparent colour, disposal method and delay default to unused */
538 transparent = -1;
539 disposal = -1;
540 delay = -1;
541
542 /* read images */
543 ppimg = &m_pfirst;
544 pprev = NULL;
545 pimg = NULL;
546
547 bool done = FALSE;
548
549 while(!done)
550 {
551 type = (unsigned char)m_f->GetC();
552
553 /* end of data? */
554 if (type == 0x3B)
555 {
556 done = TRUE;
557 }
558 else
559 /* extension block? */
560 if (type == 0x21)
561 {
562 if (((unsigned char)m_f->GetC()) == 0xF9)
563 /* graphics control extension, parse it */
564 {
565 m_f->Read(buf, 6);
566
567 /* read delay and convert from 1/100 of a second to ms */
568 delay = 10 * (buf[2] + 256 * buf[3]);
569
570 /* read transparent colour index, if used */
571 if (buf[1] & 0x01)
572 transparent = buf[4];
573
574 /* read disposal method */
575 disposal = (buf[1] & 0x1C) - 1;
576 }
577 else
578 /* other extension, skip */
579 {
580 while ((i = (unsigned char)m_f->GetC()) != 0)
581 {
582 m_f->SeekI(i, wxFromCurrent);
583 }
584 }
585 }
586 else
587 /* image descriptor block? */
588 if (type == 0x2C)
589 {
590 /* allocate memory for IMAGEN struct */
591 pimg = (*ppimg) = new GIFImage();
592
593 if (pimg == NULL)
594 {
595 Destroy();
596 return wxGIF_MEMERR;
597 }
598
599 /* fill in the data */
600 m_f->Read(buf, 9);
601 pimg->left = buf[4] + 256 * buf[5];
602 pimg->top = buf[4] + 256 * buf[5];
603 pimg->w = buf[4] + 256 * buf[5];
604 pimg->h = buf[6] + 256 * buf[7];
605 interl = ((buf[8] & 0x40)? 1 : 0);
606 size = pimg->w * pimg->h;
607
608 pimg->transparent = transparent;
609 pimg->disposal = disposal;
610 pimg->delay = delay;
611 pimg->next = NULL;
612 pimg->prev = pprev;
613 pprev = pimg;
614 ppimg = &pimg->next;
615
616 /* allocate memory for image and palette */
617 pimg->p = (unsigned char *) malloc((size_t)size);
618 pimg->pal = (unsigned char *) malloc(768);
619
620 if ((!pimg->p) || (!pimg->pal))
621 {
622 Destroy();
623 return wxGIF_MEMERR;
624 }
625
626 /* load local color map if available, else use global map */
627 if ((buf[8] & 0x80) == 0x80)
628 {
629 ncolors = 2 << (buf[8] & 0x07);
630 m_f->Read(pimg->pal, 3 * ncolors);
631 }
632 else
633 memcpy(pimg->pal, pal, 768);
634
635 /* get initial code size from first byte in raster data */
636 bits = (unsigned char)m_f->GetC();
637
638 /* decode image */
639 dgif(pimg, interl, bits);
640 m_nimages++;
641
642 /* if this is not an animated GIF, exit after first image */
643 if (!m_anim)
644 done = TRUE;
645 }
646 }
647
648 /* setup image pointers */
649 if (m_nimages != 0)
650 {
651 m_image = 1;
652 m_plast = pimg;
653 m_pimage = m_pfirst;
654 }
655
656 /* try to read to the end of the stream */
657 while (type != 0x3B)
658 {
659 type = (unsigned char)m_f->GetC();
660
661 if (type == 0x21)
662 {
663 /* extension type */
664 (void) m_f->GetC();
665
666 /* skip all data */
667 while ((i = (unsigned char)m_f->GetC()) != 0)
668 {
669 m_f->SeekI(i, wxFromCurrent);
670 }
671 }
672 else if (type == 0x2C)
673 {
674 /* image descriptor block */
675 m_f->Read(buf, 9);
676
677 /* local color map */
678 if ((buf[8] & 0x80) == 0x80)
679 {
680 ncolors = 2 << (buf[8] & 0x07);
681 m_f->SeekI(3 * ncolors, wxFromCurrent);
682 }
683
684 /* initial code size */
685 (void) m_f->GetC();
686
687 /* skip all data */
688 while ((i = (unsigned char)m_f->GetC()) != 0)
689 {
690 m_f->SeekI(i, wxFromCurrent);
691 }
692 }
693 else if ((type != 0x3B) && (type != 00)) /* testing */
694 {
695 /* images are OK, but couldn't read to the end of the stream */
696 return wxGIF_TRUNCATED;
697 }
698 }
699
700 return wxGIF_OK;
701 }
702
703 #endif // wxUSE_STREAMS && wxUSE_GIF