Add Alpha8 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 59 matching lines @@
         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 },
+        { kAlpha_8_SkColorType,     true,   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 83 matching lines @@
 };
 
 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 kAlpha_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 Alpha_8 as Grayscale(black)+Alpha
             if (originalBitmap.copyTo(&copy, kN32_SkColorType)) {
                 bitmap = ©
             }
     }
     SkColorType ct = bitmap->colorType();
 
     const bool hasAlpha = !bitmap->isOpaque();
     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:
             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 kAlpha_8_SkColorType:
+            // This is a bit of a trick.  PNG does not have an alpha-only format, so
+            // we tell libpng that we are encoding a gray image.  We'll also encode
+            // an extra custom chunk, so our decoder knows that the image is actually
+            // Alpha8.
+            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;
@@ skipping 81 matching lines @@
     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);
         }
     }
 
     png_set_sBIT(png_ptr, info_ptr, &sig_bit);
+
+    if (kAlpha_8_SkColorType == ct) {
+        static constexpr char key[] = "SkColorType";
+        static constexpr char value[] = "Alpha8";
+
+        png_text text;
+        text.compression = 0; // Use deflate for text compression.
+        text.key = const_cast<char*>(key);
+        text.text = const_cast<char*>(value);
+        text.text_length = sizeof(value) - 1;
+        text.itxt_length = 0;
+        text.lang = nullptr;
+        text.lang_key = nullptr;
+        png_set_text(png_ptr, info_ptr, &text, 1);
+    }
+
     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);