use geometric ave for choosing mip level

src/core/SkBitmapProcState.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkBitmapProcState.h"
 #include "SkColorPriv.h"
@@ skipping 80 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool valid_for_filtering(unsigned dimension) {
     // for filtering, width and height must fit in 14bits, since we use steal
     // 2 bits from each to store our 4bit subpixel data
     return (dimension & ~0x3FFF) == 0;
 }
 
-static SkScalar effective_matrix_scale_sqrd(const SkMatrix& mat) {
-    SkPoint v1, v2;
-
-    v1.fX = mat.getScaleX();
-    v1.fY = mat.getSkewY();
-
-    v2.fX = mat.getSkewX();
-    v2.fY = mat.getScaleY();
-
-    return SkMaxScalar(v1.lengthSqd(), v2.lengthSqd());
+static SkScalar effective_matrix_scale(const SkMatrix& mat) {
+    SkScalar dx = SkVector::Length(mat.getScaleX(), mat.getSkewY());
+    SkScalar dy = SkVector::Length(mat.getSkewX(), mat.getScaleY());
+#ifdef SK_SUPPORT_LEGACY_MIPMAP_EFFECTIVE_SCALE
+    return SkMaxScalar(dx, dy);
+#else
+    return SkScalarSqrt(dx * dy);
+#endif
 }
 
 // Check to see that the size of the bitmap that would be produced by
 // scaling by the given inverted matrix is less than the maximum allowed.
 static inline bool cache_size_okay(const SkBitmap& bm, const SkMatrix& invMat) {
     size_t maximumAllocation = SkResourceCache::GetEffectiveSingleAllocationByteLimit();
     if (0 == maximumAllocation) {
         return true;
     }
     // float matrixScaleFactor = 1.0 / (invMat.scaleX * invMat.scaleY);
@@ skipping 82 matching lines @@
  *  Modulo internal errors, this should always succeed *if* the matrix is downscaling
  *  (in this case, we have the inverse, so it succeeds if fInvMatrix is upscaling)
  */
 void SkBitmapProcState::processMediumRequest() {
     SkASSERT(SkPaint::kMedium_FilterLevel == fFilterLevel);
 
     // Our default return state is to downgrade the request to Low, w/ or w/o setting fBitmap
     // to a valid bitmap.
     fFilterLevel = SkPaint::kLow_FilterLevel;
 
-    SkScalar invScaleSqd = effective_matrix_scale_sqrd(fInvMatrix);
+    SkScalar invScale = effective_matrix_scale(fInvMatrix);
 
-    if (invScaleSqd > SK_Scalar1) {
+    if (invScale > SK_Scalar1) {
         fCurrMip.reset(SkMipMapCache::FindAndRef(fOrigBitmap));
         if (NULL == fCurrMip.get()) {
             fCurrMip.reset(SkMipMapCache::AddAndRef(fOrigBitmap));
             if (NULL == fCurrMip.get()) {
                 return;
             }
         }
         // diagnostic for a crasher...
         if (NULL == fCurrMip->data()) {
             sk_throw();
         }
 
-        SkScalar levelScale = SkScalarInvert(SkScalarSqrt(invScaleSqd));
+        SkScalar levelScale = SkScalarInvert(invScale);
         SkMipMap::Level level;
         if (fCurrMip->extractLevel(levelScale, &level)) {
             SkScalar invScaleFixup = level.fScale;
             fInvMatrix.postScale(invScaleFixup, invScaleFixup);
 
             const SkImageInfo info = fOrigBitmap.info().makeWH(level.fWidth, level.fHeight);
             // todo: if we could wrap the fCurrMip in a pixelref, then we could just install
             //       that here, and not need to explicitly track it ourselves.
             fScaledBitmap.installPixels(info, level.fPixels, level.fRowBytes);
             fBitmap = &fScaledBitmap;
@@ skipping 796 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }