Avoid matrix inverse in SkBitmapProcInfo::init for translate-only cases

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 "SkBitmapController.h"
 #include "SkBitmapProcState.h"
@@ skipping 44 matching lines @@
     , fSrcGammaTreatment(treatment)
     , fBMState(nullptr)
 {}
 
 SkBitmapProcInfo::~SkBitmapProcInfo() {
     SkInPlaceDeleteCheck(fBMState, fBMStateStorage.get());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// true iff the matrix contains, at most, scale and translate elements
+// true iff the matrix has a scale and no more than an optional translate.
 static bool matrix_only_scale_translate(const SkMatrix& m) {
-    return m.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask);
+    return (m.getType() & ~SkMatrix::kTranslate_Mask) == SkMatrix::kScale_Mask;
 }
 
 /**
  *  For the purposes of drawing bitmaps, if a matrix is "almost" translate
  *  go ahead and treat it as if it were, so that subsequent code can go fast.
  */
 static bool just_trans_clamp(const SkMatrix& matrix, const SkPixmap& pixmap) {
     SkASSERT(matrix_only_scale_translate(matrix));
 
-    if (matrix.getType() & SkMatrix::kScale_Mask) {
-        SkRect dst;
-        SkRect src = SkRect::Make(pixmap.bounds());
+    SkRect dst;
+    SkRect src = SkRect::Make(pixmap.bounds());
 
-        // Can't call mapRect(), since that will fix up inverted rectangles,
-        // e.g. when scale is negative, and we don't want to return true for
-        // those.
-        matrix.mapPoints(SkTCast<SkPoint*>(&dst),
-                         SkTCast<const SkPoint*>(&src),
-                         2);
+    // Can't call mapRect(), since that will fix up inverted rectangles,
+    // e.g. when scale is negative, and we don't want to return true for
+    // those.
+    matrix.mapPoints(SkTCast<SkPoint*>(&dst),
+                     SkTCast<const SkPoint*>(&src),
+                     2);
 
-        // Now round all 4 edges to device space, and then compare the device
-        // width/height to the original. Note: we must map all 4 and subtract
-        // rather than map the "width" and compare, since we care about the
-        // phase (in pixel space) that any translate in the matrix might impart.
-        SkIRect idst;
-        dst.round(&idst);
-        return idst.width() == pixmap.width() && idst.height() == pixmap.height();
-    }
-    // if we got here, we're either kTranslate_Mask or identity
-    return true;
+    // Now round all 4 edges to device space, and then compare the device
+    // width/height to the original. Note: we must map all 4 and subtract
+    // rather than map the "width" and compare, since we care about the
+    // phase (in pixel space) that any translate in the matrix might impart.
+    SkIRect idst;
+    dst.round(&idst);
+    return idst.width() == pixmap.width() && idst.height() == pixmap.height();
 }
 
 static bool just_trans_general(const SkMatrix& matrix) {
     SkASSERT(matrix_only_scale_translate(matrix));
 
-    if (matrix.getType() & SkMatrix::kScale_Mask) {
-        const SkScalar tol = SK_Scalar1 / 32768;
+    const SkScalar tol = SK_Scalar1 / 32768;
 
-        if (!SkScalarNearlyZero(matrix[SkMatrix::kMScaleX] - SK_Scalar1, tol)) {
-            return false;
-        }
-        if (!SkScalarNearlyZero(matrix[SkMatrix::kMScaleY] - SK_Scalar1, tol)) {
-            return false;
-        }
-    }
-    // if we got here, treat us as either kTranslate_Mask or identity
-    return true;
+    return SkScalarNearlyZero(matrix[SkMatrix::kMScaleX] - SK_Scalar1, tol)
+        && SkScalarNearlyZero(matrix[SkMatrix::kMScaleY] - SK_Scalar1, tol);
 }
 
 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;
 }
 
 bool SkBitmapProcInfo::init(const SkMatrix& inv, const SkPaint& paint) {
     const int origW = fProvider.info().width();
@@ skipping 697 matching lines @@
             *dst++ = src[index];
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }