Add support for multiple frames in SkCodec

include/codec/SkCodec.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCodec_DEFINED
 #define SkCodec_DEFINED
 
 #include "../private/SkTemplates.h"
 #include "SkColor.h"
 #include "SkEncodedFormat.h"
 #include "SkEncodedInfo.h"
 #include "SkImageInfo.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkTypes.h"
 #include "SkYUVSizeInfo.h"
 
+#include <vector>
+
 class SkColorSpace;
 class SkData;
 class SkPngChunkReader;
 class SkSampler;
 
 namespace DM {
 class CodecSrc;
 class ColorCodecSrc;
 }
 class ColorCodecBench;
@@ skipping 568 matching lines @@
     /**
      *  Returns the output y-coordinate of the row that corresponds to an input
      *  y-coordinate.  The input y-coordinate represents where the scanline
      *  is located in the encoded data.
      *
      *  This will equal inputScanline, except in the case of strangely
      *  encoded image types (bottom-up bmps, interlaced gifs).
      */
     int outputScanline(int inputScanline) const;
 
-    /**
-     *  Return the number of frames in the image.
-     *
-     *  May require reading through the stream to determine the number of
-     *  frames.
-     *
-     *  As such, future decoding calls may require a rewind.
-     */
-    size_t getFrameCount() {
-        return this->onGetFrameCount();
-    }
-
     // The required frame for an independent frame is marked as
     // kIndependentFrame.
     static constexpr size_t kIndependentFrame = static_cast<size_t>(-1);
 
     /**
-     *  For a multiframed image, return the image that frame |index| needs to
-     *  be blended with.
-     *
-     *  If the frame needs no blending, return kIndependentFrame.
+     *  Information about individual frames in a multi-framed image.
      */
-    size_t getRequiredFrame(size_t index) {
-        return this->onGetRequiredFrame(index);
-    }
+    struct FrameInfo {
+        /**
+         *  The frame that this frame needs to be blended with, or
+         *  kIndependentFrame.
+         */
+        size_t fRequiredFrame;
+
+        /**
+         *  Number of 1/100 seconds to show this frame.
+         */
+        size_t fDuration;
+    };
 
     /**
-     *  For a multiframed image, return the number of 1/100 seconds to
-     *  show frame |index|.
+     *  Return info about the frames in the image.
+     *
+     *  May require reading through the stream to determine the number of
+     *  frames.
+     *
+     *  As such, future decoding calls may require a rewind.
+     *
+     *  For single-frame images, this will return an empty vector.
      */
-    size_t getFrameDuration(size_t index) {
-        return this->onGetFrameDuration(index);
+    std::vector<FrameInfo> getFrameInfo() {

[scroggo, 2016/09/26 15:51:43]

sgtm
I guess there's not a huge downside - I don't want the caller to think they need
to animate or to think e.g. fDuration means something when it doesn't.

But as you say below, a GIF with only one frame received so far should have some
information about fDuration that will give us a hint that it is animated.
It looks like Chrome defaults to 0 delay time [1], keep disposal method [2], and
loop once [4]

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...
[2]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...
(ImageFrame::DisposeNotSpecified is treated the same as keep [3])
[3]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...
[4]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...
Each time the client calls getFrameInfo(), we're going to have to create a new
vector (or copy one, if we have it internally) with this API. This is true even
if nothing has changed.

That seems like unnecessary work/memory use, but that's just me prematurely
optimizing...

+        return this->onGetFrameInfo();
     }
 
 protected:
     /**
      *  Takes ownership of SkStream*
      */
     SkCodec(int width,
             int height,
             const SkEncodedInfo&,
             SkStream*,
@@ skipping 122 matching lines @@
     /**
      *  Returns the number of scanlines that have been decoded so far.
      *  This is unaffected by the SkScanlineOrder.
      *
      *  Returns -1 if we have not started a scanline decode.
      */
     int currScanline() const { return fCurrScanline; }
 
     virtual int onOutputScanline(int inputScanline) const;
 
-    virtual size_t onGetFrameCount() {
-        return 1;
-    }
-
-    virtual size_t onGetRequiredFrame(size_t) {
-        return kIndependentFrame;
-    }
-
-    virtual size_t onGetFrameDuration(size_t) {
-        return 0;
+    virtual std::vector<FrameInfo> onGetFrameInfo() {
+        // empty vector - this is not animated.
+        return {};
     }
 
     /**
      *  Used for testing with qcms.
      *  FIXME: Remove this when we are done comparing with qcms.
      */
     virtual sk_sp<SkData> getICCData() const { return nullptr; }
 private:
     const SkEncodedInfo         fEncodedInfo;
     const SkImageInfo           fSrcInfo;
@@ skipping 72 matching lines @@
     // For testing with qcms
     // FIXME: Remove these when we are done comparing with qcms.
     friend class DM::ColorCodecSrc;
     friend class ColorCodecBench;
 
     friend class DM::CodecSrc;  // for fillIncompleteImage
     friend class SkSampledCodec;
     friend class SkIcoCodec;
 };
 #endif // SkCodec_DEFINED