Add support for multiple frames in SkCodec

src/codec/SkGifCodec.h

Index: src/codec/SkGifCodec.h
diff --git a/src/codec/SkGifCodec.h b/src/codec/SkGifCodec.h
index c56d3719a9e0733acf7d078e49ca889f48727323..4b343e682b3bb1c9b4b28071eb37c451ba200f70 100644
--- a/src/codec/SkGifCodec.h
+++ b/src/codec/SkGifCodec.h
@@ -6,13 +6,13 @@
  */
 
 #include "SkCodec.h"
+#include "SkCodecAnimation.h"
 #include "SkColorSpace.h"
 #include "SkColorTable.h"
 #include "SkImageInfo.h"
 #include "SkSwizzler.h"
 
-struct GifFileType;
-struct SavedImage;
+#include "GIFImageReader.h"
 
 /*
  *
@@ -30,30 +30,10 @@ public:
      */
     static SkCodec* NewFromStream(SkStream*);
 
+    // Callback for GIFImageReader when a row is available.
+    bool haveDecodedRow(size_t frameIndex, const unsigned char* rowBegin,

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

Seems strange to me that this is public...  I guess we never really allow people
to know that they specifically have an SkGifCodec anyway.

Still I think I might prefer hiding this and friend classing GIFImageReader.

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

Indeed, it is a little awkward, though someone would have to go out of their way
to abuse it.
That strikes me as more dangerous. The GIFImageReader can then call any method
on SkGifCodec, or change its private variables.

+                        size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels);
 protected:
-
-    /*
-     * 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.
-     *
-     */
-    static bool ReadHeader(SkStream* stream, SkCodec** codecOut,
-            GifFileType** gifOut);
-
     /*
      * Performs the full gif decode
      */
@@ -68,55 +48,36 @@ protected:
 
     uint64_t onGetFillValue(const SkImageInfo&) const override;
 
-    int onOutputScanline(int inputScanline) const override;
+    std::vector<FrameInfo> onGetFrameInfo() override;
 
-private:
+    Result onStartIncrementalDecode(const SkImageInfo& /*dstInfo*/, void*, size_t,
+            const SkCodec::Options&, SkPMColor*, int*) override;
 
-    /*
-     * A gif can contain multiple image frames.  We will only decode the first
-     * frame.  This function reads up to the first image frame, processing
-     * transparency and/or animation information that comes before the image
-     * data.
-     *
-     * @param gif        Pointer to the library type that manages the gif decode
-     * @param transIndex This call will set the transparent index based on the
-     *                   extension data.
-     */
-     static Result ReadUpToFirstImage(GifFileType* gif, uint32_t* transIndex);
-
-     /*
-      * A gif may contain many image frames, all of different sizes.
-      * This function checks if the gif dimensions are valid, based on the frame
-      * dimensions, and corrects the gif dimensions if necessary.
-      *
-      * @param gif       Pointer to the library type that manages the gif decode
-      * @param size      Size of the image that we will decode.
-      *                  Will be set by this function if the return value is true.
-      * @param frameRect Contains the dimenions and offset of the first image frame.
-      *                  Will be set by this function if the return value is true.
-      *
-      * @return true on success, false otherwise
-      */
-     static bool GetDimensions(GifFileType* gif, SkISize* size, SkIRect* frameRect);
+    Result onIncrementalDecode(int*) override;
+
+private:
 
     /*
      * Initializes the color table that we will use for decoding.
      *
      * @param dstInfo         Contains the requested dst color type.
+     * @param frameIndex      Frame whose color table to use.
      * @param inputColorPtr   Copies the encoded color table to the client's
      *                        input color table if the client requests kIndex8.
      * @param inputColorCount If the client requests kIndex8, sets
      *                        inputColorCount to 256.  Since gifs always
      *                        contain 8-bit indices, we need a 256 entry color

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

Maybe delete this wrong comment?  (pretty sure I wrote it)

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

I updated the comment to better reflect what happens.

      *                        table to ensure that indexing is always in
-     *                        bounds.
+     *                        bounds. (Exception - set to 1 if the gif's color
+     *                        table is missing. The only entry will be
+     *                        transparent.)
      */
-    void initializeColorTable(const SkImageInfo& dstInfo, SkPMColor* colorPtr,
-            int* inputColorCount);
+    void initializeColorTable(const SkImageInfo& dstInfo, size_t frameIndex,
+            SkPMColor* colorPtr, int* inputColorCount);
 
    /*
-    * Checks for invalid inputs and calls setFrameDimensions(), and
-    * initializeColorTable() in the proper sequence.
+    * Does necessary setup, including setting up the color table and swizzler,
+    * and reports color info to the client.
     */
     Result prepareToDecode(const SkImageInfo& dstInfo, SkPMColor* inputColorPtr,
             int* inputColorCount, const Options& opts);
@@ -124,82 +85,75 @@ private:
     /*
      * Initializes the swizzler.
      *
-     * @param dstInfo  Output image information.  Dimensions may have been
-     *                 adjusted if the image frame size does not match the size
-     *                 indicated in the header.
-     * @param options  Informs the swizzler if destination memory is zero initialized.
-     *                 Contains subset information.
+     * @param dstInfo    Output image information.  Dimensions may have been
+     *                   adjusted if the image frame size does not match the size
+     *                   indicated in the header.
+     * @param frameIndex Which frame we are decoding. This determines the frameRect
+     *                   to use.
      */
