Support the non-native (RGBA/BGRA) swizzle

src/codec/SkPngCodec.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 "SkBitmap.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 68 matching lines @@
         fPng_ptr = nullptr;
         fInfo_ptr = nullptr;
     }
 
 private:
     png_structp     fPng_ptr;
     png_infop       fInfo_ptr;
 };
 #define AutoCleanPng(...) SK_REQUIRE_LOCAL_VAR(AutoCleanPng)
 
-// Method for coverting to either an SkPMColor or a similarly packed
-// unpremultiplied color.
-typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
-
 // Note: SkColorTable claims to store SkPMColors, which is not necessarily
 // the case here.
 // TODO: If we add support for non-native swizzles, we'll need to handle that here.
-bool SkPngCodec::decodePalette(bool premultiply, int* ctableCount) {
+bool SkPngCodec::createColorTable(SkColorType dstColorType, bool premultiply, int* ctableCount) {
 
     int numColors;
     png_color* palette;
     if (!png_get_PLTE(fPng_ptr, fInfo_ptr, &palette, &numColors)) {
         return false;
     }
 
     // Note: These are not necessarily SkPMColors.
     SkPMColor colorPtr[256];
 
     png_bytep alphas;
     int numColorsWithAlpha = 0;
     if (png_get_tRNS(fPng_ptr, fInfo_ptr, &alphas, &numColorsWithAlpha, nullptr)) {
         // Choose which function to use to create the color table. If the final destination's
         // colortype is unpremultiplied, the color table will store unpremultiplied colors.
-        PackColorProc proc;
-        if (premultiply) {
-            proc = &SkPremultiplyARGBInline;
-        } else {
-            proc = &SkPackARGB32NoCheck;
-        }
+        PackColorProc proc = choose_pack_color_proc(premultiply, dstColorType);
 
         for (int i = 0; i < numColorsWithAlpha; i++) {
             // We don't have a function in SkOpts that combines a set of alphas with a set
             // of RGBs.  We could write one, but it's hardly worth it, given that this
             // is such a small fraction of the total decode time.
             colorPtr[i] = proc(alphas[i], palette->red, palette->green, palette->blue);
             palette++;
         }
     }
 
     if (numColorsWithAlpha < numColors) {
         // The optimized code depends on a 3-byte png_color struct with the colors
         // in RGB order.  These checks make sure it is safe to use.
         static_assert(3 == sizeof(png_color), "png_color struct has changed.  Opts are broken.");
 #ifdef SK_DEBUG
         SkASSERT(&palette->red < &palette->green);
         SkASSERT(&palette->green < &palette->blue);
 #endif
 
-#ifdef SK_PMCOLOR_IS_RGBA
-        SkOpts::RGB_to_RGB1(colorPtr + numColorsWithAlpha, palette, numColors - numColorsWithAlpha);
-#else
-        SkOpts::RGB_to_BGR1(colorPtr + numColorsWithAlpha, palette, numColors - numColorsWithAlpha);
-#endif
+        if (is_rgba(dstColorType)) {
+            SkOpts::RGB_to_RGB1(colorPtr + numColorsWithAlpha, palette,
+                    numColors - numColorsWithAlpha);
+        } else {
+            SkOpts::RGB_to_BGR1(colorPtr + numColorsWithAlpha, palette,
+                    numColors - numColorsWithAlpha);
+        }
     }
 
     // Pad the color table with the last color in the table (or black) in the case that
     // invalid pixel indices exceed the number of colors in the table.
     const int maxColors = 1 << fBitDepth;
     if (numColors < maxColors) {
         SkPMColor lastColor = numColors > 0 ? colorPtr[numColors - 1] : SK_ColorBLACK;
         sk_memset32(colorPtr + numColors, lastColor, maxColors - numColors);
     }
 
@@ skipping 315 matching lines @@
                                                int* ctableCount) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
     png_read_update_info(fPng_ptr, fInfo_ptr);
 
     if (SkEncodedInfo::kPalette_Color == this->getEncodedInfo().color()) {
-        if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(), ctableCount)) {
+        if (!this->createColorTable(requestedInfo.colorType(),
+                kPremul_SkAlphaType == requestedInfo.alphaType(), ctableCount)) {
             return kInvalidInput;
         }
     }
 
     // Copy the color table to the client if they request kIndex8 mode
     copy_color_table(requestedInfo, fColorTable, ctable, ctableCount);
 
     // Create the swizzler.  SkPngCodec retains ownership of the color table.
     const SkPMColor* colors = get_color_ptr(fColorTable.get());
     fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colors, requestedInfo,
@@ skipping 336 matching lines @@
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(width, height, imageInfo, streamDeleter.release(),
                                         chunkReader, png_ptr, info_ptr, bitDepth, colorSpace);
     }
 
     return new SkPngInterlacedScanlineDecoder(width, height, imageInfo, streamDeleter.release(),
                                               chunkReader, png_ptr, info_ptr, bitDepth,
                                               numberPasses, colorSpace);
 }