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 "SkGifImageReader.h" 76 #include "SkColorPriv.h" 77 #include "SkGifCodec.h" 78 79 #include <algorithm> 80 #include <string.h> 81 82 83 // GETN(n, s) requests at least 'n' bytes available from 'q', at start of state 's'. 84 // 85 // Note, the hold will never need to be bigger than 256 bytes to gather up in the hold, 86 // as each GIF block (except colormaps) can never be bigger than 256 bytes. 87 // Colormaps are directly copied in the resp. global_colormap or dynamically allocated local_colormap. 88 // So a fixed buffer in SkGifImageReader is good enough. 89 // This buffer is only needed to copy left-over data from one GifWrite call to the next 90 #define GETN(n, s) \ 91 do { \ 92 m_bytesToConsume = (n); \ 93 m_state = (s); \ 94 } while (0) 95 96 // Get a 16-bit value stored in little-endian format. 97 #define GETINT16(p) ((p)[1]<<8|(p)[0]) 98 99 namespace { 100 bool is_palette_index_valid(int transparentIndex) { 101 // -1 is a signal that there is no transparent index. 102 // Otherwise, it is encoded in 8 bits, and all 256 values are considered 103 // valid since a GIF may use an index outside of the palette to be 104 // transparent. 105 return transparentIndex >= 0; 106 } 107 } // anonymous namespace 108 109 // Send the data to the display front-end. 110 void SkGIFLZWContext::outputRow(const unsigned char* rowBegin) 111 { 112 int drowStart = irow; 113 int drowEnd = irow; 114 115 // Haeberli-inspired hack for interlaced GIFs: Replicate lines while 116 // displaying to diminish the "venetian-blind" effect as the image is 117 // loaded. Adjust pixel vertical positions to avoid the appearance of the 118 // image crawling up the screen as successive passes are drawn. 119 if (m_frameContext->progressiveDisplay() && m_frameContext->interlaced() && ipass < 4) { 120 unsigned rowDup = 0; 121 unsigned rowShift = 0; 122 123 switch (ipass) { 124 case 1: 125 rowDup = 7; 126 rowShift = 3; 127 break; 128 case 2: 129 rowDup = 3; 130 rowShift = 1; 131 break; 132 case 3: 133 rowDup = 1; 134 rowShift = 0; 135 break; 136 default: 137 break; 138 } 139 140 drowStart -= rowShift; 141 drowEnd = drowStart + rowDup; 142 143 // Extend if bottom edge isn't covered because of the shift upward. 144 if ((unsigned)((m_frameContext->height() - 1) - drowEnd) <= rowShift) 145 drowEnd = m_frameContext->height() - 1; 146 147 // Clamp first and last rows to upper and lower edge of image. 148 if (drowStart < 0) 149 drowStart = 0; 150 151 if (drowEnd >= m_frameContext->height()) 152 drowEnd = m_frameContext->height() - 1; 153 } 154 155 // Protect against too much image data. 156 if (drowStart >= m_frameContext->height()) 157 return; 158 159 // CALLBACK: Let the client know we have decoded a row. 160 const bool writeTransparentPixels = 161 SkCodec::kNoFrame == m_frameContext->getRequiredFrame(); 162 m_client->haveDecodedRow(m_frameContext->frameId(), rowBegin, 163 drowStart, drowEnd - drowStart + 1, writeTransparentPixels); 164 165 if (!m_frameContext->interlaced()) 166 irow++; 167 else { 168 do { 169 switch (ipass) { 170 case 1: 171 irow += 8; 172 if (irow >= (unsigned) m_frameContext->height()) { 173 ipass++; 174 irow = 4; 175 } 176 break; 177 178 case 2: 179 irow += 8; 180 if (irow >= (unsigned) m_frameContext->height()) { 181 ipass++; 182 irow = 2; 183 } 184 break; 185 186 case 3: 187 irow += 4; 188 if (irow >= (unsigned) m_frameContext->height()) { 189 ipass++; 190 irow = 1; 191 } 192 break; 193 194 case 4: 195 irow += 2; 196 if (irow >= (unsigned) m_frameContext->height()) { 197 ipass++; 198 irow = 0; 199 } 200 break; 201 202 default: 203 break; 204 } 205 } while (irow > (unsigned) (m_frameContext->height() - 1)); 206 } 207 } 208 209 // Perform Lempel-Ziv-Welch decoding. 210 // Returns true if decoding was successful. In this case the block will have been completely consumed and/or rowsRemaining will be 0. 211 // Otherwise, decoding failed; returns false in this case, which will always cause the SkGifImageReader to set the "decode failed" flag. 212 bool SkGIFLZWContext::doLZW(const unsigned char* block, size_t bytesInBlock) 213 { 214 const int width = m_frameContext->width(); 215 216 if (rowIter == rowBuffer.end()) 217 return true; 218 219 for (const unsigned char* ch = block; bytesInBlock-- > 0; ch++) { 220 // Feed the next byte into the decoder's 32-bit input buffer. 221 datum += ((int) *ch) << bits; 222 bits += 8; 223 224 // Check for underflow of decoder's 32-bit input buffer. 225 while (bits >= codesize) { 226 // Get the leading variable-length symbol from the data stream. 227 int code = datum & codemask; 228 datum >>= codesize; 229 bits -= codesize; 230 231 // Reset the dictionary to its original state, if requested. 232 if (code == clearCode) { 233 codesize = m_frameContext->dataSize() + 1; 234 codemask = (1 << codesize) - 1; 235 avail = clearCode + 2; 236 oldcode = -1; 237 continue; 238 } 239 240 // Check for explicit end-of-stream code. 241 if (code == (clearCode + 1)) { 242 // end-of-stream should only appear after all image data. 243 if (!rowsRemaining) 244 return true; 245 return false; 246 } 247 248 const int tempCode = code; 249 unsigned short codeLength = 0; 250 if (code < avail) { 251 // This is a pre-existing code, so we already know what it 252 // encodes. 253 codeLength = suffixLength[code]; 254 rowIter += codeLength; 255 } else if (code == avail && oldcode != -1) { 256 // This is a new code just being added to the dictionary. 257 // It must encode the contents of the previous code, plus 258 // the first character of the previous code again. 259 codeLength = suffixLength[oldcode] + 1; 260 rowIter += codeLength; 261 *--rowIter = firstchar; 262 code = oldcode; 263 } else { 264 // This is an invalid code. The dictionary is just initialized 265 // and the code is incomplete. We don't know how to handle 266 // this case. 267 return false; 268 } 269 270 while (code >= clearCode) { 271 *--rowIter = suffix[code]; 272 code = prefix[code]; 273 } 274 275 *--rowIter = firstchar = suffix[code]; 276 277 // Define a new codeword in the dictionary as long as we've read 278 // more than one value from the stream. 279 if (avail < SK_MAX_DICTIONARY_ENTRIES && oldcode != -1) { 280 prefix[avail] = oldcode; 281 suffix[avail] = firstchar; 282 suffixLength[avail] = suffixLength[oldcode] + 1; 283 ++avail; 284 285 // If we've used up all the codewords of a given length 286 // increase the length of codewords by one bit, but don't 287 // exceed the specified maximum codeword size. 288 if (!(avail & codemask) && avail < SK_MAX_DICTIONARY_ENTRIES) { 289 ++codesize; 290 codemask += avail; 291 } 292 } 293 oldcode = tempCode; 294 rowIter += codeLength; 295 296 // Output as many rows as possible. 297 unsigned char* rowBegin = rowBuffer.begin(); 298 for (; rowBegin + width <= rowIter; rowBegin += width) { 299 outputRow(rowBegin); 300 rowsRemaining--; 301 if (!rowsRemaining) 302 return true; 303 } 304 305 if (rowBegin != rowBuffer.begin()) { 306 // Move the remaining bytes to the beginning of the buffer. 307 const size_t bytesToCopy = rowIter - rowBegin; 308 memcpy(&rowBuffer.front(), rowBegin, bytesToCopy); 309 rowIter = rowBuffer.begin() + bytesToCopy; 310 } 311 } 312 } 313 return true; 314 } 315 316 sk_sp<SkColorTable> SkGIFColorMap::buildTable(SkStreamBuffer* streamBuffer, SkColorType colorType, 317 int transparentPixel) const 318 { 319 if (!m_isDefined) 320 return nullptr; 321 322 const PackColorProc proc = choose_pack_color_proc(false, colorType); 323 if (m_table && proc == m_packColorProc && m_transPixel == transparentPixel) { 324 SkASSERT(transparentPixel == kNotFound || transparentPixel > m_table->count() 325 || m_table->operator[](transparentPixel) == SK_ColorTRANSPARENT); 326 // This SkColorTable has already been built with the same transparent color and 327 // packing proc. Reuse it. 328 return m_table; 329 } 330 m_packColorProc = proc; 331 m_transPixel = transparentPixel; 332 333 const size_t bytes = m_colors * SK_BYTES_PER_COLORMAP_ENTRY; 334 sk_sp<SkData> rawData(streamBuffer->getDataAtPosition(m_position, bytes)); 335 if (!rawData) { 336 return nullptr; 337 } 338 339 SkASSERT(m_colors <= SK_MAX_COLORS); 340 const uint8_t* srcColormap = rawData->bytes(); 341 SkPMColor colorStorage[SK_MAX_COLORS]; 342 for (int i = 0; i < m_colors; i++) { 343 if (i == transparentPixel) { 344 colorStorage[i] = SK_ColorTRANSPARENT; 345 } else { 346 colorStorage[i] = proc(255, srcColormap[0], srcColormap[1], srcColormap[2]); 347 } 348 srcColormap += SK_BYTES_PER_COLORMAP_ENTRY; 349 } 350 for (int i = m_colors; i < SK_MAX_COLORS; i++) { 351 colorStorage[i] = SK_ColorTRANSPARENT; 352 } 353 m_table = sk_sp<SkColorTable>(new SkColorTable(colorStorage, SK_MAX_COLORS)); 354 return m_table; 355 } 356 357 sk_sp<SkColorTable> SkGifImageReader::getColorTable(SkColorType colorType, int index) { 358 if (index < 0 || index >= m_frames.count()) { 359 return nullptr; 360 } 361 362 const SkGIFFrameContext* frameContext = m_frames[index].get(); 363 const SkGIFColorMap& localColorMap = frameContext->localColorMap(); 364 const int transPix = frameContext->transparentPixel(); 365 if (localColorMap.isDefined()) { 366 return localColorMap.buildTable(&m_streamBuffer, colorType, transPix); 367 } 368 if (m_globalColorMap.isDefined()) { 369 return m_globalColorMap.buildTable(&m_streamBuffer, colorType, transPix); 370 } 371 return nullptr; 372 } 373 374 // Perform decoding for this frame. frameComplete will be true if the entire frame is decoded. 375 // Returns false if a decoding error occurred. This is a fatal error and causes the SkGifImageReader to set the "decode failed" flag. 376 // Otherwise, either not enough data is available to decode further than before, or the new data has been decoded successfully; returns true in this case. 377 bool SkGIFFrameContext::decode(SkStreamBuffer* streamBuffer, SkGifCodec* client, 378 bool* frameComplete) 379 { 380 *frameComplete = false; 381 if (!m_lzwContext) { 382 // Wait for more data to properly initialize SkGIFLZWContext. 383 if (!isDataSizeDefined() || !isHeaderDefined()) 384 return true; 385 386 m_lzwContext.reset(new SkGIFLZWContext(client, this)); 387 if (!m_lzwContext->prepareToDecode()) { 388 m_lzwContext.reset(); 389 return false; 390 } 391 392 m_currentLzwBlock = 0; 393 } 394 395 // Some bad GIFs have extra blocks beyond the last row, which we don't want to decode. 396 while (m_currentLzwBlock < m_lzwBlocks.count() && m_lzwContext->hasRemainingRows()) { 397 const auto& block = m_lzwBlocks[m_currentLzwBlock]; 398 const size_t len = block.blockSize; 399 400 sk_sp<SkData> data(streamBuffer->getDataAtPosition(block.blockPosition, len)); 401 if (!data) { 402 return false; 403 } 404 if (!m_lzwContext->doLZW(reinterpret_cast<const unsigned char*>(data->data()), len)) { 405 return false; 406 } 407 ++m_currentLzwBlock; 408 } 409 410 // If this frame is data complete then the previous loop must have completely decoded all LZW blocks. 411 // There will be no more decoding for this frame so it's time to cleanup. 412 if (isComplete()) { 413 *frameComplete = true; 414 m_lzwContext.reset(); 415 } 416 return true; 417 } 418 419 // Decode a frame. 420 // This method uses SkGIFFrameContext:decode() to decode the frame; decoding error is reported to client as a critical failure. 421 // Return true if decoding has progressed. Return false if an error has occurred. 422 bool SkGifImageReader::decode(int frameIndex, bool* frameComplete) 423 { 424 SkGIFFrameContext* currentFrame = m_frames[frameIndex].get(); 425 426 return currentFrame->decode(&m_streamBuffer, m_client, frameComplete); 427 } 428 429 // Parse incoming GIF data stream into internal data structures. 430 SkCodec::Result SkGifImageReader::parse(SkGifImageReader::SkGIFParseQuery query) 431 { 432 if (m_parseCompleted) { 433 return SkCodec::kSuccess; 434 } 435 436 if (SkGIFLoopCountQuery == query && m_loopCount != cLoopCountNotSeen) { 437 // Loop count has already been parsed. 438 return SkCodec::kSuccess; 439 } 440 441 // SkGIFSizeQuery and SkGIFFrameCountQuery are negative, so this is only meaningful when >= 0. 442 const int lastFrameToParse = (int) query; 443 if (lastFrameToParse >= 0 && m_frames.count() > lastFrameToParse 444 && m_frames[lastFrameToParse]->isComplete()) { 445 // We have already parsed this frame. 446 return SkCodec::kSuccess; 447 } 448 449 while (true) { 450 if (!m_streamBuffer.buffer(m_bytesToConsume)) { 451 // The stream does not yet have enough data. 452 return SkCodec::kIncompleteInput; 453 } 454 455 switch (m_state) { 456 case SkGIFLZW: { 457 SkASSERT(!m_frames.empty()); 458 auto* frame = m_frames.back().get(); 459 frame->addLzwBlock(m_streamBuffer.markPosition(), m_bytesToConsume); 460 GETN(1, SkGIFSubBlock); 461 break; 462 } 463 case SkGIFLZWStart: { 464 SkASSERT(!m_frames.empty()); 465 auto* currentFrame = m_frames.back().get(); 466 467 currentFrame->setDataSize(this->getOneByte()); 468 GETN(1, SkGIFSubBlock); 469 break; 470 } 471 472 case SkGIFType: { 473 const char* currentComponent = m_streamBuffer.get(); 474 475 // All GIF files begin with "GIF87a" or "GIF89a". 476 if (!memcmp(currentComponent, "GIF89a", 6)) 477 m_version = 89; 478 else if (!memcmp(currentComponent, "GIF87a", 6)) 479 m_version = 87; 480 else { 481 // This prevents attempting to continue reading this invalid stream. 482 GETN(0, SkGIFDone); 483 return SkCodec::kInvalidInput; 484 } 485 GETN(7, SkGIFGlobalHeader); 486 break; 487 } 488 489 case SkGIFGlobalHeader: { 490 const unsigned char* currentComponent = 491 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); 492 493 // This is the height and width of the "screen" or frame into which 494 // images are rendered. The individual images can be smaller than 495 // the screen size and located with an origin anywhere within the 496 // screen. 497 // Note that we don't inform the client of the size yet, as it might 498 // change after we read the first frame's image header. 499 fScreenWidth = GETINT16(currentComponent); 500 fScreenHeight = GETINT16(currentComponent + 2); 501 502 const int globalColorMapColors = 2 << (currentComponent[4] & 0x07); 503 504 if ((currentComponent[4] & 0x80) && globalColorMapColors > 0) { /* global map */ 505 m_globalColorMap.setNumColors(globalColorMapColors); 506 GETN(SK_BYTES_PER_COLORMAP_ENTRY * globalColorMapColors, SkGIFGlobalColormap); 507 break; 508 } 509 510 GETN(1, SkGIFImageStart); 511 break; 512 } 513 514 case SkGIFGlobalColormap: { 515 m_globalColorMap.setTablePosition(m_streamBuffer.markPosition()); 516 GETN(1, SkGIFImageStart); 517 break; 518 } 519 520 case SkGIFImageStart: { 521 const char currentComponent = m_streamBuffer.get()[0]; 522 523 if (currentComponent == '!') { // extension. 524 GETN(2, SkGIFExtension); 525 break; 526 } 527 528 if (currentComponent == ',') { // image separator. 529 GETN(9, SkGIFImageHeader); 530 break; 531 } 532 533 // If we get anything other than ',' (image separator), '!' 534 // (extension), or ';' (trailer), there is extraneous data 535 // between blocks. The GIF87a spec tells us to keep reading 536 // until we find an image separator, but GIF89a says such 537 // a file is corrupt. We follow Mozilla's implementation and 538 // proceed as if the file were correctly terminated, so the 539 // GIF will display. 540 GETN(0, SkGIFDone); 541 break; 542 } 543 544 case SkGIFExtension: { 545 const unsigned char* currentComponent = 546 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); 547 548 size_t bytesInBlock = currentComponent[1]; 549 SkGIFState exceptionState = SkGIFSkipBlock; 550 551 switch (*currentComponent) { 552 case 0xf9: 553 // The GIF spec mandates that the GIFControlExtension header block length is 4 bytes, 554 exceptionState = SkGIFControlExtension; 555 // and the parser for this block reads 4 bytes, so we must enforce that the buffer 556 // contains at least this many bytes. If the GIF specifies a different length, we 557 // allow that, so long as it's larger; the additional data will simply be ignored. 558 bytesInBlock = std::max(bytesInBlock, static_cast<size_t>(4)); 559 break; 560 561 // The GIF spec also specifies the lengths of the following two extensions' headers 562 // (as 12 and 11 bytes, respectively). Because we ignore the plain text extension entirely 563 // and sanity-check the actual length of the application extension header before reading it, 564 // we allow GIFs to deviate from these values in either direction. This is important for 565 // real-world compatibility, as GIFs in the wild exist with application extension headers 566 // that are both shorter and longer than 11 bytes. 567 case 0x01: 568 // ignoring plain text extension 569 break; 570 571 case 0xff: 572 exceptionState = SkGIFApplicationExtension; 573 break; 574 575 case 0xfe: 576 exceptionState = SkGIFConsumeComment; 577 break; 578 } 579 580 if (bytesInBlock) 581 GETN(bytesInBlock, exceptionState); 582 else 583 GETN(1, SkGIFImageStart); 584 break; 585 } 586 587 case SkGIFConsumeBlock: { 588 const unsigned char currentComponent = this->getOneByte(); 589 if (!currentComponent) 590 GETN(1, SkGIFImageStart); 591 else 592 GETN(currentComponent, SkGIFSkipBlock); 593 break; 594 } 595 596 case SkGIFSkipBlock: { 597 GETN(1, SkGIFConsumeBlock); 598 break; 599 } 600 601 case SkGIFControlExtension: { 602 const unsigned char* currentComponent = 603 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); 604 605 addFrameIfNecessary(); 606 SkGIFFrameContext* currentFrame = m_frames.back().get(); 607 if (*currentComponent & 0x1) 608 currentFrame->setTransparentPixel(currentComponent[3]); 609 610 // We ignore the "user input" bit. 611 612 // NOTE: This relies on the values in the FrameDisposalMethod enum 613 // matching those in the GIF spec! 614 int rawDisposalMethod = ((*currentComponent) >> 2) & 0x7; 615 switch (rawDisposalMethod) { 616 case 1: 617 case 2: 618 case 3: 619 currentFrame->setDisposalMethod((SkCodecAnimation::DisposalMethod) rawDisposalMethod); 620 break; 621 case 4: 622 // Some specs say that disposal method 3 is "overwrite previous", others that setting 623 // the third bit of the field (i.e. method 4) is. We map both to the same value. 624 currentFrame->setDisposalMethod(SkCodecAnimation::DisposalMethod::kRestorePrevious); 625 break; 626 default: 627 // Other values use the default. 628 currentFrame->setDisposalMethod(SkCodecAnimation::DisposalMethod::kKeep); 629 break; 630 } 631 currentFrame->setDuration(GETINT16(currentComponent + 1) * 10); 632 GETN(1, SkGIFConsumeBlock); 633 break; 634 } 635 636 case SkGIFCommentExtension: { 637 const unsigned char currentComponent = this->getOneByte(); 638 if (currentComponent) 639 GETN(currentComponent, SkGIFConsumeComment); 640 else 641 GETN(1, SkGIFImageStart); 642 break; 643 } 644 645 case SkGIFConsumeComment: { 646 GETN(1, SkGIFCommentExtension); 647 break; 648 } 649 650 case SkGIFApplicationExtension: { 651 // Check for netscape application extension. 652 if (m_bytesToConsume == 11) { 653 const unsigned char* currentComponent = 654 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); 655 656 if (!memcmp(currentComponent, "NETSCAPE2.0", 11) || !memcmp(currentComponent, "ANIMEXTS1.0", 11)) 657 GETN(1, SkGIFNetscapeExtensionBlock); 658 } 659 660 if (m_state != SkGIFNetscapeExtensionBlock) 661 GETN(1, SkGIFConsumeBlock); 662 break; 663 } 664 665 // Netscape-specific GIF extension: animation looping. 666 case SkGIFNetscapeExtensionBlock: { 667 const int currentComponent = this->getOneByte(); 668 // SkGIFConsumeNetscapeExtension always reads 3 bytes from the stream; we should at least wait for this amount. 669 if (currentComponent) 670 GETN(std::max(3, currentComponent), SkGIFConsumeNetscapeExtension); 671 else 672 GETN(1, SkGIFImageStart); 673 break; 674 } 675 676 // Parse netscape-specific application extensions 677 case SkGIFConsumeNetscapeExtension: { 678 const unsigned char* currentComponent = 679 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); 680 681 int netscapeExtension = currentComponent[0] & 7; 682 683 // Loop entire animation specified # of times. Only read the loop count during the first iteration. 684 if (netscapeExtension == 1) { 685 m_loopCount = GETINT16(currentComponent + 1); 686 687 // Zero loop count is infinite animation loop request. 688 if (!m_loopCount) 689 m_loopCount = SkCodec::kRepetitionCountInfinite; 690 691 GETN(1, SkGIFNetscapeExtensionBlock); 692 693 if (SkGIFLoopCountQuery == query) { 694 m_streamBuffer.flush(); 695 return SkCodec::kSuccess; 696 } 697 } else if (netscapeExtension == 2) { 698 // Wait for specified # of bytes to enter buffer. 699 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, SkGIFNetscapeExtensionBlock); 704 } else { 705 // 0,3-7 are yet to be defined netscape extension codes 706 // This prevents attempting to continue reading this invalid stream. 707 GETN(0, SkGIFDone); 708 return SkCodec::kInvalidInput; 709 } 710 break; 711 } 712 713 case SkGIFImageHeader: { 714 int height, width, xOffset, yOffset; 715 const unsigned char* currentComponent = 716 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); 717 718 /* Get image offsets, with respect to the screen origin */ 719 xOffset = GETINT16(currentComponent); 720 yOffset = GETINT16(currentComponent + 2); 721 722 /* Get image width and height. */ 723 width = GETINT16(currentComponent + 4); 724 height = GETINT16(currentComponent + 6); 725 726 // Some GIF files have frames that don't fit in the specified 727 // overall image size. For the first frame, we can simply enlarge 728 // the image size to allow the frame to be visible. We can't do 729 // this on subsequent frames because the rest of the decoding 730 // infrastructure assumes the image size won't change as we 731 // continue decoding, so any subsequent frames that are even 732 // larger will be cropped. 733 // Luckily, handling just the first frame is sufficient to deal 734 // with most cases, e.g. ones where the image size is erroneously 735 // set to zero, since usually the first frame completely fills 736 // the image. 737 if (currentFrameIsFirstFrame()) { 738 fScreenHeight = std::max(fScreenHeight, yOffset + height); 739 fScreenWidth = std::max(fScreenWidth, xOffset + width); 740 } 741 742 // NOTE: Chromium placed this block after setHeaderDefined, down 743 // below we returned true when asked for the size. So Chromium 744 // created an image which would fail. Is this the correct behavior? 745 // We choose to return false early, so we will not create an 746 // SkCodec. 747 748 // Work around more broken GIF files that have zero image width or 749 // height. 750 if (!height || !width) { 751 height = fScreenHeight; 752 width = fScreenWidth; 753 if (!height || !width) { 754 // This prevents attempting to continue reading this invalid stream. 755 GETN(0, SkGIFDone); 756 return SkCodec::kInvalidInput; 757 } 758 } 759 760 const bool isLocalColormapDefined = SkToBool(currentComponent[8] & 0x80); 761 // The three low-order bits of currentComponent[8] specify the bits per pixel. 762 const int numColors = 2 << (currentComponent[8] & 0x7); 763 if (currentFrameIsFirstFrame()) { 764 const int transPix = m_frames.empty() ? SkGIFColorMap::kNotFound 765 : m_frames[0]->transparentPixel(); 766 if (is_palette_index_valid(transPix)) { 767 m_firstFrameHasAlpha = true; 768 } else { 769 const bool frameIsSubset = xOffset > 0 || yOffset > 0 770 || width < fScreenWidth 771 || height < fScreenHeight; 772 m_firstFrameHasAlpha = frameIsSubset; 773 } 774 } 775 776 addFrameIfNecessary(); 777 SkGIFFrameContext* currentFrame = m_frames.back().get(); 778 currentFrame->setHeaderDefined(); 779 780 if (query == SkGIFSizeQuery) { 781 // The decoder needs to stop, so we return here, before 782 // flushing the buffer. Next time through, we'll be in the same 783 // state, requiring the same amount in the buffer. 784 return SkCodec::kSuccess; 785 } 786 787 788 currentFrame->setXYWH(xOffset, yOffset, width, height); 789 currentFrame->setInterlaced(SkToBool(currentComponent[8] & 0x40)); 790 791 // Overlaying interlaced, transparent GIFs over 792 // existing image data using the Haeberli display hack 793 // requires saving the underlying image in order to 794 // avoid jaggies at the transparency edges. We are 795 // unprepared to deal with that, so don't display such 796 // images progressively. Which means only the first 797 // frame can be progressively displayed. 798 // FIXME: It is possible that a non-transparent frame 799 // can be interlaced and progressively displayed. 800 currentFrame->setProgressiveDisplay(currentFrameIsFirstFrame()); 801 802 if (isLocalColormapDefined) { 803 currentFrame->localColorMap().setNumColors(numColors); 804 GETN(SK_BYTES_PER_COLORMAP_ENTRY * numColors, SkGIFImageColormap); 805 break; 806 } 807 808 setAlphaAndRequiredFrame(currentFrame); 809 GETN(1, SkGIFLZWStart); 810 break; 811 } 812 813 case SkGIFImageColormap: { 814 SkASSERT(!m_frames.empty()); 815 auto* currentFrame = m_frames.back().get(); 816 auto& cmap = currentFrame->localColorMap(); 817 cmap.setTablePosition(m_streamBuffer.markPosition()); 818 setAlphaAndRequiredFrame(currentFrame); 819 GETN(1, SkGIFLZWStart); 820 break; 821 } 822 823 case SkGIFSubBlock: { 824 const size_t bytesInBlock = this->getOneByte(); 825 if (bytesInBlock) 826 GETN(bytesInBlock, SkGIFLZW); 827 else { 828 // Finished parsing one frame; Process next frame. 829 SkASSERT(!m_frames.empty()); 830 // Note that some broken GIF files do not have enough LZW blocks to fully 831 // decode all rows but we treat it as frame complete. 832 m_frames.back()->setComplete(); 833 GETN(1, SkGIFImageStart); 834 if (lastFrameToParse >= 0 && m_frames.count() > lastFrameToParse) { 835 m_streamBuffer.flush(); 836 return SkCodec::kSuccess; 837 } 838 } 839 break; 840 } 841 842 case SkGIFDone: { 843 m_parseCompleted = true; 844 return SkCodec::kSuccess; 845 } 846 847 default: 848 // We shouldn't ever get here. 849 // This prevents attempting to continue reading this invalid stream. 850 GETN(0, SkGIFDone); 851 return SkCodec::kInvalidInput; 852 break; 853 } // switch 854 m_streamBuffer.flush(); 855 } 856 } 857 858 void SkGifImageReader::addFrameIfNecessary() 859 { 860 if (m_frames.empty() || m_frames.back()->isComplete()) { 861 const int i = m_frames.count(); 862 m_frames.emplace_back(new SkGIFFrameContext(i)); 863 } 864 } 865 866 SkEncodedInfo::Alpha SkGIFFrameContext::onReportedAlpha() const { 867 // Note: We could correct these after decoding - i.e. some frames may turn out to be 868 // independent and opaque if they do not use the transparent pixel, but that would require 869 // checking whether each pixel used the transparent index. 870 return is_palette_index_valid(this->transparentPixel()) ? SkEncodedInfo::kBinary_Alpha 871 : SkEncodedInfo::kOpaque_Alpha; 872 } 873 874 // FIXME: Move this method to close to doLZW(). 875 bool SkGIFLZWContext::prepareToDecode() 876 { 877 SkASSERT(m_frameContext->isDataSizeDefined() && m_frameContext->isHeaderDefined()); 878 879 // Since we use a codesize of 1 more than the datasize, we need to ensure 880 // that our datasize is strictly less than the SK_MAX_DICTIONARY_ENTRY_BITS. 881 if (m_frameContext->dataSize() >= SK_MAX_DICTIONARY_ENTRY_BITS) 882 return false; 883 clearCode = 1 << m_frameContext->dataSize(); 884 avail = clearCode + 2; 885 oldcode = -1; 886 codesize = m_frameContext->dataSize() + 1; 887 codemask = (1 << codesize) - 1; 888 datum = bits = 0; 889 ipass = m_frameContext->interlaced() ? 1 : 0; 890 irow = 0; 891 892 // We want to know the longest sequence encodable by a dictionary with 893 // SK_MAX_DICTIONARY_ENTRIES entries. If we ignore the need to encode the base 894 // values themselves at the beginning of the dictionary, as well as the need 895 // for a clear code or a termination code, we could use every entry to 896 // encode a series of multiple values. If the input value stream looked 897 // like "AAAAA..." (a long string of just one value), the first dictionary 898 // entry would encode AA, the next AAA, the next AAAA, and so forth. Thus 899 // the longest sequence would be SK_MAX_DICTIONARY_ENTRIES + 1 values. 900 // 901 // However, we have to account for reserved entries. The first |datasize| 902 // bits are reserved for the base values, and the next two entries are 903 // reserved for the clear code and termination code. In theory a GIF can 904 // set the datasize to 0, meaning we have just two reserved entries, making 905 // the longest sequence (SK_MAX_DICTIONARY_ENTIRES + 1) - 2 values long. Since 906 // each value is a byte, this is also the number of bytes in the longest 907 // encodable sequence. 908 const size_t maxBytes = SK_MAX_DICTIONARY_ENTRIES - 1; 909 910 // Now allocate the output buffer. We decode directly into this buffer 911 // until we have at least one row worth of data, then call outputRow(). 912 // This means worst case we may have (row width - 1) bytes in the buffer 913 // and then decode a sequence |maxBytes| long to append. 914 rowBuffer.reset(m_frameContext->width() - 1 + maxBytes); 915 rowIter = rowBuffer.begin(); 916 rowsRemaining = m_frameContext->height(); 917 918 // Clearing the whole suffix table lets us be more tolerant of bad data. 919 for (int i = 0; i < clearCode; ++i) { 920 suffix[i] = i; 921 suffixLength[i] = 1; 922 } 923 return true; 924 } 925 926