Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(79)

Side by Side Diff: src/core/SkSpecialImage.cpp

Issue 1705113002: Update SkSpecialImage API (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Add missing files Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 /* 1 /*
2 * Copyright 2016 Google Inc. 2 * Copyright 2016 Google Inc.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license that can be 4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file 5 * found in the LICENSE file
6 */ 6 */
7 7
8 #include "SkCanvas.h" 8 #include "SkCanvas.h"
9 #include "SkSpecialImage.h" 9 #include "SkSpecialImage.h"
10 #include "SkSpecialSurface.h" 10 #include "SkSpecialSurface.h"
11 11
12 /////////////////////////////////////////////////////////////////////////////// 12 ///////////////////////////////////////////////////////////////////////////////
13 class SkSpecialImage_Base : public SkSpecialImage { 13 class SkSpecialImage_Base : public SkSpecialImage {
14 public: 14 public:
15 SkSpecialImage_Base(const SkIRect& subset) : INHERITED(subset) { } 15 SkSpecialImage_Base(const SkIRect& subset, uint32_t uniqueID) : INHERITED(su bset, uniqueID) {}
16 virtual ~SkSpecialImage_Base() { } 16 virtual ~SkSpecialImage_Base() { }
17 17
18 virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const = 0; 18 virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const = 0;
19 19
20 virtual bool onPeekPixels(SkPixmap*) const { return false; } 20 virtual bool onPeekPixels(SkPixmap*) const { return false; }
21 21
22 virtual GrTexture* onPeekTexture() const { return nullptr; } 22 virtual GrTexture* onPeekTexture() const { return nullptr; }
23 23
24 // Delete this entry point ASAP
25 virtual bool getBitmap(SkBitmap* result) const = 0;
26
24 virtual SkSpecialSurface* onNewSurface(const SkImageInfo& info) const { retu rn nullptr; } 27 virtual SkSpecialSurface* onNewSurface(const SkImageInfo& info) const { retu rn nullptr; }
25 28
26 private: 29 private:
27 typedef SkSpecialImage INHERITED; 30 typedef SkSpecialImage INHERITED;
28 }; 31 };
29 32
30 /////////////////////////////////////////////////////////////////////////////// 33 ///////////////////////////////////////////////////////////////////////////////
31 static inline const SkSpecialImage_Base* as_IB(const SkSpecialImage* image) { 34 static inline const SkSpecialImage_Base* as_IB(const SkSpecialImage* image) {
32 return static_cast<const SkSpecialImage_Base*>(image); 35 return static_cast<const SkSpecialImage_Base*>(image);
33 } 36 }
34 37
35 void SkSpecialImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPain t* paint) const { 38 void SkSpecialImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPain t* paint) const {
36 return as_IB(this)->onDraw(canvas, x, y, paint); 39 return as_IB(this)->onDraw(canvas, x, y, paint);
37 } 40 }
38 41
39 bool SkSpecialImage::peekPixels(SkPixmap* pixmap) const { 42 bool SkSpecialImage::peekPixels(SkPixmap* pixmap) const {
40 return as_IB(this)->onPeekPixels(pixmap); 43 return as_IB(this)->onPeekPixels(pixmap);
41 } 44 }
42 45
43 GrTexture* SkSpecialImage::peekTexture() const { 46 GrTexture* SkSpecialImage::peekTexture() const {
44 return as_IB(this)->onPeekTexture(); 47 return as_IB(this)->onPeekTexture();
45 } 48 }
46 49
47 SkSpecialSurface* SkSpecialImage::newSurface(const SkImageInfo& info) const { 50 SkSpecialSurface* SkSpecialImage::newSurface(const SkImageInfo& info) const {
48 return as_IB(this)->onNewSurface(info); 51 return as_IB(this)->onNewSurface(info);
49 } 52 }
50 53
54 #if SK_SUPPORT_GPU
55 #include "SkGr.h"
56 #include "SkGrPixelRef.h"
57 #endif
58
59 SkSpecialImage* SkSpecialImage::internal_fromBM(const SkBitmap& src) {
60 // Need to test offset case!
61 if (src.getTexture()) {
62 return SkSpecialImage::NewFromGpu(src.bounds(), src.getGenerationID(), s rc.getTexture());
63 }
64
65 return SkSpecialImage::NewFromRaster(src.bounds(), src);
66 }
67
68 bool SkSpecialImage::internal_getBM(SkBitmap* result) {
69 const SkSpecialImage_Base* ib = as_IB(this);
70
71 // TODO: need to test offset case!
72 return ib->getBitmap(result);
73 }
74
75 #include "SkBitmapDevice.h"
76 #if SK_SUPPORT_GPU
77 #include "SkGpuDevice.h"
78 #endif
79
80 SkImageFilter::Proxy* SkSpecialImage::internal_getProxy() {
81 if (fProxy) {
82 SkASSERT(fDevice);
83 return fProxy;
84 }
85
86 const SkImageInfo info = SkImageInfo::MakeN32Premul(16, 16);
87 const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
88
89 #if SK_SUPPORT_GPU
90 if (this->peekTexture()) {
91 GrContext* context = this->peekTexture()->getContext();
92
93 // Youch!
94 fDevice.reset(SkGpuDevice::Create(context, SkSurface::kYes_Budgeted, inf o, 0, &props,
Stephen White 2016/02/17 17:00:02 This doesn't make sense to me. Why do we need to h
robertphillips 2016/02/17 19:10:28 Done.
95 SkGpuDevice::kUninit_InitContents));
96
97 fProxy = new SkImageFilter::DeviceProxy(fDevice);
98 return fProxy;
99 }
100 #endif
101
102 fDevice.reset(SkBitmapDevice::Create(info, props));
103
104 fProxy = new SkImageFilter::DeviceProxy(fDevice);
105 return fProxy;
106 }
107
51 /////////////////////////////////////////////////////////////////////////////// 108 ///////////////////////////////////////////////////////////////////////////////
52 #include "SkImage.h" 109 #include "SkImage.h"
53 #if SK_SUPPORT_GPU 110 #if SK_SUPPORT_GPU
54 #include "SkGr.h"
55 #include "SkGrPriv.h" 111 #include "SkGrPriv.h"
56 #endif 112 #endif
57 113
58 class SkSpecialImage_Image : public SkSpecialImage_Base { 114 class SkSpecialImage_Image : public SkSpecialImage_Base {
59 public: 115 public:
60 SkSpecialImage_Image(const SkIRect& subset, const SkImage* image) 116 SkSpecialImage_Image(const SkIRect& subset, const SkImage* image)
61 : INHERITED(subset) 117 : INHERITED(subset, image->uniqueID())
62 , fImage(SkRef(image)) { 118 , fImage(SkRef(image)) {
63 } 119 }
64 120
65 ~SkSpecialImage_Image() override { } 121 ~SkSpecialImage_Image() override { }
66 122
123 bool isOpaque() const override { return fImage->isOpaque(); }
124
125 size_t getSize() const override {
126 if (fImage->getTexture()) {
127 return fImage->getTexture()->gpuMemorySize();
128 } else {
129 SkImageInfo info;
130 size_t rowBytes;
131
132 if (fImage->peekPixels(&info, &rowBytes)) {
133 return info.height() * rowBytes;
134 }
135 }
136 return 0;
137 }
138
67 void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override { 139 void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
68 SkRect dst = SkRect::MakeXYWH(x, y, this->subset().width(), this->subset ().height()); 140 SkRect dst = SkRect::MakeXYWH(x, y, this->subset().width(), this->subset ().height());
69 141
70 canvas->drawImageRect(fImage, this->subset(), 142 canvas->drawImageRect(fImage, this->subset(),
71 dst, paint, SkCanvas::kStrict_SrcRectConstraint); 143 dst, paint, SkCanvas::kStrict_SrcRectConstraint);
72 } 144 }
73 145
74 bool onPeekPixels(SkPixmap* pixmap) const override { 146 bool onPeekPixels(SkPixmap* pixmap) const override {
75 return fImage->peekPixels(pixmap); 147 return fImage->peekPixels(pixmap);
76 } 148 }
77 149
78 GrTexture* onPeekTexture() const override { return fImage->getTexture(); } 150 GrTexture* onPeekTexture() const override { return fImage->getTexture(); }
79 151
152 bool getBitmap(SkBitmap* result) const override {
153 return false;
154 }
155
80 SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override { 156 SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override {
81 #if SK_SUPPORT_GPU 157 #if SK_SUPPORT_GPU
82 GrTexture* texture = fImage->getTexture(); 158 GrTexture* texture = fImage->getTexture();
83 if (texture) { 159 if (texture) {
84 GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info); 160 GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info);
85 desc.fFlags = kRenderTarget_GrSurfaceFlag; 161 desc.fFlags = kRenderTarget_GrSurfaceFlag;
86 162
87 return SkSpecialSurface::NewRenderTarget(texture->getContext(), desc ); 163 return SkSpecialSurface::NewRenderTarget(texture->getContext(), desc );
88 } 164 }
89 #endif 165 #endif
(...skipping 21 matching lines...) Expand all
111 } 187 }
112 188
113 /////////////////////////////////////////////////////////////////////////////// 189 ///////////////////////////////////////////////////////////////////////////////
114 #include "SkBitmap.h" 190 #include "SkBitmap.h"
115 #include "SkImageInfo.h" 191 #include "SkImageInfo.h"
116 #include "SkPixelRef.h" 192 #include "SkPixelRef.h"
117 193
118 class SkSpecialImage_Raster : public SkSpecialImage_Base { 194 class SkSpecialImage_Raster : public SkSpecialImage_Base {
119 public: 195 public:
120 SkSpecialImage_Raster(const SkIRect& subset, const SkBitmap& bm) 196 SkSpecialImage_Raster(const SkIRect& subset, const SkBitmap& bm)
121 : INHERITED(subset) 197 : INHERITED(subset, bm.getGenerationID())
122 , fBitmap(bm) { 198 , fBitmap(bm) {
123 if (bm.pixelRef()->isPreLocked()) { 199 if (bm.pixelRef()->isPreLocked()) {
124 // we only preemptively lock if there is no chance of triggering som ething expensive 200 // we only preemptively lock if there is no chance of triggering som ething expensive
125 // like a lazy decode or imagegenerator. PreLocked means it is flat pixels already. 201 // like a lazy decode or imagegenerator. PreLocked means it is flat pixels already.
126 fBitmap.lockPixels(); 202 fBitmap.lockPixels();
127 } 203 }
128 } 204 }
129 205
130 ~SkSpecialImage_Raster() override { } 206 ~SkSpecialImage_Raster() override { }
131 207
208 bool isOpaque() const override { return fBitmap.isOpaque(); }
209
210 size_t getSize() const override { return fBitmap.getSize(); }
211
132 void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override { 212 void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
133 SkRect dst = SkRect::MakeXYWH(x, y, 213 SkRect dst = SkRect::MakeXYWH(x, y,
134 this->subset().width(), this->subset().hei ght()); 214 this->subset().width(), this->subset().hei ght());
135 215
136 canvas->drawBitmapRect(fBitmap, this->subset(), 216 canvas->drawBitmapRect(fBitmap, this->subset(),
137 dst, paint, SkCanvas::kStrict_SrcRectConstraint); 217 dst, paint, SkCanvas::kStrict_SrcRectConstraint);
138 } 218 }
139 219
140 bool onPeekPixels(SkPixmap* pixmap) const override { 220 bool onPeekPixels(SkPixmap* pixmap) const override {
141 const SkImageInfo info = fBitmap.info(); 221 const SkImageInfo info = fBitmap.info();
142 if ((kUnknown_SkColorType == info.colorType()) || !fBitmap.getPixels()) { 222 if ((kUnknown_SkColorType == info.colorType()) || !fBitmap.getPixels()) {
143 return false; 223 return false;
144 } 224 }
145 const void* pixels = fBitmap.getPixels(); 225 const void* pixels = fBitmap.getPixels();
146 if (pixels) { 226 if (pixels) {
147 if (pixmap) { 227 if (pixmap) {
148 pixmap->reset(info, pixels, fBitmap.rowBytes()); 228 pixmap->reset(info, pixels, fBitmap.rowBytes());
149 } 229 }
150 return true; 230 return true;
151 } 231 }
152 return false; 232 return false;
153 } 233 }
154 234
235 bool getBitmap(SkBitmap* result) const override {
236 *result = fBitmap;
237 return true;
238 }
239
155 SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override { 240 SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override {
156 return SkSpecialSurface::NewRaster(info, nullptr); 241 return SkSpecialSurface::NewRaster(info, nullptr);
157 } 242 }
158 243
159 private: 244 private:
160 SkBitmap fBitmap; 245 SkBitmap fBitmap;
161 246
162 typedef SkSpecialImage_Base INHERITED; 247 typedef SkSpecialImage_Base INHERITED;
163 }; 248 };
164 249
165 SkSpecialImage* SkSpecialImage::NewFromRaster(const SkIRect& subset, const SkBit map& bm) { 250 SkSpecialImage* SkSpecialImage::NewFromRaster(const SkIRect& subset, const SkBit map& bm) {
166 SkASSERT(nullptr == bm.getTexture()); 251 SkASSERT(nullptr == bm.getTexture());
167 SkASSERT(rect_fits(subset, bm.width(), bm.height())); 252 SkASSERT(rect_fits(subset, bm.width(), bm.height()));
168 return new SkSpecialImage_Raster(subset, bm); 253 return new SkSpecialImage_Raster(subset, bm);
169 } 254 }
170 255
171 #if SK_SUPPORT_GPU 256 #if SK_SUPPORT_GPU
172 /////////////////////////////////////////////////////////////////////////////// 257 ///////////////////////////////////////////////////////////////////////////////
173 #include "GrTexture.h" 258 #include "GrTexture.h"
174 259
175 class SkSpecialImage_Gpu : public SkSpecialImage_Base { 260 class SkSpecialImage_Gpu : public SkSpecialImage_Base {
176 public: 261 public:
177 SkSpecialImage_Gpu(const SkIRect& subset, GrTexture* tex) 262 SkSpecialImage_Gpu(const SkIRect& subset, uint32_t uniqueID, GrTexture* tex, SkAlphaType at)
178 : INHERITED(subset) 263 : INHERITED(subset, uniqueID)
179 , fTexture(SkRef(tex)) { 264 , fTexture(SkRef(tex))
265 , fAlphaType(at) {
180 } 266 }
181 267
182 ~SkSpecialImage_Gpu() override { } 268 ~SkSpecialImage_Gpu() override { }
183 269
270 bool isOpaque() const override {
271 return GrPixelConfigIsOpaque(fTexture->config()) || fAlphaType == kOpaqu e_SkAlphaType;
272 }
273
274 size_t getSize() const override { return fTexture->gpuMemorySize(); }
275
184 void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override { 276 void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
185 SkRect dst = SkRect::MakeXYWH(x, y, 277 SkRect dst = SkRect::MakeXYWH(x, y,
186 this->subset().width(), this->subset().hei ght()); 278 this->subset().width(), this->subset().hei ght());
187 279
188 SkBitmap bm; 280 SkBitmap bm;
189 281
190 static const bool kUnknownOpacity = false;
191 GrWrapTextureInBitmap(fTexture, 282 GrWrapTextureInBitmap(fTexture,
192 fTexture->width(), fTexture->height(), kUnknownOpa city, &bm); 283 fTexture->width(), fTexture->height(), this->isOpa que(), &bm);
193 284
194 canvas->drawBitmapRect(bm, this->subset(), 285 canvas->drawBitmapRect(bm, this->subset(),
195 dst, paint, SkCanvas::kStrict_SrcRectConstraint); 286 dst, paint, SkCanvas::kStrict_SrcRectConstraint);
196 } 287 }
197 288
198 GrTexture* onPeekTexture() const override { return fTexture; } 289 GrTexture* onPeekTexture() const override { return fTexture; }
199 290
291 bool getBitmap(SkBitmap* result) const override {
292 const SkImageInfo info = GrMakeInfoFromTexture(fTexture,
293 this->width(), this->heig ht(),
294 this->isOpaque());
295 if (!result->setInfo(info)) {
296 return false;
297 }
298
299 result->setPixelRef(new SkGrPixelRef(info, fTexture))->unref();
300 return true;
301 }
302
200 SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override { 303 SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override {
201 GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info); 304 GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info);
202 desc.fFlags = kRenderTarget_GrSurfaceFlag; 305 desc.fFlags = kRenderTarget_GrSurfaceFlag;
203 306
204 return SkSpecialSurface::NewRenderTarget(fTexture->getContext(), desc); 307 return SkSpecialSurface::NewRenderTarget(fTexture->getContext(), desc);
205 } 308 }
206 309
207 private: 310 private:
208 SkAutoTUnref<GrTexture> fTexture; 311 SkAutoTUnref<GrTexture> fTexture;
312 const SkAlphaType fAlphaType;
209 313
210 typedef SkSpecialImage_Base INHERITED; 314 typedef SkSpecialImage_Base INHERITED;
211 }; 315 };
212 316
213 SkSpecialImage* SkSpecialImage::NewFromGpu(const SkIRect& subset, GrTexture* tex ) { 317 SkSpecialImage* SkSpecialImage::NewFromGpu(const SkIRect& subset,
318 uint32_t uniqueID,
319 GrTexture* tex,
320 SkAlphaType at) {
214 SkASSERT(rect_fits(subset, tex->width(), tex->height())); 321 SkASSERT(rect_fits(subset, tex->width(), tex->height()));
215 return new SkSpecialImage_Gpu(subset, tex); 322 return new SkSpecialImage_Gpu(subset, uniqueID, tex, at);
216 } 323 }
217 324
218 #else 325 #else
219 326
220 SkSpecialImage* SkSpecialImage::NewFromGpu(const SkIRect& subset, GrTexture* tex ) { 327 SkSpecialImage* SkSpecialImage::NewFromGpu(const SkIRect& subset,
328 uint32_t uniqueID,
329 GrTexture* tex,
330 SkAlphaType at) {
221 return nullptr; 331 return nullptr;
222 } 332 }
223 333
224 #endif 334 #endif
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698