Add ability to ninepatch blurred rounded rectangle

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 "SkGpuBlurUtils.h"
 #include "SkFlattenableBuffers.h"
 #include "SkMaskFilter.h"
+#include "SkRRect.h"
 #include "SkRTConf.h"
 #include "SkStringUtils.h"
 #include "SkStrokeRec.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrTexture.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "SkGrPixelRef.h"
 #endif
@@ skipping 21 matching lines @@
     virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
 
     SkDEVCODE(virtual void toString(SkString* str) 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;
 
+    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;
 
 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;
@@ skipping 83 matching lines @@
                                           const SkMatrix& matrix,
                                           SkIPoint* margin, SkMask::CreateMode createMode) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
     return SkBlurMask::BlurRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle,
                                 margin, createMode);
 }
 
 #include "SkCanvas.h"
 
-static bool drawRectsIntoMask(const SkRect rects[], int count, SkMask* mask) {
-    rects[0].roundOut(&mask->fBounds);
+static SkCanvas* 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;
-    size_t size = mask->computeImageSize();
+    const size_t size = mask->computeImageSize();
     mask->fImage = SkMask::AllocImage(size);
     if (NULL == mask->fImage) {
-        return false;
+        return NULL;
     }
+
+    // FIXME: use sk_calloc in AllocImage?
     sk_bzero(mask->fImage, size);
-
     SkBitmap bitmap;
     bitmap.setConfig(SkBitmap::kA8_Config,
                      mask->fBounds.width(), mask->fBounds.height(),
                      mask->fRowBytes);
     bitmap.setPixels(mask->fImage);
 
-    SkCanvas canvas(bitmap);
-    canvas.translate(-SkIntToScalar(mask->fBounds.left()),
-                     -SkIntToScalar(mask->fBounds.top()));
+    SkCanvas* canvas = SkNEW_ARGS(SkCanvas, (bitmap));

[scroggo, 2013/10/30 22:51:31]

In trying to share code, I've added an allocation! I'll try to figure out the
right way to share code without the extra allocation...

[robertphillips, 2013/10/31 00:24:58]

Can you just set up the mask then return true or false and let the caller create
the canvas (and do the translate)?

[scroggo, 2013/11/01 21:45:46]

I could, but that means I'm still duplicating code. How about a macro?

+    canvas->translate(-SkIntToScalar(mask->fBounds.left()),
+                      -SkIntToScalar(mask->fBounds.top()));
+    return canvas;
+}
+
+static bool draw_rrect_into_mask(const SkRRect rrect, SkMask* mask) {
+    SkAutoTUnref<SkCanvas> canvas(prepare_to_draw_into_mask(rrect.rect(), mask));
+    if (NULL == canvas.get()) {
+        return false;
+    }
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    canvas->drawRRect(rrect, paint);
+    return true;
+}
+
+static bool drawRectsIntoMask(const SkRect rects[], int count, SkMask* mask) {
+    SkAutoTUnref<SkCanvas> canvas(prepare_to_draw_into_mask(rects[0], mask));
+    if (NULL == canvas.get()) {
+        return false;
+    }
 
     SkPaint paint;
     paint.setAntiAlias(true);
 
     if (1 == count) {
-        canvas.drawRect(rects[0], paint);
+        canvas->drawRect(rects[0], paint);
     } else {
         // todo: do I need a fast way to do this?
         SkPath path;
         path.addRect(rects[0]);
         path.addRect(rects[1]);
         path.setFillType(SkPath::kEvenOdd_FillType);
-        canvas.drawPath(path, paint);
+        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;
 }
 
+SkMaskFilter::FilterReturn
+SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& matrix,
+                                        const SkIRect& clipBounds,
+                                        NinePatch* patch) const {
+    switch (rrect.getType()) {
+        case SkRRect::kUnknown_Type:
+            // Unknown should never be returned.
+            SkASSERT(false);
+            // Fall through.
+        case SkRRect::kEmpty_Type:
+            // Nothing to draw.
+            return kFalse_FilterReturn;
+
+        case SkRRect::kRect_Type:

[robertphillips, 2013/10/31 00:24:58]

I think we should assert here (that the RRect isn't a rect). It seems like that
should be caught upstream.

[scroggo, 2013/11/01 21:45:46]

Done.

+            // Fall through.
+        case SkRRect::kOval_Type:
+            // The nine patch special case does not handle ovals, and we
+            // already have code for rectangles.
+            return kUnimplemented_FilterReturn;
+
+        case SkRRect::kSimple_Type:
+            // Fall through.
+        case SkRRect::kComplex_Type:
+            // These can take advantage of this fast path.
+            break;
+    }
+
+    // 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(rrect.rect(), SkIntToScalar(32767))) {
+        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)) {
+        return kFalse_FilterReturn;
+    }
+

[robertphillips, 2013/10/31 13:30:31]

Does this behave correctly if the RR is 100x100 with 1x1 corners and the blur is
10 pixels wide?

[scroggo, 2013/11/01 21:45:46]

No. Latest patch fixes this. Thank you for the suggested test case.

+    // Now we figure out the appropriate width and height of the stretchy
+    // rectangle.
+    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);
+
+    // The smaller rectangle must be large enough to include the larger
+    // radius of all four sides, plus some extra for stretching.
+    const SkScalar maxLeftXRadius = SkTMax(UL.fX, LL.fX);
+    const SkScalar maxRightXRadius = SkTMax(UR.fX, LR.fX);
+

[robertphillips, 2013/10/31 00:24:58]

I think there should be a +3 in here and maybe make it a constant?

[scroggo, 2013/11/01 21:45:46]

Done.

+    if (maxLeftXRadius + maxRightXRadius >= rrect.rect().width()) {
+        // There is no valid piece to stretch.
+        return kUnimplemented_FilterReturn;
+    }
+
+    const SkScalar maxTopYRadius = SkTMax(UL.fY, UR.fY);
+    const SkScalar maxBottomYRadius = SkTMax(LL.fY, LR.fY);
+

[robertphillips, 2013/10/31 00:24:58]

Here too

[scroggo, 2013/11/01 21:45:46]

Done.

+    if (maxTopYRadius + maxBottomYRadius >= rrect.rect().height()) {
+        // There is no valid piece to stretch.
+        return kUnimplemented_FilterReturn;
+    }
+
+    // Add some extra space to make sure we have a stretch row/col

[robertphillips, 2013/10/31 00:24:58]

Are the x & y values correct? Can they be 0 & 0?

[scroggo, 2013/11/01 21:45:46]

The x and y values are irrelevant. I have switched to calling MakeWH, so they
are 0, 0.

+    SkRect smallR = SkRect::MakeXYWH(rrect.rect().left(), rrect.rect().top(),
+                                     maxLeftXRadius + maxRightXRadius + SkIntToScalar(3),
+                                     maxTopYRadius + maxBottomYRadius + SkIntToScalar(3));
+
+    SkRRect smallRR;

[robertphillips, 2013/10/31 00:24:58]

Maybe change setRectRadii to setAllRadii?

[scroggo, 2013/11/01 21:45:46]

I think the current name makes sense. It sets both the rect and the radii.

+    smallRR.setRectRadii(smallR, rrect.getAllRadii());
+
+    if (!draw_rrect_into_mask(smallRR, &srcM)) {
+        return kFalse_FilterReturn;
+    }
+
+    if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+        return kFalse_FilterReturn;
+    }
+
+    patch->fMask.fBounds.offsetTo(0, 0);
+    patch->fOuterRect = dstM.fBounds;
+    // Stretch just beyond the radii.
+    patch->fCenter.fX = SkScalarCeilToInt(maxLeftXRadius) + 1;
+    patch->fCenter.fY = SkScalarCeilToInt(maxTopYRadius) + 1;
+    return kTrue_FilterReturn;
+}
+
 #ifdef SK_IGNORE_FAST_RECT_BLUR
 SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", false, "Use the faster analytic blur approach for ninepatch rects" );
 #else
 SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "Use the faster analytic blur approach for ninepatch rects" );
 #endif
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
@@ skipping 263 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