Fix quickReject computation for blurs

src/effects/SkBlurMask.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 "SkBlurMask.h"
 #include "SkMath.h"
 #include "SkTemplates.h"
 #include "SkEndian.h"
-
-// scale factor for the blur radius to match the behavior of the all existing blur
-// code (both on the CPU and the GPU).  This magic constant is  1/sqrt(3).
-
-// TODO: get rid of this fudge factor and move any required fudging up into
-// the calling library
-
-#define kBlurRadiusFudgeFactor SkFloatToScalar( .57735f )
+#include "SkBlurMaskFilter.h"
 
 #define UNROLL_SEPARABLE_LOOPS
 
 /**
  * This function performs a box blur in X, of the given radius.  If the
  * "transpose" parameter is true, it will transpose the pixels on write,
  * such that X and Y are swapped. Reads are always performed from contiguous
  * memory in X, for speed. The destination buffer (dst) must be at least
  * (width + leftRadius + rightRadius) * height bytes in size.
  *
@@ skipping 456 matching lines @@
 
     // Force high quality off for small radii (performance)
     if (radius < SkIntToScalar(3)) {
         quality = kLow_Quality;
     }
 
     // highQuality: use three box blur passes as a cheap way
     // to approximate a Gaussian blur
     int passCount = (kHigh_Quality == quality) ? 3 : 1;
     SkScalar passRadius = (kHigh_Quality == quality) ?
-                          SkScalarMul( radius, kBlurRadiusFudgeFactor):
+                          SkScalarMul( radius, SkBlurMaskFilter::kBlurRadiusFudgeFactor):
                           radius;
 
     int rx = SkScalarCeil(passRadius);
     int outerWeight = 255 - SkScalarRound((SkIntToScalar(rx) - passRadius) * 255);
 
     SkASSERT(rx >= 0);
     SkASSERT((unsigned)outerWeight <= 255);
     if (rx <= 0) {
         return false;
     }
@@ skipping 199 matching lines @@
     }
 
     return profile[ox];
 }
 
 bool SkBlurMask::BlurRect(SkMask *dst, const SkRect &src,
                           SkScalar provided_radius, Style style,
                           SkIPoint *margin, SkMask::CreateMode createMode) {
     int profile_size;
 
-    float radius = SkScalarToFloat(SkScalarMul(provided_radius, kBlurRadiusFudgeFactor));
+    float radius = SkScalarToFloat(SkScalarMul(provided_radius, SkBlurMaskFilter::kBlurRadiusFudgeFactor));
 
     // adjust blur radius to match interpretation from boxfilter code
     radius = (radius + .5f) * 2.f;
 
     profile_size = compute_profile_size(radius);
 
     int pad = profile_size/2;
     if (margin) {
         margin->set( pad, pad );
     }
@@ skipping 115 matching lines @@
 // gaussian kernel.  It's "ground truth" in a sense; too slow to be used, but very
 // useful for correctness comparisons.
 
 bool SkBlurMask::BlurGroundTruth(SkMask* dst, const SkMask& src, SkScalar provided_radius,
                             Style style, SkIPoint* margin) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 
-    float radius = SkScalarToFloat(SkScalarMul(provided_radius, kBlurRadiusFudgeFactor));
+    float radius = SkScalarToFloat(SkScalarMul(provided_radius, SkBlurMaskFilter::kBlurRadiusFudgeFactor));
     float stddev = SkScalarToFloat(radius) /2.0f;
     float variance = stddev * stddev;
 
     int windowSize = SkScalarCeil(stddev*4);
     // round window size up to nearest odd number
     windowSize |= 1;
 
     SkAutoTMalloc<float> gaussWindow(windowSize);
 
     int halfWindow = windowSize >> 1;
@@ skipping 117 matching lines @@
         (void)autoCall.detach();
     }
 
     if (style == kInner_Style) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }