Make filters use SkImage instead of SkBitmap

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkBitmapDevice.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDraw.h"
 #include "SkDrawable.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
+#include "SkImagePriv.h"
 #include "SkImage_Base.h"
 #include "SkMetaData.h"
 #include "SkPathOps.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
 #include "SkRasterClip.h"
 #include "SkReadPixelsRec.h"
 #include "SkRRect.h"
 #include "SkSmallAllocator.h"
 #include "SkSurface_Base.h"
@@ skipping 1077 matching lines @@
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
     while (iter.next()) {
         SkBaseDevice* dstDev = iter.fDevice;
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !dstDev->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(dstDev, fProps);
-            SkBitmap dst;
+            SkAutoTUnref<const SkImage> dst;
             SkIPoint offset = SkIPoint::Make(0, 0);
             SkAutoTUnref<SkImage> src(srcDev->newImageSnapshot());
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
-            SkIRect clipBounds = SkIRect::MakeWH(srcDev->width(), srcDev->height());
+            SkIRect clipBounds = SkIRect::MakeWH(src->width(), src->height());
             SkAutoTUnref<SkImageFilter::Cache> cache(dstDev->getImageFilterCache());
             SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
-            SkBitmap srcBitmap;  // TODO: remove once filters accept SkImage
-#if SK_SUPPORT_GPU
-            // TODO: Gpu devices need bitmap that came from gpu, not through
-            // getROPixels. Remove once filters accept SkImage.
-            if (NULL != src->getTexture()) {
-                SkImageFilter::WrapTexture(src->getTexture(), src->width(), src->height(),
-                                           &srcBitmap);
-            } else
-#endif
-            {
-                as_IB(src)->getROPixels(&srcBitmap);
-            }
-            if (!srcBitmap.empty()) {
-                if (filter->filterImage(&proxy, srcBitmap, ctx, &dst, &offset)) {
-                    SkPaint tmpUnfiltered(*paint);
-                    tmpUnfiltered.setImageFilter(NULL);
-                    dstDev->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
-                                       tmpUnfiltered);
-                }
+            if (filter->filterImage(&proxy, src, ctx, dst, &offset)) {
+                SkPaint tmpUnfiltered(*paint);
+                tmpUnfiltered.setImageFilter(NULL);
+                dstDev->drawSprite(iter, *dst, pos.x() + offset.x(), pos.y() + offset.y(),
+                                   tmpUnfiltered);
             }
         } else {
             dstDev->drawDevice(iter, srcDev, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 void SkCanvas::onDrawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint* paint) {
     if (gTreatSpriteAsBitmap) {
@@ skipping 16 matching lines @@
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
 
     while (iter.next()) {
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !iter.fDevice->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(iter.fDevice, fProps);
-            SkBitmap dst;
+            SkAutoTUnref<SkImage> src(SkNewImageFromBitmap(bitmap, NULL));
+            SkAutoTUnref<const SkImage> dst;
             SkIPoint offset = SkIPoint::Make(0, 0);
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
             const SkIRect clipBounds = bitmap.bounds();
             SkAutoTUnref<SkImageFilter::Cache> cache(iter.fDevice->getImageFilterCache());
             SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
-            if (filter->filterImage(&proxy, bitmap, ctx, &dst, &offset)) {
+            if (filter->filterImage(&proxy, src, ctx, dst, &offset)) {
                 SkPaint tmpUnfiltered(*paint);
                 tmpUnfiltered.setImageFilter(NULL);
-                iter.fDevice->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
-                                         tmpUnfiltered);
+                iter.fDevice->drawSprite(iter, *dst, pos.x() + offset.x(),
+                                         pos.y() + offset.y(), tmpUnfiltered);
             }
         } else {
             iter.fDevice->drawSprite(iter, bitmap, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
+void SkCanvas::onDrawSprite(const SkImage& image, int x, int y, const SkPaint* paint) {
+    if (gTreatSpriteAsBitmap) {
+        this->save();
+        this->resetMatrix();
+        this->drawImage(&image, SkIntToScalar(x), SkIntToScalar(y), paint);
+        this->restore();
+        return;
+    }
+
+    TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawSprite()");
+
+    SkPaint tmp;
+    if (NULL == paint) {
+        paint = &tmp;
+    }
+
+    LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kImage_Type)
+
+    while (iter.next()) {
+        paint = &looper.paint();
+        SkImageFilter* filter = paint->getImageFilter();
+        SkIPoint pos = { x - iter.getX(), y - iter.getY() };
+        if (filter && !iter.fDevice->canHandleImageFilter(filter)) {
+            SkDeviceImageFilterProxy proxy(iter.fDevice, fProps);
+            SkAutoTUnref<const SkImage> dst;
+            SkIPoint offset = SkIPoint::Make(0, 0);
+            SkMatrix matrix = *iter.fMatrix;
+            matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
+            const SkIRect clipBounds = SkIRect::MakeWH(image.width(), image.height());
+            SkAutoTUnref<SkImageFilter::Cache> cache(iter.fDevice->getImageFilterCache());
+            SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
+            if (filter->filterImage(&proxy, &image, ctx, dst, &offset)) {
+                SkPaint tmpUnfiltered(*paint);
+                tmpUnfiltered.setImageFilter(NULL);
+                iter.fDevice->drawSprite(iter, *dst, pos.x() + offset.x(),
+                                         pos.y() + offset.y(), tmpUnfiltered);
+            }
+        } else {
+            iter.fDevice->drawSprite(iter, image, pos.x(), pos.y(), *paint);
+        }
+    }
+    LOOPER_END
+}
+
 /////////////////////////////////////////////////////////////////////////////
 void SkCanvas::translate(SkScalar dx, SkScalar dy) {
     SkMatrix m;
     m.setTranslate(dx, dy);
     this->concat(m);
 }
 
 void SkCanvas::scale(SkScalar sx, SkScalar sy) {
     SkMatrix m;
     m.setScale(sx, sy);
@@ skipping 446 matching lines @@
 }
 
 void SkCanvas::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst,
                               const SkPaint* paint) {
     this->onDrawBitmapNine(bitmap, center, dst, paint);
 }
 
 void SkCanvas::drawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint) {
     this->onDrawSprite(bitmap, left, top, paint);
 }
+void SkCanvas::drawSprite(const SkImage& image, int left, int top, const SkPaint* paint) {
+    this->onDrawSprite(image, left, top, paint);
+}
 
 //////////////////////////////////////////////////////////////////////////////
 //  These are the virtual drawing methods
 //////////////////////////////////////////////////////////////////////////////
 
 void SkCanvas::onDiscard() {
     if (NULL != this->getDevice()) {
         this->getDevice()->discard();
     }
 }
@@ skipping 839 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }