SkPNGImageEncoder encodes all SkColorTypes

src/images/SkImageDecoder_libpng.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 "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkColor.h"
@@ skipping 809 matching lines @@
     bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) override;
 private:
     bool doEncode(SkWStream* stream, const SkBitmap& bm,
                   const bool& hasAlpha, int colorType,
                   int bitDepth, SkColorType ct,
                   png_color_8& sig_bit);
 
     typedef SkImageEncoder INHERITED;
 };
 
-bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, int /*quality*/) {
-    SkColorType ct = bitmap.colorType();
+bool SkPNGImageEncoder::onEncode(SkWStream* stream,
+                                 const SkBitmap& originalBitmap,
+                                 int /*quality*/) {
+    SkBitmap copy;
+    const SkBitmap* bitmap = &originalBitmap;
+    switch (originalBitmap.colorType()) {
+        case kIndex_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();
+    const bool hasAlpha = !bitmap->isOpaque();
     int colorType = PNG_COLOR_MASK_COLOR;
     int bitDepth = 8;   // default for color
     png_color_8 sig_bit;
 
     switch (ct) {
         case kIndex_8_SkColorType:
             colorType |= PNG_COLOR_MASK_PALETTE;
             // fall through to the ARGB_8888 case
         case kN32_SkColorType:
             sig_bit.red = 8;
@@ skipping 19 matching lines @@
 
     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);
+    SkAutoLockPixels alp(*bitmap);
     // readyToDraw checks for pixels (and colortable if that is required)
-    if (!bitmap.readyToDraw()) {
+    if (!bitmap->readyToDraw()) {
         return false;
     }
 
     // we must do this after we have locked the pixels
-    SkColorTable* ctable = bitmap.getColorTable();
+    SkColorTable* ctable = bitmap->getColorTable();
     if (ctable) {
         if (ctable->count() == 0) {
             return false;
         }
         // check if we can store in fewer than 8 bits
         bitDepth = computeBitDepth(ctable->count());
     }
 
-    return doEncode(stream, bitmap, hasAlpha, colorType, bitDepth, ct, sig_bit);
+    return doEncode(stream, *bitmap, hasAlpha, colorType, bitDepth, ct, sig_bit);
 }
 
 bool SkPNGImageEncoder::doEncode(SkWStream* stream, const SkBitmap& bitmap,
                   const bool& hasAlpha, int colorType,
                   int bitDepth, SkColorType ct,
                   png_color_8& sig_bit) {
 
     png_structp png_ptr;
     png_infop info_ptr;
 
@@ skipping 96 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? new SkPNGImageEncoder : nullptr;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libpng_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_png);
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);