ui/gfx: optimize UnPreMultiply operation by checking alpha value

ui/gfx/color_analysis.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/color_analysis.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.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 "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/color_utils.h"
 
 namespace color_utils {
 namespace {
 
 // RGBA KMean Constants
 const uint32_t kNumberOfClusters = 4;
 const int kNumberOfIterations = 50;
@@ skipping 98 matching lines @@
   // Holds the sum of all the points that make up this cluster. Used to
   // generate the next centroid as well as to check for convergence.
   uint32_t aggregate[3];
   uint32_t counter;
 
   // The weight of the cluster, determined by how many points were used
   // to generate the previous centroid.
   uint32_t weight;
 };
 
-// Un-premultiplies each pixel in |bitmap| into an output |buffer|. Requires
-// approximately 10 microseconds for a 16x16 icon on an Intel Core i5.
+// Un-premultiplies each pixel in |bitmap| into an output |buffer|.
 void UnPreMultiply(const SkBitmap& bitmap, uint32_t* buffer, int buffer_size) {
   SkAutoLockPixels auto_lock(bitmap);
   uint32_t* in = static_cast<uint32_t*>(bitmap.getPixels());
   uint32_t* out = buffer;
   int pixel_count = std::min(bitmap.width() * bitmap.height(), buffer_size);
-  for (int i = 0; i < pixel_count; ++i)
-    *out++ = SkUnPreMultiply::PMColorToColor(*in++);
+  for (int i = 0; i < pixel_count; ++i) {
+    int alpha = SkGetPackedA32(*in);
+    if (alpha != 0 && alpha != 255)
+      *out++ = SkUnPreMultiply::PMColorToColor(*in++);
+    else
+      *out++ = *in++;
+  }
 }
 
 } // namespace
 
 KMeanImageSampler::KMeanImageSampler() {
 }
 
 KMeanImageSampler::~KMeanImageSampler() {
 }
 
@@ skipping 276 matching lines @@
   int64_t rr_sum = 0;
   int64_t gg_sum = 0;
   int64_t bb_sum = 0;
   int64_t rg_sum = 0;
   int64_t rb_sum = 0;
   int64_t gb_sum = 0;
 
   for (int y = 0; y < bitmap.height(); ++y) {
     SkPMColor* current_color = static_cast<uint32_t*>(bitmap.getAddr32(0, y));
     for (int x = 0; x < bitmap.width(); ++x, ++current_color) {
-      SkColor c = SkUnPreMultiply::PMColorToColor(*current_color);
+      SkColor c;
+      int alpha = SkGetPackedA32(*current_color);
+      if (alpha != 0 && alpha != 255)
+        c = SkUnPreMultiply::PMColorToColor(*current_color);
+      else
+        c = *current_color;
+
       SkColor r = SkColorGetR(c);
       SkColor g = SkColorGetG(c);
       SkColor b = SkColorGetB(c);
 
       r_sum += r;
       g_sum += g;
       b_sum += b;
       rr_sum += r * r;
       gg_sum += g * g;
       bb_sum += b * b;
@@ skipping 56 matching lines @@
 
   if (fit_to_range) {
     // We will figure out min/max in a preprocessing step and adjust
     // actual_transform as required.
     float max_val = std::numeric_limits<float>::min();
     float min_val = std::numeric_limits<float>::max();
     for (int y = 0; y < source_bitmap.height(); ++y) {
       const SkPMColor* source_color_row = static_cast<SkPMColor*>(
           source_bitmap.getAddr32(0, y));
       for (int x = 0; x < source_bitmap.width(); ++x) {
-        SkColor c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
+        SkColor c;
+        int alpha = SkGetPackedA32(source_color_row[x]);
+        if (alpha != 0 && alpha != 255)
+          c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
+        else
+          c = source_color_row[x];
+
         float r = SkColorGetR(c);
         float g = SkColorGetG(c);
         float b = SkColorGetB(c);
         float gray_level = tr * r + tg * g + tb * b;
         max_val = std::max(max_val, gray_level);
         min_val = std::min(min_val, gray_level);
       }
     }
 
     // Adjust the transform so that the result is scaling.
     float scale = 0.0;
     t0 = -min_val;
     if (max_val > min_val)
       scale = 255.0 / (max_val - min_val);
     t0 *= scale;
     tr *= scale;
     tg *= scale;
     tb *= scale;
   }
 
   for (int y = 0; y < source_bitmap.height(); ++y) {
     const SkPMColor* source_color_row = static_cast<SkPMColor*>(
         source_bitmap.getAddr32(0, y));
     uint8_t* target_color_row = target_bitmap->getAddr8(0, y);
     for (int x = 0; x < source_bitmap.width(); ++x) {
-      SkColor c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
+      SkColor c;
+      int alpha = SkGetPackedA32(source_color_row[x]);
+      if (alpha != 0 && alpha != 255)
+        c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
+      else
+        c = source_color_row[x];
+
       float r = SkColorGetR(c);
       float g = SkColorGetG(c);
       float b = SkColorGetB(c);
 
       float gl = t0 + tr * r + tg * g + tb * b;
       if (gl < 0)
         gl = 0;
       if (gl > 0xFF)
         gl = 0xFF;
       target_color_row[x] = static_cast<uint8_t>(gl);
@@ skipping 13 matching lines @@
   gfx::Matrix3F covariance = ComputeColorCovariance(source_bitmap);
   gfx::Matrix3F eigenvectors = gfx::Matrix3F::Zeros();
   gfx::Vector3dF eigenvals = covariance.SolveEigenproblem(&eigenvectors);
   gfx::Vector3dF principal = eigenvectors.get_column(0);
   if (eigenvals == gfx::Vector3dF() || principal == gfx::Vector3dF())
     return false;  // This may happen for some edge cases.
   return ApplyColorReduction(source_bitmap, principal, true, target_bitmap);
 }
 
 }  // color_utils