Make SkAndroidCodec support gif

src/codec/SkSwizzler.h

Index: src/codec/SkSwizzler.h
diff --git a/src/codec/SkSwizzler.h b/src/codec/SkSwizzler.h
index 691dc77aa6a99f20cc676f7b3f854b8655a060f1..c08a741653a88ba57b9f7b8c46a28121d352c824 100644
--- a/src/codec/SkSwizzler.h
+++ b/src/codec/SkSwizzler.h
@@ -126,11 +126,19 @@ public:
      *  @param options Indicates if dst is zero-initialized. The
      *                         implementation may choose to skip writing zeroes
      *                         if set to kYes_ZeroInitialized.
-     *                 Contains subset information.
+     *                 Contains partial scanline information.
+     *  @param frame   Is non-NULL if the source pixels are part of an image
+     *                 frame that is a subset of the full image.
+     *
+     *  Note that a deeper discussion of partial scanline subsets and image frame
+     *  subsets is below.  Currently, we do not support both simultaneously.  If
+     *  options->fSubset is non-NULL, frame must be NULL.
+     *
      *  @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
@@ -151,7 +159,7 @@ public:
      */
     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);
     }
 
@@ -176,19 +184,97 @@ private:
 
     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.
-    int                 fSampleX;         // step between X samples
-    const int           fBPP;             // if bitsPerPixel % 8 == 0
+
+    // Subset Swizzles

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

This is complicated :(.

I'm continuing to think about how we might simplify things.

+    // There are two types of subset swizzles that we support.  We do not
+    // support both at the same time.
+    // TODO: If we want to support partial scanlines for gifs (which may
+    //       use frame subsets), we will need to support both subsetting
+    //       modes at the same time.
+    // (1) Partial Scanlines
+    //         The client only wants to write a subset of the source pixels
+    //         to the destination.  This subset is specified to CreateSwizzler
+    //         using options->fSubset.  We will store subset information in
+    //         the following fields.
+    //
+    //         fSrcOffset:      The starting pixel of the source.
+    //         fSrcOffsetUnits: Derived from fSrcOffset.
+    //                          If we are sampling, this will be a few pixels
+    //                          larger than fSrcOffset (depending on the

[scroggo, 2015/11/17 18:18:25]

Hmm, fSrcOffset is in pixels, but this one is not, so it seems a bit odd to
state that this is "a few pixels larger". I guess you explain that further down
below...

[msarett, 2015/11/17 18:58:07]

Tried to restate this a little clearer.

+    //                          sample size) since sampling implies that we
+    //                          will skip some pixels.
+    //                          This also takes the size of source pixels into
+    //                          account by multiplying by fSrcBPP.  This may
+    //                          be measured in bits or bytes depending on
+    //                          which is natural for the SrcConfig.
+    //         fDstOffset:      Will be zero.  There is no destination offset
+    //                          for this type of subset.
+    //         fDstOffsetBytes: Will be zero.
+    //         fSrcWidth:       The width of the desired subset of source
+    //                          pixels, before any sampling is performed.
+    //         fDstWidth:       Will be equal to fSrcWidth, since this is also
+    //                          calculated before any sampling is performed.
+    //                          For this type of subset, the destination width
+    //                          matches the desired subset of the source.
+    //         fSwizzleWidth:   The actual number of pixels that will be
+    //                          written by the RowProc.  This is a scaled
+    //                          version of fSrcWidth/fDstWidth.
+    //         fAllocatedWidth: Will be equal to fSwizzleWidth.  For this type
+    //                          of subset, the number of pixels written is the
+    //                          same as the actual width of the destination.
+    // (2) Frame Subset
+    //         The client will decode the entire width of the source into a
+    //         subset of destination memory.  This subset is specified to
+    //         CreateSwizzler in the frame parameter.  We store subset

[scroggo, 2015/11/17 18:18:25]

I don't think we have a Skia standard for this, but maybe this should be

|frame|

or

"frame"

[msarett, 2015/11/17 18:58:07]

Done.

+    //         information in the following fields.
+    //
+    //         fSrcOffset:      Will be zero.  The starting pixel of the source.
+    //         fSrcOffsetUnits: Will only be non-zero if we are sampling.
+    //                          If we are sampling, this will be a few pixels
+    //                          larger than fSrcOffset (depending on the
+    //                          sample size) since sampling implies that we
+    //                          will skip some pixels.
+    //                          This also takes the size of source pixels into
+    //                          account by multiplying by fSrcBPP.  This may
+    //                          be measured in bits or bytes depending on
+    //                          which is natural for the SrcConfig.
+    //         fDstOffset:      First pixel to write in destination.
+    //         fDstOffsetBytes: fDstOffset * fDstBPP.
+    //         fSrcWidth:       The entire width of the source pixels, before
+    //                          any sampling is performed.
+    //         fDstWidth:       The entire width of the destination memory,
+    //                          before any sampling is performed.
+    //         fSwizzleWidth:   The actual number of pixels that will be
+    //                          written by the RowProc.  This is a scaled
+    //                          version of fSrcWidth.
+    //         fAllocatedWidth: The actual number of pixels in destination
+    //                          memory.  This is a scaled version of
+    //                          fDstWidth.
+    //
+    // If we are not subsetting, these fields are more straightforward.
+    //         fSrcOffset = fDstOffet = fDstOffsetBytes = 0
+    //         fSrcOffsetUnits may be non-zero (we will skip the first few pixels when sampling)
+    //         fSrcWidth = fDstWidth = Full original width
+    //         fSwizzleWidth = fAllcoatedWidth = Scaled width (if we are sampling)
+    const int           fSrcOffset;
+    const int           fDstOffset;
+    int                 fSrcOffsetUnits;
+    int                 fDstOffsetBytes;
+    const int           fSrcWidth;
+    const int           fDstWidth;
+    int                 fSwizzleWidth;
+    int                 fAllocatedWidth;
+
+    int                 fSampleX;         // Step between X samples
+    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;