quick hackup of SkNx SkMatrixConvolutionImageFilter

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 "SkNx.h"
 #include "SkReadBuffer.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
 #include "SkRect.h"
 #include "SkUnPreMultiply.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrDrawContext.h"
@@ skipping 146 matching lines @@
                                                   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;
+            Sk4s sum = 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) {
-                        sumA += SkScalarMul(SkIntToScalar(SkGetPackedA32(s)), k);
-                    }
-                    sumR += SkScalarMul(SkIntToScalar(SkGetPackedR32(s)), k);
-                    sumG += SkScalarMul(SkIntToScalar(SkGetPackedG32(s)), k);
-                    sumB += SkScalarMul(SkIntToScalar(SkGetPackedB32(s)), k);
+
+                    sum += k * SkNx_cast<SkScalar>(Sk4b::Load(&s));
                 }
             }
-            int a = convolveAlpha
-                  ? 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) {
-                a = SkGetPackedA32(PixelFetcher::fetch(src, x, y, bounds));
-                *dptr++ = SkPreMultiplyARGB(a, r, g, b);
+            Sk4s d = Sk4s::Max(0, Sk4s::Min(sum * fGain + fBias, 255.0f));
+
+            if (convolveAlpha) {
+                d = Sk4s::Min(d, d[3]);
             } else {
-                *dptr++ = SkPackARGB32(a, r, g, b);
+                SkScalar a01 = (1/255.0f) * SkGetPackedA32(PixelFetcher::fetch(src, x, y, bounds));
+                d = Sk4s{d[0],d[1],d[2], 255} * a01;
             }
+            SkNx_cast<uint8_t>(d).store(dptr++);
         }
     }
 }
 
 template<class PixelFetcher>
 void SkMatrixConvolutionImageFilter::filterPixels(const SkBitmap& src,
                                                   SkBitmap* result,
                                                   const SkIRect& rect,
                                                   const SkIRect& bounds) const {
     if (fConvolveAlpha) {
@@ skipping 199 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