floating point scale factors for images

src/core/SkBitmapScaler.cpp

 #include "SkBitmapScaler.h"
 #include "SkBitmapFilter.h"
 #include "SkRect.h"
 #include "SkTArray.h"
 #include "SkErrorInternals.h"
 #include "SkConvolver.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,
-                   int destWidth, int destHeight,
-                   const SkIRect& destSubset,
+                   float destWidth, float destHeight,
+                   const SkRect& destSubset,
                    const SkConvolutionProcs& convolveProcs);
     ~SkResizeFilter() {
         SkDELETE( fBitmapFilter );
     }
 
     // Returns the filled filter values.
     const SkConvolutionFilter1D& xFilter() { return fXFilter; }
     const SkConvolutionFilter1D& yFilter() { return fYFilter; }
 
 private:
 
     SkBitmapFilter* fBitmapFilter;
 
     // Computes one set of filters either horizontally or vertically. The caller
     // will specify the "min" and "max" rather than the bottom/top and
     // right/bottom so that the same code can be re-used in each dimension.
     //
     // |srcDependLo| and |srcDependSize| gives the range for the source
     // depend rectangle (horizontally or vertically at the caller's discretion
     // -- see above for what this means).
     //
     // Likewise, the range of destination values to compute and the scale factor
     // for the transform is also specified.
 
     void computeFilters(int srcSize,
-                        int destSubsetLo, int destSubsetSize,
+                        float destSubsetLo, float destSubsetSize,
                         float scale,
                         SkConvolutionFilter1D* output,
                         const SkConvolutionProcs& convolveProcs);
 
     SkConvolutionFilter1D fXFilter;
     SkConvolutionFilter1D fYFilter;
 };
 
 SkResizeFilter::SkResizeFilter(SkBitmapScaler::ResizeMethod method,
                                int srcFullWidth, int srcFullHeight,
-                               int destWidth, int destHeight,
-                               const SkIRect& destSubset,
+                               float destWidth, float destHeight,
+                               const SkRect& destSubset,
                                const SkConvolutionProcs& convolveProcs) {
 
     // method will only ever refer to an "algorithm method".
     SkASSERT((SkBitmapScaler::RESIZE_FIRST_ALGORITHM_METHOD <= method) &&
              (method <= SkBitmapScaler::RESIZE_LAST_ALGORITHM_METHOD));
 
     switch(method) {
         case SkBitmapScaler::RESIZE_BOX:
             fBitmapFilter = SkNEW(SkBoxFilter);
             break;
         case SkBitmapScaler::RESIZE_TRIANGLE:
             fBitmapFilter = SkNEW(SkTriangleFilter);
             break;
         case SkBitmapScaler::RESIZE_MITCHELL:
             fBitmapFilter = SkNEW_ARGS(SkMitchellFilter, (1.f/3.f, 1.f/3.f));
             break;
         case SkBitmapScaler::RESIZE_HAMMING:
             fBitmapFilter = SkNEW(SkHammingFilter);
             break;
         case SkBitmapScaler::RESIZE_LANCZOS3:
             fBitmapFilter = SkNEW(SkLanczosFilter);
             break;
         default:
             // NOTREACHED:
             fBitmapFilter = SkNEW_ARGS(SkMitchellFilter, (1.f/3.f, 1.f/3.f));
             break;
     }
 
 
-    float scaleX = static_cast<float>(destWidth) /
-                   static_cast<float>(srcFullWidth);
-    float scaleY = static_cast<float>(destHeight) /
-                   static_cast<float>(srcFullHeight);
+    float scaleX = destWidth / srcFullWidth;
+    float scaleY = destHeight / srcFullHeight;
 
     this->computeFilters(srcFullWidth, destSubset.fLeft, destSubset.width(),
                          scaleX, &fXFilter, convolveProcs);
     if (srcFullWidth == srcFullHeight &&
         destSubset.fLeft == destSubset.fTop &&
         destSubset.width() == destSubset.height()&&
         scaleX == scaleY) {
         fYFilter = fXFilter;
     } else {
         this->computeFilters(srcFullHeight, destSubset.fTop, destSubset.height(),
                           scaleY, &fYFilter, convolveProcs);
     }
 }
 
 // TODO(egouriou): Take advantage of periods in the convolution.
 // Practical resizing filters are periodic outside of the border area.
 // For Lanczos, a scaling by a (reduced) factor of p/q (q pixels in the
 // source become p pixels in the destination) will have a period of p.
 // A nice consequence is a period of 1 when downscaling by an integral
 // factor. Downscaling from typical display resolutions is also bound
 // to produce interesting periods as those are chosen to have multiple
 // small factors.
 // Small periods reduce computational load and improve cache usage if
 // the coefficients can be shared. For periods of 1 we can consider
 // loading the factors only once outside the borders.
 void SkResizeFilter::computeFilters(int srcSize,
-                                  int destSubsetLo, int destSubsetSize,
+                                  float destSubsetLo, float destSubsetSize,
                                   float scale,
                                   SkConvolutionFilter1D* output,
                                   const SkConvolutionProcs& convolveProcs) {
-  int destSubsetHi = destSubsetLo + destSubsetSize;  // [lo, hi)
+  float destSubsetHi = destSubsetLo + destSubsetSize;  // [lo, hi)
 
   // When we're doing a magnification, the scale will be larger than one. This
   // 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);
 
   // 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.
-  for (int destSubsetI = destSubsetLo; destSubsetI < destSubsetHi;
+  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*
@@ skipping 88 matching lines @@
 #else
             return SkBitmapScaler::RESIZE_MITCHELL;
 #endif
     }
 }
 
 // static
 bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
                             const SkBitmap& source,
                             ResizeMethod method,
-                            int destWidth, int destHeight,
-                            const SkIRect& destSubset,
+                            float destWidth, float destHeight,
                             const SkConvolutionProcs& convolveProcs,
                             SkBitmap::Allocator* allocator) {
+
+  SkRect destSubset = { 0, 0, destWidth, destHeight };
+
   // Ensure that the ResizeMethod enumeration is sound.
     SkASSERT(((RESIZE_FIRST_QUALITY_METHOD <= method) &&
         (method <= RESIZE_LAST_QUALITY_METHOD)) ||
         ((RESIZE_FIRST_ALGORITHM_METHOD <= method) &&
         (method <= RESIZE_LAST_ALGORITHM_METHOD)));
 
-    SkIRect dest = { 0, 0, destWidth, destHeight };
+    SkRect dest = { 0, 0, destWidth, destHeight };
     if (!dest.contains(destSubset)) {
         SkErrorInternals::SetError( kInvalidArgument_SkError,
-                                    "Sorry, you passed me a bitmap resize "
-                                    " method I have never heard of: %d",
-                                    method );
+                                    "Sorry, the destination bitmap scale subset "
+                                    "falls outside the full destination bitmap." );
     }
 
     // If the size of source or destination is 0, i.e. 0x0, 0xN or Nx0, just
     // return empty.
     if (source.width() < 1 || source.height() < 1 ||
         destWidth < 1 || destHeight < 1) {
         // todo: seems like we could handle negative dstWidth/Height, since that
         // is just a negative scale (flip)
         return false;
     }
@@ skipping 14 matching lines @@
                           destWidth, destHeight, destSubset, convolveProcs);
 
     // Get a source bitmap encompassing this touched area. We construct the
     // offsets and row strides such that it looks like a new bitmap, while
     // referring to the old data.
     const unsigned char* sourceSubset =
         reinterpret_cast<const unsigned char*>(source.getPixels());
 
     // Convolve into the result.
     SkBitmap result;
-    result.setConfig(SkImageInfo::MakeN32(destSubset.width(),
-                                          destSubset.height(),
+    result.setConfig(SkImageInfo::MakeN32(SkScalarCeilToInt(destSubset.width()),
+                                          SkScalarCeilToInt(destSubset.height()),
                                           source.alphaType()));
     result.allocPixels(allocator, NULL);
     if (!result.readyToDraw()) {
         return false;
     }
 
     BGRAConvolve2D(sourceSubset, static_cast<int>(source.rowBytes()),
         !source.isOpaque(), filter.xFilter(), filter.yFilter(),
         static_cast<int>(result.rowBytes()),
         static_cast<unsigned char*>(result.getPixels()),
         convolveProcs, true);
 
     *resultPtr = result;
     resultPtr->lockPixels();
     SkASSERT(NULL != resultPtr->getPixels());
     return true;
 }
-
-// static
-bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
-                            const SkBitmap& source,
-                            ResizeMethod method,
-                            int destWidth, int destHeight,
-                            const SkConvolutionProcs& convolveProcs,
-                            SkBitmap::Allocator* allocator) {
-    SkIRect destSubset = { 0, 0, destWidth, destHeight };
-    return Resize(resultPtr, source, method, destWidth, destHeight, destSubset,
-                  convolveProcs, allocator);
-}