-    void initializeSwizzler(const SkImageInfo& dstInfo,
-            const Options& options);
+    void initializeSwizzler(const SkImageInfo& dstInfo, size_t frameIndex);
 
     SkSampler* getSampler(bool createIfNecessary) override {
         SkASSERT(fSwizzler);
-        return fSwizzler;
+        return fSwizzler.get();
     }
 
     /*
-     * @return true if the read is successful and false if the read fails.
-     */
-    bool readRow();
-
-    Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& opts,
-                   SkPMColor inputColorPtr[], int* inputColorCount) override;
-
-    int onGetScanlines(void* dst, int count, size_t rowBytes) override;
-
-    bool onSkipScanlines(int count) override;
-
-    /*
-     * For a scanline decode of "count" lines, this function indicates how
-     * many of the "count" lines should be skipped until we reach the top of
-     * the image frame and how many of the "count" lines are actually inside
-     * the image frame.
+     * Recursive function to decode a frame.
      *
-     * @param count           The number of scanlines requested.
-     * @param rowsBeforeFrame Output variable.  The number of lines before
-     *                        we reach the top of the image frame.
-     * @param rowsInFrame     Output variable.  The number of lines to decode
-     *                        inside the image frame.
-     */
-    void handleScanlineFrame(int count, int* rowsBeforeFrame, int* rowsInFrame);
-
-    SkScanlineOrder onGetScanlineOrder() const override;
-
-    /*
-     * This function cleans up the gif object after the decode completes
-     * It is used in a SkAutoTCallIProc template
+     * @param firstAttempt Whether this is the first call to decodeFrame since
+     *                     starting. e.g. true in onGetPixels, and true in the
+     *                     first call to onIncrementalDecode after calling
+     *                     onStartIncrementalDecode.
+     *                     When true, this method may have to initialize the
+     *                     frame, for example by filling or decoding the prior
+     *                     frame.
+     * @param opts         Options for decoding. May be different from
+     *                     this->options() for decoding prior frames. Specifies
+     *                     the frame to decode and whether the prior frame has
+     *                     already been decoded to fDst. If not, and the frame
+     *                     is not independent, this method will recursively
+     *                     decode the frame it depends on.
+     * @param rowsDecoded  Out-parameter to report the total number of rows
+     *                     that have been decoded (or at least written to, if
+     *                     it had to fill), including rows decoded by prior
+     *                     calls to onIncrementalDecode.
+     * @return             kSuccess if the frame is complete, kIncompleteInput
+     *                     otherwise.
      */
-    static void CloseGif(GifFileType* gif);
-
-    /*
-     * Frees any extension data used in the decode
-     * Used in a SkAutoTCallVProc
-     */
-    static void FreeExtension(SavedImage* image);
+    Result decodeFrame(bool firstAttempt, const Options& opts, int* rowsDecoded);
 
     /*
      * Creates an instance of the decoder
      * Called only by NewFromStream
-     *
-     * @param info contains properties of the encoded data
-     * @param stream the stream of image data
-     * @param gif pointer to library type that manages gif decode
-     *            takes ownership
-     * @param transIndex  The transparent index.  An invalid value
-     *            indicates that there is no transparent index.
+     * Takes ownership of the GIFImageReader
      */
-    SkGifCodec(int width, int height, const SkEncodedInfo& info, SkStream* stream,
-            GifFileType* gif, uint32_t transIndex, const SkIRect& frameRect, bool frameIsSubset);
-
-    SkAutoTCallVProc<GifFileType, CloseGif> fGif; // owned
-    SkAutoTDeleteArray<uint8_t>             fSrcBuffer;
-    const SkIRect                           fFrameRect;
-    const uint32_t                          fTransIndex;
-    uint32_t                                fFillIndex;
-    const bool                              fFrameIsSubset;
-    SkAutoTDelete<SkSwizzler>               fSwizzler;
-    SkAutoTUnref<SkColorTable>              fColorTable;
+    SkGifCodec(GIFImageReader*);
+
+    std::unique_ptr<GIFImageReader>         fReader;
+    std::unique_ptr<uint8_t[]>              fTmpBuffer;
+    std::unique_ptr<SkSwizzler>             fSwizzler;
+    sk_sp<SkColorTable>                     fCurrColorTable;
+    // We may create a dummy table if there is not a Map in the input data. In
+    // that case, we set this value to false, and we can skip a lot of decoding
+    // work (which would not be meaningful anyway). We create a "fake"/"dummy"
+    // one in that case, so the client and the swizzler have something to draw.
+    bool                                    fCurrColorTableIsReal;
+    // Whether the background was filled.
+    bool                                    fFilledBackground;
+    // True on the first call to onIncrementalDecode. This value is passed to
+    // decodeFrame.
+    bool                                    fFirstCallToIncrementalDecode;
+
+    void*                                   fDst;
+    size_t                                  fDstRowBytes;
+
+    int                                     fFirstRow;
+    int                                     fLastRow;
+
+    // Updated inside haveDecodedRow when rows are decoded, unless we filled
+    // the background, in which case it is set once and left alone.
+    int                                     fRowsDecoded;
 
     typedef SkCodec INHERITED;
 };