Blur refactoring

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 "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
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
 public:
-    SkBlurMaskFilterImpl(SkScalar radius, SkBlurMaskFilter::BlurStyle,
-                         uint32_t flags);
+    SkBlurMaskFilterImpl(SkScalar sigma, 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;
 
 #if SK_SUPPORT_GPU
     virtual bool canFilterMaskGPU(const SkRect& devBounds,
                                   const SkIRect& clipBounds,
                                   const SkMatrix& ctm,
@@ skipping 14 matching lines @@
                                            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_RADIUS;
-    // This constant approximates the scaling done in the software path's
-    // "high quality" mode, in SkBlurMask::Blur() (1 / sqrt(3)).
-    // IMHO, it actually should be 1:  we blur "less" than we should do
-    // according to the CSS and canvas specs, simply because Safari does the same.
-    // Firefox used to do the same too, until 4.0 where they fixed it.  So at some
-    // point we should probably get rid of these scaling constants and rebaseline
-    // all the blur tests.
-    static const SkScalar kBLUR_SIGMA_SCALE;
+    static const SkScalar kMAX_BLUR_SIGMA;
 
-    SkScalar                    fRadius;
+    SkScalar                    fSigma;
     SkBlurMaskFilter::BlurStyle fBlurStyle;
     uint32_t                    fBlurFlags;
 
     SkBlurMaskFilterImpl(SkFlattenableReadBuffer&);
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
-#if SK_SUPPORT_GPU
-    SkScalar computeXformedRadius(const SkMatrix& ctm) const {
+
+    SkScalar computeXformedSigma(const SkMatrix& ctm) const {
         bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
 
-        SkScalar xformedRadius = ignoreTransform ? fRadius
-                                                 : ctm.mapRadius(fRadius);
-        return SkMinScalar(xformedRadius, kMAX_BLUR_RADIUS);
+        SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma);
+        return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
     }
-#endif
 
     typedef SkMaskFilter INHERITED;
 };
 
-const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_RADIUS = SkIntToScalar(128);
-const SkScalar SkBlurMaskFilterImpl::kBLUR_SIGMA_SCALE = SkFloatToScalar(0.6f);
+const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
 SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius,
                                        SkBlurMaskFilter::BlurStyle style,
                                        uint32_t flags) {
     // use !(radius > 0) instead of radius <= 0 to reject NaN values
     if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
         || flags > SkBlurMaskFilter::kAll_BlurFlag) {
         return NULL;
     }
 
-    return SkNEW_ARGS(SkBlurMaskFilterImpl, (radius, style, flags));
+    SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
+
+    return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags));
+}
+
+SkMaskFilter* SkBlurMaskFilter::Create(SkBlurMaskFilter::BlurStyle style,
+                                       SkScalar sigma,
+                                       uint32_t flags) {
+    // use !(sigma > 0) instead of sigma <= 0 to reject NaN values
+    if (!(sigma > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
+        || flags > SkBlurMaskFilter::kAll_BlurFlag) {
+        return NULL;
+    }
+
+    return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar radius,
+SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma,
                                            SkBlurMaskFilter::BlurStyle style,
                                            uint32_t flags)
-    : fRadius(radius), fBlurStyle(style), fBlurFlags(flags) {
+    : fSigma(sigma), fBlurStyle(style), fBlurFlags(flags) {
 #if 0
     fGamma = NULL;
     if (gammaScale) {
         fGamma = new U8[256];
         if (gammaScale > 0)
             SkBlurMask::BuildSqrGamma(fGamma, gammaScale);
         else
             SkBlurMask::BuildSqrtGamma(fGamma, -gammaScale);
     }
 #endif
-    SkASSERT(radius >= 0);
+    SkASSERT(fSigma >= 0);
     SkASSERT((unsigned)style < SkBlurMaskFilter::kBlurStyleCount);
     SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag);
 }
 
 SkMask::Format SkBlurMaskFilterImpl::getFormat() const {
     return SkMask::kA8_Format;
 }
 
 bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src,
                                       const SkMatrix& matrix,
                                       SkIPoint* margin) const{
-    SkScalar radius;
-    if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
-        radius = fRadius;
-    } else {
-        radius = matrix.mapRadius(fRadius);
-    }
+    SkScalar sigma = this->computeXformedSigma(matrix);
 
