The Tor Browser: gfx/skia/trunk/src/animator/SkParseSVGPath.cpp@a63d609f5ebe (annotated)

gfx/skia/trunk/src/animator/SkParseSVGPath.cpp@a63d609f5ebe (annotated)

gfx/skia/trunk/src/animator/SkParseSVGPath.cpp

Thu, 15 Jan 2015 15:55:04 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:55:04 +0100
branch: TOR_BUG_9701
changeset 9: a63d609f5ebe
permissions: -rw-r--r--

Back out 97036ab72558 which inappropriately compared turds to third parties.

 /*
  * 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 <ctype.h>
 #include "SkDrawPath.h"
 #include "SkParse.h"
 #include "SkPoint.h"
 #include "SkUtils.h"
 #define QUADRATIC_APPROXIMATION 1
 #if QUADRATIC_APPROXIMATION
 ////////////////////////////////////////////////////////////////////////////////////
 //functions to approximate a cubic using two quadratics
 //      midPt sets the first argument to be the midpoint of the other two
 //      it is used by quadApprox
 static inline void midPt(SkPoint& dest,const SkPoint& a,const SkPoint& b)
 {
     dest.set(SkScalarAve(a.fX, b.fX),SkScalarAve(a.fY, b.fY));
 }
 //      quadApprox - makes an approximation, which we hope is faster
 static void quadApprox(SkPath &fPath, const SkPoint &p0, const SkPoint &p1, const SkPoint &p2)
 {
     //divide the cubic up into two cubics, then convert them into quadratics
     //define our points
     SkPoint c,j,k,l,m,n,o,p,q, mid;
     fPath.getLastPt(&c);
     midPt(j, p0, c);
     midPt(k, p0, p1);
     midPt(l, p1, p2);
     midPt(o, j, k);
     midPt(p, k, l);
     midPt(q, o, p);
     //compute the first half
     m.set(SkScalarHalf(3*j.fX - c.fX), SkScalarHalf(3*j.fY - c.fY));
     n.set(SkScalarHalf(3*o.fX -q.fX), SkScalarHalf(3*o.fY - q.fY));
     midPt(mid,m,n);
     fPath.quadTo(mid,q);
     c = q;
     //compute the second half
     m.set(SkScalarHalf(3*p.fX - c.fX), SkScalarHalf(3*p.fY - c.fY));
     n.set(SkScalarHalf(3*l.fX -p2.fX),SkScalarHalf(3*l.fY -p2.fY));
     midPt(mid,m,n);
     fPath.quadTo(mid,p2);
 }
 #endif
 static inline bool is_between(int c, int min, int max)
 {
     return (unsigned)(c - min) <= (unsigned)(max - min);
 }
 static inline bool is_ws(int c)
 {
     return is_between(c, 1, 32);
 }
 static inline bool is_digit(int c)
 {
     return is_between(c, '0', '9');
 }
 static inline bool is_sep(int c)
 {
     return is_ws(c) || c == ',';
 }
 static const char* skip_ws(const char str[])
 {
     SkASSERT(str);
     while (is_ws(*str))
         str++;
     return str;
 }
 static const char* skip_sep(const char str[])
 {
     SkASSERT(str);
     while (is_sep(*str))
         str++;
     return str;
 }
 static const char* find_points(const char str[], SkPoint value[], int count,
      bool isRelative, SkPoint* relative)
 {
     str = SkParse::FindScalars(str, &value[0].fX, count * 2);
     if (isRelative) {
         for (int index = 0; index < count; index++) {
             value[index].fX += relative->fX;
             value[index].fY += relative->fY;
         }
     }
     return str;
 }
 static const char* find_scalar(const char str[], SkScalar* value,
     bool isRelative, SkScalar relative)
 {
     str = SkParse::FindScalar(str, value);
     if (isRelative)
         *value += relative;
     return str;
 }
 void SkDrawPath::parseSVG() {
     fPath.reset();
     const char* data = d.c_str();
     SkPoint f = {0, 0};
     SkPoint c = {0, 0};
     SkPoint lastc = {0, 0};
     SkPoint points[3];
     char op = '\0';
     char previousOp = '\0';
     bool relative = false;
     do {
         data = skip_ws(data);
         if (data[0] == '\0')
             break;
         char ch = data[0];
         if (is_digit(ch) || ch == '-' || ch == '+') {
             if (op == '\0')
                 return;
         }
         else {
             op = ch;
             relative = false;
             if (islower(op)) {
                 op = (char) toupper(op);
                 relative = true;
             }
             data++;
             data = skip_sep(data);
         }
         switch (op) {
             case 'M':
                 data = find_points(data, points, 1, relative, &c);
                 fPath.moveTo(points[0]);
                 op = 'L';
                 c = points[0];
                 break;
             case 'L':
                 data = find_points(data, points, 1, relative, &c);
                 fPath.lineTo(points[0]);
                 c = points[0];
                 break;
             case 'H': {
                 SkScalar x;
                 data = find_scalar(data, &x, relative, c.fX);
                 fPath.lineTo(x, c.fY);
                 c.fX = x;
             }
                 break;
             case 'V': {
                 SkScalar y;
                 data = find_scalar(data, &y, relative, c.fY);
                 fPath.lineTo(c.fX, y);
                 c.fY = y;
             }
                 break;
             case 'C':
                 data = find_points(data, points, 3, relative, &c);
                 goto cubicCommon;
             case 'S':
                 data = find_points(data, &points[1], 2, relative, &c);
                 points[0] = c;
                 if (previousOp == 'C' || previousOp == 'S') {
                     points[0].fX -= lastc.fX - c.fX;
                     points[0].fY -= lastc.fY - c.fY;
                 }
             cubicCommon:
     //          if (data[0] == '\0')
     //              return;
 #if QUADRATIC_APPROXIMATION
                     quadApprox(fPath, points[0], points[1], points[2]);
 #else   //this way just does a boring, slow old cubic
                     fPath.cubicTo(points[0], points[1], points[2]);
 #endif
         //if we are using the quadApprox, lastc is what it would have been if we had used
         //cubicTo
                     lastc = points[1];
                     c = points[2];
                 break;
             case 'Q':  // Quadratic Bezier Curve
                 data = find_points(data, points, 2, relative, &c);
                 goto quadraticCommon;
             case 'T':
                 data = find_points(data, &points[1], 1, relative, &c);
                 points[0] = points[1];
                 if (previousOp == 'Q' || previousOp == 'T') {
                     points[0].fX = c.fX * 2 - lastc.fX;
                     points[0].fY = c.fY * 2 - lastc.fY;
                 }
             quadraticCommon:
                 fPath.quadTo(points[0], points[1]);
                 lastc = points[0];
                 c = points[1];
                 break;
             case 'Z':
                 fPath.close();
 #if 0   // !!! still a bug?
                 if (fPath.isEmpty() && (f.fX != 0 || f.fY != 0)) {
                     c.fX -= SkScalar.Epsilon;   // !!! enough?
                     fPath.moveTo(c);
                     fPath.lineTo(f);
                     fPath.close();
                 }
 #endif
                 c = f;
                 op = '\0';
                 break;
             case '~': {
                 SkPoint args[2];
                 data = find_points(data, args, 2, false, NULL);
                 fPath.moveTo(args[0].fX, args[0].fY);
                 fPath.lineTo(args[1].fX, args[1].fY);
             }
                 break;
             default:
                 SkASSERT(0);
                 return;
         }
         if (previousOp == 0)
             f = c;
         previousOp = op;
     } while (data[0] > 0);
 }

The Tor Browser / annotate

gfx/skia/trunk/src/animator/SkParseSVGPath.cpp@a63d609f5ebe (annotated)

gfx/skia/trunk/src/animator/SkParseSVGPath.cpp