1 /* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkBitmapDevice_DEFINED 9 #define SkBitmapDevice_DEFINED 10 11 #include "include/core/SkBitmap.h" 12 #include "include/core/SkBlurTypes.h" 13 #include "include/core/SkCanvas.h" 14 #include "include/core/SkColor.h" 15 #include "include/core/SkImageInfo.h" 16 #include "include/core/SkRect.h" 17 #include "include/core/SkScalar.h" 18 #include "include/core/SkSize.h" 19 #include "include/core/SkSurfaceProps.h" 20 #include "src/core/SkDevice.h" 21 #include "src/core/SkGlyphRunPainter.h" 22 #include "src/core/SkRasterClip.h" 23 #include "src/core/SkRasterClipStack.h" 24 25 class SkImageFilterCache; 26 class SkMatrix; 27 class SkPaint; 28 class SkPath; 29 class SkPixmap; 30 class SkRasterHandleAllocator; 31 class SkRRect; 32 class SkSurface; 33 struct SkPoint; 34 35 /////////////////////////////////////////////////////////////////////////////// 36 class SkBitmapDevice : public SkBaseDevice { 37 public: 38 /** 39 * Construct a new device with the specified bitmap as its backend. It is 40 * valid for the bitmap to have no pixels associated with it. In that case, 41 * any drawing to this device will have no effect. 42 */ 43 SkBitmapDevice(const SkBitmap& bitmap); 44 45 /** 46 * Create a new device along with its requisite pixel memory using 47 * default SkSurfaceProps (i.e., kLegacyFontHost_InitType-style). 48 * Note: this entry point is slated for removal - no one should call it. 49 */ 50 static SkBitmapDevice* Create(const SkImageInfo& info); 51 52 /** 53 * Construct a new device with the specified bitmap as its backend. It is 54 * valid for the bitmap to have no pixels associated with it. In that case, 55 * any drawing to this device will have no effect. 56 */ 57 SkBitmapDevice(const SkBitmap& bitmap, const SkSurfaceProps& surfaceProps, 58 void* externalHandle, const SkBitmap* coverage); 59 60 static SkBitmapDevice* Create(const SkImageInfo&, const SkSurfaceProps&, 61 bool trackCoverage, 62 SkRasterHandleAllocator*); 63 Create(const SkImageInfo & info,const SkSurfaceProps & props)64 static SkBitmapDevice* Create(const SkImageInfo& info, const SkSurfaceProps& props) { 65 return Create(info, props, false, nullptr); 66 } 67 accessCoverage()68 const SkPixmap* accessCoverage() const { 69 return fCoverage ? &fCoverage->pixmap() : nullptr; 70 } 71 72 protected: getRasterHandle()73 void* getRasterHandle() const override { return fRasterHandle; } 74 75 /** These are called inside the per-device-layer loop for each draw call. 76 When these are called, we have already applied any saveLayer operations, 77 and are handling any looping from the paint. 78 */ 79 void drawPaint(const SkPaint& paint) override; 80 void drawPoints(SkCanvas::PointMode mode, size_t count, 81 const SkPoint[], const SkPaint& paint) override; 82 void drawRect(const SkRect& r, const SkPaint& paint) override; 83 void drawOval(const SkRect& oval, const SkPaint& paint) override; 84 void drawRRect(const SkRRect& rr, const SkPaint& paint) override; 85 86 /** 87 * If pathIsMutable, then the implementation is allowed to cast path to a 88 * non-const pointer and modify it in place (as an optimization). Canvas 89 * may do this to implement helpers such as drawOval, by placing a temp 90 * path on the stack to hold the representation of the oval. 91 */ 92 void drawPath(const SkPath&, const SkPaint&, bool pathIsMutable) override; 93 94 void drawImageRect(const SkImage*, const SkRect* src, const SkRect& dst, 95 const SkSamplingOptions&, const SkPaint&, 96 SkCanvas::SrcRectConstraint) override; 97 98 void drawVertices(const SkVertices*, SkBlendMode, const SkPaint&) override; 99 void drawAtlas(const SkRSXform[], const SkRect[], const SkColor[], int count, SkBlendMode, 100 const SkPaint&) override; 101 102 /////////////////////////////////////////////////////////////////////////// 103 104 void drawDevice(SkBaseDevice*, const SkSamplingOptions&, const SkPaint&) override; 105 void drawSpecial(SkSpecialImage*, const SkMatrix&, const SkSamplingOptions&, 106 const SkPaint&) override; 107 108 sk_sp<SkSpecialImage> makeSpecial(const SkBitmap&) override; 109 sk_sp<SkSpecialImage> makeSpecial(const SkImage*) override; 110 sk_sp<SkSpecialImage> snapSpecial(const SkIRect&, bool = false) override; setImmutable()111 void setImmutable() override { fBitmap.setImmutable(); } 112 113 /////////////////////////////////////////////////////////////////////////// 114 115 void onDrawGlyphRunList(const SkGlyphRunList& glyphRunList, const SkPaint& paint) override; 116 bool onReadPixels(const SkPixmap&, int x, int y) override; 117 bool onWritePixels(const SkPixmap&, int, int) override; 118 bool onPeekPixels(SkPixmap*) override; 119 bool onAccessPixels(SkPixmap*) override; 120 121 void onSave() override; 122 void onRestore() override; 123 void onClipRect(const SkRect& rect, SkClipOp, bool aa) override; 124 void onClipRRect(const SkRRect& rrect, SkClipOp, bool aa) override; 125 void onClipPath(const SkPath& path, SkClipOp, bool aa) override; 126 void onClipShader(sk_sp<SkShader>) override; 127 void onClipRegion(const SkRegion& deviceRgn, SkClipOp) override; 128 void onReplaceClip(const SkIRect& rect) override; 129 bool onClipIsAA() const override; 130 bool onClipIsWideOpen() const override; 131 void onAsRgnClip(SkRegion*) const override; 132 void validateDevBounds(const SkIRect& r) override; 133 ClipType onGetClipType() const override; 134 SkIRect onDevClipBounds() const override; 135 136 void drawBitmap(const SkBitmap&, const SkMatrix&, const SkRect* dstOrNull, 137 const SkSamplingOptions&, const SkPaint&); 138 drawBlurImage(const SkImage * image,const SkBlurArg & blurArg)139 bool drawBlurImage(const SkImage* image, const SkBlurArg& blurArg) override { return false; } 140 141 private: 142 friend class SkCanvas; 143 friend class SkDraw; 144 friend class SkDrawTiler; 145 friend class SkSurface_Raster; 146 147 class BDDraw; 148 149 // used to change the backend's pixels (and possibly config/rowbytes) 150 // but cannot change the width/height, so there should be no change to 151 // any clip information. 152 void replaceBitmapBackendForRasterSurface(const SkBitmap&) override; 153 154 SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override; 155 156 sk_sp<SkSurface> makeSurface(const SkImageInfo&, const SkSurfaceProps&) override; 157 158 SkImageFilterCache* getImageFilterCache() override; 159 160 SkBitmap fBitmap; 161 void* fRasterHandle = nullptr; 162 SkRasterClipStack fRCStack; 163 std::unique_ptr<SkBitmap> fCoverage; // if non-null, will have the same dimensions as fBitmap 164 SkGlyphRunListPainter fGlyphPainter; 165 166 167 using INHERITED = SkBaseDevice; 168 }; 169 170 class SkBitmapDeviceFilteredSurfaceProps { 171 public: SkBitmapDeviceFilteredSurfaceProps(const SkBitmap & bitmap,const SkPaint & paint,const SkSurfaceProps & surfaceProps)172 SkBitmapDeviceFilteredSurfaceProps(const SkBitmap& bitmap, const SkPaint& paint, 173 const SkSurfaceProps& surfaceProps) 174 : fSurfaceProps((kN32_SkColorType != bitmap.colorType() || !paint.isSrcOver()) 175 ? fLazy.init(surfaceProps.flags(), kUnknown_SkPixelGeometry) 176 : &surfaceProps) 177 { } 178 179 SkBitmapDeviceFilteredSurfaceProps(const SkBitmapDeviceFilteredSurfaceProps&) = delete; 180 SkBitmapDeviceFilteredSurfaceProps& operator=(const SkBitmapDeviceFilteredSurfaceProps&) = delete; 181 SkBitmapDeviceFilteredSurfaceProps(SkBitmapDeviceFilteredSurfaceProps&&) = delete; 182 SkBitmapDeviceFilteredSurfaceProps& operator=(SkBitmapDeviceFilteredSurfaceProps&&) = delete; 183 operator()184 const SkSurfaceProps& operator()() const { return *fSurfaceProps; } 185 186 private: 187 SkTLazy<SkSurfaceProps> fLazy; 188 SkSurfaceProps const * const fSurfaceProps; 189 }; 190 191 #endif // SkBitmapDevice_DEFINED 192