Blur refactoring

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"
 
-const SkScalar SkBlurMask::kBlurRadiusFudgeFactor = SkFloatToScalar(.57735f);
+
+SkScalar SkBlurMask::ConvertRadiusToSigma(SkScalar 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 = SkFloatToScalar(0.57735f);
+
+    return radius ? kBLUR_SIGMA_SCALE * radius + 0.5f : 0.0f;
+}
 
 #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 438 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // we use a local function to wrap the class static method to work around
 // a bug in gcc98
 void SkMask_FreeImage(uint8_t* image);
 void SkMask_FreeImage(uint8_t* image) {
     SkMask::FreeImage(image);
 }
 
-bool SkBlurMask::Blur(SkMask* dst, const SkMask& src,
-                      SkScalar radius, Style style, Quality quality,
-                      SkIPoint* margin)
-{
+bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
+                         SkScalar radius, Style style, Quality quality,
+                         SkIPoint* margin) {
+    return SkBlurMask::BoxBlur(dst, src, 
+                               SkBlurMask::ConvertRadiusToSigma(radius),
+                               style, quality, margin, true);
+}
+
+bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
+                         SkScalar sigma, Style style, Quality quality,
+                         SkIPoint* margin, bool unused) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 
     // Force high quality off for small radii (performance)

[robertphillips, 2013/08/05 18:11:27]

This should really be 2.232 to be completely consistent with the old code but
using 2 doesn't introduce a lot of differences.

-    if (radius < SkIntToScalar(3)) {
+    if (sigma <= SkIntToScalar(2)) {
         quality = kLow_Quality;
     }
 

[robertphillips, 2013/08/05 18:11:27]

If we were willing to live with this code here:

   SkScalar passRadius = (kHigh_Quality == quality) ? sigma - 0.5f :
                     (sigma - 0.5f) / SkBlurMask::kBLUR_SIGMA_SCALE;

The only GM image differences we would have would be in the GPU path. The
downside of this is that it lets kBLUR_SIGMA_SCALE out of its box.

+    SkScalar passRadius;
+    if (kHigh_Quality == quality) {
+        // For the high quality path the 3 pass box blur kernel width is
+        // 6*rad+1 while the full Gaussian width is 6*sigma.
+        passRadius = sigma - (1/6.0f);
+    } else {
+        // For the low quality path we only attempt to cover 3*sigma of the 
+        // Gaussian blur area (1.5*sigma on each side). The single pass box 
+        // blur's kernel size is 2*rad+1.
+        passRadius = 1.5f*sigma - 0.5f;
+    }
+
     // 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):
-                          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;
     }
 
     int ry = rx;    // only do square blur for now
 
     int padx = passCount * rx;
     int pady = passCount * ry;
 
     if (margin) {
         margin->set(padx, pady);
     }
     dst->fBounds.set(src.fBounds.fLeft - padx, src.fBounds.fTop - pady,
-        src.fBounds.fRight + padx, src.fBounds.fBottom + pady);
+                     src.fBounds.fRight + padx, src.fBounds.fBottom + pady);
 
     dst->fRowBytes = dst->fBounds.width();
     dst->fFormat = SkMask::kA8_Format;
     dst->fImage = NULL;
 
     if (src.fImage) {
         size_t dstSize = dst->computeImageSize();
         if (0 == dstSize) {
             return false;   // too big to allocate, abort
         }
@@ skipping 120 matching lines @@
 
     if ( x > 0.5f ) {
         return 0.5625f - (x3 / 6.0f - 3.0f * x2 * 0.25f + 1.125f * x);
     }
     if ( x > -0.5f ) {
         return 0.5f - (0.75f * x - x3 / 3.0f);
     }
     return 0.4375f + (-x3 / 6.0f - 3.0f * x2 * 0.25f - 1.125f * x);
 }
 
