Optimize CSS box-shadow performance

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 "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
+#include "SkMaskCache.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 "GrProcessor.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "GrTBackendProcessorFactory.h"
 #include "SkGrPixelRef.h"
 #include "SkDraw.h"
 #endif
 
 SkScalar SkBlurMaskFilter::ConvertRadiusToSigma(SkScalar radius) {
     return SkBlurMask::ConvertRadiusToSigma(radius);
 }
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
 public:
     SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, 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;
+                            SkIPoint* margin, SkCachedData** data) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
     virtual bool canFilterMaskGPU(const SkRect& devBounds,
                                   const SkIRect& clipBounds,
                                   const SkMatrix& ctm,
                                   SkRect* maskRect) const SK_OVERRIDE;
     virtual bool directFilterMaskGPU(GrContext* context,
                                      GrPaint* grp,
                                      const SkStrokeRec& strokeRec,
                                      const SkPath& path) const SK_OVERRIDE;
@@ skipping 18 matching lines @@
 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;
+                        SkIPoint* margin, SkMask::CreateMode createMode, SkCachedData** data) const;
     bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix,
-                        SkIPoint* margin, SkMask::CreateMode createMode) const;
+                        SkIPoint* margin, SkMask::CreateMode createMode, SkCachedData** data) 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;
     SkBlurStyle fBlurStyle;
     uint32_t    fBlurFlags;
@@ skipping 56 matching lines @@
     if (rec) {
         rec->fSigma = fSigma;
         rec->fStyle = fBlurStyle;
         rec->fQuality = this->getQuality();
     }
     return true;
 }
 
 bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src,
                                       const SkMatrix& matrix,
-                                      SkIPoint* margin) const{
+                                      SkIPoint* margin, SkCachedData** data) const{
     SkScalar sigma = this->computeXformedSigma(matrix);
-    return SkBlurMask::BoxBlur(dst, src, sigma, fBlurStyle, this->getQuality(), margin);
+    return SkBlurMask::BoxBlur(dst, data, src, sigma, fBlurStyle, this->getQuality(), margin);
 }
 
 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
                                           const SkMatrix& matrix,
-                                          SkIPoint* margin, SkMask::CreateMode createMode) const{
+                                          SkIPoint* margin, SkMask::CreateMode createMode, SkCachedData** data) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
-    return SkBlurMask::BlurRect(sigma, dst, r, fBlurStyle,
+    return SkBlurMask::BlurRect(sigma, dst, data, r, fBlurStyle,
                                 margin, createMode);
 }
 
 bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r,
                                           const SkMatrix& matrix,
-                                          SkIPoint* margin, SkMask::CreateMode createMode) const{
+                                          SkIPoint* margin, SkMask::CreateMode createMode, SkCachedData** data) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
-    return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle,
+    return SkBlurMask::BlurRRect(sigma, dst, data, r, 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());
@@ skipping 119 matching lines @@
     rrect.rect().roundOut(&srcM.fBounds);
     srcM.fImage = NULL;
     srcM.fFormat = SkMask::kA8_Format;
     srcM.fRowBytes = 0;
 
     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);
+                                            SkMask::kJustComputeBounds_CreateMode, &patch->fData);

[reed1, 2014/10/21 21:29:49]

If we are just computing bounds, shouldn't we pass NULL for the last parameter?

     }
 
     if (!filterResult) {
-        filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
+        filterResult = this->filterMask(&dstM, srcM, matrix, &margin, &patch->fData);
     }
 
     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);
@@ skipping 26 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);
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    if ((patch->fData = SkMaskCache::FindAndRef(sigma, rrect, &patch->fMask))) {
+        patch->fOuterRect = dstM.fBounds;
+        patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;

[reed1, 2014/10/21 21:29:49]

Can we set these fields of the patch once, before even calling the cache? That
way we don't have to keep this block, and the one on line 399, in sync.

+        patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
+        return kTrue_FilterReturn;
+    }
+
     bool analyticBlurWorked = false;
     if (c_analyticBlurRRect) {
         analyticBlurWorked =
             this->filterRRectMask(&patch->fMask, smallRR, matrix, &margin,
-                                  SkMask::kComputeBoundsAndRenderImage_CreateMode);
+                                  SkMask::kComputeBoundsAndRenderImage_CreateMode, &patch->fData);
     }
 
     if (!analyticBlurWorked) {
         if (!draw_rrect_into_mask(smallRR, &srcM)) {
             return kFalse_FilterReturn;
         }
 
         SkAutoMaskFreeImage amf(srcM.fImage);
 
-        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin, &patch->fData)) {
             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;
+    SkMaskCache::Add(sigma, rrect, patch->fMask, patch->fData);
+
     return kTrue_FilterReturn;
 }
 
 SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "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 {
@@ skipping 18 matching lines @@
     rects[0].roundOut(&srcM.fBounds);
     srcM.fImage = NULL;
     srcM.fFormat = SkMask::kA8_Format;
     srcM.fRowBytes = 0;
 
     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,
-                                            SkMask::kJustComputeBounds_CreateMode);
+                                            SkMask::kJustComputeBounds_CreateMode, &patch->fData);

[reed1, 2014/10/21 21:29:49]

again, can/should we pass NULL for the last parameter?

     } else {
-        filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
+        filterResult = this->filterMask(&dstM, srcM, matrix, &margin, &patch->fData);
     }
 
     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.
@@ skipping 18 matching lines @@
     if (1 == count) {
         innerIR = srcM.fBounds;
         center.set(smallW, smallH);
     } else {
         SkASSERT(2 == count);
         rects[1].roundIn(&innerIR);
         center.set(smallW + (innerIR.left() - srcM.fBounds.left()),
                    smallH + (innerIR.top() - srcM.fBounds.top()));
     }
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    if ((patch->fData = SkMaskCache::FindAndRef(sigma, count, rects, &patch->fMask))) {
+        patch->fOuterRect = dstM.fBounds;

[reed1, 2014/10/21 21:29:49]

again, can we share setup code for patch between here and line 532?

+        patch->fCenter = center;
+
+        return kTrue_FilterReturn;
+    }
+
     // +1 so we get a clean, stretchable, center row/col
     smallW += 1;
     smallH += 1;
 
     // we want the inset amounts to be integral, so we don't change any
     // fractional phase on the fRight or fBottom of our smallR.
     const SkScalar dx = SkIntToScalar(innerIR.width() - smallW);
     const SkScalar dy = SkIntToScalar(innerIR.height() - smallH);
     if (dx < 0 || dy < 0) {
         // we're too small, relative to our blur, to break into nine-patch,
@@ skipping 11 matching lines @@
         SkASSERT(!smallR[1].isEmpty());
     }
 
     if (count > 1 || !c_analyticBlurNinepatch) {
         if (!draw_rects_into_mask(smallR, count, &srcM)) {
             return kFalse_FilterReturn;
         }
 
         SkAutoMaskFreeImage amf(srcM.fImage);
 
-        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin, &patch->fData)) {
             return kFalse_FilterReturn;
         }
     } else {
         if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin,
-                                  SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
+                                  SkMask::kComputeBoundsAndRenderImage_CreateMode, &patch->fData)) {
             return kFalse_FilterReturn;
         }
     }
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter = center;
+    SkMaskCache::Add(sigma, count, rects, patch->fMask, patch->fData);
+
     return kTrue_FilterReturn;
 }
 
 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
                                              SkRect* dst) const {
     SkScalar pad = 3.0f * fSigma;
 
     dst->set(src.fLeft  - pad, src.fTop    - pad,
              src.fRight + pad, src.fBottom + pad);
 }
@@ skipping 382 matching lines @@
 
         SkRRect smallRRect;
         smallRRect.setRectXY(smallRect, SkIntToScalar(cornerRadius), SkIntToScalar(cornerRadius));
 
         SkPath path;
         path.addRRect( smallRRect );
 
         SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask, SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style);
 
         SkMask blurred_mask;
-        SkBlurMask::BoxBlur(&blurred_mask, mask, sigma, kNormal_SkBlurStyle, kHigh_SkBlurQuality, NULL, true );
+        SkBlurMask::BoxBlur(&blurred_mask, NULL, mask, sigma, kNormal_SkBlurStyle, kHigh_SkBlurQuality, NULL, true );
 
         blurNinePatchTexture = context->createTexture(&params, texDesc, blurRRectNinePatchID, blurred_mask.fImage, 0);
         SkMask::FreeImage(blurred_mask.fImage);
     }
 
     SkAutoTUnref<GrTexture> blurunref(blurNinePatchTexture);
     if (NULL == blurNinePatchTexture) {
         return NULL;
     }
 
@@ skipping 291 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