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