first attempt to plumb fast blur code into skia mask filter

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 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 "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkFlattenableBuffers.h"
 #include "SkMaskFilter.h"
+#include "SkBounder.h"
+#include "SkRasterClip.h"
+#include "SkRTConf.h"
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
 public:
     SkBlurMaskFilterImpl(SkScalar radius, SkBlurMaskFilter::BlurStyle,
                          uint32_t flags);
 
     // overrides from SkMaskFilter
     virtual SkMask::Format getFormat() const SK_OVERRIDE;
     virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                             SkIPoint* margin) const SK_OVERRIDE;
+    
     virtual BlurType asABlur(BlurInfo*) const SK_OVERRIDE;
     virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurMaskFilterImpl)
 
 protected:
     virtual FilterReturn filterRectsToNine(const SkRect[], int count, const SkMatrix&,
                                            const SkIRect& clipBounds,
                                            NinePatch*) const SK_OVERRIDE;
+                                           
+    bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix, 
+                        SkIPoint* margin, bool perform_blur=true) const;
 
 private:
     SkScalar                    fRadius;
     SkBlurMaskFilter::BlurStyle fBlurStyle;
     uint32_t                    fBlurFlags;
 
     SkBlurMaskFilterImpl(SkFlattenableReadBuffer&);
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
 
     typedef SkMaskFilter INHERITED;
@@ skipping 57 matching lines @@
 
 #ifndef SK_DISABLE_SEPARABLE_MASK_BLUR
     return SkBlurMask::BlurSeparable(dst, src, radius, (SkBlurMask::Style)fBlurStyle,
                             blurQuality, margin);
 #else
     return SkBlurMask::Blur(dst, src, radius, (SkBlurMask::Style)fBlurStyle,
                             blurQuality, margin);
 #endif
 }
 
+bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
+                                          const SkMatrix& matrix,
+                                          SkIPoint* margin, bool perform_blur) const{
+    SkScalar radius;
+    if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
+        radius = fRadius;
+    } else {
+        radius = matrix.mapRadius(fRadius);
+    }
+
+    // To avoid unseemly allocation requests (esp. for finite platforms like
+    // handset) we limit the radius so something manageable. (as opposed to
+    // a request like 10,000)
+    static const SkScalar MAX_RADIUS = SkIntToScalar(128);
+    radius = SkMinScalar(radius, MAX_RADIUS);
+    
+    return SkBlurMask::BlurRect(dst, r, radius, (SkBlurMask::Style)fBlurStyle,
+                                margin, perform_blur);
+}
+
 #include "SkCanvas.h"
 
 static bool drawRectsIntoMask(const SkRect rects[], int count, SkMask* mask) {
     rects[0].roundOut(&mask->fBounds);
     mask->fRowBytes = SkAlign4(mask->fBounds.width());
     mask->fFormat = SkMask::kA8_Format;
     size_t size = mask->computeImageSize();
     mask->fImage = SkMask::AllocImage(size);
     if (NULL == mask->fImage) {
         return false;
@@ skipping 24 matching lines @@
         canvas.drawPath(path, paint);
     }
     return true;
 }
 
 static bool rect_exceeds(const SkRect& r, SkScalar v) {
     return r.fLeft < -v || r.fTop < -v || r.fRight > v || r.fBottom > v ||
            r.width() > v || r.height() > v;
 }
 
+SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", 
+#ifdef SK_IGNORE_FAST_RECT_BLUR
+                 false, 
+#else
+                 true,
+#endif
+                 "Use the faster analytic blur approach for ninepatch rects" );
+
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
     if (count < 1 || count > 2) {
         return kUnimplemented_FilterReturn;
     }
 
     // TODO: report correct metrics for innerstyle, where we do not grow the
     // total bounds, but we do need an inset the size of our blur-radius
     if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle) {
         return kUnimplemented_FilterReturn;
     }
 
     // TODO: take clipBounds into account to limit our coordinates up front
     // for now, just skip too-large src rects (to take the old code path).
     if (rect_exceeds(rects[0], SkIntToScalar(32767))) {
         return kUnimplemented_FilterReturn;
     }
 
     SkIPoint margin;
     SkMask  srcM, dstM;
     rects[0].roundOut(&srcM.fBounds);
     srcM.fImage = NULL;
     srcM.fFormat = SkMask::kA8_Format;
     srcM.fRowBytes = 0;
-    if (!this->filterMask(&dstM, srcM, matrix, &margin)) {
+    
+    bool filterResult = false;
+    if (count == 1 && c_analyticBlurNinepatch) {
+        // special case for fast rect blur
+        // don't actually do the blur the first time, just compute the correct size
+        filterResult = this->filterRectMask(&dstM, rects[0], matrix, &margin, false);
+    } else {
+        filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
+    }
+    
+    if (!filterResult) {
         return kFalse_FilterReturn;
     }
 
     /*
      *  smallR is the smallest version of 'rect' that will still guarantee that
      *  we get the same blur results on all edges, plus 1 center row/col that is
      *  representative of the extendible/stretchable edges of the ninepatch.
      *  Since our actual edge may be fractional we inset 1 more to be sure we
      *  don't miss any interior blur.
      *  x is an added pixel of blur, and { and } are the (fractional) edge
@@ skipping 37 matching lines @@
     }
 
     smallR[0].set(rects[0].left(), rects[0].top(), rects[0].right() - dx, rects[0].bottom() - dy);
     SkASSERT(!smallR[0].isEmpty());
     if (2 == count) {
         smallR[1].set(rects[1].left(), rects[1].top(),
                       rects[1].right() - dx, rects[1].bottom() - dy);
         SkASSERT(!smallR[1].isEmpty());
     }
 
-    if (!drawRectsIntoMask(smallR, count, &srcM)) {
-        return kFalse_FilterReturn;
-    }
+    if (count > 1 || !c_analyticBlurNinepatch) {
+        if (!drawRectsIntoMask(smallR, count, &srcM)) {
+            return kFalse_FilterReturn;
+        }
 
-    SkAutoMaskFreeImage amf(srcM.fImage);
+        SkAutoMaskFreeImage amf(srcM.fImage);
 
-    if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
-        return kFalse_FilterReturn;
+        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+            return kFalse_FilterReturn;
+        }
+    } else {
+        if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin, true)) {
+            return kFalse_FilterReturn;
+        }
     }
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter = center;
     return kTrue_FilterReturn;
 }
 
 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
                                              SkRect* dst) const {
     dst->set(src.fLeft - fRadius, src.fTop - fRadius,
@@ skipping 28 matching lines @@
         info->fRadius = fRadius;
         info->fIgnoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
         info->fHighQuality = SkToBool(fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag);
     }
     return gBlurStyle2BlurType[fBlurStyle];
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END