Refactor resize filter to go faster

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 "SkMath.h"
-#include "SkSize.h"
-#include "SkTypes.h"
+#include "SkTArray.h"
 
 namespace {
 
     // Converts the argument to an 8-bit unsigned value by clamping to the range
     // 0-255.
     inline unsigned char ClampTo8(int a) {
         if (static_cast<unsigned>(a) < 256) {
             return a;  // Avoid the extra check in the common case.
         }
         if (a < 0) {
@@ skipping 259 matching lines @@
 // SkConvolutionFilter1D ---------------------------------------------------------
 
 SkConvolutionFilter1D::SkConvolutionFilter1D()
 : fMaxFilter(0) {
 }
 
 SkConvolutionFilter1D::~SkConvolutionFilter1D() {
 }
 
 void SkConvolutionFilter1D::AddFilter(int filterOffset,
-                                      const float* filterValues,
-                                      int filterLength) {
-    SkASSERT(filterLength > 0);
-
-    SkTArray<ConvolutionFixed> fixedValues;
-    fixedValues.reset(filterLength);
-
-    for (int i = 0; i < filterLength; ++i) {
-        fixedValues.push_back(FloatToFixed(filterValues[i]));
-    }
-
-    AddFilter(filterOffset, &fixedValues[0], filterLength);
-}
-
-void SkConvolutionFilter1D::AddFilter(int filterOffset,
                                       const ConvolutionFixed* filterValues,
                                       int filterLength) {
     // It is common for leading/trailing filter values to be zeros. In such
     // cases it is beneficial to only store the central factors.
     // For a scaling to 1/4th in each dimension using a Lanczos-2 filter on
     // a 1080p image this optimization gives a ~10% speed improvement.
     int filterSize = filterLength;
     int firstNonZero = 0;
     while (firstNonZero < filterLength && filterValues[firstNonZero] == 0) {
         firstNonZero++;
     }
 
     if (firstNonZero < filterLength) {
         // Here we have at least one non-zero factor.
         int lastNonZero = filterLength - 1;
         while (lastNonZero >= 0 && filterValues[lastNonZero] == 0) {
             lastNonZero--;
         }
 
         filterOffset += firstNonZero;
         filterLength = lastNonZero + 1 - firstNonZero;
         SkASSERT(filterLength > 0);
 
-        for (int i = firstNonZero; i <= lastNonZero; i++) {
-            fFilterValues.push_back(filterValues[i]);
-        }
+        fFilterValues.append(filterLength, &filterValues[firstNonZero]);
     } else {
         // Here all the factors were zeroes.
         filterLength = 0;
     }
 
     FilterInstance instance;
 
     // We pushed filterLength elements onto fFilterValues
     instance.fDataLocation = (static_cast<int>(fFilterValues.count()) -
                                                filterLength);
     instance.fOffset = filterOffset;
     instance.fTrimmedLength = filterLength;
     instance.fLength = filterSize;
-    fFilters.push_back(instance);
+    fFilters.push(instance);
 
     fMaxFilter = SkTMax(fMaxFilter, filterLength);
 }
 
 const SkConvolutionFilter1D::ConvolutionFixed* SkConvolutionFilter1D::GetSingleFilter(
                                         int* specifiedFilterlength,
                                         int* filterOffset,
                                         int* filterLength) const {
     const FilterInstance& filter = fFilters[0];
     *filterOffset = filter.fOffset;
@@ skipping 143 matching lines @@
                                                sourceHasAlpha);
         } else {
             ConvolveVertically(filterValues, filterLength,
                                firstRowForFilter,
                                filterX.numValues(), curOutputRow,
                                sourceHasAlpha);
         }
     }
     return true;
 }