plumb API for analytic rrect blur

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"
@@ skipping 51 matching lines @@
     virtual FilterReturn filterRectsToNine(const SkRect[], int count, const SkMatrix&,
                                            const SkIRect& clipBounds,
                                            NinePatch*) const SK_OVERRIDE;
 
     virtual FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
                                            const SkIRect& clipBounds,
                                            NinePatch*) const SK_OVERRIDE;
 
     bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix,
                         SkIPoint* margin, SkMask::CreateMode createMode) const;
+    bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix,
+                        SkIPoint* margin, SkMask::CreateMode createMode) const;
 
 private:
     // 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 kMAX_BLUR_SIGMA;
 
     SkScalar                    fSigma;
     SkBlurMaskFilter::BlurStyle fBlurStyle;
     uint32_t                    fBlurFlags;
@@ skipping 79 matching lines @@
 
 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
                                           const SkMatrix& matrix,
                                           SkIPoint* margin, SkMask::CreateMode createMode) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
     return SkBlurMask::BlurRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle,
                                 margin, createMode);
 }
 
+bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r,
+                                          const SkMatrix& matrix,
+                                          SkIPoint* margin, SkMask::CreateMode createMode) const{
+    SkScalar sigma = computeXformedSigma(matrix);
+
+    return SkBlurMask::BlurRRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle,
+                                margin, createMode);
+}
+
 #include "SkCanvas.h"
 
 static bool prepare_to_draw_into_mask(const SkRect& bounds, SkMask* mask) {
     SkASSERT(mask != NULL);
 
     bounds.roundOut(&mask->fBounds);
     mask->fRowBytes = SkAlign4(mask->fBounds.width());
     mask->fFormat = SkMask::kA8_Format;
     const size_t size = mask->computeImageSize();
     mask->fImage = SkMask::AllocImage(size);
@@ skipping 56 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;
 }
 
+#ifdef SK_IGNORE_FAST_RRECT_BLUR
+SK_CONF_DECLARE( bool, c_analyticBlurRRect, "mask.filter.blur.analyticRRect", false, "Use the faster analytic blur approach for ninepatch rects" );
+#else
+SK_CONF_DECLARE( bool, c_analyticBlurRRect, "mask.filter.blur.analyticRRect", true, "Use the faster analytic blur approach for ninepatch round rects" );
+#endif
+
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
     SkASSERT(patch != NULL);
     switch (rrect.getType()) {
         case SkRRect::kUnknown_Type:
             // Unknown should never be returned.
             SkASSERT(false);
             // Fall through.
@@ skipping 29 matching lines @@
         return kUnimplemented_FilterReturn;
     }
 
     SkIPoint margin;
     SkMask  srcM, dstM;
     rrect.rect().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 (c_analyticBlurRRect) {
+        // special case for fast round rect blur
+        // don't actually do the blur the first time, just compute the correct size
+        filterResult = this->filterRRectMask(&dstM, rrect, matrix, &margin,
+                                            SkMask::kJustComputeBounds_CreateMode);
+    }
+
+    if (!filterResult) {
+        filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
+    }
+
+    if (!filterResult) {
         return kFalse_FilterReturn;
     }
 
     // Now figure out the appropriate width and height of the smaller round rectangle
     // to stretch. It will take into account the larger radius per side as well as double
     // the margin, to account for inner and outer blur.
     const SkVector& UL = rrect.radii(SkRRect::kUpperLeft_Corner);
     const SkVector& UR = rrect.radii(SkRRect::kUpperRight_Corner);
     const SkVector& LR = rrect.radii(SkRRect::kLowerRight_Corner);
     const SkVector& LL = rrect.radii(SkRRect::kLowerLeft_Corner);
@@ skipping 23 matching lines @@
     SkRect smallR = SkRect::MakeWH(totalSmallWidth, totalSmallHeight);
 
     SkRRect smallRR;
     SkVector radii[4];
     radii[SkRRect::kUpperLeft_Corner] = UL;
     radii[SkRRect::kUpperRight_Corner] = UR;
     radii[SkRRect::kLowerRight_Corner] = LR;
     radii[SkRRect::kLowerLeft_Corner] = LL;
     smallRR.setRectRadii(smallR, radii);
 
-    if (!draw_rrect_into_mask(smallRR, &srcM)) {
-        return kFalse_FilterReturn;
+    bool analyticBlurWorked = false;
+    if (c_analyticBlurRRect) {
+        analyticBlurWorked =
+            this->filterRRectMask(&patch->fMask, smallRR, matrix, &margin,
+                                  SkMask::kComputeBoundsAndRenderImage_CreateMode);
     }
 
-    SkAutoMaskFreeImage amf(srcM.fImage);
+    if (!analyticBlurWorked) {
+        if (!draw_rrect_into_mask(smallRR, &srcM)) {
+            return kFalse_FilterReturn;
+        }
 
-    if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
-        return kFalse_FilterReturn;
+        SkAutoMaskFreeImage amf(srcM.fImage);
+
+        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+            return kFalse_FilterReturn;
+        }
     }
 
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
     patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
     return kTrue_FilterReturn;
 }
 
 #ifdef SK_IGNORE_FAST_RECT_BLUR
@@ skipping 537 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END