Scanline decoding for gifs

src/codec/SkCodec_libgif.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.
  */
 
 #include "SkCodec.h"
+#include "SkColorTable.h"
 #include "SkImageInfo.h"
+#include "SkScanlineDecoder.h"
+#include "SkSwizzler.h"
 
 #include "gif_lib.h"
 
 /*
  *
  * This class implements the decoding for gif images
  *
  */
 class SkGifCodec : public SkCodec {
 public:
 
     /*
      * Checks the start of the stream to see if the image is a gif
      */
     static bool IsGif(SkStream*);
 
     /*
      * Assumes IsGif was called and returned true
      * Creates a gif decoder
      * Reads enough of the stream to determine the image format
      */
     static SkCodec* NewFromStream(SkStream*);
     
+    static SkScanlineDecoder* NewSDFromStream(SkStream* stream);
 
 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 NULL,
      * codecOut will be set to a new SkGifCodec.
      *
      * @param gifOut
      * If it returned true, and codecOut was NULL,
      * gifOut must be non-NULL 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);
+    static bool ReadHeader(SkStream* stream, SkCodec** codecOut,
+            GifFileType** gifOut);
 
     /*
-     * Initiates the gif decode
+     * Performs the full gif decode
      */
     Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&,
             SkPMColor*, int32_t*) override;
 
     SkEncodedFormat onGetEncodedFormat() const override {
         return kGIF_SkEncodedFormat;
     }
 
     bool onRewind() override;
 
 private:
 
     /*
+     * 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 transIndex This call will set the transparent index based on the
+     *                   extension data.
+     */
+     SkCodec::Result readUpToFirstImage(uint32_t* transIndex);
+
+     /*
+      * A gif may contain many image frames, all of different sizes.
+      * This function checks if the frame dimensions are valid and corrects
+      * them if necessary.  It then sets fFrameDims to the corrected
+      * dimensions.
+      *
+      * @param desc The image frame descriptor
+      */
+     bool setFrameDimensions(const GifImageDesc& desc);
+
+    /*
+     * Initializes the color table that we will use for decoding.
+     * Sets inputColorCount to 256.  Since gifs always contain 8-bit indices,

[scroggo, 2015/08/27 16:35:50]

It seems weird that we always set this parameter to 256. Do we need that to be
in this function? I guess all places where we need to return this to the caller
share this function? In that case, maybe we should go all the way, and have this
function also call copy_color_table?

[msarett, 2015/09/01 18:03:59]

Sorry forgot this comment.  Moving copy_color_table into initializeColorTable,
which I think makes sense.

+     * we need a 256 entry color table to ensure that indexing is always in
+     * bounds.

[msarett, 2015/08/24 23:20:13]

Will improve this comment.

+     */
+    void initializeColorTable(int* inputColorCount, uint32_t transIndex);
+
+    /*
+     * 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 zeroInit Indicates if destination memory is zero initialized.
+     */
+    SkCodec::Result initializeSwizzler(const SkImageInfo& dstInfo,
+            ZeroInitialized zeroInit);
+
+    /*
+     * @return kSuccess if the read is successful and kIncompleteInput is the

[scroggo, 2015/08/27 16:35:50]

if*

[msarett, 2015/09/01 17:50:16]

Done.

+     *         read fails.
+     */
+    SkCodec::Result readRow();
+
+    /*
      * This function cleans up the gif object after the decode completes
      * It is used in a SkAutoTCallIProc template
      */
     static void CloseGif(GifFileType* gif);
 
     /*
      * Frees any extension data used in the decode
      * Used in a SkAutoTCallVProc
      */
     static void FreeExtension(SavedImage* image);
 
     /*
      * Creates an instance of the decoder
      * Called only by NewFromStream
      *
      * @param srcInfo contains the source width and height
      * @param stream the stream of image data
      * @param gif pointer to library type that manages gif decode
      *            takes ownership
      */
     SkGifCodec(const SkImageInfo& srcInfo, SkStream* stream, GifFileType* gif);
 
     SkAutoTCallVProc<GifFileType, CloseGif> fGif; // owned
+    SkIRect                                 fFrameDims;
+    uint32_t                                fFillIndex;
+    bool                                    fFrameIsSubset;
+    SkAutoTDelete<SkSwizzler>               fSwizzler;
+    SkAutoTUnref<SkColorTable>              fColorTable;
+    SkAutoTDeleteArray<uint8_t>             fSrcBuffer;
+
+    friend class SkGifScanlineDecoder;
 
     typedef SkCodec INHERITED;
 };