add virtuals to optimize composing colorfilters

src/effects/SkColorMatrix.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 "SkColorMatrix.h"
 
+// To detect if we need to apply clamping after applying a matrix, we check if
+// any output component might go outside of [0, 255] for any combination of
+// input components in [0..255].
+// Each output component is an affine transformation of the input component, so
+// the minimum and maximum values are for any combination of minimum or maximum
+// values of input components (i.e. 0 or 255).
+// E.g. if R' = x*R + y*G + z*B + w*A + t
+// Then the maximum value will be for R=255 if x>0 or R=0 if x<0, and the
+// minimum value will be for R=0 if x>0 or R=255 if x<0.
+// Same goes for all components.
+static bool component_needs_clamping(const SkScalar row[5]) {
+    SkScalar maxValue = row[4] / 255;
+    SkScalar minValue = row[4] / 255;
+    for (int i = 0; i < 4; ++i) {
+        if (row[i] > 0)
+            maxValue += row[i];
+        else
+            minValue += row[i];
+    }
+    return (maxValue > 1) || (minValue < 0);
+}
+
+bool SkColorMatrix::NeedsClamping(const SkScalar matrix[20]) {
+    return component_needs_clamping(matrix)
+        || component_needs_clamping(matrix+5)
+        || component_needs_clamping(matrix+10)
+        || component_needs_clamping(matrix+15);
+}
+
+void SkColorMatrix::SetConcat(SkScalar result[20],
+                              const SkScalar outer[20], const SkScalar inner[20]) {
+    SkScalar    tmp[20];
+    SkScalar*   target;
+
+    if (outer == result || inner == result) {
+        target = tmp;   // will memcpy answer when we're done into result
+    } else {
+        target = result;
+    }
+
+    int index = 0;
+    for (int j = 0; j < 20; j += 5) {
+        for (int i = 0; i < 4; i++) {
+            target[index++] =   outer[j + 0] * inner[i + 0] +
+                                outer[j + 1] * inner[i + 5] +
+                                outer[j + 2] * inner[i + 10] +
+                                outer[j + 3] * inner[i + 15];
+        }
+        target[index++] =   outer[j + 0] * inner[4] +
+                            outer[j + 1] * inner[9] +
+                            outer[j + 2] * inner[14] +
+                            outer[j + 3] * inner[19] +
+                            outer[j + 4];
+    }
+
+    if (target != result) {
+        memcpy(result, target, 20 * sizeof(SkScalar));
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 void SkColorMatrix::setIdentity() {
     memset(fMat, 0, sizeof(fMat));
     fMat[kR_Scale] = fMat[kG_Scale] = fMat[kB_Scale] = fMat[kA_Scale] = 1;
 }
 
 void SkColorMatrix::setScale(SkScalar rScale, SkScalar gScale, SkScalar bScale,
                              SkScalar aScale) {
     memset(fMat, 0, sizeof(fMat));
     fMat[kR_Scale] = rScale;
     fMat[kG_Scale] = gScale;
@@ skipping 43 matching lines @@
 }
 
 void SkColorMatrix::postRotate(Axis axis, SkScalar degrees) {
     SkColorMatrix tmp;
     tmp.setRotate(axis, degrees);
     this->postConcat(tmp);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkColorMatrix::setConcat(const SkColorMatrix& matA,
-                              const SkColorMatrix& matB) {
+void SkColorMatrix::setConcat(const SkColorMatrix& matA, const SkColorMatrix& matB) {
+#if 0

[Stephen White, 2015/03/02 21:10:10]

Please remove #if 0'ed code.

[reed1, 2015/03/02 21:19:19]

Ooops. Done.

     SkScalar    tmp[20];
     SkScalar*   result = fMat;
 
     if (&matA == this || &matB == this) {
         result = tmp;
     }
 
     const SkScalar* a = matA.fMat;
     const SkScalar* b = matB.fMat;
 
     int index = 0;
     for (int j = 0; j < 20; j += 5) {
         for (int i = 0; i < 4; i++) {
             result[index++] =   SkScalarMul(a[j + 0], b[i + 0]) +
                                 SkScalarMul(a[j + 1], b[i + 5]) +
                                 SkScalarMul(a[j + 2], b[i + 10]) +
                                 SkScalarMul(a[j + 3], b[i + 15]);
         }
         result[index++] =   SkScalarMul(a[j + 0], b[4]) +
                             SkScalarMul(a[j + 1], b[9]) +
                             SkScalarMul(a[j + 2], b[14]) +
                             SkScalarMul(a[j + 3], b[19]) +
                             a[j + 4];
     }
 
     if (fMat != result) {
         memcpy(fMat, result, sizeof(fMat));
     }
+#else
+    SetConcat(fMat, matA.fMat, matB.fMat);
+#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void setrow(SkScalar row[], SkScalar r, SkScalar g, SkScalar b) {
     row[0] = r;
     row[1] = g;
     row[2] = b;
 }
 
@@ skipping 41 matching lines @@
 static const SkScalar kU2B = 1.772f;
 
 void SkColorMatrix::setYUV2RGB() {
     memset(fMat, 0, sizeof(fMat));
 
     setrow(fMat +  0, 1, 0, kV2R);
     setrow(fMat +  5, 1, kU2G, kV2G);
     setrow(fMat + 10, 1, kU2B, 0);
     fMat[kA_Scale] = 1;
 }
+