Add bitmap manipulation functions in advance of themes.

skia/ext/image_operations.cc

 // Copyright (c) 2006-2008 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.
 //
 #define _USE_MATH_DEFINES
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "skia/ext/image_operations.h"
 
 #include "base/gfx/rect.h"
 #include "base/gfx/size.h"
 #include "base/logging.h"
 #include "base/stack_container.h"
 #include "SkBitmap.h"
 #include "skia/ext/convolver.h"
+#include "skia/include/SkColorPriv.h"
+#include "skia/ext/skia_utils.h"
 
 namespace skia {
 
 // TODO(brettw) remove this and put this file in the skia namespace.
 using namespace gfx;
 
 namespace {
 
 // Returns the ceiling/floor as an integer.
 inline int CeilInt(float val) {
@@ skipping 228 matching lines @@
 
 // static
 SkBitmap ImageOperations::Resize(const SkBitmap& source,
                                  ResizeMethod method,
                                  int dest_width, int dest_height,
                                  const gfx::Rect& dest_subset) {
   DCHECK(gfx::Rect(dest_width, dest_height).Contains(dest_subset)) <<
       "The supplied subset does not fall within the destination image.";
 
   // If the size of source or destination is 0, i.e. 0x0, 0xN or Nx0, just
-  // return empty
+  // return empty.
   if (source.width() < 1 || source.height() < 1 ||
       dest_width < 1 || dest_height < 1)
     return SkBitmap();
 
   SkAutoLockPixels locker(source);
 
   ResizeFilter filter(method, source.width(), source.height(),
                       dest_width, dest_height, dest_subset);
 
   // Get a source bitmap encompassing this touched area. We construct the
@@ skipping 31 matching lines @@
                                               double alpha) {
   DCHECK(alpha <= 1 && alpha >= 0);
   DCHECK(first.width() == second.width());
   DCHECK(first.height() == second.height());
   DCHECK(first.bytesPerPixel() == second.bytesPerPixel());
   DCHECK(first.config() == SkBitmap::kARGB_8888_Config);
 
   // Optimize for case where we won't need to blend anything.
   static const double alpha_min = 1.0 / 255;
   static const double alpha_max = 254.0 / 255;
-  if (alpha < alpha_min) {
+  if (alpha < alpha_min)
     return first;
-  } else if (alpha > alpha_max) {
+  else if (alpha > alpha_max)
     return second;
-  }
 
   SkAutoLockPixels lock_first(first);
   SkAutoLockPixels lock_second(second);
 
   SkBitmap blended;
   blended.setConfig(SkBitmap::kARGB_8888_Config, first.width(),
                     first.height(), 0);
   blended.allocPixels();
   blended.eraseARGB(0, 0, 0, 0);
 
@@ skipping 21 matching lines @@
           SkColorGetB(first_pixel) * first_alpha +
           SkColorGetB(second_pixel) * alpha);
 
       dst_row[x] = SkColorSetARGB(a, r, g, b);
     }
   }
 
   return blended;
 }
 
