Support RGBA/BGRA swizzles using SkEncodedInfo

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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkOpts.h"
@@ skipping 330 matching lines @@
 
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
     // Note that there is no need to distinguish between rgb and bgr.
     // Each color channel will get the same value.
     SkOpts::grayA_to_rgbA((uint32_t*) dst, src + offset, width);
 }
 
-// kBGRX
+// kBGR
 
-static void swizzle_bgrx_to_n32(
+static void swizzle_bgr_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
-    src += offset;
-    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    for (int x = 0; x < dstWidth; x++) {
-        dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
-        src += deltaSrc;
-    }
-}
-
-static void swizzle_bgrx_to_565(
-        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
-
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPack888ToRGB16(src[2], src[1], src[0]);
         src += deltaSrc;
     }
 }
 
-// kBGRA
+// kRGB
 
-static void swizzle_bgra_to_n32_unpremul(
+static void swizzle_rgb_to_rgba(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
-        uint8_t alpha = src[3];
-        dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
+        dst[x] = SkPackARGB_as_RGBA(0xFF, src[0], src[1], src[2]);
         src += deltaSrc;
     }
 }
 
-static void fast_swizzle_bgra_to_n32_unpremul(
-        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
-        const SkPMColor ctable[]) {
-
-    // This function must not be called if we are sampling.  If we are not
-    // sampling, deltaSrc should equal bpp.
-    SkASSERT(deltaSrc == bpp);
-
-#ifdef SK_PMCOLOR_IS_RGBA
-    SkOpts::RGBA_to_BGRA((uint32_t*) dst, src + offset, width);
-#else
-    memcpy(dst, src + offset, width * bpp);
-#endif
-}
-
-static void swizzle_bgra_to_n32_premul(
+static void swizzle_rgb_to_bgra(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
-        uint8_t alpha = src[3];
-        dst[x] = SkPremultiplyARGBInline(alpha, src[2], src[1], src[0]);
+        dst[x] = SkPackARGB_as_BGRA(0xFF, src[0], src[1], src[2]);
         src += deltaSrc;
     }
 }
 
-static void fast_swizzle_bgra_to_n32_premul(
-        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
-        const SkPMColor ctable[]) {
+static void fast_swizzle_rgb_to_rgba(
+        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+        int offset, const SkPMColor ctable[]) {
 
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
-#ifdef SK_PMCOLOR_IS_RGBA
-    SkOpts::RGBA_to_bgrA((uint32_t*) dst, src + offset, width);
-#else
-    SkOpts::RGBA_to_rgbA((uint32_t*) dst, src + offset, width);
-#endif
+    SkOpts::RGB_to_RGB1((uint32_t*) dst, src + offset, width);
 }
 
-// kRGB
-
-static void swizzle_rgb_to_n32(
-        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
-
-    src += offset;
-    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    for (int x = 0; x < dstWidth; x++) {
-        dst[x] = SkPackARGB32NoCheck(0xFF, src[0], src[1], src[2]);
-        src += deltaSrc;
-    }
-}
-
-static void fast_swizzle_rgb_to_n32(
+static void fast_swizzle_rgb_to_bgra(
         void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
         int offset, const SkPMColor ctable[]) {
 
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
-#ifdef SK_PMCOLOR_IS_RGBA
-    SkOpts::RGB_to_RGB1((uint32_t*) dst, src + offset, width);
-#else
     SkOpts::RGB_to_BGR1((uint32_t*) dst, src + offset, width);
-#endif
 }
 
 static void swizzle_rgb_to_565(
        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
        int bytesPerPixel, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPack888ToRGB16(src[0], src[1], src[2]);
         src += deltaSrc;
     }
 }
 
 // kRGBA
 
-static void swizzle_rgba_to_n32_premul(
+static void swizzle_rgba_to_rgba_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
-        unsigned alpha = src[3];
-        dst[x] = SkPremultiplyARGBInline(alpha, src[0], src[1], src[2]);
+        dst[x] = premultiply_argb_as_rgba(src[3], src[0], src[1], src[2]);
         src += deltaSrc;
     }
 }
 
