Prefer native scaling to sampling

src/codec/SkScaledCodec.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 "SkCodecPriv.h"
 #include "SkScaledCodec.h"
 #include "SkStream.h"
@@ skipping 35 matching lines @@
 
 // returns a scaled dimension based on the original dimension and the sampleSize
 // NOTE: we round down here for scaled dimension to match the behavior of SkImageDecoder
 static int get_scaled_dimension(int srcDimension, int sampleSize) {
     if (sampleSize > srcDimension) {
         return 1;
     }
     return srcDimension / sampleSize;
 }
 
-static SkISize best_scaled_dimensions(const SkISize& origDims, const SkISize& nativeDims, 
+static SkISize best_scaled_dimensions(const SkISize& origDims, const SkISize& nativeDims,
                                       const SkISize& scaledCodecDims, float desiredScale) {
     if (nativeDims == scaledCodecDims) {
         // does not matter which to return if equal. Return here to skip below calculations
         return nativeDims;
     }
     float idealWidth = origDims.width() * desiredScale;
     float idealHeight = origDims.height() * desiredScale;
 
     // calculate difference between native dimensions and ideal dimensions
     float nativeWDiff = SkTAbs(idealWidth - nativeDims.width());
     float nativeHDiff = SkTAbs(idealHeight - nativeDims.height());
-    float nativeDiff = (nativeWDiff + nativeHDiff) / 2;
+    float nativeDiff = nativeWDiff + nativeHDiff;
+
+    // Native scaling is preferred to sampling.  If we can scale natively to
+    // within one of the ideal value, we should choose to scale natively.
+    if (nativeWDiff < 1.0f && nativeHDiff < 1.0f) {
+        return nativeDims;
+    }
 
     // calculate difference between scaledCodec dimensions and ideal dimensions
     float scaledCodecWDiff = SkTAbs(idealWidth - scaledCodecDims.width());
     float scaledCodecHDiff = SkTAbs(idealHeight - scaledCodecDims.height());
-    float scaledCodecDiff = (scaledCodecWDiff + scaledCodecHDiff) / 2;
+    float scaledCodecDiff = scaledCodecWDiff + scaledCodecHDiff;
 
     // return dimensions closest to ideal dimensions.
     // If the differences are equal, return nativeDims, as native scaling is more efficient.
     return nativeDiff > scaledCodecDiff ? scaledCodecDims : nativeDims;
+}
 
-} 
 /*
  * Return a valid set of output dimensions for this decoder, given an input scale
  */
 SkISize SkScaledCodec::onGetScaledDimensions(float desiredScale) const {
     SkISize nativeDimensions = fScanlineDecoder->getScaledDimensions(desiredScale);
     // support scaling down by integer numbers. Ex: 1/2, 1/3, 1/4 ...
     SkISize scaledCodecDimensions;
     if (desiredScale > 0.5f) {
         // sampleSize = 1
         scaledCodecDimensions = fScanlineDecoder->getInfo().dimensions();
     }
     // sampleSize determines the step size between samples
     // Ex: sampleSize = 2, sample every second pixel in x and y directions
     int sampleSize = int(1 / desiredScale);
 
     int scaledWidth = get_scaled_dimension(this->getInfo().width(), sampleSize);
     int scaledHeight = get_scaled_dimension(this->getInfo().height(), sampleSize);
 
     // Return the calculated output dimensions for the given scale
     scaledCodecDimensions = SkISize::Make(scaledWidth, scaledHeight);
 
-    return best_scaled_dimensions(this->getInfo().dimensions(), nativeDimensions, 
+    return best_scaled_dimensions(this->getInfo().dimensions(), nativeDimensions,
                                   scaledCodecDimensions, desiredScale);
 }
 
 // check if scaling to dstInfo size from srcInfo size using sampleSize is possible
 static bool scaling_supported(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
                               int* sampleX, int* sampleY) {
     SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, sampleX, sampleY);
     const int dstWidth = dstInfo.width();
     const int dstHeight = dstInfo.height();
     const int srcWidth = srcInfo.width();
@@ skipping 140 matching lines @@
                 result = fScanlineDecoder->skipScanlines(sampleY - 1);
                 if (kSuccess != result) {
                     return result;
                 }
             }
             dst = SkTAddOffset<void>(dst, rowBytes);
         }
     }
     return kSuccess;
 }