Remove legacy mask blur code.

This was flag flipped about last year in the chrome code, and
flag flipped about three weeks ago in Android.

All the *_LEGACY_*BLUR flags are gone.

Change-Id: I046f3a040ccbf12ff3a810c41b02131095df3368
Reviewed-on: https://skia-review.googlesource.com/96001
Reviewed-by: Mike Klein <mtklein@chromium.org>
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Herb Derby <herb@google.com>

1 files changed, 0 insertions, 486 deletions

diff --git a/src/effects/SkBlurMask.cpp b/src/effects/SkBlurMask.cpp
index cd2d83996a..f06e2b9f1e 100644
--- a/src/effects/SkBlurMask.cpp
+++ b/src/effects/SkBlurMask.cpp
@@ -30,386 +30,6 @@ SkScalar SkBlurMask::ConvertSigmaToRadius(SkScalar sigma) {
     return sigma > 0.5f ? (sigma - 0.5f) / kBLUR_SIGMA_SCALE : 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.
- *
- * This is what the inner loop looks like before unrolling, and with the two
- * cases broken out separately (width < diameter, width >= diameter):
- *
- *      if (width < diameter) {
- *          for (int x = 0; x < width; ++x) {
- *              sum += *right++;
- *              *dptr = (sum * scale + half) >> 24;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = width; x < diameter; ++x) {
- *              *dptr = (sum * scale + half) >> 24;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = 0; x < width; ++x) {
- *              *dptr = (sum * scale + half) >> 24;
- *              sum -= *left++;
- *              dptr += dst_x_stride;
- *          }
- *      } else {
- *          for (int x = 0; x < diameter; ++x) {
- *              sum += *right++;
- *              *dptr = (sum * scale + half) >> 24;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = diameter; x < width; ++x) {
- *              sum += *right++;
- *              *dptr = (sum * scale + half) >> 24;
- *              sum -= *left++;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = 0; x < diameter; ++x) {
- *              *dptr = (sum * scale + half) >> 24;
- *              sum -= *left++;
- *              dptr += dst_x_stride;
- *          }
- *      }
- */
-template <bool Transpose>
-static int boxBlur(const uint8_t* src, int src_y_stride, uint8_t* dst,
-                   int leftRadius, int rightRadius, int width, int height)
-{
-    int diameter = leftRadius + rightRadius;
-    int kernelSize = diameter + 1;
-    int border = SkMin32(width, diameter);
-    uint32_t scale = (1 << 24) / kernelSize;
-    int new_width = width + SkMax32(leftRadius, rightRadius) * 2;
-    int dst_x_stride = Transpose ? height : 1;
-    int dst_y_stride = Transpose ? 1 : new_width;
-    uint32_t half = 1 << 23;
-    for (int y = 0; y < height; ++y) {
-        uint32_t sum = 0;
-        uint8_t* dptr = dst + y * dst_y_stride;
-        const uint8_t* right = src + y * src_y_stride;
-        const uint8_t* left = right;
-        for (int x = 0; x < rightRadius - leftRadius; x++) {
-            *dptr = 0;
-            dptr += dst_x_stride;
-        }
-#define LEFT_BORDER_ITER \
-            sum += *right++; \
-            *dptr = (sum * scale + half) >> 24; \
-            dptr += dst_x_stride;
-
-        int x = 0;
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (; x < border - 16; x += 16) {
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-        }
-#endif
-        for (; x < border; ++x) {
-            LEFT_BORDER_ITER
-        }
-#undef LEFT_BORDER_ITER
-#define TRIVIAL_ITER \
-            *dptr = (sum * scale + half) >> 24; \
-            dptr += dst_x_stride;
-        x = width;
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (; x < diameter - 16; x += 16) {
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-            TRIVIAL_ITER
-        }
-#endif
-        for (; x < diameter; ++x) {
-            TRIVIAL_ITER
-        }
-#undef TRIVIAL_ITER
-#define CENTER_ITER \
-            sum += *right++; \
-            *dptr = (sum * scale + half) >> 24; \
-            sum -= *left++; \
-            dptr += dst_x_stride;
-
-        x = diameter;
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (; x < width - 16; x += 16) {
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-        }
-#endif
-        for (; x < width; ++x) {
-            CENTER_ITER
-        }
-#undef CENTER_ITER
-#define RIGHT_BORDER_ITER \
-            *dptr = (sum * scale + half) >> 24; \
-            sum -= *left++; \
-            dptr += dst_x_stride;
-
-        x = 0;
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (; x < border - 16; x += 16) {
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-        }
-#endif
-        for (; x < border; ++x) {
-            RIGHT_BORDER_ITER
-        }
-#undef RIGHT_BORDER_ITER
-        for (int x = 0; x < leftRadius - rightRadius; ++x) {
-            *dptr = 0;
-            dptr += dst_x_stride;
-        }
-        SkASSERT(sum == 0);
-    }
-    return new_width;
-}
-
-/**
- * This variant of the box blur handles blurring of non-integer radii.  It
- * keeps two running sums: an outer sum for the rounded-up kernel radius, and
- * an inner sum for the rounded-down kernel radius.  For each pixel, it linearly
- * interpolates between them.  In float this would be:
- *  outer_weight * outer_sum / kernelSize +
- *  (1.0 - outer_weight) * innerSum / (kernelSize - 2)
- *
- * This is what the inner loop looks like before unrolling, and with the two
- * cases broken out separately (width < diameter, width >= diameter):
- *
- *      if (width < diameter) {
- *          for (int x = 0; x < width; x++) {
- *              inner_sum = outer_sum;
- *              outer_sum += *right++;
- *              *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = width; x < diameter; ++x) {
- *              *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = 0; x < width; x++) {
- *              inner_sum = outer_sum - *left++;
- *              *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
- *              dptr += dst_x_stride;
- *              outer_sum = inner_sum;
- *          }
- *      } else {
- *          for (int x = 0; x < diameter; x++) {
- *              inner_sum = outer_sum;
- *              outer_sum += *right++;
- *              *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
- *              dptr += dst_x_stride;
- *          }
- *          for (int x = diameter; x < width; ++x) {
- *              inner_sum = outer_sum - *left;
- *              outer_sum += *right++;
- *              *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
- *              dptr += dst_x_stride;
- *              outer_sum -= *left++;
- *          }
- *          for (int x = 0; x < diameter; x++) {
- *              inner_sum = outer_sum - *left++;
- *              *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
- *              dptr += dst_x_stride;
- *              outer_sum = inner_sum;
- *          }
- *      }
- *  }
- *  return new_width;
- */
-
-template <bool Transpose>
-static int boxBlurInterp(const uint8_t* src, int src_y_stride, uint8_t* dst,
-                         int radius, int width, int height,
-                         uint8_t outer_weight)
-{
-    int diameter = radius * 2;
-    int kernelSize = diameter + 1;
-    int border = SkMin32(width, diameter);
-    int inner_weight = 255 - outer_weight;
-    outer_weight += outer_weight >> 7;
-    inner_weight += inner_weight >> 7;
-    uint32_t outer_scale = (outer_weight << 16) / kernelSize;
-    uint32_t inner_scale = (inner_weight << 16) / (kernelSize - 2);
-    uint32_t half = 1 << 23;
-    int new_width = width + diameter;
-    int dst_x_stride = Transpose ? height : 1;
-    int dst_y_stride = Transpose ? 1 : new_width;
-    for (int y = 0; y < height; ++y) {
-        uint32_t outer_sum = 0, inner_sum = 0;
-        uint8_t* dptr = dst + y * dst_y_stride;
-        const uint8_t* right = src + y * src_y_stride;
-        const uint8_t* left = right;
-        int x = 0;
-
-#define LEFT_BORDER_ITER \
-            inner_sum = outer_sum; \
-            outer_sum += *right++; \
-            *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24; \
-            dptr += dst_x_stride;
-
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (;x < border - 16; x += 16) {
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-            LEFT_BORDER_ITER
-        }
-#endif
-
-        for (;x < border; ++x) {
-            LEFT_BORDER_ITER
-        }
-#undef LEFT_BORDER_ITER
-        for (int x = width; x < diameter; ++x) {
-            *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24;
-            dptr += dst_x_stride;
-        }
-        x = diameter;
-
-#define CENTER_ITER \
-            inner_sum = outer_sum - *left; \
-            outer_sum += *right++; \
-            *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24; \
-            dptr += dst_x_stride; \
-            outer_sum -= *left++;
-
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (; x < width - 16; x += 16) {
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-            CENTER_ITER
-        }
-#endif
-        for (; x < width; ++x) {
-            CENTER_ITER
-        }
-#undef CENTER_ITER
-
-        #define RIGHT_BORDER_ITER \
-            inner_sum = outer_sum - *left++; \
-            *dptr = (outer_sum * outer_scale + inner_sum * inner_scale + half) >> 24; \
-            dptr += dst_x_stride; \
-            outer_sum = inner_sum;
-
-        x = 0;
-#ifdef UNROLL_SEPARABLE_LOOPS
-        for (; x < border - 16; x += 16) {
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-            RIGHT_BORDER_ITER
-        }
-#endif
-        for (; x < border; ++x) {
-            RIGHT_BORDER_ITER
-        }
-#undef RIGHT_BORDER_ITER
-        SkASSERT(outer_sum == 0 && inner_sum == 0);
-    }
-    return new_width;
-}
-
-
-
-#include "SkColorData.h"
 
 static void merge_src_with_blur(uint8_t dst[], int dstRB,
                                 const uint8_t src[], int srcRB,
@@ -484,111 +104,6 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
 
     SkIPoint border;
 
-#ifdef SK_SUPPORT_LEGACY_MASK_BLUR
-
-    auto get_adjusted_radii = [](SkScalar passRadius, int *loRadius, int *hiRadius) {
-        *loRadius = *hiRadius = SkScalarCeilToInt(passRadius);
-        if (SkIntToScalar(*hiRadius) - passRadius > 0.5f) {
-            *loRadius = *hiRadius - 1;
-        }
-    };
-
-    // Force high quality off for small radii (performance)
-    if (!force_quality && sigma <= SkIntToScalar(2)) {
-        quality = kLow_SkBlurQuality;
-    }
-
-    SkScalar passRadius;
-    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_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;
-    }
-
-    int ry = rx;    // only do square blur for now
-
-    int padx = passCount * rx;
-    int pady = passCount * ry;
-
-    border = {padx, pady};
-
-    dst->fBounds.set(src.fBounds.fLeft - padx, src.fBounds.fTop - pady,
-                     src.fBounds.fRight + padx, src.fBounds.fBottom + pady);
-
-    dst->fRowBytes = dst->fBounds.width();
-    dst->fFormat = SkMask::kA8_Format;
-    dst->fImage = nullptr;
-
-    if (src.fImage) {
-        size_t dstSize = dst->computeImageSize();
-        if (0 == dstSize) {
-            return false;   // too big to allocate, abort
-        }
-
-        int sw = src.fBounds.width();
-        int sh = src.fBounds.height();
-        const uint8_t* sp = src.fImage;
-        uint8_t* dp = SkMask::AllocImage(dstSize);
-        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_SkBlurQuality == quality) {
-                // Do three X blurs, with a transpose on the final one.
-                w = boxBlur<false>(sp, src.fRowBytes, tp, loRadius, hiRadius, w, h);
-                w = boxBlur<false>(tp, w, dp, hiRadius, loRadius, w, h);
-                w = boxBlur<true>(dp, w, tp, hiRadius, hiRadius, w, h);
-                // Do three Y blurs, with a transpose on the final one.
-                h = boxBlur<false>(tp, h, dp, loRadius, hiRadius, h, w);
-                h = boxBlur<false>(dp, h, tp, hiRadius, loRadius, h, w);
-                h = boxBlur<true>(tp, h, dp, hiRadius, hiRadius, h, w);
-            } else {
-                w = boxBlur<true>(sp, src.fRowBytes, tp, rx, rx, w, h);
-                h = boxBlur<true>(tp, h, dp, ry, ry, h, w);
-            }
-        } else {
-            if (kHigh_SkBlurQuality == quality) {
-                // Do three X blurs, with a transpose on the final one.
-                w = boxBlurInterp<false>(sp, src.fRowBytes, tp, rx, w, h, outerWeight);
-                w = boxBlurInterp<false>(tp, w, dp, rx, w, h, outerWeight);
-                w = boxBlurInterp<true>(dp, w, tp, rx, w, h, outerWeight);
-                // Do three Y blurs, with a transpose on the final one.
-                h = boxBlurInterp<false>(tp, h, dp, ry, h, w, outerWeight);
-                h = boxBlurInterp<false>(dp, h, tp, ry, h, w, outerWeight);
-                h = boxBlurInterp<true>(tp, h, dp, ry, h, w, outerWeight);
-            } else {
-                w = boxBlurInterp<true>(sp, src.fRowBytes, tp, rx, w, h, outerWeight);
-                h = boxBlurInterp<true>(tp, h, dp, ry, h, w, outerWeight);
-            }
-        }
-
-        dst->fImage = autoCall.release();
-    }
-#else
     SkMaskBlurFilter blurFilter{sigma, sigma};
     if (blurFilter.hasNoBlur()) {
         return false;
@@ -598,7 +113,6 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src,
     if (src.fImage != nullptr && dst->fImage == nullptr) {
         return false;
     }
-#endif  // SK_SUPPORT_LEGACY_MASK_BLUR
 
     if (src.fImage != nullptr) {
         // if need be, alloc the "real" dst (same size as src) and copy/merge