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.
  */
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkCodecAnimation.h"
@@ skipping 248 matching lines @@
             // A lot of users (including Chromium!) ignore the background color, but we (currently)
             // use it to fill in the color table if it's less than 256 colors.
             fColorTable.reset(create_color_table(*desc.ColorMap, transIndex, SK_MaxU32));
         }
     }
 
     for (int i = 0; i < gif->ImageCount; i++) {
         const SavedImage* image = &gif->SavedImages[i];
         const GifImageDesc& desc = image->ImageDesc;
 
-        auto& frame = fFrameInfos.push_back();
+        auto& frame = fFrameInfos[i];
         // FIXME: Probably want to intersect this with the bounds, just in case.
         // But then we'll need to make sure we draw the right thing...
         // i.e. if the top is cut off (desc.Top < 0), we want to start off drawing line -desc.Top
         // (probably?)
         // Or if we're cut off width-wise, we need to ensure we use the original row bytes
         // (desc.Width) but the corrected width.
         frame.fFrameRect = SkIRect::MakeXYWH(desc.Left, desc.Top, desc.Width, desc.Height);
         if (!read_graphics_extension(*image, &frame.fTransIndex, &frame.fDuration,
                                      &frame.fDisposalMethod)) {
             frame.fDisposalMethod = SkCodecAnimation::Keep_DisposalMethod;
@@ skipping 20 matching lines @@
                         frame.fRequiredFrame = kIndependentFrame;
                     } else {
                         frame.fRequiredFrame = i - 1;
                     }
                     break;
             }
         }
     }
 }
 
-size_t SkGifCodec::onGetRequiredFrame(size_t index) {
-    if ((int) index >= fFrameInfos.count()) {
-        return kIndependentFrame;
+std::vector<SkCodec::FrameInfo> SkGifCodec::onGetFrameInfo() {
+    const size_t size = fFrameInfos.size();
+    if (1 == size) {
+        // As with other formats, return empty set for non-animated
+        // FIXME: But it might be animated, we just haven't received the second frame?
+        // I suppose we could check the duration? But even that might not be perfect...
+        return {};
     }
-
-    return fFrameInfos[index].fRequiredFrame;
-}
-
-size_t SkGifCodec::onGetFrameDuration(size_t index) {
-    if ((int) index >= fFrameInfos.count()) {
-        return 0;
+    std::vector<FrameInfo> result(size);
+    for (size_t i = 0; i < size; i++) {
+        result[i] = (FrameInfo) fFrameInfos[i];
     }
-
-    return fFrameInfos[index].fDuration;
+    return result;
 }
 
 bool SkGifCodec::GetDimensions(GifFileType* gif, SkISize* size) {
     // Get the encoded dimension values for the first frame. Some GIFs have frames that are bigger
     // than the screen width and height. For the first frame only, we will expand in that case.
     SavedImage* image = &gif->SavedImages[0];
     const GifImageDesc& desc = image->ImageDesc;
     int frameLeft = desc.Left;
     int frameTop = desc.Top;
     int frameWidth = desc.Width;
@@ skipping 87 matching lines @@
             && 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.
         return gif_error("Cannot decode multiframe gif (except frame 0) as index 8.\n",
                          kInvalidConversion);
     }
 
-    if (opts.fFrameOptions && (int) opts.fFrameOptions->fIndex > fFrameInfos.count()) {
+    if (opts.fFrameOptions && opts.fFrameOptions->fIndex > fFrameInfos.size()) {
         return gif_error("frame index out of range!\n", kInvalidParameters);
     }
 
     // Initialize color table and copy to the client if necessary
     this->initializeColorTable(dstInfo, inputColorPtr, inputColorCount);
     return kSuccess;
 }
 
 /*
  * Initiates the gif decode
@@ skipping 17 matching lines @@
     return kSuccess;
 }
 
 // FIXME: This should be SkCodec::Result, probably?
 void SkGifCodec::decodeFrame(const SkImageInfo& dstInfo, void* pixels, size_t dstRowBytes,
                              const Options& opts) {
     SkBitmap tmpBm;
     void* dst = pixels;
 
     const size_t frameIndex = opts.fFrameOptions ? opts.fFrameOptions->fIndex : 0;
-    SkASSERT((int) frameIndex < fFrameInfos.count());
+    SkASSERT(frameIndex < fFrameInfos.size());
     const auto& frameInfo = fFrameInfos[frameIndex];
     const SkIRect& frameRect = frameInfo.fFrameRect;
     const bool independent = frameInfo.fRequiredFrame == kIndependentFrame;
     if (!independent) {
         if (opts.fFrameOptions && !opts.fFrameOptions->fHasPriorFrame) {
             // Decode that frame into pixels.
             Options prevFrameOpts(opts);
             MultiFrameOptions prevFrameMultiOpts;
             prevFrameMultiOpts.fIndex = frameInfo.fRequiredFrame;
             prevFrameMultiOpts.fHasPriorFrame = false;
@@ skipping 70 matching lines @@
     }
 }
 
 // FIXME: This is similar to the implementation for bmp and png.  Can we share more code or
 //        possibly make this non-virtual?
 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);
 }