SkBitmapDevice.h revision 4cd9e2169e35cd67ee7358acea6541245e1d1744
1 2/* 3 * Copyright 2013 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9#ifndef SkBitmapDevice_DEFINED 10#define SkBitmapDevice_DEFINED 11 12#include "SkDevice.h" 13 14/////////////////////////////////////////////////////////////////////////////// 15class SK_API SkBitmapDevice : public SkBaseDevice { 16public: 17 SK_DECLARE_INST_COUNT(SkBitmapDevice) 18 19 /** 20 * Construct a new device with the specified bitmap as its backend. It is 21 * valid for the bitmap to have no pixels associated with it. In that case, 22 * any drawing to this device will have no effect. 23 */ 24 SkBitmapDevice(const SkBitmap& bitmap); 25 26 /** 27 * Construct a new device with the specified bitmap as its backend. It is 28 * valid for the bitmap to have no pixels associated with it. In that case, 29 * any drawing to this device will have no effect. 30 */ 31 SkBitmapDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties); 32 33#ifdef SK_SUPPORT_LEGACY_COMPATIBLEDEVICE_CONFIG 34 /** 35 * Create a new raster device and have the pixels be automatically 36 * allocated. The rowBytes of the device will be computed automatically 37 * based on the config and the width. 38 * 39 * @param config The desired config for the pixels. If the request cannot 40 * be met, the closest matching support config will be used. 41 * @param width width (in pixels) of the device 42 * @param height height (in pixels) of the device 43 * @param isOpaque Set to true if it is known that all of the pixels will 44 * be drawn to opaquely. Used as an accelerator when drawing 45 * these pixels to another device. 46 */ 47 SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque = false); 48 49 /** 50 * Create a new raster device and have the pixels be automatically 51 * allocated. The rowBytes of the device will be computed automatically 52 * based on the config and the width. 53 * 54 * @param config The desired config for the pixels. If the request cannot 55 * be met, the closest matching support config will be used. 56 * @param width width (in pixels) of the device 57 * @param height height (in pixels) of the device 58 * @param isOpaque Set to true if it is known that all of the pixels will 59 * be drawn to opaquely. Used as an accelerator when drawing 60 * these pixels to another device. 61 * @param deviceProperties Properties which affect compositing. 62 */ 63 SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque, 64 const SkDeviceProperties& deviceProperties); 65#endif 66 static SkBitmapDevice* Create(const SkImageInfo&, 67 const SkDeviceProperties* = NULL); 68 69 virtual uint32_t getDeviceCapabilities() SK_OVERRIDE { return 0; } 70 71 /** Return the width of the device (in pixels). 72 */ 73 virtual int width() const SK_OVERRIDE { return fBitmap.width(); } 74 /** Return the height of the device (in pixels). 75 */ 76 virtual int height() const SK_OVERRIDE { return fBitmap.height(); } 77 78 /** Returns true if the device's bitmap's config treats every pixels as 79 implicitly opaque. 80 */ 81 virtual bool isOpaque() const SK_OVERRIDE { return fBitmap.isOpaque(); } 82 83 /** Return the bitmap config of the device's pixels 84 */ 85 virtual SkBitmap::Config config() const SK_OVERRIDE { return fBitmap.config(); } 86 87 virtual SkImageInfo imageInfo() const SK_OVERRIDE; 88 89#ifdef SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG 90 /** 91 * DEPRECATED: This will be made protected once WebKit stops using it. 92 * Instead use Canvas' writePixels method. 93 * 94 * Similar to draw sprite, this method will copy the pixels in bitmap onto 95 * the device, with the top/left corner specified by (x, y). The pixel 96 * values in the device are completely replaced: there is no blending. 97 * 98 * Currently if bitmap is backed by a texture this is a no-op. This may be 99 * relaxed in the future. 100 * 101 * If the bitmap has config kARGB_8888_Config then the config8888 param 102 * will determines how the pixel valuess are intepreted. If the bitmap is 103 * not kARGB_8888_Config then this parameter is ignored. 104 */ 105 virtual void writePixels(const SkBitmap& bitmap, int x, int y, 106 SkCanvas::Config8888 config8888) SK_OVERRIDE; 107#endif 108 /** 109 * Return the device's associated gpu render target, or NULL. 110 */ 111 virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE { return NULL; } 112 113protected: 114 /** 115 * Device may filter the text flags for drawing text here. If it wants to 116 * make a change to the specified values, it should write them into the 117 * textflags parameter (output) and return true. If the paint is fine as 118 * is, then ignore the textflags parameter and return false. 119 * 120 * The baseclass SkDevice filters based on its depth and blitters. 121 */ 122 virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE; 123 124 /** Clears the entire device to the specified color (including alpha). 125 * Ignores the clip. 126 */ 127 virtual void clear(SkColor color) SK_OVERRIDE; 128 129 /** These are called inside the per-device-layer loop for each draw call. 130 When these are called, we have already applied any saveLayer operations, 131 and are handling any looping from the paint, and any effects from the 132 DrawFilter. 133 */ 134 virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE; 135 virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count, 136 const SkPoint[], const SkPaint& paint) SK_OVERRIDE; 137 virtual void drawRect(const SkDraw&, const SkRect& r, 138 const SkPaint& paint) SK_OVERRIDE; 139 virtual void drawOval(const SkDraw&, const SkRect& oval, 140 const SkPaint& paint) SK_OVERRIDE; 141 virtual void drawRRect(const SkDraw&, const SkRRect& rr, 142 const SkPaint& paint) SK_OVERRIDE; 143 144 /** 145 * If pathIsMutable, then the implementation is allowed to cast path to a 146 * non-const pointer and modify it in place (as an optimization). Canvas 147 * may do this to implement helpers such as drawOval, by placing a temp 148 * path on the stack to hold the representation of the oval. 149 * 150 * If prePathMatrix is not null, it should logically be applied before any 151 * stroking or other effects. If there are no effects on the paint that 152 * affect the geometry/rasterization, then the pre matrix can just be 153 * pre-concated with the current matrix. 154 */ 155 virtual void drawPath(const SkDraw&, const SkPath& path, 156 const SkPaint& paint, 157 const SkMatrix* prePathMatrix = NULL, 158 bool pathIsMutable = false) SK_OVERRIDE; 159 virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap, 160 const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE; 161 virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap, 162 int x, int y, const SkPaint& paint) SK_OVERRIDE; 163 164 /** 165 * The default impl. will create a bitmap-shader from the bitmap, 166 * and call drawRect with it. 167 */ 168 virtual void drawBitmapRect(const SkDraw&, const SkBitmap&, 169 const SkRect* srcOrNull, const SkRect& dst, 170 const SkPaint& paint, 171 SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE; 172 173 /** 174 * Does not handle text decoration. 175 * Decorations (underline and stike-thru) will be handled by SkCanvas. 176 */ 177 virtual void drawText(const SkDraw&, const void* text, size_t len, 178 SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE; 179 virtual void drawPosText(const SkDraw&, const void* text, size_t len, 180 const SkScalar pos[], SkScalar constY, 181 int scalarsPerPos, const SkPaint& paint) SK_OVERRIDE; 182 virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len, 183 const SkPath& path, const SkMatrix* matrix, 184 const SkPaint& paint) SK_OVERRIDE; 185 virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount, 186 const SkPoint verts[], const SkPoint texs[], 187 const SkColor colors[], SkXfermode* xmode, 188 const uint16_t indices[], int indexCount, 189 const SkPaint& paint) SK_OVERRIDE; 190 /** The SkBaseDevice passed will be an SkBaseDevice which was returned by a call to 191 onCreateDevice on this device with kSaveLayer_Usage. 192 */ 193 virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, 194 const SkPaint&) SK_OVERRIDE; 195 196 /////////////////////////////////////////////////////////////////////////// 197 198 /** Update as needed the pixel value in the bitmap, so that the caller can 199 access the pixels directly. Note: only the pixels field should be 200 altered. The config/width/height/rowbytes must remain unchanged. 201 @return the device contents as a bitmap 202 */ 203 virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE; 204 205 SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); } 206 // just for subclasses, to assign a custom pixelref 207 SkPixelRef* setPixelRef(SkPixelRef* pr) { 208 fBitmap.setPixelRef(pr); 209 return pr; 210 } 211 212 /** 213 * Implements readPixels API. The caller will ensure that: 214 * 1. bitmap has pixel config kARGB_8888_Config. 215 * 2. bitmap has pixels. 216 * 3. The rectangle (x, y, x + bitmap->width(), y + bitmap->height()) is 217 * contained in the device bounds. 218 */ 219 virtual bool onReadPixels(const SkBitmap&, int x, int y, SkCanvas::Config8888) SK_OVERRIDE; 220 virtual bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) SK_OVERRIDE; 221 222 /** Called when this device is installed into a Canvas. Balanced by a call 223 to unlockPixels() when the device is removed from a Canvas. 224 */ 225 virtual void lockPixels() SK_OVERRIDE; 226 virtual void unlockPixels() SK_OVERRIDE; 227 228 /** 229 * Returns true if the device allows processing of this imagefilter. If 230 * false is returned, then the filter is ignored. This may happen for 231 * some subclasses that do not support pixel manipulations after drawing 232 * has occurred (e.g. printing). The default implementation returns true. 233 */ 234 virtual bool allowImageFilter(const SkImageFilter*) SK_OVERRIDE; 235 236 /** 237 * Override and return true for filters that the device can handle 238 * intrinsically. Doing so means that SkCanvas will pass-through this 239 * filter to drawSprite and drawDevice (and potentially filterImage). 240 * Returning false means the SkCanvas will have apply the filter itself, 241 * and just pass the resulting image to the device. 242 */ 243 virtual bool canHandleImageFilter(const SkImageFilter*) SK_OVERRIDE; 244 245 /** 246 * Related (but not required) to canHandleImageFilter, this method returns 247 * true if the device could apply the filter to the src bitmap and return 248 * the result (and updates offset as needed). 249 * If the device does not recognize or support this filter, 250 * it just returns false and leaves result and offset unchanged. 251 */ 252 virtual bool filterImage(const SkImageFilter*, const SkBitmap&, const SkMatrix&, 253 SkBitmap* result, SkIPoint* offset) SK_OVERRIDE; 254 255private: 256 friend class SkCanvas; 257 friend struct DeviceCM; //for setMatrixClip 258 friend class SkDraw; 259 friend class SkDrawIter; 260 friend class SkDeviceFilteredPaint; 261 friend class SkDeviceImageFilterProxy; 262 263 friend class SkSurface_Raster; 264 265 // used to change the backend's pixels (and possibly config/rowbytes) 266 // but cannot change the width/height, so there should be no change to 267 // any clip information. 268 virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE; 269 270#ifdef SK_SUPPORT_LEGACY_COMPATIBLEDEVICE_CONFIG 271 // in support of legacy constructors 272 void init(SkBitmap::Config config, int width, int height, bool isOpaque); 273#endif 274 275 virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE; 276 277 /** Causes any deferred drawing to the device to be completed. 278 */ 279 virtual void flush() SK_OVERRIDE {} 280 281 virtual SkSurface* newSurface(const SkImageInfo&) SK_OVERRIDE; 282 virtual const void* peekPixels(SkImageInfo*, size_t* rowBytes) SK_OVERRIDE; 283 284 SkBitmap fBitmap; 285 286 typedef SkBaseDevice INHERITED; 287}; 288 289#endif // SkBitmapDevice_DEFINED 290