-// Compute the size of the array allocated for the profile.
-
-static int compute_profile_size(SkScalar radius) {
-    return SkScalarRoundToInt(radius * 3);
-
-}
-
 /*  compute_profile allocates and fills in an array of floating
     point values between 0 and 255 for the profile signature of
     a blurred half-plane with the given blur radius.  Since we're
     going to be doing screened multiplications (i.e., 1 - (1-x)(1-y))
     all the time, we actually fill in the profile pre-inverted
     (already done 255-x).
 
     It's the responsibility of the caller to delete the
     memory returned in profile_out.
 */
 
-static void compute_profile(SkScalar radius, unsigned int **profile_out) {
-    int size = compute_profile_size(radius);
+static void compute_profile(SkScalar sigma, unsigned int **profile_out) {
+    int size = SkScalarCeilToInt(6*sigma);
 
     int center = size >> 1;
     unsigned int *profile = SkNEW_ARRAY(unsigned int, size);
 
-    float invr = 1.f/radius;
+    float invr = 1.f/(2*sigma);
 
     profile[0] = 255;
     for (int x = 1 ; x < size ; ++x) {
         float scaled_x = (center - x - .5f) * invr;
         float gi = gaussianIntegral(scaled_x);
         profile[x] = 255 - (uint8_t) (255.f * gi);
     }
 
     *profile_out = profile;
 }
 
 // TODO MAYBE: Maintain a profile cache to avoid recomputing this for
 // commonly used radii.  Consider baking some of the most common blur radii
 // directly in as static data?
 
 // Implementation adapted from Michael Herf's approach:
 // http://stereopsis.com/shadowrect/
 
 static inline unsigned int profile_lookup( unsigned int *profile, int loc, int blurred_width, int sharp_width ) {
     int dx = SkAbs32(((loc << 1) + 1) - blurred_width) - sharp_width; // how far are we from the original edge?
     int ox = dx >> 1;
     if (ox < 0) {
         ox = 0;
     }
 
     return profile[ox];
 }
 
 bool SkBlurMask::BlurRect(SkMask *dst, const SkRect &src,
-                          SkScalar provided_radius, Style style,
+                          SkScalar radius, Style style,
                           SkIPoint *margin, SkMask::CreateMode createMode) {
-    int profile_size;
+    return SkBlurMask::BlurRect(dst, src, 
+                                SkBlurMask::ConvertRadiusToSigma(radius),
+                                style, margin, createMode, true);
+}
 
-    float radius = SkScalarToFloat(SkScalarMul(provided_radius, kBlurRadiusFudgeFactor));
-
-    // adjust blur radius to match interpretation from boxfilter code
-    radius = (radius + .5f) * 2.f;
-
-    profile_size = compute_profile_size(radius);
+bool SkBlurMask::BlurRect(SkMask *dst, const SkRect &src,
+                          SkScalar sigma, Style style,
+                          SkIPoint *margin, SkMask::CreateMode createMode, bool unused) {
+    int profile_size = SkScalarCeilToInt(6*sigma);
 
     int pad = profile_size/2;
     if (margin) {
         margin->set( pad, pad );
     }
 
     dst->fBounds.set(SkScalarRoundToInt(src.fLeft - pad),
                      SkScalarRoundToInt(src.fTop - pad),
                      SkScalarRoundToInt(src.fRight + pad),
                      SkScalarRoundToInt(src.fBottom + pad));
@@ skipping 10 matching lines @@
             dst->fBounds.set(SkScalarRoundToInt(src.fLeft),
                              SkScalarRoundToInt(src.fTop),
                              SkScalarRoundToInt(src.fRight),
                              SkScalarRoundToInt(src.fBottom)); // restore trimmed bounds
             dst->fRowBytes = sw;
         }
         return true;
     }
     unsigned int *profile = NULL;
 
-    compute_profile(radius, &profile);
+    compute_profile(sigma, &profile);
     SkAutoTDeleteArray<unsigned int> ada(profile);
 
     size_t dstSize = dst->computeImageSize();
     if (0 == dstSize) {
         return false;   // too big to allocate, abort
     }
 
     uint8_t*        dp = SkMask::AllocImage(dstSize);
 
     dst->fImage = dp;
 
     int dstHeight = dst->fBounds.height();
     int dstWidth = dst->fBounds.width();
 
     // nearest odd number less than the profile size represents the center
     // of the (2x scaled) profile
     int center = ( profile_size & ~1 ) - 1;
 
     int w = sw - center;
     int h = sh - center;
 
     uint8_t *outptr = dp;
 
     SkAutoTMalloc<uint8_t> horizontalScanline(dstWidth);
 
     for (int x = 0 ; x < dstWidth ; ++x) {
         if (profile_size <= sw) {
             horizontalScanline[x] = profile_lookup(profile, x, dstWidth, w);
         } else {
-            float span = float(sw)/radius;
-            float giX = 1.5f - (x+.5f)/radius;
+            float span = float(sw)/(2*sigma);
+            float giX = 1.5f - (x+.5f)/(2*sigma);
             horizontalScanline[x] = (uint8_t) (255 * (gaussianIntegral(giX) - gaussianIntegral(giX + span)));
         }
     }
 
     for (int y = 0 ; y < dstHeight ; ++y) {
         unsigned int profile_y;
         if (profile_size <= sh) {
             profile_y = profile_lookup(profile, y, dstHeight, h);
         } else {
-            float span = float(sh)/radius;
-            float giY = 1.5f - (y+.5f)/radius;
+            float span = float(sh)/(2*sigma);
+            float giY = 1.5f - (y+.5f)/(2*sigma);
             profile_y = (uint8_t) (255 * (gaussianIntegral(giY) - gaussianIntegral(giY + span)));
         }
 
         for (int x = 0 ; x < dstWidth ; x++) {
             unsigned int maskval = SkMulDiv255Round(horizontalScanline[x], profile_y);
             *(outptr++) = maskval;
         }
     }
 
     if (style == kInner_Style) {
@@ skipping 26 matching lines @@
             uint8_t *dst_scanline = dp + y*dstWidth + pad;
             memset(dst_scanline, 0xff, sw);
         }
     }
     // normal and solid styles are the same for analytic rect blurs, so don't
     // need to handle solid specially.
 
     return true;
 }
 
+bool SkBlurMask::BlurGroundTruth(SkMask* dst, const SkMask& src, SkScalar radius,
+                            Style style, SkIPoint* margin) {
+    return BlurGroundTruth(dst, src, ConvertRadiusToSigma(radius), style, margin, true);
+}
 // The "simple" blur is a direct implementation of separable convolution with a discrete
 // 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) {
+bool SkBlurMask::BlurGroundTruth(SkMask* dst, const SkMask& src, SkScalar sigma,
+                                 Style style, SkIPoint* margin, bool unused) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 

[robertphillips, 2013/08/05 18:11:27]

This is a bit of a radical switch in how sigma is computed. The old method was:
  rad*K/2 
while the new is:
  rad*K + .5

-    float radius = SkScalarToFloat(SkScalarMul(provided_radius, kBlurRadiusFudgeFactor));
-    float stddev = SkScalarToFloat(radius) /2.0f;
-    float variance = stddev * stddev;
+    float variance = sigma * sigma;
 
-    int windowSize = SkScalarCeil(stddev*4);
+    int windowSize = SkScalarCeil(sigma*4);
     // round window size up to nearest odd number
     windowSize |= 1;
 
     SkAutoTMalloc<float> gaussWindow(windowSize);
 
     int halfWindow = windowSize >> 1;
 
     gaussWindow[halfWindow] = 1;
 
     float windowSum = 1;
@@ skipping 113 matching lines @@
         (void)autoCall.detach();
     }
 
     if (style == kInner_Style) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }