Use SkEncodedInfo in place of SkSwizzler::SrcConfig

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
 
 #include "SkCodec.h"
 #include "SkColor.h"
 #include "SkImageInfo.h"
 #include "SkSampler.h"
 
 class SkSwizzler : public SkSampler {
 public:
     /**
-     *  Enum describing the config of the source data.
-     */
-    enum SrcConfig {
-        kUnknown,  // Invalid type.
-        kBit,      // A single bit to distinguish between white and black.
-        kGray,
-        kGrayAlpha,
-        kIndex1,
-        kIndex2,
-        kIndex4,
-        kIndex,
-        kRGB,
-        kBGR,
-        kBGRX,     // The alpha channel can be anything, but the image is opaque.
-        kRGBA,
-        kBGRA,
-        kCMYK,
-        kNoOp8,    // kNoOp modes are used exclusively for sampling, subsetting, and
-        kNoOp16,   // copying.  The pixels themselves do not need to be modified.
-        kNoOp32,
-    };
-
-    /*
-     *
-     * Returns bits per pixel for source config
-     *
-     */
-    static int BitsPerPixel(SrcConfig sc) {
-        switch (sc) {
-            case kBit:
-            case kIndex1:
-                return 1;
-            case kIndex2:
-                return 2;
-            case kIndex4:
-                return 4;
-            case kGray:
-            case kIndex:
-            case kNoOp8:
-                return 8;
-            case kGrayAlpha:
-            case kNoOp16:
-                return 16;
-            case kRGB:
-            case kBGR:
-                return 24;
-            case kRGBA:
-            case kBGRX:
-            case kBGRA:
-            case kCMYK:
-            case kNoOp32:
-                return 32;
-            default:
-                SkASSERT(false);
-                return 0;
-        }
-    }
-
-    /*
-     *
-     * Returns bytes per pixel for source config
-     * Raises an error if each pixel is not stored in an even number of bytes
-     *
-     */
-    static int BytesPerPixel(SrcConfig sc) {
-        SkASSERT(SkIsAlign8(BitsPerPixel(sc)));
-        return BitsPerPixel(sc) >> 3;
-    }
-
-    /**
      *  Create a new SkSwizzler.
-     *  @param SrcConfig Description of the format of the source.
+     *  @param encodedInfo Description of the format of the encoded data.
      *  @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 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,
+    static SkSwizzler* CreateSwizzler(const SkEncodedInfo& encodedInfo, const SkPMColor* ctable,
                                       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.
@@ skipping 144 matching lines @@
                                           //     fBPP is bitsPerPixel
     const int           fDstBPP;          // Bytes per pixel for the destination color type
 
     SkSwizzler(RowProc fastProc, RowProc proc, const SkPMColor* ctable, int srcOffset,
             int srcWidth, int dstOffset, int dstWidth, int srcBPP, int dstBPP);
 
     int onSetSampleX(int) override;
 
 };
 #endif // SkSwizzler_DEFINED