blob: 2a96d59e4f8cbd017ef9442552295af0eae018b1 [file] [log] [blame]
// 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 "skia/ext/skia_utils_mac.h"
#import <AppKit/AppKit.h>
#include "base/logging.h"
#include "base/mac/scoped_cftyperef.h"
#include "base/mac/scoped_nsobject.h"
#include "base/memory/scoped_ptr.h"
#include "skia/ext/bitmap_platform_device_mac.h"
#include "third_party/skia/include/core/SkRegion.h"
#include "third_party/skia/include/utils/mac/SkCGUtils.h"
namespace {
// Draws an NSImage or an NSImageRep with a given size into a SkBitmap.
SkBitmap NSImageOrNSImageRepToSkBitmapWithColorSpace(
NSImage* image,
NSImageRep* image_rep,
NSSize size,
bool is_opaque,
CGColorSpaceRef color_space) {
// Only image or image_rep should be provided, not both.
DCHECK((image != 0) ^ (image_rep != 0));
SkBitmap bitmap;
bitmap.setConfig(SkBitmap::kARGB_8888_Config,
size.width,
size.height,
0,
is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
if (!bitmap.allocPixels())
return bitmap; // Return |bitmap| which should respond true to isNull().
void* data = bitmap.getPixels();
// Allocate a bitmap context with 4 components per pixel (BGRA). Apple
// recommends these flags for improved CG performance.
#define HAS_ARGB_SHIFTS(a, r, g, b) \
(SK_A32_SHIFT == (a) && SK_R32_SHIFT == (r) \
&& SK_G32_SHIFT == (g) && SK_B32_SHIFT == (b))
#if defined(SK_CPU_LENDIAN) && HAS_ARGB_SHIFTS(24, 16, 8, 0)
base::ScopedCFTypeRef<CGContextRef> context(CGBitmapContextCreate(
data,
size.width,
size.height,
8,
size.width * 4,
color_space,
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
#else
#error We require that Skia's and CoreGraphics's recommended \
image memory layout match.
#endif
#undef HAS_ARGB_SHIFTS
// Something went really wrong. Best guess is that the bitmap data is invalid.
DCHECK(context);
[NSGraphicsContext saveGraphicsState];
NSGraphicsContext* context_cocoa =
[NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO];
[NSGraphicsContext setCurrentContext:context_cocoa];
NSRect drawRect = NSMakeRect(0, 0, size.width, size.height);
if (image) {
[image drawInRect:drawRect
fromRect:NSZeroRect
operation:NSCompositeCopy
fraction:1.0];
} else {
[image_rep drawInRect:drawRect
fromRect:NSZeroRect
operation:NSCompositeCopy
fraction:1.0
respectFlipped:NO
hints:nil];
}
[NSGraphicsContext restoreGraphicsState];
return bitmap;
}
} // namespace
namespace gfx {
CGAffineTransform SkMatrixToCGAffineTransform(const SkMatrix& matrix) {
// CGAffineTransforms don't support perspective transforms, so make sure
// we don't get those.
DCHECK(matrix[SkMatrix::kMPersp0] == 0.0f);
DCHECK(matrix[SkMatrix::kMPersp1] == 0.0f);
DCHECK(matrix[SkMatrix::kMPersp2] == 1.0f);
return CGAffineTransformMake(matrix[SkMatrix::kMScaleX],
matrix[SkMatrix::kMSkewY],
matrix[SkMatrix::kMSkewX],
matrix[SkMatrix::kMScaleY],
matrix[SkMatrix::kMTransX],
matrix[SkMatrix::kMTransY]);
}
SkRect CGRectToSkRect(const CGRect& rect) {
SkRect sk_rect = {
rect.origin.x, rect.origin.y, CGRectGetMaxX(rect), CGRectGetMaxY(rect)
};
return sk_rect;
}
CGRect SkIRectToCGRect(const SkIRect& rect) {
CGRect cg_rect = {
{ rect.fLeft, rect.fTop },
{ rect.fRight - rect.fLeft, rect.fBottom - rect.fTop }
};
return cg_rect;
}
CGRect SkRectToCGRect(const SkRect& rect) {
CGRect cg_rect = {
{ rect.fLeft, rect.fTop },
{ rect.fRight - rect.fLeft, rect.fBottom - rect.fTop }
};
return cg_rect;
}
// Converts CGColorRef to the ARGB layout Skia expects.
SkColor CGColorRefToSkColor(CGColorRef color) {
DCHECK(CGColorGetNumberOfComponents(color) == 4);
const CGFloat* components = CGColorGetComponents(color);
return SkColorSetARGB(SkScalarRoundToInt(255.0 * components[3]), // alpha
SkScalarRoundToInt(255.0 * components[0]), // red
SkScalarRoundToInt(255.0 * components[1]), // green
SkScalarRoundToInt(255.0 * components[2])); // blue
}
// Converts ARGB to CGColorRef.
CGColorRef CGColorCreateFromSkColor(SkColor color) {
return CGColorCreateGenericRGB(SkColorGetR(color) / 255.0,
SkColorGetG(color) / 255.0,
SkColorGetB(color) / 255.0,
SkColorGetA(color) / 255.0);
}
// Converts NSColor to ARGB
SkColor NSDeviceColorToSkColor(NSColor* color) {
DCHECK([color colorSpace] == [NSColorSpace genericRGBColorSpace] ||
[color colorSpace] == [NSColorSpace deviceRGBColorSpace]);
CGFloat red, green, blue, alpha;
color = [color colorUsingColorSpace:[NSColorSpace deviceRGBColorSpace]];
[color getRed:&red green:&green blue:&blue alpha:&alpha];
return SkColorSetARGB(SkScalarRoundToInt(255.0 * alpha),
SkScalarRoundToInt(255.0 * red),
SkScalarRoundToInt(255.0 * green),
SkScalarRoundToInt(255.0 * blue));
}
// Converts ARGB to NSColor.
NSColor* SkColorToCalibratedNSColor(SkColor color) {
return [NSColor colorWithCalibratedRed:SkColorGetR(color) / 255.0
green:SkColorGetG(color) / 255.0
blue:SkColorGetB(color) / 255.0
alpha:SkColorGetA(color) / 255.0];
}
NSColor* SkColorToDeviceNSColor(SkColor color) {
return [NSColor colorWithDeviceRed:SkColorGetR(color) / 255.0
green:SkColorGetG(color) / 255.0
blue:SkColorGetB(color) / 255.0
alpha:SkColorGetA(color) / 255.0];
}
NSColor* SkColorToSRGBNSColor(SkColor color) {
const CGFloat components[] = {
SkColorGetR(color) / 255.0,
SkColorGetG(color) / 255.0,
SkColorGetB(color) / 255.0,
SkColorGetA(color) / 255.0
};
return [NSColor colorWithColorSpace:[NSColorSpace sRGBColorSpace]
components:components
count:4];
}
SkBitmap CGImageToSkBitmap(CGImageRef image) {
if (!image)
return SkBitmap();
int width = CGImageGetWidth(image);
int height = CGImageGetHeight(image);
scoped_ptr<SkBaseDevice> device(
skia::BitmapPlatformDevice::Create(NULL, width, height, false));
CGContextRef context = skia::GetBitmapContext(device.get());
// We need to invert the y-axis of the canvas so that Core Graphics drawing
// happens right-side up. Skia has an upper-left origin and CG has a lower-
// left one.
CGContextScaleCTM(context, 1.0, -1.0);
CGContextTranslateCTM(context, 0, -height);
// We want to copy transparent pixels from |image|, instead of blending it
// onto uninitialized pixels.
CGContextSetBlendMode(context, kCGBlendModeCopy);
CGRect rect = CGRectMake(0, 0, width, height);
CGContextDrawImage(context, rect, image);
// Because |device| will be cleaned up and will take its pixels with it, we
// copy it to the stack and return it.
SkBitmap bitmap = device->accessBitmap(false);
return bitmap;
}
SkBitmap NSImageToSkBitmapWithColorSpace(
NSImage* image, bool is_opaque, CGColorSpaceRef color_space) {
return NSImageOrNSImageRepToSkBitmapWithColorSpace(
image, nil, [image size], is_opaque, color_space);
}
SkBitmap NSImageRepToSkBitmapWithColorSpace(NSImageRep* image_rep,
NSSize size,
bool is_opaque,
CGColorSpaceRef color_space) {
return NSImageOrNSImageRepToSkBitmapWithColorSpace(
nil, image_rep, size, is_opaque, color_space);
}
NSBitmapImageRep* SkBitmapToNSBitmapImageRep(const SkBitmap& skiaBitmap) {
base::ScopedCFTypeRef<CGColorSpaceRef> color_space(
CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
return SkBitmapToNSBitmapImageRepWithColorSpace(skiaBitmap, color_space);
}
NSBitmapImageRep* SkBitmapToNSBitmapImageRepWithColorSpace(
const SkBitmap& skiaBitmap,
CGColorSpaceRef colorSpace) {
// First convert SkBitmap to CGImageRef.
base::ScopedCFTypeRef<CGImageRef> cgimage(
SkCreateCGImageRefWithColorspace(skiaBitmap, colorSpace));
// Now convert to NSBitmapImageRep.
base::scoped_nsobject<NSBitmapImageRep> bitmap(
[[NSBitmapImageRep alloc] initWithCGImage:cgimage]);
return [bitmap.release() autorelease];
}
NSImage* SkBitmapToNSImageWithColorSpace(const SkBitmap& skiaBitmap,
CGColorSpaceRef colorSpace) {
if (skiaBitmap.isNull())
return nil;
base::scoped_nsobject<NSImage> image([[NSImage alloc] init]);
[image addRepresentation:
SkBitmapToNSBitmapImageRepWithColorSpace(skiaBitmap, colorSpace)];
[image setSize:NSMakeSize(skiaBitmap.width(), skiaBitmap.height())];
return [image.release() autorelease];
}
NSImage* SkBitmapToNSImage(const SkBitmap& skiaBitmap) {
base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
return SkBitmapToNSImageWithColorSpace(skiaBitmap, colorSpace.get());
}
SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas)
: canvas_(canvas),
cgContext_(0) {
}
SkiaBitLocker::~SkiaBitLocker() {
releaseIfNeeded();
}
// This must be called to balance calls to cgContext
void SkiaBitLocker::releaseIfNeeded() {
if (!cgContext_)
return;
if (useBitmap_) {
// Find the bits that were drawn to.
const uint32_t* pixelBase
= reinterpret_cast<uint32_t*>(bitmap_.getPixels());
int rowPixels = bitmap_.rowBytesAsPixels();
int width = bitmap_.width();
int height = bitmap_.height();
SkIRect bounds;
bounds.fTop = 0;
int x;
int y = -1;
const uint32_t* pixels = pixelBase;
while (++y < height) {
for (x = 0; x < width; ++x) {
if (pixels[x]) {
bounds.fTop = y;
goto foundTop;
}
}
pixels += rowPixels;
}
foundTop:
bounds.fBottom = height;
y = height;
pixels = pixelBase + rowPixels * (y - 1);
while (--y > bounds.fTop) {
for (x = 0; x < width; ++x) {
if (pixels[x]) {
bounds.fBottom = y + 1;
goto foundBottom;
}
}
pixels -= rowPixels;
}
foundBottom:
bounds.fLeft = 0;
x = -1;
while (++x < width) {
pixels = pixelBase + rowPixels * bounds.fTop;
for (y = bounds.fTop; y < bounds.fBottom; ++y) {
if (pixels[x]) {
bounds.fLeft = x;
goto foundLeft;
}
pixels += rowPixels;
}
}
foundLeft:
bounds.fRight = width;
x = width;
while (--x > bounds.fLeft) {
pixels = pixelBase + rowPixels * bounds.fTop;
for (y = bounds.fTop; y < bounds.fBottom; ++y) {
if (pixels[x]) {
bounds.fRight = x + 1;
goto foundRight;
}
pixels += rowPixels;
}
}
foundRight:
SkBitmap subset;
if (!bitmap_.extractSubset(&subset, bounds)) {
return;
}
// Neutralize the global matrix by concatenating the inverse. In the
// future, Skia may provide some mechanism to set the device portion of
// the matrix to identity without clobbering any hosting matrix (e.g., the
// picture's matrix).
const SkMatrix& skMatrix = canvas_->getTotalMatrix();
SkMatrix inverse;
if (!skMatrix.invert(&inverse))
return;
canvas_->save();
canvas_->concat(inverse);
canvas_->drawBitmap(subset, bounds.fLeft, bounds.fTop);
canvas_->restore();
}
CGContextRelease(cgContext_);
cgContext_ = 0;
}
CGContextRef SkiaBitLocker::cgContext() {
releaseIfNeeded(); // This flushes any prior bitmap use
SkIRect clip_bounds;
const bool clip_is_empty = !canvas_->getClipDeviceBounds(&clip_bounds);
SkImageInfo info;
size_t row_bytes;
SkIPoint origin;
void* top_pixels = canvas_->accessTopLayerPixels(&info, &row_bytes, &origin);
if (top_pixels && (clip_is_empty || canvas_->isClipRect())) {
useBitmap_ = false;
} else {
useBitmap_ = true;
info = SkImageInfo::MakeN32Premul(clip_bounds.width(), clip_bounds.height());
origin.set(clip_bounds.x(), clip_bounds.y());
CHECK(bitmap_.allocPixels(info));
bitmap_.eraseColor(0);
top_pixels = bitmap_.getPixels();
}
base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
CGColorSpaceCreateDeviceRGB());
cgContext_ = CGBitmapContextCreate(top_pixels, info.width(),
info.height(), 8, row_bytes, colorSpace,
kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
// Apply device matrix.
CGAffineTransform contentsTransform = CGAffineTransformMakeScale(1, -1);
contentsTransform = CGAffineTransformTranslate(contentsTransform, 0,
-info.height());
CGContextConcatCTM(cgContext_, contentsTransform);
// Skip applying the clip when not writing directly to device.
// They're applied in the offscreen case when the bitmap is drawn.
if (!useBitmap_) {
// Apply clip in device coordinates.
CGMutablePathRef clipPath = CGPathCreateMutable();
if (clip_is_empty) {
// CoreGraphics does not consider a newly created path to be empty.
// Explicitly set it to empty so the subsequent drawing is clipped out.
// It would be better to make the CGContext hidden if there was a CG
// call that does that.
CGPathAddRect(clipPath, 0, CGRectMake(0, 0, 0, 0));
} else {
SkIRect r = clip_bounds;
r.offset(-origin);
CGPathAddRect(clipPath, 0, SkIRectToCGRect(r));
}
CGContextAddPath(cgContext_, clipPath);
CGContextClip(cgContext_);
CGPathRelease(clipPath);
}
// Apply content matrix.
SkMatrix skMatrix = canvas_->getTotalMatrix();
skMatrix.postTranslate(-SkIntToScalar(origin.fX), -SkIntToScalar(origin.fY));
CGAffineTransform affine = SkMatrixToCGAffineTransform(skMatrix);
CGContextConcatCTM(cgContext_, affine);
return cgContext_;
}
} // namespace gfx