0f9b2e9bb0080a310706a367800e5580b00bf7d2
[WebKit-https.git] / WebCore / platform / image-decoders / gif / GIFImageReader.cpp
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* ***** BEGIN LICENSE BLOCK *****
3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4  *
5  * The contents of this file are subject to the Mozilla Public License Version
6  * 1.1 (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  * http://www.mozilla.org/MPL/
9  *
10  * Software distributed under the License is distributed on an "AS IS" basis,
11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12  * for the specific language governing rights and limitations under the
13  * License.
14  *
15  * The Original Code is mozilla.org code.
16  *
17  * The Initial Developer of the Original Code is
18  * Netscape Communications Corporation.
19  * Portions created by the Initial Developer are Copyright (C) 1998
20  * the Initial Developer. All Rights Reserved.
21  *
22  * Contributor(s):
23  *   Chris Saari <saari@netscape.com>
24  *   Apple Computer
25  *
26  * Alternatively, the contents of this file may be used under the terms of
27  * either the GNU General Public License Version 2 or later (the "GPL"), or
28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29  * in which case the provisions of the GPL or the LGPL are applicable instead
30  * of those above. If you wish to allow use of your version of this file only
31  * under the terms of either the GPL or the LGPL, and not to allow others to
32  * use your version of this file under the terms of the MPL, indicate your
33  * decision by deleting the provisions above and replace them with the notice
34  * and other provisions required by the GPL or the LGPL. If you do not delete
35  * the provisions above, a recipient may use your version of this file under
36  * the terms of any one of the MPL, the GPL or the LGPL.
37  *
38  * ***** END LICENSE BLOCK ***** */
39
40 /*
41 The Graphics Interchange Format(c) is the copyright property of CompuServe
42 Incorporated. Only CompuServe Incorporated is authorized to define, redefine,
43 enhance, alter, modify or change in any way the definition of the format.
44
45 CompuServe Incorporated hereby grants a limited, non-exclusive, royalty-free
46 license for the use of the Graphics Interchange Format(sm) in computer
47 software; computer software utilizing GIF(sm) must acknowledge ownership of the
48 Graphics Interchange Format and its Service Mark by CompuServe Incorporated, in
49 User and Technical Documentation. Computer software utilizing GIF, which is
50 distributed or may be distributed without User or Technical Documentation must
51 display to the screen or printer a message acknowledging ownership of the
52 Graphics Interchange Format and the Service Mark by CompuServe Incorporated; in
53 this case, the acknowledgement may be displayed in an opening screen or leading
54 banner, or a closing screen or trailing banner. A message such as the following
55 may be used:
56
57     "The Graphics Interchange Format(c) is the Copyright property of
58     CompuServe Incorporated. GIF(sm) is a Service Mark property of
59     CompuServe Incorporated."
60
61 For further information, please contact :
62
63     CompuServe Incorporated
64     Graphics Technology Department
65     5000 Arlington Center Boulevard
66     Columbus, Ohio  43220
67     U. S. A.
68
69 CompuServe Incorporated maintains a mailing list with all those individuals and
70 organizations who wish to receive copies of this document when it is corrected
71 or revised. This service is offered free of charge; please provide us with your
72 mailing address.
73 */
74
75 #include "config.h"
76 #include "GIFImageReader.h"
77
78 #include <string.h>
79 #include "GIFImageDecoder.h"
80
81 #if PLATFORM(CAIRO) || PLATFORM(QT) || PLATFORM(WX)
82
83 using WebCore::GIFImageDecoder;
84
85 // Define the Mozilla macro setup so that we can leave the macros alone.
86 #define PR_BEGIN_MACRO  do {
87 #define PR_END_MACRO    } while (0)
88
89 /*
90  * GETN(n, s) requests at least 'n' bytes available from 'q', at start of state 's'
91  *
92  * Note, the hold will never need to be bigger than 256 bytes to gather up in the hold,
93  * as each GIF block (except colormaps) can never be bigger than 256 bytes.
94  * Colormaps are directly copied in the resp. global_colormap or dynamically allocated local_colormap.
95  * So a fixed buffer in GIFImageReader is good enough.
96  * This buffer is only needed to copy left-over data from one GifWrite call to the next
97  */
98 #define GETN(n,s)                    \
99   PR_BEGIN_MACRO                     \
100     bytes_to_consume = (n);      \
101     state = (s);                 \
102   PR_END_MACRO
103
104 /* Get a 16-bit value stored in little-endian format */
105 #define GETINT16(p)   ((p)[1]<<8|(p)[0])
106
107 //******************************************************************************
108 // Send the data to the display front-end.
109 void GIFImageReader::output_row()
110 {
111   GIFFrameReader* gs = frame_reader;
112
113   int drow_start, drow_end;
114
115   drow_start = drow_end = gs->irow;
116
117   /*
118    * Haeberli-inspired hack for interlaced GIFs: Replicate lines while
119    * displaying to diminish the "venetian-blind" effect as the image is
120    * loaded. Adjust pixel vertical positions to avoid the appearance of the
121    * image crawling up the screen as successive passes are drawn.
122    */
123   if (gs->progressive_display && gs->interlaced && gs->ipass < 4) {
124     unsigned row_dup = 0, row_shift = 0;
125
126     switch (gs->ipass) {
127     case 1:
128       row_dup = 7;
129       row_shift = 3;
130       break;
131     case 2:
132       row_dup = 3;
133       row_shift = 1;
134       break;
135     case 3:
136       row_dup = 1;
137       row_shift = 0;
138       break;
139     default:
140       break;
141     }
142
143     drow_start -= row_shift;
144     drow_end = drow_start + row_dup;
145
146     /* Extend if bottom edge isn't covered because of the shift upward. */
147     if (((gs->height - 1) - drow_end) <= row_shift)
148       drow_end = gs->height - 1;
149
150     /* Clamp first and last rows to upper and lower edge of image. */
151     if (drow_start < 0)
152       drow_start = 0;
153     if ((unsigned)drow_end >= gs->height)
154       drow_end = gs->height - 1;
155   }
156
157   /* Protect against too much image data */
158   if ((unsigned)drow_start >= gs->height)
159     return;
160
161   // CALLBACK: Let the client know we have decoded a row.
162   if (clientptr && frame_reader)
163     clientptr->haveDecodedRow(images_count - 1, frame_reader->rowbuf, frame_reader->rowend,
164                               drow_start, drow_end - drow_start + 1);
165
166   gs->rowp = gs->rowbuf;
167
168   if (!gs->interlaced)
169     gs->irow++;
170   else {
171     do {
172       switch (gs->ipass)
173       {
174         case 1:
175           gs->irow += 8;
176           if (gs->irow >= gs->height) {
177             gs->ipass++;
178             gs->irow = 4;
179           }
180           break;
181
182         case 2:
183           gs->irow += 8;
184           if (gs->irow >= gs->height) {
185             gs->ipass++;
186             gs->irow = 2;
187           }
188           break;
189
190         case 3:
191           gs->irow += 4;
192           if (gs->irow >= gs->height) {
193             gs->ipass++;
194             gs->irow = 1;
195           }
196           break;
197
198         case 4:
199           gs->irow += 2;
200           if (gs->irow >= gs->height){
201             gs->ipass++;
202             gs->irow = 0;
203           }
204           break;
205
206         default:
207           break;
208       }
209     } while (gs->irow > (gs->height - 1));
210   }
211 }
212
213 //******************************************************************************
214 /* Perform Lempel-Ziv-Welch decoding */
215 int GIFImageReader::do_lzw(const unsigned char *q)
216 {
217   GIFFrameReader* gs = frame_reader;
218   if (!gs)
219     return 0;
220
221   int code;
222   int incode;
223   const unsigned char *ch;
224   
225   /* Copy all the decoder state variables into locals so the compiler
226    * won't worry about them being aliased.  The locals will be homed
227    * back into the GIF decoder structure when we exit.
228    */
229   int avail       = gs->avail;
230   int bits        = gs->bits;
231   int cnt         = count;
232   int codesize    = gs->codesize;
233   int codemask    = gs->codemask;
234   int oldcode     = gs->oldcode;
235   int clear_code  = gs->clear_code;
236   unsigned char firstchar = gs->firstchar;
237   int datum     = gs->datum;
238
239   if (!gs->prefix) {
240     gs->prefix = new unsigned short[MAX_BITS];
241     memset(gs->prefix, 0, MAX_BITS * sizeof(short));
242   }
243
244   unsigned short *prefix  = gs->prefix;
245   unsigned char *stackp   = gs->stackp;
246   unsigned char *suffix   = gs->suffix;
247   unsigned char *stack    = gs->stack;
248   unsigned char *rowp     = gs->rowp;
249   unsigned char *rowend   = gs->rowend;
250   unsigned rows_remaining = gs->rows_remaining;
251
252   if (rowp == rowend)
253     return 0;
254
255 #define OUTPUT_ROW                                                  \
256   PR_BEGIN_MACRO                                                        \
257     output_row();                                                     \
258     rows_remaining--;                                                   \
259     rowp = frame_reader->rowp;                                                    \
260     if (!rows_remaining)                                                \
261       goto END;                                                         \
262   PR_END_MACRO
263
264   for (ch = q; cnt-- > 0; ch++)
265   {
266     /* Feed the next byte into the decoder's 32-bit input buffer. */
267     datum += ((int) *ch) << bits;
268     bits += 8;
269
270     /* Check for underflow of decoder's 32-bit input buffer. */
271     while (bits >= codesize)
272     {
273       /* Get the leading variable-length symbol from the data stream */
274       code = datum & codemask;
275       datum >>= codesize;
276       bits -= codesize;
277
278       /* Reset the dictionary to its original state, if requested */
279       if (code == clear_code) {
280         codesize = gs->datasize + 1;
281         codemask = (1 << codesize) - 1;
282         avail = clear_code + 2;
283         oldcode = -1;
284         continue;
285       }
286
287       /* Check for explicit end-of-stream code */
288       if (code == (clear_code + 1)) {
289         /* end-of-stream should only appear after all image data */
290         if (rows_remaining != 0)
291           return -1;
292         return 0;
293       }
294
295       if (oldcode == -1) {
296         *rowp++ = suffix[code];
297         if (rowp == rowend)
298           OUTPUT_ROW;
299
300         firstchar = oldcode = code;
301         continue;
302       }
303
304       incode = code;
305       if (code >= avail) {
306         *stackp++ = firstchar;
307         code = oldcode;
308
309         if (stackp == stack + MAX_BITS)
310           return -1;
311       }
312
313       while (code >= clear_code)
314       {
315         if (code == prefix[code])
316           return -1;
317
318         *stackp++ = suffix[code];
319         code = prefix[code];
320
321         if (stackp == stack + MAX_BITS)
322           return -1;
323       }
324
325       *stackp++ = firstchar = suffix[code];
326
327       /* Define a new codeword in the dictionary. */
328       if (avail < 4096) {
329         prefix[avail] = oldcode;
330         suffix[avail] = firstchar;
331         avail++;
332
333         /* If we've used up all the codewords of a given length
334          * increase the length of codewords by one bit, but don't
335          * exceed the specified maximum codeword size of 12 bits.
336          */
337         if (((avail & codemask) == 0) && (avail < 4096)) {
338           codesize++;
339           codemask += avail;
340         }
341       }
342       oldcode = incode;
343
344         /* Copy the decoded data out to the scanline buffer. */
345       do {
346         *rowp++ = *--stackp;
347         if (rowp == rowend) {
348           OUTPUT_ROW;
349         }
350       } while (stackp > stack);
351     }
352   }
353
354   END:
355
356   /* Home the local copies of the GIF decoder state variables */
357   gs->avail = avail;
358   gs->bits = bits;
359   gs->codesize = codesize;
360   gs->codemask = codemask;
361   count = cnt;
362   gs->oldcode = oldcode;
363   gs->firstchar = firstchar;
364   gs->datum = datum;
365   gs->stackp = stackp;
366   gs->rowp = rowp;
367   gs->rows_remaining = rows_remaining;
368
369   return 0;
370 }
371
372
373 /******************************************************************************/
374 /*
375  * process data arriving from the stream for the gif decoder
376  */
377
378 bool GIFImageReader::read(const unsigned char *buf, unsigned len, 
379                      GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
380 {
381   if (!len) {
382     // No new data has come in since the last call, just ignore this call.
383     return true;
384   }
385
386   const unsigned char *q = buf;
387
388   // Add what we have so far to the block
389   // If previous call to me left something in the hold first complete current block
390   // Or if we are filling the colormaps, first complete the colormap
391   unsigned char* p = 0;
392   if (state == gif_global_colormap)
393     p = global_colormap;
394   else if (state == gif_image_colormap)
395     p = frame_reader ? frame_reader->local_colormap : 0;
396   else if (bytes_in_hold)
397     p = hold;
398   else
399     p = 0;
400
401   if (p || (state == gif_global_colormap) || (state == gif_image_colormap)) {
402     // Add what we have sofar to the block
403     unsigned l = len < bytes_to_consume ? len : bytes_to_consume;
404     if (p)
405         memcpy(p + bytes_in_hold, buf, l);
406
407     if (l < bytes_to_consume) {
408       // Not enough in 'buf' to complete current block, get more
409       bytes_in_hold += l;
410       bytes_to_consume -= l;
411       if (clientptr)
412         clientptr->decodingHalted(0);
413       return true;
414     }
415     // Reset hold buffer count
416     bytes_in_hold = 0;
417     // Point 'q' to complete block in hold (or in colormap)
418     q = p;
419   }
420
421   // Invariant:
422   //    'q' is start of current to be processed block (hold, colormap or buf)
423   //    'bytes_to_consume' is number of bytes to consume from 'buf'
424   //    'buf' points to the bytes to be consumed from the input buffer
425   //    'len' is number of bytes left in input buffer from position 'buf'.
426   //    At entrance of the for loop will 'buf' will be moved 'bytes_to_consume'
427   //    to point to next buffer, 'len' is adjusted accordingly.
428   //    So that next round in for loop, q gets pointed to the next buffer.
429
430   for (;len >= bytes_to_consume; q=buf) {
431     // Eat the current block from the buffer, q keeps pointed at current block
432     buf += bytes_to_consume;
433     len -= bytes_to_consume;
434
435     switch (state)
436     {
437     case gif_lzw:
438       if (do_lzw(q) < 0) {
439         state = gif_error;
440         break;
441       }
442       GETN(1, gif_sub_block);
443       break;
444
445     case gif_lzw_start:
446     {
447       /* Initialize LZW parser/decoder */
448       int datasize = *q;
449       if (datasize > MAX_LZW_BITS) {
450         state = gif_error;
451         break;
452       }
453       int clear_code = 1 << datasize;
454       if (clear_code >= MAX_BITS) {
455         state = gif_error;
456         break;
457       }
458
459       if (frame_reader) {
460         frame_reader->datasize = datasize;
461         frame_reader->clear_code = clear_code;
462         frame_reader->avail = frame_reader->clear_code + 2;
463         frame_reader->oldcode = -1;
464         frame_reader->codesize = frame_reader->datasize + 1;
465         frame_reader->codemask = (1 << frame_reader->codesize) - 1;
466
467         frame_reader->datum = frame_reader->bits = 0;
468
469         /* init the tables */
470         if (!frame_reader->suffix)
471           frame_reader->suffix = new unsigned char[MAX_BITS];
472         for (int i = 0; i < frame_reader->clear_code; i++)
473           frame_reader->suffix[i] = i;
474
475         if (!frame_reader->stack)
476           frame_reader->stack = new unsigned char[MAX_BITS];
477         frame_reader->stackp = frame_reader->stack;
478       }
479
480       GETN(1, gif_sub_block);
481     }
482     break;
483
484     /* All GIF files begin with "GIF87a" or "GIF89a" */
485     case gif_type:
486     {
487       if (!strncmp((char*)q, "GIF89a", 6)) {
488         version = 89;
489       } else if (!strncmp((char*)q, "GIF87a", 6)) {
490         version = 87;
491       } else {
492         state = gif_error;
493         break;
494       }
495       GETN(7, gif_global_header);
496     }
497     break;
498
499     case gif_global_header:
500     {
501       /* This is the height and width of the "screen" or
502        * frame into which images are rendered.  The
503        * individual images can be smaller than the
504        * screen size and located with an origin anywhere
505        * within the screen.
506        */
507
508       screen_width = GETINT16(q);
509       screen_height = GETINT16(q + 2);
510
511       // CALLBACK: Inform the decoderplugin of our size.
512       if (clientptr)
513         clientptr->sizeNowAvailable(screen_width, screen_height);
514       
515       screen_bgcolor = q[5];
516       global_colormap_size = 2<<(q[4]&0x07);
517
518       if ((q[4] & 0x80) && global_colormap_size > 0) { /* global map */
519         // Get the global colormap
520         const unsigned size = 3*global_colormap_size;
521         
522         // Malloc the color map, but only if we're not just counting frames.
523         if (query != GIFImageDecoder::GIFFrameCountQuery)
524           global_colormap = new unsigned char[size];
525
526         if (len < size) {
527           // Use 'hold' pattern to get the global colormap
528           GETN(size, gif_global_colormap);
529           break;
530         }
531         
532         // Copy everything and go directly to gif_image_start.
533         if (global_colormap)
534             memcpy(global_colormap, buf, size);
535         buf += size;
536         len -= size;
537       }
538
539       GETN(1, gif_image_start);
540
541       // q[6] = Pixel Aspect Ratio
542       //   Not used
543       //   float aspect = (float)((q[6] + 15) / 64.0);
544     }
545     break;
546
547     case gif_global_colormap:
548       // Everything is already copied into global_colormap
549       GETN(1, gif_image_start);
550     break;
551
552     case gif_image_start:
553     {
554       if (*q == ';') { /* terminator */
555         state = gif_done;
556         break;
557       }
558
559       if (*q == '!') { /* extension */
560         GETN(2, gif_extension);
561         break;
562       }
563
564       /* If we get anything other than ',' (image separator), '!'
565        * (extension), or ';' (trailer), there is extraneous data
566        * between blocks. The GIF87a spec tells us to keep reading
567        * until we find an image separator, but GIF89a says such
568        * a file is corrupt. We follow GIF89a and bail out. */
569       if (*q != ',') {
570         if (images_decoded > 0) {
571           /* The file is corrupt, but one or more images have
572            * been decoded correctly. In this case, we proceed
573            * as if the file were correctly terminated and set
574            * the state to gif_done, so the GIF will display.
575            */
576           state = gif_done;
577         } else {
578           /* No images decoded, there is nothing to display. */
579           state = gif_error;
580         }
581         break;
582       } else
583         GETN(9, gif_image_header);
584     }
585     break;
586
587     case gif_extension:
588     {
589       int len = count = q[1];
590       gstate es = gif_skip_block;
591
592       switch (*q)
593       {
594       case 0xf9:
595         es = gif_control_extension;
596         break;
597
598       case 0x01:
599         // ignoring plain text extension
600         break;
601
602       case 0xff:
603         es = gif_application_extension;
604         break;
605
606       case 0xfe:
607         es = gif_consume_comment;
608         break;
609       }
610
611       if (len)
612         GETN(len, es);
613       else
614         GETN(1, gif_image_start);
615     }
616     break;
617
618     case gif_consume_block:
619       if (!*q)
620         GETN(1, gif_image_start);
621       else
622         GETN(*q, gif_skip_block);
623     break;
624
625     case gif_skip_block:
626       GETN(1, gif_consume_block);
627       break;
628
629     case gif_control_extension:
630     {
631       if (query != GIFImageDecoder::GIFFrameCountQuery) {
632           if (!frame_reader)
633             frame_reader = new GIFFrameReader();
634       }
635
636       if (frame_reader) {
637         if (*q & 0x1) {
638           frame_reader->tpixel = q[3];
639           frame_reader->is_transparent = true;
640         } else {
641           frame_reader->is_transparent = false;
642           // ignoring gfx control extension
643         }
644         // NOTE: This relies on the values in the FrameDisposalMethod enum
645         // matching those in the GIF spec!
646         frame_reader->disposal_method = (WebCore::RGBA32Buffer::FrameDisposalMethod)(((*q) >> 2) & 0x7);
647         // Some specs say 3rd bit (value 4), other specs say value 3
648         // Let's choose 3 (the more popular)
649         if (frame_reader->disposal_method == 4)
650           frame_reader->disposal_method = WebCore::RGBA32Buffer::DisposeOverwritePrevious;
651         frame_reader->delay_time = GETINT16(q + 1) * 10;
652       }
653       GETN(1, gif_consume_block);
654     }
655     break;
656
657     case gif_comment_extension:
658     {
659       if (*q)
660         GETN(*q, gif_consume_comment);
661       else
662         GETN(1, gif_image_start);
663     }
664     break;
665
666     case gif_consume_comment:
667       GETN(1, gif_comment_extension);
668     break;
669
670     case gif_application_extension:
671       /* Check for netscape application extension */
672       if (!strncmp((char*)q, "NETSCAPE2.0", 11) ||
673         !strncmp((char*)q, "ANIMEXTS1.0", 11))
674         GETN(1, gif_netscape_extension_block);
675       else
676         GETN(1, gif_consume_block);
677     break;
678
679     /* Netscape-specific GIF extension: animation looping */
680     case gif_netscape_extension_block:
681       if (*q)
682         GETN(*q, gif_consume_netscape_extension);
683       else
684         GETN(1, gif_image_start);
685     break;
686
687     /* Parse netscape-specific application extensions */
688     case gif_consume_netscape_extension:
689     {
690       int netscape_extension = q[0] & 7;
691
692       /* Loop entire animation specified # of times.  Only read the
693          loop count during the first iteration. */
694       if (netscape_extension == 1) {
695         loop_count = GETINT16(q + 1);
696
697         GETN(1, gif_netscape_extension_block);
698       }
699       /* Wait for specified # of bytes to enter buffer */
700       else if (netscape_extension == 2) {
701         // Don't do this, this extension doesn't exist (isn't used at all) 
702         // and doesn't do anything, as our streaming/buffering takes care of it all...
703         // See: http://semmix.pl/color/exgraf/eeg24.htm
704         GETN(1, gif_netscape_extension_block);
705       } else
706         state = gif_error; // 0,3-7 are yet to be defined netscape
707                                // extension codes
708
709       break;
710     }
711
712     case gif_image_header:
713     {
714       unsigned height, width, x_offset, y_offset;
715       
716       /* Get image offsets, with respect to the screen origin */
717       x_offset = GETINT16(q);
718       y_offset = GETINT16(q + 2);
719
720       /* Get image width and height. */
721       width  = GETINT16(q + 4);
722       height = GETINT16(q + 6);
723
724       /* Work around broken GIF files where the logical screen
725        * size has weird width or height.  We assume that GIF87a
726        * files don't contain animations.
727        */
728       if ((images_decoded == 0) &&
729           ((screen_height < height) || (screen_width < width) ||
730            (version == 87)))
731       {
732         screen_height = height;
733         screen_width = width;
734         x_offset = 0;
735         y_offset = 0;
736
737         // CALLBACK: Inform the decoderplugin of our size.
738         if (clientptr)
739           clientptr->sizeNowAvailable(screen_width, screen_height);
740       }
741
742       /* Work around more broken GIF files that have zero image
743          width or height */
744       if (!height || !width) {
745         height = screen_height;
746         width = screen_width;
747         if (!height || !width) {
748           state = gif_error;
749           break;
750         }
751       }
752
753       if (query == GIFImageDecoder::GIFSizeQuery || haltAtFrame == images_decoded) {
754         // The decoder needs to stop.  Hand back the number of bytes we consumed from
755         // buffer minus 9 (the amount we consumed to read the header).
756         if (clientptr)
757             clientptr->decodingHalted(len + 9);
758         GETN(9, gif_image_header);
759         return true;
760       }
761       
762       images_count = images_decoded + 1;
763
764       if (query == GIFImageDecoder::GIFFullQuery && !frame_reader)
765         frame_reader = new GIFFrameReader();
766
767       if (frame_reader) {
768         frame_reader->x_offset = x_offset;
769         frame_reader->y_offset = y_offset;
770         frame_reader->height = height;
771         frame_reader->width = width;
772
773         /* This case will never be taken if this is the first image */
774         /* being decoded. If any of the later images are larger     */
775         /* than the screen size, we need to reallocate buffers.     */
776         if (screen_width < width) {
777           /* XXX Deviant! */
778
779           delete []frame_reader->rowbuf;
780           screen_width = width;
781           frame_reader->rowbuf = new unsigned char[screen_width];
782         } else if (!frame_reader->rowbuf) {
783           frame_reader->rowbuf = new unsigned char[screen_width];
784         }
785
786         if (!frame_reader->rowbuf) {
787           state = gif_oom;
788           break;
789         }
790         if (screen_height < height)
791           screen_height = height;
792
793         if (q[8] & 0x40) {
794           frame_reader->interlaced = true;
795           frame_reader->ipass = 1;
796         } else {
797           frame_reader->interlaced = false;
798           frame_reader->ipass = 0;
799         }
800
801         if (images_decoded == 0) {
802           frame_reader->progressive_display = true;
803         } else {
804           /* Overlaying interlaced, transparent GIFs over
805              existing image data using the Haeberli display hack
806              requires saving the underlying image in order to
807              avoid jaggies at the transparency edges.  We are
808              unprepared to deal with that, so don't display such
809              images progressively */
810           frame_reader->progressive_display = false;
811         }
812
813         /* Clear state from last image */
814         frame_reader->irow = 0;
815         frame_reader->rows_remaining = frame_reader->height;
816         frame_reader->rowend = frame_reader->rowbuf + frame_reader->width;
817         frame_reader->rowp = frame_reader->rowbuf;
818
819         /* bits per pixel is q[8]&0x07 */
820       }
821       
822       if (q[8] & 0x80) /* has a local colormap? */
823       {
824         int num_colors = 2 << (q[8] & 0x7);
825         const unsigned size = 3*num_colors;
826         unsigned char *map = frame_reader ? frame_reader->local_colormap : 0;
827         if (frame_reader && (!map || (num_colors > frame_reader->local_colormap_size))) {
828           delete []map;
829           map = new unsigned char[size];
830           if (!map) {
831             state = gif_oom;
832             break;
833           }
834         }
835
836         /* Switch to the new local palette after it loads */
837         if (frame_reader) {
838           frame_reader->local_colormap = map;
839           frame_reader->local_colormap_size = num_colors;
840           frame_reader->is_local_colormap_defined = true;
841         }
842
843         if (len < size) {
844           // Use 'hold' pattern to get the image colormap
845           GETN(size, gif_image_colormap);
846           break;
847         }
848         // Copy everything and directly go to gif_lzw_start
849         if (frame_reader)
850           memcpy(frame_reader->local_colormap, buf, size);
851         buf += size;
852         len -= size;
853       } else if (frame_reader) {
854         /* Switch back to the global palette */
855         frame_reader->is_local_colormap_defined = false;
856       }
857       GETN(1, gif_lzw_start);
858     }
859     break;
860
861     case gif_image_colormap:
862       // Everything is already copied into local_colormap
863       GETN(1, gif_lzw_start);
864     break;
865
866     case gif_sub_block:
867     {
868       if ((count = *q) != 0)
869       /* Still working on the same image: Process next LZW data block */
870       {
871         /* Make sure there are still rows left. If the GIF data */
872         /* is corrupt, we may not get an explicit terminator.   */
873         if (frame_reader && frame_reader->rows_remaining == 0) {
874           /* This is an illegal GIF, but we remain tolerant. */
875           GETN(1, gif_sub_block);
876         }
877         GETN(count, gif_lzw);
878       }
879       else
880       /* See if there are any more images in this sequence. */
881       {
882         images_decoded++;
883
884         // CALLBACK: The frame is now complete.
885         if (clientptr && frame_reader)
886           clientptr->frameComplete(images_decoded - 1, frame_reader->delay_time, 
887                                    frame_reader->disposal_method);
888
889         /* Clear state from this image */
890         if (frame_reader) {
891             frame_reader->is_local_colormap_defined = false;
892             frame_reader->is_transparent = false;
893         }
894
895         GETN(1, gif_image_start);
896       }
897     }
898     break;
899
900     case gif_done:
901       // When the GIF is done, we can stop.
902       if (clientptr)
903         clientptr->gifComplete();
904       return true;
905
906     // Handle out of memory errors
907     case gif_oom:
908       return false;
909
910     // Handle general errors
911     case gif_error:
912       // nsGIFDecoder2::EndGIF(gs->clientptr, gs->loop_count);
913       return false;
914
915     // We shouldn't ever get here.
916     default:
917       break;
918     }
919   }
920
921   // Copy the leftover into gs->hold
922   bytes_in_hold = len;
923   if (len) {
924     // Add what we have sofar to the block
925     unsigned char* p;
926     if (state == gif_global_colormap)
927       p = global_colormap;
928     else if (state == gif_image_colormap)
929       p = frame_reader ? frame_reader->local_colormap : 0;
930     else
931       p = hold;
932     if (p)
933       memcpy(p, buf, len);
934     bytes_to_consume -= len;
935   }
936
937   if (clientptr)
938     clientptr->decodingHalted(0);
939   return true;
940 }
941
942 #endif // PLATFORM(CAIRO)