allow subpixel positioning w/ bitmap filtering

src/core/SkMatrix.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkFloatBits.h"
 #include "SkString.h"
@@ skipping 1620 matching lines @@
     str->appendf("[%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f]",
              fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5],
              fMat[6], fMat[7], fMat[8]);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkMatrixUtils.h"
 
+bool SkRectIsOnGrid(int width, int height, const SkRect& r, unsigned subpixelBits) {
+    const int lowBitsMask = (1 << subpixelBits) - 1;
+    const SkScalar scale = 1 << subpixelBits;
+    
+    const int dL = SkScalarRoundToInt(r.fLeft * scale);
+    const int dT = SkScalarRoundToInt(r.fTop * scale);
+    const int dR = SkScalarRoundToInt(r.fRight * scale);
+    const int dB = SkScalarRoundToInt(r.fBottom * scale);
+
+    if (subpixelBits) {
+        // we only check the low-bits for gridding if we have subpixelBits
+        const int merge = dL | dT | dR | dB;
+        if (merge & lowBitsMask) {
+            return false;
+        }
+    }
+    
+    // Now we know we're integral, just need to check our width/height
+    const int dW = (dR - dL);
+    const int dH = (dB - dT);
+    if (dW != (width << subpixelBits) || dH != (height << subpixelBits)) {
+        return false;
+    }
+    return true;
+}
+
 bool SkTreatAsSprite(const SkMatrix& mat, int width, int height,
                      unsigned subpixelBits) {
     // quick reject on affine or perspective
     if (mat.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
         return false;
     }
 
     // quick success check
     if (!subpixelBits && !(mat.getType() & ~SkMatrix::kTranslate_Mask)) {
         return true;
     }
 
     // mapRect supports negative scales, so we eliminate those first
     if (mat.getScaleX() < 0 || mat.getScaleY() < 0) {
         return false;
     }
 
     SkRect dst;
     SkIRect isrc = { 0, 0, width, height };
 
     {
         SkRect src;
         src.set(isrc);
         mat.mapRect(&dst, src);
     }
 
+#if 0
     // just apply the translate to isrc
     isrc.offset(SkScalarRoundToInt(mat.getTranslateX()),
                 SkScalarRoundToInt(mat.getTranslateY()));
 
     if (subpixelBits) {
         isrc.fLeft <<= subpixelBits;
         isrc.fTop <<= subpixelBits;
         isrc.fRight <<= subpixelBits;
         isrc.fBottom <<= subpixelBits;
 
         const float scale = 1 << subpixelBits;
         dst.fLeft *= scale;
         dst.fTop *= scale;
         dst.fRight *= scale;
         dst.fBottom *= scale;
     }
 
     SkIRect idst;
     dst.round(&idst);
     return isrc == idst;
+#else
+    return SkRectIsOnGrid(width, height, dst, subpixelBits);
+#endif
 }
 
 // A square matrix M can be decomposed (via polar decomposition) into two matrices --
 // an orthogonal matrix Q and a symmetric matrix S. In turn we can decompose S into U*W*U^T,
 // where U is another orthogonal matrix and W is a scale matrix. These can be recombined
 // to give M = (Q*U)*W*U^T, i.e., the product of two orthogonal matrices and a scale matrix.
 //
 // The one wrinkle is that traditionally Q may contain a reflection -- the
 // calculation has been rejiggered to put that reflection into W.
 bool SkDecomposeUpper2x2(const SkMatrix& matrix,
@@ skipping 83 matching lines @@
         rotation1->fX = cos1;
         rotation1->fY = sin1;
     }
     if (NULL != rotation2) {
         rotation2->fX = cos2;
         rotation2->fY = sin2;
     }
 
     return true;
 }