Change SkBlurImageFilter to use fixed-point division. Yields ~1.8X speedup on

src/effects/SkBlurImageFilter.cpp

 /*
  * Copyright 2011 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 "SkBitmap.h"
 #include "SkBlurImageFilter.h"
 #include "SkColorPriv.h"
@@ skipping 26 matching lines @@
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fSigma.fWidth);
     buffer.writeScalar(fSigma.fHeight);
 }
 
 static void boxBlurX(const SkBitmap& src, SkBitmap* dst, int kernelSize,
                      int leftOffset, int rightOffset, const SkIRect& bounds)
 {
     int width = bounds.width(), height = bounds.height();
     int rightBorder = SkMin32(rightOffset + 1, width);
+#ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
+    uint32_t scale = (1 << 24) / kernelSize;
+    uint32_t half = 1 << 23;
+#endif
     for (int y = 0; y < height; ++y) {
         int sumA = 0, sumR = 0, sumG = 0, sumB = 0;
         SkPMColor* p = src.getAddr32(bounds.fLeft, y + bounds.fTop);
         for (int i = 0; i < rightBorder; ++i) {
             sumA += SkGetPackedA32(*p);
             sumR += SkGetPackedR32(*p);
             sumG += SkGetPackedG32(*p);
             sumB += SkGetPackedB32(*p);
             p++;
         }
 
         const SkColor* sptr = src.getAddr32(bounds.fLeft, bounds.fTop + y);
         SkColor* dptr = dst->getAddr32(0, y);
         for (int x = 0; x < width; ++x) {
+#ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
+            *dptr = SkPackARGB32((sumA * scale + half) >> 24,
+                                 (sumR * scale + half) >> 24,
+                                 (sumG * scale + half) >> 24,
+                                 (sumB * scale + half) >> 24);
+#else
             *dptr = SkPackARGB32(sumA / kernelSize,
                                  sumR / kernelSize,
                                  sumG / kernelSize,
                                  sumB / kernelSize);
+#endif
             if (x >= leftOffset) {
                 SkColor l = *(sptr - leftOffset);
                 sumA -= SkGetPackedA32(l);
                 sumR -= SkGetPackedR32(l);
                 sumG -= SkGetPackedG32(l);
                 sumB -= SkGetPackedB32(l);
             }
             if (x + rightOffset + 1 < width) {
                 SkColor r = *(sptr + rightOffset + 1);
                 sumA += SkGetPackedA32(r);
                 sumR += SkGetPackedR32(r);
                 sumG += SkGetPackedG32(r);
                 sumB += SkGetPackedB32(r);
             }
             sptr++;
             dptr++;
         }
     }
 }
 
 static void boxBlurY(const SkBitmap& src, SkBitmap* dst, int kernelSize,
                      int topOffset, int bottomOffset, const SkIRect& bounds)
 {
     int width = bounds.width(), height = bounds.height();
     int bottomBorder = SkMin32(bottomOffset + 1, height);
     int srcStride = src.rowBytesAsPixels();
     int dstStride = dst->rowBytesAsPixels();
+#ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
+    uint32_t scale = (1 << 24) / kernelSize;
+    uint32_t half = 1 << 23;
+#endif
     for (int x = 0; x < width; ++x) {
         int sumA = 0, sumR = 0, sumG = 0, sumB = 0;
         SkColor* p = src.getAddr32(bounds.fLeft + x, bounds.fTop);
         for (int i = 0; i < bottomBorder; ++i) {
             sumA += SkGetPackedA32(*p);
             sumR += SkGetPackedR32(*p);
             sumG += SkGetPackedG32(*p);
             sumB += SkGetPackedB32(*p);
             p += srcStride;
         }
 
         const SkColor* sptr = src.getAddr32(bounds.fLeft + x, bounds.fTop);
         SkColor* dptr = dst->getAddr32(x, 0);
         for (int y = 0; y < height; ++y) {
+#ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
+            *dptr = SkPackARGB32((sumA * scale + half) >> 24,
+                                 (sumR * scale + half) >> 24,
+                                 (sumG * scale + half) >> 24,
+                                 (sumB * scale + half) >> 24);
+#else
             *dptr = SkPackARGB32(sumA / kernelSize,
                                  sumR / kernelSize,
                                  sumG / kernelSize,
                                  sumB / kernelSize);
+#endif
             if (y >= topOffset) {
                 SkColor l = *(sptr - topOffset * srcStride);
                 sumA -= SkGetPackedA32(l);
                 sumR -= SkGetPackedR32(l);
                 sumG -= SkGetPackedG32(l);
                 sumB -= SkGetPackedB32(l);
             }
             if (y + bottomOffset + 1 < height) {
                 SkColor r = *(sptr + (bottomOffset + 1) * srcStride);
                 sumA += SkGetPackedA32(r);
@@ skipping 111 matching lines @@
                                                              fSigma.width(),
                                                              fSigma.height()));
     offset->fX += rect.fLeft;
     offset->fY += rect.fTop;
     return SkImageFilterUtils::WrapTexture(tex, rect.width(), rect.height(), result);
 #else
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 #endif
 }