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
 
@@ skipping 202 matching lines @@
          */
         kCouldNotRewind,
         /**
          *  This method is not implemented by this codec.
          *  FIXME: Perhaps this should be kUnsupported?
          */
         kUnimplemented,
     };
 
     /**
+     *  Additional options that only apply to multiframe images.
+     */
+    struct MultiFrameOptions {

[msarett, 2016/09/26 14:13:13]

I like how this looks, but don't feel strongly.  Might be convenient to have
this is a struct if we decide to add/remove multi-frame options.

Also might be nice to do something similar for "ColorTableOptions".

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

+1

+        MultiFrameOptions()
+            : fIndex(0)
+            , fHasPriorFrame(false)
+        {}
+
+        /**
+         *  The frame to decode.
+         */
+        size_t fIndex;
+
+        /**
+         *  If true, the dst already contains the prior frame.
+         *
+         *  If fIndex needs to be blended with a prior frame (as reported by
+         *  getRequiredFrame(fIndex)), the client can set this to either
+         *  true or false:
+         *
+         *  true means that the prior frame is already in the dst, and this
+         *  codec only needs to decode fIndex and blend it with the dst.
+         *  Options.fZeroInitialized is ignored in this case.
+         *
+         *  false means that the dst does not contain the prior frame, so this
+         *  codec needs to first decode the prior frame (which in turn may need
+         *  to decode its prior frame).
+         */
+        bool   fHasPriorFrame;
+    };
+
+    /**
      *  Whether or not the memory passed to getPixels is zero initialized.
      */
     enum ZeroInitialized {
         /**
          *  The memory passed to getPixels is zero initialized. The SkCodec
          *  may take advantage of this by skipping writing zeroes.
          */
         kYes_ZeroInitialized,
         /**
          *  The memory passed to getPixels has not been initialized to zero,
          *  so the SkCodec must write all zeroes to memory.
          *
          *  This is the default. It will be used if no Options struct is used.
          */
         kNo_ZeroInitialized,
     };
 
     /**
      *  Additional options to pass to getPixels.
      */
     struct Options {
         Options()
             : fZeroInitialized(kNo_ZeroInitialized)
-            , fSubset(NULL)
+            , fSubset(nullptr)
+            , fFrameOptions(nullptr)
         {}
 
-        ZeroInitialized fZeroInitialized;
+        ZeroInitialized     fZeroInitialized;
         /**
          *  If not NULL, represents a subset of the original image to decode.
          *  Must be within the bounds returned by getInfo().
          *  If the EncodedFormat is kWEBP_SkEncodedFormat (the only one which
          *  currently supports subsets), the top and left values must be even.
          *
          *  In getPixels and incremental decode, we will attempt to decode the
          *  exact rectangular subset specified by fSubset.
          *
          *  In a scanline decode, it does not make sense to specify a subset
          *  top or subset height, since the client already controls which rows
          *  to get and which rows to skip.  During scanline decodes, we will
          *  require that the subset top be zero and the subset height be equal
          *  to the full height.  We will, however, use the values of
          *  subset left and subset width to decode partial scanlines on calls
          *  to getScanlines().
          */
-        SkIRect*        fSubset;
+        SkIRect*            fSubset;
+
+        /**
+         *  Options that are only relevant for multi-frame images.
+         *
+         *  Unowned pointer.
+         */
+        MultiFrameOptions*  fFrameOptions;
     };
 
     /**
      *  Decode into the given pixels, a block of memory of size at
      *  least (info.fHeight - 1) * rowBytes + (info.fWidth *
      *  bytesPerPixel)
      *
      *  Repeated calls to this function should give the same results,
      *  allowing the PixelRef to be immutable.
      *
@@ skipping 281 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.
+     */
+    size_t getRequiredFrame(size_t index) {
+        return this->onGetRequiredFrame(index);
+    }
+
+    /**
+     *  For a multiframed image, return the number of 1/100 seconds to
+     *  show frame |index|.
+     */
+    size_t getFrameDuration(size_t index) {
+        return this->onGetFrameDuration(index);
+    }
+
 protected:
     /**
      *  Takes ownership of SkStream*
      */
     SkCodec(int width,
             int height,
             const SkEncodedInfo&,
             SkStream*,
             sk_sp<SkColorSpace> = nullptr,
             Origin = kTopLeft_Origin);
@@ skipping 120 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;
+    }
+
     /**
      *  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;
     SkAutoTDelete<SkStream>     fStream;
     bool                        fNeedsRewind;
@@ skipping 70 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