Roll out r27896 as it caused lots of build breakages.
[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         frame_reader->disposal_method = (gdispose)(((*q) >> 2) & 0x7);
645         // Some specs say 3rd bit (value 4), other specs say value 3
646         // Let's choose 3 (the more popular)
647         if (frame_reader->disposal_method == 4)
648           frame_reader->disposal_method = (gdispose)3;
649         frame_reader->delay_time = GETINT16(q + 1) * 10;
650       }
651       GETN(1, gif_consume_block);
652     }
653     break;
654
655     case gif_comment_extension:
656     {
657       if (*q)
658         GETN(*q, gif_consume_comment);
659       else
660         GETN(1, gif_image_start);
661     }
662     break;
663
664     case gif_consume_comment:
665       GETN(1, gif_comment_extension);
666     break;
667
668     case gif_application_extension:
669       /* Check for netscape application extension */
670       if (!strncmp((char*)q, "NETSCAPE2.0", 11) ||
671         !strncmp((char*)q, "ANIMEXTS1.0", 11))
672         GETN(1, gif_netscape_extension_block);
673       else
674         GETN(1, gif_consume_block);
675     break;
676
677     /* Netscape-specific GIF extension: animation looping */
678     case gif_netscape_extension_block:
679       if (*q)
680         GETN(*q, gif_consume_netscape_extension);
681       else
682         GETN(1, gif_image_start);
683     break;
684
685     /* Parse netscape-specific application extensions */
686     case gif_consume_netscape_extension:
687     {
688       int netscape_extension = q[0] & 7;
689
690       /* Loop entire animation specified # of times.  Only read the
691          loop count during the first iteration. */
692       if (netscape_extension == 1) {
693         loop_count = GETINT16(q + 1);
694
695         GETN(1, gif_netscape_extension_block);
696       }
697       /* Wait for specified # of bytes to enter buffer */
698       else if (netscape_extension == 2) {
699         // Don't do this, this extension doesn't exist (isn't used at all) 
700         // and doesn't do anything, as our streaming/buffering takes care of it all...
701         // See: http://semmix.pl/color/exgraf/eeg24.htm
702         GETN(1, gif_netscape_extension_block);
703       } else
704         state = gif_error; // 0,3-7 are yet to be defined netscape
705                                // extension codes
706
707       break;
708     }
709
710     case gif_image_header:
711     {
712       unsigned height, width, x_offset, y_offset;
713       
714       /* Get image offsets, with respect to the screen origin */
715       x_offset = GETINT16(q);
716       y_offset = GETINT16(q + 2);
717
718       /* Get image width and height. */
719       width  = GETINT16(q + 4);
720       height = GETINT16(q + 6);
721
722       /* Work around broken GIF files where the logical screen
723        * size has weird width or height.  We assume that GIF87a
724        * files don't contain animations.
725        */
726       if ((images_decoded == 0) &&
727           ((screen_height < height) || (screen_width < width) ||
728            (version == 87)))
729       {
730         screen_height = height;
731         screen_width = width;
732         x_offset = 0;
733         y_offset = 0;
734
735         // CALLBACK: Inform the decoderplugin of our size.
736         if (clientptr)
737           clientptr->sizeNowAvailable(screen_width, screen_height);
738       }
739
740       /* Work around more broken GIF files that have zero image
741          width or height */
742       if (!height || !width) {
743         height = screen_height;
744         width = screen_width;
745         if (!height || !width) {
746           state = gif_error;
747           break;
748         }
749       }
750
751       if (query == GIFImageDecoder::GIFSizeQuery || haltAtFrame == images_decoded) {
752         // The decoder needs to stop.  Hand back the number of bytes we consumed from
753         // buffer minus 9 (the amount we consumed to read the header).
754         if (clientptr)
755             clientptr->decodingHalted(len + 9);
756         GETN(9, gif_image_header);
757         return true;
758       }
759       
760       images_count = images_decoded + 1;
761
762       if (query == GIFImageDecoder::GIFFullQuery && !frame_reader)
763         frame_reader = new GIFFrameReader();
764
765       if (frame_reader) {
766         frame_reader->x_offset = x_offset;
767         frame_reader->y_offset = y_offset;
768         frame_reader->height = height;
769         frame_reader->width = width;
770
771         /* This case will never be taken if this is the first image */
772         /* being decoded. If any of the later images are larger     */
773         /* than the screen size, we need to reallocate buffers.     */
774         if (screen_width < width) {
775           /* XXX Deviant! */
776
777           delete []frame_reader->rowbuf;
778           screen_width = width;
779           frame_reader->rowbuf = new unsigned char[screen_width];
780         } else if (!frame_reader->rowbuf) {
781           frame_reader->rowbuf = new unsigned char[screen_width];
782         }
783
784         if (!frame_reader->rowbuf) {
785           state = gif_oom;
786           break;
787         }
788         if (screen_height < height)
789           screen_height = height;
790
791         if (q[8] & 0x40) {
792           frame_reader->interlaced = true;
793           frame_reader->ipass = 1;
794         } else {
795           frame_reader->interlaced = false;
796           frame_reader->ipass = 0;
797         }
798
799         if (images_decoded == 0) {
800           frame_reader->progressive_display = true;
801         } else {
802           /* Overlaying interlaced, transparent GIFs over
803              existing image data using the Haeberli display hack
804              requires saving the underlying image in order to
805              avoid jaggies at the transparency edges.  We are
806              unprepared to deal with that, so don't display such
807              images progressively */
808           frame_reader->progressive_display = false;
809         }
810
811         /* Clear state from last image */
812         frame_reader->irow = 0;
813         frame_reader->rows_remaining = frame_reader->height;
814         frame_reader->rowend = frame_reader->rowbuf + frame_reader->width;
815         frame_reader->rowp = frame_reader->rowbuf;
816
817         /* bits per pixel is q[8]&0x07 */
818       }
819       
820       if (q[8] & 0x80) /* has a local colormap? */
821       {
822         int num_colors = 2 << (q[8] & 0x7);
823         const unsigned size = 3*num_colors;
824         unsigned char *map = frame_reader ? frame_reader->local_colormap : 0;
825         if (frame_reader && (!map || (num_colors > frame_reader->local_colormap_size))) {
826           delete []map;
827           map = new unsigned char[size];
828           if (!map) {
829             state = gif_oom;
830             break;
831           }
832         }
833
834         /* Switch to the new local palette after it loads */
835         if (frame_reader) {
836           frame_reader->local_colormap = map;
837           frame_reader->local_colormap_size = num_colors;
838           frame_reader->is_local_colormap_defined = true;
839         }
840
841         if (len < size) {
842           // Use 'hold' pattern to get the image colormap
843           GETN(size, gif_image_colormap);
844           break;
845         }
846         // Copy everything and directly go to gif_lzw_start
847         if (frame_reader)
848           memcpy(frame_reader->local_colormap, buf, size);
849         buf += size;
850         len -= size;
851       } else if (frame_reader) {
852         /* Switch back to the global palette */
853         frame_reader->is_local_colormap_defined = false;
854       }
855       GETN(1, gif_lzw_start);
856     }
857     break;
858
859     case gif_image_colormap:
860       // Everything is already copied into local_colormap
861       GETN(1, gif_lzw_start);
862     break;
863
864     case gif_sub_block:
865     {
866       if ((count = *q) != 0)
867       /* Still working on the same image: Process next LZW data block */
868       {
869         /* Make sure there are still rows left. If the GIF data */
870         /* is corrupt, we may not get an explicit terminator.   */
871         if (frame_reader && frame_reader->rows_remaining == 0) {
872           /* This is an illegal GIF, but we remain tolerant. */
873           GETN(1, gif_sub_block);
874         }
875         GETN(count, gif_lzw);
876       }
877       else
878       /* See if there are any more images in this sequence. */
879       {
880         images_decoded++;
881
882         // CALLBACK: The frame is now complete.
883         if (clientptr && frame_reader)
884           clientptr->frameComplete(images_decoded - 1, frame_reader->delay_time, 
885                                    frame_reader->disposal_method == DISPOSE_KEEP);
886
887         /* Clear state from this image */
888         if (frame_reader) {
889             frame_reader->is_local_colormap_defined = false;
890             frame_reader->is_transparent = false;
891         }
892
893         GETN(1, gif_image_start);
894       }
895     }
896     break;
897
898     case gif_done:
899       // When the GIF is done, we can stop.
900       if (clientptr)
901         clientptr->gifComplete();
902       return true;
903
904     // Handle out of memory errors
905     case gif_oom:
906       return false;
907
908     // Handle general errors
909     case gif_error:
910       // nsGIFDecoder2::EndGIF(gs->clientptr, gs->loop_count);
911       return false;
912
913     // We shouldn't ever get here.
914     default:
915       break;
916     }
917   }
918
919   // Copy the leftover into gs->hold
920   bytes_in_hold = len;
921   if (len) {
922     // Add what we have sofar to the block
923     unsigned char* p;
924     if (state == gif_global_colormap)
925       p = global_colormap;
926     else if (state == gif_image_colormap)
927       p = frame_reader ? frame_reader->local_colormap : 0;
928     else
929       p = hold;
930     if (p)
931       memcpy(p, buf, len);
932     bytes_to_consume -= len;
933   }
934
935   if (clientptr)
936     clientptr->decodingHalted(0);
937   return true;
938 }
939
940 #endif // PLATFORM(CAIRO)