Make SSE2/Neon convolution functions not to read extra bytes

src/core/SkConvolver.cpp

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "SkConvolver.h"
 #include "SkTArray.h"
 
 namespace {
 
     // Converts the argument to an 8-bit unsigned value by clamping to the range
@@ skipping 383 matching lines @@
                                 filterOffset);
 
     // Loop over every possible output row, processing just enough horizontal
     // convolutions to run each subsequent vertical convolution.
     SkASSERT(outputByteRowStride >= filterX.numValues() * 4);
     int numOutputRows = filterY.numValues();
 
     // We need to check which is the last line to convolve before we advance 4
     // lines in one iteration.
     int lastFilterOffset, lastFilterLength;
-
-    // SSE2 can access up to 3 extra pixels past the end of the
-    // buffer. At the bottom of the image, we have to be careful
-    // not to access data past the end of the buffer. Normally
-    // we fall back to the C++ implementation for the last row.
-    // If the last row is less than 3 pixels wide, we may have to fall
-    // back to the C++ version for more rows. Compute how many
-    // rows we need to avoid the SSE implementation for here.
-    filterX.FilterForValue(filterX.numValues() - 1, &lastFilterOffset,
-                           &lastFilterLength);
-    int avoidSimdRows = 1 + convolveProcs.fExtraHorizontalReads /
-        (lastFilterOffset + lastFilterLength);
-
     filterY.FilterForValue(numOutputRows - 1, &lastFilterOffset,
                            &lastFilterLength);
 
     for (int outY = 0; outY < numOutputRows; outY++) {
         filterValues = filterY.FilterForValue(outY,
                                               &filterOffset, &filterLength);
 
         // Generate output rows until we have enough to run the current filter.
         while (nextXRow < filterOffset + filterLength) {
             if (convolveProcs.fConvolve4RowsHorizontally &&
-                nextXRow + 3 < lastFilterOffset + lastFilterLength -
-                avoidSimdRows) {
+                nextXRow + 3 < lastFilterOffset + lastFilterLength) {
                 const unsigned char* src[4];
                 unsigned char* outRow[4];
                 for (int i = 0; i < 4; ++i) {
                     src[i] = &sourceData[(uint64_t)(nextXRow + i) * sourceByteRowStride];
                     outRow[i] = rowBuffer.advanceRow();
                 }
                 convolveProcs.fConvolve4RowsHorizontally(src, filterX, outRow, 4*rowBufferWidth);
                 nextXRow += 4;
             } else {
-                // Check if we need to avoid SSE2 for this row.
-                if (convolveProcs.fConvolveHorizontally &&
-                    nextXRow < lastFilterOffset + lastFilterLength -
-                    avoidSimdRows) {
+                if (convolveProcs.fConvolveHorizontally) {
                     convolveProcs.fConvolveHorizontally(
                         &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                         filterX, rowBuffer.advanceRow(), sourceHasAlpha);
                 } else {
                     if (sourceHasAlpha) {
                         ConvolveHorizontallyAlpha(
                             &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                             filterX, rowBuffer.advanceRow());
                     } else {
                         ConvolveHorizontallyNoAlpha(
@@ skipping 25 matching lines @@
                                                sourceHasAlpha);
         } else {
             ConvolveVertically(filterValues, filterLength,
                                firstRowForFilter,
                                filterX.numValues(), curOutputRow,
                                sourceHasAlpha);
         }
     }
     return true;
 }