Revive quad approximation stroker

src/core/SkStroke.cpp

 /*
  * Copyright 2008 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 "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
 
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
 
     enum {
         kTangent_RecursiveLimit,
         kCubic_RecursiveLimit,
+        kConic_RecursiveLimit,
         kQuad_RecursiveLimit
     };
 
     // quads with extreme widths (e.g. (0,1) (1,6) (0,3) width=5e7) recurse to point of failure
     // largest seen for normal cubics : 5, 26
     // largest seen for normal quads : 11
-    static const int kRecursiveLimits[] = { 5*3, 26*3, 11*3 };  // 3x limits seen in practical tests
+    static const int kRecursiveLimits[] = { 5*3, 26*3, 11*3, 11*3 }; // 3x limits seen in practice
 
+    SK_COMPILE_ASSERT(0 == kTangent_RecursiveLimit, cubic_stroke_relies_on_tangent_equalling_zero);
+    SK_COMPILE_ASSERT(1 == kCubic_RecursiveLimit, cubic_stroke_relies_on_cubic_equalling_one);
     SK_COMPILE_ASSERT(SK_ARRAY_COUNT(kRecursiveLimits) == kQuad_RecursiveLimit + 1,
             recursive_limits_mismatch);
 
-    #ifdef SK_DEBUG  // enables tweaking these values at runtime from SampleApp
-        bool gDebugStrokerErrorSet = false;
-        SkScalar gDebugStrokerError;
-
+    #ifdef SK_DEBUG
         int gMaxRecursion[SK_ARRAY_COUNT(kRecursiveLimits)] = { 0 };
     #endif
     #ifndef DEBUG_QUAD_STROKER
         #define DEBUG_QUAD_STROKER 0
     #endif
 
     #if DEBUG_QUAD_STROKER
         /* Enable to show the decisions made in subdividing the curve -- helpful when the resulting
            stroke has more than the optimal number of quadratics and lines */
         #define STROKER_RESULT(resultType, depth, quadPts, format, ...) \
                 SkDebugf("[%d] %s " format "\n", depth, __FUNCTION__, __VA_ARGS__), \
                 SkDebugf("  " #resultType " t=(%g,%g)\n", quadPts->fStartT, quadPts->fEndT), \
                 resultType
         #define STROKER_DEBUG_PARAMS(...) , __VA_ARGS__
     #else
         #define STROKER_RESULT(resultType, depth, quadPts, format, ...) \
                 resultType
         #define STROKER_DEBUG_PARAMS(...)
     #endif
 
 #endif
 
+#ifndef SK_QUAD_STROKE_APPROXIMATION
 #define kMaxQuadSubdivide   5
 #define kMaxCubicSubdivide  7
+#endif
 
 static inline bool degenerate_vector(const SkVector& v) {
     return !SkPoint::CanNormalize(v.fX, v.fY);
 }
 
-#if !QUAD_STROKE_APPROXIMATION
+#ifndef SK_QUAD_STROKE_APPROXIMATION
 static inline bool normals_too_curvy(const SkVector& norm0, SkVector& norm1) {
     /*  root2/2 is a 45-degree angle
         make this constant bigger for more subdivisions (but not >= 1)
     */
     static const SkScalar kFlatEnoughNormalDotProd =
                                             SK_ScalarSqrt2/2 + SK_Scalar1/10;
 
     SkASSERT(kFlatEnoughNormalDotProd > 0 &&
              kFlatEnoughNormalDotProd < SK_Scalar1);
 
@@ skipping 32 matching lines @@
                                   SkVector* normal, SkVector* unitNormal) {
     if (!unitNormal->setNormalize(vec.fX, vec.fY)) {
         return false;
     }
     unitNormal->rotateCCW();
     unitNormal->scale(radius, normal);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
 
 struct SkQuadConstruct {    // The state of the quad stroke under construction.
     SkPoint fQuad[3];       // the stroked quad parallel to the original curve
     SkPoint fTangentStart;  // a point tangent to fQuad[0]
     SkPoint fTangentEnd;    // a point tangent to fQuad[2]
     SkScalar fStartT;       // a segment of the original curve
     SkScalar fMidT;         //              "
     SkScalar fEndT;         //              "
     bool fStartSet;         // state to share common points across structs
     bool fEndSet;           //                     "
@@ skipping 24 matching lines @@
         fQuad[2] = parent->fQuad[2];
         fTangentEnd = parent->fTangentEnd;
         fEndSet = true;
         return true;
    }
 };
 #endif
 
 class SkPathStroker {
 public:
-#if QUAD_STROKE_APPROXIMATION
-    SkPathStroker(const SkPath& src,
-                  SkScalar radius, SkScalar miterLimit, SkScalar error, SkPaint::Cap,
-                  SkPaint::Join, SkScalar resScale);
-#else
     SkPathStroker(const SkPath& src,
                   SkScalar radius, SkScalar miterLimit, SkPaint::Cap,
                   SkPaint::Join, SkScalar resScale);
-#endif
 
     void moveTo(const SkPoint&);
     void lineTo(const SkPoint&);
     void quadTo(const SkPoint&, const SkPoint&);
+#ifdef SK_QUAD_STROKE_APPROXIMATION
+    void conicTo(const SkPoint&, const SkPoint&, SkScalar weight);
+#endif
     void cubicTo(const SkPoint&, const SkPoint&, const SkPoint&);
     void close(bool isLine) { this->finishContour(true, isLine); }
 
     void done(SkPath* dst, bool isLine) {
         this->finishContour(false, isLine);
         fOuter.addPath(fExtra);
         dst->swap(fOuter);
     }
 
     SkScalar getResScale() const { return fResScale; }
 
 private:
-#if QUAD_STROKE_APPROXIMATION
-    SkScalar    fError;
-#endif
     SkScalar    fRadius;
     SkScalar    fInvMiterLimit;
     SkScalar    fResScale;
+#ifdef SK_QUAD_STROKE_APPROXIMATION
+    SkScalar    fInvResScale;
+    SkScalar    fInvResScaleSquared;
+#endif
 
     SkVector    fFirstNormal, fPrevNormal, fFirstUnitNormal, fPrevUnitNormal;
     SkPoint     fFirstPt, fPrevPt;  // on original path
     SkPoint     fFirstOuterPt;
     int         fSegmentCount;
     bool        fPrevIsLine;
 
     SkStrokerPriv::CapProc  fCapper;
     SkStrokerPriv::JoinProc fJoiner;
 
     SkPath  fInner, fOuter; // outer is our working answer, inner is temp
     SkPath  fExtra;         // added as extra complete contours
 
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
     enum StrokeType {
         kOuter_StrokeType = 1,      // use sign-opposite values later to flip perpendicular axis
         kInner_StrokeType = -1
     } fStrokeType;
 
     enum ResultType {
         kSplit_ResultType,          // the caller should split the quad stroke in two
         kDegenerate_ResultType,     // the caller should add a line
         kQuad_ResultType,           // the caller should (continue to try to) add a quad stroke
         kNormalError_ResultType,    // the cubic's normal couldn't be computed -- abort
@@ skipping 10 matching lines @@
 
     enum IntersectRayType {
         kCtrlPt_RayType,
         kResultType_RayType,
     };
 
     int fRecursionDepth;            // track stack depth to abort if numerics run amok
     bool fFoundTangents;            // do less work until tangents meet (cubic)
 
     void addDegenerateLine(const SkQuadConstruct* );
+    ReductionType CheckConicLinear(const SkConic& , SkPoint* reduction);
     ReductionType CheckCubicLinear(const SkPoint cubic[4], SkPoint reduction[3],
                                    const SkPoint** tanPtPtr);
     ReductionType CheckQuadLinear(const SkPoint quad[3], SkPoint* reduction);
+    ResultType compareQuadConic(const SkConic& , SkQuadConstruct* );
     ResultType compareQuadCubic(const SkPoint cubic[4], SkQuadConstruct* );
     ResultType compareQuadQuad(const SkPoint quad[3], SkQuadConstruct* );
+    bool conicPerpRay(const SkConic& , SkScalar t, SkPoint* tPt, SkPoint* onPt,
+                      SkPoint* tangent) const;
+    bool conicQuadEnds(const SkConic& , SkQuadConstruct* );
+    bool conicStroke(const SkConic& , SkQuadConstruct* );
     bool cubicMidOnLine(const SkPoint cubic[4], const SkQuadConstruct* ) const;
     bool cubicPerpRay(const SkPoint cubic[4], SkScalar t, SkPoint* tPt, SkPoint* onPt,
                       SkPoint* tangent) const;
     bool cubicQuadEnds(const SkPoint cubic[4], SkQuadConstruct* );
     bool cubicQuadMid(const SkPoint cubic[4], const SkQuadConstruct* , SkPoint* mid) const;
     bool cubicStroke(const SkPoint cubic[4], SkQuadConstruct* );
     void init(StrokeType strokeType, SkQuadConstruct* , SkScalar tStart, SkScalar tEnd);
     ResultType intersectRay(SkQuadConstruct* , IntersectRayType  STROKER_DEBUG_PARAMS(int) ) const;
     bool ptInQuadBounds(const SkPoint quad[3], const SkPoint& pt) const;
     void quadPerpRay(const SkPoint quad[3], SkScalar t, SkPoint* tPt, SkPoint* onPt,
                      SkPoint* tangent) const;
     bool quadStroke(const SkPoint quad[3], SkQuadConstruct* );
+    void setConicEndNormal(const SkConic& ,
+                           const SkVector& normalAB, const SkVector& unitNormalAB,
+                           SkVector* normalBC, SkVector* unitNormalBC);
     void setCubicEndNormal(const SkPoint cubic[4],
                            const SkVector& normalAB, const SkVector& unitNormalAB,
                            SkVector* normalCD, SkVector* unitNormalCD);
     void setQuadEndNormal(const SkPoint quad[3],
                           const SkVector& normalAB, const SkVector& unitNormalAB,
                           SkVector* normalBC, SkVector* unitNormalBC);
     void setRayPts(const SkPoint& tPt, SkVector* dxy, SkPoint* onPt, SkPoint* tangent) const;
     static bool SlightAngle(SkQuadConstruct* );
     ResultType strokeCloseEnough(const SkPoint stroke[3], const SkPoint ray[2],
                                  SkQuadConstruct*  STROKER_DEBUG_PARAMS(int depth) ) const;
     ResultType tangentsMeet(const SkPoint cubic[4], SkQuadConstruct* );
 #endif
 
     void    finishContour(bool close, bool isLine);
     void    preJoinTo(const SkPoint&, SkVector* normal, SkVector* unitNormal,
                       bool isLine);
     void    postJoinTo(const SkPoint&, const SkVector& normal,
                        const SkVector& unitNormal);
 
     void    line_to(const SkPoint& currPt, const SkVector& normal);
-#if !QUAD_STROKE_APPROXIMATION
+#ifndef SK_QUAD_STROKE_APPROXIMATION
     void    quad_to(const SkPoint pts[3],
                     const SkVector& normalAB, const SkVector& unitNormalAB,
                     SkVector* normalBC, SkVector* unitNormalBC,
                     int subDivide);
     void    cubic_to(const SkPoint pts[4],
                     const SkVector& normalAB, const SkVector& unitNormalAB,
                     SkVector* normalCD, SkVector* unitNormalCD,
                     int subDivide);
 #endif
 };
@@ skipping 59 matching lines @@
         }
     }
     // since we may re-use fInner, we rewind instead of reset, to save on
     // reallocating its internal storage.
     fInner.rewind();
     fSegmentCount = -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#if QUAD_STROKE_APPROXIMATION
