Fix for Issue 331895: Make gesturenav screenshot greyscale

ui/gfx/codec/png_codec.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/codec/png_codec.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "third_party/libpng/png.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "third_party/zlib/zlib.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 
 namespace {
 
+// Transform coefficients (expressed in 16.16 fixed-point numbers)
+// for RGB into grayscale.
+// Same coefficients as used in png_do_rgb_to_gray() in pngtran.c in libpng
+static const uint32_t RED_TO_GRAY_COEF = 6969;       // .212671 * 32768

[sadrul, 2014/01/15 21:43:06]

two spaces before EOL // comments

+static const uint32_t GREEN_TO_GRAY_COEF = 23434;      // .715160 * 32768
+static const uint32_t BLUE_TO_GRAY_COEF = 32768 - RED_TO_GRAY_COEF -
+    GREEN_TO_GRAY_COEF;
+
+static inline unsigned char PixelRgbtoGray(unsigned char r, unsigned char b,
+                                      unsigned char g) {
+  return (RED_TO_GRAY_COEF * r + GREEN_TO_GRAY_COEF * g +
+      BLUE_TO_GRAY_COEF * b) >> 15;
+}
+
+
 // Converts BGRA->RGBA and RGBA->BGRA.
 void ConvertBetweenBGRAandRGBA(const unsigned char* input, int pixel_width,
                                unsigned char* output, bool* is_opaque) {
   for (int x = 0; x < pixel_width; x++) {
     const unsigned char* pixel_in = &input[x * 4];
     unsigned char* pixel_out = &output[x * 4];
     pixel_out[0] = pixel_in[2];
     pixel_out[1] = pixel_in[1];
     pixel_out[2] = pixel_in[0];
     pixel_out[3] = pixel_in[3];
   }
 }
 
+void ConvertBGRAtoGray(const unsigned char* bgra, int pixel_width,
+                       unsigned char* gray, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &bgra[x * 4];
+    gray[x] = PixelRgbtoGray(pixel_in[2], pixel_in[1], pixel_in[0]);
+  }
+}
+
+void ConvertBGRAtoGrayAlpha(const unsigned char* bgra, int pixel_width,
+                            unsigned char* grayalpha, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &bgra[x * 4];
+    unsigned char* pixel_out = &grayalpha[x * 2];
+    pixel_out[0] = PixelRgbtoGray(pixel_in[2], pixel_in[1], pixel_in[0]);
+    pixel_out[1] = pixel_in[3]; // alpha
+  }
+}
+
+void ConvertRGBtoGray(const unsigned char* rgb, int pixel_width,
+                      unsigned char* gray, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &rgb[x * 3];
+    gray[x] = PixelRgbtoGray(pixel_in[0], pixel_in[1], pixel_in[2]);
+  }
+}
+
 void ConvertRGBAtoRGB(const unsigned char* rgba, int pixel_width,
                       unsigned char* rgb, bool* is_opaque) {
   for (int x = 0; x < pixel_width; x++) {
     const unsigned char* pixel_in = &rgba[x * 4];
     unsigned char* pixel_out = &rgb[x * 3];
     pixel_out[0] = pixel_in[0];
     pixel_out[1] = pixel_in[1];
     pixel_out[2] = pixel_in[2];
   }
 }
 
