skia/ext/skia_utils_mac.mm

   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 "skia/ext/skia_utils_mac.h"
   6
   7 #import <AppKit/AppKit.h>
   8
   9 #include "base/logging.h"
  10 #include "base/mac/scoped_cftyperef.h"
  11 #include "base/mac/scoped_nsobject.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "skia/ext/bitmap_platform_device_mac.h"
  14 #include "third_party/skia/include/core/SkRegion.h"
  15 #include "third_party/skia/include/utils/mac/SkCGUtils.h"
  16
  17 namespace {
  18
  19 // Draws an NSImage or an NSImageRep with a given size into a SkBitmap.
  20 SkBitmap NSImageOrNSImageRepToSkBitmapWithColorSpace(
  21     NSImage* image,
  22     NSImageRep* image_rep,
  23     NSSize size,
  24     bool is_opaque,
  25     CGColorSpaceRef color_space) {
  26   // Only image or image_rep should be provided, not both.
  27   DCHECK((image != 0) ^ (image_rep != 0));
  28
  29   SkBitmap bitmap;
  30   if (!bitmap.allocN32Pixels(size.width, size.height, is_opaque))
  31     return bitmap;  // Return |bitmap| which should respond true to isNull().
  32
  33
  34   void* data = bitmap.getPixels();
  35
  36   // Allocate a bitmap context with 4 components per pixel (BGRA). Apple
  37   // recommends these flags for improved CG performance.
  38 #define HAS_ARGB_SHIFTS(a, r, g, b) \
  39             (SK_A32_SHIFT == (a) && SK_R32_SHIFT == (r) \
  40              && SK_G32_SHIFT == (g) && SK_B32_SHIFT == (b))
  41 #if defined(SK_CPU_LENDIAN) && HAS_ARGB_SHIFTS(24, 16, 8, 0)
  42   base::ScopedCFTypeRef<CGContextRef> context(CGBitmapContextCreate(
  43       data,
  44       size.width,
  45       size.height,
  46       8,
  47       size.width * 4,
  48       color_space,
  49       kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
  50 #else
  51 #error We require that Skia's and CoreGraphics's recommended \
  52        image memory layout match.
  53 #endif
  54 #undef HAS_ARGB_SHIFTS
  55
  56   // Something went really wrong. Best guess is that the bitmap data is invalid.
  57   DCHECK(context);
  58
  59   [NSGraphicsContext saveGraphicsState];
  60
  61   NSGraphicsContext* context_cocoa =
  62       [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO];
  63   [NSGraphicsContext setCurrentContext:context_cocoa];
  64
  65   NSRect drawRect = NSMakeRect(0, 0, size.width, size.height);
  66   if (image) {
  67     [image drawInRect:drawRect
  68              fromRect:NSZeroRect
  69             operation:NSCompositeCopy
  70              fraction:1.0];
  71   } else {
  72     [image_rep drawInRect:drawRect
  73                  fromRect:NSZeroRect
  74                 operation:NSCompositeCopy
  75                  fraction:1.0
  76            respectFlipped:NO
  77                     hints:nil];
  78   }
  79
  80   [NSGraphicsContext restoreGraphicsState];
  81
  82   return bitmap;
  83 }
  84
  85 } // namespace
  86
  87 namespace gfx {
  88
  89 CGAffineTransform SkMatrixToCGAffineTransform(const SkMatrix& matrix) {
  90   // CGAffineTransforms don't support perspective transforms, so make sure
  91   // we don't get those.
  92   DCHECK(matrix[SkMatrix::kMPersp0] == 0.0f);
  93   DCHECK(matrix[SkMatrix::kMPersp1] == 0.0f);
  94   DCHECK(matrix[SkMatrix::kMPersp2] == 1.0f);
  95
  96   return CGAffineTransformMake(matrix[SkMatrix::kMScaleX],
  97                                matrix[SkMatrix::kMSkewY],
  98                                matrix[SkMatrix::kMSkewX],
  99                                matrix[SkMatrix::kMScaleY],
 100                                matrix[SkMatrix::kMTransX],
 101                                matrix[SkMatrix::kMTransY]);
 102 }
 103
 104 SkRect CGRectToSkRect(const CGRect& rect) {
 105   SkRect sk_rect = {
 106     rect.origin.x, rect.origin.y, CGRectGetMaxX(rect), CGRectGetMaxY(rect)
 107   };
 108   return sk_rect;
 109 }
 110
 111 CGRect SkIRectToCGRect(const SkIRect& rect) {
 112   CGRect cg_rect = {
 113     { rect.fLeft, rect.fTop },
 114     { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop }
 115   };
 116   return cg_rect;
 117 }
 118
 119 CGRect SkRectToCGRect(const SkRect& rect) {
 120   CGRect cg_rect = {
 121     { rect.fLeft, rect.fTop },
 122     { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop }
 123   };
 124   return cg_rect;
 125 }
 126
 127 // Converts CGColorRef to the ARGB layout Skia expects.
 128 SkColor CGColorRefToSkColor(CGColorRef color) {
 129   DCHECK(CGColorGetNumberOfComponents(color) == 4);
 130   const CGFloat* components = CGColorGetComponents(color);
 131   return SkColorSetARGB(SkScalarRoundToInt(255.0 * components[3]), // alpha
 132                         SkScalarRoundToInt(255.0 * components[0]), // red
 133                         SkScalarRoundToInt(255.0 * components[1]), // green
 134                         SkScalarRoundToInt(255.0 * components[2])); // blue
 135 }
 136
 137 // Converts ARGB to CGColorRef.
 138 CGColorRef CGColorCreateFromSkColor(SkColor color) {
 139   return CGColorCreateGenericRGB(SkColorGetR(color) / 255.0,
 140                                  SkColorGetG(color) / 255.0,
 141                                  SkColorGetB(color) / 255.0,
 142                                  SkColorGetA(color) / 255.0);
 143 }
 144
 145 // Converts NSColor to ARGB
 146 SkColor NSDeviceColorToSkColor(NSColor* color) {
 147   DCHECK([color colorSpace] == [NSColorSpace genericRGBColorSpace] ||
 148          [color colorSpace] == [NSColorSpace deviceRGBColorSpace]);
 149   CGFloat red, green, blue, alpha;
 150   color = [color colorUsingColorSpace:[NSColorSpace deviceRGBColorSpace]];
 151   [color getRed:&red green:&green blue:&blue alpha:&alpha];
 152   return SkColorSetARGB(SkScalarRoundToInt(255.0 * alpha),
 153                         SkScalarRoundToInt(255.0 * red),
 154                         SkScalarRoundToInt(255.0 * green),
 155                         SkScalarRoundToInt(255.0 * blue));
 156 }
 157
 158 // Converts ARGB to NSColor.
 159 NSColor* SkColorToCalibratedNSColor(SkColor color) {
 160   return [NSColor colorWithCalibratedRed:SkColorGetR(color) / 255.0
 161                                    green:SkColorGetG(color) / 255.0
 162                                     blue:SkColorGetB(color) / 255.0
 163                                    alpha:SkColorGetA(color) / 255.0];
 164 }
 165
 166 NSColor* SkColorToDeviceNSColor(SkColor color) {
 167   return [NSColor colorWithDeviceRed:SkColorGetR(color) / 255.0
 168                                green:SkColorGetG(color) / 255.0
 169                                 blue:SkColorGetB(color) / 255.0
 170                                alpha:SkColorGetA(color) / 255.0];
 171 }
 172
 173 NSColor* SkColorToSRGBNSColor(SkColor color) {
 174   const CGFloat components[] = {
 175     SkColorGetR(color) / 255.0,
 176     SkColorGetG(color) / 255.0,
 177     SkColorGetB(color) / 255.0,
 178     SkColorGetA(color) / 255.0
 179   };
 180   return [NSColor colorWithColorSpace:[NSColorSpace sRGBColorSpace]
 181                            components:components
 182                                 count:4];
 183 }
 184
 185 SkBitmap CGImageToSkBitmap(CGImageRef image) {
 186   if (!image)
 187     return SkBitmap();
 188
 189   int width = CGImageGetWidth(image);
 190   int height = CGImageGetHeight(image);
 191
 192   scoped_ptr<SkBaseDevice> device(
 193       skia::BitmapPlatformDevice::Create(NULL, width, height, false));
 194
 195   CGContextRef context = skia::GetBitmapContext(device.get());
 196
 197   // We need to invert the y-axis of the canvas so that Core Graphics drawing
 198   // happens right-side up. Skia has an upper-left origin and CG has a lower-
 199   // left one.
 200   CGContextScaleCTM(context, 1.0, -1.0);
 201   CGContextTranslateCTM(context, 0, -height);
 202
 203   // We want to copy transparent pixels from |image|, instead of blending it
 204   // onto uninitialized pixels.
 205   CGContextSetBlendMode(context, kCGBlendModeCopy);
 206
 207   CGRect rect = CGRectMake(0, 0, width, height);
 208   CGContextDrawImage(context, rect, image);
 209
 210   // Because |device| will be cleaned up and will take its pixels with it, we
 211   // copy it to the stack and return it.
 212   SkBitmap bitmap = device->accessBitmap(false);
 213
 214   return bitmap;
 215 }
 216
 217 SkBitmap NSImageToSkBitmapWithColorSpace(
 218     NSImage* image, bool is_opaque, CGColorSpaceRef color_space) {
 219   return NSImageOrNSImageRepToSkBitmapWithColorSpace(
 220       image, nil, [image size], is_opaque, color_space);
 221 }
 222
 223 SkBitmap NSImageRepToSkBitmapWithColorSpace(NSImageRep* image_rep,
 224                                             NSSize size,
 225                                             bool is_opaque,
 226                                             CGColorSpaceRef color_space) {
 227   return NSImageOrNSImageRepToSkBitmapWithColorSpace(
 228       nil, image_rep, size, is_opaque, color_space);
 229 }
 230
 231 NSBitmapImageRep* SkBitmapToNSBitmapImageRep(const SkBitmap& skiaBitmap) {
 232   base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
 233       CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
 234   return SkBitmapToNSBitmapImageRepWithColorSpace(skiaBitmap, color_space);
 235 }
 236
 237 NSBitmapImageRep* SkBitmapToNSBitmapImageRepWithColorSpace(
 238     const SkBitmap& skiaBitmap,
 239     CGColorSpaceRef colorSpace) {
 240   // First convert SkBitmap to CGImageRef.
 241   base::ScopedCFTypeRef<CGImageRef> cgimage(
 242       SkCreateCGImageRefWithColorspace(skiaBitmap, colorSpace));
 243
 244   // Now convert to NSBitmapImageRep.
 245   base::scoped_nsobject<NSBitmapImageRep> bitmap(
 246       [[NSBitmapImageRep alloc] initWithCGImage:cgimage]);
 247   return [bitmap.release() autorelease];
 248 }
 249
 250 NSImage* SkBitmapToNSImageWithColorSpace(const SkBitmap& skiaBitmap,
 251                                          CGColorSpaceRef colorSpace) {
 252   if (skiaBitmap.isNull())
 253     return nil;
 254
 255   base::scoped_nsobject<NSImage> image([[NSImage alloc] init]);
 256   [image addRepresentation:
 257       SkBitmapToNSBitmapImageRepWithColorSpace(skiaBitmap, colorSpace)];
 258   [image setSize:NSMakeSize(skiaBitmap.width(), skiaBitmap.height())];
 259   return [image.release() autorelease];
 260 }
 261
 262 NSImage* SkBitmapToNSImage(const SkBitmap& skiaBitmap) {
 263   base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
 264       CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
 265   return SkBitmapToNSImageWithColorSpace(skiaBitmap, colorSpace.get());
 266 }
 267
 268 SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas)
 269     : canvas_(canvas),
 270       userClipRectSpecified_(false),
 271       cgContext_(0),
 272       useDeviceBits_(false),
 273       bitmapIsDummy_(false) {
 274 }
 275
 276 SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas, const SkIRect& userClipRect)
 277     : canvas_(canvas),
 278       userClipRectSpecified_(true),
 279       cgContext_(0),
 280       useDeviceBits_(false),
 281       bitmapIsDummy_(false) {
 282   canvas_->save();
 283   canvas_->clipRect(SkRect::MakeFromIRect(userClipRect));
 284 }
 285
 286 SkiaBitLocker::~SkiaBitLocker() {
 287   releaseIfNeeded();
 288   if (userClipRectSpecified_)
 289     canvas_->restore();
 290 }
 291
 292 SkIRect SkiaBitLocker::computeDirtyRect() {
 293   // If the user specified a clip region, assume that it was tight and that the
 294   // dirty rect is approximately the whole bitmap.
 295   if (userClipRectSpecified_)
 296     return SkIRect::MakeWH(bitmap_.width(), bitmap_.height());
 297
 298   // Find the bits that were drawn to.
 299   SkAutoLockPixels lockedPixels(bitmap_);
 300   const uint32_t* pixelBase
 301       = reinterpret_cast<uint32_t*>(bitmap_.getPixels());
 302   int rowPixels = bitmap_.rowBytesAsPixels();
 303   int width = bitmap_.width();
 304   int height = bitmap_.height();
 305   SkIRect bounds;
 306   bounds.fTop = 0;
 307   int x;
 308   int y = -1;
 309   const uint32_t* pixels = pixelBase;
 310   while (++y < height) {
 311     for (x = 0; x < width; ++x) {
 312       if (pixels[x]) {
 313         bounds.fTop = y;
 314         goto foundTop;
 315       }
 316     }
 317     pixels += rowPixels;
 318   }
 319 foundTop:
 320   bounds.fBottom = height;
 321   y = height;
 322   pixels = pixelBase + rowPixels * (y - 1);
 323   while (--y > bounds.fTop) {
 324     for (x = 0; x < width; ++x) {
 325       if (pixels[x]) {
 326         bounds.fBottom = y + 1;
 327         goto foundBottom;
 328       }
 329     }
 330     pixels -= rowPixels;
 331   }
 332 foundBottom:
 333   bounds.fLeft = 0;
 334   x = -1;
 335   while (++x < width) {
 336     pixels = pixelBase + rowPixels * bounds.fTop;
 337     for (y = bounds.fTop; y < bounds.fBottom; ++y) {
 338       if (pixels[x]) {
 339         bounds.fLeft = x;
 340         goto foundLeft;
 341       }
 342       pixels += rowPixels;
 343     }
 344   }
 345 foundLeft:
 346   bounds.fRight = width;
 347   x = width;
 348   while (--x > bounds.fLeft) {
 349     pixels = pixelBase + rowPixels * bounds.fTop;
 350     for (y = bounds.fTop; y < bounds.fBottom; ++y) {
 351       if (pixels[x]) {
 352         bounds.fRight = x + 1;
 353         goto foundRight;
 354       }
 355       pixels += rowPixels;
 356     }
 357   }
 358 foundRight:
 359   return bounds;
 360 }
 361
 362 // This must be called to balance calls to cgContext
 363 void SkiaBitLocker::releaseIfNeeded() {
 364   if (!cgContext_)
 365     return;
 366   if (useDeviceBits_) {
 367     bitmap_.unlockPixels();
 368   } else if (!bitmapIsDummy_) {
 369     // Find the bits that were drawn to.
 370     SkIRect bounds = computeDirtyRect();
 371     SkBitmap subset;
 372     if (!bitmap_.extractSubset(&subset, bounds)) {
 373         return;
 374     }
 375     // Neutralize the global matrix by concatenating the inverse. In the
 376     // future, Skia may provide some mechanism to set the device portion of
 377     // the matrix to identity without clobbering any hosting matrix (e.g., the
 378     // picture's matrix).
 379     const SkMatrix& skMatrix = canvas_->getTotalMatrix();
 380     SkMatrix inverse;
 381     if (!skMatrix.invert(&inverse))
 382       return;
 383     canvas_->save();
 384     canvas_->concat(inverse);
 385     canvas_->drawBitmap(subset, bounds.x() + bitmapOffset_.x(),
 386                                 bounds.y() + bitmapOffset_.y());
 387     canvas_->restore();
 388   }
 389   CGContextRelease(cgContext_);
 390   cgContext_ = 0;
 391   useDeviceBits_ = false;
 392   bitmapIsDummy_ = false;
 393 }
 394
 395 CGContextRef SkiaBitLocker::cgContext() {
 396   SkIRect clip_bounds;
 397   if (!canvas_->getClipDeviceBounds(&clip_bounds)) {
 398     // If the clip is empty, then there is nothing to draw. The caller may
 399     // attempt to draw (to-be-clipped) results, so ensure there is a dummy
 400     // non-NULL CGContext to use.
 401     bitmapIsDummy_ = true;
 402     clip_bounds = SkIRect::MakeXYWH(0, 0, 1, 1);
 403   }
 404
 405   SkBaseDevice* device = canvas_->getTopDevice();
 406   DCHECK(device);
 407   if (!device)
 408     return 0;
 409
 410   releaseIfNeeded(); // This flushes any prior bitmap use
 411
 412   // remember the top/left, in case we need to compose this later
 413   bitmapOffset_.set(clip_bounds.x(), clip_bounds.y());
 414
 415   // Now make clip_bounds be relative to the current layer/device
 416   clip_bounds.offset(-device->getOrigin());
 417
 418   const SkBitmap& deviceBits = device->accessBitmap(true);
 419
 420   // Only draw directly if we have pixels, and we're only rect-clipped.
 421   // If not, we allocate an offscreen and draw into that, relying on the
 422   // compositing step to apply skia's clip.
 423   useDeviceBits_ = deviceBits.getPixels() &&
 424                    canvas_->isClipRect() &&
 425                    !bitmapIsDummy_;
 426   if (useDeviceBits_) {
 427     bool result = deviceBits.extractSubset(&bitmap_, clip_bounds);
 428     DCHECK(result);
 429     if (!result)
 430       return 0;
 431     bitmap_.lockPixels();
 432   } else {
 433     bool result = bitmap_.allocN32Pixels(
 434         clip_bounds.width(), clip_bounds.height());
 435     DCHECK(result);
 436     if (!result)
 437       return 0;
 438     bitmap_.eraseColor(0);
 439   }
 440   base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
 441       CGColorSpaceCreateDeviceRGB());
 442   cgContext_ = CGBitmapContextCreate(bitmap_.getPixels(), bitmap_.width(),
 443     bitmap_.height(), 8, bitmap_.rowBytes(), colorSpace,
 444     kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
 445   DCHECK(cgContext_);
 446
 447   SkMatrix matrix = canvas_->getTotalMatrix();
 448   matrix.postTranslate(-SkIntToScalar(bitmapOffset_.x()),
 449                        -SkIntToScalar(bitmapOffset_.y()));
 450   matrix.postScale(1, -1);
 451   matrix.postTranslate(0, SkIntToScalar(bitmap_.height()));
 452
 453   CGContextConcatCTM(cgContext_, SkMatrixToCGAffineTransform(matrix));
 454
 455   return cgContext_;
 456 }
 457
 458 bool SkiaBitLocker::hasEmptyClipRegion() const {
 459   return canvas_->isClipEmpty();
 460 }
 461
 462 }  // namespace gfx