Refactor resize filter to go faster

src/core/SkConvolver.h

 // Copyright (c) 2012 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.
 
 #ifndef SK_CONVOLVER_H
 #define SK_CONVOLVER_H
 
 #include "SkSize.h"
-#include "SkTypes.h"
-#include "SkTArray.h"
+#include "SkTDArray.h"
 
 // avoid confusion with Mac OS X's math library (Carbon)
 #if defined(__APPLE__)
 #undef FloatToConvolutionFixed
 #undef ConvolutionFixedToFloat
 #undef FloatToFixed
 #undef FixedToFloat
 #endif
 
 // Represents a filter in one dimension. Each output pixel has one entry in this
@@ skipping 30 matching lines @@
         return ldexpf(raw, -kShiftBits);
     }
 
     // Returns the maximum pixel span of a filter.
     int maxFilter() const { return fMaxFilter; }
 
     // Returns the number of filters in this filter. This is the dimension of the
     // output image.
     int numValues() const { return static_cast<int>(fFilters.count()); }
 
+    void reserveAdditional(int filterCount, int filterValueCount) {
+        fFilters.setReserve(fFilters.count() + filterCount);
+        fFilterValues.setReserve(fFilterValues.count() + filterValueCount);
+    }
+
     // Appends the given list of scaling values for generating a given output
     // pixel. |filterOffset| is the distance from the edge of the image to where
     // the scaling factors start. The scaling factors apply to the source pixels
     // starting from this position, and going for the next |filterLength| pixels.
     //
     // You will probably want to make sure your input is normalized (that is,
     // all entries in |filterValuesg| sub to one) to prevent affecting the overall
     // brighness of the image.
     //
     // The filterLength must be > 0.
-    //
-    // This version will automatically convert your input to ConvolutionFixed point.
-    SK_API void AddFilter(int filterOffset,
-                          const float* filterValues,
-                          int filterLength);
-
-    // Same as the above version, but the input is already ConvolutionFixed point.
     void AddFilter(int filterOffset,
                    const ConvolutionFixed* filterValues,
                    int filterLength);
 
     // Retrieves a filter for the given |valueOffset|, a position in the output
     // image in the direction we're convolving. The offset and length of the
     // filter values are put into the corresponding out arguments (see AddFilter
     // above for what these mean), and a pointer to the first scaling factor is
     // returned. There will be |filterLength| values in this array.
     inline const ConvolutionFixed* FilterForValue(int valueOffset,
@@ skipping 17 matching lines @@
   // Returns nullptr if the filter is 0-length (for instance when all floating
   // point values passed to AddFilter were clipped to 0).
     SK_API const ConvolutionFixed* GetSingleFilter(int* specifiedFilterLength,
         int* filterOffset,
         int* filterLength) const;
 
     // Add another value to the fFilterValues array -- useful for
     // SIMD padding which happens outside of this class.
 
     void addFilterValue( ConvolutionFixed val ) {
-        fFilterValues.push_back( val );
+        fFilterValues.push( val );
     }
 private:
     struct FilterInstance {
         // Offset within filterValues for this instance of the filter.
         int fDataLocation;
 
         // Distance from the left of the filter to the center. IN PIXELS
         int fOffset;
 
         // Number of values in this filter instance.
         int fTrimmedLength;
 
         // Filter length as specified. Note that this may be different from
         // 'trimmed_length' if leading/trailing zeros of the original floating
         // point form were clipped differently on each tail.
         int fLength;
     };
 
     // Stores the information for each filter added to this class.
-    SkTArray<FilterInstance> fFilters;
+    SkTDArray<FilterInstance> fFilters;
 
     // We store all the filter values in this flat list, indexed by
     // |FilterInstance.data_location| to avoid the mallocs required for storing
     // each one separately.
-    SkTArray<ConvolutionFixed> fFilterValues;
+    SkTDArray<ConvolutionFixed> fFilterValues;
 
     // The maximum size of any filter we've added.
     int fMaxFilter;
 };
 
 typedef void (*SkConvolveVertically_pointer)(
     const SkConvolutionFilter1D::ConvolutionFixed* filterValues,
     int filterLength,
     unsigned char* const* sourceDataRows,
     int pixelWidth,
@@ skipping 50 matching lines @@
     int sourceByteRowStride,
     bool sourceHasAlpha,
     const SkConvolutionFilter1D& xfilter,
     const SkConvolutionFilter1D& yfilter,
     int outputByteRowStride,
     unsigned char* output,
     const SkConvolutionProcs&,
     bool useSimdIfPossible);
 
 #endif  // SK_CONVOLVER_H