use forward matrix to determine if we can ignore scale part of a matrix

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 "SkBitmapProcState.h"
 #include "SkColorPriv.h"
 #include "SkFilterProc.h"
@@ skipping 18 matching lines @@
 #include "SkBitmapProcState_procs.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  *  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 SkBitmap& bitmap) {
     SkMatrix::TypeMask mask = matrix.getType();
 

[robertphillips, 2013/04/15 19:43:02]

assert this now?

[reed1, 2013/04/15 20:00:26]

Done.

     if (mask & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
         return false;
     }
     if (mask & SkMatrix::kScale_Mask) {
+#if 0
         SkScalar sx = matrix[SkMatrix::kMScaleX];
         SkScalar sy = matrix[SkMatrix::kMScaleY];
         int w = bitmap.width();
         int h = bitmap.height();
         int sw = SkScalarRound(SkScalarMul(sx, SkIntToScalar(w)));
         int sh = SkScalarRound(SkScalarMul(sy, SkIntToScalar(h)));
         return sw == w && sh == h;
+#else
+        SkRect src, dst;
+        bitmap.getBounds(&src);
+        matrix.mapRect(&dst, src);
+        SkIRect idst;
+        dst.round(&idst);
+        return idst.width() == bitmap.width() && idst.height() == bitmap.height();
+#endif
     }
     // if we got here, we're either kTranslate_Mask or identity
     return true;
 }
 
 static bool just_trans_general(const SkMatrix& matrix) {
     SkMatrix::TypeMask mask = matrix.getType();
 

[robertphillips, 2013/04/15 19:43:02]

Assert this now?

     if (mask & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
         return false;
     }
     if (mask & SkMatrix::kScale_Mask) {
         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;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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 bool matrix_only_scale_translate(const SkMatrix& m) {

[robertphillips, 2013/04/15 19:43:02]

This is done as "if (mask <= (SkMatrix::kTranslate_Mask |
SkMatrix::kScale_Mask))" elsewhere.

[reed1, 2013/04/15 20:00:26]

Done.

+    unsigned mask = SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask;
+    return 0 == (m.getType() & ~mask);
+}
+
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     if (fOrigBitmap.width() == 0 || fOrigBitmap.height() == 0) {
         return false;
     }
 
     const SkMatrix* m;
     bool trivial_matrix = (inv.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clamp_clamp = SkShader::kClamp_TileMode == fTileModeX &&
                        SkShader::kClamp_TileMode == fTileModeY;
 
@@ skipping 19 matching lines @@
 
             SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
             fUnitInvMatrix.postScale(scale, scale);
 
             // now point here instead of fOrigBitmap
             fBitmap = &fMipBitmap;
         }
     }
 
     // wack our matrix to exactly no-scale, if we're really close to begin with
-    {
+    if (false) {
         bool fixupMatrix = clamp_clamp ?
         just_trans_clamp(*m, *fBitmap) : just_trans_general(*m);
         if (fixupMatrix) {
             // If we can be treated just like translate, construct that inverse
             // such that we landed in the proper place. Given that m may have
             // some slight scale, we have to invert it to compute this new
             // matrix.
             SkMatrix forward;
             if (m->invert(&forward)) {
                 SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
                 SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
                 fUnitInvMatrix.setTranslate(tx, ty);
                 m = &fUnitInvMatrix;
                 // now the following code will sniff m, and decide to take the
                 // fast case (since m is purely translate).
             }
         }
     }
+    if (matrix_only_scale_translate(*m)) {
+        SkMatrix forward;
+        if (m->invert(&forward)) {
+            if (clamp_clamp ? just_trans_clamp(forward, *fBitmap)
+                            : just_trans_general(forward)) {
+                SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
+                SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
+                fUnitInvMatrix.setTranslate(tx, ty);
+                m = &fUnitInvMatrix;
+                // now the following code will sniff m, and decide to take the
+                // fast case (since m is purely translate).
+            }
+        }
+    }
 
     // Below this point, we should never refer to the inv parameter, since we
     // may be using a munged version for "our" inverse.
 
     fInvMatrix      = m;
     fInvProc        = m->getMapXYProc();
     fInvType        = m->getType();
     fInvSx          = SkScalarToFixed(m->getScaleX());
     fInvSxFractionalInt = SkScalarToFractionalInt(m->getScaleX());
     fInvKy          = SkScalarToFixed(m->getSkewY());
@@ skipping 559 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fDoFilter) {
         size >>= 1;
     }
 
     return size;
 }