skia/ext/bitmap_platform_device_mac.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 "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.setConfig(SkBitmap::kARGB_8888_Config, width, height, 0,
 107                    is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 108
 109   void* data;
 110   if (context) {
 111     data = CGBitmapContextGetData(context);
 112     bitmap.setPixels(data);
 113   } else {
 114     if (!bitmap.allocPixels())
 115       return NULL;
 116     data = bitmap.getPixels();
 117   }
 118
 119   // If we were given data, then don't clobber it!
 120 #ifndef NDEBUG
 121   if (!context && is_opaque) {
 122     // To aid in finding bugs, we set the background color to something
 123     // obviously wrong so it will be noticable when it is not cleared
 124     bitmap.eraseARGB(255, 0, 255, 128);  // bright bluish green
 125   }
 126 #endif
 127
 128   if (!context) {
 129     context = CGContextForData(data, width, height);
 130     if (!context)
 131       return NULL;
 132   } else
 133     CGContextRetain(context);
 134
 135   BitmapPlatformDevice* rv = new BitmapPlatformDevice(context, bitmap);
 136
 137   // The device object took ownership of the graphics context with its own
 138   // CGContextRetain call.
 139   CGContextRelease(context);
 140
 141   return rv;
 142 }
 143
 144 BitmapPlatformDevice* BitmapPlatformDevice::CreateAndClear(int width,
 145                                                            int height,
 146                                                            bool is_opaque) {
 147   BitmapPlatformDevice* device = Create(NULL, width, height, is_opaque);
 148   if (!is_opaque)
 149     device->accessBitmap(true).eraseARGB(0, 0, 0, 0);
 150   return device;
 151 }
 152
 153 BitmapPlatformDevice* BitmapPlatformDevice::CreateWithData(uint8_t* data,
 154                                                            int width,
 155                                                            int height,
 156                                                            bool is_opaque) {
 157   CGContextRef context = NULL;
 158   if (data)
 159     context = CGContextForData(data, width, height);
 160
 161   BitmapPlatformDevice* rv = Create(context, width, height, is_opaque);
 162
 163   // The device object took ownership of the graphics context with its own
 164   // CGContextRetain call.
 165   if (context)
 166     CGContextRelease(context);
 167
 168   return rv;
 169 }
 170
 171 // The device will own the bitmap, which corresponds to also owning the pixel
 172 // data. Therefore, we do not transfer ownership to the SkBitmapDevice's bitmap.
 173 BitmapPlatformDevice::BitmapPlatformDevice(
 174     CGContextRef context, const SkBitmap& bitmap)
 175     : SkBitmapDevice(bitmap),
 176       bitmap_context_(context),
 177       config_dirty_(true),  // Want to load the config next time.
 178       transform_(SkMatrix::I()) {
 179   SetPlatformDevice(this, this);
 180   SkASSERT(bitmap_context_);
 181   // Initialize the clip region to the entire bitmap.
 182
 183   SkIRect rect;
 184   rect.set(0, 0,
 185            CGBitmapContextGetWidth(bitmap_context_),
 186            CGBitmapContextGetHeight(bitmap_context_));
 187   clip_region_ = SkRegion(rect);
 188   CGContextRetain(bitmap_context_);
 189   // We must save the state once so that we can use the restore/save trick
 190   // in LoadConfig().
 191   CGContextSaveGState(bitmap_context_);
 192 }
 193
 194 BitmapPlatformDevice::~BitmapPlatformDevice() {
 195   if (bitmap_context_)
 196     CGContextRelease(bitmap_context_);
 197 }
 198
 199 CGContextRef BitmapPlatformDevice::GetBitmapContext() {
 200   LoadConfig();
 201   return bitmap_context_;
 202 }
 203
 204 void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
 205                                          const SkRegion& region,
 206                                          const SkClipStack&) {
 207   SetMatrixClip(transform, region);
 208 }
 209
 210 void BitmapPlatformDevice::DrawToNativeContext(CGContextRef context, int x,
 211                                                int y, const CGRect* src_rect) {
 212   bool created_dc = false;
 213   if (!bitmap_context_) {
 214     created_dc = true;
 215     GetBitmapContext();
 216   }
 217
 218   // this should not make a copy of the bits, since we're not doing
 219   // anything to trigger copy on write
 220   CGImageRef image = CGBitmapContextCreateImage(bitmap_context_);
 221   CGRect bounds;
 222   bounds.origin.x = x;
 223   bounds.origin.y = y;
 224   if (src_rect) {
 225     bounds.size.width = src_rect->size.width;
 226     bounds.size.height = src_rect->size.height;
 227     CGImageRef sub_image = CGImageCreateWithImageInRect(image, *src_rect);
 228     CGContextDrawImage(context, bounds, sub_image);
 229     CGImageRelease(sub_image);
 230   } else {
 231     bounds.size.width = width();
 232     bounds.size.height = height();
 233     CGContextDrawImage(context, bounds, image);
 234   }
 235   CGImageRelease(image);
 236
 237   if (created_dc)
 238     ReleaseBitmapContext();
 239 }
 240
 241 SkBaseDevice* BitmapPlatformDevice::onCreateCompatibleDevice(
 242     SkBitmap::Config config, int width, int height, bool isOpaque,
 243     Usage /*usage*/) {
 244   SkASSERT(config == SkBitmap::kARGB_8888_Config);
 245   SkBaseDevice* bitmap_device = BitmapPlatformDevice::CreateAndClear(width,
 246                                                                      height,
 247                                                                      isOpaque);
 248   return bitmap_device;
 249 }
 250
 251 // PlatformCanvas impl
 252
 253 SkCanvas* CreatePlatformCanvas(CGContextRef ctx, int width, int height,
 254                                bool is_opaque, OnFailureType failureType) {
 255   skia::RefPtr<SkBaseDevice> dev = skia::AdoptRef(
 256       BitmapPlatformDevice::Create(ctx, width, height, is_opaque));
 257   return CreateCanvas(dev, failureType);
 258 }
 259
 260 SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
 261                                uint8_t* data, OnFailureType failureType) {
 262   skia::RefPtr<SkBaseDevice> dev = skia::AdoptRef(
 263       BitmapPlatformDevice::CreateWithData(data, width, height, is_opaque));
 264   return CreateCanvas(dev, failureType);
 265 }
 266
 267 // Port of PlatformBitmap to mac
 268
 269 PlatformBitmap::~PlatformBitmap() {
 270   if (surface_)
 271     CGContextRelease(surface_);
 272 }
 273
 274 bool PlatformBitmap::Allocate(int width, int height, bool is_opaque) {
 275   if (RasterDeviceTooBigToAllocate(width, height))
 276     return false;
 277
 278   bitmap_.setConfig(SkBitmap::kARGB_8888_Config, width, height, width * 4,
 279                     is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 280   if (!bitmap_.allocPixels())
 281       return false;
 282
 283   if (!is_opaque)
 284     bitmap_.eraseColor(0);
 285
 286   surface_ = CGContextForData(bitmap_.getPixels(), bitmap_.width(),
 287                               bitmap_.height());
 288   return true;
 289 }
 290
 291 }  // namespace skia