-SkPathStroker::SkPathStroker(const SkPath& src,
-                             SkScalar radius, SkScalar miterLimit, SkScalar error,
-                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale)
-#else
 SkPathStroker::SkPathStroker(const SkPath& src,
                              SkScalar radius, SkScalar miterLimit,
                              SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale)
-#endif
-        : fRadius(radius), fResScale(resScale) {
+        : fRadius(radius)
+        , fResScale(resScale) {
 
     /*  This is only used when join is miter_join, but we initialize it here
         so that it is always defined, to fis valgrind warnings.
     */
     fInvMiterLimit = 0;
 
     if (join == SkPaint::kMiter_Join) {
         if (miterLimit <= SK_Scalar1) {
             join = SkPaint::kBevel_Join;
         } else {
             fInvMiterLimit = SkScalarInvert(miterLimit);
         }
     }
     fCapper = SkStrokerPriv::CapFactory(cap);
     fJoiner = SkStrokerPriv::JoinFactory(join);
     fSegmentCount = -1;
     fPrevIsLine = false;
 
     // Need some estimate of how large our final result (fOuter)
     // and our per-contour temp (fInner) will be, so we don't spend
     // extra time repeatedly growing these arrays.
     //
     // 3x for result == inner + outer + join (swag)
     // 1x for inner == 'wag' (worst contour length would be better guess)
     fOuter.incReserve(src.countPoints() * 3);
     fOuter.setIsVolatile(true);
     fInner.incReserve(src.countPoints());
     fInner.setIsVolatile(true);
-#if QUAD_STROKE_APPROXIMATION
-#ifdef SK_DEBUG
-    if (!gDebugStrokerErrorSet) {
-        gDebugStrokerError = error;
-    }
-    fError = gDebugStrokerError;
-#else
-    fError = error;
-#endif
+#ifdef SK_QUAD_STROKE_APPROXIMATION
+    // TODO : write a common error function used by stroking and filling
+    // The '4' below matches the fill scan converter's error term
+    fInvResScale = SkScalarInvert(resScale * 4);
+    fInvResScaleSquared = fInvResScale * fInvResScale;
     fRecursionDepth = 0;
 #endif
 }
 
 void SkPathStroker::moveTo(const SkPoint& pt) {
     if (fSegmentCount > 0) {
         this->finishContour(false, false);
     }
     fSegmentCount = 0;
     fFirstPt = fPrevPt = pt;
 }
 
 void SkPathStroker::line_to(const SkPoint& currPt, const SkVector& normal) {
     fOuter.lineTo(currPt.fX + normal.fX, currPt.fY + normal.fY);
     fInner.lineTo(currPt.fX - normal.fX, currPt.fY - normal.fY);
 }
 
 void SkPathStroker::lineTo(const SkPoint& currPt) {
     if (SkPath::IsLineDegenerate(fPrevPt, currPt)) {
         return;
     }
     SkVector    normal, unitNormal;
 
     this->preJoinTo(currPt, &normal, &unitNormal, true);
     this->line_to(currPt, normal);
     this->postJoinTo(currPt, normal, unitNormal);
 }
 
-#if !QUAD_STROKE_APPROXIMATION
+#ifndef SK_QUAD_STROKE_APPROXIMATION
 void SkPathStroker::quad_to(const SkPoint pts[3],
                       const SkVector& normalAB, const SkVector& unitNormalAB,
                       SkVector* normalBC, SkVector* unitNormalBC,
                       int subDivide) {
     if (!set_normal_unitnormal(pts[1], pts[2], fRadius,
                                normalBC, unitNormalBC)) {
         // pts[1] nearly equals pts[2], so just draw a line to pts[2]
         this->line_to(pts[2], normalAB);
         *normalBC = normalAB;
         *unitNormalBC = unitNormalAB;
@@ skipping 17 matching lines @@
                                      SkScalarSqrt((SK_Scalar1 + dot)/2))));
 
         fOuter.quadTo(  pts[1].fX + normalB.fX, pts[1].fY + normalB.fY,
                         pts[2].fX + normalBC->fX, pts[2].fY + normalBC->fY);
         fInner.quadTo(  pts[1].fX - normalB.fX, pts[1].fY - normalB.fY,
                         pts[2].fX - normalBC->fX, pts[2].fY - normalBC->fY);
     }
 }
 #endif
 
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
 void SkPathStroker::setQuadEndNormal(const SkPoint quad[3], const SkVector& normalAB,
         const SkVector& unitNormalAB, SkVector* normalBC, SkVector* unitNormalBC) {
     if (!set_normal_unitnormal(quad[1], quad[2], fRadius, normalBC, unitNormalBC)) {
         *normalBC = normalAB;
         *unitNormalBC = unitNormalAB;
     }
 }
 
