Make SSE2/Neon convolution functions not to read extra bytes

src/core/SkBitmapScaler.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapScaler.h"
 #include "SkBitmapFilter.h"
 #include "SkConvolver.h"
 #include "SkImageInfo.h"
 #include "SkPixmap.h"
 #include "SkRect.h"
 #include "SkTArray.h"
 
 // SkResizeFilter ----------------------------------------------------------------
 
 // Encapsulates computation and storage of the filters required for one complete
 // resize operation.
 class SkResizeFilter {
 public:
     SkResizeFilter(SkBitmapScaler::ResizeMethod method,
                    int srcFullWidth, int srcFullHeight,
                    float destWidth, float destHeight,
-                   const SkRect& destSubset,
-                   const SkConvolutionProcs& convolveProcs);
+                   const SkRect& destSubset);
     ~SkResizeFilter() { delete fBitmapFilter; }
 
     // Returns the filled filter values.
     const SkConvolutionFilter1D& xFilter() { return fXFilter; }
     const SkConvolutionFilter1D& yFilter() { return fYFilter; }
 
 private:
 
     SkBitmapFilter* fBitmapFilter;
 
     // Computes one set of filters either horizontally or vertically. The caller
     // will specify the "min" and "max" rather than the bottom/top and
     // right/bottom so that the same code can be re-used in each dimension.
     //
     // |srcDependLo| and |srcDependSize| gives the range for the source
     // depend rectangle (horizontally or vertically at the caller's discretion
     // -- see above for what this means).
     //
     // Likewise, the range of destination values to compute and the scale factor
     // for the transform is also specified.
 
     void computeFilters(int srcSize,
                         float destSubsetLo, float destSubsetSize,
                         float scale,
-                        SkConvolutionFilter1D* output,
-                        const SkConvolutionProcs& convolveProcs);
+                        SkConvolutionFilter1D* output);
 
     SkConvolutionFilter1D fXFilter;
     SkConvolutionFilter1D fYFilter;
 };
 
 SkResizeFilter::SkResizeFilter(SkBitmapScaler::ResizeMethod method,
                                int srcFullWidth, int srcFullHeight,
                                float destWidth, float destHeight,
-                               const SkRect& destSubset,
-                               const SkConvolutionProcs& convolveProcs) {
+                               const SkRect& destSubset) {
 
     SkASSERT(method >= SkBitmapScaler::RESIZE_FirstMethod &&
              method <= SkBitmapScaler::RESIZE_LastMethod);
 
     fBitmapFilter = nullptr;
     switch(method) {
         case SkBitmapScaler::RESIZE_BOX:
             fBitmapFilter = new SkBoxFilter;
             break;
         case SkBitmapScaler::RESIZE_TRIANGLE:
             fBitmapFilter = new SkTriangleFilter;
             break;
         case SkBitmapScaler::RESIZE_MITCHELL:
             fBitmapFilter = new SkMitchellFilter;
             break;
         case SkBitmapScaler::RESIZE_HAMMING:
             fBitmapFilter = new SkHammingFilter;
             break;
         case SkBitmapScaler::RESIZE_LANCZOS3:
             fBitmapFilter = new SkLanczosFilter;
             break;
     }
 
 
     float scaleX = destWidth / srcFullWidth;
     float scaleY = destHeight / srcFullHeight;
 
     this->computeFilters(srcFullWidth, destSubset.fLeft, destSubset.width(),
-                         scaleX, &fXFilter, convolveProcs);
+                         scaleX, &fXFilter);
     if (srcFullWidth == srcFullHeight &&
         destSubset.fLeft == destSubset.fTop &&
         destSubset.width() == destSubset.height()&&
         scaleX == scaleY) {
         fYFilter = fXFilter;
     } else {
         this->computeFilters(srcFullHeight, destSubset.fTop, destSubset.height(),
-                          scaleY, &fYFilter, convolveProcs);
+                          scaleY, &fYFilter);
     }
 }
 
 // TODO(egouriou): Take advantage of periods in the convolution.
 // Practical resizing filters are periodic outside of the border area.
 // For Lanczos, a scaling by a (reduced) factor of p/q (q pixels in the
 // source become p pixels in the destination) will have a period of p.
 // A nice consequence is a period of 1 when downscaling by an integral
 // factor. Downscaling from typical display resolutions is also bound
 // to produce interesting periods as those are chosen to have multiple
 // small factors.
 // Small periods reduce computational load and improve cache usage if
 // the coefficients can be shared. For periods of 1 we can consider
 // loading the factors only once outside the borders.
 void SkResizeFilter::computeFilters(int srcSize,
                                   float destSubsetLo, float destSubsetSize,
                                   float scale,
-                                  SkConvolutionFilter1D* output,
-                                  const SkConvolutionProcs& convolveProcs) {
+                                  SkConvolutionFilter1D* output) {
   float destSubsetHi = destSubsetLo + destSubsetSize;  // [lo, hi)
 
   // When we're doing a magnification, the scale will be larger than one. This
   // means the destination pixels are much smaller than the source pixels, and
   // that the range covered by the filter won't necessarily cover any source
   // pixel boundaries. Therefore, we use these clamped values (max of 1) for
   // some computations.
   float clampedScale = SkTMin(1.0f, scale);
 
   // This is how many source pixels from the center we need to count
@@ skipping 64 matching lines @@
     // we add back in to avoid affecting the brightness of the image. We
     // arbitrarily add this to the center of the filter array (this won't always
     // be the center of the filter function since it could get clipped on the
     // edges, but it doesn't matter enough to worry about that case).
     int leftovers = SkConvolutionFilter1D::FloatToFixed(1) - fixedSum;
     fixedFilterValues[filterCount / 2] += leftovers;
 
     // Now it's ready to go.
     output->AddFilter(SkScalarFloorToInt(srcBegin), fixedFilterValues, filterCount);
   }
