SSE2 implementation of RGBA box blurs. This yields ~2X perf improvement on

src/effects/SkBlurImageFilter.cpp

Index: src/effects/SkBlurImageFilter.cpp
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index c04c258829ed846faeb7c1a89508e6e13fde902d..3be76e83dda47294b968e59bee5987192de0556e 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -10,6 +10,7 @@
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkGpuBlurUtils.h"
+#include "SkBlurImage_opts.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "SkImageFilterUtils.h"
@@ -39,10 +40,6 @@ void SkBlurImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
     buffer.writeScalar(fSigma.fHeight);
 }
 
-enum BlurDirection {
-    kX, kY
-};
-
 /**
  *
  * In order to make memory accesses cache-friendly, we reorder the passes to
@@ -62,15 +59,15 @@ enum BlurDirection {
  * images, and all memory reads are contiguous.
  */
 
-template<BlurDirection srcDirection, BlurDirection dstDirection>
+template<SkBlurDirection srcDirection, SkBlurDirection dstDirection>
 static void boxBlur(const SkPMColor* src, int srcStride, SkPMColor* dst, int kernelSize,
                     int leftOffset, int rightOffset, int width, int height)
 {
     int rightBorder = SkMin32(rightOffset + 1, width);
-    int srcStrideX = srcDirection == kX ? 1 : srcStride;
-    int dstStrideX = dstDirection == kX ? 1 : height;
-    int srcStrideY = srcDirection == kX ? srcStride : 1;
-    int dstStrideY = dstDirection == kX ? width : 1;
+    int srcStrideX = srcDirection == kX_BlurDirection ? 1 : srcStride;
+    int dstStrideX = dstDirection == kX_BlurDirection ? 1 : height;
+    int srcStrideY = srcDirection == kX_BlurDirection ? srcStride : 1;
+    int dstStrideY = dstDirection == kX_BlurDirection ? width : 1;
 #ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
     uint32_t scale = (1 << 24) / kernelSize;
     uint32_t half = 1 << 23;
@@ -115,7 +112,7 @@ static void boxBlur(const SkPMColor* src, int srcStride, SkPMColor* dst, int ker
                 sumB += SkGetPackedB32(r);
             }
             sptr += srcStrideX;
-            if (srcDirection == kY) {
+            if (srcDirection == kY_BlurDirection) {
                 SK_PREFETCH(sptr + (rightOffset + 1) * srcStrideX);
             }
             dptr += dstStrideX;
@@ -125,26 +122,6 @@ static void boxBlur(const SkPMColor* src, int srcStride, SkPMColor* dst, int ker
     }
 }
 
-static void boxBlurX(const SkPMColor* src, int srcStride, SkPMColor* dst, int kernelSize,
-                     int leftOffset, int rightOffset, int width, int height)
-{
-    boxBlur<kX, kX>(src, srcStride, dst, kernelSize, leftOffset, rightOffset, width, height);
-}
-
-#ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
-static void boxBlurXY(const SkPMColor* src, int srcStride, SkPMColor* dst, int kernelSize,
-                              int leftOffset, int rightOffset, int width, int height)
-{
-    boxBlur<kX, kY>(src, srcStride, dst, kernelSize, leftOffset, rightOffset, width, height);
-}
-#endif
-
-static void boxBlurY(const SkPMColor* src, int srcStride, SkPMColor* dst, int kernelSize,
-                     int topOffset, int bottomOffset, int width, int height)
-{
-    boxBlur<kY, kY>(src, srcStride, dst, kernelSize, topOffset, bottomOffset, width, height);
-}
-
 static void getBox3Params(SkScalar s, int *kernelSize, int* kernelSize3, int *lowOffset,
                           int *highOffset)
 {
@@ -212,6 +189,19 @@ bool SkBlurImageFilter::onFilterImage(Proxy* proxy,
     SkPMColor* d = dst->getAddr32(0, 0);
     int w = dstBounds.width(), h = dstBounds.height();
     int sw = src.rowBytesAsPixels();
+    SkBoxBlurProc boxBlurX = SkBoxBlurGetPlatformProc(kX_BlurDirection, kX_BlurDirection);

[mtklein, 2013/11/08 02:11:03]

This feels weird, like unnecessary degrees of freedom.  Would prefer something
like

SkBoxBlurProc boxBlurX, boxBlurY, boxBlurXY;
if (!SkBoxBlurGetPlatformProcs(&boxBlurX, &boxBlurY, &boxBlurXY)) {
  const SkBlurDirection X = kX_BlurDirection, Y = kY_BlurDirection;
  boxBlurX  = boxBlur<X,X>;
  boxBlurY  = boxBlur<Y,Y>;
  boxBlurXY = boxBlur<X,Y>;
}

[Stephen White, 2013/11/08 15:47:47]

Done.

+    if (!boxBlurX) {
+        boxBlurX = boxBlur<kX_BlurDirection, kX_BlurDirection>;
+    }
+    SkBoxBlurProc boxBlurY = SkBoxBlurGetPlatformProc(kY_BlurDirection, kY_BlurDirection);
+    if (!boxBlurY) {
+        boxBlurY = boxBlur<kY_BlurDirection, kY_BlurDirection>;
+    }
+    SkBoxBlurProc boxBlurXY = SkBoxBlurGetPlatformProc(kX_BlurDirection, kY_BlurDirection);
+    if (!boxBlurY) {

[mtklein, 2013/11/08 02:11:03]

oh dear.

-> boxBlurXY?

[Stephen White, 2013/11/08 15:47:47]

Thanks! Good catch. Should be obsoleted by new code now.

+        boxBlurXY = boxBlur<kX_BlurDirection, kY_BlurDirection>;
+    }
+
     if (kernelSizeX > 0 && kernelSizeY > 0) {
 #ifndef SK_DISABLE_BLUR_DIVISION_OPTIMIZATION
         boxBlurX(s,  sw, t, kernelSizeX,  lowOffsetX,  highOffsetX, w, h);