Make filters use SkImage instead of SkBitmap

src/utils/SkDeferredCanvas.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDeferredCanvas.h"
 
 #include "SkBitmapDevice.h"
 #include "SkChunkAlloc.h"
 #include "SkColorFilter.h"
 #include "SkDrawFilter.h"
 #include "SkGPipe.h"
+#include "SkImage_Base.h"
 #include "SkPaint.h"
 #include "SkPaintPriv.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 #include "SkSurface.h"
 
 enum {
     // Deferred canvas will auto-flush when recording reaches this limit
     kDefaultMaxRecordingStorageBytes = 64*1024*1024,
     kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature
 
     kNoSaveLayerIndex = -1,
 };
 
 enum PlaybackMode {
     kNormal_PlaybackMode,
     kSilent_PlaybackMode,
 };
 
-static bool should_draw_immediately(const SkBitmap* bitmap, const SkPaint* paint,
-                                    size_t bitmapSizeThreshold) {
-    if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) ||
-        (bitmap->getSize() > bitmapSizeThreshold))) {
-        return true;
-    }
+static bool should_draw_immediately(const SkPaint* paint) {
     if (paint) {
         SkShader* shader = paint->getShader();
         // Here we detect the case where the shader is an SkBitmapProcShader
         // with a gpu texture attached.  Checking this without RTTI
         // requires making the assumption that only gradient shaders
         // and SkBitmapProcShader implement asABitmap().  The following
         // code may need to be revised if that assumption is ever broken.
         if (shader && !shader->asAGradient(NULL)) {
             SkBitmap bm;
             if (shader->asABitmap(&bm, NULL, NULL) &&
                 bm.getTexture()) {
                 return true;
             }
         }
     }
     return false;
 }
 
+static bool should_draw_immediately(const SkBitmap* bitmap, const SkPaint* paint,
+                                    size_t bitmapSizeThreshold) {
+    if ((bitmap->getTexture() && !bitmap->isImmutable()) ||
+        (bitmap->getSize() > bitmapSizeThreshold)) {
+        return true;
+    }
+    return should_draw_immediately(paint);
+}
+
+static bool should_draw_immediately(const SkImage* image, const SkPaint* paint,
+                                    size_t bitmapSizeThreshold) {
+    SkASSERT(image);
+    if (as_IB(image)->getSize() > bitmapSizeThreshold) {
+        return true;
+    }
+    return should_draw_immediately(paint);
+}
+
+
 //-----------------------------------------------------------------------------
 // DeferredPipeController
 //-----------------------------------------------------------------------------
 
 class DeferredPipeController : public SkGPipeController {
 public:
     DeferredPipeController();
     void setPlaybackCanvas(SkCanvas*);
     virtual ~DeferredPipeController();
     void* requestBlock(size_t minRequest, size_t* actual) SK_OVERRIDE;
@@ skipping 126 matching lines @@
     virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
                             const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE
         {SkASSERT(0);}
     virtual void drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect*,
                                 const SkRect&, const SkPaint&,
                                 SkCanvas::DrawBitmapRectFlags) SK_OVERRIDE
         {SkASSERT(0);}
     virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
                             int x, int y, const SkPaint& paint) SK_OVERRIDE
         {SkASSERT(0);}
