Bmp Image Decoding

src/codec/SkSwizzler.cpp

 /*
  * 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 "SkColorPriv.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 
-// index
-
 #define A32_MASK_IN_PLACE   (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT)
 
-static bool swizzle_index_to_n32(void* SK_RESTRICT dstRow,
-                                 const uint8_t* SK_RESTRICT src,
-                                 int width, int deltaSrc, int, const SkPMColor ctable[]) {
+// kIndex1, kIndex2, kIndex4
+
+static bool swizzle_small_index_to_n32(void* SK_RESTRICT dstRow,
+                                       const uint8_t* SK_RESTRICT src,
+                                       int width, int bitsPerPixel, int,
+                                       const SkPMColor ctable[],
+                                       const SkSwizzler::ColorMasks,
+                                       const SkSwizzler::AlphaOption, bool*,
+                                       bool*) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     SkPMColor cc = A32_MASK_IN_PLACE;
+    const uint32_t pixelsPerByte = 8 / bitsPerPixel;
+    const uint32_t rowBytes = (width + pixelsPerByte - 1) / pixelsPerByte;
+    const uint8_t mask = (1 << bitsPerPixel) - 1;
+
+    uint32_t x = 0;
+    for (uint32_t byte = 0; byte < rowBytes; byte++) {
+        uint8_t pixelData = src[byte];
+        for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) {
+            uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
+            dst[x] = ctable[index];
+            cc &= ctable[index];
+            pixelData <<= bitsPerPixel;
+            x++;
+        }
+    }
+    return cc != A32_MASK_IN_PLACE;
+}
+
+// kIndex
+
+static bool swizzle_index_to_n32(void* SK_RESTRICT dstRow,
+                                const uint8_t* SK_RESTRICT src,
+                                int width, int bitsPerPixel, int,
+                                const SkPMColor ctable[],
+                                const SkSwizzler::ColorMasks,
+                                const SkSwizzler::AlphaOption, bool*, bool*) {
+
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    SkPMColor cc = A32_MASK_IN_PLACE;
     for (int x = 0; x < width; x++) {
         SkPMColor c = ctable[*src];
         cc &= c;
         dst[x] = c;
-        src += deltaSrc;
+        src++;
     }
     return cc != A32_MASK_IN_PLACE;
 }
 
 static bool swizzle_index_to_n32_skipZ(void* SK_RESTRICT dstRow,
-                                      const uint8_t* SK_RESTRICT src,
-                                      int width, int deltaSrc, int,
-                                      const SkPMColor ctable[]) {
+                                       const uint8_t* SK_RESTRICT src,
+                                       int width, int bitsPerPixel, int,
+                                       const SkPMColor ctable[],
+                                       const SkSwizzler::ColorMasks,
+                                       const SkSwizzler::AlphaOption, bool*,
+                                       bool*) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     SkPMColor cc = A32_MASK_IN_PLACE;
     for (int x = 0; x < width; x++) {
         SkPMColor c = ctable[*src];
         cc &= c;
         if (c != 0) {
             dst[x] = c;
         }
+        src++;
+    }
+    return cc != A32_MASK_IN_PLACE;
+}
+
+#undef A32_MASK_IN_PLACE
+
+// mask
+
+/**
+ *
+ * Used to convert 1-7 bit color components into 8-bit color components
+ *
+ */
+const uint8_t nBitTo8BitlookupTable[] = {
+    // 1 bit
+    0, 255,
+    // 2 bits
+    0, 85, 170, 255,
+    // 3 bits
+    0, 36, 73, 109, 146, 182, 219, 255,
+    // 4 bits
+    0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255,
+    // 5 bits
+    0, 8, 16, 25, 33, 41, 49, 58, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140,
+    148, 156, 165, 173, 181, 189, 197, 206, 214, 222, 230, 239, 247, 255,
+    // 6 bits
+    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 45, 49, 53, 57, 61, 65, 69, 73,
+    77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 130, 134, 138,
+    142, 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198,
+    202, 206, 210, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255,
+    // 7 bits
+    0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38,
+    40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76,
+    78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110,
+    112, 114, 116, 118, 120, 122, 124, 126, 129, 131, 133, 135, 137, 139, 141,
+    143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171,
+    173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201,
+    203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231,
+    233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255
+};
+
+/*
+ *
+ * Convert an n bit component to an 8-bit component
+ *
+ */
+static uint8_t convert_n_to_8(uint32_t component, uint32_t n) {
+    if (0 == n) {
+        return 0;
+    } else if (8 > n) {
+        return nBitTo8BitlookupTable[(1 << n) - 2 + component];
+    } else if (8 == n) {
+        return component;
+    } else {
+        SkDebugf("Error: too many bits for lookup table.\n");
+        return 0;
+    }
+}
+
+/*
+ *
+ * For a continuous bit mask (ex: 0011100), retrieves the size of the mask and
+ * the trailing zeros
+ *
+ */
+static void get_mask_info(uint32_t mask, uint32_t bPP, uint32_t* size,
+        uint32_t* shift) {
+    // For empty masks, set zeros and return
+    uint32_t tempMask = mask;
+    if (!tempMask) {
+        *size = 0;
+        *shift = 0;
+        return;
+    }
+
+    // Count trailing zeros
+    int zeros = 0;
+    for (; !(tempMask & 1); tempMask >>= 1) {
+        zeros++;
+    }
+
+    // Count mask size
+    int count = 0;
+    for (; tempMask & 1; tempMask >>= 1) {
+        count++;
+    }
+
+    // We will use a maximum of 8 bits for the size, truncate some of the mask
+    // bits if necessary
+    if (count > 8) {
+        *shift = count - 8 + zeros;
+        *size = 8;
+    } else {
+        *shift = zeros;
+        *size = count;
+    }
+    return;
+}
+
+/*
+ * 
+ * Set the alpha channel value based on the input alpha type.  The interesting
+ * case is kTransparentAsOpaque.  We must respect the alpha channel in this
+ * case.  However, if it is all zeros, we want to display the image as opaque
+ * instead of transparent.  This may require reseting the loop iterator and
+ * reprocessing previous rows.
+ *
+ */
+static uint8_t get_alpha(uint8_t alpha, SkSwizzler::AlphaOption opt,
+                         uint32_t* currIndex, int deltaSrc,
+                         bool* seenNonZeroAlphaPtr, bool* zeroPrevRowsPtr) {
+    switch (opt) {
+        case SkSwizzler::kOpaque_AlphaOption:
+            return 0xFF;
+        case SkSwizzler::kNormal_AlphaOption:
+            return alpha;
+        case SkSwizzler::kTransparentAsOpaque_AlphaOption:
+            if (*seenNonZeroAlphaPtr) {
+                return alpha;
+            } else if(!alpha) {
+                return 0xFF;
+            } else {
+                *zeroPrevRowsPtr = true;
+                *seenNonZeroAlphaPtr = true;
+                *currIndex = -deltaSrc;
+                return alpha;
+            }
+        default:
+            SkASSERT(false);
+            return 0;
+    }
+}
+
+// kMask16
+
+static bool swizzle_mask16_to_n32(void* SK_RESTRICT dstRow,
+                                  const uint8_t* SK_RESTRICT src,
+                                  int width, int bitsPerPixel, int,
+                                  const SkPMColor ctable[],
+                                  const SkSwizzler::ColorMasks masks,
+                                  const SkSwizzler::AlphaOption alphaOption,
+                                  bool* seenNonZeroAlphaPtr,
+                                  bool* zeroPrevRowsPtr) {
+    // Load the bit masks
+    uint32_t redMask = masks.redMask;

[scroggo, 2015/03/04 17:10:31]

Would it be possible to make a function that looks something like the
following?:

static inline void mask_color(uint8_t* a, uint8_t* r, uint8_t* g, uint8_t* b,
                              const ColorMasks& masks) {
    ...
}

This seems like it would simplify your swizzle functions.

Maybe this would mean recalculating a bunch of things. If so, maybe we could
modify the ColorMask to have some member functions that do things ahead of time
(or even do the calculations in the constructor). I'm guessing that the mask
info will always be the same for a single ColorMask?

+    uint32_t greenMask = masks.greenMask;
+    uint32_t blueMask = masks.blueMask;
+    uint32_t alphaMask = masks.alphaMask;
+    uint32_t rBits, rShift, gBits, gShift, bBits, bShift, aBits, aShift;
+    get_mask_info(redMask, bitsPerPixel, &rBits, &rShift);
+    get_mask_info(greenMask, bitsPerPixel, &gBits, &gShift);
+    get_mask_info(blueMask, bitsPerPixel, &bBits, &bShift);
+    get_mask_info(alphaMask, bitsPerPixel, &aBits, &aShift);
+
+    // Use the masks to decode to the destination
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = 2;
+    for (uint32_t p = 0; p < width * deltaSrc; p += deltaSrc) {
+        uint16_t pixel = src[p] | (src[p + 1] << 8);
+        uint8_t red = convert_n_to_8((pixel & redMask) >> rShift, rBits);
+        uint8_t green = convert_n_to_8((pixel & greenMask) >> gShift, gBits);
+        uint8_t blue = convert_n_to_8((pixel & blueMask) >> bShift, bBits);
+        uint8_t alpha = convert_n_to_8((pixel & alphaMask) >> aShift, aBits);
+        // Call to get_alpha may reset the loop iterator.
+        // We will get a safe result cell before this call.
+        SkPMColor* dstCell = &dst[p/deltaSrc];
+        uint8_t trueAlpha = get_alpha(alpha, alphaOption, &p, deltaSrc,
+                seenNonZeroAlphaPtr, zeroPrevRowsPtr);
+        *dstCell = SkPreMultiplyARGB(trueAlpha, red, green, blue);
+    }
+    return *seenNonZeroAlphaPtr;

[scroggo, 2015/03/04 17:10:31]

I think this is not want you want to return. The functions are supposed to
return the following:

true : If anything on this line had some alpha less than 100% (e.g. 255 for 8
bit alpha)
false : Everything on this line has 100% alpha

IIUC, seenNonZeroAlpha returns:

true: Something had an alpha > 0
false : Everything had an alpha of 0

(In addition, it seems to include prior lines, which is also different from the
intended return value.)

The general decoders only care about the former. Maybe there's a way to get
both? What if we used a bit field, where part of it tells us if there was a
non-zero alpha, and part tells whether there was a non-100% alpha? Then could we
get rid of the in/out parameter seenNonZeroAlphaPtr? (Or maybe there's a better
way?)

+}
+
+// kMask24
+
+static bool swizzle_mask24_to_n32(void* SK_RESTRICT dstRow,
+                                  const uint8_t* SK_RESTRICT src,
+                                  int width, int bitsPerPixel, int,
+                                  const SkPMColor ctable[],
+                                  const SkSwizzler::ColorMasks masks,
+                                  const SkSwizzler::AlphaOption alphaOption,
+                                  bool* seenNonZeroAlphaPtr,
+                                  bool* zeroPrevRowsPtr) {

[scroggo, 2015/03/04 17:10:31]

I'm trying to figure out how we can cut down on the parameters passed to this
function. Let me see if I understand how zeroPrevRowsPtr:

It is only an out parameter. We set it to true if
1) all previous rows had an alpha of zero.
and
2) this row had an alpha that was not zero.

Then, next will set all the previous rows to zero. Does that sound correct?

Is it redundant with seenNonZeroAlphaPtr? It seems like the value for one can
tell us the meaningful value for the other?

+    // Load the bit masks
+    uint32_t redMask = masks.redMask;
+    uint32_t greenMask = masks.greenMask;
+    uint32_t blueMask = masks.blueMask;
+    uint32_t alphaMask = masks.alphaMask;
+    uint32_t rBits, rShift, gBits, gShift, bBits, bShift, aBits, aShift;
+    get_mask_info(redMask, bitsPerPixel, &rBits, &rShift);
+    get_mask_info(greenMask, bitsPerPixel, &gBits, &gShift);
+    get_mask_info(blueMask, bitsPerPixel, &bBits, &bShift);
+    get_mask_info(alphaMask, bitsPerPixel, &aBits, &aShift);
+
+    // Use the masks to decode to the destination
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int x = 0;
+    int deltaSrc = 3;
+    for (uint32_t p = 0; p < width * deltaSrc; p += deltaSrc) {
+        uint32_t pixel = src[p] | (src[p + 1] << 8) | src[p + 2] << 16;
+        uint8_t red = convert_n_to_8((pixel & redMask) >> rShift, rBits);
+        uint8_t green = convert_n_to_8((pixel & greenMask) >> gShift, gBits);
+        uint8_t blue = convert_n_to_8((pixel & blueMask) >> bShift, bBits);
+        uint8_t alpha = convert_n_to_8((pixel & alphaMask) >> aShift, aBits);
+        // Call to get_alpha may reset the loop iterator.
+        // We will get a safe result cell before this call.
+        SkPMColor* dstCell = &dst[p/deltaSrc];
+        uint8_t trueAlpha = get_alpha(alpha, alphaOption, &p, deltaSrc,
+                seenNonZeroAlphaPtr, zeroPrevRowsPtr);
+        *dstCell = SkPreMultiplyARGB(trueAlpha, red, green, blue);
+    }
+    return *seenNonZeroAlphaPtr;
+}
+
+// kMask32
+
+static bool swizzle_mask32_to_n32(void* SK_RESTRICT dstRow,
+                                  const uint8_t* SK_RESTRICT src,
+                                  int width, int bitsPerPixel, int,
+                                  const SkPMColor ctable[],
+                                  const SkSwizzler::ColorMasks masks,
+                                  const SkSwizzler::AlphaOption alphaOption,
+                                  bool* seenNonZeroAlphaPtr,
+                                  bool* zeroPrevRowsPtr) {
+    // Load the bit masks
+    uint32_t redMask = masks.redMask;
+    uint32_t greenMask = masks.greenMask;
+    uint32_t blueMask = masks.blueMask;
+    uint32_t alphaMask = masks.alphaMask;
+    uint32_t rBits, rShift, gBits, gShift, bBits, bShift, aBits, aShift;
+    get_mask_info(redMask, bitsPerPixel, &rBits, &rShift);
+    get_mask_info(greenMask, bitsPerPixel, &gBits, &gShift);
+    get_mask_info(blueMask, bitsPerPixel, &bBits, &bShift);
+    get_mask_info(alphaMask, bitsPerPixel, &aBits, &aShift);
+
+    // Use the masks to decode to the destination
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int x = 0;
+    int deltaSrc = 4;
+    for (uint32_t p = 0; p < width * deltaSrc; p += deltaSrc) {
+        uint32_t pixel = src[p] | (src[p + 1] << 8) | src[p + 2] << 16 |
+                src[p + 3] << 24;
+        uint8_t red = convert_n_to_8((pixel & redMask) >> rShift, rBits);
+        uint8_t green = convert_n_to_8((pixel & greenMask) >> gShift, gBits);
+        uint8_t blue = convert_n_to_8((pixel & blueMask) >> bShift, bBits);
+        uint8_t alpha = convert_n_to_8((pixel & alphaMask) >> aShift, aBits);
+        // Call to get_alpha may reset the loop iterator.
+        // We will get a safe result cell before this call.
+        SkPMColor* dstCell = &dst[p/deltaSrc];
+        uint8_t trueAlpha = get_alpha(alpha, alphaOption, &p, deltaSrc,
+                seenNonZeroAlphaPtr, zeroPrevRowsPtr);
+        *dstCell = SkPreMultiplyARGB(trueAlpha, red, green, blue);
+    }
+    return *seenNonZeroAlphaPtr;
+}
+
+// kBGRX and kBGR
+
+static bool swizzle_bgrx_to_n32(void* SK_RESTRICT dstRow,
+                                const uint8_t* SK_RESTRICT src,
+                                int width, int bitsPerPixel, int,
+                                const SkPMColor[],
+                                const SkSwizzler::ColorMasks,
+                                const SkSwizzler::AlphaOption, bool*, bool*) {
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = bitsPerPixel / 8;
+    for (int x = 0; x < width; x++) {
+        dst[x] = SkPackARGB32(0xFF, src[2], src[1], src[0]);
         src += deltaSrc;
     }
-    return cc != A32_MASK_IN_PLACE;
-}
-
-#undef A32_MASK_IN_PLACE
+    return false;
+}
+
+// kBGRA
+
+static bool swizzle_bgra_to_n32(void* SK_RESTRICT dstRow,
+                                const uint8_t* SK_RESTRICT src,
+                                int width, int bitsPerPixel, int,
+                                const SkPMColor[],
+                                const SkSwizzler::ColorMasks masks,
+                                const SkSwizzler::AlphaOption alphaOption,
+                                bool* seenNonZeroAlphaPtr,
+                                bool* zeroPrevRowsPtr) {
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    uint32_t alphaMask = masks.alphaMask;
+    for (uint32_t x = 0; x < width; x++) {
+        uint8_t alpha = alphaMask & src[4*x + 3];
+        SkPMColor* dstCell = &dst[x];
+        uint8_t trueAlpha = get_alpha(alpha, alphaOption, &x, 1,
+                seenNonZeroAlphaPtr, zeroPrevRowsPtr);
+        dst[x] = SkPreMultiplyARGB(alpha, src[4*x + 2], src[4*x + 1], src[4*x]);
+    }
+    return *seenNonZeroAlphaPtr;
+}
 
 // n32
 static bool swizzle_rgbx_to_n32(void* SK_RESTRICT dstRow,
                                 const uint8_t* SK_RESTRICT src,
-                                int width, int deltaSrc, int, const SkPMColor[]) {
-    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+                                int width, int bitsPerPixel, int,
+                                const SkPMColor[],
+                                const SkSwizzler::ColorMasks,
+                                const SkSwizzler::AlphaOption, bool*, bool*) {
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = bitsPerPixel / 8;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
         src += deltaSrc;
     }
     return false;
 }
 
 static bool swizzle_rgba_to_n32_premul(void* SK_RESTRICT dstRow,
                                        const uint8_t* SK_RESTRICT src,
-                                       int width, int deltaSrc, int, const SkPMColor[]) {
+                                       int width, int bitsPerPixel, int,
+                                       const SkPMColor[],
+                                       const SkSwizzler::ColorMasks,
+                                       const SkSwizzler::AlphaOption, bool*,
+                                       bool*) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = bitsPerPixel / 8;
     unsigned alphaMask = 0xFF;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 
 static bool swizzle_rgba_to_n32_unpremul(void* SK_RESTRICT dstRow,
                                          const uint8_t* SK_RESTRICT src,
-                                         int width, int deltaSrc, int,
-                                         const SkPMColor[]) {
+                                         int width, int bitsPerPixel, int,
+                                         const SkPMColor[],
+                                         const SkSwizzler::ColorMasks,
+                                         const SkSwizzler::AlphaOption, bool*,
+                                         bool*) {
     uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
+    int deltaSrc = bitsPerPixel / 8;
     unsigned alphaMask = 0xFF;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 
 static bool swizzle_rgba_to_n32_premul_skipZ(void* SK_RESTRICT dstRow,
                                              const uint8_t* SK_RESTRICT src,
-                                             int width, int deltaSrc, int,
-                                             const SkPMColor[]) {
+                                             int width, int bitsPerPixel, int,
+                                             const SkPMColor[],
+                                             const SkSwizzler::ColorMasks,
+                                             const SkSwizzler::AlphaOption,
+                                             bool*, bool*) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = bitsPerPixel / 8;
     unsigned alphaMask = 0xFF;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         if (0 != alpha) {
             dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         }
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 
 /**
     FIXME: This was my idea to cheat in order to continue taking advantage of skipping zeroes.
     This would be fine for drawing normally, but not for drawing with transfer modes. Being
     honest means we can draw correctly with transfer modes, with the cost of not being able
     to take advantage of Android's free unwritten pages. Something to keep in mind when we
     decide whether to switch to unpremul default.
 static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow,
                                                const uint8_t* SK_RESTRICT src,
-                                               int width, int deltaSrc, int,
+                                               int width, int bitsPerPixel,
                                                const SkPMColor[]) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     unsigned alphaMask = 0xFF;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         // NOTE: We cheat here. The caller requested unpremul and skip zeroes. It's possible
         // the color components are not zero, but we skip them anyway, meaning they'll remain
         // zero (implied by the request to skip zeroes).
         if (0 != alpha) {
             dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
         }
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 */
 
-SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc, const SkPMColor* ctable,
+SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
+                                       const SkPMColor* ctable,
                                        const SkImageInfo& info, void* dst,
-                                       size_t dstRowBytes, bool skipZeroes) {
-    if (info.colorType() == kUnknown_SkColorType) {
+                                       size_t dstRowBytes, bool skipZeroes,
+                                       const ColorMasks bitMasks,
+                                       const AlphaOption alphaOption,
+                                       const RowOrder rowOrder) {
+    if (kUnknown_SkColorType == info.colorType()) {
         return NULL;
     }
     if (info.minRowBytes() > dstRowBytes) {
         return  NULL;
     }
-    if (kIndex == sc && NULL == ctable) {
+    if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
+            && NULL == ctable) {
         return NULL;
     }
     RowProc proc = NULL;
     switch (sc) {
+        case kIndex1:
+        case kIndex2:
+        case kIndex4:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_small_index_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
         case kIndex:
             switch (info.colorType()) {
                 case kN32_SkColorType:
-                    // We assume the color premultiplied ctable (or not) as desired.
-                    if (skipZeroes) {
-                        proc = &swizzle_index_to_n32_skipZ;
-                    } else {
-                        proc = &swizzle_index_to_n32;
-                    }
+                    proc = &swizzle_index_to_n32;
                     break;
-                    
                 default:
                     break;
             }
+            break;
+        case kMask16:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_mask16_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case kMask24:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_mask24_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case kMask32:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_mask32_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case kBGR:
+        case kBGRX:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_bgrx_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case kBGRA:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_bgra_to_n32;
+                    break;
+                default:
+                    break;
+            }
             break;
         case kRGBX:
             // TODO: Support other swizzles.
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_rgbx_to_n32;
                     break;
                 default:
                     break;
             }
             break;
         case kRGBA:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     if (info.alphaType() == kUnpremul_SkAlphaType) {
                         // Respect skipZeroes?
                         proc = &swizzle_rgba_to_n32_unpremul;
                     } else {
                         if (skipZeroes) {
                             proc = &swizzle_rgba_to_n32_premul_skipZ;
                         } else {
                             proc = &swizzle_rgba_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
+        case kRGB:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_rgbx_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
         default:
             break;
     }
     if (NULL == proc) {
         return NULL;
     }
-    return SkNEW_ARGS(SkSwizzler, (proc, ctable, BytesPerPixel(sc), info, dst, dstRowBytes));
+    return SkNEW_ARGS(SkSwizzler, (proc, ctable, BitsPerPixel(sc), info, dst,
+                                   dstRowBytes, bitMasks, alphaOption, rowOrder));
 }
 
-SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcBpp,
-                       const SkImageInfo& info, void* dst, size_t rowBytes)
+SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
+                       int srcBitsPerPixel, const SkImageInfo& info, void* dst,
+                       size_t rowBytes, const ColorMasks bitMasks,
+                       const AlphaOption alphaOption, const RowOrder rowOrder)
     : fRowProc(proc)
     , fColorTable(ctable)
-    , fSrcPixelSize(srcBpp)
+    , fSrcBitsPerPixel(srcBitsPerPixel)
     , fDstInfo(info)
     , fDstRow(dst)
     , fDstRowBytes(rowBytes)
     , fCurrY(0)
+    , fBitMasks(bitMasks)
+    , fAlphaOption(alphaOption)
+    , fRowOrder(rowOrder)
+    , fSeenNonZeroAlpha(false)
+    , fZeroPrevRows(false)
 {
 }
 
 bool SkSwizzler::next(const uint8_t* SK_RESTRICT src) {
     SkASSERT(fCurrY < fDstInfo.height());
-    const bool hadAlpha = fRowProc(fDstRow, src, fDstInfo.width(), fSrcPixelSize,
-                                   fCurrY, fColorTable);
+
+    // On the first iteration, if the image is inverted, start at the bottom
+    if (0 == fCurrY && kBottomUp_RowOrder == fRowOrder) {

[scroggo, 2015/03/04 17:10:31]

I think the bottom up row order is only going to be used by BMP. (Though I could
be wrong.) That said, GIF also has a mode that decodes in an order besides top
down - it is interlaced. Maybe instead of providing the option to go in reverse
order, add a function that can be called instead of next, where the caller
supplies the y value. SkBmpCodec can take care of the loop going from height
down to zero, and then we can reuse the same function for GIF.

Take a look at SkScaledBitmapSampler::sampleInterlaced. This function should be
simpler (no need to worry about sampling), but work somewhat similarly.

+        fDstRow = SkTAddOffset<void>(fDstRow,
+                fDstRowBytes * (fDstInfo.height() - 1));
+    }
+
+    // Decode a row
+    const bool hadAlpha = fRowProc(fDstRow, src, fDstInfo.width(),
+            fSrcBitsPerPixel, fCurrY, fColorTable, fBitMasks, fAlphaOption,
+            &fSeenNonZeroAlpha, &fZeroPrevRows);
+
+    // This flag indicates that we have decoded the image as opaque instead of
+    // transparent, and we just realized that it should have been transparent.
+    // To fix this, we zero the rows that have already been decoded.
+    if (fZeroPrevRows) {

[scroggo, 2015/03/04 17:10:31]

Some thoughts:

1) I think this behavior is exclusive to BMP. Can we move it into SkBmpCodec?
2) It looks like you zero out every single value on previous rows. This assumes
premultiplied, and we need to support unpremul for Android. For normal drawing,
premultiplying the alpha, when 0, is the same as unpremul, but if an SkXfermode
is used, then I believe it will be different.
3) I wonder if it would be better to make SkBmpCodec do the correction after the
fact (simplifying this function and the row procs). Or, we could switch row
procs once we've seen a non zero alpha (though that may make things much more
complicated).

+        void* dstRow;
+        if (kTopDown_RowOrder == fRowOrder) {
+            void* dstStart = SkTAddOffset<void>(fDstRow, -fCurrY*fDstRowBytes);
+            memset(dstStart, 0, fCurrY*fDstRowBytes);
+        } else {
+            void* dstStart = SkTAddOffset<void>(fDstRow, fDstRowBytes);
+            memset(dstStart, 0, fCurrY*fDstRowBytes);
+        }
+        fZeroPrevRows = false;
+    }
+
+    // Move to the next row and return the result
     fCurrY++;
-    fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes);
+    if (kTopDown_RowOrder == fRowOrder) {
+        fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes);
+    } else {
+        fDstRow = SkTAddOffset<void>(fDstRow, -fDstRowBytes);
+    }
     return hadAlpha;
 }