Refactor resize filter to go faster

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 "SkScalar.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,
@@ skipping 42 matching lines @@
 
     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(1.f / 3.f, 1.f / 3.f);
+            fBitmapFilter = new SkMitchellFilter;
             break;
         case SkBitmapScaler::RESIZE_HAMMING:
             fBitmapFilter = new SkHammingFilter;
             break;
         case SkBitmapScaler::RESIZE_LANCZOS3:
             fBitmapFilter = new SkLanczosFilter;
             break;
     }
 
 
@@ skipping 35 matching lines @@
   // 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
   // to support the filtering function.
   float srcSupport = fBitmapFilter->width() / clampedScale;
 
-  // Speed up the divisions below by turning them into multiplies.
   float invScale = 1.0f / scale;
 
-  SkTArray<float> filterValues(64);
-  SkTArray<short> fixedFilterValues(64);
+  SkSTArray<64, float, true> filterValuesArray;
+  SkSTArray<64, SkConvolutionFilter1D::ConvolutionFixed, true> fixedFilterValuesArray;
 
   // Loop over all pixels in the output range. We will generate one set of
   // filter values for each one. Those values will tell us how to blend the
   // source pixels to compute the destination pixel.
+
+  // This is the pixel in the source directly under the pixel in the dest.
+  // Note that we base computations on the "center" of the pixels. To see
+  // why, observe that the destination pixel at coordinates (0, 0) in a 5.0x
+  // downscale should "cover" the pixels around the pixel with *its center*
+  // at coordinates (2.5, 2.5) in the source, not those around (0, 0).
+  // Hence we need to scale coordinates (0.5, 0.5), not (0, 0).
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
+  int destLimit = SkScalarTruncToInt(SkScalarCeilToScalar(destSubsetHi)
+        - SkScalarFloorToScalar(destSubsetLo));
+#else
+  destSubsetLo = SkScalarFloorToScalar(destSubsetLo);
+  destSubsetHi = SkScalarCeilToScalar(destSubsetHi);
+  float srcPixel = (destSubsetLo + 0.5f) * invScale;
+  int destLimit = SkScalarTruncToInt(destSubsetHi - destSubsetLo);
+#endif
+  output->reserveAdditional(destLimit, SkScalarCeilToInt(destLimit * srcSupport * 2));
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
   for (int destSubsetI = SkScalarFloorToInt(destSubsetLo); destSubsetI < SkScalarCeilToInt(destSubsetHi);
-       destSubsetI++) {
-    // Reset the arrays. We don't declare them inside so they can re-use the
-    // same malloc-ed buffer.
-    filterValues.reset();
-    fixedFilterValues.reset();
-
-    // This is the pixel in the source directly under the pixel in the dest.
-    // Note that we base computations on the "center" of the pixels. To see
-    // why, observe that the destination pixel at coordinates (0, 0) in a 5.0x
-    // downscale should "cover" the pixels around the pixel with *its center*
-    // at coordinates (2.5, 2.5) in the source, not those around (0, 0).
-    // Hence we need to scale coordinates (0.5, 0.5), not (0, 0).
+       destSubsetI++)
+#else
+  for (int destI = 0; destI < destLimit; srcPixel += invScale, destI++)
+#endif
+  {
+    // Compute the (inclusive) range of source pixels the filter covers.
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
     float srcPixel = (static_cast<float>(destSubsetI) + 0.5f) * invScale;
-
-    // Compute the (inclusive) range of source pixels the filter covers.
     int srcBegin = SkTMax(0, SkScalarFloorToInt(srcPixel - srcSupport));
     int srcEnd = SkTMin(srcSize - 1, SkScalarCeilToInt(srcPixel + srcSupport));
+#else
+    float srcBegin = SkTMax(0.f, SkScalarFloorToScalar(srcPixel - srcSupport));
+    float srcEnd = SkTMin(srcSize - 1.f, SkScalarCeilToScalar(srcPixel + srcSupport));
+#endif
 
     // Compute the unnormalized filter value at each location of the source
     // it covers.
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
     float filterSum = 0.0f;  // Sub of the filter values for normalizing.
+    int filterCount = srcEnd - srcBegin + 1;
+    filterValuesArray.reset(filterCount);
     for (int curFilterPixel = srcBegin; curFilterPixel <= srcEnd;
          curFilterPixel++) {
-      // Distance from the center of the filter, this is the filter coordinate
-      // in source space. We also need to consider the center of the pixel
-      // when comparing distance against 'srcPixel'. In the 5x downscale
-      // example used above the distance from the center of the filter to
-      // the pixel with coordinates (2, 2) should be 0, because its center
-      // is at (2.5, 2.5).
+#endif
+    // Sum of the filter values for normalizing.
+    // Distance from the center of the filter, this is the filter coordinate
+    // in source space. We also need to consider the center of the pixel
+    // when comparing distance against 'srcPixel'. In the 5x downscale
+    // example used above the distance from the center of the filter to
+    // the pixel with coordinates (2, 2) should be 0, because its center
+    // is at (2.5, 2.5).
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
       float srcFilterDist =
           ((static_cast<float>(curFilterPixel) + 0.5f) - srcPixel);
 
       // Since the filter really exists in dest space, map it there.
       float destFilterDist = srcFilterDist * clampedScale;
 
       // Compute the filter value at that location.
       float filterValue = fBitmapFilter->evaluate(destFilterDist);
-      filterValues.push_back(filterValue);
+      filterValuesArray[curFilterPixel - srcBegin] = filterValue;
 
       filterSum += filterValue;
     }
-    SkASSERT(!filterValues.empty());
-
+#else
+    float destFilterDist = (srcBegin + 0.5f - srcPixel) * clampedScale;
+    int filterCount = SkScalarTruncToInt(srcEnd - srcBegin) + 1;
+    SkASSERT(filterCount > 0);
+    filterValuesArray.reset(filterCount);
+    float filterSum = fBitmapFilter->evaluate_n(destFilterDist, clampedScale, filterCount,
+                                                filterValuesArray.begin());
+#endif
     // The filter must be normalized so that we don't affect the brightness of
     // the image. Convert to normalized fixed point.
-    short fixedSum = 0;
-    for (int i = 0; i < filterValues.count(); i++) {
-      short curFixed = output->FloatToFixed(filterValues[i] / filterSum);
+    int fixedSum = 0;
+    fixedFilterValuesArray.reset(filterCount);
+    const float* filterValues = filterValuesArray.begin();
+    SkConvolutionFilter1D::ConvolutionFixed* fixedFilterValues = fixedFilterValuesArray.begin();
+#ifndef SK_SUPPORT_LEGACY_BITMAP_FILTER
+    float invFilterSum = 1 / filterSum;
+#endif
+    for (int fixedI = 0; fixedI < filterCount; fixedI++) {
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
+      int curFixed = SkConvolutionFilter1D::FloatToFixed(filterValues[fixedI] / filterSum);
+#else
+      int curFixed = SkConvolutionFilter1D::FloatToFixed(filterValues[fixedI] * invFilterSum);
+#endif
       fixedSum += curFixed;
-      fixedFilterValues.push_back(curFixed);
+      fixedFilterValues[fixedI] = SkToS16(curFixed);
     }
+    SkASSERT(fixedSum <= 0x7FFF);
 
     // The conversion to fixed point will leave some rounding errors, which
     // 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).
-    short leftovers = output->FloatToFixed(1.0f) - fixedSum;
-    fixedFilterValues[fixedFilterValues.count() / 2] += leftovers;
+    int leftovers = SkConvolutionFilter1D::FloatToFixed(1) - fixedSum;
+    fixedFilterValues[filterCount / 2] += leftovers;
 
     // Now it's ready to go.
-    output->AddFilter(srcBegin, &fixedFilterValues[0],
-                      static_cast<int>(fixedFilterValues.count()));
+#ifdef SK_SUPPORT_LEGACY_BITMAP_FILTER
+    output->AddFilter(srcBegin, fixedFilterValues, filterCount);
+#else
+    output->AddFilter(SkScalarFloorToInt(srcBegin), fixedFilterValues, filterCount);
+#endif
   }
 
   if (convolveProcs.fApplySIMDPadding) {
-      convolveProcs.fApplySIMDPadding( output );
+      convolveProcs.fApplySIMDPadding(output);
   }
 }
 
 bool SkBitmapScaler::Resize(SkBitmap* resultPtr, const SkPixmap& source, ResizeMethod method,
                             int destWidth, int destHeight, SkBitmap::Allocator* allocator) {
     if (nullptr == source.addr() || source.colorType() != kN32_SkColorType ||
         source.width() < 1 || source.height() < 1)
     {
         return false;
     }
@@ skipping 32 matching lines @@
                         convolveProcs, true)) {
         return false;
     }
 
     *resultPtr = result;
     resultPtr->lockPixels();
     SkASSERT(resultPtr->getPixels());
     return true;
 }