-static void fast_swizzle_rgba_to_n32_premul(
+static void swizzle_rgba_to_bgra_premul(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
+
+    src += offset;
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    for (int x = 0; x < dstWidth; x++) {
+        dst[x] = premultiply_argb_as_bgra(src[3], src[0], src[1], src[2]);
+        src += deltaSrc;
+    }
+}
+
+static void fast_swizzle_rgba_to_rgba_premul(
         void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
         int offset, const SkPMColor ctable[]) {
 
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
-#ifdef SK_PMCOLOR_IS_RGBA
     SkOpts::RGBA_to_rgbA((uint32_t*) dst, src + offset, width);
-#else
-    SkOpts::RGBA_to_bgrA((uint32_t*) dst, src + offset, width);
-#endif
 }
 
-static void swizzle_rgba_to_n32_unpremul(
+static void fast_swizzle_rgba_to_bgra_premul(
+        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+        int offset, const SkPMColor ctable[]) {
+
+    // This function must not be called if we are sampling.  If we are not
+    // sampling, deltaSrc should equal bpp.
+    SkASSERT(deltaSrc == bpp);
+
+    SkOpts::RGBA_to_bgrA((uint32_t*) dst, src + offset, width);
+}
+
+static void swizzle_rgba_to_bgra_unpremul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
     for (int x = 0; x < dstWidth; x++) {
         unsigned alpha = src[3];
-        dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
+        dst[x] = SkPackARGB_as_BGRA(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
     }
 }
 
-static void fast_swizzle_rgba_to_n32_unpremul(
+static void fast_swizzle_rgba_to_bgra_unpremul(
         void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
         const SkPMColor ctable[]) {
 
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
-#ifdef SK_PMCOLOR_IS_RGBA
-    memcpy(dst, src + offset, width * bpp);
-#else
     SkOpts::RGBA_to_BGRA((uint32_t*) dst, src + offset, width);
-#endif
 }
 
 // kCMYK
 //
 // CMYK is stored as four bytes per pixel.
 //
 // We will implement a crude conversion from CMYK -> RGB using formulas
 // from easyrgb.com.
 //
 // CMYK -> CMY
@@ skipping 27 matching lines @@
 // B = Y * K * 255
 //
 // As a final note, we have treated the CMYK values as if they were on
 // a scale from 0-1, when in fact they are 8-bit ints scaling from 0-255.
 // We must divide each CMYK component by 255 to obtain the true conversion
 // we should perform.
 // CMYK -> RGB
 // R = C * K / 255
 // G = M * K / 255
 // B = Y * K / 255
-static void swizzle_cmyk_to_n32(
+static void swizzle_cmyk_to_rgba(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
+    src += offset;
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    for (int x = 0; x < dstWidth; x++) {
+        const uint8_t r = SkMulDiv255Round(src[0], src[3]);
+        const uint8_t g = SkMulDiv255Round(src[1], src[3]);
+        const uint8_t b = SkMulDiv255Round(src[2], src[3]);
+
+        dst[x] = SkPackARGB_as_RGBA(0xFF, r, g, b);
+        src += deltaSrc;
+    }
+}
+
+static void swizzle_cmyk_to_bgra(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
+
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         const uint8_t r = SkMulDiv255Round(src[0], src[3]);
         const uint8_t g = SkMulDiv255Round(src[1], src[3]);
         const uint8_t b = SkMulDiv255Round(src[2], src[3]);
 
-        dst[x] = SkPackARGB32NoCheck(0xFF, r, g, b);
+        dst[x] = SkPackARGB_as_BGRA(0xFF, r, g, b);
         src += deltaSrc;
     }
 }
 
-static void fast_swizzle_cmyk_to_n32(
+static void fast_swizzle_cmyk_to_rgba(
         void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
         const SkPMColor ctable[]) {
 
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
-#ifdef SK_PMCOLOR_IS_RGBA
     SkOpts::inverted_CMYK_to_RGB1((uint32_t*) dst, src + offset, width);
-#else
+}
+
+static void fast_swizzle_cmyk_to_bgra(
+        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
+        const SkPMColor ctable[]) {
+
+    // This function must not be called if we are sampling.  If we are not
+    // sampling, deltaSrc should equal bpp.
+    SkASSERT(deltaSrc == bpp);
+
     SkOpts::inverted_CMYK_to_BGR1((uint32_t*) dst, src + offset, width);
-#endif
 }
 
 static void swizzle_cmyk_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         const uint8_t r = SkMulDiv255Round(src[0], src[3]);
@@ skipping 36 matching lines @@
     // This may miss opportunities to skip when the output is premultiplied,
     // e.g. for a src pixel 0x00FFFFFF which is not zero but becomes zero after premultiplication.
     while (dstWidth > 0 && *src32 == 0x00000000) {
         dstWidth--;
         dst32++;
         src32 += deltaSrc/4;
     }
     proc(dst32, (const uint8_t*)src32, dstWidth, bpp, deltaSrc, 0, ctable);
 }
 
-SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
+SkSwizzler* SkSwizzler::CreateSwizzler(const SkEncodedInfo& encodedInfo,
                                        const SkPMColor* ctable,
                                        const SkImageInfo& dstInfo,
                                        const SkCodec::Options& options,
                                        const SkIRect* frame) {
-    if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
+    if (SkEncodedInfo::kPalette_Color == encodedInfo.color() && nullptr == ctable) {
         return nullptr;
     }
-    if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
-            && nullptr == ctable) {
-        return nullptr;
-    }
+
     RowProc fastProc = nullptr;
     RowProc proc = nullptr;
     SkCodec::ZeroInitialized zeroInit = options.fZeroInitialized;
-    switch (sc) {
-        case kBit:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    proc = &swizzle_bit_to_n32;
-                    break;
-                case kIndex_8_SkColorType:
-                    proc = &swizzle_bit_to_index;
-                    break;
-                case kRGB_565_SkColorType:
-                    proc = &swizzle_bit_to_565;
-                    break;
-                case kGray_8_SkColorType:
-                    proc = &swizzle_bit_to_grayscale;
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kIndex1:
-        case kIndex2:
-        case kIndex4:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    proc = &swizzle_small_index_to_n32;
-                    break;
-                case kRGB_565_SkColorType:
-                    proc = &swizzle_small_index_to_565;
-                    break;
-                case kIndex_8_SkColorType:
-                    proc = &swizzle_small_index_to_index;
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kIndex:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    // We assume the color premultiplied ctable (or not) as desired.
-                    if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                        proc = &swizzle_index_to_n32_skipZ;
-                        break;
-                    } else {
-                        proc = &swizzle_index_to_n32;
-                        break;
-                    }
-                    break;
-                case kRGB_565_SkColorType:
-                    proc = &swizzle_index_to_565;
-                    break;
-                case kIndex_8_SkColorType:
-                    proc = &sample1;
-                    fastProc = &copy;
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kGray:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    proc = &swizzle_gray_to_n32;
-                    fastProc = &fast_swizzle_gray_to_n32;
-                    break;
-                case kGray_8_SkColorType:
-                    proc = &sample1;
-                    fastProc = &copy;
-                    break;
-                case kRGB_565_SkColorType:
-                    proc = &swizzle_gray_to_565;
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kGrayAlpha:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
+    bool premultiply = (SkEncodedInfo::kOpaque_Alpha != encodedInfo.alpha()) &&
+            (kPremul_SkAlphaType == dstInfo.alphaType());
+    switch (encodedInfo.color()) {
+        case SkEncodedInfo::kGray_Color:
+            switch (encodedInfo.bitsPerComponent()) {
+                case 1:
+                    switch (dstInfo.colorType()) {
+                        case kRGBA_8888_SkColorType:
+                        case kBGRA_8888_SkColorType:
+                            proc = &swizzle_bit_to_n32;
+                            break;
+                        case kIndex_8_SkColorType:
+                            proc = &swizzle_bit_to_index;
+                            break;
+                        case kRGB_565_SkColorType:
+                            proc = &swizzle_bit_to_565;
+                            break;
+                        case kGray_8_SkColorType:
+                            proc = &swizzle_bit_to_grayscale;
+                            break;
+                        default:
+                            return nullptr;
+                    }
+                    break;
+                case 8:
+                    switch (dstInfo.colorType()) {
+                        case kRGBA_8888_SkColorType:
+                        case kBGRA_8888_SkColorType:
+                            proc = &swizzle_gray_to_n32;
+                            fastProc = &fast_swizzle_gray_to_n32;
+                            break;
+                        case kGray_8_SkColorType:
+                            proc = &sample1;
+                            fastProc = &copy;
+                            break;
+                        case kRGB_565_SkColorType:
+                            proc = &swizzle_gray_to_565;
+                            break;
+                        default:
+                            return nullptr;
+                    }
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kGrayAlpha_Color:
+            switch (dstInfo.colorType()) {
+                case kRGBA_8888_SkColorType:
+                case kBGRA_8888_SkColorType:
+                    if (premultiply) {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeadingGrayAlphaZerosThen<swizzle_grayalpha_to_n32_premul>;
+                            fastProc = &SkipLeadingGrayAlphaZerosThen
+                                    <fast_swizzle_grayalpha_to_n32_premul>;
+                        } else {
+                            proc = &swizzle_grayalpha_to_n32_premul;
+                            fastProc = &fast_swizzle_grayalpha_to_n32_premul;
+                        }
+                    } else {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeadingGrayAlphaZerosThen
                                     <swizzle_grayalpha_to_n32_unpremul>;
                             fastProc = &SkipLeadingGrayAlphaZerosThen
                                     <fast_swizzle_grayalpha_to_n32_unpremul>;
                         } else {
                             proc = &swizzle_grayalpha_to_n32_unpremul;
                             fastProc = &fast_swizzle_grayalpha_to_n32_unpremul;
                         }
-                    } else {
-                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                            proc = &SkipLeadingGrayAlphaZerosThen<swizzle_grayalpha_to_n32_premul>;
-                            fastProc = &SkipLeadingGrayAlphaZerosThen
-                                    <fast_swizzle_grayalpha_to_n32_premul>;
-                        } else {
-                            proc = &swizzle_grayalpha_to_n32_premul;
-                            fastProc = &fast_swizzle_grayalpha_to_n32_premul;
-                        }
-                    }
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kBGR:
-        case kBGRX:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    proc = &swizzle_bgrx_to_n32;
-                    break;
-                case kRGB_565_SkColorType:
-                    proc = &swizzle_bgrx_to_565;
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kBGRA:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
-                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                            proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_unpremul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_unpremul>;
-                        } else {
-                            proc = &swizzle_bgra_to_n32_unpremul;
-                            fastProc = &fast_swizzle_bgra_to_n32_unpremul;
-                        }
-                    } else {
-                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                            proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_premul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_premul>;
-                        } else {
-                            proc = &swizzle_bgra_to_n32_premul;
-                            fastProc = &fast_swizzle_bgra_to_n32_premul;
-                        }
-                    }
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kRGB:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    proc = &swizzle_rgb_to_n32;
-                    fastProc = &fast_swizzle_rgb_to_n32;
+                    }
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kPalette_Color:
+            // We assumes that the color table is premultiplied and swizzled
+            // as desired.
+            switch (encodedInfo.bitsPerComponent()) {
+                case 1:
+                case 2:
+                case 4:
+                    switch (dstInfo.colorType()) {
+                        case kRGBA_8888_SkColorType:
+                        case kBGRA_8888_SkColorType:
+                            proc = &swizzle_small_index_to_n32;
+                            break;
+                        case kRGB_565_SkColorType:
+                            proc = &swizzle_small_index_to_565;
+                            break;
+                        case kIndex_8_SkColorType:
+                            proc = &swizzle_small_index_to_index;
+                            break;
+                        default:
+                            return nullptr;
+                    }
+                    break;
+                case 8:
+                    switch (dstInfo.colorType()) {
+                        case kRGBA_8888_SkColorType:
+                        case kBGRA_8888_SkColorType:
+                            if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                                proc = &swizzle_index_to_n32_skipZ;
+                            } else {
+                                proc = &swizzle_index_to_n32;
+                            }
+                            break;
+                        case kRGB_565_SkColorType:
+                            proc = &swizzle_index_to_565;
+                            break;
+                        case kIndex_8_SkColorType:
+                            proc = &sample1;
+                            fastProc = &copy;
+                            break;
+                        default:
+                            return nullptr;
+                    }
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kRGB_Color:
+            switch (dstInfo.colorType()) {
+                case kRGBA_8888_SkColorType:
+                    proc = &swizzle_rgb_to_rgba;
+                    fastProc = &fast_swizzle_rgb_to_rgba;
+                    break;
+                case kBGRA_8888_SkColorType:
+                    proc = &swizzle_rgb_to_bgra;
+                    fastProc = &fast_swizzle_rgb_to_bgra;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_rgb_to_565;
                     break;
                 default:
-                    break;
-            }
-            break;
-        case kRGBA:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
-                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_unpremul>;
-                        } else {
-                            proc = &swizzle_rgba_to_n32_unpremul;
-                            fastProc = &fast_swizzle_rgba_to_n32_unpremul;
-                        }
-                    } else {
-                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_premul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_premul>;
-                        } else {
-                            proc = &swizzle_rgba_to_n32_premul;
-                            fastProc = &fast_swizzle_rgba_to_n32_premul;
-                        }
-                    }
-                    break;
-                default:
-                    break;
-            }
-            break;
-        case kCMYK:
-            switch (dstInfo.colorType()) {
-                case kN32_SkColorType:
-                    proc = &swizzle_cmyk_to_n32;
-                    fastProc = &fast_swizzle_cmyk_to_n32;
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kRGBA_Color:
+            switch (dstInfo.colorType()) {
+                case kRGBA_8888_SkColorType:
+                    if (premultiply) {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_rgba_premul>;
+                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_rgba_premul>;
+                        } else {
+                            proc = &swizzle_rgba_to_rgba_premul;
+                            fastProc = &fast_swizzle_rgba_to_rgba_premul;
+                        }
+                    } else {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<sample4>;
+                            fastProc = &SkipLeading8888ZerosThen<copy>;
+                        } else {
+                            proc = &sample4;
+                            fastProc = &copy;
+                        }
+                    }
+                    break;
+                case kBGRA_8888_SkColorType:
+                    if (premultiply) {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_premul>;
+                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_bgra_premul>;
+                        } else {
+                            proc = &swizzle_rgba_to_bgra_premul;
+                            fastProc = &fast_swizzle_rgba_to_bgra_premul;
+                        }
+                    } else {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_unpremul>;
+                            fastProc = &SkipLeading8888ZerosThen
+                                    <fast_swizzle_rgba_to_bgra_unpremul>;
+                        } else {
+                            proc = &swizzle_rgba_to_bgra_unpremul;
+                            fastProc = &fast_swizzle_rgba_to_bgra_unpremul;
+                        }
+                    }
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kBGR_Color:
+            switch (dstInfo.colorType()) {
+                case kBGRA_8888_SkColorType:
+                    proc = &swizzle_rgb_to_rgba;
+                    fastProc = &fast_swizzle_rgb_to_rgba;
+                    break;
+                case kRGBA_8888_SkColorType:
+                    proc = &swizzle_rgb_to_bgra;
+                    fastProc = &fast_swizzle_rgb_to_bgra;
+                    break;
+                case kRGB_565_SkColorType:
+                    proc = &swizzle_bgr_to_565;
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kBGRX_Color:
+            switch (dstInfo.colorType()) {
+                case kBGRA_8888_SkColorType:
+                    proc = &swizzle_rgb_to_rgba;
+                    break;
+                case kRGBA_8888_SkColorType:
+                    proc = &swizzle_rgb_to_bgra;
+                    break;
+                case kRGB_565_SkColorType:
+                    proc = &swizzle_bgr_to_565;
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kBGRA_Color:
+            switch (dstInfo.colorType()) {
+                case kBGRA_8888_SkColorType:
+                    if (premultiply) {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_rgba_premul>;
+                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_rgba_premul>;
+                        } else {
+                            proc = &swizzle_rgba_to_rgba_premul;
+                            fastProc = &fast_swizzle_rgba_to_rgba_premul;
+                        }
+                    } else {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<sample4>;
+                            fastProc = &SkipLeading8888ZerosThen<copy>;
+                        } else {
+                            proc = &sample4;
+                            fastProc = &copy;
+                        }
+                    }
+                    break;
+                case kRGBA_8888_SkColorType:
+                    if (premultiply) {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_premul>;
+                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_bgra_premul>;
+                        } else {
+                            proc = &swizzle_rgba_to_bgra_premul;
+                            fastProc = &fast_swizzle_rgba_to_bgra_premul;
+                        }
+                    } else {
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_unpremul>;
+                            fastProc = &SkipLeading8888ZerosThen
+                                    <fast_swizzle_rgba_to_bgra_unpremul>;
+                        } else {
+                            proc = &swizzle_rgba_to_bgra_unpremul;
+                            fastProc = &fast_swizzle_rgba_to_bgra_unpremul;
+                        }
+                    }
+                    break;
+                default:
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kInvertedCMYK_Color:
+            switch (dstInfo.colorType()) {
+                case kRGBA_8888_SkColorType:
+                    proc = &swizzle_cmyk_to_rgba;
+                    fastProc = &fast_swizzle_cmyk_to_rgba;
+                    break;
+                case kBGRA_8888_SkColorType:
+                    proc = &swizzle_cmyk_to_bgra;
+                    fastProc = &fast_swizzle_cmyk_to_bgra;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_cmyk_to_565;
                     break;
                 default:
-                    break;
-            }
-            break;
-        case kNoOp8:
-            proc = &sample1;
-            fastProc = &copy;
-            break;
-        case kNoOp16:
-            proc = sample2;
-            fastProc = &copy;
-            break;
-        case kNoOp32:
-            proc = &sample4;
-            fastProc = &copy;
+                    return nullptr;
+            }
+            break;
+        case SkEncodedInfo::kUnknown_Color:
+            // Use kUnknown to indicate that we don't need to swizzle.  The
+            // encoded format already matches the output format.
+            switch (dstInfo.colorType()) {
+                case kRGB_565_SkColorType:
+                    proc = &sample2;
+                    fastProc = &copy;
+                    break;
+                default:
+                    return nullptr;
+            }
             break;
         default:
-            break;
+            return nullptr;
     }
 
     // Store bpp in bytes if it is an even multiple, otherwise use bits
-    int srcBPP = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
+    uint8_t bitsPerPixel = encodedInfo.bitsPerPixel();
+    int srcBPP = SkIsAlign8(bitsPerPixel) ? encodedInfo.bytesPerPixel() : bitsPerPixel;
     int dstBPP = SkColorTypeBytesPerPixel(dstInfo.colorType());
 
     int srcOffset = 0;
     int srcWidth = dstInfo.width();
     int dstOffset = 0;
     int dstWidth = srcWidth;
     if (options.fSubset) {
         // We do not currently support subset decodes for image types that may have
         // frames (gif).
         SkASSERT(!frame);
@@ skipping 47 matching lines @@
     }
 
     return fAllocatedWidth;
 }
 
 void SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(nullptr != dst && nullptr != src);
     fActualProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
             fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);
 }