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/bitmap_platform_device_mac.h" 6 7 #import <ApplicationServices/ApplicationServices.h> 8 #include <time.h> 9 10 #include "base/mac/mac_util.h" 11 #include "base/memory/ref_counted.h" 12 #include "skia/ext/bitmap_platform_device.h" 13 #include "skia/ext/platform_canvas.h" 14 #include "skia/ext/skia_utils_mac.h" 15 #include "third_party/skia/include/core/SkMatrix.h" 16 #include "third_party/skia/include/core/SkRegion.h" 17 #include "third_party/skia/include/core/SkTypes.h" 18 #include "third_party/skia/include/core/SkUtils.h" 19 20 namespace skia { 21 22 namespace { 23 24 static CGContextRef CGContextForData(void* data, int width, int height) { 25 #define HAS_ARGB_SHIFTS(a, r, g, b) \ 26 (SK_A32_SHIFT == (a) && SK_R32_SHIFT == (r) \ 27 && SK_G32_SHIFT == (g) && SK_B32_SHIFT == (b)) 28 #if defined(SK_CPU_LENDIAN) && HAS_ARGB_SHIFTS(24, 16, 8, 0) 29 // Allocate a bitmap context with 4 components per pixel (BGRA). Apple 30 // recommends these flags for improved CG performance. 31 32 // CGBitmapContextCreate returns NULL if width/height are 0. However, our 33 // callers expect to get a canvas back (which they later resize/reallocate) 34 // so we pin the dimensions here. 35 width = SkMax32(1, width); 36 height = SkMax32(1, height); 37 CGContextRef context = 38 CGBitmapContextCreate(data, width, height, 8, width * 4, 39 base::mac::GetSystemColorSpace(), 40 kCGImageAlphaPremultipliedFirst | 41 kCGBitmapByteOrder32Host); 42 #else 43 #error We require that Skia's and CoreGraphics's recommended \ 44 image memory layout match. 45 #endif 46 #undef HAS_ARGB_SHIFTS 47 48 if (!context) 49 return NULL; 50 51 // Change the coordinate system to match WebCore's 52 CGContextTranslateCTM(context, 0, height); 53 CGContextScaleCTM(context, 1.0, -1.0); 54 55 return context; 56 } 57 58 } // namespace 59 60 void BitmapPlatformDevice::ReleaseBitmapContext() { 61 SkASSERT(bitmap_context_); 62 CGContextRelease(bitmap_context_); 63 bitmap_context_ = NULL; 64 } 65 66 void BitmapPlatformDevice::SetMatrixClip( 67 const SkMatrix& transform, 68 const SkRegion& region) { 69 transform_ = transform; 70 clip_region_ = region; 71 config_dirty_ = true; 72 } 73 74 void BitmapPlatformDevice::LoadConfig() { 75 if (!config_dirty_ || !bitmap_context_) 76 return; // Nothing to do. 77 config_dirty_ = false; 78 79 // We must restore and then save the state of the graphics context since the 80 // calls to Load the clipping region to the context are strictly cummulative, 81 // i.e., you can't replace a clip rect, other than with a save/restore. 82 // But this implies that no other changes to the state are done elsewhere. 83 // If we ever get to need to change this, then we must replace the clip rect 84 // calls in LoadClippingRegionToCGContext() with an image mask instead. 85 CGContextRestoreGState(bitmap_context_); 86 CGContextSaveGState(bitmap_context_); 87 LoadTransformToCGContext(bitmap_context_, transform_); 88 LoadClippingRegionToCGContext(bitmap_context_, clip_region_, transform_); 89 } 90 91 92 // We use this static factory function instead of the regular constructor so 93 // that we can create the pixel data before calling the constructor. This is 94 // required so that we can call the base class' constructor with the pixel 95 // data. 96 BitmapPlatformDevice* BitmapPlatformDevice::Create(CGContextRef context, 97 int width, 98 int height, 99 bool is_opaque) { 100 if (RasterDeviceTooBigToAllocate(width, height)) 101 return NULL; 102 103 SkBitmap bitmap; 104 // TODO: verify that the CG Context's pixels will have tight rowbytes or pass in the correct 105 // rowbytes for the case when context != NULL. 106 bitmap.setInfo(SkImageInfo::MakeN32(width, height, is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType)); 107 108 void* data; 109 if (context) { 110 data = CGBitmapContextGetData(context); 111 bitmap.setPixels(data); 112 } else { 113 if (!bitmap.allocPixels()) 114 return NULL; 115 data = bitmap.getPixels(); 116 } 117 118 // If we were given data, then don't clobber it! 119 #ifndef NDEBUG 120 if (!context && is_opaque) { 121 // To aid in finding bugs, we set the background color to something 122 // obviously wrong so it will be noticable when it is not cleared 123 bitmap.eraseARGB(255, 0, 255, 128); // bright bluish green 124 } 125 #endif 126 127 if (!context) { 128 context = CGContextForData(data, width, height); 129 if (!context) 130 return NULL; 131 } else 132 CGContextRetain(context); 133 134 BitmapPlatformDevice* rv = new BitmapPlatformDevice(context, bitmap); 135 136 // The device object took ownership of the graphics context with its own 137 // CGContextRetain call. 138 CGContextRelease(context); 139 140 return rv; 141 } 142 143 BitmapPlatformDevice* BitmapPlatformDevice::CreateAndClear(int width, 144 int height, 145 bool is_opaque) { 146 BitmapPlatformDevice* device = Create(NULL, width, height, is_opaque); 147 if (!is_opaque) 148 device->clear(0); 149 return device; 150 } 151 152 BitmapPlatformDevice* BitmapPlatformDevice::CreateWithData(uint8_t* data, 153 int width, 154 int height, 155 bool is_opaque) { 156 CGContextRef context = NULL; 157 if (data) 158 context = CGContextForData(data, width, height); 159 160 BitmapPlatformDevice* rv = Create(context, width, height, is_opaque); 161 162 // The device object took ownership of the graphics context with its own 163 // CGContextRetain call. 164 if (context) 165 CGContextRelease(context); 166 167 return rv; 168 } 169 170 // The device will own the bitmap, which corresponds to also owning the pixel 171 // data. Therefore, we do not transfer ownership to the SkBitmapDevice's bitmap. 172 BitmapPlatformDevice::BitmapPlatformDevice( 173 CGContextRef context, const SkBitmap& bitmap) 174 : SkBitmapDevice(bitmap), 175 bitmap_context_(context), 176 config_dirty_(true), // Want to load the config next time. 177 transform_(SkMatrix::I()) { 178 SetPlatformDevice(this, this); 179 SkASSERT(bitmap_context_); 180 // Initialize the clip region to the entire bitmap. 181 182 SkIRect rect; 183 rect.set(0, 0, 184 CGBitmapContextGetWidth(bitmap_context_), 185 CGBitmapContextGetHeight(bitmap_context_)); 186 clip_region_ = SkRegion(rect); 187 CGContextRetain(bitmap_context_); 188 // We must save the state once so that we can use the restore/save trick 189 // in LoadConfig(). 190 CGContextSaveGState(bitmap_context_); 191 } 192 193 BitmapPlatformDevice::~BitmapPlatformDevice() { 194 if (bitmap_context_) 195 CGContextRelease(bitmap_context_); 196 } 197 198 CGContextRef BitmapPlatformDevice::GetBitmapContext() { 199 LoadConfig(); 200 return bitmap_context_; 201 } 202 203 void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform, 204 const SkRegion& region, 205 const SkClipStack&) { 206 SetMatrixClip(transform, region); 207 } 208 209 void BitmapPlatformDevice::DrawToNativeContext(CGContextRef context, int x, 210 int y, const CGRect* src_rect) { 211 bool created_dc = false; 212 if (!bitmap_context_) { 213 created_dc = true; 214 GetBitmapContext(); 215 } 216 217 // this should not make a copy of the bits, since we're not doing 218 // anything to trigger copy on write 219 CGImageRef image = CGBitmapContextCreateImage(bitmap_context_); 220 CGRect bounds; 221 bounds.origin.x = x; 222 bounds.origin.y = y; 223 if (src_rect) { 224 bounds.size.width = src_rect->size.width; 225 bounds.size.height = src_rect->size.height; 226 CGImageRef sub_image = CGImageCreateWithImageInRect(image, *src_rect); 227 CGContextDrawImage(context, bounds, sub_image); 228 CGImageRelease(sub_image); 229 } else { 230 bounds.size.width = width(); 231 bounds.size.height = height(); 232 CGContextDrawImage(context, bounds, image); 233 } 234 CGImageRelease(image); 235 236 if (created_dc) 237 ReleaseBitmapContext(); 238 } 239 240 SkBaseDevice* BitmapPlatformDevice::onCreateDevice(const SkImageInfo& info, 241 Usage /*usage*/) { 242 SkASSERT(info.colorType() == kPMColor_SkColorType); 243 return BitmapPlatformDevice::CreateAndClear(info.width(), info.height(), 244 info.isOpaque()); 245 } 246 247 // PlatformCanvas impl 248 249 SkCanvas* CreatePlatformCanvas(CGContextRef ctx, int width, int height, 250 bool is_opaque, OnFailureType failureType) { 251 skia::RefPtr<SkBaseDevice> dev = skia::AdoptRef( 252 BitmapPlatformDevice::Create(ctx, width, height, is_opaque)); 253 return CreateCanvas(dev, failureType); 254 } 255 256 SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque, 257 uint8_t* data, OnFailureType failureType) { 258 skia::RefPtr<SkBaseDevice> dev = skia::AdoptRef( 259 BitmapPlatformDevice::CreateWithData(data, width, height, is_opaque)); 260 return CreateCanvas(dev, failureType); 261 } 262 263 // Port of PlatformBitmap to mac 264 265 PlatformBitmap::~PlatformBitmap() { 266 if (surface_) 267 CGContextRelease(surface_); 268 } 269 270 bool PlatformBitmap::Allocate(int width, int height, bool is_opaque) { 271 if (RasterDeviceTooBigToAllocate(width, height)) 272 return false; 273 274 if (!bitmap_.allocN32Pixels(width, height, is_opaque)) 275 return false; 276 277 if (!is_opaque) 278 bitmap_.eraseColor(0); 279 280 surface_ = CGContextForData(bitmap_.getPixels(), bitmap_.width(), 281 bitmap_.height()); 282 return true; 283 } 284 285 } // namespace skia 286
