Revert of add SkMatrix::decomposeScale

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(const SkMatrix& mat) {
+    SkScalar dx = SkVector::Length(mat.getScaleX(), mat.getSkewY());
+    SkScalar dy = SkVector::Length(mat.getSkewX(), mat.getScaleY());
+    return SkScalarSqrt(dx * dy);
+}
+
 // 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);
     // return ((origBitmapSize * matrixScaleFactor) < maximumAllocationSize);
     // Skip the division step:
     return bm.info().getSafeSize(bm.info().minRowBytes())
         < (maximumAllocation * invMat.getScaleX() * invMat.getScaleY());
 }
 
 /*
+ *  Extract the "best" scale factors from a matrix.
+ */
+static bool extract_scale(const SkMatrix& matrix, SkVector* scale) {
+    SkASSERT(!matrix.hasPerspective());
+    SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
+    SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX],  matrix[SkMatrix::kMScaleY]);
+    if (!SkScalarIsFinite(sx) || !SkScalarIsFinite(sy) ||
+        SkScalarNearlyZero(sx) || SkScalarNearlyZero(sy))
+    {
+        return false;
+    }
+    scale->set(sx, sy);
+    return true;
+}
+
+/*
  *  High quality is implemented by performing up-right scale-only filtering and then
  *  using bilerp for any remaining transformations.
  */
 void SkBitmapProcState::processHQRequest() {
     SkASSERT(kHigh_SkFilterQuality == fFilterLevel);
 
     // Our default return state is to downgrade the request to Medium, w/ or w/o setting fBitmap
     // to a valid bitmap. If we succeed, we will set this to Low instead.
     fFilterLevel = kMedium_SkFilterQuality;
 
     if (kN32_SkColorType != fOrigBitmap.colorType() || !cache_size_okay(fOrigBitmap, fInvMatrix) ||
         fInvMatrix.hasPerspective())
     {
         return; // can't handle the reqeust
     }
 
     SkScalar invScaleX = fInvMatrix.getScaleX();
     SkScalar invScaleY = fInvMatrix.getScaleY();
     if (fInvMatrix.getType() & SkMatrix::kAffine_Mask) {
-        SkSize scale;
-        if (!fInvMatrix.decomposeScale(&scale)) {
-            return;
+        SkVector scale;
+        if (!extract_scale(fInvMatrix, &scale)) {
+            return; // can't find suitable scale factors
         }
-        invScaleX = scale.width();
-        invScaleY = scale.height();
+        invScaleX = scale.x();
+        invScaleY = scale.y();
     }
     if (SkScalarNearlyEqual(invScaleX, 1) && SkScalarNearlyEqual(invScaleY, 1)) {
         return; // no need for HQ
     }
 
     SkScalar trueDestWidth  = fOrigBitmap.width() / invScaleX;
     SkScalar trueDestHeight = fOrigBitmap.height() / invScaleY;
     SkScalar roundedDestWidth = SkScalarRoundToScalar(trueDestWidth);
     SkScalar roundedDestHeight = SkScalarRoundToScalar(trueDestHeight);
 
@@ skipping 24 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(kMedium_SkFilterQuality == fFilterLevel);
 
     // Our default return state is to downgrade the request to Low, w/ or w/o setting fBitmap
     // to a valid bitmap.
     fFilterLevel = kLow_SkFilterQuality;
 
-    SkSize invScaleSize;
-    if (!fInvMatrix.decomposeScale(&invScaleSize, NULL)) {
-        return;
-    }
-    SkScalar invScale = SkScalarSqrt(invScaleSize.width() * invScaleSize.height());
+    SkScalar invScale = effective_matrix_scale(fInvMatrix);
 
     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...
@@ skipping 796 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }