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)