+void ConvertRGBAtoGray(const unsigned char* rgba, int pixel_width,
+                      unsigned char* gray, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &rgba[x * 4];
+    gray[x] = PixelRgbtoGray(pixel_in[0], pixel_in[1], pixel_in[2]);
+  }
+}
+
+void ConvertRGBAtoGrayAlpha(const unsigned char* rgba, int pixel_width,
+                            unsigned char* grayalpha, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const unsigned char* pixel_in = &rgba[x * 4];
+    unsigned char* pixel_out = &grayalpha[x * 2];
+    pixel_out[0] = PixelRgbtoGray(pixel_in[0], pixel_in[1], pixel_in[2]);
+    pixel_out[1] = pixel_in[3]; // alpha
+  }
+}
+
+
 void ConvertSkiatoRGB(const unsigned char* skia, int pixel_width,
                       unsigned char* rgb, bool* is_opaque) {
   for (int x = 0; x < pixel_width; x++) {
     const uint32_t pixel_in = *reinterpret_cast<const uint32_t*>(&skia[x * 4]);
     unsigned char* pixel_out = &rgb[x * 3];
 
     int alpha = SkGetPackedA32(pixel_in);
     if (alpha != 0 && alpha != 255) {
       SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(pixel_in);
       pixel_out[0] = SkColorGetR(unmultiplied);
       pixel_out[1] = SkColorGetG(unmultiplied);
       pixel_out[2] = SkColorGetB(unmultiplied);
     } else {
       pixel_out[0] = SkGetPackedR32(pixel_in);
       pixel_out[1] = SkGetPackedG32(pixel_in);
       pixel_out[2] = SkGetPackedB32(pixel_in);
     }
   }
 }
 
 void ConvertSkiatoRGBA(const unsigned char* skia, int pixel_width,
                        unsigned char* rgba, bool* is_opaque) {
   gfx::ConvertSkiaToRGBA(skia, pixel_width, rgba);
 }
 
