OLD | NEW |
---|---|
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2013 Google Inc. | 3 * Copyright 2013 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #include "SkDeferredCanvas.h" | 9 #include "SkDeferredCanvas.h" |
10 | 10 |
(...skipping 11 matching lines...) Expand all Loading... | |
22 enum { | 22 enum { |
23 // Deferred canvas will auto-flush when recording reaches this limit | 23 // Deferred canvas will auto-flush when recording reaches this limit |
24 kDefaultMaxRecordingStorageBytes = 64*1024*1024, | 24 kDefaultMaxRecordingStorageBytes = 64*1024*1024, |
25 kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature | 25 kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature |
26 }; | 26 }; |
27 | 27 |
28 enum PlaybackMode { | 28 enum PlaybackMode { |
29 kNormal_PlaybackMode, | 29 kNormal_PlaybackMode, |
30 kSilent_PlaybackMode, | 30 kSilent_PlaybackMode, |
31 }; | 31 }; |
32 | 32 |
robertphillips
2014/06/30 13:36:20
should_draw_immediately ?
reed1
2014/06/30 14:33:12
Done.
| |
33 static bool shouldDrawImmediately(const SkBitmap* bitmap, const SkPaint* paint, | 33 static bool shouldDrawImmediately(const SkBitmap* bitmap, const SkPaint* paint, |
34 size_t bitmapSizeThreshold) { | 34 size_t bitmapSizeThreshold) { |
35 if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) || | 35 if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) || |
36 (bitmap->getSize() > bitmapSizeThreshold))) { | 36 (bitmap->getSize() > bitmapSizeThreshold))) { |
37 return true; | 37 return true; |
38 } | 38 } |
39 if (paint) { | 39 if (paint) { |
40 SkShader* shader = paint->getShader(); | 40 SkShader* shader = paint->getShader(); |
41 // Here we detect the case where the shader is an SkBitmapProcShader | 41 // Here we detect the case where the shader is an SkBitmapProcShader |
42 // with a gpu texture attached. Checking this without RTTI | 42 // with a gpu texture attached. Checking this without RTTI |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
143 void setNotificationClient(SkDeferredCanvas::NotificationClient* notificatio nClient); | 143 void setNotificationClient(SkDeferredCanvas::NotificationClient* notificatio nClient); |
144 SkCanvas* recordingCanvas(); | 144 SkCanvas* recordingCanvas(); |
145 SkCanvas* immediateCanvas() const {return fImmediateCanvas;} | 145 SkCanvas* immediateCanvas() const {return fImmediateCanvas;} |
146 SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice ();} | 146 SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice ();} |
147 SkImage* newImageSnapshot(); | 147 SkImage* newImageSnapshot(); |
148 void setSurface(SkSurface* surface); | 148 void setSurface(SkSurface* surface); |
149 bool isFreshFrame(); | 149 bool isFreshFrame(); |
150 bool hasPendingCommands(); | 150 bool hasPendingCommands(); |
151 size_t storageAllocatedForRecording() const; | 151 size_t storageAllocatedForRecording() const; |
152 size_t freeMemoryIfPossible(size_t bytesToFree); | 152 size_t freeMemoryIfPossible(size_t bytesToFree); |
153 size_t getBitmapSizeThreshold() const; | |
154 void setBitmapSizeThreshold(size_t sizeThreshold); | |
155 void flushPendingCommands(PlaybackMode); | 153 void flushPendingCommands(PlaybackMode); |
156 void skipPendingCommands(); | 154 void skipPendingCommands(); |
157 void setMaxRecordingStorage(size_t); | 155 void setMaxRecordingStorage(size_t); |
158 void recordedDrawCommand(); | 156 void recordedDrawCommand(); |
159 | 157 |
160 virtual SkImageInfo imageInfo() const SK_OVERRIDE; | 158 virtual SkImageInfo imageInfo() const SK_OVERRIDE; |
161 | 159 |
162 virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE; | 160 virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE; |
163 | 161 |
164 virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE; | 162 virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE; |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
256 DeferredPipeController fPipeController; | 254 DeferredPipeController fPipeController; |
257 SkGPipeWriter fPipeWriter; | 255 SkGPipeWriter fPipeWriter; |
258 SkCanvas* fImmediateCanvas; | 256 SkCanvas* fImmediateCanvas; |
259 SkCanvas* fRecordingCanvas; | 257 SkCanvas* fRecordingCanvas; |
260 SkSurface* fSurface; | 258 SkSurface* fSurface; |
261 SkDeferredCanvas::NotificationClient* fNotificationClient; | 259 SkDeferredCanvas::NotificationClient* fNotificationClient; |
262 bool fFreshFrame; | 260 bool fFreshFrame; |
263 bool fCanDiscardCanvasContents; | 261 bool fCanDiscardCanvasContents; |
264 size_t fMaxRecordingStorageBytes; | 262 size_t fMaxRecordingStorageBytes; |
265 size_t fPreviousStorageAllocated; | 263 size_t fPreviousStorageAllocated; |
266 size_t fBitmapSizeThreshold; | |
267 }; | 264 }; |
268 | 265 |
269 SkDeferredDevice::SkDeferredDevice(SkSurface* surface) { | 266 SkDeferredDevice::SkDeferredDevice(SkSurface* surface) { |
270 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; | 267 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; |
271 fNotificationClient = NULL; | 268 fNotificationClient = NULL; |
272 fImmediateCanvas = NULL; | 269 fImmediateCanvas = NULL; |
273 fSurface = NULL; | 270 fSurface = NULL; |
274 this->setSurface(surface); | 271 this->setSurface(surface); |
275 this->init(); | 272 this->init(); |
276 } | 273 } |
277 | 274 |
278 void SkDeferredDevice::setSurface(SkSurface* surface) { | 275 void SkDeferredDevice::setSurface(SkSurface* surface) { |
279 SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas()); | 276 SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas()); |
280 SkRefCnt_SafeAssign(fSurface, surface); | 277 SkRefCnt_SafeAssign(fSurface, surface); |
281 fPipeController.setPlaybackCanvas(fImmediateCanvas); | 278 fPipeController.setPlaybackCanvas(fImmediateCanvas); |
282 } | 279 } |
283 | 280 |
284 void SkDeferredDevice::init() { | 281 void SkDeferredDevice::init() { |
285 fRecordingCanvas = NULL; | 282 fRecordingCanvas = NULL; |
286 fFreshFrame = true; | 283 fFreshFrame = true; |
287 fCanDiscardCanvasContents = false; | 284 fCanDiscardCanvasContents = false; |
288 fPreviousStorageAllocated = 0; | 285 fPreviousStorageAllocated = 0; |
289 fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold; | |
290 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; | 286 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; |
291 fNotificationClient = NULL; | 287 fNotificationClient = NULL; |
292 this->beginRecording(); | 288 this->beginRecording(); |
293 } | 289 } |
294 | 290 |
295 SkDeferredDevice::~SkDeferredDevice() { | 291 SkDeferredDevice::~SkDeferredDevice() { |
296 this->flushPendingCommands(kSilent_PlaybackMode); | 292 this->flushPendingCommands(kSilent_PlaybackMode); |
297 SkSafeUnref(fImmediateCanvas); | 293 SkSafeUnref(fImmediateCanvas); |
298 SkSafeUnref(fSurface); | 294 SkSafeUnref(fSurface); |
299 } | 295 } |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
371 this->flushPendingCommands(kNormal_PlaybackMode); | 367 this->flushPendingCommands(kNormal_PlaybackMode); |
372 fImmediateCanvas->flush(); | 368 fImmediateCanvas->flush(); |
373 } | 369 } |
374 | 370 |
375 size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) { | 371 size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) { |
376 size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree); | 372 size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree); |
377 fPreviousStorageAllocated = storageAllocatedForRecording(); | 373 fPreviousStorageAllocated = storageAllocatedForRecording(); |
378 return val; | 374 return val; |
379 } | 375 } |
380 | 376 |
381 size_t SkDeferredDevice::getBitmapSizeThreshold() const { | |
382 return fBitmapSizeThreshold; | |
383 } | |
384 | |
385 void SkDeferredDevice::setBitmapSizeThreshold(size_t sizeThreshold) { | |
386 fBitmapSizeThreshold = sizeThreshold; | |
387 } | |
388 | |
389 size_t SkDeferredDevice::storageAllocatedForRecording() const { | 377 size_t SkDeferredDevice::storageAllocatedForRecording() const { |
390 return (fPipeController.storageAllocatedForRecording() | 378 return (fPipeController.storageAllocatedForRecording() |
391 + fPipeWriter.storageAllocatedForRecording()); | 379 + fPipeWriter.storageAllocatedForRecording()); |
392 } | 380 } |
393 | 381 |
394 void SkDeferredDevice::recordedDrawCommand() { | 382 void SkDeferredDevice::recordedDrawCommand() { |
395 size_t storageAllocated = this->storageAllocatedForRecording(); | 383 size_t storageAllocated = this->storageAllocatedForRecording(); |
396 | 384 |
397 if (storageAllocated > fMaxRecordingStorageBytes) { | 385 if (storageAllocated > fMaxRecordingStorageBytes) { |
398 // First, attempt to reduce cache without flushing | 386 // First, attempt to reduce cache without flushing |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
502 AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) { | 490 AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) { |
503 this->init(canvas, NULL, paint); | 491 this->init(canvas, NULL, paint); |
504 } | 492 } |
505 | 493 |
506 ~AutoImmediateDrawIfNeeded() { | 494 ~AutoImmediateDrawIfNeeded() { |
507 if (fCanvas) { | 495 if (fCanvas) { |
508 fCanvas->setDeferredDrawing(true); | 496 fCanvas->setDeferredDrawing(true); |
509 } | 497 } |
510 } | 498 } |
511 private: | 499 private: |
512 void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* p aint) | 500 void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* p aint) { |
513 { | 501 if (canvas.isDeferredDrawing() && |
514 SkDeferredDevice* device = static_cast<SkDeferredDevice*>(canvas.getDevi ce()); | 502 shouldDrawImmediately(bitmap, paint, canvas.getBitmapSizeThreshold() )) { |
515 if (canvas.isDeferredDrawing() && (NULL != device) && | |
516 shouldDrawImmediately(bitmap, paint, device->getBitmapSizeThreshold( ))) { | |
517 canvas.setDeferredDrawing(false); | 503 canvas.setDeferredDrawing(false); |
518 fCanvas = &canvas; | 504 fCanvas = &canvas; |
519 } else { | 505 } else { |
520 fCanvas = NULL; | 506 fCanvas = NULL; |
521 } | 507 } |
522 } | 508 } |
523 | 509 |
524 SkDeferredCanvas* fCanvas; | 510 SkDeferredCanvas* fCanvas; |
525 }; | 511 }; |
526 | 512 |
527 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) { | 513 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) { |
528 SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, ( surface))); | 514 SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, ( surface))); |
529 return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice)); | 515 return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice)); |
530 } | 516 } |
531 | 517 |
532 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) { | 518 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) { |
533 this->init(); | 519 this->init(); |
534 } | 520 } |
535 | 521 |
536 void SkDeferredCanvas::init() { | 522 void SkDeferredCanvas::init() { |
523 fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold; | |
537 fDeferredDrawing = true; // On by default | 524 fDeferredDrawing = true; // On by default |
538 } | 525 } |
539 | 526 |
540 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) { | 527 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) { |
541 this->validate(); | 528 this->validate(); |
542 this->getDeferredDevice()->setMaxRecordingStorage(maxStorage); | 529 this->getDeferredDevice()->setMaxRecordingStorage(maxStorage); |
543 } | 530 } |
544 | 531 |
545 size_t SkDeferredCanvas::storageAllocatedForRecording() const { | 532 size_t SkDeferredCanvas::storageAllocatedForRecording() const { |
546 return this->getDeferredDevice()->storageAllocatedForRecording(); | 533 return this->getDeferredDevice()->storageAllocatedForRecording(); |
547 } | 534 } |
548 | 535 |
549 size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) { | 536 size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) { |
550 return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree); | 537 return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree); |
551 } | 538 } |
552 | 539 |
553 void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) { | 540 void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) { |
554 SkDeferredDevice* deferredDevice = this->getDeferredDevice(); | 541 fBitmapSizeThreshold = sizeThreshold; |
555 SkASSERT(deferredDevice); | |
556 deferredDevice->setBitmapSizeThreshold(sizeThreshold); | |
557 } | 542 } |
558 | 543 |
559 void SkDeferredCanvas::recordedDrawCommand() { | 544 void SkDeferredCanvas::recordedDrawCommand() { |
560 if (fDeferredDrawing) { | 545 if (fDeferredDrawing) { |
561 this->getDeferredDevice()->recordedDrawCommand(); | 546 this->getDeferredDevice()->recordedDrawCommand(); |
562 } | 547 } |
563 } | 548 } |
564 | 549 |
565 void SkDeferredCanvas::validate() const { | 550 void SkDeferredCanvas::validate() const { |
566 SkASSERT(this->getDevice()); | 551 SkASSERT(this->getDevice()); |
(...skipping 365 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
932 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) { | 917 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) { |
933 this->drawingCanvas()->setDrawFilter(filter); | 918 this->drawingCanvas()->setDrawFilter(filter); |
934 this->INHERITED::setDrawFilter(filter); | 919 this->INHERITED::setDrawFilter(filter); |
935 this->recordedDrawCommand(); | 920 this->recordedDrawCommand(); |
936 return filter; | 921 return filter; |
937 } | 922 } |
938 | 923 |
939 SkCanvas* SkDeferredCanvas::canvasForDrawIter() { | 924 SkCanvas* SkDeferredCanvas::canvasForDrawIter() { |
940 return this->drawingCanvas(); | 925 return this->drawingCanvas(); |
941 } | 926 } |
OLD | NEW |