Add support for multiple frames in SkCodec

src/codec/SkGifCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+/*
+ * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "SkCodecAnimation.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkGifCodec.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
-#include "SkUtils.h"
 
-#include "gif_lib.h"
+#define GIF87_STAMP "GIF87a"
+#define GIF89_STAMP "GIF89a"
+#define GIF_STAMP_LEN 6
 
 /*
  * Checks the start of the stream to see if the image is a gif
  */
 bool SkGifCodec::IsGif(const void* buf, size_t bytesRead) {
     if (bytesRead >= GIF_STAMP_LEN) {
-        if (memcmp(GIF_STAMP,   buf, GIF_STAMP_LEN) == 0 ||

[msarett, 2016/10/14 14:58:51]

Why this change?

[scroggo_chromium, 2016/10/14 19:56:00]

GIFImageReader does not check for GIF_STAMP (see [1]). I could instead update it
to do so, but the fact that Chromium does not check for it, and presumably it
hasn't been a problem, leads me to believe that we're not missing any real life
GIFs by not checking it.

I'm not opposed to reviving the check though.

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...

-            memcmp(GIF87_STAMP, buf, GIF_STAMP_LEN) == 0 ||
+        if (memcmp(GIF87_STAMP, buf, GIF_STAMP_LEN) == 0 ||
             memcmp(GIF89_STAMP, buf, GIF_STAMP_LEN) == 0)
         {
             return true;
         }
     }
     return false;
 }
 
 /*
  * Error function
  */
 static SkCodec::Result gif_error(const char* msg, SkCodec::Result result = SkCodec::kInvalidInput) {
     SkCodecPrintf("Gif Error: %s\n", msg);
     return result;
 }
 
-
-/*
- * Read function that will be passed to gif_lib
- */
-static int32_t read_bytes_callback(GifFileType* fileType, GifByteType* out, int32_t size) {
-    SkStream* stream = (SkStream*) fileType->UserData;
-    return (int32_t) stream->read(out, size);
-}
-
-/*
- * Open the gif file
- */
-static GifFileType* open_gif(SkStream* stream) {
-#if GIFLIB_MAJOR < 5
-    return DGifOpen(stream, read_bytes_callback);
-#else
-    return DGifOpen(stream, read_bytes_callback, nullptr);
-#endif
-}
-
-/*
- * Check if a there is an index of the color table for a transparent pixel
- */
-static uint32_t find_trans_index(const SavedImage& image) {
-    // If there is a transparent index specified, it will be contained in an
-    // extension block.  We will loop through extension blocks in reverse order
-    // to check the most recent extension blocks first.
-    for (int32_t i = image.ExtensionBlockCount - 1; i >= 0; i--) {
-        // Get an extension block
-        const ExtensionBlock& extBlock = image.ExtensionBlocks[i];
-
-        // Specifically, we need to check for a graphics control extension,
-        // which may contain transparency information.  Also, note that a valid
-        // graphics control extension is always four bytes.  The fourth byte
-        // is the transparent index (if it exists), so we need at least four
-        // bytes.
-        if (GRAPHICS_EXT_FUNC_CODE == extBlock.Function && extBlock.ByteCount >= 4) {
-            // Check the transparent color flag which indicates whether a
-            // transparent index exists.  It is the least significant bit of
-            // the first byte of the extension block.
-            if (1 == (extBlock.Bytes[0] & 1)) {
-                // Use uint32_t to prevent sign extending
-                return extBlock.Bytes[3];
-            }
-
-            // There should only be one graphics control extension for the image frame
-            break;
-        }
-    }
-
-    // Use maximum unsigned int (surely an invalid index) to indicate that a valid
-    // index was not found.
-    return SK_MaxU32;
-}
-
-inline uint32_t ceil_div(uint32_t a, uint32_t b) {
-    return (a + b - 1) / b;
-}
-
-/*
- * Gets the output row corresponding to the encoded row for interlaced gifs
- */
-inline uint32_t get_output_row_interlaced(uint32_t encodedRow, uint32_t height) {
-    SkASSERT(encodedRow < height);
-    // First pass
-    if (encodedRow * 8 < height) {
-        return encodedRow * 8;
-    }
-    // Second pass
-    if (encodedRow * 4 < height) {
-        return 4 + 8 * (encodedRow - ceil_div(height, 8));
-    }
-    // Third pass
-    if (encodedRow * 2 < height) {
-        return 2 + 4 * (encodedRow - ceil_div(height, 4));
-    }
-    // Fourth pass
-    return 1 + 2 * (encodedRow - ceil_div(height, 2));
-}
-
-/*
- * This function cleans up the gif object after the decode completes
- * It is used in a SkAutoTCallIProc template
- */
-void SkGifCodec::CloseGif(GifFileType* gif) {
-#if GIFLIB_MAJOR < 5 || (GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0)
-    DGifCloseFile(gif);
-#else
-    DGifCloseFile(gif, nullptr);
-#endif
-}
-
-/*
- * This function free extension data that has been saved to assist the image
- * decoder
- */
-void SkGifCodec::FreeExtension(SavedImage* image) {
-    if (NULL != image->ExtensionBlocks) {
-#if GIFLIB_MAJOR < 5
-        FreeExtension(image);
-#else
-        GifFreeExtensions(&image->ExtensionBlockCount, &image->ExtensionBlocks);
-#endif
-    }
-}
-
-/*
- * Read enough of the stream to initialize the SkGifCodec.
- * Returns a bool representing success or failure.
- *
- * @param codecOut
- * If it returned true, and codecOut was not nullptr,
- * codecOut will be set to a new SkGifCodec.
- *
- * @param gifOut
- * If it returned true, and codecOut was nullptr,
- * gifOut must be non-nullptr and gifOut will be set to a new
- * GifFileType pointer.
- *
- * @param stream
- * Deleted on failure.
- * codecOut will take ownership of it in the case where we created a codec.
- * Ownership is unchanged when we returned a gifOut.
- *
- */
-bool SkGifCodec::ReadHeader(SkStream* stream, SkCodec** codecOut, GifFileType** gifOut) {
-    SkAutoTDelete<SkStream> streamDeleter(stream);
-
-    // Read gif header, logical screen descriptor, and global color table
-    SkAutoTCallVProc<GifFileType, CloseGif> gif(open_gif(stream));
-
-    if (nullptr == gif) {
-        gif_error("DGifOpen failed.\n");
-        return false;
-    }
-
-    // Read through gif extensions to get to the image data.  Set the
-    // transparent index based on the extension data.
-    uint32_t transIndex;
-    SkCodec::Result result = ReadUpToFirstImage(gif, &transIndex);
-    if (kSuccess != result){
-        return false;
-    }
-
-    // Read the image descriptor
-    if (GIF_ERROR == DGifGetImageDesc(gif)) {
-        return false;
-    }
-    // If reading the image descriptor is successful, the image count will be
-    // incremented.
-    SkASSERT(gif->ImageCount >= 1);
-
-    if (nullptr != codecOut) {
-        SkISize size;
-        SkIRect frameRect;
-        if (!GetDimensions(gif, &size, &frameRect)) {
-            gif_error("Invalid gif size.\n");
-            return false;
-        }
-        bool frameIsSubset = (size != frameRect.size());
-
-        // Determine the encoded alpha type.  The transIndex might be valid if it less
-        // than 256.  We are not certain that the index is valid until we process the color
-        // table, since some gifs have color tables with less than 256 colors.  If
-        // there might be a valid transparent index, we must indicate that the image has
-        // alpha.
-        // In the case where we must support alpha, we indicate kBinary, since every
-        // pixel will either be fully opaque or fully transparent.
-        SkEncodedInfo::Alpha alpha = (transIndex < 256) ? SkEncodedInfo::kBinary_Alpha :
-                SkEncodedInfo::kOpaque_Alpha;
-
-        // Return the codec
-        // Use kPalette since Gifs are encoded with a color table.
-        // Use 8-bits per component, since this is the output we get from giflib.
-        // FIXME: Gifs can actually be encoded with 4-bits per pixel.  Can we support this?
-        SkEncodedInfo info = SkEncodedInfo::Make(SkEncodedInfo::kPalette_Color, alpha, 8);
-        *codecOut = new SkGifCodec(size.width(), size.height(), info, streamDeleter.release(),
-                gif.release(), transIndex, frameRect, frameIsSubset);
-    } else {
-        SkASSERT(nullptr != gifOut);
-        streamDeleter.release();
-        *gifOut = gif.release();
-    }
-    return true;
-}
-
 /*
  * Assumes IsGif was called and returned true
  * Creates a gif decoder
  * Reads enough of the stream to determine the image format
  */
 SkCodec* SkGifCodec::NewFromStream(SkStream* stream) {
-    SkCodec* codec = nullptr;
-    if (ReadHeader(stream, &codec, nullptr)) {
-        return codec;
+    std::unique_ptr<GIFImageReader> reader(new GIFImageReader(stream));
+    if (!reader->parse(GIFImageReader::GIFSizeQuery)) {
+        // Not enough data to determine the size.
+        return nullptr;
     }
-    return nullptr;
+
+    if (0 == reader->screenWidth() || 0 == reader->screenHeight()) {
+        return nullptr;
+    }
+
+    return new SkGifCodec(reader.release());
 }
 
-SkGifCodec::SkGifCodec(int width, int height, const SkEncodedInfo& info, SkStream* stream,
-        GifFileType* gif, uint32_t transIndex, const SkIRect& frameRect, bool frameIsSubset)
-    : INHERITED(width, height, info, stream)
-    , fGif(gif)
-    , fSrcBuffer(new uint8_t[this->getInfo().width()])
-    , fFrameRect(frameRect)
-    // If it is valid, fTransIndex will be used to set fFillIndex.  We don't know if
-    // fTransIndex is valid until we process the color table, since fTransIndex may
-    // be greater than the size of the color table.
-    , fTransIndex(transIndex)
-    // Default fFillIndex is 0.  We will overwrite this if fTransIndex is valid, or if
-    // there is a valid background color.
-    , fFillIndex(0)
-    , fFrameIsSubset(frameIsSubset)
-    , fSwizzler(NULL)
-    , fColorTable(NULL)
-{}
-
 bool SkGifCodec::onRewind() {
-    GifFileType* gifOut = nullptr;
-    if (!ReadHeader(this->stream(), nullptr, &gifOut)) {
-        return false;
-    }
-
-    SkASSERT(nullptr != gifOut);
-    fGif.reset(gifOut);
+    fReader->clearDecodeState();
     return true;
 }
 
-SkCodec::Result SkGifCodec::ReadUpToFirstImage(GifFileType* gif, uint32_t* transIndex) {
-    // Use this as a container to hold information about any gif extension
-    // blocks.  This generally stores transparency and animation instructions.
-    SavedImage saveExt;
-    SkAutoTCallVProc<SavedImage, FreeExtension> autoFreeExt(&saveExt);
-    saveExt.ExtensionBlocks = nullptr;
-    saveExt.ExtensionBlockCount = 0;
-    GifByteType* extData;
-    int32_t extFunction;
-
-    // We will loop over components of gif images until we find an image.  Once
-    // we find an image, we will decode and return it.  While many gif files
-    // contain more than one image, we will simply decode the first image.
-    GifRecordType recordType;
-    do {
-        // Get the current record type
-        if (GIF_ERROR == DGifGetRecordType(gif, &recordType)) {
-            return gif_error("DGifGetRecordType failed.\n", kInvalidInput);
-        }
-        switch (recordType) {
-            case IMAGE_DESC_RECORD_TYPE: {
-                *transIndex = find_trans_index(saveExt);
-
-                // FIXME: Gif files may have multiple images stored in a single
-                //        file.  This is most commonly used to enable
-                //        animations.  Since we are leaving animated gifs as a
-                //        TODO, we will return kSuccess after decoding the
-                //        first image in the file.  This is the same behavior
-                //        as SkImageDecoder_libgif.
-                //
-                //        Most times this works pretty well, but sometimes it
-                //        doesn't.  For example, I have an animated test image
-                //        where the first image in the file is 1x1, but the
-                //        subsequent images are meaningful.  This currently
-                //        displays the 1x1 image, which is not ideal.  Right
-                //        now I am leaving this as an issue that will be
-                //        addressed when we implement animated gifs.
-                //
-                //        It is also possible (not explicitly disallowed in the
-                //        specification) that gif files provide multiple
-                //        images in a single file that are all meant to be
-                //        displayed in the same frame together.  I will
-                //        currently leave this unimplemented until I find a
-                //        test case that expects this behavior.
-                return kSuccess;
-            }
-            // Extensions are used to specify special properties of the image
-            // such as transparency or animation.
-            case EXTENSION_RECORD_TYPE:
-                // Read extension data
-                if (GIF_ERROR == DGifGetExtension(gif, &extFunction, &extData)) {
-                    return gif_error("Could not get extension.\n", kIncompleteInput);
-                }
-
-                // Create an extension block with our data
-                while (nullptr != extData) {
-                    // Add a single block
-
-#if GIFLIB_MAJOR < 5
-                    if (AddExtensionBlock(&saveExt, extData[0],
-                                          &extData[1]) == GIF_ERROR) {
-#else
-                    if (GIF_ERROR == GifAddExtensionBlock(&saveExt.ExtensionBlockCount,
-                                                          &saveExt.ExtensionBlocks,
-                                                          extFunction, extData[0], &extData[1])) {
-#endif
-                        return gif_error("Could not add extension block.\n", kIncompleteInput);
-                    }
-                    // Move to the next block
-                    if (GIF_ERROR == DGifGetExtensionNext(gif, &extData)) {
-                        return gif_error("Could not get next extension.\n", kIncompleteInput);
-                    }
-                }
-                break;
-
-            // Signals the end of the gif file
-            case TERMINATE_RECORD_TYPE:
-                break;
-
-            default:
-                // DGifGetRecordType returns an error if the record type does
-                // not match one of the above cases.  This should not be
-                // reached.
-                SkASSERT(false);
-                break;
-        }
-    } while (TERMINATE_RECORD_TYPE != recordType);
-
-    return gif_error("Could not find any images to decode in gif file.\n", kInvalidInput);
+static SkEncodedInfo make_info() {
+    // Use kPalette since Gifs are encoded with a color table.
+    // FIXME: Except that we may not be able to decode to index8 for a frame beyond the first :(

[msarett, 2016/10/14 14:58:50]

I'm guessing that users of the animated API are "smart".  Maybe they can handle
the fact that requests for Index8 may fail?

[scroggo_chromium, 2016/10/14 19:56:00]

Currently, requests for Index8 for frames beyond the first *will* fail. But we
still want to report Index8 so we can continue to allow the Android framework to
support Index8 (without adding some extra code that knows a GIF is actually
Index8), yet this means a client could ask for getInfo(), frame 1, which would
fail. I don't know how to make this cleaner, but there may not be any good
"FIX"...

+    // FIXME: Gifs can actually be encoded with 4-bits per pixel.  Can we support this?

[msarett, 2016/10/14 14:58:50]

I think the swizzler already supports this.  So yes, I think we should report
this accurately in SkEncodedInfo and let the swizzler deal with it.

Doesn't need to be part of this CL though.

[scroggo_chromium, 2016/10/14 19:56:00]

sgtm. Updated the comment.

+    // FIXME: We do not yet know whether the image has alpha, so report binary. More specifically,

[msarett, 2016/10/14 14:58:50]

This may be fine, but it's starting to feel like SkEncodedInfo is not great for
describing animated images.

Might be nice to actually report opacity to clients that know they only care
about the single-frame case.

[scroggo_chromium, 2016/10/14 19:56:00]

I'm not sure how to do that, though. At this point, we don't know whether the
client wants the first frame or a later frame. I figure this is a decent
conservative guess.

I've updated the FIXME a little.

+    //        we cannot know without parsing the whole stream, since an arbitrary frame could
+    //        require clearing to the background, even though all preceding frames were opaque.
+    return SkEncodedInfo::Make(SkEncodedInfo::kPalette_Color, SkEncodedInfo::kBinary_Alpha, 8);
 }
 
-bool SkGifCodec::GetDimensions(GifFileType* gif, SkISize* size, SkIRect* frameRect) {
-    // Get the encoded dimension values
-    SavedImage* image = &gif->SavedImages[gif->ImageCount - 1];
-    const GifImageDesc& desc = image->ImageDesc;
-    int frameLeft = desc.Left;
-    int frameTop = desc.Top;
-    int frameWidth = desc.Width;
-    int frameHeight = desc.Height;
-    int width = gif->SWidth;
-    int height = gif->SHeight;
+SkGifCodec::SkGifCodec(GIFImageReader* reader)
+    : INHERITED(reader->screenWidth(), reader->screenHeight(), make_info(), nullptr)
+    , fReader(reader)
+    , fTmpBuffer(nullptr)
+    , fSwizzler(nullptr)
+    , fCurrColorTable(nullptr)
+    , fCurrColorTableIsReal(false)
+    , fFilledBackground(false)
+    , fFirstCallToIncrementalDecode(false)
+    , fDst(nullptr)
+    , fDstRowBytes(0)
+    , fFirstRow(0)
+    , fLastRow(0)
+    , fRowsDecoded(0)
+{
+    reader->setClient(this);
+}
 
-    // Ensure that the decode dimensions are large enough to contain the frame
-    width = SkTMax(width, frameWidth + frameLeft);
-    height = SkTMax(height, frameHeight + frameTop);
+std::vector<SkCodec::FrameInfo> SkGifCodec::onGetFrameInfo() {
+    fReader->parse(GIFImageReader::GIFFrameCountQuery);
+    const size_t size = fReader->imagesCount();
+    std::vector<FrameInfo> result(size);
+    for (size_t i = 0; i < size; i++) {
+        const GIFFrameContext* frameContext = fReader->frameContext(i);
+        result[i].fDuration = frameContext->delayTime();
+        result[i].fRequiredFrame = frameContext->getRequiredFrame();
+    }
+    return result;
+}
 
-    // All of these dimensions should be positive, as they are encoded as unsigned 16-bit integers.
-    // It is unclear why giflib casts them to ints.  We will go ahead and check that they are
-    // in fact positive.
-    if (frameLeft < 0 || frameTop < 0 || frameWidth < 0 || frameHeight < 0 || width <= 0 ||
-            height <= 0) {
-        return false;
+void SkGifCodec::initializeColorTable(const SkImageInfo& dstInfo, size_t frameIndex,
+        SkPMColor* inputColorPtr, int* inputColorCount) {
+    fCurrColorTable = std::move(fReader->getColorTable(dstInfo.colorType(), frameIndex));
+    fCurrColorTableIsReal = fCurrColorTable;
+    if (!fCurrColorTable) {
+        // This is possible for an empty frame. Create a dummy with one value (transparent).
+        SkPMColor color = SK_ColorTRANSPARENT;
+        fCurrColorTable.reset(new SkColorTable(&color, 1));
     }
 
-    frameRect->setXYWH(frameLeft, frameTop, frameWidth, frameHeight);
-    size->set(width, height);
-    return true;
+    if (inputColorCount) {
+        *inputColorCount = fCurrColorTable->count();
+    }
+
+    copy_color_table(dstInfo, fCurrColorTable.get(), inputColorPtr, inputColorCount);
 }
 
-void SkGifCodec::initializeColorTable(const SkImageInfo& dstInfo, SkPMColor* inputColorPtr,
-        int* inputColorCount) {
-    // Set up our own color table
-    const uint32_t maxColors = 256;
-    SkPMColor colorPtr[256];
-    if (NULL != inputColorCount) {
-        // We set the number of colors to maxColors in order to ensure
-        // safe memory accesses.  Otherwise, an invalid pixel could
-        // access memory outside of our color table array.
-        *inputColorCount = maxColors;
-    }
-
-    // Get local color table
-    ColorMapObject* colorMap = fGif->Image.ColorMap;
-    // If there is no local color table, use the global color table
-    if (NULL == colorMap) {
-        colorMap = fGif->SColorMap;
-    }
-
-    uint32_t colorCount = 0;
-    if (NULL != colorMap) {
-        colorCount = colorMap->ColorCount;
-        // giflib guarantees these properties
-        SkASSERT(colorCount == (unsigned) (1 << (colorMap->BitsPerPixel)));
-        SkASSERT(colorCount <= 256);
-        PackColorProc proc = choose_pack_color_proc(false, dstInfo.colorType());
-        for (uint32_t i = 0; i < colorCount; i++) {
-            colorPtr[i] = proc(0xFF, colorMap->Colors[i].Red,
-                    colorMap->Colors[i].Green, colorMap->Colors[i].Blue);
-        }
-    }
-
-    // Fill in the color table for indices greater than color count.
-    // This allows for predictable, safe behavior.
-    if (colorCount > 0) {
-        // Gifs have the option to specify the color at a single index of the color
-        // table as transparent.  If the transparent index is greater than the
-        // colorCount, we know that there is no valid transparent color in the color
-        // table.  If there is not valid transparent index, we will try to use the
-        // backgroundIndex as the fill index.  If the backgroundIndex is also not
-        // valid, we will let fFillIndex default to 0 (it is set to zero in the
-        // constructor).  This behavior is not specified but matches
-        // SkImageDecoder_libgif.
-        uint32_t backgroundIndex = fGif->SBackGroundColor;
-        if (fTransIndex < colorCount) {
-            colorPtr[fTransIndex] = SK_ColorTRANSPARENT;
-            fFillIndex = fTransIndex;
-        } else if (backgroundIndex < colorCount) {
-            fFillIndex = backgroundIndex;
-        }
-
-        for (uint32_t i = colorCount; i < maxColors; i++) {
-            colorPtr[i] = colorPtr[fFillIndex];
-        }
-    } else {
-        sk_memset32(colorPtr, 0xFF000000, maxColors);
-    }
-
-    fColorTable.reset(new SkColorTable(colorPtr, maxColors));
-    copy_color_table(dstInfo, this->fColorTable, inputColorPtr, inputColorCount);
-}
 
 SkCodec::Result SkGifCodec::prepareToDecode(const SkImageInfo& dstInfo, SkPMColor* inputColorPtr,
         int* inputColorCount, const Options& opts) {
     // Check for valid input parameters
     if (!conversion_possible_ignore_color_space(dstInfo, this->getInfo())) {
         return gif_error("Cannot convert input type to output type.\n", kInvalidConversion);
     }
 
+    if (dstInfo.colorType() == kRGBA_F16_SkColorType) {
+        // FIXME: This should be supported.
+        return gif_error("GIF does not yet support F16.\n", kInvalidConversion);
+    }
+
+    const size_t frameIndex = opts.fFrameOptions ? opts.fFrameOptions->fIndex : 0;
+    if (frameIndex > 0 && dstInfo.colorType() == kIndex_8_SkColorType) {
+        // FIXME: It is possible that a later frame can be decoded to index8, if it does one of the
+        // following:
+        // - Covers the entire previous frame
+        // - Shares a color table (and transparent index) with any prior frames that are showing.
+        // We must support index8 for the first frame to be backwards compatible on Android, but
+        // we do not (currently) need to support later frames as index8.
+        return gif_error("Cannot decode multiframe gif (except frame 0) as index 8.\n",
+                         kInvalidConversion);
+    }
+
+    fReader->parse((GIFImageReader::GIFParseQuery) frameIndex);
+
+    if (frameIndex >= fReader->imagesCount()) {
+        return gif_error("frame index out of range!\n", kIncompleteInput);
+    }
+
+    fTmpBuffer.reset(new uint8_t[dstInfo.minRowBytes()]);
+
     // Initialize color table and copy to the client if necessary
-    this->initializeColorTable(dstInfo, inputColorPtr, inputColorCount);
-
-    this->initializeSwizzler(dstInfo, opts);
+    this->initializeColorTable(dstInfo, frameIndex, inputColorPtr, inputColorCount);
+    this->initializeSwizzler(dstInfo, frameIndex);
     return kSuccess;
 }
 
-void SkGifCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& opts) {
-    const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-    const SkIRect* frameRect = fFrameIsSubset ? &fFrameRect : nullptr;
-    fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colorPtr, dstInfo, opts,
-            frameRect));
-    SkASSERT(fSwizzler);
-}
+void SkGifCodec::initializeSwizzler(const SkImageInfo& dstInfo, size_t frameIndex) {
+    const GIFFrameContext* frame = fReader->frameContext(frameIndex);
+    // This is only called by prepareToDecode, which ensures frameIndex is in range.
+    SkASSERT(frame);
 
-bool SkGifCodec::readRow() {
-    return GIF_ERROR != DGifGetLine(fGif, fSrcBuffer.get(), fFrameRect.width());
+    const int xBegin = frame->xOffset();
+    const int xEnd = std::min(static_cast<int>(frame->xOffset() + frame->width()),
+                              static_cast<int>(fReader->screenWidth()));
+
+    // CreateSwizzler only reads left and right of the frame. We cannot use the frame's raw
+    // frameRect, since it might extend beyond the edge of the frame.
+    SkIRect swizzleRect = SkIRect::MakeLTRB(xBegin, 0, xEnd, 0);
+
+    // The default Options should be fine:
+    // - we'll ignore if the memory is zero initialized - unless we're the first frame, this won't
+    //   matter anyway.
+    // - subsets are not supported for gif
+    // - the swizzler does not need to know about the frame.
+    // We may not be able to use the real Options anyway, since getPixels does not store it (due to
+    // a bug).
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(),
+                    fCurrColorTable->readColors(), dstInfo, Options(), &swizzleRect));
+    SkASSERT(fSwizzler.get());
 }
 
 /*
  * Initiates the gif decode
  */
 SkCodec::Result SkGifCodec::onGetPixels(const SkImageInfo& dstInfo,
-                                        void* dst, size_t dstRowBytes,
+                                        void* pixels, size_t dstRowBytes,
                                         const Options& opts,
                                         SkPMColor* inputColorPtr,
                                         int* inputColorCount,
                                         int* rowsDecoded) {
     Result result = this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, opts);
     if (kSuccess != result) {
         return result;
     }
 
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         return gif_error("Scaling not supported.\n", kInvalidScale);
     }
 
-    // Initialize the swizzler
-    if (fFrameIsSubset) {
-        // Fill the background
-        SkSampler::Fill(dstInfo, dst, dstRowBytes, this->getFillValue(dstInfo),
-                opts.fZeroInitialized);
-    }
-
-    // Iterate over rows of the input
-    for (int y = fFrameRect.top(); y < fFrameRect.bottom(); y++) {
-        if (!this->readRow()) {
-            *rowsDecoded = y;
-            return gif_error("Could not decode line.\n", kIncompleteInput);
-        }
-        void* dstRow = SkTAddOffset<void>(dst, dstRowBytes * this->outputScanline(y));
-        fSwizzler->swizzle(dstRow, fSrcBuffer.get());
-    }
+    fDst = pixels;
+    fDstRowBytes = dstRowBytes;
+
+    fFirstRow = 0;
+    fLastRow = dstInfo.height() - 1;
+
+    return this->decodeFrame(true, opts, rowsDecoded);
+}
+
+SkCodec::Result SkGifCodec::onStartIncrementalDecode(const SkImageInfo& dstInfo,
+                                                     void* pixels, size_t dstRowBytes,
+                                                     const SkCodec::Options& opts,
+                                                     SkPMColor* inputColorPtr,
+                                                     int* inputColorCount) {
+    Result result = this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, opts);
+    if (result != kSuccess) {
+        return result;
+    }
+
+    fDst = pixels;
+    fDstRowBytes = dstRowBytes;
+
+    if (opts.fSubset) {
+        fFirstRow = opts.fSubset->top();
+        fLastRow = opts.fSubset->bottom() - 1;
+    } else {
+        fFirstRow = 0;
+        fLastRow = dstInfo.height() - 1;
+    }
+
+    fFirstCallToIncrementalDecode = true;
+
     return kSuccess;
 }
 
