ui/gfx/image/image_skia_operations.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/image/image_skia_operations.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/logging.h"
   9 #include "skia/ext/image_operations.h"
  10 #include "ui/gfx/canvas.h"
  11 #include "ui/gfx/image/canvas_image_source.h"
  12 #include "ui/gfx/image/image_skia.h"
  13 #include "ui/gfx/image/image_skia_rep.h"
  14 #include "ui/gfx/image/image_skia_source.h"
  15 #include "ui/gfx/insets.h"
  16 #include "ui/gfx/point.h"
  17 #include "ui/gfx/point_conversions.h"
  18 #include "ui/gfx/rect.h"
  19 #include "ui/gfx/rect_conversions.h"
  20 #include "ui/gfx/size.h"
  21 #include "ui/gfx/size_conversions.h"
  22 #include "ui/gfx/skbitmap_operations.h"
  23 #include "ui/gfx/skia_util.h"
  24
  25 namespace gfx {
  26 namespace {
  27
  28 gfx::Size DIPToPixelSize(gfx::Size dip_size, float scale) {
  29   return ToCeiledSize(ScaleSize(dip_size, scale));
  30 }
  31
  32 gfx::Rect DIPToPixelBounds(gfx::Rect dip_bounds, float scale) {
  33   return gfx::Rect(ToFlooredPoint(ScalePoint(dip_bounds.origin(), scale)),
  34                    DIPToPixelSize(dip_bounds.size(), scale));
  35 }
  36
  37 // Returns an image rep for the ImageSkiaSource to return to visually indicate
  38 // an error.
  39 ImageSkiaRep GetErrorImageRep(float scale, const gfx::Size& pixel_size) {
  40   SkBitmap bitmap;
  41   bitmap.allocN32Pixels(pixel_size.width(), pixel_size.height());
  42   bitmap.eraseColor(SK_ColorRED);
  43   return gfx::ImageSkiaRep(bitmap, scale);
  44 }
  45
  46 // A base image source class that creates an image from two source images.
  47 // This class guarantees that two ImageSkiaReps have have the same pixel size.
  48 class BinaryImageSource : public gfx::ImageSkiaSource {
  49  protected:
  50   BinaryImageSource(const ImageSkia& first,
  51                     const ImageSkia& second,
  52                     const char* source_name)
  53       : first_(first),
  54         second_(second),
  55         source_name_(source_name) {
  56   }
  57   virtual ~BinaryImageSource() {
  58   }
  59
  60   // gfx::ImageSkiaSource overrides:
  61   virtual ImageSkiaRep GetImageForScale(float scale) override {
  62     ImageSkiaRep first_rep = first_.GetRepresentation(scale);
  63     ImageSkiaRep second_rep = second_.GetRepresentation(scale);
  64     if (first_rep.pixel_size() != second_rep.pixel_size()) {
  65       DCHECK_NE(first_rep.scale(), second_rep.scale());
  66       if (first_rep.scale() == second_rep.scale()) {
  67         LOG(ERROR) << "ImageSkiaRep size mismatch in " << source_name_;
  68         return GetErrorImageRep(first_rep.scale(),first_rep.pixel_size());
  69       }
  70       first_rep = first_.GetRepresentation(1.0f);
  71       second_rep = second_.GetRepresentation(1.0f);
  72       DCHECK_EQ(first_rep.pixel_width(), second_rep.pixel_width());
  73       DCHECK_EQ(first_rep.pixel_height(), second_rep.pixel_height());
  74       if (first_rep.pixel_size() != second_rep.pixel_size()) {
  75         LOG(ERROR) << "ImageSkiaRep size mismatch in " << source_name_;
  76         return GetErrorImageRep(first_rep.scale(), first_rep.pixel_size());
  77       }
  78     } else {
  79       DCHECK_EQ(first_rep.scale(), second_rep.scale());
  80     }
  81     return CreateImageSkiaRep(first_rep, second_rep);
  82   }
  83
  84   // Creates a final image from two ImageSkiaReps. The pixel size of
  85   // the two images are guaranteed to be the same.
  86   virtual ImageSkiaRep CreateImageSkiaRep(
  87       const ImageSkiaRep& first_rep,
  88       const ImageSkiaRep& second_rep) const = 0;
  89
  90  private:
  91   const ImageSkia first_;
  92   const ImageSkia second_;
  93   // The name of a class that implements the BinaryImageSource.
  94   // The subclass is responsible for managing the memory.
  95   const char* source_name_;
  96
  97   DISALLOW_COPY_AND_ASSIGN(BinaryImageSource);
  98 };
  99
 100 class BlendingImageSource : public BinaryImageSource {
 101  public:
 102   BlendingImageSource(const ImageSkia& first,
 103                       const ImageSkia& second,
 104                       double alpha)
 105       : BinaryImageSource(first, second, "BlendingImageSource"),
 106         alpha_(alpha) {
 107   }
 108
 109   virtual ~BlendingImageSource() {
 110   }
 111
 112   // BinaryImageSource overrides:
 113   virtual ImageSkiaRep CreateImageSkiaRep(
 114       const ImageSkiaRep& first_rep,
 115       const ImageSkiaRep& second_rep) const override {
 116     SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
 117         first_rep.sk_bitmap(), second_rep.sk_bitmap(), alpha_);
 118     return ImageSkiaRep(blended, first_rep.scale());
 119   }
 120
 121  private:
 122   double alpha_;
 123
 124   DISALLOW_COPY_AND_ASSIGN(BlendingImageSource);
 125 };
 126
 127 class SuperimposedImageSource : public gfx::CanvasImageSource {
 128  public:
 129   SuperimposedImageSource(const ImageSkia& first,
 130                           const ImageSkia& second)
 131       : gfx::CanvasImageSource(first.size(), false /* is opaque */),
 132         first_(first),
 133         second_(second) {
 134   }
 135
 136   virtual ~SuperimposedImageSource() {}
 137
 138   // gfx::CanvasImageSource override.
 139   virtual void Draw(Canvas* canvas) override {
 140     canvas->DrawImageInt(first_, 0, 0);
 141     canvas->DrawImageInt(second_,
 142                          (first_.width() - second_.width()) / 2,
 143                          (first_.height() - second_.height()) / 2);
 144   }
 145
 146  private:
 147   const ImageSkia first_;
 148   const ImageSkia second_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(SuperimposedImageSource);
 151 };
 152
 153 class TransparentImageSource : public gfx::ImageSkiaSource {
 154  public:
 155   TransparentImageSource(const ImageSkia& image, double alpha)
 156       : image_(image),
 157         alpha_(alpha) {
 158   }
 159
 160   virtual ~TransparentImageSource() {}
 161
 162  private:
 163   // gfx::ImageSkiaSource overrides:
 164   virtual ImageSkiaRep GetImageForScale(float scale) override {
 165     ImageSkiaRep image_rep = image_.GetRepresentation(scale);
 166     SkBitmap alpha;
 167     alpha.allocN32Pixels(image_rep.pixel_width(),
 168                          image_rep.pixel_height());
 169     alpha.eraseColor(SkColorSetARGB(alpha_ * 255, 0, 0, 0));
 170     return ImageSkiaRep(
 171         SkBitmapOperations::CreateMaskedBitmap(image_rep.sk_bitmap(), alpha),
 172         image_rep.scale());
 173   }
 174
 175   ImageSkia image_;
 176   double alpha_;
 177
 178   DISALLOW_COPY_AND_ASSIGN(TransparentImageSource);
 179 };
 180
 181 class MaskedImageSource : public BinaryImageSource {
 182  public:
 183   MaskedImageSource(const ImageSkia& rgb, const ImageSkia& alpha)
 184       : BinaryImageSource(rgb, alpha, "MaskedImageSource") {
 185   }
 186
 187   virtual ~MaskedImageSource() {
 188   }
 189
 190   // BinaryImageSource overrides:
 191   virtual ImageSkiaRep CreateImageSkiaRep(
 192       const ImageSkiaRep& first_rep,
 193       const ImageSkiaRep& second_rep) const override {
 194     return ImageSkiaRep(SkBitmapOperations::CreateMaskedBitmap(
 195         first_rep.sk_bitmap(), second_rep.sk_bitmap()),
 196                         first_rep.scale());
 197   }
 198
 199  private:
 200   DISALLOW_COPY_AND_ASSIGN(MaskedImageSource);
 201 };
 202
 203 class TiledImageSource : public gfx::ImageSkiaSource {
 204  public:
 205   TiledImageSource(const ImageSkia& source,
 206                    int src_x, int src_y,
 207                    int dst_w, int dst_h)
 208       : source_(source),
 209         src_x_(src_x),
 210         src_y_(src_y),
 211         dst_w_(dst_w),
 212         dst_h_(dst_h) {
 213   }
 214
 215   virtual ~TiledImageSource() {
 216   }
 217
 218   // gfx::ImageSkiaSource overrides:
 219   virtual ImageSkiaRep GetImageForScale(float scale) override {
 220     ImageSkiaRep source_rep = source_.GetRepresentation(scale);
 221     gfx::Rect bounds = DIPToPixelBounds(gfx::Rect(src_x_, src_y_, dst_w_,
 222                                                   dst_h_), source_rep.scale());
 223     return ImageSkiaRep(
 224         SkBitmapOperations::CreateTiledBitmap(
 225             source_rep.sk_bitmap(),
 226             bounds.x(), bounds.y(), bounds.width(), bounds.height()),
 227         source_rep.scale());
 228   }
 229
 230  private:
 231   const ImageSkia source_;
 232   const int src_x_;
 233   const int src_y_;
 234   const int dst_w_;
 235   const int dst_h_;
 236
 237   DISALLOW_COPY_AND_ASSIGN(TiledImageSource);
 238 };
 239
 240 class HSLImageSource : public gfx::ImageSkiaSource {
 241  public:
 242   HSLImageSource(const ImageSkia& image,
 243                  const color_utils::HSL& hsl_shift)
 244       : image_(image),
 245         hsl_shift_(hsl_shift) {
 246   }
 247
 248   virtual ~HSLImageSource() {
 249   }
 250
 251   // gfx::ImageSkiaSource overrides:
 252   virtual ImageSkiaRep GetImageForScale(float scale) override {
 253     ImageSkiaRep image_rep = image_.GetRepresentation(scale);
 254     return gfx::ImageSkiaRep(
 255         SkBitmapOperations::CreateHSLShiftedBitmap(image_rep.sk_bitmap(),
 256             hsl_shift_), image_rep.scale());
 257   }
 258
 259  private:
 260   const gfx::ImageSkia image_;
 261   const color_utils::HSL hsl_shift_;
 262   DISALLOW_COPY_AND_ASSIGN(HSLImageSource);
 263 };
 264
 265 // ImageSkiaSource which uses SkBitmapOperations::CreateButtonBackground
 266 // to generate image reps for the target image.  The image and mask can be
 267 // diferent sizes (crbug.com/171725).
 268 class ButtonImageSource: public gfx::ImageSkiaSource {
 269  public:
 270   ButtonImageSource(SkColor color,
 271                     const ImageSkia& image,
 272                     const ImageSkia& mask)
 273       : color_(color),
 274         image_(image),
 275         mask_(mask) {
 276   }
 277
 278   virtual ~ButtonImageSource() {
 279   }
 280
 281   // gfx::ImageSkiaSource overrides:
 282   virtual ImageSkiaRep GetImageForScale(float scale) override {
 283     ImageSkiaRep image_rep = image_.GetRepresentation(scale);
 284     ImageSkiaRep mask_rep = mask_.GetRepresentation(scale);
 285     if (image_rep.scale() != mask_rep.scale()) {
 286       image_rep = image_.GetRepresentation(1.0f);
 287       mask_rep = mask_.GetRepresentation(1.0f);
 288     }
 289     return gfx::ImageSkiaRep(
 290         SkBitmapOperations::CreateButtonBackground(color_,
 291               image_rep.sk_bitmap(), mask_rep.sk_bitmap()),
 292           image_rep.scale());
 293   }
 294
 295  private:
 296   const SkColor color_;
 297   const ImageSkia image_;
 298   const ImageSkia mask_;
 299
 300   DISALLOW_COPY_AND_ASSIGN(ButtonImageSource);
 301 };
 302
 303 // ImageSkiaSource which uses SkBitmap::extractSubset to generate image reps
 304 // for the target image.
 305 class ExtractSubsetImageSource: public gfx::ImageSkiaSource {
 306  public:
 307   ExtractSubsetImageSource(const gfx::ImageSkia& image,
 308                            const gfx::Rect& subset_bounds)
 309       : image_(image),
 310         subset_bounds_(subset_bounds) {
 311   }
 312
 313   virtual ~ExtractSubsetImageSource() {
 314   }
 315
 316   // gfx::ImageSkiaSource overrides:
 317   virtual ImageSkiaRep GetImageForScale(float scale) override {
 318     ImageSkiaRep image_rep = image_.GetRepresentation(scale);
 319     SkIRect subset_bounds_in_pixel = RectToSkIRect(
 320         DIPToPixelBounds(subset_bounds_, image_rep.scale()));
 321     SkBitmap dst;
 322     bool success = image_rep.sk_bitmap().extractSubset(&dst,
 323                                                        subset_bounds_in_pixel);
 324     DCHECK(success);
 325     return gfx::ImageSkiaRep(dst, image_rep.scale());
 326   }
 327
 328  private:
 329   const gfx::ImageSkia image_;
 330   const gfx::Rect subset_bounds_;
 331
 332   DISALLOW_COPY_AND_ASSIGN(ExtractSubsetImageSource);
 333 };
 334
 335 // ResizeSource resizes relevant image reps in |source| to |target_dip_size|
 336 // for requested scale factors.
 337 class ResizeSource : public ImageSkiaSource {
 338  public:
 339   ResizeSource(const ImageSkia& source,
 340                skia::ImageOperations::ResizeMethod method,
 341                const Size& target_dip_size)
 342       : source_(source),
 343         resize_method_(method),
 344         target_dip_size_(target_dip_size) {
 345   }
 346   virtual ~ResizeSource() {}
 347
 348   // gfx::ImageSkiaSource overrides:
 349   virtual ImageSkiaRep GetImageForScale(float scale) override {
 350     const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
 351     if (image_rep.GetWidth() == target_dip_size_.width() &&
 352         image_rep.GetHeight() == target_dip_size_.height())
 353       return image_rep;
 354
 355     const Size target_pixel_size = DIPToPixelSize(target_dip_size_, scale);
 356     const SkBitmap resized = skia::ImageOperations::Resize(
 357         image_rep.sk_bitmap(),
 358         resize_method_,
 359         target_pixel_size.width(),
 360         target_pixel_size.height());
 361     return ImageSkiaRep(resized, scale);
 362   }
 363
 364  private:
 365   const ImageSkia source_;
 366   skia::ImageOperations::ResizeMethod resize_method_;
 367   const Size target_dip_size_;
 368
 369   DISALLOW_COPY_AND_ASSIGN(ResizeSource);
 370 };
 371
 372 // DropShadowSource generates image reps with drop shadow for image reps in
 373 // |source| that represent requested scale factors.
 374 class DropShadowSource : public ImageSkiaSource {
 375  public:
 376   DropShadowSource(const ImageSkia& source,
 377                    const ShadowValues& shadows_in_dip)
 378       : source_(source),
 379         shaodws_in_dip_(shadows_in_dip) {
 380   }
 381   virtual ~DropShadowSource() {}
 382
 383   // gfx::ImageSkiaSource overrides:
 384   virtual ImageSkiaRep GetImageForScale(float scale) override {
 385     const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
 386
 387     ShadowValues shadows_in_pixel;
 388     for (size_t i = 0; i < shaodws_in_dip_.size(); ++i)
 389       shadows_in_pixel.push_back(shaodws_in_dip_[i].Scale(scale));
 390
 391     const SkBitmap shadow_bitmap = SkBitmapOperations::CreateDropShadow(
 392         image_rep.sk_bitmap(),
 393         shadows_in_pixel);
 394     return ImageSkiaRep(shadow_bitmap, image_rep.scale());
 395   }
 396
 397  private:
 398   const ImageSkia source_;
 399   const ShadowValues shaodws_in_dip_;
 400
 401   DISALLOW_COPY_AND_ASSIGN(DropShadowSource);
 402 };
 403
 404 // RotatedSource generates image reps that are rotations of those in
 405 // |source| that represent requested scale factors.
 406 class RotatedSource : public ImageSkiaSource {
 407  public:
 408   RotatedSource(const ImageSkia& source,
 409                 SkBitmapOperations::RotationAmount rotation)
 410     : source_(source),
 411       rotation_(rotation) {
 412   }
 413   virtual ~RotatedSource() {}
 414
 415   // gfx::ImageSkiaSource overrides:
 416   virtual ImageSkiaRep GetImageForScale(float scale) override {
 417     const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
 418     const SkBitmap rotated_bitmap =
 419         SkBitmapOperations::Rotate(image_rep.sk_bitmap(), rotation_);
 420     return ImageSkiaRep(rotated_bitmap, image_rep.scale());
 421   }
 422
 423  private:
 424   const ImageSkia source_;
 425   const SkBitmapOperations::RotationAmount rotation_;
 426
 427   DISALLOW_COPY_AND_ASSIGN(RotatedSource);
 428 };
 429
 430
 431 }  // namespace
 432
 433 // static
 434 ImageSkia ImageSkiaOperations::CreateBlendedImage(const ImageSkia& first,
 435                                                   const ImageSkia& second,
 436                                                   double alpha) {
 437   if (first.isNull() || second.isNull())
 438     return ImageSkia();
 439
 440   return ImageSkia(new BlendingImageSource(first, second, alpha), first.size());
 441 }
 442
 443 // static
 444 ImageSkia ImageSkiaOperations::CreateSuperimposedImage(
 445     const ImageSkia& first,
 446     const ImageSkia& second) {
 447   if (first.isNull() || second.isNull())
 448     return ImageSkia();
 449
 450   return ImageSkia(new SuperimposedImageSource(first, second), first.size());
 451 }
 452
 453 // static
 454 ImageSkia ImageSkiaOperations::CreateTransparentImage(const ImageSkia& image,
 455                                                       double alpha) {
 456   if (image.isNull())
 457     return ImageSkia();
 458
 459   return ImageSkia(new TransparentImageSource(image, alpha), image.size());
 460 }
 461
 462 // static
 463 ImageSkia ImageSkiaOperations::CreateMaskedImage(const ImageSkia& rgb,
 464                                                  const ImageSkia& alpha) {
 465   if (rgb.isNull() || alpha.isNull())
 466     return ImageSkia();
 467
 468   return ImageSkia(new MaskedImageSource(rgb, alpha), rgb.size());
 469 }
 470
 471 // static
 472 ImageSkia ImageSkiaOperations::CreateTiledImage(const ImageSkia& source,
 473                                                 int src_x, int src_y,
 474                                                 int dst_w, int dst_h) {
 475   if (source.isNull())
 476     return ImageSkia();
 477
 478   return ImageSkia(new TiledImageSource(source, src_x, src_y, dst_w, dst_h),
 479                    gfx::Size(dst_w, dst_h));
 480 }
 481
 482 // static
 483 ImageSkia ImageSkiaOperations::CreateHSLShiftedImage(
 484     const ImageSkia& image,
 485     const color_utils::HSL& hsl_shift) {
 486   if (image.isNull())
 487     return ImageSkia();
 488
 489   return ImageSkia(new HSLImageSource(image, hsl_shift), image.size());
 490 }
 491
 492 // static
 493 ImageSkia ImageSkiaOperations::CreateButtonBackground(SkColor color,
 494                                                       const ImageSkia& image,
 495                                                       const ImageSkia& mask) {
 496   if (image.isNull() || mask.isNull())
 497     return ImageSkia();
 498
 499   return ImageSkia(new ButtonImageSource(color, image, mask), mask.size());
 500 }
 501
 502 // static
 503 ImageSkia ImageSkiaOperations::ExtractSubset(const ImageSkia& image,
 504                                              const Rect& subset_bounds) {
 505   gfx::Rect clipped_bounds =
 506       gfx::IntersectRects(subset_bounds, gfx::Rect(image.size()));
 507   if (image.isNull() || clipped_bounds.IsEmpty()) {
 508     return ImageSkia();
 509   }
 510
 511   return ImageSkia(new ExtractSubsetImageSource(image, clipped_bounds),
 512                    clipped_bounds.size());
 513 }
 514
 515 // static
 516 ImageSkia ImageSkiaOperations::CreateResizedImage(
 517     const ImageSkia& source,
 518     skia::ImageOperations::ResizeMethod method,
 519     const Size& target_dip_size) {
 520   if (source.isNull())
 521     return ImageSkia();
 522
 523   return ImageSkia(new ResizeSource(source, method, target_dip_size),
 524                    target_dip_size);
 525 }
 526
 527 // static
 528 ImageSkia ImageSkiaOperations::CreateImageWithDropShadow(
 529     const ImageSkia& source,
 530     const ShadowValues& shadows) {
 531   if (source.isNull())
 532     return ImageSkia();
 533
 534   const gfx::Insets shadow_padding = -gfx::ShadowValue::GetMargin(shadows);
 535   gfx::Size shadow_image_size = source.size();
 536   shadow_image_size.Enlarge(shadow_padding.width(),
 537                             shadow_padding.height());
 538   return ImageSkia(new DropShadowSource(source, shadows), shadow_image_size);
 539 }
 540
 541 // static
 542 ImageSkia ImageSkiaOperations::CreateRotatedImage(
 543       const ImageSkia& source,
 544       SkBitmapOperations::RotationAmount rotation) {
 545   if (source.isNull())
 546     return ImageSkia();
 547
 548   return ImageSkia(new RotatedSource(source, rotation),
 549       SkBitmapOperations::ROTATION_180_CW == rotation ?
 550           source.size() :
 551           gfx::Size(source.height(), source.width()));
 552
 553 }
 554
 555 }  // namespace gfx