Rewriting MatrixConvolution image filter with SSE and AVX2

src/effects/SkMatrixConvolutionImageFilter.cpp

 /*
  * Copyright 2012 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 "SkMatrixConvolutionImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkDevice.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkRect.h"
 #include "SkUnPreMultiply.h"
+#include "SkOpts.h"
 
 #if SK_SUPPORT_GPU
 #include "effects/GrMatrixConvolutionEffect.h"
 #endif
 
 // We need to be able to read at most SK_MaxS32 bytes, so divide that
 // by the size of a scalar to know how many scalars we can read.
 static const int32_t gMaxKernelSize = SK_MaxS32 / sizeof(SkScalar);
 
 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(
@@ skipping 84 matching lines @@
     buffer.writeInt(fKernelOffset.fX);
     buffer.writeInt(fKernelOffset.fY);
     buffer.writeInt((int) fTileMode);
     buffer.writeBool(fConvolveAlpha);
 }
 
 SkMatrixConvolutionImageFilter::~SkMatrixConvolutionImageFilter() {
     delete[] fKernel;
 }
 
-class UncheckedPixelFetcher {
-public:
-    static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
-        return *src.getAddr32(x, y);
-    }
-};
-
 class ClampPixelFetcher {
 public:
     static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
         x = SkTPin(x, bounds.fLeft, bounds.fRight - 1);
         y = SkTPin(y, bounds.fTop, bounds.fBottom - 1);
         return *src.getAddr32(x, y);
     }
 };
 
 class RepeatPixelFetcher {
@@ skipping 15 matching lines @@
 public:
     static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
         if (x < bounds.fLeft || x >= bounds.fRight || y < bounds.fTop || y >= bounds.fBottom) {
             return 0;
         } else {
             return *src.getAddr32(x, y);
         }
     }
 };
 
-template<class PixelFetcher, bool convolveAlpha>
+template<class PixelFetcher>
 void SkMatrixConvolutionImageFilter::filterPixels(const SkBitmap& src,
                                                   SkBitmap* result,
                                                   const SkIRect& r,
                                                   const SkIRect& bounds) const {
     SkIRect rect(r);
     if (!rect.intersect(bounds)) {
         return;
     }
     for (int y = rect.fTop; y < rect.fBottom; ++y) {
         SkPMColor* dptr = result->getAddr32(rect.fLeft - bounds.fLeft, y - bounds.fTop);
         for (int x = rect.fLeft; x < rect.fRight; ++x) {
             SkScalar sumA = 0, sumR = 0, sumG = 0, sumB = 0;
             for (int cy = 0; cy < fKernelSize.fHeight; cy++) {
                 for (int cx = 0; cx < fKernelSize.fWidth; cx++) {
                     SkPMColor s = PixelFetcher::fetch(src,
                                                       x + cx - fKernelOffset.fX,
                                                       y + cy - fKernelOffset.fY,
                                                       bounds);
                     SkScalar k = fKernel[cy * fKernelSize.fWidth + cx];
-                    if (convolveAlpha) {
+                    if (fConvolveAlpha) {

[Stephen White, 2016/04/12 20:01:58]

IIRC, this did actually have a measurable impact when I original wrote it
(hence, the template param). Is that no longer the case?

                         sumA += SkScalarMul(SkIntToScalar(SkGetPackedA32(s)), k);
                     }
                     sumR += SkScalarMul(SkIntToScalar(SkGetPackedR32(s)), k);
                     sumG += SkScalarMul(SkIntToScalar(SkGetPackedG32(s)), k);
                     sumB += SkScalarMul(SkIntToScalar(SkGetPackedB32(s)), k);
                 }
             }
-            int a = convolveAlpha
+            int a = fConvolveAlpha
                   ? SkClampMax(SkScalarFloorToInt(SkScalarMul(sumA, fGain) + fBias), 255)
                   : 255;
             int r = SkClampMax(SkScalarFloorToInt(SkScalarMul(sumR, fGain) + fBias), a);
             int g = SkClampMax(SkScalarFloorToInt(SkScalarMul(sumG, fGain) + fBias), a);
             int b = SkClampMax(SkScalarFloorToInt(SkScalarMul(sumB, fGain) + fBias), a);
-            if (!convolveAlpha) {
+            if (!fConvolveAlpha) {
                 a = SkGetPackedA32(PixelFetcher::fetch(src, x, y, bounds));
                 *dptr++ = SkPreMultiplyARGB(a, r, g, b);
             } else {
                 *dptr++ = SkPackARGB32(a, r, g, b);
             }
         }
     }
 }
 
-template<class PixelFetcher>
-void SkMatrixConvolutionImageFilter::filterPixels(const SkBitmap& src,
-                                                  SkBitmap* result,
-                                                  const SkIRect& rect,
-                                                  const SkIRect& bounds) const {
-    if (fConvolveAlpha) {
-        filterPixels<PixelFetcher, true>(src, result, rect, bounds);
-    } else {
-        filterPixels<PixelFetcher, false>(src, result, rect, bounds);
-    }
-}
 
 void SkMatrixConvolutionImageFilter::filterInteriorPixels(const SkBitmap& src,
                                                           SkBitmap* result,
                                                           const SkIRect& rect,
                                                           const SkIRect& bounds) const {
-    filterPixels<UncheckedPixelFetcher>(src, result, rect, bounds);
+    SkOpts::matrix_convolution_image_filter_filter_pixels(
+        src,

[Stephen White, 2016/04/12 20:01:58]

Please use spaces instead of tabs.

+        result,
+        rect,
+        bounds,
+        fConvolveAlpha,
+        fKernel,
+        fKernelSize,
+        fKernelOffset,
+        fGain,
+        fBias);
 }
 
 void SkMatrixConvolutionImageFilter::filterBorderPixels(const SkBitmap& src,
                                                         SkBitmap* result,
                                                         const SkIRect& rect,
                                                         const SkIRect& bounds) const {
     switch (fTileMode) {
         case kClamp_TileMode:
             filterPixels<ClampPixelFetcher>(src, result, rect, bounds);
             break;
@@ skipping 157 matching lines @@
             str->appendf("%f ", fKernel[y * fKernelSize.width() + x]);
         }
     }
     str->appendf(")");
     str->appendf("gain: %f bias: %f ", fGain, fBias);
     str->appendf("offset: (%d, %d) ", fKernelOffset.fX, fKernelOffset.fY);
     str->appendf("convolveAlpha: %s", fConvolveAlpha ? "true" : "false");
     str->append(")");
 }
 #endif