-
-  if (convolveProcs.fApplySIMDPadding) {
-      convolveProcs.fApplySIMDPadding(output);
-  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static bool valid_for_resize(const SkPixmap& source, int dstW, int dstH) {
     // TODO: Seems like we shouldn't care about the swizzle of source, just that it's 8888
     return source.addr() && source.colorType() == kN32_SkColorType &&
            source.width() >= 1 && source.height() >= 1 && dstW >= 1 && dstH >= 1;
 }
 
 bool SkBitmapScaler::Resize(const SkPixmap& result, const SkPixmap& source, ResizeMethod method) {
     if (!valid_for_resize(source, result.width(), result.height())) {
         return false;
     }
     if (!result.addr() || result.colorType() != source.colorType()) {
         return false;
     }
 
-    SkConvolutionProcs convolveProcs= { 0, nullptr, nullptr, nullptr, nullptr };
+    SkConvolutionProcs convolveProcs= { nullptr, nullptr, nullptr };
     PlatformConvolutionProcs(&convolveProcs);
 
     SkRect destSubset = SkRect::MakeIWH(result.width(), result.height());
 
     SkResizeFilter filter(method, source.width(), source.height(),
-                          result.width(), result.height(), destSubset, convolveProcs);
+                          result.width(), result.height(), destSubset);
 
     // Get a subset encompassing this touched area. We construct the
     // offsets and row strides such that it looks like a new bitmap, while
     // referring to the old data.
     const uint8_t* sourceSubset = reinterpret_cast<const uint8_t*>(source.addr());
 
     return BGRAConvolve2D(sourceSubset, static_cast<int>(source.rowBytes()),
                           !source.isOpaque(), filter.xFilter(), filter.yFilter(),
                           static_cast<int>(result.rowBytes()),
                           static_cast<unsigned char*>(result.writable_addr()),
@@ skipping 17 matching lines @@
     SkPixmap resultPM;
     if (!result.peekPixels(&resultPM) || !Resize(resultPM, source, method)) {
         return false;
     }
 
     *resultPtr = result;
     resultPtr->lockPixels();
     SkASSERT(resultPtr->getPixels());
     return true;
 }