Unreviewed, rolling out r143936.
[WebKit-https.git] / Source / 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 #include "ImageSource.h"
81
82 using WebCore::GIFImageDecoder;
83
84 // GETN(n, s) requests at least 'n' bytes available from 'q', at start of state 's'.
85 //
86 // Note, the hold will never need to be bigger than 256 bytes to gather up in the hold,
87 // as each GIF block (except colormaps) can never be bigger than 256 bytes.
88 // Colormaps are directly copied in the resp. global_colormap or dynamically allocated local_colormap.
89 // So a fixed buffer in GIFImageReader is good enough.
90 // This buffer is only needed to copy left-over data from one GifWrite call to the next
91 #define GETN(n, s) \
92     do { \
93         m_bytesToConsume = (n); \
94         m_state = (s); \
95     } while (0)
96
97 // Get a 16-bit value stored in little-endian format.
98 #define GETINT16(p)   ((p)[1]<<8|(p)[0])
99
100 // Send the data to the display front-end.
101 bool GIFImageReader::outputRow()
102 {
103     int drowStart = m_frameContext->irow;
104     int drowEnd = m_frameContext->irow;
105
106     // Haeberli-inspired hack for interlaced GIFs: Replicate lines while
107     // displaying to diminish the "venetian-blind" effect as the image is
108     // loaded. Adjust pixel vertical positions to avoid the appearance of the
109     // image crawling up the screen as successive passes are drawn.
110     if (m_frameContext->progressiveDisplay && m_frameContext->interlaced && m_frameContext->ipass < 4) {
111         unsigned rowDup = 0;
112         unsigned rowShift = 0;
113
114         switch (m_frameContext->ipass) {
115         case 1:
116             rowDup = 7;
117             rowShift = 3;
118             break;
119         case 2:
120             rowDup = 3;
121             rowShift = 1;
122             break;
123         case 3:
124             rowDup = 1;
125             rowShift = 0;
126             break;
127         default:
128             break;
129         }
130
131         drowStart -= rowShift;
132         drowEnd = drowStart + rowDup;
133
134         // Extend if bottom edge isn't covered because of the shift upward.
135         if (((m_frameContext->height - 1) - drowEnd) <= rowShift)
136             drowEnd = m_frameContext->height - 1;
137
138         // Clamp first and last rows to upper and lower edge of image.
139         if (drowStart < 0)
140             drowStart = 0;
141
142         if ((unsigned)drowEnd >= m_frameContext->height)
143             drowEnd = m_frameContext->height - 1;
144     }
145
146     // Protect against too much image data.
147     if ((unsigned)drowStart >= m_frameContext->height)
148         return true;
149
150     // CALLBACK: Let the client know we have decoded a row.
151     if (m_client && m_frameContext
152         && !m_client->haveDecodedRow(m_imagesCount - 1, m_frameContext->rowbuf, m_frameContext->rowend,
153             drowStart, drowEnd - drowStart + 1, m_frameContext->progressiveDisplay && m_frameContext->interlaced && m_frameContext->ipass > 1))
154         return false;
155
156     m_frameContext->rowp = m_frameContext->rowbuf;
157
158     if (!m_frameContext->interlaced)
159         m_frameContext->irow++;
160     else {
161         do {
162             switch (m_frameContext->ipass) {
163             case 1:
164                 m_frameContext->irow += 8;
165                 if (m_frameContext->irow >= m_frameContext->height) {
166                     m_frameContext->ipass++;
167                     m_frameContext->irow = 4;
168                 }
169                 break;
170
171             case 2:
172                 m_frameContext->irow += 8;
173                 if (m_frameContext->irow >= m_frameContext->height) {
174                     m_frameContext->ipass++;
175                     m_frameContext->irow = 2;
176                 }
177                 break;
178
179             case 3:
180                 m_frameContext->irow += 4;
181                 if (m_frameContext->irow >= m_frameContext->height) {
182                     m_frameContext->ipass++;
183                     m_frameContext->irow = 1;
184                 }
185                 break;
186
187             case 4:
188                 m_frameContext->irow += 2;
189                 if (m_frameContext->irow >= m_frameContext->height) {
190                     m_frameContext->ipass++;
191                     m_frameContext->irow = 0;
192                 }
193                 break;
194
195             default:
196                 break;
197             }
198         } while (m_frameContext->irow > (m_frameContext->height - 1));
199     }
200     return true;
201 }
202
203 // Perform Lempel-Ziv-Welch decoding.
204 bool GIFImageReader::doLZW(const unsigned char *q)
205 {
206     if (!m_frameContext)
207         return true;
208
209     int code;
210     int incode;
211     const unsigned char *ch;
212
213     // Copy all the decoder state variables into locals so the compiler
214     // won't worry about them being aliased. The locals will be homed
215     // back into the GIF decoder structure when we exit.
216     int avail = m_frameContext->avail;
217     int bits = m_frameContext->bits;
218     int cnt = m_count;
219     int codesize = m_frameContext->codesize;
220     int codemask = m_frameContext->codemask;
221     int oldcode = m_frameContext->oldcode;
222     int clearCode = m_frameContext->clearCode;
223     unsigned char firstchar = m_frameContext->firstchar;
224     int datum = m_frameContext->datum;
225
226     if (!m_frameContext->prefix) {
227         m_frameContext->prefix = new unsigned short[MAX_BITS];
228         memset(m_frameContext->prefix, 0, MAX_BITS * sizeof(short));
229     }
230
231     unsigned short *prefix = m_frameContext->prefix;
232     unsigned char *stackp = m_frameContext->stackp;
233     unsigned char *suffix = m_frameContext->suffix;
234     unsigned char *stack = m_frameContext->stack;
235     unsigned char *rowp = m_frameContext->rowp;
236     unsigned char *rowend = m_frameContext->rowend;
237     unsigned rowsRemaining = m_frameContext->rowsRemaining;
238
239     if (rowp == rowend)
240         return true;
241
242 #define OUTPUT_ROW \
243     do { \
244         if (!outputRow()) \
245             return false; \
246         rowsRemaining--; \
247         rowp = m_frameContext->rowp; \
248         if (!rowsRemaining) \
249             goto END; \
250     } while (0)
251
252     for (ch = q; cnt-- > 0; ch++) {
253         // Feed the next byte into the decoder's 32-bit input buffer.
254         datum += ((int) *ch) << bits;
255         bits += 8;
256
257         // Check for underflow of decoder's 32-bit input buffer.
258         while (bits >= codesize) {
259             // Get the leading variable-length symbol from the data stream.
260             code = datum & codemask;
261             datum >>= codesize;
262             bits -= codesize;
263
264             // Reset the dictionary to its original state, if requested.
265             if (code == clearCode) {
266                 codesize = m_frameContext->datasize + 1;
267                 codemask = (1 << codesize) - 1;
268                 avail = clearCode + 2;
269                 oldcode = -1;
270                 continue;
271             }
272
273             // Check for explicit end-of-stream code.
274             if (code == (clearCode + 1)) {
275                 // end-of-stream should only appear after all image data.
276                 if (!rowsRemaining)
277                     return true;
278                 return m_client ? m_client->setFailed() : false;
279             }
280
281             if (oldcode == -1) {
282                 *rowp++ = suffix[code];
283                 if (rowp == rowend)
284                     OUTPUT_ROW;
285
286                 firstchar = oldcode = code;
287                 continue;
288             }
289
290             incode = code;
291             if (code >= avail) {
292                 *stackp++ = firstchar;
293                 code = oldcode;
294
295                 if (stackp == stack + MAX_BITS)
296                     return m_client ? m_client->setFailed() : false;
297             }
298
299             while (code >= clearCode) {
300                 if (code >= MAX_BITS || code == prefix[code])
301                     return m_client ? m_client->setFailed() : false;
302
303                 // Even though suffix[] only holds characters through suffix[avail - 1],
304                 // allowing code >= avail here lets us be more tolerant of malformed
305                 // data. As long as code < MAX_BITS, the only risk is a garbled image,
306                 // which is no worse than refusing to display it.
307                 *stackp++ = suffix[code];
308                 code = prefix[code];
309
310                 if (stackp == stack + MAX_BITS)
311                     return m_client ? m_client->setFailed() : false;
312             }
313
314             *stackp++ = firstchar = suffix[code];
315
316             // Define a new codeword in the dictionary.
317             if (avail < 4096) {
318                 prefix[avail] = oldcode;
319                 suffix[avail] = firstchar;
320                 avail++;
321
322                 // If we've used up all the codewords of a given length
323                 // increase the length of codewords by one bit, but don't
324                 // exceed the specified maximum codeword size of 12 bits.
325                 if ((!(avail & codemask)) && (avail < 4096)) {
326                     codesize++;
327                     codemask += avail;
328                 }
329             }
330             oldcode = incode;
331
332             // Copy the decoded data out to the scanline buffer.
333             do {
334                 *rowp++ = *--stackp;
335                 if (rowp == rowend)
336                     OUTPUT_ROW;
337             } while (stackp > stack);
338         }
339     }
340
341 END:
342     // Home the local copies of the GIF decoder state variables.
343     m_frameContext->avail = avail;
344     m_frameContext->bits = bits;
345     m_frameContext->codesize = codesize;
346     m_frameContext->codemask = codemask;
347     m_count = cnt;
348     m_frameContext->oldcode = oldcode;
349     m_frameContext->firstchar = firstchar;
350     m_frameContext->datum = datum;
351     m_frameContext->stackp = stackp;
352     m_frameContext->rowp = rowp;
353     m_frameContext->rowsRemaining = rowsRemaining;
354     return true;
355 }
356
357
358 // Process data arriving from the stream for the gif decoder.
359 bool GIFImageReader::read(const unsigned char *buf, unsigned len, GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
360 {
361     if (!len) {
362         // No new data has come in since the last call, just ignore this call.
363         return true;
364     }
365
366     const unsigned char *q = buf;
367
368     // Add what we have so far to the block.
369     // If previous call to me left something in the hold first complete current block
370     // or if we are filling the colormaps, first complete the colormap.
371     unsigned char* p = 0;
372     if (m_state == GIFGlobalColormap)
373         p = m_globalColormap;
374     else if (m_state == GIFImageColormap)
375         p = m_frameContext ? m_frameContext->localColormap : 0;
376     else if (m_bytesInHold)
377         p = m_hold;
378     else
379         p = 0;
380
381     if (p || (m_state == GIFGlobalColormap) || (m_state == GIFImageColormap)) {
382         // Add what we have sofar to the block
383         unsigned length = len < m_bytesToConsume ? len : m_bytesToConsume;
384         if (p)
385             memcpy(p + m_bytesInHold, buf, length);
386
387         if (length < m_bytesToConsume) {
388             // Not enough in 'buf' to complete current block, get more
389             m_bytesInHold += length;
390             m_bytesToConsume -= length;
391             if (m_client)
392                 m_client->decodingHalted(0);
393             return false;
394         }
395
396         // Reset hold buffer count
397         m_bytesInHold = 0;
398
399         // Point 'q' to complete block in hold (or in colormap)
400         q = p;
401     }
402
403     // Invariant:
404     //    'q' is start of current to be processed block (hold, colormap or buf)
405     //    'm_bytesToConsume' is number of bytes to consume from 'buf'
406     //    'buf' points to the bytes to be consumed from the input buffer
407     //    'len' is number of bytes left in input buffer from position 'buf'.
408     //    At entrance of the for loop will 'buf' will be moved 'm_bytesToConsume'
409     //    to point to next buffer, 'len' is adjusted accordingly.
410     //    So that next round in for loop, q gets pointed to the next buffer.
411     for (;len >= m_bytesToConsume; q = buf) {
412         // Eat the current block from the buffer, q keeps pointed at current block.
413         buf += m_bytesToConsume;
414         len -= m_bytesToConsume;
415
416         switch (m_state) {
417         case GIFLZW:
418             if (!doLZW(q))
419                 return false; // If doLZW() encountered an error, it has already called m_client->setFailed().
420             GETN(1, GIFSubBlock);
421             break;
422
423         case GIFLZWStart: {
424             // Initialize LZW parser/decoder.
425             int datasize = *q;
426
427             // Since we use a codesize of 1 more than the datasize, we need to ensure
428             // that our datasize is strictly less than the MAX_LZW_BITS value (12).
429             // This sets the largest possible codemask correctly at 4095.
430             if (datasize >= MAX_LZW_BITS)
431                 return m_client ? m_client->setFailed() : false;
432             int clearCode = 1 << datasize;
433             if (clearCode >= MAX_BITS)
434                 return m_client ? m_client->setFailed() : false;
435
436             if (m_frameContext) {
437                 m_frameContext->datasize = datasize;
438                 m_frameContext->clearCode = clearCode;
439                 m_frameContext->avail = m_frameContext->clearCode + 2;
440                 m_frameContext->oldcode = -1;
441                 m_frameContext->codesize = m_frameContext->datasize + 1;
442                 m_frameContext->codemask = (1 << m_frameContext->codesize) - 1;
443                 m_frameContext->datum = m_frameContext->bits = 0;
444
445                 // Init the tables.
446                 if (!m_frameContext->suffix)
447                     m_frameContext->suffix = new unsigned char[MAX_BITS];
448
449                 // Clearing the whole suffix table lets us be more tolerant of bad data.
450                 memset(m_frameContext->suffix, 0, MAX_BITS);
451                 for (int i = 0; i < m_frameContext->clearCode; i++)
452                     m_frameContext->suffix[i] = i;
453
454                 if (!m_frameContext->stack)
455                     m_frameContext->stack = new unsigned char[MAX_BITS];
456                 m_frameContext->stackp = m_frameContext->stack;
457             }
458
459             GETN(1, GIFSubBlock);
460             break;
461         }
462
463         case GIFType: {
464             // All GIF files begin with "GIF87a" or "GIF89a".
465             if (!strncmp((char*)q, "GIF89a", 6))
466                 m_version = 89;
467             else if (!strncmp((char*)q, "GIF87a", 6))
468                 m_version = 87;
469             else
470                 return m_client ? m_client->setFailed() : false;
471             GETN(7, GIFGlobalHeader);
472             break;
473         }
474
475         case GIFGlobalHeader: {
476             // This is the height and width of the "screen" or frame into which images are rendered. The
477             // individual images can be smaller than the screen size and located with an origin anywhere
478             // within the screen.
479             m_screenWidth = GETINT16(q);
480             m_screenHeight = GETINT16(q + 2);
481
482             // CALLBACK: Inform the decoderplugin of our size.
483             if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))
484                 return false;
485
486             m_screenBgcolor = q[5];
487             m_globalColormapSize = 2 << (q[4] & 0x07);
488
489             if ((q[4] & 0x80) && m_globalColormapSize > 0) { /* global map */
490                 // Get the global colormap
491                 const unsigned size = 3*m_globalColormapSize;
492
493                 // Malloc the color map, but only if we're not just counting frames.
494                 if (query != GIFImageDecoder::GIFFrameCountQuery)
495                     m_globalColormap = new unsigned char[size];
496
497                 if (len < size) {
498                     // Use 'hold' pattern to get the global colormap
499                     GETN(size, GIFGlobalColormap);
500                     break;
501                 }
502
503                 // Copy everything and go directly to GIFImage_start.
504                 if (m_globalColormap)
505                     memcpy(m_globalColormap, buf, size);
506                 buf += size;
507                 len -= size;
508             }
509
510             GETN(1, GIFImageStart);
511
512             // q[6] = Pixel Aspect Ratio
513             //   Not used
514             //   float aspect = (float)((q[6] + 15) / 64.0);
515             break;
516         }
517
518         case GIFGlobalColormap: {
519             // Everything is already copied into m_globalColormap
520             GETN(1, GIFImageStart);
521             break;
522         }
523
524         case GIFImageStart: {
525             if (*q == ';') { // terminator.
526                 GETN(0, GIFDone);
527                 break;
528             }
529
530             if (*q == '!') { // extension.
531                 GETN(2, GIFExtension);
532                 break;
533             }
534
535             // If we get anything other than ',' (image separator), '!'
536             // (extension), or ';' (trailer), there is extraneous data
537             // between blocks. The GIF87a spec tells us to keep reading
538             // until we find an image separator, but GIF89a says such
539             // a file is corrupt. We follow GIF89a and bail out.
540             if (*q != ',')
541                 return m_client ? m_client->setFailed() : false;
542
543             GETN(9, GIFImageHeader);
544             break;
545         }
546
547         case GIFExtension: {
548             m_count = q[1];
549             GIFState es = GIFSkipBlock;
550
551             // The GIF spec mandates lengths for three of the extensions below.
552             // However, it's possible for GIFs in the wild to deviate. For example,
553             // some GIFs that embed ICC color profiles using GIFApplicationExtension
554             // violate the spec and treat this extension block like a sort of
555             // "extension + data" block, giving a size greater than 11 and filling the
556             // remaining bytes with data (then following with more data blocks as
557             // needed), instead of placing a true data block just after the 11 byte
558             // extension block.
559             //
560             // Accordingly, if the specified length is larger than the required value,
561             // we use it. If it's smaller, then we enforce the spec value, because the
562             // parsers for these extensions expect to have the specified number of
563             // bytes available, and if we don't ensure that, they could read off the
564             // end of the heap buffer. (In this case, it's likely the GIF is corrupt
565             // and we'll soon fail to decode anyway.)
566             switch (*q) {
567             case 0xf9:
568                 es = GIFControlExtension;
569                 m_count = std::max(m_count, 4);
570                 break;
571
572             case 0x01:
573                 // ignoring plain text extension
574                 m_count = std::max(m_count, 12);
575                 break;
576
577             case 0xff:
578                 es = GIFApplicationExtension;
579                 m_count = std::max(m_count, 11);
580                 break;
581
582             case 0xfe:
583                 es = GIFConsumeComment;
584                 break;
585             }
586
587             if (m_count)
588                 GETN(m_count, es);
589             else
590                 GETN(1, GIFImageStart);
591             break;
592         }
593
594         case GIFConsumeBlock: {
595             if (!*q)
596                 GETN(1, GIFImageStart);
597             else
598                 GETN(*q, GIFSkipBlock);
599             break;
600         }
601
602         case GIFSkipBlock: {
603             GETN(1, GIFConsumeBlock);
604             break;
605         }
606
607         case GIFControlExtension: {
608             if (query != GIFImageDecoder::GIFFrameCountQuery) {
609                 if (!m_frameContext)
610                     m_frameContext = new GIFFrameContext();
611             }
612
613             if (m_frameContext) {
614                 if (*q & 0x1) {
615                     m_frameContext->tpixel = q[3];
616                     m_frameContext->isTransparent = true;
617                 } else {
618                     m_frameContext->isTransparent = false;
619                     // ignoring gfx control extension
620                 }
621                 // NOTE: This relies on the values in the FrameDisposalMethod enum
622                 // matching those in the GIF spec!
623                 int disposalMethod = ((*q) >> 2) & 0x7;
624                 m_frameContext->disposalMethod = (WebCore::ImageFrame::FrameDisposalMethod)disposalMethod;
625
626                 // Some specs say 3rd bit (value 4), other specs say value 3
627                 // Let's choose 3 (the more popular)
628                 if (disposalMethod == 4)
629                     m_frameContext->disposalMethod = WebCore::ImageFrame::DisposeOverwritePrevious;
630                 m_frameContext->delayTime = GETINT16(q + 1) * 10;
631             }
632             GETN(1, GIFConsumeBlock);
633             break;
634         }
635
636         case GIFCommentExtension: {
637             if (*q)
638                 GETN(*q, GIFConsumeComment);
639             else
640                 GETN(1, GIFImageStart);
641             break;
642         }
643
644         case GIFConsumeComment: {
645             GETN(1, GIFCommentExtension);
646             break;
647         }
648
649         case GIFApplicationExtension: {
650             // Check for netscape application extension.
651             if (!strncmp((char*)q, "NETSCAPE2.0", 11) || !strncmp((char*)q, "ANIMEXTS1.0", 11))
652                 GETN(1, GIFNetscapeExtensionBlock);
653             else
654                 GETN(1, GIFConsumeBlock);
655             break;
656         }
657
658         // Netscape-specific GIF extension: animation looping.
659         case GIFNetscapeExtensionBlock: {
660             if (*q)
661                 GETN(*q, GIFConsumeNetscapeExtension);
662             else
663                 GETN(1, GIFImageStart);
664             break;
665         }
666
667         // Parse netscape-specific application extensions
668         case GIFConsumeNetscapeExtension: {
669             int netscapeExtension = q[0] & 7;
670
671             // Loop entire animation specified # of times. Only read the loop count during the first iteration.
672             if (netscapeExtension == 1) {
673                 m_loopCount = GETINT16(q + 1);
674
675                 // Zero loop count is infinite animation loop request.
676                 if (!m_loopCount)
677                     m_loopCount = WebCore::cAnimationLoopInfinite;
678
679                 GETN(1, GIFNetscapeExtensionBlock);
680             } else if (netscapeExtension == 2) {
681                 // Wait for specified # of bytes to enter buffer.
682
683                 // Don't do this, this extension doesn't exist (isn't used at all)
684                 // and doesn't do anything, as our streaming/buffering takes care of it all...
685                 // See: http://semmix.pl/color/exgraf/eeg24.htm
686                 GETN(1, GIFNetscapeExtensionBlock);
687             } else {
688                 // 0,3-7 are yet to be defined netscape extension codes
689                 return m_client ? m_client->setFailed() : false;
690             }
691             break;
692         }
693
694         case GIFImageHeader: {
695             unsigned height, width, xOffset, yOffset;
696
697             /* Get image offsets, with respect to the screen origin */
698             xOffset = GETINT16(q);
699             yOffset = GETINT16(q + 2);
700
701             /* Get image width and height. */
702             width  = GETINT16(q + 4);
703             height = GETINT16(q + 6);
704
705             /* Work around broken GIF files where the logical screen
706              * size has weird width or height.  We assume that GIF87a
707              * files don't contain animations.
708              */
709             if (!m_imagesDecoded
710                 && ((m_screenHeight < height) || (m_screenWidth < width) || (m_version == 87))) {
711                 m_screenHeight = height;
712                 m_screenWidth = width;
713                 xOffset = 0;
714                 yOffset = 0;
715
716                 // CALLBACK: Inform the decoderplugin of our size.
717                 if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))
718                     return false;
719             }
720
721             // Work around more broken GIF files that have zero image width or height
722             if (!height || !width) {
723                 height = m_screenHeight;
724                 width = m_screenWidth;
725                 if (!height || !width)
726                     return m_client ? m_client->setFailed() : false;
727             }
728
729             if (query == GIFImageDecoder::GIFSizeQuery || haltAtFrame == m_imagesDecoded) {
730                 // The decoder needs to stop. Hand back the number of bytes we consumed from
731                 // buffer minus 9 (the amount we consumed to read the header).
732                 if (m_client)
733                     m_client->decodingHalted(len + 9);
734                 GETN(9, GIFImageHeader);
735                 return true;
736             }
737
738             m_imagesCount = m_imagesDecoded + 1;
739
740             if (query == GIFImageDecoder::GIFFullQuery && !m_frameContext)
741                 m_frameContext = new GIFFrameContext();
742
743             if (m_frameContext) {
744                 m_frameContext->xOffset = xOffset;
745                 m_frameContext->yOffset = yOffset;
746                 m_frameContext->height = height;
747                 m_frameContext->width = width;
748
749                 /* This case will never be taken if this is the first image */
750                 /* being decoded. If any of the later images are larger     */
751                 /* than the screen size, we need to reallocate buffers.     */
752                 if (m_screenWidth < width) {
753                     /* XXX Deviant! */
754                     delete []m_frameContext->rowbuf;
755                     m_screenWidth = width;
756                     m_frameContext->rowbuf = new unsigned char[m_screenWidth];
757                 } else if (!m_frameContext->rowbuf)
758                     m_frameContext->rowbuf = new unsigned char[m_screenWidth];
759
760                 if (!m_frameContext->rowbuf)
761                     return m_client ? m_client->setFailed() : false;
762                 if (m_screenHeight < height)
763                     m_screenHeight = height;
764
765                 if (q[8] & 0x40) {
766                     m_frameContext->interlaced = true;
767                     m_frameContext->ipass = 1;
768                 } else {
769                     m_frameContext->interlaced = false;
770                     m_frameContext->ipass = 0;
771                 }
772
773                 if (!m_imagesDecoded)
774                     m_frameContext->progressiveDisplay = true;
775                 else {
776                     // Overlaying interlaced, transparent GIFs over
777                     // existing image data using the Haeberli display hack
778                     // requires saving the underlying image in order to
779                     // avoid jaggies at the transparency edges. We are
780                     // unprepared to deal with that, so don't display such
781                     // images progressively
782                     m_frameContext->progressiveDisplay = false;
783                 }
784
785                 // Clear state from last image.
786                 m_frameContext->irow = 0;
787                 m_frameContext->rowsRemaining = m_frameContext->height;
788                 m_frameContext->rowend = m_frameContext->rowbuf + m_frameContext->width;
789                 m_frameContext->rowp = m_frameContext->rowbuf;
790
791                 // bits per pixel is q[8]&0x07
792             }
793
794             // has a local colormap?
795             if (q[8] & 0x80) {
796                 int numColors = 2 << (q[8] & 0x7);
797                 const unsigned size = 3 * numColors;
798                 unsigned char *map = m_frameContext ? m_frameContext->localColormap : 0;
799                 if (m_frameContext && (!map || (numColors > m_frameContext->localColormapSize))) {
800                     delete []map;
801                     map = new unsigned char[size];
802                     if (!map)
803                         return m_client ? m_client->setFailed() : false;
804                 }
805
806                 // Switch to the new local palette after it loads
807                 if (m_frameContext) {
808                     m_frameContext->localColormap = map;
809                     m_frameContext->localColormapSize = numColors;
810                     m_frameContext->isLocalColormapDefined = true;
811                 }
812
813                 if (len < size) {
814                     // Use 'hold' pattern to get the image colormap
815                     GETN(size, GIFImageColormap);
816                     break;
817                 }
818
819                 // Copy everything and directly go to GIFLZWStart
820                 if (m_frameContext)
821                     memcpy(m_frameContext->localColormap, buf, size);
822                 buf += size;
823                 len -= size;
824             } else if (m_frameContext) {
825                 // Switch back to the global palette
826                 m_frameContext->isLocalColormapDefined = false;
827             }
828             GETN(1, GIFLZWStart);
829             break;
830         }
831
832         case GIFImageColormap: {
833             // Everything is already copied into localColormap
834             GETN(1, GIFLZWStart);
835             break;
836         }
837
838         case GIFSubBlock: {
839             // Still working on the same image: Process next LZW data block.
840             if ((m_count = *q)) {
841                 // Make sure there are still rows left. If the GIF data
842                 // is corrupt, we may not get an explicit terminator.
843                 if (m_frameContext && !m_frameContext->rowsRemaining) {
844                     // This is an illegal GIF, but we remain tolerant.
845                     GETN(1, GIFSubBlock);
846                 }
847                 GETN(m_count, GIFLZW);
848             } else {
849                 // See if there are any more images in this sequence.
850                 m_imagesDecoded++;
851
852                 // CALLBACK: The frame is now complete.
853                 if (m_client && m_frameContext && !m_client->frameComplete(m_imagesDecoded - 1, m_frameContext->delayTime, m_frameContext->disposalMethod))
854                     return false; // frameComplete() has already called m_client->setFailed().
855
856                 // Clear state from this image
857                 if (m_frameContext) {
858                     m_frameContext->isLocalColormapDefined = false;
859                     m_frameContext->isTransparent = false;
860                 }
861
862                 GETN(1, GIFImageStart);
863             }
864             break;
865         }
866
867         case GIFDone: {
868             // When the GIF is done, we can stop.
869             if (m_client)
870                 m_client->gifComplete();
871             return true;
872         }
873
874         default:
875             // We shouldn't ever get here.
876             break;
877         }
878     }
879
880     // Copy the leftover into m_frameContext->m_hold
881     m_bytesInHold = len;
882     if (len) {
883         // Add what we have sofar to the block
884         unsigned char* p;
885         if (m_state == GIFGlobalColormap)
886             p = m_globalColormap;
887         else if (m_state == GIFImageColormap)
888             p = m_frameContext ? m_frameContext->localColormap : 0;
889         else
890             p = m_hold;
891         if (p)
892             memcpy(p, buf, len);
893         m_bytesToConsume -= len;
894     }
895
896     if (m_client)
897         m_client->decodingHalted(0);
898     return false;
899 }