first attempt to plumb fast blur code into skia mask filter

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"
@@ skipping 1182 matching lines @@
     all the time, we actually fill in the profile pre-inverted
     (already done 255-x).
 
     The function returns the size of the array allocated for the
     profile.  It's the responsibility of the caller to delete the
     memory returned in profile_out.
 */
 
 static int compute_profile(SkScalar radius, unsigned int **profile_out) {
     int size = SkScalarRoundToInt(radius * 3);
-    int center = size >> 1;
+    
+    if (profile_out) {
+        int center = size >> 1;
+        unsigned int *profile = SkNEW_ARRAY(unsigned int, size);
 
-    unsigned int *profile = SkNEW_ARRAY(unsigned int, size);
+        float invr = 1.f/radius;
 
-    float invr = 1.f/radius;
+        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[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;
     }
-
-    *profile_out = profile;
     return size;
 }
 
 // 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,
-                          SkIPoint *margin) {
+                          SkIPoint *margin, bool perform_blur) {
     int profile_size;
-    unsigned int *profile;
+    unsigned int *profile = NULL;
 
     float radius = SkScalarToFloat( SkScalarMul( provided_radius, kBlurRadiusFudgeFactor ) );
 
     // adjust blur radius to match interpretation from boxfilter code
     radius = (radius + .5f) *2.f;

[bungeman-skia, 2013/03/11 19:47:41]

My eyes... need a space after *

 
-    profile_size = compute_profile( radius, &profile );
+    profile_size = compute_profile( radius, perform_blur ? &profile : NULL );

[bungeman-skia, 2013/03/11 19:47:41]

It feels awkward to have this check here and another check in the function. Can
we separate 'size' from 'profile' since one if a logical part of the blur (or at
least out blur approximation) and the other an implementation detail?

 
     SkAutoTDeleteArray<unsigned int> ada(profile);
 
     int pad = profile_size/2;
     if (margin) {
         margin->set( pad, pad );
     }
 
     int shadow_left = -pad;
     int shadow_top = -pad;
     int shadow_right = (int)(src.width()) + pad;
     int shadow_bottom = (int)(src.height()) + pad;
 
-    dst->fBounds.set(shadow_left, shadow_top, shadow_right, shadow_bottom);
+    dst->fBounds.set(shadow_left + src.fLeft, shadow_top + src.fTop, shadow_right + src.fRight, shadow_bottom + src.fBottom);

[bungeman-skia, 2013/03/11 19:47:41]

Nit: This line got really long. A few more below.

 
     dst->fRowBytes = dst->fBounds.width();
     dst->fFormat = SkMask::kA8_Format;
     dst->fImage = NULL;
-
-    size_t dstSize = dst->computeImageSize();
-    if (0 == dstSize) {
-        return false;   // too big to allocate, abort
-    }
-
+    
     int             sw = SkScalarFloorToInt(src.width());
     int             sh = SkScalarFloorToInt(src.height());
+    
+    if (perform_blur) {

[bungeman-skia, 2013/03/11 19:47:41]

Can we put the else clause under !perform_blur and return true in there, leaving
the rest of the 'meat' unindented?

+        size_t dstSize = dst->computeImageSize();
+        if (0 == dstSize) {
+            return false;   // too big to allocate, abort
+        }
 
-    uint8_t*        dp = SkMask::AllocImage(dstSize);
+        uint8_t*        dp = SkMask::AllocImage(dstSize);
 
-    dst->fImage = dp;
+        dst->fImage = dp;
 
-    int dstHeight = dst->fBounds.height();
-    int dstWidth = dst->fBounds.width();
+        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;
+        // 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;
+        int w = sw - center;
+        int h = sh - center;
 
-    uint8_t *outptr = dp;
+        uint8_t *outptr = dp;
 
-    SkAutoTMalloc<uint8_t> horizontalScanline(dstWidth);
+        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;
-            horizontalScanline[x] = (uint8_t) (255 * (gaussianIntegral(giX) - gaussianIntegral(giX + span)));
+        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;
+                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;
+                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) {
+            // now we allocate the "real" dst, mirror the size of src
+            size_t srcSize = (size_t)(src.width() * src.height());
+            if (0 == srcSize) {
+                return false;   // too big to allocate, abort
+            }
+            dst->fImage = SkMask::AllocImage(srcSize);
+            for (int y = 0 ; y < sh ; y++) {
+                uint8_t *blur_scanline = dp + (y+pad)*dstWidth + pad;
+                uint8_t *inner_scanline = dst->fImage + y*sw;
+                memcpy(inner_scanline, blur_scanline, sw);
+            }
+            SkMask::FreeImage(dp);
+
+            dst->fBounds.set(0, 0, sw, sh); // restore trimmed bounds
+            dst->fRowBytes = sw;
+
+        } else if (style == kOuter_Style) {
+            for (int y = pad ; y < dstHeight-pad ; y++) {
+                uint8_t *dst_scanline = dp + y*dstWidth + pad;
+                memset(dst_scanline, 0, sw);
+            }
+        }
+        // normal and solid styles are the same for analytic rect blurs, so don't
+        // need to handle solid specially.
+    } else {
+        if (style == kInner_Style) {
+            dst->fBounds.set(0, 0, sw, sh); // restore trimmed bounds
+            dst->fRowBytes = sw;
         }
     }
 
-    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;
-            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) {
-        // now we allocate the "real" dst, mirror the size of src
-        size_t srcSize = (size_t)(src.width() * src.height());
-        if (0 == srcSize) {
-            return false;   // too big to allocate, abort
-        }
-        dst->fImage = SkMask::AllocImage(srcSize);
-        for (int y = 0 ; y < sh ; y++) {
-            uint8_t *blur_scanline = dp + (y+pad)*dstWidth + pad;
-            uint8_t *inner_scanline = dst->fImage + y*sw;
-            memcpy(inner_scanline, blur_scanline, sw);
-        }
-        SkMask::FreeImage(dp);
-
-        dst->fBounds.set(0, 0, sw, sh); // restore trimmed bounds
-        dst->fRowBytes = sw;
-
-    } else if (style == kOuter_Style) {
-        for (int y = pad ; y < dstHeight-pad ; y++) {
-            uint8_t *dst_scanline = dp + y*dstWidth + pad;
-            memset(dst_scanline, 0, sw);
-        }
-    }
-    // normal and solid styles are the same for analytic rect blurs, so don't
-    // need to handle solid specially.
-
     return 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) {
 
@@ skipping 132 matching lines @@
         (void)autoCall.detach();
     }
 
     if (style == kInner_Style) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }