cce069fe2c4914407808f5afc4f251b3a4841c73
[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* block, size_t bytesInBlock)
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     size_t cnt = bytesInBlock;
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 = block; 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_frameContext->oldcode = oldcode;
348     m_frameContext->firstchar = firstchar;
349     m_frameContext->datum = datum;
350     m_frameContext->stackp = stackp;
351     m_frameContext->rowp = rowp;
352     m_frameContext->rowsRemaining = rowsRemaining;
353     return true;
354 }
355
356 bool GIFImageReader::decode(GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
357 {
358     ASSERT(m_bytesRead <= m_data->size());
359     return decodeInternal(m_bytesRead, m_data->size() - m_bytesRead, query, haltAtFrame);
360 }
361
362 // Process data arriving from the stream for the gif decoder.
363 bool GIFImageReader::decodeInternal(size_t dataPosition, size_t len, GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
364 {
365     if (!len) {
366         // No new data has come in since the last call, just ignore this call.
367         return true;
368     }
369
370     if (len < m_bytesToConsume)
371         return false;
372
373     // This loop reads as many components from |m_data| as possible.
374     // At the beginning of each iteration, dataPosition will be advanced by m_bytesToConsume to
375     // point to the next component. len will be decremented accordingly.
376     while (len >= m_bytesToConsume) {
377         // FIXME: Rename this variable to currentComponent.
378         const unsigned char* q = data(dataPosition);
379
380         // Mark the current component as consumed. Note that q will remain pointed at this
381         // component until the next loop iteration.
382         dataPosition += m_bytesToConsume;
383         len -= m_bytesToConsume;
384
385         switch (m_state) {
386         case GIFLZW:
387             // m_bytesToConsume is the current component size because it hasn't been updated.
388             if (!doLZW(q, m_bytesToConsume))
389                 return false; // If doLZW() encountered an error, it has already called m_client->setFailed().
390             GETN(1, GIFSubBlock);
391             break;
392
393         case GIFLZWStart: {
394             // Initialize LZW parser/decoder.
395             int datasize = *q;
396
397             // Since we use a codesize of 1 more than the datasize, we need to ensure
398             // that our datasize is strictly less than the MAX_LZW_BITS value (12).
399             // This sets the largest possible codemask correctly at 4095.
400             if (datasize >= MAX_LZW_BITS)
401                 return m_client ? m_client->setFailed() : false;
402             int clearCode = 1 << datasize;
403             if (clearCode >= MAX_BITS)
404                 return m_client ? m_client->setFailed() : false;
405
406             if (m_frameContext) {
407                 m_frameContext->datasize = datasize;
408                 m_frameContext->clearCode = clearCode;
409                 m_frameContext->avail = m_frameContext->clearCode + 2;
410                 m_frameContext->oldcode = -1;
411                 m_frameContext->codesize = m_frameContext->datasize + 1;
412                 m_frameContext->codemask = (1 << m_frameContext->codesize) - 1;
413                 m_frameContext->datum = m_frameContext->bits = 0;
414
415                 // Init the tables.
416                 if (!m_frameContext->suffix)
417                     m_frameContext->suffix = new unsigned char[MAX_BITS];
418
419                 // Clearing the whole suffix table lets us be more tolerant of bad data.
420                 memset(m_frameContext->suffix, 0, MAX_BITS);
421                 for (int i = 0; i < m_frameContext->clearCode; i++)
422                     m_frameContext->suffix[i] = i;
423
424                 if (!m_frameContext->stack)
425                     m_frameContext->stack = new unsigned char[MAX_BITS];
426                 m_frameContext->stackp = m_frameContext->stack;
427             }
428
429             GETN(1, GIFSubBlock);
430             break;
431         }
432
433         case GIFType: {
434             // All GIF files begin with "GIF87a" or "GIF89a".
435             if (!strncmp((char*)q, "GIF89a", 6))
436                 m_version = 89;
437             else if (!strncmp((char*)q, "GIF87a", 6))
438                 m_version = 87;
439             else
440                 return m_client ? m_client->setFailed() : false;
441             GETN(7, GIFGlobalHeader);
442             break;
443         }
444
445         case GIFGlobalHeader: {
446             // This is the height and width of the "screen" or frame into which images are rendered. The
447             // individual images can be smaller than the screen size and located with an origin anywhere
448             // within the screen.
449             m_screenWidth = GETINT16(q);
450             m_screenHeight = GETINT16(q + 2);
451
452             // CALLBACK: Inform the decoderplugin of our size.
453             if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))
454                 return false;
455
456             m_screenBgcolor = q[5];
457             m_globalColormapSize = 2 << (q[4] & 0x07);
458
459             if ((q[4] & 0x80) && m_globalColormapSize > 0) { /* global map */
460                 // Get the global colormap
461                 const size_t globalColormapBytes = 3 * m_globalColormapSize;
462                 m_globalColormapPosition = dataPosition;
463
464                 if (len < globalColormapBytes) {
465                     // Wait until we have enough bytes to consume the entire colormap at once.
466                     GETN(globalColormapBytes, GIFGlobalColormap);
467                     break;
468                 }
469
470                 m_isGlobalColormapDefined = true;
471                 dataPosition += globalColormapBytes;
472                 len -= globalColormapBytes;
473             }
474
475             GETN(1, GIFImageStart);
476
477             // q[6] = Pixel Aspect Ratio
478             //   Not used
479             //   float aspect = (float)((q[6] + 15) / 64.0);
480             break;
481         }
482
483         case GIFGlobalColormap: {
484             m_isGlobalColormapDefined = true;
485             GETN(1, GIFImageStart);
486             break;
487         }
488
489         case GIFImageStart: {
490             if (*q == ';') { // terminator.
491                 GETN(0, GIFDone);
492                 break;
493             }
494
495             if (*q == '!') { // extension.
496                 GETN(2, GIFExtension);
497                 break;
498             }
499
500             // If we get anything other than ',' (image separator), '!'
501             // (extension), or ';' (trailer), there is extraneous data
502             // between blocks. The GIF87a spec tells us to keep reading
503             // until we find an image separator, but GIF89a says such
504             // a file is corrupt. We follow GIF89a and bail out.
505             if (*q != ',')
506                 return m_client ? m_client->setFailed() : false;
507
508             GETN(9, GIFImageHeader);
509             break;
510         }
511
512         case GIFExtension: {
513             size_t bytesInBlock = q[1];
514             GIFState es = GIFSkipBlock;
515
516             // The GIF spec mandates lengths for three of the extensions below.
517             // However, it's possible for GIFs in the wild to deviate. For example,
518             // some GIFs that embed ICC color profiles using GIFApplicationExtension
519             // violate the spec and treat this extension block like a sort of
520             // "extension + data" block, giving a size greater than 11 and filling the
521             // remaining bytes with data (then following with more data blocks as
522             // needed), instead of placing a true data block just after the 11 byte
523             // extension block.
524             //
525             // Accordingly, if the specified length is larger than the required value,
526             // we use it. If it's smaller, then we enforce the spec value, because the
527             // parsers for these extensions expect to have the specified number of
528             // bytes available, and if we don't ensure that, they could read off the
529             // end of the heap buffer. (In this case, it's likely the GIF is corrupt
530             // and we'll soon fail to decode anyway.)
531             switch (*q) {
532             case 0xf9:
533                 es = GIFControlExtension;
534                 bytesInBlock = std::max(bytesInBlock, static_cast<size_t>(4));
535                 break;
536
537             case 0x01:
538                 // ignoring plain text extension
539                 bytesInBlock = std::max(bytesInBlock, static_cast<size_t>(12));
540                 break;
541
542             case 0xff:
543                 es = GIFApplicationExtension;
544                 bytesInBlock = std::max(bytesInBlock, static_cast<size_t>(11));
545                 break;
546
547             case 0xfe:
548                 es = GIFConsumeComment;
549                 break;
550             }
551
552             if (bytesInBlock)
553                 GETN(bytesInBlock, es);
554             else
555                 GETN(1, GIFImageStart);
556             break;
557         }
558
559         case GIFConsumeBlock: {
560             if (!*q)
561                 GETN(1, GIFImageStart);
562             else
563                 GETN(*q, GIFSkipBlock);
564             break;
565         }
566
567         case GIFSkipBlock: {
568             GETN(1, GIFConsumeBlock);
569             break;
570         }
571
572         case GIFControlExtension: {
573             if (query != GIFImageDecoder::GIFFrameCountQuery) {
574                 if (!m_frameContext)
575                     m_frameContext = new GIFFrameContext();
576             }
577
578             if (m_frameContext) {
579                 if (*q & 0x1) {
580                     m_frameContext->tpixel = q[3];
581                     m_frameContext->isTransparent = true;
582                 } else {
583                     m_frameContext->isTransparent = false;
584                     // ignoring gfx control extension
585                 }
586                 // NOTE: This relies on the values in the FrameDisposalMethod enum
587                 // matching those in the GIF spec!
588                 int disposalMethod = ((*q) >> 2) & 0x7;
589                 m_frameContext->disposalMethod = (WebCore::ImageFrame::FrameDisposalMethod)disposalMethod;
590
591                 // Some specs say 3rd bit (value 4), other specs say value 3
592                 // Let's choose 3 (the more popular)
593                 if (disposalMethod == 4)
594                     m_frameContext->disposalMethod = WebCore::ImageFrame::DisposeOverwritePrevious;
595                 m_frameContext->delayTime = GETINT16(q + 1) * 10;
596             }
597             GETN(1, GIFConsumeBlock);
598             break;
599         }
600
601         case GIFCommentExtension: {
602             if (*q)
603                 GETN(*q, GIFConsumeComment);
604             else
605                 GETN(1, GIFImageStart);
606             break;
607         }
608
609         case GIFConsumeComment: {
610             GETN(1, GIFCommentExtension);
611             break;
612         }
613
614         case GIFApplicationExtension: {
615             // Check for netscape application extension.
616             if (!strncmp((char*)q, "NETSCAPE2.0", 11) || !strncmp((char*)q, "ANIMEXTS1.0", 11))
617                 GETN(1, GIFNetscapeExtensionBlock);
618             else
619                 GETN(1, GIFConsumeBlock);
620             break;
621         }
622
623         // Netscape-specific GIF extension: animation looping.
624         case GIFNetscapeExtensionBlock: {
625             if (*q)
626                 GETN(*q, GIFConsumeNetscapeExtension);
627             else
628                 GETN(1, GIFImageStart);
629             break;
630         }
631
632         // Parse netscape-specific application extensions
633         case GIFConsumeNetscapeExtension: {
634             int netscapeExtension = q[0] & 7;
635
636             // Loop entire animation specified # of times. Only read the loop count during the first iteration.
637             if (netscapeExtension == 1) {
638                 m_loopCount = GETINT16(q + 1);
639
640                 // Zero loop count is infinite animation loop request.
641                 if (!m_loopCount)
642                     m_loopCount = WebCore::cAnimationLoopInfinite;
643
644                 GETN(1, GIFNetscapeExtensionBlock);
645             } else if (netscapeExtension == 2) {
646                 // Wait for specified # of bytes to enter buffer.
647
648                 // Don't do this, this extension doesn't exist (isn't used at all)
649                 // and doesn't do anything, as our streaming/buffering takes care of it all...
650                 // See: http://semmix.pl/color/exgraf/eeg24.htm
651                 GETN(1, GIFNetscapeExtensionBlock);
652             } else {
653                 // 0,3-7 are yet to be defined netscape extension codes
654                 return m_client ? m_client->setFailed() : false;
655             }
656             break;
657         }
658
659         case GIFImageHeader: {
660             unsigned height, width, xOffset, yOffset;
661
662             /* Get image offsets, with respect to the screen origin */
663             xOffset = GETINT16(q);
664             yOffset = GETINT16(q + 2);
665
666             /* Get image width and height. */
667             width  = GETINT16(q + 4);
668             height = GETINT16(q + 6);
669
670             /* Work around broken GIF files where the logical screen
671              * size has weird width or height.  We assume that GIF87a
672              * files don't contain animations.
673              */
674             if (!m_imagesDecoded
675                 && ((m_screenHeight < height) || (m_screenWidth < width) || (m_version == 87))) {
676                 m_screenHeight = height;
677                 m_screenWidth = width;
678                 xOffset = 0;
679                 yOffset = 0;
680
681                 // CALLBACK: Inform the decoderplugin of our size.
682                 if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))
683                     return false;
684             }
685
686             // Work around more broken GIF files that have zero image width or height
687             if (!height || !width) {
688                 height = m_screenHeight;
689                 width = m_screenWidth;
690                 if (!height || !width)
691                     return m_client ? m_client->setFailed() : false;
692             }
693
694             if (query == GIFImageDecoder::GIFSizeQuery || haltAtFrame == m_imagesDecoded) {
695                 // The decoder needs to stop. Hand back the number of bytes we consumed from
696                 // buffer minus 9 (the amount we consumed to read the header).
697                 setRemainingBytes(len + 9);
698                 GETN(9, GIFImageHeader);
699                 return true;
700             }
701
702             m_imagesCount = m_imagesDecoded + 1;
703
704             if (query == GIFImageDecoder::GIFFullQuery && !m_frameContext)
705                 m_frameContext = new GIFFrameContext();
706
707             if (m_frameContext) {
708                 m_frameContext->xOffset = xOffset;
709                 m_frameContext->yOffset = yOffset;
710                 m_frameContext->height = height;
711                 m_frameContext->width = width;
712
713                 /* This case will never be taken if this is the first image */
714                 /* being decoded. If any of the later images are larger     */
715                 /* than the screen size, we need to reallocate buffers.     */
716                 if (m_screenWidth < width) {
717                     /* XXX Deviant! */
718                     delete []m_frameContext->rowbuf;
719                     m_screenWidth = width;
720                     m_frameContext->rowbuf = new unsigned char[m_screenWidth];
721                 } else if (!m_frameContext->rowbuf)
722                     m_frameContext->rowbuf = new unsigned char[m_screenWidth];
723
724                 if (!m_frameContext->rowbuf)
725                     return m_client ? m_client->setFailed() : false;
726                 if (m_screenHeight < height)
727                     m_screenHeight = height;
728
729                 if (q[8] & 0x40) {
730                     m_frameContext->interlaced = true;
731                     m_frameContext->ipass = 1;
732                 } else {
733                     m_frameContext->interlaced = false;
734                     m_frameContext->ipass = 0;
735                 }
736
737                 if (!m_imagesDecoded)
738                     m_frameContext->progressiveDisplay = true;
739                 else {
740                     // Overlaying interlaced, transparent GIFs over
741                     // existing image data using the Haeberli display hack
742                     // requires saving the underlying image in order to
743                     // avoid jaggies at the transparency edges. We are
744                     // unprepared to deal with that, so don't display such
745                     // images progressively
746                     m_frameContext->progressiveDisplay = false;
747                 }
748
749                 // Clear state from last image.
750                 m_frameContext->irow = 0;
751                 m_frameContext->rowsRemaining = m_frameContext->height;
752                 m_frameContext->rowend = m_frameContext->rowbuf + m_frameContext->width;
753                 m_frameContext->rowp = m_frameContext->rowbuf;
754
755                 // bits per pixel is q[8]&0x07
756             }
757
758             // has a local colormap?
759             if (q[8] & 0x80) {
760                 int numColors = 2 << (q[8] & 0x7);
761                 const size_t localColormapBytes = 3 * numColors;
762
763                 // Switch to the new local palette after it loads
764                 if (m_frameContext) {
765                     m_frameContext->localColormapPosition = dataPosition;
766                     m_frameContext->localColormapSize = numColors;
767                 }
768
769                 if (len < localColormapBytes) {
770                     // Wait until we have enough bytes to consume the entire colormap at once.
771                     GETN(localColormapBytes, GIFImageColormap);
772                     break;
773                 }
774
775                 if (m_frameContext)
776                     m_frameContext->isLocalColormapDefined = true;
777                 dataPosition += localColormapBytes;
778                 len -= localColormapBytes;
779             } else if (m_frameContext) {
780                 // Switch back to the global palette
781                 m_frameContext->isLocalColormapDefined = false;
782             }
783             GETN(1, GIFLZWStart);
784             break;
785         }
786
787         case GIFImageColormap: {
788             if (m_frameContext)
789                 m_frameContext->isLocalColormapDefined = true;
790             GETN(1, GIFLZWStart);
791             break;
792         }
793
794         case GIFSubBlock: {
795             // Still working on the same image: Process next LZW data block.
796             const size_t bytesInBlock = *q;
797             if (bytesInBlock) {
798                 // Make sure there are still rows left. If the GIF data
799                 // is corrupt, we may not get an explicit terminator.
800                 if (m_frameContext && !m_frameContext->rowsRemaining) {
801                     // This is an illegal GIF, but we remain tolerant.
802                     GETN(1, GIFSubBlock);
803                 }
804                 GETN(bytesInBlock, GIFLZW);
805             } else {
806                 // See if there are any more images in this sequence.
807                 m_imagesDecoded++;
808
809                 // CALLBACK: The frame is now complete.
810                 if (m_client && m_frameContext && !m_client->frameComplete(m_imagesDecoded - 1, m_frameContext->delayTime, m_frameContext->disposalMethod))
811                     return false; // frameComplete() has already called m_client->setFailed().
812
813                 // Clear state from this image
814                 if (m_frameContext) {
815                     m_frameContext->isLocalColormapDefined = false;
816                     m_frameContext->isTransparent = false;
817                 }
818
819                 GETN(1, GIFImageStart);
820             }
821             break;
822         }
823
824         case GIFDone: {
825             // When the GIF is done, we can stop.
826             if (m_client)
827                 m_client->gifComplete();
828             return true;
829         }
830
831         default:
832             // We shouldn't ever get here.
833             break;
834         }
835     }
836
837     setRemainingBytes(len);
838     return false;
839 }
840
841 void GIFImageReader::setRemainingBytes(size_t remainingBytes)
842 {
843     ASSERT(remainingBytes <= m_data->size());
844     m_bytesRead = m_data->size() - remainingBytes;
845 }