+void SkPathStroker::setConicEndNormal(const SkConic& conic, const SkVector& normalAB,
+        const SkVector& unitNormalAB, SkVector* normalBC, SkVector* unitNormalBC) {
+    setQuadEndNormal(conic.fPts, normalAB, unitNormalAB, normalBC, unitNormalBC);
+}
+
 void SkPathStroker::setCubicEndNormal(const SkPoint cubic[4], const SkVector& normalAB,
         const SkVector& unitNormalAB, SkVector* normalCD, SkVector* unitNormalCD) {
     SkVector    ab = cubic[1] - cubic[0];
     SkVector    cd = cubic[3] - cubic[2];
 
     bool    degenerateAB = degenerate_vector(ab);
     bool    degenerateCD = degenerate_vector(cd);
 
     if (degenerateAB && degenerateCD) {
         goto DEGENERATE_NORMAL;
@@ skipping 57 matching lines @@
     If outer_1 == 0 and outer_2 == 1, the smaller of the remaining indices (2 and 3) is 2.
 
     This table can be collapsed to: (1 + (2 >> outer_2)) >> outer_1
 
     Given three indices (outer_1 outer_2 mid_1) from 0..3, the remaining index is:
 
                mid_2 == (outer_1 ^ outer_2 ^ mid_1)
  */
 static bool cubic_in_line(const SkPoint cubic[4]) {
     SkScalar ptMax = -1;
-    int outer1, outer2;
+    int outer1 SK_INIT_TO_AVOID_WARNING;
+    int outer2 SK_INIT_TO_AVOID_WARNING;
     for (int index = 0; index < 3; ++index) {
         for (int inner = index + 1; inner < 4; ++inner) {
             SkVector testDiff = cubic[inner] - cubic[index];
             SkScalar testMax = SkTMax(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
             if (ptMax < testMax) {
                 outer1 = index;
                 outer2 = inner;
                 ptMax = testMax;
             }
         }
@@ skipping 15 matching lines @@
 
 /* Given quad, see if all there points are in a line.
    Return true if the inside point is close to a line connecting the outermost points.
 
    Find the outermost point by looking for the largest difference in X or Y.
    Since the XOR of the indices is 3  (0 ^ 1 ^ 2)
    the missing index equals: outer_1 ^ outer_2 ^ 3
  */
 static bool quad_in_line(const SkPoint quad[3]) {
     SkScalar ptMax = -1;
-    int outer1, outer2;
+    int outer1 SK_INIT_TO_AVOID_WARNING;
+    int outer2 SK_INIT_TO_AVOID_WARNING;
     for (int index = 0; index < 2; ++index) {
         for (int inner = index + 1; inner < 3; ++inner) {
             SkVector testDiff = quad[inner] - quad[index];
             SkScalar testMax = SkTMax(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
             if (ptMax < testMax) {
                 outer1 = index;
                 outer2 = inner;
                 ptMax = testMax;
             }
         }
     }
     SkASSERT(outer1 >= 0 && outer1 <= 1);
     SkASSERT(outer2 >= 1 && outer2 <= 2);
     SkASSERT(outer1 < outer2);
     int mid = outer1 ^ outer2 ^ 3;
     SkScalar lineSlop =  ptMax * ptMax * 0.00001f;  // this multiplier is pulled out of the air
     return pt_to_line(quad[mid], quad[outer1], quad[outer2]) <= lineSlop;
 }
 
+static bool conic_in_line(const SkConic& conic) {
+    return quad_in_line(conic.fPts);
+}
+
 SkPathStroker::ReductionType SkPathStroker::CheckCubicLinear(const SkPoint cubic[4],
         SkPoint reduction[3], const SkPoint** tangentPtPtr) {
     bool degenerateAB = degenerate_vector(cubic[1] - cubic[0]);
     bool degenerateBC = degenerate_vector(cubic[2] - cubic[1]);
     bool degenerateCD = degenerate_vector(cubic[3] - cubic[2]);
     if (degenerateAB & degenerateBC & degenerateCD) {
         return kPoint_ReductionType;
     }
     if (degenerateAB + degenerateBC + degenerateCD == 2) {
         return kLine_ReductionType;
@@ skipping 11 matching lines @@
         SkScalar t = tValues[index];
         SkEvalCubicAt(cubic, t, &reduction[index], NULL, NULL);
     }
     SK_COMPILE_ASSERT(kQuad_ReductionType + 1 == kDegenerate_ReductionType, enum_out_of_whack);
     SK_COMPILE_ASSERT(kQuad_ReductionType + 2 == kDegenerate2_ReductionType, enum_out_of_whack);
     SK_COMPILE_ASSERT(kQuad_ReductionType + 3 == kDegenerate3_ReductionType, enum_out_of_whack);
 
     return (ReductionType) (kQuad_ReductionType + count);
 }
 
+SkPathStroker::ReductionType SkPathStroker::CheckConicLinear(const SkConic& conic,
+        SkPoint* reduction) {
+    bool degenerateAB = degenerate_vector(conic.fPts[1] - conic.fPts[0]);
+    bool degenerateBC = degenerate_vector(conic.fPts[2] - conic.fPts[1]);
+    if (degenerateAB & degenerateBC) {
+        return kPoint_ReductionType;
+    }
+    if (degenerateAB | degenerateBC) {
+        return kLine_ReductionType;
+    }
+    if (!conic_in_line(conic)) {
+        return kQuad_ReductionType;
+    }
+    SkScalar t;
+    if (!conic.findMaxCurvature(&t) || 0 == t) {
+        return kLine_ReductionType;
+    }
+    conic.evalAt(t, reduction, NULL);
+    return kDegenerate_ReductionType;
+}
+
 SkPathStroker::ReductionType SkPathStroker::CheckQuadLinear(const SkPoint quad[3],
         SkPoint* reduction) {
     bool degenerateAB = degenerate_vector(quad[1] - quad[0]);
     bool degenerateBC = degenerate_vector(quad[2] - quad[1]);
     if (degenerateAB & degenerateBC) {
         return kPoint_ReductionType;
     }
     if (degenerateAB | degenerateBC) {
         return kLine_ReductionType;
     }
@@ skipping 88 matching lines @@
                         pts[2].fX + normalC.fX, pts[2].fY + normalC.fY,
                         pts[3].fX + normalCD->fX, pts[3].fY + normalCD->fY);
 
         fInner.cubicTo( pts[1].fX - normalB.fX, pts[1].fY - normalB.fY,
                         pts[2].fX - normalC.fX, pts[2].fY - normalC.fY,
                         pts[3].fX - normalCD->fX, pts[3].fY - normalCD->fY);
     }
 }
 #endif
 
+#ifdef SK_QUAD_STROKE_APPROXIMATION
+void SkPathStroker::conicTo(const SkPoint& pt1, const SkPoint& pt2, SkScalar weight) {
+    const SkConic conic(fPrevPt, pt1, pt2, weight);
+    SkPoint reduction;
+    ReductionType reductionType = CheckConicLinear(conic, &reduction);
+    if (kPoint_ReductionType == reductionType) {
+        return;
+    }
+    if (kLine_ReductionType == reductionType) {
+        this->lineTo(pt2);
+        return;
+    }
+    if (kDegenerate_ReductionType == reductionType) {
+        this->lineTo(reduction);
+        SkStrokerPriv::JoinProc saveJoiner = fJoiner;
+        fJoiner = SkStrokerPriv::JoinFactory(SkPaint::kRound_Join);
+        this->lineTo(pt2);
+        fJoiner = saveJoiner;
+        return;
+    }
+    SkASSERT(kQuad_ReductionType == reductionType);
+    SkVector normalAB, unitAB, normalBC, unitBC;
+    this->preJoinTo(pt1, &normalAB, &unitAB, false);
+    SkQuadConstruct quadPts;
+    this->init(kOuter_StrokeType, &quadPts, 0, 1);
+    if (!this->conicStroke(conic, &quadPts)) {
+        return;
+    }
+    this->init(kInner_StrokeType, &quadPts, 0, 1);
+    if (!this->conicStroke(conic, &quadPts)) {
+        return;
+    }
+    this->setConicEndNormal(conic, normalAB, unitAB, &normalBC, &unitBC);
+    this->postJoinTo(pt2, normalBC, unitBC);
+}
+#endif
+
 void SkPathStroker::quadTo(const SkPoint& pt1, const SkPoint& pt2) {
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
     const SkPoint quad[3] = { fPrevPt, pt1, pt2 };
     SkPoint reduction;
     ReductionType reductionType = CheckQuadLinear(quad, &reduction);
     if (kPoint_ReductionType == reductionType) {
         return;
     }
     if (kLine_ReductionType == reductionType) {
         this->lineTo(pt2);
         return;
     }
@@ skipping 67 matching lines @@
         } else {
             this->quad_to(pts, normalAB, unitAB, &normalBC, &unitBC,
                           kMaxQuadSubdivide);
         }
     }
 #endif
 
     this->postJoinTo(pt2, normalBC, unitBC);
 }
 
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
 // Given a point on the curve and its derivative, scale the derivative by the radius, and
 // compute the perpendicular point and its tangent.
 void SkPathStroker::setRayPts(const SkPoint& tPt, SkVector* dxy, SkPoint* onPt,
         SkPoint* tangent) const {
     if (!dxy->setLength(fRadius)) {  // consider moving double logic into SkPoint::setLength
         double xx = dxy->fX;
         double yy = dxy->fY;
         double dscale = fRadius / sqrt(xx * xx + yy * yy);
         dxy->fX = SkDoubleToScalar(xx * dscale);
         dxy->fY = SkDoubleToScalar(yy * dscale);
     }
     SkScalar axisFlip = SkIntToScalar(fStrokeType);  // go opposite ways for outer, inner
     onPt->fX = tPt.fX + axisFlip * dxy->fY;
     onPt->fY = tPt.fY - axisFlip * dxy->fX;
     if (tangent) {
         tangent->fX = onPt->fX + dxy->fX;
         tangent->fY = onPt->fY + dxy->fY;
     }
 }
 
+// Given a conic and t, return the point on curve, its perpendicular, and the perpendicular tangent.
+// Returns false if the perpendicular could not be computed (because the derivative collapsed to 0)
+bool SkPathStroker::conicPerpRay(const SkConic& conic, SkScalar t, SkPoint* tPt, SkPoint* onPt,
+        SkPoint* tangent) const {
+    SkVector dxy;
+    conic.evalAt(t, tPt, &dxy);
+    if (dxy.fX == 0 && dxy.fY == 0) {
+        dxy = conic.fPts[2] - conic.fPts[0];
+    }
+    setRayPts(*tPt, &dxy, onPt, tangent);
+    return true;
+}
+
+// Given a conic and a t range, find the start and end if they haven't been found already.
+bool SkPathStroker::conicQuadEnds(const SkConic& conic, SkQuadConstruct* quadPts) {
+    if (!quadPts->fStartSet) {
+        SkPoint conicStartPt;
+        if (!this->conicPerpRay(conic, quadPts->fStartT, &conicStartPt, &quadPts->fQuad[0],
+                &quadPts->fTangentStart)) {
+            return false;
+        }
+        quadPts->fStartSet = true;
+    }
+    if (!quadPts->fEndSet) {
+        SkPoint conicEndPt;
+        if (!this->conicPerpRay(conic, quadPts->fEndT, &conicEndPt, &quadPts->fQuad[2],
+                &quadPts->fTangentEnd)) {
+            return false;
+        }
+        quadPts->fEndSet = true;
+    }
+    return true;
+}
+
+
 // Given a cubic and t, return the point on curve, its perpendicular, and the perpendicular tangent.
 // Returns false if the perpendicular could not be computed (because the derivative collapsed to 0)
 bool SkPathStroker::cubicPerpRay(const SkPoint cubic[4], SkScalar t, SkPoint* tPt, SkPoint* onPt,
         SkPoint* tangent) const {
     SkVector dxy;
     SkEvalCubicAt(cubic, t, tPt, &dxy, NULL);
     if (dxy.fX == 0 && dxy.fY == 0) {
         if (SkScalarNearlyZero(t)) {
             dxy = cubic[2] - cubic[0];
         } else if (SkScalarNearlyZero(1 - t)) {
@@ skipping 58 matching lines @@
     SkVector bLen = quadPts->fTangentEnd - end;
     SkScalar denom = aLen.cross(bLen);
     SkVector ab0 = start - end;
     SkScalar numerA = bLen.cross(ab0);
     SkScalar numerB = aLen.cross(ab0);
     if (!SkScalarNearlyZero(denom)) {
         // if the perpendicular distances from the quad points to the opposite tangent line
         // are small, a straight line is good enough
         SkScalar dist1 = pt_to_line(start, end, quadPts->fTangentEnd);
         SkScalar dist2 = pt_to_line(end, start, quadPts->fTangentStart);
-        if (SkTMax(dist1, dist2) <= fError * fError) {
-            return STROKER_RESULT(kDegenerate_ResultType, depth, quadPts,
-                    "SkTMax(dist1=%g, dist2=%g) <= fError * fError", dist1, dist2);
-        }
         if ((numerA >= 0) != (numerB >= 0)) {
             if (kCtrlPt_RayType == intersectRayType) {
                 numerA /= denom;
                 SkPoint* ctrlPt = &quadPts->fQuad[1];
                 ctrlPt->fX = start.fX * (1 - numerA) + quadPts->fTangentStart.fX * numerA;
                 ctrlPt->fY = start.fY * (1 - numerA) + quadPts->fTangentStart.fY * numerA;
             }
             return STROKER_RESULT(kQuad_ResultType, depth, quadPts,
                     "(numerA=%g >= 0) != (numerB=%g >= 0)", numerA, numerB);
         }
+        if (SkTMax(dist1, dist2) <= fInvResScaleSquared) {
+            return STROKER_RESULT(kDegenerate_ResultType, depth, quadPts,
+                    "SkTMax(dist1=%g, dist2=%g) <= fInvResScaleSquared", dist1, dist2);
+        }
         return STROKER_RESULT(kSplit_ResultType, depth, quadPts,
                 "(numerA=%g >= 0) == (numerB=%g >= 0)", numerA, numerB);
     } else { // if the lines are parallel, straight line is good enough
         return STROKER_RESULT(kDegenerate_ResultType, depth, quadPts,
                 "SkScalarNearlyZero(denom=%g)", denom);
     }
 }
 
 // Given a cubic and a t-range, determine if the stroke can be described by a quadratic.
 SkPathStroker::ResultType SkPathStroker::tangentsMeet(const SkPoint cubic[4],
@@ skipping 15 matching lines @@
     SkScalar B = r[1];
     SkScalar C = r[0];
     A += C - 2 * B;  // A = a - 2*b + c
     B -= C;  // B = -(b - c)
     return SkFindUnitQuadRoots(A, 2 * B, C, roots);
 }
 
 // Return true if the point is close to the bounds of the quad. This is used as a quick reject.
 bool SkPathStroker::ptInQuadBounds(const SkPoint quad[3], const SkPoint& pt) const {
     SkScalar xMin = SkTMin(SkTMin(quad[0].fX, quad[1].fX), quad[2].fX);
-    if (pt.fX + fError < xMin) {
+    if (pt.fX + fInvResScale < xMin) {
         return false;
     }
     SkScalar xMax = SkTMax(SkTMax(quad[0].fX, quad[1].fX), quad[2].fX);
-    if (pt.fX - fError > xMax) {
+    if (pt.fX - fInvResScale > xMax) {
         return false;
     }
     SkScalar yMin = SkTMin(SkTMin(quad[0].fY, quad[1].fY), quad[2].fY);
-    if (pt.fY + fError < yMin) {
+    if (pt.fY + fInvResScale < yMin) {
         return false;
     }
     SkScalar yMax = SkTMax(SkTMax(quad[0].fY, quad[1].fY), quad[2].fY);
-    if (pt.fY - fError > yMax) {
+    if (pt.fY - fInvResScale > yMax) {
         return false;
     }
     return true;
 }
 
 static bool points_within_dist(const SkPoint& nearPt, const SkPoint& farPt, SkScalar limit) {
     return nearPt.distanceToSqd(farPt) <= limit * limit;
 }
 
 static bool sharp_angle(const SkPoint quad[3]) {
@@ skipping 10 matching lines @@
     }
     SkScalar dot = smaller.dot(larger);
     return dot > 0;
 }
 
 SkPathStroker::ResultType SkPathStroker::strokeCloseEnough(const SkPoint stroke[3],
         const SkPoint ray[2], SkQuadConstruct* quadPts  STROKER_DEBUG_PARAMS(int depth)) const {
     SkPoint strokeMid;
     SkEvalQuadAt(stroke, SK_ScalarHalf, &strokeMid);
     // measure the distance from the curve to the quad-stroke midpoint, compare to radius
-    if (points_within_dist(ray[0], strokeMid, fError)) {  // if the difference is small
+    if (points_within_dist(ray[0], strokeMid, fInvResScaleSquared)) {  // if the difference is small
         if (sharp_angle(quadPts->fQuad)) {
             return STROKER_RESULT(kSplit_ResultType, depth, quadPts,
                     "sharp_angle (1) =%g,%g, %g,%g, %g,%g",
                     quadPts->fQuad[0].fX, quadPts->fQuad[0].fY,
                     quadPts->fQuad[1].fX, quadPts->fQuad[1].fY,
                     quadPts->fQuad[2].fX, quadPts->fQuad[2].fY);
         }
         return STROKER_RESULT(kQuad_ResultType, depth, quadPts,
-                "points_within_dist(ray[0]=%g,%g, strokeMid=%g,%g, fError)",
-                ray[0].fX, ray[0].fY, strokeMid.fX, strokeMid.fY);
+                "points_within_dist(ray[0]=%g,%g, strokeMid=%g,%g, fInvResScaleSquared=%g)",
+                ray[0].fX, ray[0].fY, strokeMid.fX, strokeMid.fY, fInvResScaleSquared);
     }
     // measure the distance to quad's bounds (quick reject)
         // an alternative : look for point in triangle
     if (!ptInQuadBounds(stroke, ray[0])) {  // if far, subdivide
         return STROKER_RESULT(kSplit_ResultType, depth, quadPts,
                 "!pt_in_quad_bounds(stroke=(%g,%g %g,%g %g,%g), ray[0]=%g,%g)",
                 stroke[0].fX, stroke[0].fY, stroke[1].fX, stroke[1].fY, stroke[2].fX, stroke[2].fY,
                 ray[0].fX, ray[0].fY);
     }
     // measure the curve ray distance to the quad-stroke
     SkScalar roots[2];
     int rootCount = intersect_quad_ray(ray, stroke, roots);
     if (rootCount != 1) {
         return STROKER_RESULT(kSplit_ResultType, depth, quadPts,
                 "rootCount=%d != 1", rootCount);
     }
     SkPoint quadPt;
     SkEvalQuadAt(stroke, roots[0], &quadPt);
-    SkScalar error = fError * (SK_Scalar1 - SkScalarAbs(roots[0] - 0.5f) * 2);
+    SkScalar error = fInvResScale * (SK_Scalar1 - SkScalarAbs(roots[0] - 0.5f) * 2);
     if (points_within_dist(ray[0], quadPt, error)) {  // if the difference is small, we're done
         if (sharp_angle(quadPts->fQuad)) {
             return STROKER_RESULT(kSplit_ResultType, depth, quadPts,
                     "sharp_angle (2) =%g,%g, %g,%g, %g,%g",
                     quadPts->fQuad[0].fX, quadPts->fQuad[0].fY,
                     quadPts->fQuad[1].fX, quadPts->fQuad[1].fY,
                     quadPts->fQuad[2].fX, quadPts->fQuad[2].fY);
         }
         return STROKER_RESULT(kQuad_ResultType, depth, quadPts,
                 "points_within_dist(ray[0]=%g,%g, quadPt=%g,%g, error=%g)",
                 ray[0].fX, ray[0].fY, quadPt.fX, quadPt.fY, error);
     }
     // otherwise, subdivide
     return STROKER_RESULT(kSplit_ResultType, depth, quadPts, "%s", "fall through");
 }
 
 SkPathStroker::ResultType SkPathStroker::compareQuadCubic(const SkPoint cubic[4],
         SkQuadConstruct* quadPts) {
     // get the quadratic approximation of the stroke
     if (!this->cubicQuadEnds(cubic, quadPts)) {
         return kNormalError_ResultType;
     }
     ResultType resultType = intersectRay(quadPts, kCtrlPt_RayType
             STROKER_DEBUG_PARAMS(fRecursionDepth) );
     if (resultType != kQuad_ResultType) {
         return resultType;
     }
     // project a ray from the curve to the stroke
-    SkPoint ray[2];  // point near midpoint on quad, midpoint on cubic
+    SkPoint ray[2];  // points near midpoint on quad, midpoint on cubic
     if (!this->cubicPerpRay(cubic, quadPts->fMidT, &ray[1], &ray[0], NULL)) {
         return kNormalError_ResultType;
     }
     return strokeCloseEnough(quadPts->fQuad, ray, quadPts  STROKER_DEBUG_PARAMS(fRecursionDepth));
 }
 
-// if false is returned, caller splits quadratic approximation
+SkPathStroker::ResultType SkPathStroker::compareQuadConic(const SkConic& conic,
+        SkQuadConstruct* quadPts) {
+    // get the quadratic approximation of the stroke
+    if (!this->conicQuadEnds(conic, quadPts)) {
+        return kNormalError_ResultType;
+    }
+    ResultType resultType = intersectRay(quadPts, kCtrlPt_RayType
+            STROKER_DEBUG_PARAMS(fRecursionDepth) );
+    if (resultType != kQuad_ResultType) {
+        return resultType;
+    }
+    // project a ray from the curve to the stroke
+    SkPoint ray[2];  // points near midpoint on quad, midpoint on conic
+    if (!this->conicPerpRay(conic, quadPts->fMidT, &ray[1], &ray[0], NULL)) {
+        return kNormalError_ResultType;
+    }
+    return strokeCloseEnough(quadPts->fQuad, ray, quadPts  STROKER_DEBUG_PARAMS(fRecursionDepth));
+}
+
 SkPathStroker::ResultType SkPathStroker::compareQuadQuad(const SkPoint quad[3],
         SkQuadConstruct* quadPts) {
     // get the quadratic approximation of the stroke
     if (!quadPts->fStartSet) {
         SkPoint quadStartPt;
         this->quadPerpRay(quad, quadPts->fStartT, &quadStartPt, &quadPts->fQuad[0],
                 &quadPts->fTangentStart);
         quadPts->fStartSet = true;
     }
     if (!quadPts->fEndSet) {
@@ skipping 18 matching lines @@
     SkPath* path = fStrokeType == kOuter_StrokeType ? &fOuter : &fInner;
     path->lineTo(quad[2].fX, quad[2].fY);
 }
 
 bool SkPathStroker::cubicMidOnLine(const SkPoint cubic[4], const SkQuadConstruct* quadPts) const {
     SkPoint strokeMid;
     if (!cubicQuadMid(cubic, quadPts, &strokeMid)) {
         return false;
     }
     SkScalar dist = pt_to_line(strokeMid, quadPts->fQuad[0], quadPts->fQuad[2]);
-    return dist < fError * fError;
+    return dist < fInvResScaleSquared;
 }
 
 bool SkPathStroker::cubicStroke(const SkPoint cubic[4], SkQuadConstruct* quadPts) {
     if (!fFoundTangents) {
         ResultType resultType = this->tangentsMeet(cubic, quadPts);
         if (kQuad_ResultType != resultType) {
             if (kNormalError_ResultType == resultType) {
                 return false;
             }
             if ((kDegenerate_ResultType == resultType
-                    || points_within_dist(quadPts->fQuad[0], quadPts->fQuad[2], fError))
-                    && cubicMidOnLine(cubic, quadPts)) {
+                    || points_within_dist(quadPts->fQuad[0], quadPts->fQuad[2],
+                    fInvResScaleSquared)) && cubicMidOnLine(cubic, quadPts)) {
                 addDegenerateLine(quadPts);
                 return true;
             }
         } else {
             fFoundTangents = true;
         }
     }
     if (fFoundTangents) {
         ResultType resultType = this->compareQuadCubic(cubic, quadPts);
         if (kQuad_ResultType == resultType) {
@@ skipping 30 matching lines @@
         addDegenerateLine(quadPts);
         return true;
     }
     if (!this->cubicStroke(cubic, &half)) {
         return false;
     }
     --fRecursionDepth;
     return true;
 }
 
+bool SkPathStroker::conicStroke(const SkConic& conic, SkQuadConstruct* quadPts) {
+    ResultType resultType = this->compareQuadConic(conic, quadPts);
+    if (kQuad_ResultType == resultType) {
+        const SkPoint* stroke = quadPts->fQuad;
+        SkPath* path = fStrokeType == kOuter_StrokeType ? &fOuter : &fInner;
+        path->quadTo(stroke[1].fX, stroke[1].fY, stroke[2].fX, stroke[2].fY);
+        return true;
+    }
+    if (kDegenerate_ResultType == resultType) {
+        addDegenerateLine(quadPts);
+        return true;
+    }
+    SkDEBUGCODE(gMaxRecursion[kConic_RecursiveLimit] = SkTMax(gMaxRecursion[kConic_RecursiveLimit],
+            fRecursionDepth + 1));
+    if (++fRecursionDepth > kRecursiveLimits[kConic_RecursiveLimit]) {
+        return false;  // just abort if projected quad isn't representable
+    }
+    SkQuadConstruct half;
+    (void) half.initWithStart(quadPts);
+    if (!this->conicStroke(conic, &half)) {
+        return false;
+    }
+    (void) half.initWithEnd(quadPts);
+    if (!this->conicStroke(conic, &half)) {
+        return false;
+    }
+    --fRecursionDepth;
+    return true;
+}
+
 bool SkPathStroker::quadStroke(const SkPoint quad[3], SkQuadConstruct* quadPts) {
     ResultType resultType = this->compareQuadQuad(quad, quadPts);
     if (kQuad_ResultType == resultType) {
         const SkPoint* stroke = quadPts->fQuad;
         SkPath* path = fStrokeType == kOuter_StrokeType ? &fOuter : &fInner;
         path->quadTo(stroke[1].fX, stroke[1].fY, stroke[2].fX, stroke[2].fY);
         return true;
     }
     if (kDegenerate_ResultType == resultType) {
         addDegenerateLine(quadPts);
@@ skipping 14 matching lines @@
         return false;
     }
     --fRecursionDepth;
     return true;
 }
 
 #endif
 
 void SkPathStroker::cubicTo(const SkPoint& pt1, const SkPoint& pt2,
                             const SkPoint& pt3) {
-#if QUAD_STROKE_APPROXIMATION
+#ifdef SK_QUAD_STROKE_APPROXIMATION
     const SkPoint cubic[4] = { fPrevPt, pt1, pt2, pt3 };
     SkPoint reduction[3];
     const SkPoint* tangentPt;
     ReductionType reductionType = CheckCubicLinear(cubic, reduction, &tangentPt);
     if (kPoint_ReductionType == reductionType) {
         return;
     }
     if (kLine_ReductionType == reductionType) {
         this->lineTo(pt3);
         return;
@@ skipping 105 matching lines @@
 }
 
 SkStroke::SkStroke(const SkPaint& p, SkScalar width) {
     fWidth      = width;
     fMiterLimit = p.getStrokeMiter();
     fCap        = (uint8_t)p.getStrokeCap();
     fJoin       = (uint8_t)p.getStrokeJoin();
     fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
 }
 
-#if QUAD_STROKE_APPROXIMATION
-void SkStroke::setError(SkScalar error) {
-    SkASSERT(error > 0);
-    fError = error;
-}
-#endif
-
 void SkStroke::setWidth(SkScalar width) {
     SkASSERT(width >= 0);
     fWidth = width;
 }
 
 void SkStroke::setMiterLimit(SkScalar miterLimit) {
     SkASSERT(miterLimit >= 0);
     fMiterLimit = miterLimit;
 }
 
@@ skipping 56 matching lines @@
             // our answer should preserve the inverseness of the src
             if (src.isInverseFillType()) {
                 SkASSERT(!dst->isInverseFillType());
                 dst->toggleInverseFillType();
             }
             return;
         }
     }
 
     SkAutoConicToQuads converter;
+#ifndef SK_QUAD_STROKE_APPROXIMATION
     const SkScalar conicTol = SK_Scalar1 / 4 / fResScale;
-
-#if QUAD_STROKE_APPROXIMATION
-    SkPathStroker   stroker(src, radius, fMiterLimit, fError, this->getCap(),
-                            this->getJoin(), fResScale);
-#else
+#endif
     SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(), fResScale);
-#endif
     SkPath::Iter    iter(src, false);
     SkPath::Verb    lastSegment = SkPath::kMove_Verb;
 
     for (;;) {
         SkPoint  pts[4];
         switch (iter.next(pts, false)) {
             case SkPath::kMove_Verb:
                 stroker.moveTo(pts[0]);
                 break;
             case SkPath::kLine_Verb:
                 stroker.lineTo(pts[1]);
                 lastSegment = SkPath::kLine_Verb;
                 break;
             case SkPath::kQuad_Verb:
                 stroker.quadTo(pts[1], pts[2]);
                 lastSegment = SkPath::kQuad_Verb;
                 break;
             case SkPath::kConic_Verb: {
+#ifdef SK_QUAD_STROKE_APPROXIMATION
+                stroker.conicTo(pts[1], pts[2], iter.conicWeight());
+                lastSegment = SkPath::kConic_Verb;
+                break;
+#else
                 // todo: if we had maxcurvature for conics, perhaps we should
                 // natively extrude the conic instead of converting to quads.
                 const SkPoint* quadPts =
                     converter.computeQuads(pts, iter.conicWeight(), conicTol);
                 for (int i = 0; i < converter.countQuads(); ++i) {
                     stroker.quadTo(quadPts[1], quadPts[2]);
                     quadPts += 2;
                 }
                 lastSegment = SkPath::kQuad_Verb;
+#endif
             } break;
             case SkPath::kCubic_Verb:
                 stroker.cubicTo(pts[1], pts[2], pts[3]);
                 lastSegment = SkPath::kCubic_Verb;
                 break;
             case SkPath::kClose_Verb:
                 stroker.close(lastSegment == SkPath::kLine_Verb);
                 break;
             case SkPath::kDone_Verb:
                 goto DONE;
@@ skipping 109 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }