plumb API for analytic rrect blur

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 457 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) {
-    return SkBlurMask::BoxBlur(dst, src,
-                               SkBlurMask::ConvertRadiusToSigma(radius),
-                               style, quality, margin);
-}
-
 bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
                          SkScalar sigma, Style style, Quality quality,
                          SkIPoint* margin) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 
     // Force high quality off for small radii (performance)
     if (sigma <= SkIntToScalar(2)) {
@@ skipping 238 matching lines @@
        if (profile_size <= sw) {
            pixels[x] = ProfileLookup(profile, x, width, w);
        } else {
            float span = float(sw)/(2*sigma);
            float giX = 1.5f - (x+.5f)/(2*sigma);
            pixels[x] = (uint8_t) (255 * (gaussianIntegral(giX) - gaussianIntegral(giX + span)));
        }
     }
 }
 
-bool SkBlurMask::BlurRect(SkMask *dst, const SkRect &src,
-                          SkScalar radius, Style style,
-                          SkIPoint *margin, SkMask::CreateMode createMode) {
-    return SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(radius),
-                                dst, src,
-                                style, margin, createMode);
-}
-
 bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst,
                           const SkRect &src, Style style,
                           SkIPoint *margin, SkMask::CreateMode createMode) {
     int profile_size = SkScalarCeilToInt(6*sigma);
 
     int pad = profile_size/2;
     if (margin) {
         margin->set( pad, pad );
     }
 
@@ skipping 81 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(ConvertRadiusToSigma(radius), dst, src, style, margin);
+bool SkBlurMask::BlurRRect(SkScalar sigma, SkMask *dst,
+                           const SkRRect &src, Style style,
+                           SkIPoint *margin, SkMask::CreateMode createMode) {
+    // Temporary for now -- always fail, should cause caller to fall back
+    // to old path.  Plumbing just to land API and parallelize effort.
+
+    return false;
 }
+
 // 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(SkScalar sigma, SkMask* dst, const SkMask& src,
                                  Style style, SkIPoint* margin) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
@@ skipping 127 matching lines @@
         (void)autoCall.detach();
     }
 
     if (style == kInner_Style) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }