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