+void ConvertSkiatoGray(const unsigned char* skia, int pixel_width,
+                       unsigned char* gray, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const uint32_t pixel_in = *reinterpret_cast<const uint32_t*>(&skia[x * 4]);
+    unsigned char* pixel_out = &gray[x];
+
+    int alpha = SkGetPackedA32(pixel_in);
+    if (alpha != 0 && alpha != 255) {
+      SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(pixel_in);
+      pixel_out[0] = PixelRgbtoGray(SkColorGetR(unmultiplied),
+                                    SkColorGetG(unmultiplied),
+                                    SkColorGetB(unmultiplied));
+    } else {
+      pixel_out[0] = PixelRgbtoGray(SkGetPackedR32(pixel_in),
+                                    SkGetPackedG32(pixel_in),
+                                    SkGetPackedB32(pixel_in));
+    }
+  }
+}
+
+void ConvertSkiatoGrayAlpha(const unsigned char* skia, int pixel_width,
+                            unsigned char* grayalpha, bool* is_opaque) {
+  for (int x = 0; x < pixel_width; x++) {
+    const uint32_t pixel_in = *reinterpret_cast<const uint32_t*>(&skia[x * 4]);
+    unsigned char* pixel_out = &grayalpha[x * 2];
+
+    int alpha = SkGetPackedA32(pixel_in);
+    if (alpha != 0 && alpha != 255) {
+      SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(pixel_in);
+      pixel_out[0] = PixelRgbtoGray(SkColorGetR(unmultiplied),
+                                    SkColorGetG(unmultiplied),
+                                    SkColorGetB(unmultiplied));
+    } else {
+      pixel_out[0] = PixelRgbtoGray(SkGetPackedR32(pixel_in),
+                                    SkGetPackedG32(pixel_in),
+                                    SkGetPackedB32(pixel_in));
+    }
+    pixel_out[1] = alpha;
+  }
+}
+
+
 }  // namespace
 
 // Decoder --------------------------------------------------------------------
 //
 // This code is based on WebKit libpng interface (PNGImageDecoder), which is
 // in turn based on the Mozilla png decoder.
 
 namespace {
 
 // Gamma constants: We assume we're on Windows which uses a gamma of 2.2.
@@ skipping 548 matching lines @@
 
   png_write_end(png_ptr, info_ptr);
   return true;
 }
 
 bool EncodeWithCompressionLevel(const unsigned char* input,
                                 PNGCodec::ColorFormat format,
                                 const Size& size,
                                 int row_byte_width,
                                 bool discard_transparency,
+                                bool discard_color,
                                 const std::vector<PNGCodec::Comment>& comments,
                                 int compression_level,
                                 std::vector<unsigned char>* output) {
   // Run to convert an input row into the output row format, NULL means no
   // conversion is necessary.
   FormatConverter converter = NULL;
 
   int input_color_components, output_color_components;
   int png_output_color_type;
   switch (format) {
     case PNGCodec::FORMAT_RGB:
       input_color_components = 3;
-      output_color_components = 3;
-      png_output_color_type = PNG_COLOR_TYPE_RGB;
+      if (discard_color) {
+        output_color_components = 1;
+        png_output_color_type = PNG_COLOR_TYPE_GRAY;
+        converter = ConvertRGBtoGray;
+      } else {
+        output_color_components = 3;
+        png_output_color_type = PNG_COLOR_TYPE_RGB;
+        converter = NULL;
+      }
       break;
 
     case PNGCodec::FORMAT_RGBA:
       input_color_components = 4;
       if (discard_transparency) {
-        output_color_components = 3;
-        png_output_color_type = PNG_COLOR_TYPE_RGB;
-        converter = ConvertRGBAtoRGB;
+        if (discard_color) {
+          output_color_components = 1;
+          png_output_color_type = PNG_COLOR_TYPE_GRAY;
+          converter = ConvertRGBAtoGray;
+        } else {
+          output_color_components = 3;
+          png_output_color_type = PNG_COLOR_TYPE_RGB;
+          converter = ConvertRGBAtoRGB;
+        }
       } else {
-        output_color_components = 4;
-        png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
-        converter = NULL;
+        if (discard_color) {
+          output_color_components = 2;
+          png_output_color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+          converter = ConvertRGBAtoGrayAlpha;
+        } else {
+          output_color_components = 4;
+          png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+          converter = NULL;
+        }
       }
       break;
 
     case PNGCodec::FORMAT_BGRA:
       input_color_components = 4;
       if (discard_transparency) {
-        output_color_components = 3;
-        png_output_color_type = PNG_COLOR_TYPE_RGB;
-        converter = ConvertBGRAtoRGB;
+        if (discard_color) {
+          output_color_components = 1;
+          png_output_color_type = PNG_COLOR_TYPE_GRAY;
+          converter = ConvertBGRAtoGray;
+        } else {
+          output_color_components = 3;
+          png_output_color_type = PNG_COLOR_TYPE_RGB;
+          converter = ConvertBGRAtoRGB;
+        }
       } else {
-        output_color_components = 4;
-        png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
-        converter = ConvertBetweenBGRAandRGBA;
+        if (discard_color) {
+          output_color_components = 2;
+          png_output_color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+          converter = ConvertBGRAtoGrayAlpha;
+        } else {
+          output_color_components = 4;
+          png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+          converter = ConvertBetweenBGRAandRGBA;
+        }
       }
       break;
 
     case PNGCodec::FORMAT_SkBitmap:
       input_color_components = 4;
       if (discard_transparency) {
-        output_color_components = 3;
-        png_output_color_type = PNG_COLOR_TYPE_RGB;
-        converter = ConvertSkiatoRGB;
+        if (discard_color) {
+          output_color_components = 1;
+          png_output_color_type = PNG_COLOR_TYPE_GRAY;
+          converter = ConvertSkiatoGray;
+        } else {
+          output_color_components = 3;
+          png_output_color_type = PNG_COLOR_TYPE_RGB;
+          converter = ConvertSkiatoRGB;
+        }
       } else {
-        output_color_components = 4;
-        png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
-        converter = ConvertSkiatoRGBA;
+        if (discard_color) {
+          output_color_components = 2;
+          png_output_color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+          converter = ConvertSkiatoGrayAlpha;
+        } else {
+          output_color_components = 4;
+          png_output_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+          converter = ConvertSkiatoRGBA;
+        }

[sadrul, 2014/01/15 21:43:06]

I wonder if this could somehow be simplified, e.g.

  int input_color_component_map[] = {
    [FORMAT_RGB] = 3,
    [FORMAT_RGBA] = 4,
    ...
  };

  int output_color_component_map[] = {
    [PNG_COLOR_TYPE_RGB] = 3,
    [PNG_COLOR_TYPE_RGB_ALPHA] = 4,
    ...
  };

  FormatConverter converters[][FORMAT_SkBitmap + 1] = {
    [PNG_COLOR_TYPE_RGB] = { [FORMAT_RGBA] = ConvertRGBAtoRGB },
    [PNG_COLOR_TYPE_RGB_ALPHA] = { [FORMAT_BGRA] = ConvertBetweenBGRAandRGBA },
    ...
  };

then, the switch-case is used to figure out png_output_color_type, and the maps
above are used to get |input_color_components|, |output_color_components|, and
|converter|. Perhaps that makes the code even less readable.

       }
       break;
 
     default:
       NOTREACHED() << "Unknown pixel format";
       return false;
   }
 
   // Row stride should be at least as long as the length of the data.
   DCHECK(input_color_components * size.width() <= row_byte_width);
@@ skipping 20 matching lines @@
 }
 
 
 }  // namespace
 
 // static
 bool PNGCodec::Encode(const unsigned char* input, ColorFormat format,
                       const Size& size, int row_byte_width,
                       bool discard_transparency,
                       const std::vector<Comment>& comments,
-                      std::vector<unsigned char>* output) {
+                      std::vector<unsigned char>* output,
+                      bool discard_color) {
   return EncodeWithCompressionLevel(input,
                                     format,
                                     size,
                                     row_byte_width,
                                     discard_transparency,
+                                    discard_color,
                                     comments,
                                     Z_DEFAULT_COMPRESSION,
                                     output);
 }
 
 // static
 bool PNGCodec::EncodeBGRASkBitmap(const SkBitmap& input,
                                   bool discard_transparency,
-                                  std::vector<unsigned char>* output) {
+                                  std::vector<unsigned char>* output,
+                                  bool discard_color) {
   static const int bbp = 4;
 
   if (input.empty())
     return false;
   DCHECK_EQ(input.bytesPerPixel(), bbp);
   DCHECK_GE(static_cast<int>(input.rowBytes()), input.width() * bbp);
 
   SkAutoLockPixels lock_input(input);
   return Encode(reinterpret_cast<unsigned char*>(input.getAddr32(0, 0)),
                 FORMAT_SkBitmap, Size(input.width(), input.height()),
                 static_cast<int>(input.rowBytes()), discard_transparency,
-                std::vector<Comment>(), output);
+                std::vector<Comment>(), output, discard_color);
 }
 
 // static
 bool PNGCodec::FastEncodeBGRASkBitmap(const SkBitmap& input,
                                       bool discard_transparency,
-                                      std::vector<unsigned char>* output) {
+                                      std::vector<unsigned char>* output,
+                                      bool discard_color) {
   static const int bbp = 4;
 
   if (input.empty())
     return false;
   DCHECK_EQ(input.bytesPerPixel(), bbp);
   DCHECK_GE(static_cast<int>(input.rowBytes()), input.width() * bbp);
 
   SkAutoLockPixels lock_input(input);
   return EncodeWithCompressionLevel(
       reinterpret_cast<unsigned char*>(input.getAddr32(0, 0)),
       FORMAT_SkBitmap, Size(input.width(), input.height()),
       static_cast<int>(input.rowBytes()), discard_transparency,
-      std::vector<Comment>(), Z_BEST_SPEED, output);
+      discard_color, std::vector<Comment>(), Z_BEST_SPEED, output);
 }
 
 PNGCodec::Comment::Comment(const std::string& k, const std::string& t)
     : key(k), text(t) {
 }
 
 PNGCodec::Comment::~Comment() {
 }
 
 }  // namespace gfx