Handle gray alpha conversions in SkSwizzler

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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
@@ skipping 279 matching lines @@
             colorType = kN32_SkColorType;
             break;
         case PNG_COLOR_TYPE_GRAY:
             // Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel.
             if (bitDepth < 8) {
                 // TODO: Should we use SkSwizzler here?
                 png_set_expand_gray_1_2_4_to_8(png_ptr);
             }
 
             if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-                // Convert to RGBA if there is a transparency chunk.
                 png_set_tRNS_to_alpha(png_ptr);
-                png_set_gray_to_rgb(png_ptr);
+
+                // We will recommend kN32 here since we do not support kGray
+                // with alpha.
                 colorType = kN32_SkColorType;
                 alphaType = kUnpremul_SkAlphaType;
             } else {
                 colorType = kGray_8_SkColorType;
                 alphaType = kOpaque_SkAlphaType;
             }
             break;
         case PNG_COLOR_TYPE_GRAY_ALPHA:
-            // Convert to RGBA if the image has alpha.
-            png_set_gray_to_rgb(png_ptr);
+            // We will recommend kN32 here since we do not support anything
+            // similar to GRAY_ALPHA.
             colorType = kN32_SkColorType;
             alphaType = kUnpremul_SkAlphaType;
             break;
         case PNG_COLOR_TYPE_RGBA:
             colorType = kN32_SkColorType;
             alphaType = kUnpremul_SkAlphaType;
             break;
         default:
             // All the color types have been covered above.
             SkASSERT(false);
@@ skipping 54 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);
 
-    // srcColorType was determined in read_header() which determined png color type
-    const SkColorType srcColorType = this->getInfo().colorType();
+    // suggestedColorType was determined in read_header() based on the encodedColorType
+    const SkColorType suggestedColorType = this->getInfo().colorType();
 
-    switch (srcColorType) {
+    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:
-            if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
+        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;
+        }
         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());
@@ skipping 329 matching lines @@
     }
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(imageInfo, streamDeleter.detach(), chunkReader,
                                         png_ptr, info_ptr, bitDepth);
     }
 
     return new SkPngInterlacedScanlineDecoder(imageInfo, streamDeleter.detach(), chunkReader,
                                               png_ptr, info_ptr, bitDepth, numberPasses);
 }