Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2)

Unified Diff: third_party/gif/GIFImageReader.cpp

Issue 2045293002: Add support for multiple frames in SkCodec (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Fix a test - we now draw transparent background for missing color table Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/gif/GIFImageReader.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/gif/GIFImageReader.cpp
diff --git a/third_party/gif/GIFImageReader.cpp b/third_party/gif/GIFImageReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..859b45f7c4ccda3ee15137186e53a8bc3e06de52
--- /dev/null
+++ b/third_party/gif/GIFImageReader.cpp
@@ -0,0 +1,941 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Chris Saari <saari@netscape.com>
+ * Apple Computer
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+The Graphics Interchange Format(c) is the copyright property of CompuServe
+Incorporated. Only CompuServe Incorporated is authorized to define, redefine,
+enhance, alter, modify or change in any way the definition of the format.
+
+CompuServe Incorporated hereby grants a limited, non-exclusive, royalty-free
+license for the use of the Graphics Interchange Format(sm) in computer
+software; computer software utilizing GIF(sm) must acknowledge ownership of the
+Graphics Interchange Format and its Service Mark by CompuServe Incorporated, in
+User and Technical Documentation. Computer software utilizing GIF, which is
+distributed or may be distributed without User or Technical Documentation must
+display to the screen or printer a message acknowledging ownership of the
+Graphics Interchange Format and the Service Mark by CompuServe Incorporated; in
+this case, the acknowledgement may be displayed in an opening screen or leading
+banner, or a closing screen or trailing banner. A message such as the following
+may be used:
+
+ "The Graphics Interchange Format(c) is the Copyright property of
+ CompuServe Incorporated. GIF(sm) is a Service Mark property of
+ CompuServe Incorporated."
+
+For further information, please contact :
+
+ CompuServe Incorporated
+ Graphics Technology Department
+ 5000 Arlington Center Boulevard
+ Columbus, Ohio 43220
+ U. S. A.
+
+CompuServe Incorporated maintains a mailing list with all those individuals and
+organizations who wish to receive copies of this document when it is corrected
+or revised. This service is offered free of charge; please provide us with your
+mailing address.
+*/
+
+#include "GIFImageReader.h"
+#include "SkColorPriv.h"
+#include "SkGifCodec.h"
+
+#include <algorithm>
+#include <string.h>
+
+
+// GETN(n, s) requests at least 'n' bytes available from 'q', at start of state 's'.
+//
+// Note, the hold will never need to be bigger than 256 bytes to gather up in the hold,
+// as each GIF block (except colormaps) can never be bigger than 256 bytes.
+// Colormaps are directly copied in the resp. global_colormap or dynamically allocated local_colormap.
+// So a fixed buffer in GIFImageReader is good enough.
+// This buffer is only needed to copy left-over data from one GifWrite call to the next
+#define GETN(n, s) \
+ do { \
+ m_bytesToConsume = (n); \
+ m_state = (s); \
+ } while (0)
+
+// Get a 16-bit value stored in little-endian format.
+#define GETINT16(p) ((p)[1]<<8|(p)[0])
+
+// Send the data to the display front-end.
+bool GIFLZWContext::outputRow(const unsigned char* rowBegin)
+{
+ int drowStart = irow;
+ int drowEnd = irow;
+
+ // Haeberli-inspired hack for interlaced GIFs: Replicate lines while
+ // displaying to diminish the "venetian-blind" effect as the image is
+ // loaded. Adjust pixel vertical positions to avoid the appearance of the
+ // image crawling up the screen as successive passes are drawn.
+ if (m_frameContext->progressiveDisplay() && m_frameContext->interlaced() && ipass < 4) {
+ unsigned rowDup = 0;
+ unsigned rowShift = 0;
+
+ switch (ipass) {
+ case 1:
+ rowDup = 7;
+ rowShift = 3;
+ break;
+ case 2:
+ rowDup = 3;
+ rowShift = 1;
+ break;
+ case 3:
+ rowDup = 1;
+ rowShift = 0;
+ break;
+ default:
+ break;
+ }
+
+ drowStart -= rowShift;
+ drowEnd = drowStart + rowDup;
+
+ // Extend if bottom edge isn't covered because of the shift upward.
+ if (((m_frameContext->height() - 1) - drowEnd) <= rowShift)
+ drowEnd = m_frameContext->height() - 1;
+
+ // Clamp first and last rows to upper and lower edge of image.
+ if (drowStart < 0)
+ drowStart = 0;
+
+ if ((unsigned)drowEnd >= m_frameContext->height())
+ drowEnd = m_frameContext->height() - 1;
+ }
+
+ // Protect against too much image data.
+ if ((unsigned)drowStart >= m_frameContext->height())
+ return true;
+
+ // CALLBACK: Let the client know we have decoded a row.
+ if (!m_client->haveDecodedRow(m_frameContext->frameId(), rowBegin,
+ drowStart, drowEnd - drowStart + 1, m_frameContext->progressiveDisplay() && m_frameContext->interlaced() && ipass > 1))
+ return false;
+
+ if (!m_frameContext->interlaced())
+ irow++;
+ else {
+ do {
+ switch (ipass) {
+ case 1:
+ irow += 8;
+ if (irow >= m_frameContext->height()) {
+ ipass++;
+ irow = 4;
+ }
+ break;
+
+ case 2:
+ irow += 8;
+ if (irow >= m_frameContext->height()) {
+ ipass++;
+ irow = 2;
+ }
+ break;
+
+ case 3:
+ irow += 4;
+ if (irow >= m_frameContext->height()) {
+ ipass++;
+ irow = 1;
+ }
+ break;
+
+ case 4:
+ irow += 2;
+ if (irow >= m_frameContext->height()) {
+ ipass++;
+ irow = 0;
+ }
+ break;
+
+ default:
+ break;
+ }
+ } while (irow > (m_frameContext->height() - 1));
+ }
+ return true;
+}
+
+// Perform Lempel-Ziv-Welch decoding.
+// Returns true if decoding was successful. In this case the block will have been completely consumed and/or rowsRemaining will be 0.
+// Otherwise, decoding failed; returns false in this case, which will always cause the GIFImageReader to set the "decode failed" flag.
+bool GIFLZWContext::doLZW(const unsigned char* block, size_t bytesInBlock)
+{
+ const size_t width = m_frameContext->width();
+
+ if (rowIter == rowBuffer.end())
+ return true;
+
+ for (const unsigned char* ch = block; bytesInBlock-- > 0; ch++) {
+ // Feed the next byte into the decoder's 32-bit input buffer.
+ datum += ((int) *ch) << bits;
+ bits += 8;
+
+ // Check for underflow of decoder's 32-bit input buffer.
+ while (bits >= codesize) {
+ // Get the leading variable-length symbol from the data stream.
+ int code = datum & codemask;
+ datum >>= codesize;
+ bits -= codesize;
+
+ // Reset the dictionary to its original state, if requested.
+ if (code == clearCode) {
+ codesize = m_frameContext->dataSize() + 1;
+ codemask = (1 << codesize) - 1;
+ avail = clearCode + 2;
+ oldcode = -1;
+ continue;
+ }
+
+ // Check for explicit end-of-stream code.
+ if (code == (clearCode + 1)) {
+ // end-of-stream should only appear after all image data.
+ if (!rowsRemaining)
+ return true;
+ return false;
+ }
+
+ const int tempCode = code;
+ unsigned short codeLength = 0;
+ if (code < avail) {
+ // This is a pre-existing code, so we already know what it
+ // encodes.
+ codeLength = suffixLength[code];
+ rowIter += codeLength;
+ } else if (code == avail && oldcode != -1) {
+ // This is a new code just being added to the dictionary.
+ // It must encode the contents of the previous code, plus
+ // the first character of the previous code again.
+ codeLength = suffixLength[oldcode] + 1;
+ rowIter += codeLength;
+ *--rowIter = firstchar;
+ code = oldcode;
+ } else {
+ // This is an invalid code. The dictionary is just initialized
+ // and the code is incomplete. We don't know how to handle
+ // this case.
+ return false;
+ }
+
+ while (code >= clearCode) {
+ *--rowIter = suffix[code];
+ code = prefix[code];
+ }
+
+ *--rowIter = firstchar = suffix[code];
+
+ // Define a new codeword in the dictionary as long as we've read
+ // more than one value from the stream.
+ if (avail < MAX_DICTIONARY_ENTRIES && oldcode != -1) {
+ prefix[avail] = oldcode;
+ suffix[avail] = firstchar;
+ suffixLength[avail] = suffixLength[oldcode] + 1;
+ ++avail;
+
+ // If we've used up all the codewords of a given length
+ // increase the length of codewords by one bit, but don't
+ // exceed the specified maximum codeword size.
+ if (!(avail & codemask) && avail < MAX_DICTIONARY_ENTRIES) {
+ ++codesize;
+ codemask += avail;
+ }
+ }
+ oldcode = tempCode;
+ rowIter += codeLength;
+
+ // Output as many rows as possible.
+ unsigned char* rowBegin = rowBuffer.begin();
+ for (; rowBegin + width <= rowIter; rowBegin += width) {
+ if (!outputRow(rowBegin))
+ return false;
+ rowsRemaining--;
+ if (!rowsRemaining)
+ return true;
+ }
+
+ if (rowBegin != rowBuffer.begin()) {
+ // Move the remaining bytes to the beginning of the buffer.
+ const size_t bytesToCopy = rowIter - rowBegin;
+ memcpy(&rowBuffer.front(), rowBegin, bytesToCopy);
+ rowIter = rowBuffer.begin() + bytesToCopy;
+ }
+ }
+ }
+ return true;
+}
+
+sk_sp<SkColorTable> GIFColorMap::buildTable(SkColorType colorType, size_t transparentPixel) const
+{
+ if (!m_isDefined)
+ return nullptr;
+
+ const PackColorProc proc = choose_pack_color_proc(false, colorType);
+ if (m_table) {
+ if (transparentPixel > (unsigned) m_table->count()
+ || m_table->operator[](transparentPixel) == SK_ColorTRANSPARENT) {
+ if (proc == m_packColorProc) {
+ // This SkColorTable has already been built with the same transparent color and
+ // packing proc. Reuse it.
+ return m_table;
+ }
+ }
+ }
+ m_packColorProc = proc;
+
+ SkASSERT(m_colors <= MAX_COLORS);
+ const uint8_t* srcColormap = m_rawData->bytes();
+ SkPMColor colorStorage[MAX_COLORS];
+ for (size_t i = 0; i < m_colors; i++) {
+ if (i == transparentPixel) {
+ colorStorage[i] = SK_ColorTRANSPARENT;
+ } else {
+ colorStorage[i] = proc(255, srcColormap[0], srcColormap[1], srcColormap[2]);
+ }
+ srcColormap += BYTES_PER_COLORMAP_ENTRY;
+ }
+ for (size_t i = m_colors; i < MAX_COLORS; i++) {
+ colorStorage[i] = SK_ColorTRANSPARENT;
+ }
+ m_table = sk_sp<SkColorTable>(new SkColorTable(colorStorage, MAX_COLORS));
+ return m_table;
+}
+
+sk_sp<SkColorTable> GIFImageReader::getColorTable(SkColorType colorType, size_t index) const {
+ if (index >= m_frames.size()) {
+ return nullptr;
+ }
+
+ const GIFFrameContext* frameContext = m_frames[index].get();
+ const GIFColorMap& localColorMap = frameContext->localColorMap();
+ if (localColorMap.isDefined()) {
+ return localColorMap.buildTable(colorType, frameContext->transparentPixel());
+ }
+ if (m_globalColorMap.isDefined()) {
+ return m_globalColorMap.buildTable(colorType, frameContext->transparentPixel());
+ }
+ return nullptr;
+}
+
+// Perform decoding for this frame. frameComplete will be true if the entire frame is decoded.
+// Returns false if a decoding error occurred. This is a fatal error and causes the GIFImageReader to set the "decode failed" flag.
+// 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.
+bool GIFFrameContext::decode(SkGifCodec* client, bool* frameComplete)
+{
+ *frameComplete = false;
+ if (!m_lzwContext) {
+ // Wait for more data to properly initialize GIFLZWContext.
+ if (!isDataSizeDefined() || !isHeaderDefined())
+ return true;
+
+ m_lzwContext.reset(new GIFLZWContext(client, this));
+ if (!m_lzwContext->prepareToDecode()) {
+ m_lzwContext.reset();
+ return false;
+ }
+
+ m_currentLzwBlock = 0;
+ }
+
+ // Some bad GIFs have extra blocks beyond the last row, which we don't want to decode.
+ while (m_currentLzwBlock < m_lzwBlocks.size() && m_lzwContext->hasRemainingRows()) {
+ if (!m_lzwContext->doLZW(reinterpret_cast<const unsigned char*>(m_lzwBlocks[m_currentLzwBlock]->data()),
+ m_lzwBlocks[m_currentLzwBlock]->size())) {
+ return false;
+ }
+ ++m_currentLzwBlock;
+ }
+
+ // If this frame is data complete then the previous loop must have completely decoded all LZW blocks.
+ // There will be no more decoding for this frame so it's time to cleanup.
+ if (isComplete()) {
+ *frameComplete = true;
+ m_lzwContext.reset();
+ }
+ return true;
+}
+
+// Decode a frame.
+// This method uses GIFFrameContext:decode() to decode the frame; decoding error is reported to client as a critical failure.
+// Return true if decoding has progressed. Return false if an error has occurred.
+bool GIFImageReader::decode(size_t frameIndex, bool* frameComplete)
+{
+ GIFFrameContext* currentFrame = m_frames[frameIndex].get();
+
+ return currentFrame->decode(m_client, frameComplete);
+}
+
+// Parse incoming GIF data stream into internal data structures.
+// Return true if parsing has progressed or there is not enough data.
+// Return false if a fatal error is encountered.
+bool GIFImageReader::parse(GIFImageReader::GIFParseQuery query)
+{
+ if (m_parseCompleted) {
+ return true;
+ }
+
+ // GIFSizeQuery and GIFFrameCountQuery are negative, so this is only meaningful when >= 0.
+ const int lastFrameToParse = (int) query;
+ if (lastFrameToParse >= 0 && (int) m_frames.size() > lastFrameToParse
+ && m_frames[lastFrameToParse]->isComplete()) {
+ // We have already parsed this frame.
+ return true;
+ }
+
+ while (true) {
+ const size_t bytesBuffered = m_streamBuffer.buffer(m_bytesToConsume);
+ if (bytesBuffered < m_bytesToConsume) {
+ // The stream does not yet have enough data. Mark that we need less next time around,
+ // and return.
+ m_bytesToConsume -= bytesBuffered;
+ return true;
+ }
+
+ switch (m_state) {
+ case GIFLZW:
+ SkASSERT(!m_frames.empty());
+ // FIXME: All this copying might be wasteful for e.g. SkMemoryStream
+ m_frames.back()->addLzwBlock(m_streamBuffer.get(), m_streamBuffer.bytesBuffered());
+ GETN(1, GIFSubBlock);
+ break;
+
+ case GIFLZWStart: {
+ SkASSERT(!m_frames.empty());
+ m_frames.back()->setDataSize(this->getOneByte());
+ GETN(1, GIFSubBlock);
+ break;
+ }
+
+ case GIFType: {
+ const char* currentComponent = m_streamBuffer.get();
+
+ // All GIF files begin with "GIF87a" or "GIF89a".
+ if (!memcmp(currentComponent, "GIF89a", 6))
+ m_version = 89;
+ else if (!memcmp(currentComponent, "GIF87a", 6))
+ m_version = 87;
+ else {
+ // This prevents attempting to continue reading this invalid stream.
+ GETN(0, GIFDone);
+ return false;
+ }
+ GETN(7, GIFGlobalHeader);
+ break;
+ }
+
+ case GIFGlobalHeader: {
+ const unsigned char* currentComponent =
+ reinterpret_cast<const unsigned char*>(m_streamBuffer.get());
+
+ // This is the height and width of the "screen" or frame into which
+ // images are rendered. The individual images can be smaller than
+ // the screen size and located with an origin anywhere within the
+ // screen.
+ // Note that we don't inform the client of the size yet, as it might
+ // change after we read the first frame's image header.
+ m_screenWidth = GETINT16(currentComponent);
+ m_screenHeight = GETINT16(currentComponent + 2);
+
+ const size_t globalColorMapColors = 2 << (currentComponent[4] & 0x07);
+
+ if ((currentComponent[4] & 0x80) && globalColorMapColors > 0) { /* global map */
+ m_globalColorMap.setNumColors(globalColorMapColors);
+ GETN(BYTES_PER_COLORMAP_ENTRY * globalColorMapColors, GIFGlobalColormap);
+ break;
+ }
+
+ GETN(1, GIFImageStart);
+ break;
+ }
+
+ case GIFGlobalColormap: {
+ m_globalColorMap.setRawData(m_streamBuffer.get(), m_streamBuffer.bytesBuffered());
+ GETN(1, GIFImageStart);
+ break;
+ }
+
+ case GIFImageStart: {
+ const char currentComponent = m_streamBuffer.get()[0];
+
+ if (currentComponent == '!') { // extension.
+ GETN(2, GIFExtension);
+ break;
+ }
+
+ if (currentComponent == ',') { // image separator.
+ GETN(9, GIFImageHeader);
+ break;
+ }
+
+ // If we get anything other than ',' (image separator), '!'
+ // (extension), or ';' (trailer), there is extraneous data
+ // between blocks. The GIF87a spec tells us to keep reading
+ // until we find an image separator, but GIF89a says such
+ // a file is corrupt. We follow Mozilla's implementation and
+ // proceed as if the file were correctly terminated, so the
+ // GIF will display.
+ GETN(0, GIFDone);
+ break;
+ }
+
+ case GIFExtension: {
+ const unsigned char* currentComponent =
+ reinterpret_cast<const unsigned char*>(m_streamBuffer.get());
+
+ size_t bytesInBlock = currentComponent[1];
+ GIFState exceptionState = GIFSkipBlock;
+
+ switch (*currentComponent) {
+ case 0xf9:
+ exceptionState = GIFControlExtension;
+ // The GIF spec mandates that the GIFControlExtension header block length is 4 bytes,
+ // and the parser for this block reads 4 bytes, so we must enforce that the buffer
+ // contains at least this many bytes. If the GIF specifies a different length, we
+ // allow that, so long as it's larger; the additional data will simply be ignored.
+ bytesInBlock = std::max(bytesInBlock, static_cast<size_t>(4));
+ break;
+
+ // The GIF spec also specifies the lengths of the following two extensions' headers
+ // (as 12 and 11 bytes, respectively). Because we ignore the plain text extension entirely
+ // and sanity-check the actual length of the application extension header before reading it,
+ // we allow GIFs to deviate from these values in either direction. This is important for
+ // real-world compatibility, as GIFs in the wild exist with application extension headers
+ // that are both shorter and longer than 11 bytes.
+ case 0x01:
+ // ignoring plain text extension
+ break;
+
+ case 0xff:
+ exceptionState = GIFApplicationExtension;
+ break;
+
+ case 0xfe:
+ exceptionState = GIFConsumeComment;
+ break;
+ }
+
+ if (bytesInBlock)
+ GETN(bytesInBlock, exceptionState);
+ else
+ GETN(1, GIFImageStart);
+ break;
+ }
+
+ case GIFConsumeBlock: {
+ const unsigned char currentComponent = this->getOneByte();
+ if (!currentComponent)
+ GETN(1, GIFImageStart);
+ else
+ GETN(currentComponent, GIFSkipBlock);
+ break;
+ }
+
+ case GIFSkipBlock: {
+ GETN(1, GIFConsumeBlock);
+ break;
+ }
+
+ case GIFControlExtension: {
+ const unsigned char* currentComponent =
+ reinterpret_cast<const unsigned char*>(m_streamBuffer.get());
+
+ addFrameIfNecessary();
+ GIFFrameContext* currentFrame = m_frames.back().get();
+ if (*currentComponent & 0x1)
+ currentFrame->setTransparentPixel(currentComponent[3]);
+
+ // We ignore the "user input" bit.
+
+ // NOTE: This relies on the values in the FrameDisposalMethod enum
+ // matching those in the GIF spec!
+ int rawDisposalMethod = ((*currentComponent) >> 2) & 0x7;
+ switch (rawDisposalMethod) {
+ case 1:
+ case 2:
+ case 3:
+ currentFrame->setDisposalMethod((SkCodecAnimation::DisposalMethod) rawDisposalMethod);
+ break;
+ case 4:
+ // Some specs say that disposal method 3 is "overwrite previous", others that setting
+ // the third bit of the field (i.e. method 4) is. We map both to the same value.
+ currentFrame->setDisposalMethod(SkCodecAnimation::RestorePrevious_DisposalMethod);
+ break;
+ default:
+ // Other values use the default.
+ currentFrame->setDisposalMethod(SkCodecAnimation::Keep_DisposalMethod);
+ break;
+ }
+ currentFrame->setDelayTime(GETINT16(currentComponent + 1) * 10);
+ GETN(1, GIFConsumeBlock);
+ break;
+ }
+
+ case GIFCommentExtension: {
+ const unsigned char currentComponent = this->getOneByte();
+ if (currentComponent)
+ GETN(currentComponent, GIFConsumeComment);
+ else
+ GETN(1, GIFImageStart);
+ break;
+ }
+
+ case GIFConsumeComment: {
+ GETN(1, GIFCommentExtension);
+ break;
+ }
+
+ case GIFApplicationExtension: {
+ // Check for netscape application extension.
+ if (m_streamBuffer.bytesBuffered() == 11) {
+ const unsigned char* currentComponent =
+ reinterpret_cast<const unsigned char*>(m_streamBuffer.get());
+
+ if (!memcmp(currentComponent, "NETSCAPE2.0", 11) || !memcmp(currentComponent, "ANIMEXTS1.0", 11))
+ GETN(1, GIFNetscapeExtensionBlock);
+ }
+
+ if (m_state != GIFNetscapeExtensionBlock)
+ GETN(1, GIFConsumeBlock);
+ break;
+ }
+
+ // Netscape-specific GIF extension: animation looping.
+ case GIFNetscapeExtensionBlock: {
+ const int currentComponent = this->getOneByte();
+ // GIFConsumeNetscapeExtension always reads 3 bytes from the stream; we should at least wait for this amount.
+ if (currentComponent)
+ GETN(std::max(3, currentComponent), GIFConsumeNetscapeExtension);
+ else
+ GETN(1, GIFImageStart);
+ break;
+ }
+
+ // Parse netscape-specific application extensions
+ case GIFConsumeNetscapeExtension: {
+ const unsigned char* currentComponent =
+ reinterpret_cast<const unsigned char*>(m_streamBuffer.get());
+
+ int netscapeExtension = currentComponent[0] & 7;
+
+ // Loop entire animation specified # of times. Only read the loop count during the first iteration.
+ if (netscapeExtension == 1) {
+ m_loopCount = GETINT16(currentComponent + 1);
+
+ // Zero loop count is infinite animation loop request.
+ if (!m_loopCount)
+ m_loopCount = SkCodecAnimation::kAnimationLoopInfinite;
+
+ GETN(1, GIFNetscapeExtensionBlock);
+ } else if (netscapeExtension == 2) {
+ // Wait for specified # of bytes to enter buffer.
+
+ // Don't do this, this extension doesn't exist (isn't used at all)
+ // and doesn't do anything, as our streaming/buffering takes care of it all...
+ // See: http://semmix.pl/color/exgraf/eeg24.htm
+ GETN(1, GIFNetscapeExtensionBlock);
+ } else {
+ // 0,3-7 are yet to be defined netscape extension codes
+ // This prevents attempting to continue reading this invalid stream.
+ GETN(0, GIFDone);
+ return false;
+ }
+ break;
+ }
+
+ case GIFImageHeader: {
+ unsigned height, width, xOffset, yOffset;
+ const unsigned char* currentComponent =
+ reinterpret_cast<const unsigned char*>(m_streamBuffer.get());
+
+ /* Get image offsets, with respect to the screen origin */
+ xOffset = GETINT16(currentComponent);
+ yOffset = GETINT16(currentComponent + 2);
+
+ /* Get image width and height. */
+ width = GETINT16(currentComponent + 4);
+ height = GETINT16(currentComponent + 6);
+
+ // Some GIF files have frames that don't fit in the specified
+ // overall image size. For the first frame, we can simply enlarge
+ // the image size to allow the frame to be visible. We can't do
+ // this on subsequent frames because the rest of the decoding
+ // infrastructure assumes the image size won't change as we
+ // continue decoding, so any subsequent frames that are even
+ // larger will be cropped.
+ // Luckily, handling just the first frame is sufficient to deal
+ // with most cases, e.g. ones where the image size is erroneously
+ // set to zero, since usually the first frame completely fills
+ // the image.
+ if (currentFrameIsFirstFrame()) {
+ m_screenHeight = std::max(m_screenHeight, yOffset + height);
+ m_screenWidth = std::max(m_screenWidth, xOffset + width);
+ }
+
+ // NOTE: Chromium placed this block after setHeaderDefined, down
+ // below we returned true when asked for the size. So Chromium
+ // created an image which would fail. Is this the correct behavior?
+ // We choose to return false early, so we will not create an
+ // SkCodec.
+
+ // Work around more broken GIF files that have zero image width or
+ // height.
+ if (!height || !width) {
+ height = m_screenHeight;
+ width = m_screenWidth;
+ if (!height || !width) {
+ // This prevents attempting to continue reading this invalid stream.
+ GETN(0, GIFDone);
+ return false;
+ }
+ }
+
+ const bool isLocalColormapDefined = currentComponent[8] & 0x80;
+ // The three low-order bits of currentComponent[8] specify the bits per pixel.
+ const size_t numColors = 2 << (currentComponent[8] & 0x7);
+ if (currentFrameIsFirstFrame()) {
+ bool hasTransparentPixel;
+ if (m_frames.size() == 0) {
+ // We did not see a Graphics Control Extension, so no transparent
+ // pixel was specified.
+ hasTransparentPixel = false;
+ } else {
+ // This means we did see a Graphics Control Extension, which specifies
+ // the transparent pixel
+ const size_t transparentPixel = m_frames[0]->transparentPixel();
+ if (isLocalColormapDefined) {
+ hasTransparentPixel = transparentPixel < numColors;
+ } else {
+ const size_t globalColors = m_globalColorMap.numColors();
+ if (!globalColors) {
+ // No color table for this frame, so the frame is empty.
+ // This is technically different from having a transparent
+ // pixel, but we'll treat it the same - nothing to draw here.
+ hasTransparentPixel = true;
+ } else {
+ hasTransparentPixel = transparentPixel < globalColors;
+ }
+ }
+ }
+
+ if (hasTransparentPixel) {
+ m_firstFrameHasAlpha = true;
+ m_firstFrameSupportsIndex8 = true;
+ } else {
+ const bool frameIsSubset = xOffset > 0 || yOffset > 0
+ || xOffset + width < m_screenWidth
+ || yOffset + height < m_screenHeight;
+ m_firstFrameHasAlpha = frameIsSubset;
+ m_firstFrameSupportsIndex8 = !frameIsSubset;
+ }
+ }
+
+ if (query == GIFSizeQuery) {
+ // The decoder needs to stop, so we return here, before
+ // flushing the buffer. Next time through, we'll be in the same
+ // state, requiring the same amount in the buffer.
+ m_bytesToConsume = 0;
+ return true;
+ }
+
+ addFrameIfNecessary();
+ GIFFrameContext* currentFrame = m_frames.back().get();
+
+ currentFrame->setHeaderDefined();
+
+ currentFrame->setRect(xOffset, yOffset, width, height);
+ currentFrame->setInterlaced(currentComponent[8] & 0x40);
+
+ // Overlaying interlaced, transparent GIFs over
+ // existing image data using the Haeberli display hack
+ // requires saving the underlying image in order to
+ // avoid jaggies at the transparency edges. We are
+ // unprepared to deal with that, so don't display such
+ // images progressively. Which means only the first
+ // frame can be progressively displayed.
+ // FIXME: It is possible that a non-transparent frame
+ // can be interlaced and progressively displayed.
+ currentFrame->setProgressiveDisplay(currentFrameIsFirstFrame());
+
+ if (isLocalColormapDefined) {
+ currentFrame->localColorMap().setNumColors(numColors);
+ GETN(BYTES_PER_COLORMAP_ENTRY * numColors, GIFImageColormap);
+ break;
+ }
+
+ GETN(1, GIFLZWStart);
+ break;
+ }
+
+ case GIFImageColormap: {
+ SkASSERT(!m_frames.empty());
+ m_frames.back()->localColorMap().setRawData(m_streamBuffer.get(), m_streamBuffer.bytesBuffered());
+ GETN(1, GIFLZWStart);
+ break;
+ }
+
+ case GIFSubBlock: {
+ const size_t bytesInBlock = this->getOneByte();
+ if (bytesInBlock)
+ GETN(bytesInBlock, GIFLZW);
+ else {
+ // Finished parsing one frame; Process next frame.
+ SkASSERT(!m_frames.empty());
+ // Note that some broken GIF files do not have enough LZW blocks to fully
+ // decode all rows but we treat it as frame complete.
+ m_frames.back()->setComplete();
+ GETN(1, GIFImageStart);
+ if (lastFrameToParse >= 0 && (int) m_frames.size() > lastFrameToParse) {
+ m_streamBuffer.flush();
+ return true;
+ }
+ }
+ break;
+ }
+
+ case GIFDone: {
+ m_parseCompleted = true;
+ return true;
+ }
+
+ default:
+ // We shouldn't ever get here.
+ // This prevents attempting to continue reading this invalid stream.
+ GETN(0, GIFDone);
+ return false;
+ break;
+ } // switch
+ m_streamBuffer.flush();
+ }
+
+ return true;
+}
+
+void GIFImageReader::addFrameIfNecessary()
+{
+ if (m_frames.empty() || m_frames.back()->isComplete()) {
+ const size_t i = m_frames.size();
+ std::unique_ptr<GIFFrameContext> frame(new GIFFrameContext(i));
+ if (0 == i) {
+ frame->setRequiredFrame(SkCodec::kNone);
+ } else {
+ // FIXME: We could correct these after decoding (i.e. some frames may turn out to be
+ // independent although we did not determine that here).
+ const GIFFrameContext* prevFrameContext = m_frames[i - 1].get();
+ switch (prevFrameContext->getDisposalMethod()) {
+ case SkCodecAnimation::Keep_DisposalMethod:
+ frame->setRequiredFrame(i - 1);
+ break;
+ case SkCodecAnimation::RestorePrevious_DisposalMethod:
+ frame->setRequiredFrame(prevFrameContext->getRequiredFrame());
+ break;
+ case SkCodecAnimation::RestoreBGColor_DisposalMethod:
+ // If the prior frame covers the whole image
+ if (prevFrameContext->frameRect() == SkIRect::MakeWH(m_screenWidth,
+ m_screenHeight)
+ // Or the prior frame was independent
+ || prevFrameContext->getRequiredFrame() == SkCodec::kNone)
+ {
+ // This frame is independent, since we clear everything
+ // prior frame to the BG color
+ frame->setRequiredFrame(SkCodec::kNone);
+ } else {
+ frame->setRequiredFrame(i - 1);
+ }
+ break;
+ }
+ }
+ m_frames.push_back(std::move(frame));
+ }
+}
+
+// FIXME: Move this method to close to doLZW().
+bool GIFLZWContext::prepareToDecode()
+{
+ SkASSERT(m_frameContext->isDataSizeDefined() && m_frameContext->isHeaderDefined());
+
+ // Since we use a codesize of 1 more than the datasize, we need to ensure
+ // that our datasize is strictly less than the MAX_DICTIONARY_ENTRY_BITS.
+ if (m_frameContext->dataSize() >= MAX_DICTIONARY_ENTRY_BITS)
+ return false;
+ clearCode = 1 << m_frameContext->dataSize();
+ avail = clearCode + 2;
+ oldcode = -1;
+ codesize = m_frameContext->dataSize() + 1;
+ codemask = (1 << codesize) - 1;
+ datum = bits = 0;
+ ipass = m_frameContext->interlaced() ? 1 : 0;
+ irow = 0;
+
+ // We want to know the longest sequence encodable by a dictionary with
+ // MAX_DICTIONARY_ENTRIES entries. If we ignore the need to encode the base
+ // values themselves at the beginning of the dictionary, as well as the need
+ // for a clear code or a termination code, we could use every entry to
+ // encode a series of multiple values. If the input value stream looked
+ // like "AAAAA..." (a long string of just one value), the first dictionary
+ // entry would encode AA, the next AAA, the next AAAA, and so forth. Thus
+ // the longest sequence would be MAX_DICTIONARY_ENTRIES + 1 values.
+ //
+ // However, we have to account for reserved entries. The first |datasize|
+ // bits are reserved for the base values, and the next two entries are
+ // reserved for the clear code and termination code. In theory a GIF can
+ // set the datasize to 0, meaning we have just two reserved entries, making
+ // the longest sequence (MAX_DICTIONARY_ENTIRES + 1) - 2 values long. Since
+ // each value is a byte, this is also the number of bytes in the longest
+ // encodable sequence.
+ const size_t maxBytes = MAX_DICTIONARY_ENTRIES - 1;
+
+ // Now allocate the output buffer. We decode directly into this buffer
+ // until we have at least one row worth of data, then call outputRow().
+ // This means worst case we may have (row width - 1) bytes in the buffer
+ // and then decode a sequence |maxBytes| long to append.
+ rowBuffer.reset(m_frameContext->width() - 1 + maxBytes);
+ rowIter = rowBuffer.begin();
+ rowsRemaining = m_frameContext->height();
+
+ // Clearing the whole suffix table lets us be more tolerant of bad data.
+ for (int i = 0; i < clearCode; ++i) {
+ suffix[i] = i;
+ suffixLength[i] = 1;
+ }
+ return true;
+}
+
« no previous file with comments | « third_party/gif/GIFImageReader.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698