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 1167 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).
 
-    The function returns the size of the array allocated for the
-    profile.  It's the responsibility of the caller to delete the
+    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);
+static void compute_profile(SkScalar radius, unsigned int **profile_out) {
+    int size = compute_profile_size(radius);
+    
     int center = size >> 1;
-
     unsigned int *profile = SkNEW_ARRAY(unsigned int, size);
 
     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_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, SkMask::CreateMode createMode) {
     int profile_size;
-    unsigned int *profile;
 
-    float radius = SkScalarToFloat( SkScalarMul( provided_radius, kBlurRadiusFudgeFactor ) );
+    float radius = SkScalarToFloat(SkScalarMul(provided_radius, kBlurRadiusFudgeFactor));
 
     // adjust blur radius to match interpretation from boxfilter code
-    radius = (radius + .5f) *2.f;
+    radius = (radius + .5f) * 2.f;
 
-    profile_size = compute_profile( radius, &profile );
-
-    SkAutoTDeleteArray<unsigned int> ada(profile);
-
+    profile_size = compute_profile_size(radius);
+    
     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);
 
     dst->fRowBytes = dst->fBounds.width();
     dst->fFormat = SkMask::kA8_Format;
     dst->fImage = NULL;
-
+    
+    int             sw = SkScalarFloorToInt(src.width());
+    int             sh = SkScalarFloorToInt(src.height());
+    
+    if (createMode == SkMask::kJustComputeBounds_CreateMode) {
+        if (style == kInner_Style) {
+            dst->fBounds.set(0, 0, sw, sh); // restore trimmed bounds
+            dst->fRowBytes = sw;
+        }
+        return true;
+    }
+    unsigned int *profile = NULL;
+    
+    compute_profile(radius, &profile);
+    SkAutoTDeleteArray<unsigned int> ada(profile);
+    
     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());
-
     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;
@@ skipping 202 matching lines @@
         (void)autoCall.detach();
     }
 
     if (style == kInner_Style) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }