Add Gray support to SkPNGImageEncoder

src/images/SkPNGImageEncoder.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageEncoder.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
@@ skipping 58 matching lines @@
         SkColorType             fColorType;
         bool                    fHasAlpha;
         transform_scanline_proc fProc;
     } gMap[] = {
         { kRGB_565_SkColorType,     false,  transform_scanline_565 },
         { kN32_SkColorType,         false,  transform_scanline_888 },
         { kN32_SkColorType,         true,   transform_scanline_8888 },
         { kARGB_4444_SkColorType,   false,  transform_scanline_444 },
         { kARGB_4444_SkColorType,   true,   transform_scanline_4444 },
         { kIndex_8_SkColorType,     false,  transform_scanline_memcpy },
+        { kGray_8_SkColorType,      false,  transform_scanline_memcpy },
     };
 
     for (int i = SK_ARRAY_COUNT(gMap) - 1; i >= 0; --i) {
         if (gMap[i].fColorType == ct && gMap[i].fHasAlpha == hasAlpha) {
             return gMap[i].fProc;
         }
     }
     sk_throw();
     return nullptr;
 }
@@ skipping 82 matching lines @@
     typedef SkImageEncoder INHERITED;
 };
 
 bool SkPNGImageEncoder::onEncode(SkWStream* stream,
                                  const SkBitmap& originalBitmap,
                                  int /*quality*/) {
     SkBitmap copy;
     const SkBitmap* bitmap = &originalBitmap;
     switch (originalBitmap.colorType()) {
         case kIndex_8_SkColorType:
+        case kGray_8_SkColorType:
         case kN32_SkColorType:
         case kARGB_4444_SkColorType:
         case kRGB_565_SkColorType:
             break;
         default:
             // TODO(scroggo): support 8888-but-not-N32 natively.
-            // TODO(scroggo): support kGray_8 directly.
             // TODO(scroggo): support Alpha_8 as Grayscale(black)+Alpha
             if (originalBitmap.copyTo(&copy, kN32_SkColorType)) {
                 bitmap = ©
             }
     }
     SkColorType ct = bitmap->colorType();
 
     const bool hasAlpha = !bitmap->isOpaque();
-    int colorType = PNG_COLOR_MASK_COLOR;
     int bitDepth = 8;   // default for color
     png_color_8 sig_bit;
+    sk_bzero(&sig_bit, sizeof(png_color_8));
 
+    int colorType;
     switch (ct) {
         case kIndex_8_SkColorType:
-            colorType |= PNG_COLOR_MASK_PALETTE;
-            // fall through to the ARGB_8888 case
+            sig_bit.red = 8;
+            sig_bit.green = 8;
+            sig_bit.blue = 8;
+            sig_bit.alpha = 8;
+            colorType = PNG_COLOR_TYPE_PALETTE;
+            break;
+        case kGray_8_SkColorType:
+            sig_bit.gray = 8;
+            colorType = PNG_COLOR_TYPE_GRAY;
+            SkASSERT(!hasAlpha);
+            break;
         case kN32_SkColorType:
             sig_bit.red = 8;
             sig_bit.green = 8;
             sig_bit.blue = 8;
             sig_bit.alpha = 8;
+            colorType = hasAlpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
             break;
         case kARGB_4444_SkColorType:
             sig_bit.red = 4;
             sig_bit.green = 4;
             sig_bit.blue = 4;
             sig_bit.alpha = 4;
+            colorType = hasAlpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
             break;
         case kRGB_565_SkColorType:
             sig_bit.red = 5;
             sig_bit.green = 6;
             sig_bit.blue = 5;
-            sig_bit.alpha = 0;
+            colorType = PNG_COLOR_TYPE_RGB;
+            SkASSERT(!hasAlpha);
             break;
         default:
             return false;
     }
 
-    if (hasAlpha) {
-        // don't specify alpha if we're a palette, even if our ctable has alpha
-        if (!(colorType & PNG_COLOR_MASK_PALETTE)) {
-            colorType |= PNG_COLOR_MASK_ALPHA;
-        }
-    } else {
-        sig_bit.alpha = 0;
-    }
-
     SkAutoLockPixels alp(*bitmap);
     // readyToDraw checks for pixels (and colortable if that is required)
     if (!bitmap->readyToDraw()) {
         return false;
     }
 
     // we must do this after we have locked the pixels
     SkColorTable* ctable = bitmap->getColorTable();
     if (ctable) {
         if (ctable->count() == 0) {
@@ skipping 54 matching lines @@
     png_color paletteColors[256];
     png_byte trans[256];
     if (kIndex_8_SkColorType == ct) {
         SkColorTable* ct = bitmap.getColorTable();
         int numTrans = pack_palette(ct, paletteColors, trans, hasAlpha);
         png_set_PLTE(png_ptr, info_ptr, paletteColors, ct->count());
         if (numTrans > 0) {
             png_set_tRNS(png_ptr, info_ptr, trans, numTrans, nullptr);
         }
     }
-#ifdef PNG_sBIT_SUPPORTED
+
     png_set_sBIT(png_ptr, info_ptr, &sig_bit);
-#endif
     png_write_info(png_ptr, info_ptr);
 
     const char* srcImage = (const char*)bitmap.getPixels();
     SkAutoSTMalloc<1024, char> rowStorage(bitmap.width() << 2);
     char* storage = rowStorage.get();
     transform_scanline_proc proc = choose_proc(ct, hasAlpha);
 
     for (int y = 0; y < bitmap.height(); y++) {
         png_bytep row_ptr = (png_bytep)storage;
         proc(srcImage, bitmap.width(), storage);
@@ skipping 10 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 DEFINE_ENCODER_CREATOR(PNGImageEncoder);
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? new SkPNGImageEncoder : nullptr;
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);