Swizzler changes Index8 and 565

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 43 matching lines @@
 
     /*
      *
      * Checks if the result of decoding a row indicates that the row was
      * opaque.
      *
      */
     static bool IsOpaque(ResultAlpha r) {
         return kOpaque_ResultAlpha == r;
     }
-    
+
     /*
      *
      * Constructs the proper result code based on accumulated alpha masks
      *
      */
     static ResultAlpha GetResult(uint8_t zeroAlpha, uint8_t maxAlpha);
 
     /*
      *
      * Returns bits per pixel for source config
@@ skipping 46 matching lines @@
      *  @param dstRowBytes rowBytes for dst.
      *  @param ZeroInitialized Whether dst is zero-initialized. The
                                implementation may choose to skip writing zeroes
      *                         if set to kYes_ZeroInitialized.
      *  @return A new SkSwizzler or NULL on failure.
      */
     static SkSwizzler* CreateSwizzler(SrcConfig, const SkPMColor* ctable,
                                       const SkImageInfo&, void* dst,
                                       size_t dstRowBytes,
                                       SkImageGenerator::ZeroInitialized);
+
+    /**
+     * Fill the remainder of the destination with a single color
+     * @param y            The starting row for the fill.
+     * @param input        The value to fill with - may be a color or an index.
+     *                     It will be an index in the case where the encoded image was
+     *                     stored in an indexed format.  If we are decoding to kIndex8
+     *                     we will fill with the index directly.  If we are decoding to
+     *                     kN32, we will use the index to look up the color that we are
+     *                     to fill with.  If the input is an index, it will be treated
+     *                     as a uint8_t.
+     *                     We recognize that the input is not an index if we are
+     *                     decoding to kN32 and the input color table is NULL.  In this
+     *                     case, we assume the input is an SkPMColor and fill with it
+     *                     directly.
+     * @param colorTable   a non-NULL colorTable indicates that the input is an index
+     *                     even if the dst color type is not an index type
+     */
+    static void Fill(void* dst, const SkImageInfo& dstInfo, size_t dstRowBytes, uint32_t y,
+            uint32_t input, SkPMColor* colorTable);
+
     /**
      *  Swizzle the next line. Call height times, once for each row of source.
      *  @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 next(const uint8_t* SK_RESTRICT src);
 
     /**
      *
      * Alternate version of next that allows the caller to specify the row.
      * It is very important to only use one version of next.  Since the other
      * version modifies the dst pointer, it will change the behavior of this
      * function.  We will check this in Debug mode.
      *
      */
     ResultAlpha next(const uint8_t* SK_RESTRICT src, int y);
 
     /**
      *  Update the destination row.
      *
      *  Typically this is done by next, but for a client that wants to manually
      *  modify the destination row (for example, for decoding scanline one at a
      *  time) they can call this before each call to next.
      *  TODO: Maybe replace this with a version of next which allows supplying the
      *  destination?
      */
     void setDstRow(void* dst) { fDstRow = dst; }
+
 private:
 
 #ifdef SK_DEBUG
     /*
      *
      * Keep track of which version of next the caller is using
      *
      */
     enum NextMode {
         kUninitialized_NextMode,
@@ skipping 28 matching lines @@
     const SkImageInfo   fDstInfo;
     void*               fDstRow;
     const size_t        fDstRowBytes;
     int                 fCurrY;
 
     SkSwizzler(RowProc proc, const SkPMColor* ctable, int deltaSrc,
                const SkImageInfo& info, void* dst, size_t rowBytes);
 
 };
 #endif // SkSwizzler_DEFINED