-    radius = SkMinScalar(radius, kMAX_BLUR_RADIUS);
     SkBlurMask::Quality blurQuality =
         (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ?
             SkBlurMask::kHigh_Quality : SkBlurMask::kLow_Quality;
 
-    return SkBlurMask::Blur(dst, src, radius, (SkBlurMask::Style)fBlurStyle,
-                            blurQuality, margin);
+    return SkBlurMask::BoxBlur(dst, src, sigma, (SkBlurMask::Style)fBlurStyle,
+                               blurQuality, margin);
 }
 
 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
                                           const SkMatrix& matrix,
                                           SkIPoint* margin, SkMask::CreateMode createMode) const{
-    SkScalar radius;
-    if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
-        radius = fRadius;
-    } else {
-        radius = matrix.mapRadius(fRadius);
-    }
+    SkScalar sigma = computeXformedSigma(matrix);
 
-    radius = SkMinScalar(radius, kMAX_BLUR_RADIUS);
-
-    return SkBlurMask::BlurRect(dst, r, radius, (SkBlurMask::Style)fBlurStyle,
+    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);
     mask->fRowBytes = SkAlign4(mask->fBounds.width());
     mask->fFormat = SkMask::kA8_Format;
     size_t size = mask->computeImageSize();
@@ skipping 153 matching lines @@
         }
     }
     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 {
-    SkScalar gpuPad, rasterPad;
-
-    {
-        // GPU path
-        SkScalar sigma = SkScalarMul(fRadius, kBLUR_SIGMA_SCALE);
-        gpuPad = sigma * 3.0f;
-    }
-
-    {
-        // raster path
-        SkScalar radius = SkScalarMul(fRadius, SkBlurMask::kBlurRadiusFudgeFactor);
-
-        radius = (radius + .5f) * 2.f;
-
-        rasterPad = SkIntToScalar(SkScalarRoundToInt(radius * 3)/2);
-    }
-
-    SkScalar pad = SkMaxScalar(gpuPad, rasterPad);
+    SkScalar pad = 3.0f * fSigma;
 
     dst->set(src.fLeft  - pad, src.fTop    - pad,
              src.fRight + pad, src.fBottom + pad);
 }
 
 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkFlattenableReadBuffer& buffer)
         : SkMaskFilter(buffer) {
-    fRadius = buffer.readScalar();
+    fSigma = buffer.readScalar();
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V13_AND_ALL_OTHER_INSTANCES_TOO
+    // Fixing this must be done in two stages. When the skps are recaptured in V13,
+    // remove the ConvertRadiusToSigma but retain the absolute value. 
+    // At the same time, switch the code in flatten to write a positive value.
+    // When the skps are captured in V14 the absolute value can be removed.
+    if (fSigma > 0) {
+        fSigma = SkBlurMask::ConvertRadiusToSigma(fSigma);
+    } else {
+        fSigma = -fSigma;
+    }
+#endif
     fBlurStyle = (SkBlurMaskFilter::BlurStyle)buffer.readInt();
     fBlurFlags = buffer.readUInt() & SkBlurMaskFilter::kAll_BlurFlag;
-    SkASSERT(fRadius >= 0);
+    SkASSERT(fSigma >= 0);
     SkASSERT((unsigned)fBlurStyle < SkBlurMaskFilter::kBlurStyleCount);
 }
 
 void SkBlurMaskFilterImpl::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
-    buffer.writeScalar(fRadius);
+    buffer.writeScalar(-fSigma);
     buffer.writeInt(fBlurStyle);
     buffer.writeUInt(fBlurFlags);
 }
 
 #if SK_SUPPORT_GPU
 
 bool SkBlurMaskFilterImpl::canFilterMaskGPU(const SkRect& srcBounds,
                                             const SkIRect& clipBounds,
                                             const SkMatrix& ctm,
                                             SkRect* maskRect) const {
-    SkScalar xformedRadius = this->computeXformedRadius(ctm);
-    if (xformedRadius <= 0) {
+    SkScalar xformedSigma = this->computeXformedSigma(ctm);
+    if (xformedSigma <= 0) {
         return false;
     }
 
-    static const SkScalar kMIN_GPU_BLUR_SIZE = SkIntToScalar(64);
-    static const SkScalar kMIN_GPU_BLUR_RADIUS = SkIntToScalar(32);
+    static const SkScalar kMIN_GPU_BLUR_SIZE  = SkIntToScalar(64);
+    static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32);
 
     if (srcBounds.width() <= kMIN_GPU_BLUR_SIZE &&
         srcBounds.height() <= kMIN_GPU_BLUR_SIZE &&
-        xformedRadius <= kMIN_GPU_BLUR_RADIUS) {
+        xformedSigma <= kMIN_GPU_BLUR_SIGMA) {
         // We prefer to blur small rect with small radius via CPU.
         return false;
     }
 
     if (NULL == maskRect) {
         // don't need to compute maskRect
         return true;
     }
 
-    float sigma3 = 3 * SkScalarToFloat(xformedRadius) * kBLUR_SIGMA_SCALE;
+    float sigma3 = 3 * SkScalarToFloat(xformedSigma);
 
     SkRect clipRect = SkRect::MakeFromIRect(clipBounds);
     SkRect srcRect(srcBounds);
 
     // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
     srcRect.outset(SkFloatToScalar(sigma3), SkFloatToScalar(sigma3));
     clipRect.outset(SkFloatToScalar(sigma3), SkFloatToScalar(sigma3));
     srcRect.intersect(clipRect);
     *maskRect = srcRect;
     return true;
 }
 
 bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
                                          const SkRect& maskRect,
                                          GrTexture** result,
                                          bool canOverwriteSrc) const {
     SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height());
 
     GrContext* context = src->getContext();
 
     GrContext::AutoWideOpenIdentityDraw awo(context, NULL);
 
-    SkScalar xformedRadius = this->computeXformedRadius(context->getMatrix());
-    SkASSERT(xformedRadius > 0);
-
-    float sigma = SkScalarToFloat(xformedRadius) * kBLUR_SIGMA_SCALE;
+    SkScalar xformedSigma = this->computeXformedSigma(context->getMatrix());
+    SkASSERT(xformedSigma > 0);
 
     // If we're doing a normal blur, we can clobber the pathTexture in the
     // gaussianBlur.  Otherwise, we need to save it for later compositing.
     bool isNormalBlur = (SkBlurMaskFilter::kNormal_BlurStyle == fBlurStyle);
     *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOverwriteSrc,
-                                           clipRect, false, sigma, sigma);
+                                           clipRect, false, xformedSigma, xformedSigma);
     if (NULL == *result) {
         return false;
     }
 
     if (!isNormalBlur) {
         context->setIdentityMatrix();
         GrPaint paint;
         SkMatrix matrix;
         matrix.setIDiv(src->width(), src->height());
         // Blend pathTexture over blurTexture.
@@ skipping 17 matching lines @@
     return true;
 }
 
 #endif // SK_SUPPORT_GPU
 
 
 #ifdef SK_DEVELOPER
 void SkBlurMaskFilterImpl::toString(SkString* str) const {
     str->append("SkBlurMaskFilterImpl: (");
 
-    str->append("radius: ");
-    str->appendScalar(fRadius);
+    str->append("sigma: ");
+    str->appendScalar(fSigma);
     str->append(" ");
 
     static const char* gStyleName[SkBlurMaskFilter::kBlurStyleCount] = {
         "normal", "solid", "outer", "inner"
     };
 
     str->appendf("style: %s ", gStyleName[fBlurStyle]);
     str->append("flags: (");
     if (fBlurFlags) {
         bool needSeparator = false;
         SkAddFlagToString(str,
                           SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag),
                           "IgnoreXform", &needSeparator);
         SkAddFlagToString(str,
                           SkToBool(fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag),
                           "HighQuality", &needSeparator);
     } 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