detect when we can filter bitmaps/images directly, w/o a tmp layer

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 "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkClipStack.h"
 #include "SkColorFilter.h"
 #include "SkDevice.h"
 #include "SkDraw.h"
 #include "SkDrawable.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
 #include "SkErrorInternals.h"
 #include "SkImage.h"
+#include "SkImage_Base.h"
 #include "SkMetaData.h"
 #include "SkNinePatchIter.h"
 #include "SkPaintPriv.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
 #include "SkRasterClip.h"
 #include "SkReadPixelsRec.h"
 #include "SkRRect.h"
 #include "SkSmallAllocator.h"
 #include "SkSurface_Base.h"
@@ skipping 555 matching lines @@
     // call this after any possible paint modifiers
     if (fPaint->nothingToDraw()) {
         fPaint = nullptr;
         return false;
     }
     return true;
 }
 
 ////////// macros to place around the internal draw calls //////////////////
 
+#define LOOPER_BEGIN_DRAWBITMAP(paint, skipLayerForFilter, bounds)          \
+    this->predrawNotify();                                                  \
+    AutoDrawLooper looper(this, fProps, paint, skipLayerForFilter, bounds); \
+    while (looper.next(SkDrawFilter::kBitmap_Type)) {                       \

[robertphillips, 2015/12/02 22:37:18]

indent this ?

[reed1, 2015/12/03 21:26:51]

Done.

+    SkDrawIter iter(this);
+
+
 #define LOOPER_BEGIN_DRAWDEVICE(paint, type)                        \
     this->predrawNotify();                                          \
     AutoDrawLooper  looper(this, fProps, paint, true);              \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_BEGIN(paint, type, bounds)                           \
     this->predrawNotify();                                          \
     AutoDrawLooper  looper(this, fProps, paint, false, bounds);     \
     while (looper.next(type)) {                                     \
@@ skipping 792 matching lines @@
     SkDEBUGCODE(bitmap.validate();)
 
     SkPaint tmp;
     if (nullptr == paint) {
         paint = &tmp;
     }
 
     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)) {
-            SkImageFilter::DeviceProxy proxy(iter.fDevice);
-            SkBitmap 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(),
-                                       SkImageFilter::kApprox_SizeConstraint);
-            if (filter->filterImage(&proxy, bitmap, ctx, &dst, &offset)) {
-                SkPaint tmpUnfiltered(*paint);
-                tmpUnfiltered.setImageFilter(nullptr);
-                iter.fDevice->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
-                                         tmpUnfiltered);
+        if (true) {

[Stephen White, 2015/12/02 23:45:15]

Remove this?

[reed1, 2015/12/03 21:26:51]

Done.

+            const SkPaint& pnt = looper.paint();
+            const SkIPoint pos = {  x - iter.getX(), y - iter.getY() };
+            if (iter.fDevice->canCallFilterSprite(nullptr, pnt)) {
+                iter.fDevice->filterSprite(iter, bitmap, pos.x(), pos.y(),

[robertphillips, 2015/12/02 22:37:18]

looper.paint() -> pnt & all on one line ?

[Stephen White, 2015/12/02 23:45:15]

Do we have any benches which exercise these different codepaths? If not, could
we?

[reed1, 2015/12/03 21:26:51]

Done.

[reed1, 2015/12/03 21:26:51]

Done.

+                                           looper.paint());
+            } else {
+                iter.fDevice->drawSprite(iter, bitmap, pos.x(), pos.y(), pnt);
             }
         } else {
-            iter.fDevice->drawSprite(iter, bitmap, pos.x(), pos.y(), *paint);
+            paint = &looper.paint();
+            SkImageFilter* filter = paint->getImageFilter();
+            SkIPoint pos = { x - iter.getX(), y - iter.getY() };
+            if (filter && !iter.fDevice->canHandleImageFilter(filter)) {
+                SkImageFilter::DeviceProxy proxy(iter.fDevice);
+                SkBitmap 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(),
+                                           SkImageFilter::kApprox_SizeConstraint);
+                if (filter->filterImage(&proxy, bitmap, ctx, &dst, &offset)) {
+                    SkPaint tmpUnfiltered(*paint);
+                    tmpUnfiltered.setImageFilter(nullptr);
+                    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::translate(SkScalar dx, SkScalar dy) {
     SkMatrix m;
     m.setTranslate(dx, dy);
     this->concat(m);
@@ skipping 752 matching lines @@
 
     LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawPath(iter, path, looper.paint());
     }
 
     LOOPER_END
 }
 
+bool SkCanvas::canCallFilterSprite(const SkRect& bounds, const SkPaint& paint) {
+#ifdef SK_SUPPORT_LEGACY_LAYER_BITMAP_IMAGEFILTERS
+    return false;
+#endif
+
+    const SkMatrix& ctm = this->getTotalMatrix();
+    SkBaseDevice* baseDevice = this->getDevice();
+    bool handleFilter = baseDevice->canCallFilterSprite(&ctm, paint);
+    // Currently we can only use the filterSprite code if we are clipped to the bitmap's bounds.
+    // Once we can filter and the filter will return a result larger than itself, we should be
+    // able to remove this constraint.
+    if (handleFilter) {
+        SkPoint pt;
+        ctm.mapXY(bounds.x(), bounds.y(), &pt);
+        SkIRect ibounds = bounds.makeOffset(pt.fX, pt.fY).round();
+        if (!ibounds.contains(fMCRec->fRasterClip.getBounds())) {
+            handleFilter = false;
+        } else {
+//            SkDebugf("------- handleFilter survived!\n");
+        }
+    }
+    return handleFilter;
+}
+
 void SkCanvas::onDrawImage(const SkImage* image, SkScalar x, SkScalar y, const SkPaint* paint) {
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawImage()");
     SkRect bounds = SkRect::MakeXYWH(x, y,
                                      SkIntToScalar(image->width()), SkIntToScalar(image->height()));
     if (nullptr == paint || paint->canComputeFastBounds()) {
         SkRect tmp = bounds;
         if (paint) {
             paint->computeFastBounds(tmp, &tmp);
         }
         if (this->quickReject(tmp)) {
             return;
         }
     }
     
     SkLazyPaint lazy;
     if (nullptr == paint) {
         paint = lazy.init();
     }
-    
-    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, &bounds)
-    
+
+    const bool handleFilter = this->canCallFilterSprite(bounds, *paint);
+    LOOPER_BEGIN_DRAWBITMAP(*paint, handleFilter, &bounds)
+
     while (iter.next()) {
-        iter.fDevice->drawImage(iter, image, x, y, looper.paint());
+        const SkPaint& pnt = looper.paint();
+        if (handleFilter && pnt.getImageFilter()) {
+            SkBitmap bitmap;
+            if (as_IB(image)->asBitmapForImageFilters(&bitmap)) {
+                SkPoint pt;
+                iter.fMatrix->mapXY(x, y, &pt);
+                iter.fDevice->filterSprite(iter, bitmap,
+                                           SkScalarRoundToInt(pt.fX),
+                                           SkScalarRoundToInt(pt.fY), pnt);
+            }
+        } else {
+            iter.fDevice->drawImage(iter, image, x, y, pnt);
+        }
     }
     
     LOOPER_END
 }
 
 void SkCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                                const SkPaint* paint, SrcRectConstraint constraint) {
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawImageRect()");
     SkRect storage;
     const SkRect* bounds = &dst;
@@ skipping 41 matching lines @@
     if (paint->canComputeFastBounds()) {
         bitmap.getBounds(&storage);
         matrix.mapRect(&storage);
         SkRect tmp = storage;
         if (this->quickReject(paint->computeFastBounds(tmp, &tmp))) {
             return;
         }
         bounds = &storage;
     }
 
-    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, bounds)
+    const bool handleFilter = bounds && this->canCallFilterSprite(*bounds, *paint);
+    LOOPER_BEGIN_DRAWBITMAP(*paint, handleFilter, bounds)
 
     while (iter.next()) {
-        iter.fDevice->drawBitmap(iter, bitmap, matrix, looper.paint());
+        const SkPaint& pnt = looper.paint();
+        if (handleFilter && pnt.getImageFilter()) {
+            SkPoint pt;
+            iter.fMatrix->mapXY(x, y, &pt);
+            iter.fDevice->filterSprite(iter, bitmap,
+                                       SkScalarRoundToInt(pt.fX),
+                                       SkScalarRoundToInt(pt.fY), pnt);
+        } else {
+            iter.fDevice->drawBitmap(iter, bitmap, matrix, looper.paint());
+        }
     }
-    
+
     LOOPER_END
 }
 
 // this one is non-virtual, so it can be called safely by other canvas apis
 void SkCanvas::internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
                                       const SkRect& dst, const SkPaint* paint,
                                       SrcRectConstraint constraint) {
     if (bitmap.drawsNothing() || dst.isEmpty()) {
         return;
     }
@@ skipping 663 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }