move more geometry to simd

src/core/SkGeometry.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 "SkGeometry.h"
 #include "SkMatrix.h"
 #include "SkNx.h"
@@ skipping 86 matching lines @@
             SkTSwap<SkScalar>(roots[0], roots[1]);
         else if (roots[0] == roots[1])  // nearly-equal?
             r -= 1; // skip the double root
     }
     return (int)(r - roots);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-static Sk2s quad_poly_eval(const Sk2s& A, const Sk2s& B, const Sk2s& C, const Sk2s& t) {
-    return (A * t + B) * t + C;
-}
-
-static SkScalar eval_quad(const SkScalar src[], SkScalar t) {
-    SkASSERT(src);
-    SkASSERT(t >= 0 && t <= SK_Scalar1);
-
-#ifdef DIRECT_EVAL_OF_POLYNOMIALS
-    SkScalar    C = src[0];
-    SkScalar    A = src[4] - 2 * src[2] + C;
-    SkScalar    B = 2 * (src[2] - C);
-    return SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C);
-#else
-    SkScalar    ab = SkScalarInterp(src[0], src[2], t);
-    SkScalar    bc = SkScalarInterp(src[2], src[4], t);
-    return SkScalarInterp(ab, bc, t);
-#endif
-}
-
-void SkQuadToCoeff(const SkPoint pts[3], SkPoint coeff[3]) {
-    Sk2s p0 = from_point(pts[0]);
-    Sk2s p1 = from_point(pts[1]);
-    Sk2s p2 = from_point(pts[2]);
-
-    Sk2s p1minus2 = p1 - p0;
-
-    coeff[0] = to_point(p2 - p1 - p1 + p0);     // A * t^2
-    coeff[1] = to_point(p1minus2 + p1minus2);   // B * t
-    coeff[2] = pts[0];                          // C
-}
-
 void SkEvalQuadAt(const SkPoint src[3], SkScalar t, SkPoint* pt, SkVector* tangent) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     if (pt) {
-        pt->set(eval_quad(&src[0].fX, t), eval_quad(&src[0].fY, t));
+        *pt = SkEvalQuadAt(src, t);
     }
     if (tangent) {
         *tangent = SkEvalQuadTangentAt(src, t);
     }
 }
 
 SkPoint SkEvalQuadAt(const SkPoint src[3], SkScalar t) {
-    SkASSERT(src);
-    SkASSERT(t >= 0 && t <= SK_Scalar1);
-
-    const Sk2s t2(t);
-
-    Sk2s P0 = from_point(src[0]);
-    Sk2s P1 = from_point(src[1]);
-    Sk2s P2 = from_point(src[2]);
-
-    Sk2s B = P1 - P0;
-    Sk2s A = P2 - P1 - B;
-
-    return to_point((A * t2 + B+B) * t2 + P0);
+    return to_point(SkQuadCoeff(src).eval(t));
 }
 
 SkVector SkEvalQuadTangentAt(const SkPoint src[3], SkScalar t) {
     // The derivative equation is 2(b - a +(a - 2b +c)t). This returns a
     // zero tangent vector when t is 0 or 1, and the control point is equal
     // to the end point. In this case, use the quad end points to compute the tangent.
     if ((t == 0 && src[0] == src[1]) || (t == 1 && src[1] == src[2])) {
         return src[2] - src[0];
     }
     SkASSERT(src);
@@ skipping 151 matching lines @@
     dst[0] = src[0];
     dst[1] = to_point(s0 + (s1 - s0) * scale);
     dst[2] = to_point(s2 + (s1 - s2) * scale);
     dst[3] = src[2];
 }
 
 //////////////////////////////////////////////////////////////////////////////
 ///// CUBICS // CUBICS // CUBICS // CUBICS // CUBICS // CUBICS // CUBICS /////
 //////////////////////////////////////////////////////////////////////////////
 
+#ifdef SK_SUPPORT_LEGACY_EVAL_CUBIC
 static SkScalar eval_cubic(const SkScalar src[], SkScalar t) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     if (t == 0) {
         return src[0];
     }
 
 #ifdef DIRECT_EVAL_OF_POLYNOMIALS
     SkScalar D = src[0];
     SkScalar A = src[6] + 3*(src[2] - src[4]) - D;
     SkScalar B = 3*(src[4] - src[2] - src[2] + D);
     SkScalar C = 3*(src[2] - D);
 
     return SkScalarMulAdd(SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C), t, D);
 #else
     SkScalar    ab = SkScalarInterp(src[0], src[2], t);
     SkScalar    bc = SkScalarInterp(src[2], src[4], t);
     SkScalar    cd = SkScalarInterp(src[4], src[6], t);
     SkScalar    abc = SkScalarInterp(ab, bc, t);
     SkScalar    bcd = SkScalarInterp(bc, cd, t);
     return SkScalarInterp(abc, bcd, t);
 #endif
 }
+#endif
 
-/** return At^2 + Bt + C
-*/
-static SkScalar eval_quadratic(SkScalar A, SkScalar B, SkScalar C, SkScalar t) {
-    SkASSERT(t >= 0 && t <= SK_Scalar1);
+static SkVector eval_cubic_derivative(const SkPoint src[4], SkScalar t) {
+    SkQuadCoeff coeff;
+    Sk2s P0 = from_point(src[0]);
+    Sk2s P1 = from_point(src[1]);
+    Sk2s P2 = from_point(src[2]);
+    Sk2s P3 = from_point(src[3]);
 
-    return SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C);
+    coeff.fA = P3 + Sk2s(3) * (P1 - P2) - P0;
+    coeff.fB = times_2(P2 - times_2(P1) + P0);
+    coeff.fC = P1 - P0;
+    return to_vector(coeff.eval(t));
 }
 
-static SkScalar eval_cubic_derivative(const SkScalar src[], SkScalar t) {
-    SkScalar A = src[6] + 3*(src[2] - src[4]) - src[0];
-    SkScalar B = 2*(src[4] - 2 * src[2] + src[0]);
-    SkScalar C = src[2] - src[0];
+static SkVector eval_cubic_2ndDerivative(const SkPoint src[4], SkScalar t) {
+    Sk2s P0 = from_point(src[0]);
+    Sk2s P1 = from_point(src[1]);
+    Sk2s P2 = from_point(src[2]);
+    Sk2s P3 = from_point(src[3]);
+    Sk2s A = P3 + Sk2s(3) * (P1 - P2) - P0;
+    Sk2s B = P2 - times_2(P1) + P0;
 
-    return eval_quadratic(A, B, C, t);
-}
-
-static SkScalar eval_cubic_2ndDerivative(const SkScalar src[], SkScalar t) {
-    SkScalar A = src[6] + 3*(src[2] - src[4]) - src[0];
-    SkScalar B = src[4] - 2 * src[2] + src[0];
-
-    return SkScalarMulAdd(A, t, B);
+    return to_vector(A * Sk2s(t) + B);
 }
 
 void SkEvalCubicAt(const SkPoint src[4], SkScalar t, SkPoint* loc,
                    SkVector* tangent, SkVector* curvature) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     if (loc) {
+#ifdef SK_SUPPORT_LEGACY_EVAL_CUBIC
         loc->set(eval_cubic(&src[0].fX, t), eval_cubic(&src[0].fY, t));
+#else
+        *loc = to_point(SkCubicCoeff(src).eval(t));
+#endif
     }
     if (tangent) {
         // The derivative equation returns a zero tangent vector when t is 0 or 1, and the
         // adjacent control point is equal to the end point. In this case, use the
         // next control point or the end points to compute the tangent.
         if ((t == 0 && src[0] == src[1]) || (t == 1 && src[2] == src[3])) {
             if (t == 0) {
                 *tangent = src[2] - src[0];
             } else {
                 *tangent = src[3] - src[1];
             }
             if (!tangent->fX && !tangent->fY) {
                 *tangent = src[3] - src[0];
             }
         } else {
-            tangent->set(eval_cubic_derivative(&src[0].fX, t),
-                         eval_cubic_derivative(&src[0].fY, t));
+            *tangent = eval_cubic_derivative(src, t);
         }
     }
     if (curvature) {
-        curvature->set(eval_cubic_2ndDerivative(&src[0].fX, t),
-                       eval_cubic_2ndDerivative(&src[0].fY, t));
+        *curvature = eval_cubic_2ndDerivative(src, t);
     }
 }
 
 /** Cubic'(t) = At^2 + Bt + C, where
     A = 3(-a + 3(b - c) + d)
     B = 6(a - 2b + c)
     C = 3(b - a)
     Solve for t, keeping only those that fit betwee 0 < t < 1
 */
 int SkFindCubicExtrema(SkScalar a, SkScalar b, SkScalar c, SkScalar d,
@@ skipping 24 matching lines @@
 
     dst[0] = src[0];
     dst[1] = to_point(ab);
     dst[2] = to_point(abc);
     dst[3] = to_point(abcd);
     dst[4] = to_point(bcd);
     dst[5] = to_point(cd);
     dst[6] = src[3];
 }
 
-void SkCubicToCoeff(const SkPoint pts[4], SkPoint coeff[4]) {
-    Sk2s p0 = from_point(pts[0]);
-    Sk2s p1 = from_point(pts[1]);
-    Sk2s p2 = from_point(pts[2]);
-    Sk2s p3 = from_point(pts[3]);
-
-    const Sk2s three(3);
-    Sk2s p1minusp2 = p1 - p2;
-
-    Sk2s D = p0;
-    Sk2s A = p3 + three * p1minusp2 - D;
-    Sk2s B = three * (D - p1minusp2 - p1);
-    Sk2s C = three * (p1 - D);
-
-    coeff[0] = to_point(A);
-    coeff[1] = to_point(B);
-    coeff[2] = to_point(C);
-    coeff[3] = to_point(D);
-}
-
 /*  http://code.google.com/p/skia/issues/detail?id=32
 
     This test code would fail when we didn't check the return result of
     valid_unit_divide in SkChopCubicAt(... tValues[], int roots). The reason is
     that after the first chop, the parameters to valid_unit_divide are equal
     (thanks to finite float precision and rounding in the subtracts). Thus
     even though the 2nd tValue looks < 1.0, after we renormalize it, we end
     up with 1.0, hence the need to check and just return the last cubic as
     a degenerate clump of 4 points in the sampe place.
 
@@ skipping 598 matching lines @@
     Sk2s bXY = times_2(dXY) - (aXY + cXY) * Sk2s(0.5f);
     Sk2s bZZ = times_2(dZZ) - (aZZ + cZZ) * Sk2s(0.5f);
     dst->fPts[0] = to_point(aXY / aZZ);
     dst->fPts[1] = to_point(bXY / bZZ);
     dst->fPts[2] = to_point(cXY / cZZ);
     Sk2s ww = bZZ / (aZZ * cZZ).sqrt();
     dst->fW = ww.kth<0>();
 }
 
 SkPoint SkConic::evalAt(SkScalar t) const {
-    Sk2s p0 = from_point(fPts[0]);
-    Sk2s p1 = from_point(fPts[1]);
-    Sk2s p2 = from_point(fPts[2]);
-    Sk2s tt(t);
-    Sk2s ww(fW);
-    Sk2s one(1);
-
-    Sk2s p1w = p1 * ww;
-    Sk2s C = p0;
-    Sk2s A = p2 - times_2(p1w) + p0;
-    Sk2s B = times_2(p1w - C);
-    Sk2s numer = quad_poly_eval(A, B, C, tt);
-
-    B = times_2(ww - one);
-    A = Sk2s(0)-B;
-    Sk2s denom = quad_poly_eval(A, B, one, tt);
-
-    return to_point(numer / denom);
+    return to_point(SkConicCoeff(*this).eval(t));
 }
 
 SkVector SkConic::evalTangentAt(SkScalar t) const {
     // The derivative equation returns a zero tangent vector when t is 0 or 1,
     // and the control point is equal to the end point.
     // In this case, use the conic endpoints to compute the tangent.
     if ((t == 0 && fPts[0] == fPts[1]) || (t == 1 && fPts[1] == fPts[2])) {
         return fPts[2] - fPts[0];
     }
     Sk2s p0 = from_point(fPts[0]);
     Sk2s p1 = from_point(fPts[1]);
     Sk2s p2 = from_point(fPts[2]);
     Sk2s ww(fW);
 
     Sk2s p20 = p2 - p0;
     Sk2s p10 = p1 - p0;
 
     Sk2s C = ww * p10;
     Sk2s A = ww * p20 - p20;
     Sk2s B = p20 - C - C;
 
-    return to_vector(quad_poly_eval(A, B, C, Sk2s(t)));
+    return to_vector(SkQuadCoeff(A, B, C).eval(t));
 }
 
 void SkConic::evalAt(SkScalar t, SkPoint* pt, SkVector* tangent) const {
     SkASSERT(t >= 0 && t <= SK_Scalar1);
     
     if (pt) {
         *pt = this->evalAt(t);
     }
     if (tangent) {
         *tangent = this->evalTangentAt(t);
     }
 }
 
 static SkScalar subdivide_w_value(SkScalar w) {
     return SkScalarSqrt(SK_ScalarHalf + w * SK_ScalarHalf);
 }
 
-static Sk2s twice(const Sk2s& value) {
-    return value + value;
-}
-
 void SkConic::chop(SkConic * SK_RESTRICT dst) const {
     Sk2s scale = Sk2s(SkScalarInvert(SK_Scalar1 + fW));
     SkScalar newW = subdivide_w_value(fW);
 
     Sk2s p0 = from_point(fPts[0]);
     Sk2s p1 = from_point(fPts[1]);
     Sk2s p2 = from_point(fPts[2]);
     Sk2s ww(fW);
 
     Sk2s wp1 = ww * p1;
-    Sk2s m = (p0 + twice(wp1) + p2) * scale * Sk2s(0.5f);
+    Sk2s m = (p0 + times_2(wp1) + p2) * scale * Sk2s(0.5f);
 
     dst[0].fPts[0] = fPts[0];
     dst[0].fPts[1] = to_point((p0 + wp1) * scale);
     dst[0].fPts[2] = dst[1].fPts[0] = to_point(m);
     dst[1].fPts[1] = to_point((wp1 + p2) * scale);
     dst[1].fPts[2] = fPts[2];
 
     dst[0].fW = dst[1].fW = newW;
 }
 
@@ skipping 241 matching lines @@
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
     }
     if (userMatrix) {
         matrix.postConcat(*userMatrix);
     }
     for (int i = 0; i < conicCount; ++i) {
         matrix.mapPoints(dst[i].fPts, 3);
     }
     return conicCount;
 }