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 (at) 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 } 926