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