Remove sk_bzero usage from SkMatrix44 for improved performance.

src/utils/SkMatrix44.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 "SkMatrix44.h"
 
 static inline bool eq4(const SkMScalar* SK_RESTRICT a,
@@ skipping 162 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkMatrix44& SkMatrix44::I() {
     static const SkMatrix44 gIdentity44(kIdentity_Constructor);
     return gIdentity44;
 }
 
 void SkMatrix44::setIdentity() {
-    sk_bzero(fMat, sizeof(fMat));
-    fMat[0][0] = fMat[1][1] = fMat[2][2] = fMat[3][3] = 1;
+    fMat[0][0] = 1;
+    fMat[0][1] = 0;
+    fMat[0][2] = 0;
+    fMat[0][3] = 0;
+    fMat[1][0] = 0;
+    fMat[1][1] = 1;
+    fMat[1][2] = 0;
+    fMat[1][3] = 0;
+    fMat[2][0] = 0;
+    fMat[2][1] = 0;
+    fMat[2][2] = 1;
+    fMat[2][3] = 0;
+    fMat[3][0] = 0;
+    fMat[3][1] = 0;
+    fMat[3][2] = 0;
+    fMat[3][3] = 1;
     this->setTypeMask(kIdentity_Mask);
 }
 
 void SkMatrix44::set3x3(SkMScalar m00, SkMScalar m01, SkMScalar m02,
                         SkMScalar m10, SkMScalar m11, SkMScalar m12,
                         SkMScalar m20, SkMScalar m21, SkMScalar m22) {
     fMat[0][0] = m00; fMat[0][1] = m01; fMat[0][2] = m02; fMat[0][3] = 0;
     fMat[1][0] = m10; fMat[1][1] = m11; fMat[1][2] = m12; fMat[1][3] = 0;
     fMat[2][0] = m20; fMat[2][1] = m21; fMat[2][2] = m22; fMat[2][3] = 0;
     fMat[3][0] = 0;   fMat[3][1] = 0;   fMat[3][2] = 0;   fMat[3][3] = 1;
@@ skipping 250 matching lines @@
     double b09 = a21 * a32 - a22 * a31;
     double b10 = a21 * a33 - a23 * a31;
     double b11 = a22 * a33 - a23 * a32;
 
     // Calculate the determinant
     return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// just picked a small value. not sure how to pick the "right" one
-#define TOO_SMALL_FOR_DETERMINANT   (1.e-8)
-
 static inline double dabs(double x) {
     if (x < 0) {
         x = -x;
     }
     return x;
 }
 
 bool SkMatrix44::invert(SkMatrix44* inverse) const {
     if (this->isIdentity()) {
         if (inverse) {
-            *inverse = *this;
+            inverse->setIdentity();
             return true;
         }
     }
     if (this->isTranslate()) {
         if (inverse) {
             inverse->setTranslate(-fMat[3][0], -fMat[3][1], -fMat[3][2]);
         }
         return true;
     }
     if (this->isScaleTranslate()) {
         if (0 == fMat[0][0] * fMat[1][1] * fMat[2][2]) {
             return false;
         }
-        if (inverse) {
-            sk_bzero(inverse->fMat, sizeof(inverse->fMat));
 
-            double invXScale = 1 / fMat[0][0];
-            double invYScale = 1 / fMat[1][1];
-            double invZScale = 1 / fMat[2][2];
+        double a00 = fMat[0][0];
+        double a11 = fMat[1][1];
+        double a22 = fMat[2][2];
+        double a30 = fMat[3][0];
+        double a31 = fMat[3][1];
+        double a32 = fMat[3][2];
 
-            inverse->fMat[3][0] = -fMat[3][0] * invXScale;
-            inverse->fMat[3][1] = -fMat[3][1] * invYScale;
-            inverse->fMat[3][2] = -fMat[3][2] * invZScale;
+        double b00 = a00 * a11;
+        double b07 = -a22 * a30;
+        double b09 = -a22 * a31;
+        double b11 = a22;
 
-            inverse->fMat[0][0] = invXScale;
-            inverse->fMat[1][1] = invYScale;
-            inverse->fMat[2][2] = invZScale;
-            inverse->fMat[3][3] = 1;
+        // Calculate the determinant
+        double det = b00 * b11;
 
-            inverse->setTypeMask(this->getType());
+        double invdet = 1.0 / det;
+        // If det is zero, we want to return false. However, we also want to return false
+        // if 1/det overflows to infinity (i.e. det is denormalized). Both of these are
+        // handled by checking that 1/det is finite.
+        if (!sk_float_isfinite(invdet)) {
+            return false;
         }
+        if (NULL == inverse) {
+            return true;
+        }
+
+        b00 *= invdet;
+        b07 *= invdet;
+        b09 *= invdet;
+        b11 *= invdet;
+
+        inverse->fMat[0][0] = SkDoubleToMScalar(a11 * b11);
+        inverse->fMat[0][1] = 0;
+        inverse->fMat[0][2] = 0;
+        inverse->fMat[0][3] = 0;
+        inverse->fMat[1][0] = 0;
+        inverse->fMat[1][1] = SkDoubleToMScalar(a00 * b11);
+        inverse->fMat[1][2] = 0;
+        inverse->fMat[1][3] = 0;
+        inverse->fMat[2][0] = 0;
+        inverse->fMat[2][1] = 0;
+        inverse->fMat[2][2] = SkDoubleToMScalar(b00);
+        inverse->fMat[2][3] = 0;
+        inverse->fMat[3][0] = SkDoubleToMScalar(a11 * b07);
+        inverse->fMat[3][1] = SkDoubleToMScalar(a00 * b09);
+        inverse->fMat[3][2] = SkDoubleToMScalar(-a32 * b00);
+        inverse->fMat[3][3] = 1;
+
+        inverse->setTypeMask(this->getType());
         return true;
     }
 
     double a00 = fMat[0][0];
     double a01 = fMat[0][1];
     double a02 = fMat[0][2];
     double a03 = fMat[0][3];
     double a10 = fMat[1][0];
     double a11 = fMat[1][1];
     double a12 = fMat[1][2];
@@ skipping 366 matching lines @@
              fMat[2][0], fMat[2][1], fMat[2][2], fMat[2][3],
              fMat[3][0], fMat[3][1], fMat[3][2], fMat[3][3]);
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // TODO: make this support src' perspective elements
 //
 static void initFromMatrix(SkMScalar dst[4][4], const SkMatrix& src) {
-    sk_bzero(dst, 16 * sizeof(SkMScalar));
     dst[0][0] = SkScalarToMScalar(src[SkMatrix::kMScaleX]);
     dst[1][0] = SkScalarToMScalar(src[SkMatrix::kMSkewX]);
+    dst[2][0] = 0;
     dst[3][0] = SkScalarToMScalar(src[SkMatrix::kMTransX]);
     dst[0][1] = SkScalarToMScalar(src[SkMatrix::kMSkewY]);
     dst[1][1] = SkScalarToMScalar(src[SkMatrix::kMScaleY]);
+    dst[2][1] = 0;
     dst[3][1] = SkScalarToMScalar(src[SkMatrix::kMTransY]);
-    dst[2][2] = dst[3][3] = 1;
+    dst[0][2] = 0;
+    dst[1][2] = 0;
+    dst[2][2] = 1;
+    dst[3][2] = 0;
+    dst[0][3] = 0;
+    dst[1][3] = 0;
+    dst[2][3] = 0;
+    dst[3][3] = 1;
 }
 
 SkMatrix44::SkMatrix44(const SkMatrix& src) {
     initFromMatrix(fMat, src);
 }
 
 SkMatrix44& SkMatrix44::operator=(const SkMatrix& src) {
     initFromMatrix(fMat, src);
 
     if (src.isIdentity()) {
@@ skipping 13 matching lines @@
     dst[SkMatrix::kMScaleX]  = SkMScalarToScalar(fMat[0][0]);
     dst[SkMatrix::kMSkewX]  = SkMScalarToScalar(fMat[1][0]);
     dst[SkMatrix::kMTransX] = SkMScalarToScalar(fMat[3][0]);
 
     dst[SkMatrix::kMSkewY]  = SkMScalarToScalar(fMat[0][1]);
     dst[SkMatrix::kMScaleY] = SkMScalarToScalar(fMat[1][1]);
     dst[SkMatrix::kMTransY] = SkMScalarToScalar(fMat[3][1]);
 
     return dst;
 }