src/third_party/skia/include/core/SkBitmapDevice.h

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