remove fConvolutionProcs from State, and just use it locally

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 "SkSize.h"
 #include "SkTypes.h"
 
 namespace {
 
@@ skipping 319 matching lines @@
     return &fFilterValues[filter.fDataLocation];
 }
 
 void BGRAConvolve2D(const unsigned char* sourceData,
                     int sourceByteRowStride,
                     bool sourceHasAlpha,
                     const SkConvolutionFilter1D& filterX,
                     const SkConvolutionFilter1D& filterY,
                     int outputByteRowStride,
                     unsigned char* output,
-                    SkConvolutionProcs* convolveProcs,
+                    const SkConvolutionProcs& convolveProcs,
                     bool useSimdIfPossible) {
 
     int maxYFilterSize = filterY.maxFilter();
 
     // The next row in the input that we will generate a horizontally
     // convolved row for. If the filter doesn't start at the beginning of the
     // image (this is the case when we are only resizing a subset), then we
     // don't want to generate any output rows before that. Compute the starting
     // row for convolution as the first pixel for the first vertical filter.
     int filterOffset, filterLength;
     const SkConvolutionFilter1D::ConvolutionFixed* filterValues =
         filterY.FilterForValue(0, &filterOffset, &filterLength);
     int nextXRow = filterOffset;
 
     // We loop over each row in the input doing a horizontal convolution. This
     // will result in a horizontally convolved image. We write the results into
     // a circular buffer of convolved rows and do vertical convolution as rows
     // are available. This prevents us from having to store the entire
     // intermediate image and helps cache coherency.
     // We will need four extra rows to allow horizontal convolution could be done
     // simultaneously. We also pad each row in row buffer to be aligned-up to
     // 16 bytes.
     // TODO(jiesun): We do not use aligned load from row buffer in vertical
     // convolution pass yet. Somehow Windows does not like it.
     int rowBufferWidth = (filterX.numValues() + 15) & ~0xF;
     int rowBufferHeight = maxYFilterSize +
-                          (convolveProcs->fConvolve4RowsHorizontally ? 4 : 0);
+                          (convolveProcs.fConvolve4RowsHorizontally ? 4 : 0);
     CircularRowBuffer rowBuffer(rowBufferWidth,
                                 rowBufferHeight,
                                 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 /
+    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 &&
+            if (convolveProcs.fConvolve4RowsHorizontally &&
                 nextXRow + 3 < lastFilterOffset + lastFilterLength -
                 avoidSimdRows) {
                 const unsigned char* src[4];
                 unsigned char* outRow[4];
                 for (int i = 0; i < 4; ++i) {
                     src[i] = &sourceData[(nextXRow + i) * sourceByteRowStride];
                     outRow[i] = rowBuffer.advanceRow();
                 }
-                convolveProcs->fConvolve4RowsHorizontally(src, filterX, outRow);
+                convolveProcs.fConvolve4RowsHorizontally(src, filterX, outRow);
                 nextXRow += 4;
             } else {
                 // Check if we need to avoid SSE2 for this row.
-                if (convolveProcs->fConvolveHorizontally &&
+                if (convolveProcs.fConvolveHorizontally &&
                     nextXRow < lastFilterOffset + lastFilterLength -
                     avoidSimdRows) {
-                    convolveProcs->fConvolveHorizontally(
+                    convolveProcs.fConvolveHorizontally(
                         &sourceData[nextXRow * sourceByteRowStride],
                         filterX, rowBuffer.advanceRow(), sourceHasAlpha);
                 } else {
                     if (sourceHasAlpha) {
                         ConvolveHorizontally<true>(
                             &sourceData[nextXRow * sourceByteRowStride],
                             filterX, rowBuffer.advanceRow());
                     } else {
                         ConvolveHorizontally<false>(
                             &sourceData[nextXRow * sourceByteRowStride],
@@ skipping 10 matching lines @@
         // Get the list of rows that the circular buffer has, in order.
         int firstRowInCircularBuffer;
         unsigned char* const* rowsToConvolve =
             rowBuffer.GetRowAddresses(&firstRowInCircularBuffer);
 
         // Now compute the start of the subset of those rows that the filter
         // needs.
         unsigned char* const* firstRowForFilter =
             &rowsToConvolve[filterOffset - firstRowInCircularBuffer];
 
-        if (convolveProcs->fConvolveVertically) {
-            convolveProcs->fConvolveVertically(filterValues, filterLength,
+        if (convolveProcs.fConvolveVertically) {
+            convolveProcs.fConvolveVertically(filterValues, filterLength,
                                                firstRowForFilter,
                                                filterX.numValues(), curOutputRow,
                                                sourceHasAlpha);
         } else {
             ConvolveVertically(filterValues, filterLength,
                                firstRowForFilter,
                                filterX.numValues(), curOutputRow,
                                sourceHasAlpha);
         }
     }
 }