-// FIXME: This is similar to the implementation for bmp and png.  Can we share more code or
-//        possibly make this non-virtual?
+SkCodec::Result SkGifCodec::onIncrementalDecode(int* rowsDecoded) {
+    // It is possible the client has appended more data. Parse, if needed.
+    const auto& options = this->options();
+    const size_t frameIndex = options.fFrameOptions ? options.fFrameOptions->fIndex : 0;
+    fReader->parse((GIFImageReader::GIFParseQuery) frameIndex);
+
+    const bool firstCallToIncrementalDecode = fFirstCallToIncrementalDecode;
+    fFirstCallToIncrementalDecode = false;
+    return this->decodeFrame(firstCallToIncrementalDecode, options, rowsDecoded);
+}
+
+SkCodec::Result SkGifCodec::decodeFrame(bool firstAttempt, const Options& opts, int* rowsDecoded) {
+    const SkImageInfo& dstInfo = this->dstInfo();
+    const size_t frameIndex = opts.fFrameOptions ? opts.fFrameOptions->fIndex : 0;
+    SkASSERT(frameIndex < fReader->imagesCount());
+    const GIFFrameContext* frameContext = fReader->frameContext(frameIndex);
+    if (firstAttempt) {
+        // rowsDecoded reports how many rows have been initialized, so a layer above
+        // can fill the rest. In some cases, we fill the background before decoding
+        // (or it is already filled for us), so we report rowsDecoded to be the full
+        // height.
+        bool filledBackground = false;
+        if (frameContext->getRequiredFrame() == kIndependentFrame) {
+            // We may need to clear to transparent for one of the following reasons:
+            // - The frameRect does not cover the full bounds. haveDecodedRow will
+            //   only draw inside the frameRect, so we need to clear the rest.
+            // - There is a valid transparent pixel value. (FIXME: I'm assuming
+            //   writeTransparentPixels will be false in this case, based on
+            //   Chromium's assumption that it would already be zeroed. If we
+            //   change that behavior, could we skip Filling here?)
+            // - The frame is interlaced. There is no obvious way to fill
+            //   afterwards for an incomplete image. (FIXME: Does the first pass
+            //   cover all rows? If so, we do not have to fill here.)
+            if (frameContext->frameRect() != this->getInfo().bounds()
+                    || frameContext->transparentPixel() < MAX_COLORS
+                    || frameContext->interlaced()) {
+                // fill ignores the width (replaces it with the actual, scaled width).
+                // But we need to scale in Y.
+                const int scaledHeight = get_scaled_dimension(dstInfo.height(), fSwizzler->sampleY());
+                auto fillInfo = dstInfo.makeWH(0, scaledHeight);
+                fSwizzler->fill(fillInfo, fDst, fDstRowBytes, this->getFillValue(dstInfo),
+                                opts.fZeroInitialized);
+                filledBackground = true;
+            }
+        } else {
+            // Not independent
+            if (opts.fFrameOptions && !opts.fFrameOptions->fHasPriorFrame) {
+                // Decode that frame into pixels.
+                Options prevFrameOpts(opts);
+                MultiFrameOptions prevFrameMultiOpts;
+                prevFrameMultiOpts.fIndex = frameContext->getRequiredFrame();
+                prevFrameMultiOpts.fHasPriorFrame = false;
+                prevFrameOpts.fFrameOptions = &prevFrameMultiOpts;
+                const Result prevResult = this->decodeFrame(true, prevFrameOpts, nullptr);
+                switch (prevResult) {
+                    case kSuccess:
+                        // Prior frame succeeded. Carry on.
+                        break;
+                    case kIncompleteInput:
+                        // Prior frame was incomplete. So this frame cannot be decoded.
+                        return kInvalidInput;
+                    default:
+                        return prevResult;
+                }
+            }
+            const GIFFrameContext* prevFrame = fReader->frameContext(frameContext->getRequiredFrame());
+            if (prevFrame->getDisposalMethod() == SkCodecAnimation::RestoreBGColor_DisposalMethod) {
+                const SkIRect prevRect = prevFrame->frameRect();
+                auto left = get_scaled_dimension(prevRect.fLeft, fSwizzler->sampleX());
+                auto top = get_scaled_dimension(prevRect.fTop, fSwizzler->sampleY());
+                void* const eraseDst = SkTAddOffset<void>(fDst, top * fDstRowBytes
+                        + left * SkColorTypeBytesPerPixel(dstInfo.colorType()));
+                auto width = get_scaled_dimension(prevRect.width(), fSwizzler->sampleX());
+                auto height = get_scaled_dimension(prevRect.height(), fSwizzler->sampleY());
+                // fSwizzler->fill() would fill to the scaled width of the frame, but we want to fill
+                // to the scaled with of the width of the PRIOR frame, so we do all the scaling
+                // ourselves and call the static version.
+                SkSampler::Fill(dstInfo.makeWH(width, height), eraseDst,
+                                fDstRowBytes, this->getFillValue(dstInfo), kNo_ZeroInitialized);
+            }
+            filledBackground = true;
+        }
+
+        fFilledBackground = filledBackground;
+        if (filledBackground) {
+            // Report the full (scaled) height, since the client will never need to fill.
+            fRowsDecoded = get_scaled_dimension(dstInfo.height(), fSwizzler->sampleY());
+        } else {
+            // This will be updated by haveDecodedRow.
+            fRowsDecoded = 0;
+        }
+    }
+
+    // Note: there is a difference between the following call to GIFImageReader::decode
+    // returning false and leaving frameDecoded false:
+    // - If the method returns false, there was an error in the stream. We still treat this as
+    //   incomplete, since we have already decoded some rows.
+    // - If frameDecoded is false, that just means that we do not have enough data. If more data
+    //   is supplied, we may be able to continue decoding this frame. We also treat this as
+    //   incomplete.
+    // FIXME: Ensure that we do not attempt to continue decoding if the method returns false and
+    // more data is supplied.
+    bool frameDecoded = false;
+    if (!fReader->decode(frameIndex, &frameDecoded) || !frameDecoded) {
+        if (rowsDecoded) {
+            *rowsDecoded = fRowsDecoded;
+        }
+        return kIncompleteInput;
+    }
+
+    return kSuccess;
+}
+
 uint64_t SkGifCodec::onGetFillValue(const SkImageInfo& dstInfo) const {
-    const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-    return get_color_table_fill_value(dstInfo.colorType(), dstInfo.alphaType(), colorPtr,
-                                      fFillIndex, nullptr);
-}
-
-SkCodec::Result SkGifCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
-        const SkCodec::Options& opts, SkPMColor inputColorPtr[], int* inputColorCount) {
-    return this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, opts);
-}
-
-void SkGifCodec::handleScanlineFrame(int count, int* rowsBeforeFrame, int* rowsInFrame) {
-    if (fFrameIsSubset) {
-        const int currRow = this->currScanline();
-
-        // The number of rows that remain to be skipped before reaching rows that we
-        // actually must decode into.
-        // This must be at least zero.  We also make sure that it is less than or
-        // equal to count, since we will skip at most count rows.
-        *rowsBeforeFrame = SkTMin(count, SkTMax(0, fFrameRect.top() - currRow));
-
-        // Rows left to decode once we reach the start of the frame.
-        const int rowsLeft = count - *rowsBeforeFrame;
-
-        // Count the number of that extend beyond the bottom of the frame.  We do not
-        // need to decode into these rows.
-        const int rowsAfterFrame = SkTMax(0, currRow + rowsLeft - fFrameRect.bottom());
-
-        // Set the actual number of source rows that we need to decode.
-        *rowsInFrame = rowsLeft - rowsAfterFrame;
+    // Note: Using fCurrColorTable relies on having called initializeColorTable already.
+    // This is (currently) safe because this method is only called when filling, after
+    // initializeColorTable has been called.
+    // FIXME: Is there a way to make this less fragile?
+    if (dstInfo.colorType() == kIndex_8_SkColorType && fCurrColorTableIsReal) {
+        // We only support index 8 for the first frame, for backwards
+        // compatibity on Android, so we are using the color table for the first frame.
+        SkASSERT(!this->options().fFrameOptions || this->options().fFrameOptions->fIndex == 0);
+        // Use the transparent index for the first frame.
+        const size_t transPixel = fReader->frameContext(0)->transparentPixel();
+        if (transPixel < (size_t) fCurrColorTable->count()) {
+            return transPixel;
+        }
+
+        const size_t backgroundIndex = fReader->getBackgroundIndex();
+        if (backgroundIndex < (size_t) fCurrColorTable->count()) {
+            // Note that this matches the old behavior in SkGifCodec, and the
+            // older behavior in SkImageDecoder_libgif. But in the case where
+            // the color table being used is a local color table, this is
+            // wrong - the background index is supposed to apply to the global
+            // color table. That said, we cannot guarantee that we can use a
+            // background color from the global color table if there is a local
+            // color table anyway.
+            return backgroundIndex;
+        }
+
+        // Neither index is useful, so we fall through to return
+        // SK_ColorTRANSPARENT (i.e. 0). This arbitrary choice matches our old
+        // behavior.
+    }
+    // Using transparent as the fill value matches the behavior in Chromium,
+    // which ignores the background color.
+    // If the colorType is kIndex_8, and there was no color table (i.e.
+    // fCurrColorTableIsReal is false), this value (zero) corresponds to the
+    // only entry in the dummy color table provided to the client.
+    return SK_ColorTRANSPARENT;
+}
+
+bool SkGifCodec::haveDecodedRow(size_t frameIndex, const unsigned char* rowBegin,
+                                size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels)
+{
+    const GIFFrameContext* frameContext = fReader->frameContext(frameIndex);
+    // The pixel data and coordinates supplied to us are relative to the frame's
+    // origin within the entire image size, i.e.
+    // (frameContext->xOffset, frameContext->yOffset). There is no guarantee
+    // that width == (size().width() - frameContext->xOffset), so
+    // we must ensure we don't run off the end of either the source data or the
+    // row's X-coordinates.
+    const size_t width = frameContext->width();
+    const int xBegin = frameContext->xOffset();
+    const int yBegin = frameContext->yOffset() + rowNumber;
+    const int xEnd = std::min(static_cast<int>(frameContext->xOffset() + width),
+                              this->getInfo().width());
+    const int yEnd = std::min(static_cast<int>(frameContext->yOffset() + rowNumber + repeatCount),
+                              this->getInfo().height());
+    // FIXME: No need to make the checks on width/xBegin/xEnd for every row. We could instead do
+    // this once in prepareToDecode.
+    if (!width || (xBegin < 0) || (yBegin < 0) || (xEnd <= xBegin) || (yEnd <= yBegin))
+        return true;
+
+    // Due to sampling (or subsetting, if we add that feature to SkGifCodec), this may be out of
+    // the range we will draw to the destination.
+    if (yBegin > fLastRow || yEnd - 1 < fFirstRow) {
+        // FIXME: Should we exit early for non-interlaced decodes once we reach the last row?
+        return true;
+    }
+
+    // yBegin is the first row in the non-sampled image. dstRow will be the row in the output,
+    // after potentially scaling it.
+    int dstRow = yBegin;
+
+    if (fSwizzler->sampleY() > 1) {
+        // Check to see whether this row or one that falls in the repeatCount is needed in the
+        // output.
+        bool foundNecessaryRow = false;
+        for (unsigned i = 0; i < repeatCount; i++) {
+            const int potentialRow = yBegin - fFirstRow + i;
+            if (potentialRow < 0 ) {
+                continue;
+            }
+            if (fSwizzler->rowNeeded(potentialRow)) {
+                foundNecessaryRow = true;
+                dstRow = potentialRow / fSwizzler->sampleY();
+                repeatCount -= i;
+                repeatCount = (repeatCount - 1) / fSwizzler->sampleY() + 1;
+
+                // Make sure the repeatCount does not take us beyond the end of the dst
+                const size_t scaledHeight = get_scaled_dimension(this->dstInfo().height(),
+                                                                 fSwizzler->sampleY());
+                if (dstRow + repeatCount > scaledHeight) {
+                    repeatCount = scaledHeight - dstRow;
+                    SkASSERT(repeatCount >= 1);
+                }
+                break;
+            }
+        }
+
+        if (!foundNecessaryRow) {
+            return true;
+        }
+    }
+
+    if (!fFilledBackground) {
+        // At this point, we are definitely going to write the row, so count it towards the number
+        // of rows decoded.
+        // We do not consider the repeatCount, which only happens for interlaced, in which case we
+        // have already set fRowsDecoded to the proper value (reflecting that we have filled the
+        // background).
+        fRowsDecoded++;
+    }
+
+    if (!fCurrColorTableIsReal) {
+        // No color table, so nothing to draw this frame.
+        // FIXME: We can abort even earlier - no need to decode this frame.
+        return true;
+    }
+
+    // The swizzler takes care of offsetting into the dst width-wise.
+    void* dstLine = SkTAddOffset<void>(fDst, dstRow * fDstRowBytes);
+
+    // We may or may not need to write transparent pixels to the buffer.
+    // If we're compositing against a previous image, it's wrong, and if
+    // we're writing atop a cleared, fully transparent buffer, it's
+    // unnecessary; but if we're decoding an interlaced gif and
+    // displaying it "Haeberli"-style, we must write these for passes
+    // beyond the first, or the initial passes will "show through" the
+    // later ones.
+    if (writeTransparentPixels) {
+        fSwizzler->swizzle(dstLine, rowBegin);
     } else {
-        *rowsBeforeFrame = 0;
-        *rowsInFrame = count;
-    }
-}
-
-int SkGifCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
-    int rowsBeforeFrame;
-    int rowsInFrame;
-    this->handleScanlineFrame(count, &rowsBeforeFrame, &rowsInFrame);
-
-    if (fFrameIsSubset) {
-        // Fill the requested rows
-        SkImageInfo fillInfo = this->dstInfo().makeWH(this->dstInfo().width(), count);
-        uint64_t fillValue = this->onGetFillValue(this->dstInfo());
-        fSwizzler->fill(fillInfo, dst, rowBytes, fillValue, this->options().fZeroInitialized);
-
-        // Start to write pixels at the start of the image frame
-        dst = SkTAddOffset<void>(dst, rowBytes * rowsBeforeFrame);
-    }
-
-    for (int i = 0; i < rowsInFrame; i++) {
-        if (!this->readRow()) {
-            return i + rowsBeforeFrame;
-        }
-        fSwizzler->swizzle(dst, fSrcBuffer.get());
-        dst = SkTAddOffset<void>(dst, rowBytes);
-    }
-
-    return count;
-}
-
-bool SkGifCodec::onSkipScanlines(int count) {
-    int rowsBeforeFrame;
-    int rowsInFrame;
-    this->handleScanlineFrame(count, &rowsBeforeFrame, &rowsInFrame);
-
-    for (int i = 0; i < rowsInFrame; i++) {
-        if (!this->readRow()) {
-            return false;
+        // We cannot swizzle directly into the dst, since that will write the transparent pixels.
+        // Instead, swizzle into a temporary buffer, and copy that into the dst.
+        const auto dstInfo = this->dstInfo();
+        // Although onGetFillValue returns a uint64_t, we only use the low eight bits.
+        memset(fTmpBuffer.get(), (uint8_t) this->onGetFillValue(dstInfo), dstInfo.minRowBytes());
+        fSwizzler->swizzle(fTmpBuffer.get(), rowBegin);
+
+        const size_t offsetBytes = fSwizzler->swizzleOffsetBytes();
+        switch (dstInfo.colorType()) {
+            case kBGRA_8888_SkColorType:
+            case kRGBA_8888_SkColorType: {
+                uint32_t* dstPixel = SkTAddOffset<uint32_t>(dstLine, offsetBytes);
+                uint32_t* srcPixel = SkTAddOffset<uint32_t>(fTmpBuffer.get(), offsetBytes);
+                for (int i = 0; i < fSwizzler->swizzleWidth(); i++) {
+                    // Technically SK_ColorTRANSPARENT is an SkPMColor, and srcPixel would have
+                    // the opposite swizzle for the non-native swizzle, but TRANSPARENT is all
+                    // zeroes, which is the same either way.
+                    if (*srcPixel != SK_ColorTRANSPARENT) {
+                        *dstPixel = *srcPixel;
+                    }
+                    dstPixel++;
+                    srcPixel++;
+                }
+                break;
+            }
+            case kIndex_8_SkColorType: {
+                uint8_t* dstPixel = SkTAddOffset<uint8_t>(dstLine, offsetBytes);
+                uint8_t* srcPixel = SkTAddOffset<uint8_t>(fTmpBuffer.get(), offsetBytes);
+                for (int i = 0; i < fSwizzler->swizzleWidth(); i++) {
+                    if (*srcPixel != frameContext->transparentPixel()) {
+                        *dstPixel = *srcPixel;
+                    }
+                    dstPixel++;
+                    srcPixel++;
+                }
+                break;
+            }
+            default:
+                SkASSERT(false);
+                break;
+        }
+    }
+
+    // Tell the frame to copy the row data if need be.
+    if (repeatCount > 1) {
+        const size_t bytesPerPixel = SkColorTypeBytesPerPixel(this->dstInfo().colorType());
+        const size_t bytesToCopy = fSwizzler->swizzleWidth() * bytesPerPixel;
+        void* copiedLine = SkTAddOffset<void>(dstLine, fSwizzler->swizzleOffsetBytes());
+        void* dst = copiedLine;
+        for (unsigned i = 1; i < repeatCount; i++) {
+            dst = SkTAddOffset<void>(dst, fDstRowBytes);
+            memcpy(dst, copiedLine, bytesToCopy);
         }
     }
 
     return true;
 }
-
-SkCodec::SkScanlineOrder SkGifCodec::onGetScanlineOrder() const {
-    if (fGif->Image.Interlace) {
-        return kOutOfOrder_SkScanlineOrder;
-    }
-    return kTopDown_SkScanlineOrder;
-}
-
-int SkGifCodec::onOutputScanline(int inputScanline) const {
-    if (fGif->Image.Interlace) {
-        if (inputScanline < fFrameRect.top() || inputScanline >= fFrameRect.bottom()) {
-            return inputScanline;
-        }
-        return get_output_row_interlaced(inputScanline - fFrameRect.top(), fFrameRect.height()) +
-                fFrameRect.top();
-    }
-    return inputScanline;
-}