Support RGBA/BGRA swizzles using SkEncodedInfo

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::decodePalette(bool premultiply, SkColorType dstColorType, 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 266 matching lines @@
     return true;
 }
 
 SkPngCodec::SkPngCodec(const SkEncodedInfo& info, SkStream* stream, SkPngChunkReader* chunkReader,
                        png_structp png_ptr, png_infop info_ptr, int bitDepth, int numberPasses,
                        sk_sp<SkColorSpace> colorSpace)
     : INHERITED(info, stream, colorSpace)
     , fPngChunkReader(SkSafeRef(chunkReader))
     , fPng_ptr(png_ptr)
     , fInfo_ptr(info_ptr)
-    , fSrcConfig(SkSwizzler::kUnknown)
     , fNumberPasses(numberPasses)
     , fBitDepth(bitDepth)
 {}
 
 SkPngCodec::~SkPngCodec() {
     this->destroyReadStruct();
 }
 
 void SkPngCodec::destroyReadStruct() {
     if (fPng_ptr) {
@@ skipping 14 matching lines @@
                                                SkPMColor ctable[],
                                                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);
 
-    // suggestedColorType was determined in read_header() based on the encodedColorType
-    const SkColorType suggestedColorType = this->getInfo().colorType();
-
-    switch (suggestedColorType) {
-        case kIndex_8_SkColorType:
-            //decode palette to Skia format
-            fSrcConfig = SkSwizzler::kIndex;
-            if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(),
-                    ctableCount)) {
-                return kInvalidInput;
-            }
-            break;
-        case kGray_8_SkColorType:
-            fSrcConfig = SkSwizzler::kGray;
-            break;
-        case kN32_SkColorType: {
-            const uint8_t encodedColorType = png_get_color_type(fPng_ptr, fInfo_ptr);
-            if (PNG_COLOR_TYPE_GRAY_ALPHA == encodedColorType ||
-                    PNG_COLOR_TYPE_GRAY == encodedColorType) {
-                // If encodedColorType is GRAY, there must be a transparent chunk.
-                // Otherwise, suggestedColorType would be kGray.  We have already
-                // instructed libpng to convert the transparent chunk to alpha,
-                // so we can treat both GRAY and GRAY_ALPHA as kGrayAlpha.
-                SkASSERT(encodedColorType == PNG_COLOR_TYPE_GRAY_ALPHA ||
-                        png_get_valid(fPng_ptr, fInfo_ptr, PNG_INFO_tRNS));
-
-                fSrcConfig = SkSwizzler::kGrayAlpha;
-            } else {
-                if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
-                    fSrcConfig = SkSwizzler::kRGB;
-                } else {
-                    fSrcConfig = SkSwizzler::kRGBA;
-                }
-            }
-            break;
+    if (SkEncodedInfo::kPalette_Color == this->getEncodedInfo().color()) {
+        if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(),
+                requestedInfo.colorType(), ctableCount)) {
+            return kInvalidInput;
         }
-        default:
-            // We will always recommend one of the above colorTypes.
-            SkASSERT(false);
     }
 
     // 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(fSrcConfig, colors, requestedInfo, options));
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colors, requestedInfo,
+            options));
     SkASSERT(fSwizzler);
 
     return kSuccess;
 }
 
 
 bool SkPngCodec::onRewind() {
     // This sets fPng_ptr and fInfo_ptr to nullptr. If read_header
     // succeeds, they will be repopulated, and if it fails, they will
     // remain nullptr. Any future accesses to fPng_ptr and fInfo_ptr will
@@ skipping 26 matching lines @@
     }
 
     // Note that ctable and ctableCount may be modified if there is a color table
     const Result result = this->initializeSwizzler(requestedInfo, options, ctable, ctableCount);
     if (result != kSuccess) {
         return result;
     }
 
     const int width = requestedInfo.width();
     const int height = requestedInfo.height();
-    const int bpp = SkSwizzler::BytesPerPixel(fSrcConfig);
+    const int bpp = this->getEncodedInfo().bytesPerPixel();
     const size_t srcRowBytes = width * bpp;
 
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     int row = 0;
     // This must be declared above the call to setjmp to avoid memory leaks on incomplete images.
     SkAutoTMalloc<uint8_t> storage;
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         // Assume that any error that occurs while reading rows is caused by an incomplete input.
         if (fNumberPasses > 1) {
@@ skipping 75 matching lines @@
         if (!conversion_possible(dstInfo, this->getInfo())) {
             return kInvalidConversion;
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
                                                        ctableCount);
         if (result != kSuccess) {
             return result;
         }
 
-        fStorage.reset(this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig()));
+        fStorage.reset(this->getInfo().width() * this->getEncodedInfo().bytesPerPixel());
         fSrcRow = fStorage.get();
 
         return kSuccess;
     }
 
     int onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // Assume that an error in libpng indicates an incomplete input.
         int row = 0;
         if (setjmp(png_jmpbuf(this->png_ptr()))) {
             SkCodecPrintf("setjmp long jump!\n");
@@ skipping 51 matching lines @@
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
                                                        ctableCount);
         if (result != kSuccess) {
             return result;
         }
 
         fHeight = dstInfo.height();
         // FIXME: This need not be called on a second call to onStartScanlineDecode.
-        fSrcRowBytes = this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig());
+        fSrcRowBytes = this->getInfo().width() * this->getEncodedInfo().bytesPerPixel();
         fGarbageRow.reset(fSrcRowBytes);
         fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
         fCanSkipRewind = true;
 
         return SkCodec::kSuccess;
     }
 
     int onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
         // rewind stream if have previously called onGetScanlines,
         // since we need entire progressive image to get scanlines
@@ skipping 100 matching lines @@
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(imageInfo, streamDeleter.release(), chunkReader,
                                         png_ptr, info_ptr, bitDepth, colorSpace);
     }
 
     return new SkPngInterlacedScanlineDecoder(imageInfo, streamDeleter.release(), chunkReader,
                                               png_ptr, info_ptr, bitDepth, numberPasses,
                                               colorSpace);
 }