Image filters: optimize crop rect application

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 "SkImageFilterCacheKey.h"
 
@@ skipping 51 matching lines @@
         str->appendf("%.2f", fRect.height());
     } else {
         str->appendf("X");
     }
     str->appendf(") ");
 }
 #endif
 
 void SkImageFilter::CropRect::applyTo(const SkIRect& imageBounds,
                                       const SkMatrix& ctm,
+                                      bool embiggen,
                                       SkIRect* cropped) const {
     *cropped = imageBounds;
     if (fFlags) {
         SkRect devCropR;
         ctm.mapRect(&devCropR, fRect);
-        const SkIRect devICropR = devCropR.roundOut();
+        SkIRect devICropR = devCropR.roundOut();
 
-        // Compute the left/top first, in case we have to read them to compute right/bottom
+        // Compute the left/top first, in case we need to modify the right/bottom for a missing edge
         if (fFlags & kHasLeft_CropEdge) {
-            cropped->fLeft = devICropR.fLeft;
+            if (embiggen || devICropR.fLeft > cropped->fLeft) {
+                cropped->fLeft = devICropR.fLeft;
+            }
+        } else {
+            devICropR.fRight = cropped->fLeft + devICropR.width();
         }
         if (fFlags & kHasTop_CropEdge) {
-            cropped->fTop = devICropR.fTop;
+            if (embiggen || devICropR.fTop > cropped->fTop) {
+                cropped->fTop = devICropR.fTop;
+            }
+        } else {
+            devICropR.fBottom = cropped->fTop + devICropR.height();
         }
         if (fFlags & kHasWidth_CropEdge) {
-            cropped->fRight = cropped->fLeft + devICropR.width();
+            if (embiggen || devICropR.fRight < cropped->fRight) {
+                cropped->fRight = devICropR.fRight;
+            }
         }
         if (fFlags & kHasHeight_CropEdge) {
-            cropped->fBottom = cropped->fTop + devICropR.height();
+            if (embiggen || devICropR.fBottom < cropped->fBottom) {
+                cropped->fBottom = devICropR.fBottom;
+            }
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static int32_t next_image_filter_unique_id() {
     static int32_t gImageFilterUniqueID;
 
     // Never return 0.
@@ skipping 198 matching lines @@
 
 SkIRect SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm,
                                  MapDirection direction) const {
     if (kReverse_MapDirection == direction) {
         SkIRect bounds = this->onFilterNodeBounds(src, ctm, direction);
         return this->onFilterBounds(bounds, ctm, direction);
     } else {
         SkIRect bounds = this->onFilterBounds(src, ctm, direction);
         bounds = this->onFilterNodeBounds(bounds, ctm, direction);
         SkIRect dst;
-        this->getCropRect().applyTo(bounds, ctm, &dst);
+        this->getCropRect().applyTo(bounds, ctm, this->affectsTransparentBlack(), &dst);
         return dst;
     }
 }
 
 SkRect SkImageFilter::computeFastBounds(const SkRect& src) const {
     if (0 == fInputCount) {
         return src;
     }
     SkRect combinedBounds = this->getInput(0) ? this->getInput(0)->computeFastBounds(src) : src;
     for (int i = 1; i < fInputCount; i++) {
         SkImageFilter* input = this->getInput(i);
         if (input) {
             combinedBounds.join(input->computeFastBounds(src));
         } else {
             combinedBounds.join(src);
         }
     }
     return combinedBounds;
 }
 
 bool SkImageFilter::canComputeFastBounds() const {
+    if (this->affectsTransparentBlack()) {
+        return false;
+    }
     for (int i = 0; i < fInputCount; i++) {
         SkImageFilter* input = this->getInput(i);
         if (input && !input->canComputeFastBounds()) {
             return false;
         }
     }
     return true;
 }
 
 bool SkImageFilter::onFilterImageDeprecated(Proxy*, const SkBitmap&, const Context&,
@@ skipping 89 matching lines @@
     if (nullptr != this->getInput(0) || (*filterPtr)->affectsTransparentBlack()) {
         (*filterPtr)->unref();
         return false;
     }
     return true;
 }
 
 bool SkImageFilter::applyCropRect(const Context& ctx, const SkIRect& srcBounds,
                                   SkIRect* dstBounds) const {
     SkIRect temp = this->onFilterNodeBounds(srcBounds, ctx.ctm(), kForward_MapDirection);
-    fCropRect.applyTo(temp, ctx.ctm(), dstBounds);
+    fCropRect.applyTo(temp, ctx.ctm(), this->affectsTransparentBlack(), 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::applyCropRectDeprecated(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(), kForward_MapDirection);
-    fCropRect.applyTo(dstBounds, ctx.ctm(), bounds);
+    fCropRect.applyTo(dstBounds, ctx.ctm(), this->affectsTransparentBlack(), 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) {
@@ skipping 30 matching lines @@
 }
 
 sk_sp<SkSpecialImage> SkImageFilter::applyCropRect(const Context& ctx,
                                                    SkSpecialImage* src,
                                                    SkIPoint* srcOffset,
                                                    SkIRect* bounds) const {
     SkIRect srcBounds;
     srcBounds = SkIRect::MakeXYWH(srcOffset->fX, srcOffset->fY, src->width(), src->height());
 
     SkIRect dstBounds = this->onFilterNodeBounds(srcBounds, ctx.ctm(), kForward_MapDirection);
-    fCropRect.applyTo(dstBounds, ctx.ctm(), bounds);
+    fCropRect.applyTo(dstBounds, ctx.ctm(), this->affectsTransparentBlack(), bounds);
     if (!bounds->intersect(ctx.clipBounds())) {
         return nullptr;
     }
 
     if (srcBounds.contains(*bounds)) {
         return sk_sp<SkSpecialImage>(SkRef(src));
     } else {
         sk_sp<SkSpecialImage> img(pad_image(src,
                                             bounds->width(), bounds->height(),
                                             srcOffset->x() - bounds->x(),
@@ skipping 287 matching lines @@
         dev = SkBitmapDevice::Create(cinfo.fInfo, surfaceProps);
     }
     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);
 }