move common blur types into central header

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 417 matching lines @@
         }
         dst += dstRB;
         src += srcRB;
         blur += blurRB;
     }
 }
 
 static void clamp_with_orig(uint8_t dst[], int dstRowBytes,
                             const uint8_t src[], int srcRowBytes,
                             int sw, int sh,
-                            SkBlurMask::Style style) {
+                            SkBlurStyle style) {
     int x;
     while (--sh >= 0) {
         switch (style) {
-        case SkBlurMask::kSolid_Style:
+        case kSolid_SkBlurStyle:
             for (x = sw - 1; x >= 0; --x) {
                 int s = *src;
                 int d = *dst;
                 *dst = SkToU8(s + d - SkMulDiv255Round(s, d));
                 dst += 1;
                 src += 1;
             }
             break;
-        case SkBlurMask::kOuter_Style:
+        case kOuter_SkBlurStyle:
             for (x = sw - 1; x >= 0; --x) {
                 if (*src) {
                     *dst = SkToU8(SkAlphaMul(*dst, SkAlpha255To256(255 - *src)));
                 }
                 dst += 1;
                 src += 1;
             }
             break;
         default:
             SkDEBUGFAIL("Unexpected blur style here");
             break;
         }
         dst += dstRowBytes - sw;
         src += srcRowBytes - sw;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // 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::BoxBlur(SkMask* dst, const SkMask& src,
-                         SkScalar sigma, Style style, Quality quality,
-                         SkIPoint* margin, bool force_quality) {
-
+bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, SkScalar sigma, SkBlurStyle style,
+                         SkBlurQuality quality, SkIPoint* margin, bool force_quality) {
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 
     // Force high quality off for small radii (performance)
     if (!force_quality && sigma <= SkIntToScalar(2)) {
-        quality = kLow_Quality;
+        quality = kLow_SkBlurQuality;
     }
 
     SkScalar passRadius;
-    if (kHigh_Quality == quality) {
+    if (kHigh_SkBlurQuality == 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;
+    int passCount = (kHigh_SkBlurQuality == quality) ? 3 : 1;
 
     int rx = SkScalarCeilToInt(passRadius);
     int outerWeight = 255 - SkScalarRoundToInt((SkIntToScalar(rx) - passRadius) * 255);
 
     SkASSERT(rx >= 0);
     SkASSERT((unsigned)outerWeight <= 255);
     if (rx <= 0) {
         return false;
     }
 
@@ skipping 25 matching lines @@
         SkAutoTCallVProc<uint8_t, SkMask_FreeImage> autoCall(dp);
 
         // build the blurry destination
         SkAutoTMalloc<uint8_t>  tmpBuffer(dstSize);
         uint8_t*                tp = tmpBuffer.get();
         int w = sw, h = sh;
 
         if (outerWeight == 255) {
             int loRadius, hiRadius;
             get_adjusted_radii(passRadius, &loRadius, &hiRadius);
-            if (kHigh_Quality == quality) {
+            if (kHigh_SkBlurQuality == quality) {
                 // Do three X blurs, with a transpose on the final one.
                 w = boxBlur(sp, src.fRowBytes, tp, loRadius, hiRadius, w, h, false);
                 w = boxBlur(tp, w,             dp, hiRadius, loRadius, w, h, false);
                 w = boxBlur(dp, w,             tp, hiRadius, hiRadius, w, h, true);
                 // Do three Y blurs, with a transpose on the final one.
                 h = boxBlur(tp, h,             dp, loRadius, hiRadius, h, w, false);
                 h = boxBlur(dp, h,             tp, hiRadius, loRadius, h, w, false);
                 h = boxBlur(tp, h,             dp, hiRadius, hiRadius, h, w, true);
             } else {
                 w = boxBlur(sp, src.fRowBytes, tp, rx, rx, w, h, true);
                 h = boxBlur(tp, h,             dp, ry, ry, h, w, true);
             }
         } else {
-            if (kHigh_Quality == quality) {
+            if (kHigh_SkBlurQuality == quality) {
                 // Do three X blurs, with a transpose on the final one.
                 w = boxBlurInterp(sp, src.fRowBytes, tp, rx, w, h, false, outerWeight);
                 w = boxBlurInterp(tp, w,             dp, rx, w, h, false, outerWeight);
                 w = boxBlurInterp(dp, w,             tp, rx, w, h, true, outerWeight);
                 // Do three Y blurs, with a transpose on the final one.
                 h = boxBlurInterp(tp, h,             dp, ry, h, w, false, outerWeight);
                 h = boxBlurInterp(dp, h,             tp, ry, h, w, false, outerWeight);
                 h = boxBlurInterp(tp, h,             dp, ry, h, w, true, outerWeight);
             } else {
                 w = boxBlurInterp(sp, src.fRowBytes, tp, rx, w, h, true, outerWeight);
                 h = boxBlurInterp(tp, h,             dp, ry, h, w, true, outerWeight);
             }
         }
 
         dst->fImage = dp;
         // if need be, alloc the "real" dst (same size as src) and copy/merge
         // the blur into it (applying the src)
-        if (style == kInner_Style) {
+        if (style == kInner_SkBlurStyle) {
             // now we allocate the "real" dst, mirror the size of src
             size_t srcSize = src.computeImageSize();
             if (0 == srcSize) {
                 return false;   // too big to allocate, abort
             }
             dst->fImage = SkMask::AllocImage(srcSize);
             merge_src_with_blur(dst->fImage, src.fRowBytes,
                                 sp, src.fRowBytes,
                                 dp + passCount * (rx + ry * dst->fRowBytes),
                                 dst->fRowBytes, sw, sh);
             SkMask::FreeImage(dp);
-        } else if (style != kNormal_Style) {
+        } else if (style != kNormal_SkBlurStyle) {
             clamp_with_orig(dp + passCount * (rx + ry * dst->fRowBytes),
                             dst->fRowBytes, sp, src.fRowBytes, sw, sh, style);
         }
         (void)autoCall.detach();
     }
 
-    if (style == kInner_Style) {
+    if (style == kInner_SkBlurStyle) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }
 
 /* Convolving a box with itself three times results in a piecewise
    quadratic function:
 
@@ skipping 114 matching lines @@
            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(SkScalar sigma, SkMask *dst,
-                          const SkRect &src, Style style,
+                          const SkRect &src, SkBlurStyle style,
                           SkIPoint *margin, SkMask::CreateMode createMode) {
     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));
 
     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) {
+        if (style == kInner_SkBlurStyle) {
             dst->fBounds.set(SkScalarRoundToInt(src.fLeft),
                              SkScalarRoundToInt(src.fTop),
                              SkScalarRoundToInt(src.fRight),
                              SkScalarRoundToInt(src.fBottom)); // restore trimmed bounds
             dst->fRowBytes = sw;
         }
         return true;
     }
     uint8_t *profile = NULL;
 
@@ skipping 20 matching lines @@
     ComputeBlurredScanline(horizontalScanline, profile, dstWidth, sigma);
     ComputeBlurredScanline(verticalScanline, profile, dstHeight, sigma);
 
     for (int y = 0 ; y < dstHeight ; ++y) {
         for (int x = 0 ; x < dstWidth ; x++) {
             unsigned int maskval = SkMulDiv255Round(horizontalScanline[x], verticalScanline[y]);
             *(outptr++) = maskval;
         }
     }
 
-    if (style == kInner_Style) {
+    if (style == kInner_SkBlurStyle) {
         // 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(SkScalarRoundToInt(src.fLeft),
                          SkScalarRoundToInt(src.fTop),
                          SkScalarRoundToInt(src.fRight),
                          SkScalarRoundToInt(src.fBottom)); // restore trimmed bounds
         dst->fRowBytes = sw;
 
-    } else if (style == kOuter_Style) {
+    } else if (style == kOuter_SkBlurStyle) {
         for (int y = pad ; y < dstHeight-pad ; y++) {
             uint8_t *dst_scanline = dp + y*dstWidth + pad;
             memset(dst_scanline, 0, sw);
         }
-    } else if (style == kSolid_Style) {
+    } else if (style == kSolid_SkBlurStyle) {
         for (int y = pad ; y < dstHeight-pad ; y++) {
             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::BlurRRect(SkScalar sigma, SkMask *dst,
-                           const SkRRect &src, Style style,
+                           const SkRRect &src, SkBlurStyle 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) {
+                                 SkBlurStyle style, SkIPoint* margin) {
 
     if (src.fFormat != SkMask::kA8_Format) {
         return false;
     }
 
     float variance = sigma * sigma;
 
     int windowSize = SkScalarCeilToInt(sigma*6);
     // round window size up to nearest odd number
     windowSize |= 1;
@@ skipping 95 matching lines @@
                 finalValue /= windowSum;
                 uint8_t *outPixel = dstPixels + (x-pad)*dstWidth + y; // transposed output
                 int integerPixel = int(finalValue + 0.5f);
                 *outPixel = SkClampMax( SkClampPos(integerPixel), 255 );
             }
         }
 
         dst->fImage = dstPixels;
         // if need be, alloc the "real" dst (same size as src) and copy/merge
         // the blur into it (applying the src)
-        if (style == kInner_Style) {
+        if (style == kInner_SkBlurStyle) {
             // now we allocate the "real" dst, mirror the size of src
             size_t srcSize = src.computeImageSize();
             if (0 == srcSize) {
                 return false;   // too big to allocate, abort
             }
             dst->fImage = SkMask::AllocImage(srcSize);
             merge_src_with_blur(dst->fImage, src.fRowBytes,
                 srcPixels, src.fRowBytes,
                 dstPixels + pad*dst->fRowBytes + pad,
                 dst->fRowBytes, srcWidth, srcHeight);
             SkMask::FreeImage(dstPixels);
-        } else if (style != kNormal_Style) {
+        } else if (style != kNormal_SkBlurStyle) {
             clamp_with_orig(dstPixels + pad*dst->fRowBytes + pad,
                 dst->fRowBytes, srcPixels, src.fRowBytes, srcWidth, srcHeight, style);
         }
         (void)autoCall.detach();
     }
 
-    if (style == kInner_Style) {
+    if (style == kInner_SkBlurStyle) {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = src.fRowBytes;
     }
 
     return true;
 }