Cache blur mask for rects which can not break into nine-patch

src/core/SkMaskFilter.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 "SkMaskFilter.h"
 #include "SkBlitter.h"
 #include "SkDraw.h"
+#include "SkMaskCache.h"
 #include "SkRasterClip.h"
 #include "SkRRect.h"
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU
 #include "GrTexture.h"
 #include "SkGr.h"
 #include "SkGrPixelRef.h"
 #endif
 
@@ skipping 193 matching lines @@
                                                       clip.getBounds(),
                                                       &patch)) {
         SkASSERT(NULL == patch.fMask.fImage);
         return false;
     }
     draw_nine(patch.fMask, patch.fOuterRect, patch.fCenter, true, clip, blitter);
     SkMask::FreeImage(patch.fMask.fImage);
     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;
+}
+
 bool SkMaskFilter::filterPath(const SkPath& devPath, const SkMatrix& matrix,
                               const SkRasterClip& clip, SkBlitter* blitter,
                               SkPaint::Style style) const {
     SkRect rects[2];
     int rectCount = 0;
     if (SkPaint::kFill_Style == style) {
         rectCount = countNestedRects(devPath, rects);
     }
     if (rectCount > 0) {
         NinePatch patch;
@@ skipping 20 matching lines @@
 
     SkMask  srcM, dstM;
 
     if (!SkDraw::DrawToMask(devPath, &clip.getBounds(), this, &matrix, &srcM,
                             SkMask::kComputeBoundsAndRenderImage_CreateMode,
                             style)) {
         return false;
     }
     SkAutoMaskFreeImage autoSrc(srcM.fImage);
 
-    if (!this->filterMask(&dstM, srcM, matrix, NULL)) {
+    // Don't actually do the blur the first time, just compute the correct bounds.
+    SkMask tmpSrc, tmpDst;
+    tmpSrc = srcM;
+    tmpSrc.fImage = NULL;
+    if (!this->filterMask(&tmpDst, tmpSrc, matrix, NULL)) {
         return false;
     }
-    SkAutoMaskFreeImage autoDst(dstM.fImage);
+
+    BlurRec rec;
+    uint8_t* maskImage = NULL;
+
+    // Try to cache blur effect applied on a path which is consist of 1 or 2 rects.
+    // Dst mask of unclipped path is saved in the cache.
+    // Actual clipped dst mask is extracted from the unclipped dst mask according bounds.
+    if (this->asABlur(&rec) && rectCount && !rect_exceeds(rects[0], SkIntToScalar(32767))) {
+        SkMask  srcMUnclipped, dstMUnclipped;
+        SkScalar scaledSigma = matrix.mapRadius(rec.fSigma);
+
+        if (SkMaskCache::FindAndCopy(scaledSigma, rec.fStyle, rec.fQuality,
+                                     rects, rectCount, &dstMUnclipped)) {
+            if (!SkDraw::DrawToMask(devPath, NULL, this, &matrix, &srcMUnclipped,
+                                    SkMask::kJustComputeBounds_CreateMode,
+                                    style)) {
+                return false;
+            }
+            srcMUnclipped.fFormat = SkMask::kA8_Format;
+            srcMUnclipped.fRowBytes = srcMUnclipped.fBounds.width();
+        } else {
+            if (!SkDraw::DrawToMask(devPath, NULL, this, &matrix, &srcMUnclipped,
+                                    SkMask::kComputeBoundsAndRenderImage_CreateMode,
+                                    style)) {
+                return false;
+            }
+            SkAutoMaskFreeImage autoSrcUnclipped(srcMUnclipped.fImage);
+            if (!this->filterMask(&dstMUnclipped, srcMUnclipped, matrix, NULL)) {
+                return false;
+            }
+            dstMUnclipped.fBounds.offsetTo(0, 0);
+            SkMaskCache::AddAndCopy(scaledSigma, rec.fStyle, rec.fQuality,
+                                    rects, rectCount, dstMUnclipped);
+        }
+
+        SkMask tmpSrcUnclipped, tmpDstUnclipped;
+        tmpSrcUnclipped = srcMUnclipped;
+        tmpSrcUnclipped.fImage = NULL;
+        if (!this->filterMask(&tmpDstUnclipped, tmpSrcUnclipped, matrix, NULL)) {
+            return false;
+        }
+        SkASSERT(tmpDstUnclipped.fBounds.contains(tmpDst.fBounds));
+
+        dstM.fBounds = tmpDst.fBounds;
+        dstM.fBounds.offsetTo(tmpDst.fBounds.fLeft - tmpDstUnclipped.fBounds.fLeft,
+                              tmpDst.fBounds.fTop - tmpDstUnclipped.fBounds.fTop);
+        extractMaskSubset(dstMUnclipped, &dstM);
+        dstM.fBounds.offsetTo(tmpDst.fBounds.fLeft, tmpDst.fBounds.fTop);
+
+        maskImage = dstMUnclipped.fImage;
+    } else {
+        if (!this->filterMask(&dstM, srcM, matrix, NULL)) {
+            return false;
+        }
+
+        maskImage = dstM.fImage;
+    }
+
+    SkAutoMaskFreeImage autoDst(maskImage);
 
     // if we get here, we need to (possibly) resolve the clip and blitter
     SkAAClipBlitterWrapper wrapper(clip, blitter);
     blitter = wrapper.getBlitter();
 
     SkRegion::Cliperator clipper(wrapper.getRgn(), dstM.fBounds);
 
     if (!clipper.done()) {
         const SkIRect& cr = clipper.rect();
         do {
@@ skipping 63 matching lines @@
     srcM.fRowBytes = 0;
     srcM.fFormat = SkMask::kA8_Format;
 
     SkIPoint margin;    // ignored
     if (this->filterMask(&dstM, srcM, SkMatrix::I(), &margin)) {
         dst->set(dstM.fBounds);
     } else {
         dst->set(srcM.fBounds);
     }
 }