+// static
+SkBitmap ImageOperations::CreateMaskedBitmap(const SkBitmap& rgb,
+                                             const SkBitmap& alpha) {
+  DCHECK(rgb.width() == alpha.width());
+  DCHECK(rgb.height() == alpha.height());
+  DCHECK(rgb.bytesPerPixel() == alpha.bytesPerPixel());
+  DCHECK(rgb.config() == SkBitmap::kARGB_8888_Config);
+  DCHECK(alpha.config() == SkBitmap::kARGB_8888_Config);
+
+  SkBitmap masked;
+  masked.setConfig(SkBitmap::kARGB_8888_Config, rgb.width(), rgb.height(), 0);
+  masked.allocPixels();
+  masked.eraseARGB(0, 0, 0, 0);
+
+  SkAutoLockPixels lock_rgb(rgb);
+  SkAutoLockPixels lock_alpha(alpha);
+  SkAutoLockPixels lock_masked(masked);
+
+  for (int y = 0; y < rgb.height(); y++) {
+    uint32* rgb_row = rgb.getAddr32(0, y);
+    uint32* alpha_row = alpha.getAddr32(0, y);
+    uint32* dst_row = masked.getAddr32(0, y);
+
+    for (int x = 0; x < rgb.width(); x++) {
+      uint32 alpha_pixel = alpha_row[x];
+      uint32 rgb_pixel = rgb_row[x];
+
+      int alpha = SkColorGetA(alpha_pixel);
+      dst_row[x] = SkColorSetARGB(alpha,
+                                  SkAlphaMul(SkColorGetR(rgb_pixel), alpha),
+                                  SkAlphaMul(SkColorGetG(rgb_pixel), alpha),
+                                  SkAlphaMul(SkColorGetB(rgb_pixel), alpha));
+    }
+  }
+
+  return masked;
+}
+
+SkBitmap ImageOperations::CreateBlurredBitmap(const SkBitmap& bitmap,
+                                              int blur_amount ) {
+  DCHECK(bitmap.config() == SkBitmap::kARGB_8888_Config);
+
+  // Blur factor (1 divided by how many pixels the blur takes place over).
+  double v = 1.0 / pow(static_cast<double>(blur_amount * 2 + 1), 2);
+
+  SkBitmap blurred;
+  blurred.setConfig(SkBitmap::kARGB_8888_Config, bitmap.width(),
+                    bitmap.height(), 0);
+  blurred.allocPixels();
+  blurred.eraseARGB(0, 0, 0, 0);
+
+  SkAutoLockPixels lock_bitmap(bitmap);
+  SkAutoLockPixels lock_blurred(blurred);
+
+  // Loop through every pixel in the image.
+  for (int y = 0; y < bitmap.height(); y++) {  // Skip top and bottom edges.
+    uint32* dst_row = blurred.getAddr32(0, y);
+
+    for (int x = 0; x < bitmap.width(); x++) {  // Skip left and right edges.
+      // Sums for this pixel.
+      double a = 0;
+      double r = 0;
+      double g = 0;
+      double b = 0;
+
+      for (int ky = -blur_amount; ky <= blur_amount; ky++) {
+        for (int kx = -blur_amount; kx <= blur_amount; kx++) {
+          // Calculate the adjacent pixel for this kernel point. Blurs
+          // are wrapped.
+          int bx = (x + kx) % bitmap.width();
+          while (bx < 0)
+            bx += bitmap.width();
+          int by = (y + ky) % bitmap.height();
+          while (by < 0)
+            by += bitmap.height();
+
+          uint32 src_pixel = bitmap.getAddr32(0, by)[bx];
+
+          a += v * static_cast<double>(SkColorGetA(src_pixel));
+          r += v * static_cast<double>(SkColorGetR(src_pixel));
+          g += v * static_cast<double>(SkColorGetG(src_pixel));
+          b += v * static_cast<double>(SkColorGetB(src_pixel));
+        }
+      }
+
+      dst_row[x] = SkColorSetARGB(
+          static_cast<int>(a),
+          static_cast<int>(r),
+          static_cast<int>(g),
+          static_cast<int>(b));
+    }
+  }
+
+  return blurred;
+}
+
+// static
+SkBitmap ImageOperations::CreateHSLShiftedBitmap(const SkBitmap& bitmap,
+                                                 float hsl_shift[3]) {
+  DCHECK(bitmap.config() == SkBitmap::kARGB_8888_Config);
+
+  SkBitmap shifted;
+  shifted.setConfig(SkBitmap::kARGB_8888_Config, bitmap.width(),
+                    bitmap.height(), 0);
+  shifted.allocPixels();
+  shifted.eraseARGB(0, 0, 0, 0);
+  shifted.setIsOpaque(false);
+
+  SkAutoLockPixels lock_bitmap(bitmap);
+  SkAutoLockPixels lock_shifted(shifted);
+
+  // Loop through the pixels of the original bitmap.
+  for (int y = 0; y < bitmap.height(); y++) {
+    SkColor* pixels = bitmap.getAddr32(0, y);
+    SkColor* tinted_pixels = shifted.getAddr32(0, y);
+
+    for (int x = 0; x < bitmap.width(); x++) {
+      // Convert the color of this pixel to HSL.
+      SkColor color = pixels[x];
+      int alpha = SkColorGetA(color);
+      if (alpha != 255) {
+        // We have to normalize the colors as they're pre-multiplied.
+        double r = SkColorGetR(color) / static_cast<double>(alpha);
+        double g = SkColorGetG(color) / static_cast<double>(alpha);
+        double b = SkColorGetB(color) / static_cast<double>(alpha);
+        color = SkColorSetARGB(255,
+                               static_cast<int>(r * 255.0),
+                               static_cast<int>(g * 255.0),
+                               static_cast<int>(b * 255.0));
+      }
+
+      float pixel_hsl[3];
+      SkColorToHSL(color, pixel_hsl);
+
+      // Replace the hue with the tint's hue.
+      if (hsl_shift[0] >= 0)
+        pixel_hsl[0] = hsl_shift[0];
+
+      // Change the saturation.
+      if (hsl_shift[1] >= 0) {
+        if (hsl_shift[1] <= 0.5) {
+          pixel_hsl[1] *= hsl_shift[1] * 2.0;
+        } else {
+          pixel_hsl[1] = pixel_hsl[1] + (1.0 - pixel_hsl[1]) *
+              ((hsl_shift[1] - 0.5) * 2.0);
+        }
+      }
+
+      // Change the lightness.
+      if (hsl_shift[2] >= 0) {
+        if (hsl_shift[2] <= 0.5) {
+          pixel_hsl[2] *= hsl_shift[2] * 2.0;
+        } else {
+          pixel_hsl[2] = pixel_hsl[2] + (1.0 - pixel_hsl[2]) *
+              ((hsl_shift[2] - 0.5) * 2.0);
+        }
+      }
+
+      // Convert back to RGB.
+      tinted_pixels[x] = HSLToSKColor(alpha, pixel_hsl);
+    }
+  }
+
+  return shifted;
+}
+
+// static
+SkBitmap ImageOperations::CreateTiledBitmap(const SkBitmap& source,

[brettw, 2009/04/28 02:49:43]

FWIW this could have been done by making a tiled bitmap shader and just drawing
the bitmap to the canvas using Skia. But your approach is fine.

+                                            int src_x, int src_y,
+                                            int dst_w, int dst_h) {
+  DCHECK(source.getConfig() == SkBitmap::kARGB_8888_Config);
+
+  SkBitmap cropped;
+  cropped.setConfig(SkBitmap::kARGB_8888_Config, dst_w, dst_h, 0);
+  cropped.allocPixels();
+  cropped.eraseARGB(0, 0, 0, 0);
+
+  SkAutoLockPixels lock_source(source);
+  SkAutoLockPixels lock_cropped(cropped);
+
+  // Loop through the pixels of the original bitmap.
+  for (int y = 0; y < dst_h; y++) {
+    int y_pix = (src_y + y) % source.height();
+    while (y_pix < 0)
+      y_pix += source.height();
+
+    uint32* source_row = source.getAddr32(0, y_pix);
+    uint32* dst_row = cropped.getAddr32(0, y);
+
+    for (int x = 0; x < dst_w; x++) {
+      int x_pix = (src_x + x) % source.width();
+      while (x_pix < 0)
+        x_pix += source.width();
+
+      dst_row[x] = source_row[x_pix];
+    }
+  }
+
+  return cropped;
+}
+
 }  // namespace skia