Image filters: Make a recursive, forward-mapping bounds traversal.

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 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 "SkImageFilter.h"
 
 #include "SkBitmap.h"
@@ skipping 48 matching lines @@
     }
     if (fFlags & CropRect::kHasHeight_CropEdge) {
         str->appendf("%.2f", fRect.height());
     } else {
         str->appendf("X");
     }
     str->appendf(") ");
 }
 #endif
 
-bool SkImageFilter::CropRect::applyTo(const SkIRect& imageBounds, const Context& ctx,
+void SkImageFilter::CropRect::applyTo(const SkIRect& imageBounds,
+                                      const SkMatrix& ctm,
                                       SkIRect* cropped) const {
     *cropped = imageBounds;
     if (fFlags) {
         SkRect devCropR;
-        ctx.ctm().mapRect(&devCropR, fRect);
+        ctm.mapRect(&devCropR, fRect);
         const SkIRect devICropR = devCropR.roundOut();
 
         // Compute the left/top first, in case we have to read them to compute right/bottom
         if (fFlags & kHasLeft_CropEdge) {
             cropped->fLeft = devICropR.fLeft;
         }
         if (fFlags & kHasTop_CropEdge) {
             cropped->fTop = devICropR.fTop;
         }
         if (fFlags & kHasWidth_CropEdge) {
             cropped->fRight = cropped->fLeft + devICropR.width();
         }
         if (fFlags & kHasHeight_CropEdge) {
             cropped->fBottom = cropped->fTop + devICropR.height();
         }
     }
-    // Intersect against the clip bounds, in case the crop rect has
-    // grown the bounds beyond the original clip. This can happen for
-    // example in tiling, where the clip is much smaller than the filtered
-    // primitive. If we didn't do this, we would be processing the filter
-    // at the full crop rect size in every tile.
-    return cropped->intersect(ctx.clipBounds());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static int32_t next_image_filter_unique_id() {
     static int32_t gImageFilterUniqueID;
 
     // Never return 0.
     int32_t id;
     do {
@@ skipping 160 matching lines @@
 bool SkImageFilter::filterInput(int index, Proxy* proxy, const SkBitmap& src,
                                 const Context& ctx,
                                 SkBitmap* result, SkIPoint* offset) const {
     SkImageFilter* input = this->getInput(index);
     if (!input) {
         return true;
     }
     return input->filterImage(proxy, src, this->mapContext(ctx), result, offset);
 }
 
-bool SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst) const {
+bool SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst,
+                                 MapDirection direction) const {
     SkASSERT(dst);
-    return this->onFilterBounds(src, ctm, dst);
+    SkIRect bounds;
+    if (kReverse_MapDirection == direction) {
+        this->onFilterNodeBounds(src, ctm, &bounds, direction);
+        return this->onFilterBounds(bounds, ctm, dst, direction);
+    } else {
+        SkIRect temp;
+        if (!this->onFilterBounds(src, ctm, &bounds, direction)) {
+            return false;
+        }
+        this->onFilterNodeBounds(bounds, ctm, &temp, direction);
+        this->getCropRect().applyTo(temp, ctm, dst);
+        return true;
+    }
 }
 
 void SkImageFilter::computeFastBounds(const SkRect& src, SkRect* dst) const {
     if (0 == fInputCount) {
         *dst = src;
         return;
     }
     if (this->getInput(0)) {
         this->getInput(0)->computeFastBounds(src, dst);
     } else {
@@ skipping 99 matching lines @@
 bool SkImageFilter::applyCropRect(const Context& ctx, const SkBitmap& src,
                                   const SkIPoint& srcOffset, SkIRect* dstBounds,
                                   SkIRect* srcBounds) const {
     SkIRect storage;
     if (!srcBounds) {
         srcBounds = &storage;
     }
     src.getBounds(srcBounds);
     srcBounds->offset(srcOffset);
     this->onFilterNodeBounds(*srcBounds, ctx.ctm(), dstBounds, kForward_MapDirection);
-    return fCropRect.applyTo(*dstBounds, ctx, dstBounds);
+    fCropRect.applyTo(*dstBounds, ctx.ctm(), dstBounds);
+    // Intersect against the clip bounds, in case the crop rect has
+    // grown the bounds beyond the original clip. This can happen for
+    // example in tiling, where the clip is much smaller than the filtered
+    // primitive. If we didn't do this, we would be processing the filter
+    // at the full crop rect size in every tile.
+    return dstBounds->intersect(ctx.clipBounds());
 }
 
 bool SkImageFilter::applyCropRect(const Context& ctx, Proxy* proxy, const SkBitmap& src,
                                   SkIPoint* srcOffset, SkIRect* bounds, SkBitmap* dst) const {
     SkIRect srcBounds;
     src.getBounds(&srcBounds);
     srcBounds.offset(*srcOffset);
     SkIRect dstBounds;
     this->onFilterNodeBounds(srcBounds, ctx.ctm(), &dstBounds, kForward_MapDirection);
-    if (!fCropRect.applyTo(dstBounds, ctx, bounds)) {
+    fCropRect.applyTo(dstBounds, ctx.ctm(), bounds);
+    if (!bounds->intersect(ctx.clipBounds())) {
         return false;
     }
 
     if (srcBounds.contains(*bounds)) {
         *dst = src;
         return true;
     } else {
         SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds->width(), bounds->height()));
         if (!device) {
             return false;
         }
         SkCanvas canvas(device);
         canvas.clear(0x00000000);
         canvas.drawBitmap(src, srcOffset->x() - bounds->x(), srcOffset->y() - bounds->y());
         *srcOffset = SkIPoint::Make(bounds->x(), bounds->y());
         *dst = device->accessBitmap(false);
         return true;
     }
 }
 
 bool SkImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
-                                   SkIRect* dst) const {
+                                   SkIRect* dst, MapDirection direction) const {
     if (fInputCount < 1) {
         *dst = src;
         return true;
     }
 
-    SkIRect bounds, totalBounds;
-    this->onFilterNodeBounds(src, ctm, &bounds, kReverse_MapDirection);
+    SkIRect totalBounds;
     for (int i = 0; i < fInputCount; ++i) {
         SkImageFilter* filter = this->getInput(i);
-        SkIRect rect = bounds;
-        if (filter && !filter->filterBounds(bounds, ctm, &rect)) {
+        SkIRect rect = src;
+        if (filter && !filter->filterBounds(src, ctm, &rect, direction)) {
             return false;
         }
         if (0 == i) {
             totalBounds = rect;
         } else {
             totalBounds.join(rect);
         }
     }
 
     // don't modify dst until now, so we don't accidentally change it in the
@@ skipping 205 matching lines @@
     }
     return dev;
 }
 
 bool SkImageFilter::DeviceProxy::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                                        const SkImageFilter::Context& ctx,
                                        SkBitmap* result, SkIPoint* offset) {
     return fDevice->filterImage(filter, src, ctx, result, offset);
 }