Make SkAndroidCodec support gif

src/codec/SkSwizzler.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 SkSwizzler_DEFINED
 #define SkSwizzler_DEFINED
 
@@ skipping 109 matching lines @@
     /**
      *  Create a new SkSwizzler.
      *  @param SrcConfig Description of the format of the source.
      *  @param ctable Unowned pointer to an array of up to 256 colors for an
      *                index source.
      *  @param dstInfo Describes the destination.
      *  @param options Indicates if dst is zero-initialized. The
      *                         implementation may choose to skip writing zeroes
      *                         if set to kYes_ZeroInitialized.
      *                 Contains subset information.
+     *  @param frame   Indicates if the source pixels represent an image frame
+     *                 that is a subset of the full image.  This is subtlely
+     *                 different than if the client requests a subset decode,

[scroggo, 2015/11/17 14:56:26]

Maybe explain how it's different? Or where an explanation can be found?

[msarett, 2015/11/17 18:00:50]

Done.

+     *                 and must be handled differently.
      *  @return A new SkSwizzler or nullptr on failure.
      */
     static SkSwizzler* CreateSwizzler(SrcConfig, const SkPMColor* ctable,
-                                      const SkImageInfo& dstInfo, const SkCodec::Options&);
+                                      const SkImageInfo& dstInfo, const SkCodec::Options&,
+                                      const SkIRect* frame = nullptr);
 
     /**
      *  Swizzle a line. Generally this will be called height times, once
      *  for each row of source.
      *  By allowing the caller to pass in the dst pointer, we give the caller
      *  flexibility to use the swizzler even when the encoded data does not
      *  store the rows in order.  This also improves usability for scaled and
      *  subset decodes.
      *  @param dst Where we write the output.
      *  @param src The next row of the source data.
      *  @return A result code describing if the row was fully opaque, fully
      *          transparent, or neither
      */
     ResultAlpha swizzle(void* dst, const uint8_t* SK_RESTRICT src);
 
     /**
      * Implement fill using a custom width.
      */
     void fill(const SkImageInfo& info, void* dst, size_t rowBytes, uint32_t colorOrIndex,
             SkCodec::ZeroInitialized zeroInit) override {
-        const SkImageInfo fillInfo = info.makeWH(fDstWidth, info.height());
+        const SkImageInfo fillInfo = info.makeWH(fAllocatedWidth, info.height());
         SkSampler::Fill(fillInfo, dst, rowBytes, colorOrIndex, zeroInit);
     }
 
 private:
 
     /**
      *  Method for converting raw data to Skia pixels.
      *  @param dstRow Row in which to write the resulting pixels.
      *  @param src Row of src data, in format specified by SrcConfig
      *  @param dstWidth Width in pixels of the destination
      *  @param bpp if bitsPerPixel % 8 == 0, deltaSrc is bytesPerPixel
      *             else, deltaSrc is bitsPerPixel
      *  @param deltaSrc bpp * sampleX
      *  @param ctable Colors (used for kIndex source).
      *  @param offset The offset before the first pixel to sample.
                         Is in bytes or bits based on what deltaSrc is in.
      */
     typedef ResultAlpha (*RowProc)(void* SK_RESTRICT dstRow,
                                    const uint8_t* SK_RESTRICT src,
                                    int dstWidth, int bpp, int deltaSrc, int offset,
                                    const SkPMColor ctable[]);
 
     const RowProc       fRowProc;
     const SkPMColor*    fColorTable;      // Unowned pointer
     const int           fSrcOffset;       // Offset of the src in pixels, allows for partial
                                           // scanline decodes.
-    int                 fX0;              // Start coordinate for the src, may be different than
-                                          // fSrcOffset if we are sampling.
-    const int           fSubsetWidth;     // Width of the subset of the source before any sampling.
-    int                 fDstWidth;        // Width of dst, which may differ with sampling.
+    const int           fDstOffset;       // Offset of the dst in pixels, allows the src to be

[scroggo, 2015/11/17 14:56:26]

a* partial frame... ?

[msarett, 2015/11/17 18:00:50]

Acknowledged.

+                                          // partial frame of the dst.
+    int                 fSrcOffsetBytes;  // Byte offset of the src, takes sampling into account.
+    int                 fDstOffsetBytes;  // Byte offset of the dst, takes sampling into account.
+    const int           fSrcWidth;        // Pixel width of src before any sampling, accounting
+                                          // for subset decodes.

[scroggo, 2015/11/17 14:56:26]

When you say "accounting for subset decodes", what do you mean? Partial
scanlines? So this is the width of the source subset? Or GIF subset frames? So
this is the width of the frame?

[msarett, 2015/11/17 18:00:50]

Acknowledged.

+    const int           fDstWidth;        // Pixel width of dst before any sampling, accounting
+                                          // subset decodes or image frame subsets.
+    int                 fSwizzleWidth;    // The number of pixels that will be written by the
+                                          // RowProc.  Scaled version of fSrcWidth.
+    int                 fAllocatedWidth;  // The pixel width of destination memory.  Scaled version
+                                          // of fDstWidth.
     int                 fSampleX;         // step between X samples
-    const int           fBPP;             // if bitsPerPixel % 8 == 0
+    const int           fSrcBPP;          // Bits/bytes per pixel for the SrcConfig
+                                          // if bitsPerPixel % 8 == 0
                                           //     fBPP is bytesPerPixel
                                           // else
                                           //     fBPP is bitsPerPixel
+    const int           fDstBPP;          // Bytes per pixel for the destination color type
 
-    SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcOffset, int subsetWidth, int bpp);
+    SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcOffset, int srcWidth, int dstOffset,
+            int dstWidth, int srcBPP, int dstBPP);
 
     int onSetSampleX(int) override;
 
 };
 #endif // SkSwizzler_DEFINED