+    virtual void drawSprite(const SkDraw&, const SkImage& image,
+                            int x, int y, const SkPaint& paint) SK_OVERRIDE
+        {SkASSERT(0);}
     virtual void drawText(const SkDraw&, const void* text, size_t len,
                             SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE
         {SkASSERT(0);}
     virtual void drawPosText(const SkDraw&, const void* text, size_t len,
                              const SkScalar pos[], int scalarsPerPos,
                              const SkPoint& offset, const SkPaint& paint) SK_OVERRIDE
         {SkASSERT(0);}
     virtual void drawTextOnPath(const SkDraw&, const void* text,
                                 size_t len, const SkPath& path,
                                 const SkMatrix* matrix,
@@ skipping 15 matching lines @@
 
     void lockPixels() SK_OVERRIDE {}
     void unlockPixels() SK_OVERRIDE {}
 
     bool allowImageFilter(const SkImageFilter*) SK_OVERRIDE {
         return false;
     }
     bool canHandleImageFilter(const SkImageFilter*) SK_OVERRIDE {
         return false;
     }
-    virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
-                             const SkImageFilter::Context&, SkBitmap*, SkIPoint*) SK_OVERRIDE {
+    virtual bool filterImage(const SkImageFilter*, const SkImage*,
+                             const SkImageFilter::Context&,
+                             SkAutoTUnref<const SkImage>&, SkIPoint*) SK_OVERRIDE {
         return false;
     }
 
 private:
     void flush() SK_OVERRIDE;
     void replaceBitmapBackend(const SkBitmap&) SK_OVERRIDE {}
 
     void beginRecording();
     void init();
     void aboutToDraw();
@@ skipping 221 matching lines @@
 
 bool SkDeferredDevice::onReadPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
                                     int x, int y) {
     this->flushPendingCommands(kNormal_PlaybackMode);
     return fImmediateCanvas->readPixels(info, pixels, rowBytes, x, y);
 }
 
 class AutoImmediateDrawIfNeeded {
 public:
     AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap,
-                              const SkPaint* paint) {
-        this->init(canvas, bitmap, paint);
+                              const SkPaint* paint)
+        : fCanvas(NULL) {
+        if (canvas.isDeferredDrawing() &&
+            should_draw_immediately(bitmap, paint, canvas.getBitmapSizeThreshold())) {
+            fCanvas = &canvas;
+        }
+        this->init();
     }
 
-    AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) {
-        this->init(canvas, NULL, paint);
+    AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkImage* image,
+                              const SkPaint* paint)
+        : fCanvas(NULL) {
+        if (canvas.isDeferredDrawing() &&
+            should_draw_immediately(image, paint, canvas.getBitmapSizeThreshold())) {
+            fCanvas = &canvas;
+        }
+        this->init();
+    }
+
+    AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint)
+        : fCanvas(NULL) {
+        if (canvas.isDeferredDrawing() && should_draw_immediately(paint)) {
+            fCanvas = &canvas;
+        }
+        this->init();
     }
 
     ~AutoImmediateDrawIfNeeded() {
         if (fCanvas) {
             fCanvas->setDeferredDrawing(true);
         }
     }
 private:
-    void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* paint) {
-        if (canvas.isDeferredDrawing() &&
-            should_draw_immediately(bitmap, paint, canvas.getBitmapSizeThreshold())) {
-            canvas.setDeferredDrawing(false);
-            fCanvas = &canvas;
-        } else {
-            fCanvas = NULL;
+    void init() {
+        if (fCanvas) {
+            fCanvas->setDeferredDrawing(false);
         }
     }
 
     SkDeferredCanvas* fCanvas;
 };
 
 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) {
     SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, (surface)));
     return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
 }
@@ skipping 343 matching lines @@
         this->isFullFrame(&bitmapRect, paint) &&
         isPaintOpaque(paint, &bitmap)) {
         this->getDeferredDevice()->skipPendingCommands();
     }
 
     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
     this->drawingCanvas()->drawSprite(bitmap, left, top, paint);
     this->recordedDrawCommand();
 }
 
+void SkDeferredCanvas::onDrawSprite(const SkImage& image, int left, int top,
+                                    const SkPaint* paint) {
+    SkRect imageRect = SkRect::MakeXYWH(
+        SkIntToScalar(left),
+        SkIntToScalar(top),
+        SkIntToScalar(image.width()),
+        SkIntToScalar(image.height()));
+    if (fDeferredDrawing &&
+        this->isFullFrame(&imageRect, paint) &&
+        isPaintOpaque(paint, &image)) {
+        this->getDeferredDevice()->skipPendingCommands();
+    }
+
+    AutoImmediateDrawIfNeeded autoDraw(*this, &image, paint);
+    this->drawingCanvas()->drawSprite(image, left, top, paint);
+    this->recordedDrawCommand();
+}
+
 void SkDeferredCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                   const SkPaint& paint) {
     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
     this->drawingCanvas()->drawText(text, byteLength, x, y, paint);
     this->recordedDrawCommand();
 }
 
 void SkDeferredCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                      const SkPaint& paint) {
     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
@@ skipping 51 matching lines @@
 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
     this->drawingCanvas()->setDrawFilter(filter);
     this->INHERITED::setDrawFilter(filter);
     this->recordedDrawCommand();
     return filter;
 }
 
 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
     return this->drawingCanvas();
 }