#include "SkPath.h"
#include "SkBuffer.h"
#include "SkMath.h"
+#include "SkPathRef.h"
+#include "SkThread.h"
SK_DEFINE_INST_COUNT(SkPath);
};
// Return true if the computed bounds are finite.
-static bool compute_pt_bounds(SkRect* bounds, const SkTDArray<SkPoint>& pts) {
- int count = pts.count();
+static bool compute_pt_bounds(SkRect* bounds, const SkPathRef& ref) {
+ int count = ref.countPoints();
if (count <= 1) { // we ignore just 1 point (moveto)
bounds->setEmpty();
- return count ? pts.begin()->isFinite() : true;
+ return count ? ref.points()->isFinite() : true;
} else {
- return bounds->setBoundsCheck(pts.begin(), pts.count());
+ return bounds->setBoundsCheck(ref.points(), count);
}
}
#define INITIAL_LASTMOVETOINDEX_VALUE ~0
SkPath::SkPath()
- : fFillType(kWinding_FillType)
+ : fPathRef(SkPathRef::CreateEmpty())
+ , fFillType(kWinding_FillType)
, fBoundsIsDirty(true) {
fConvexity = kUnknown_Convexity;
fSegmentMask = 0;
SkPath::SkPath(const SkPath& src) {
SkDEBUGCODE(src.validate();)
- *this = src;
+ src.fPathRef.get()->ref();
+ fPathRef.reset(src.fPathRef.get());
+ fBounds = src.fBounds;
+ fFillType = src.fFillType;
+ fBoundsIsDirty = src.fBoundsIsDirty;
+ fConvexity = src.fConvexity;
+ fIsFinite = src.fIsFinite;
+ fSegmentMask = src.fSegmentMask;
+ fLastMoveToIndex = src.fLastMoveToIndex;
+ fIsOval = src.fIsOval;
#ifdef SK_BUILD_FOR_ANDROID
- // the assignment operator above increments the ID so correct for that here
fGenerationID = src.fGenerationID;
fSourcePath = NULL;
#endif
SkDEBUGCODE(src.validate();)
if (this != &src) {
+ src.fPathRef.get()->ref();
+ fPathRef.reset(src.fPathRef.get());
fBounds = src.fBounds;
- fPts = src.fPts;
- fVerbs = src.fVerbs;
fFillType = src.fFillType;
fBoundsIsDirty = src.fBoundsIsDirty;
fConvexity = src.fConvexity;
return &a == &b ||
(a.fFillType == b.fFillType && a.fSegmentMask == b.fSegmentMask &&
- a.fVerbs == b.fVerbs && a.fPts == b.fPts);
+ *a.fPathRef.get() == *b.fPathRef.get());
}
void SkPath::swap(SkPath& other) {
if (this != &other) {
SkTSwap<SkRect>(fBounds, other.fBounds);
- fPts.swap(other.fPts);
- fVerbs.swap(other.fVerbs);
+ fPathRef.swap(&other.fPathRef);
SkTSwap<uint8_t>(fFillType, other.fFillType);
SkTSwap<uint8_t>(fBoundsIsDirty, other.fBoundsIsDirty);
SkTSwap<uint8_t>(fConvexity, other.fConvexity);
void SkPath::reset() {
SkDEBUGCODE(this->validate();)
- fPts.reset();
- fVerbs.reset();
+ fPathRef.reset(SkPathRef::CreateEmpty());
GEN_ID_INC;
fBoundsIsDirty = true;
fConvexity = kUnknown_Convexity;
void SkPath::rewind() {
SkDEBUGCODE(this->validate();)
- fPts.rewind();
- fVerbs.rewind();
+ SkPathRef::Rewind(&fPathRef);
GEN_ID_INC;
fConvexity = kUnknown_Convexity;
fBoundsIsDirty = true;
bool SkPath::isEmpty() const {
SkDEBUGCODE(this->validate();)
- return 0 == fVerbs.count();
+ return 0 == fPathRef->countVerbs();
}
bool SkPath::isLine(SkPoint line[2]) const {
- int verbCount = fVerbs.count();
- int ptCount = fPts.count();
+ int verbCount = fPathRef->countVerbs();
+ int ptCount = fPathRef->countVerbs();
if (2 == verbCount && 2 == ptCount) {
- const uint8_t* verbs = fVerbs.begin();
- if (kMove_Verb == verbs[0] && kLine_Verb == verbs[1]) {
+ if (kMove_Verb == fPathRef->atVerb(0) &&
+ kLine_Verb == fPathRef->atVerb(1)) {
if (line) {
- const SkPoint* pts = fPts.begin();
+ const SkPoint* pts = fPathRef->points();
line[0] = pts[0];
line[1] = pts[1];
}
int nextDirection = 0;
bool closedOrMoved = false;
bool autoClose = false;
- const uint8_t* verbs = fVerbs.begin();
- const uint8_t* verbStop = fVerbs.end();
- const SkPoint* pts = fPts.begin();
- while (verbs != verbStop) {
- switch (*verbs++) {
+ const SkPoint* pts = fPathRef->points();
+ int verbCnt = fPathRef->countVerbs();
+ int currVerb = 0;
+ while (currVerb < verbCnt) {
+ switch (fPathRef->atVerb(currVerb++)) {
case kClose_Verb:
- pts = fPts.begin();
+ pts = fPathRef->points();
autoClose = true;
case kLine_Verb: {
SkScalar left = last.fX;
return result;
}
+int SkPath::countPoints() const {
+ return fPathRef->countPoints();
+}
+
int SkPath::getPoints(SkPoint dst[], int max) const {
SkDEBUGCODE(this->validate();)
SkASSERT(max >= 0);
SkASSERT(!max || dst);
- int count = fPts.count();
- fPts.copyRange(dst, 0, max);
- return count;
+ int count = SkMin32(max, fPathRef->countPoints());
+ memcpy(dst, fPathRef->points(), count * sizeof(SkPoint));
+ return fPathRef->countPoints();
}
SkPoint SkPath::getPoint(int index) const {
- if ((unsigned)index < (unsigned)fPts.count()) {
- return fPts[index];
+ if ((unsigned)index < (unsigned)fPathRef->countPoints()) {
+ return fPathRef->atPoint(index);
}
return SkPoint::Make(0, 0);
}
+int SkPath::countVerbs() const {
+ return fPathRef->countVerbs();
+}
+
+static inline void copy_verbs_reverse(uint8_t* inorderDst,
+ const uint8_t* reversedSrc,
+ int count) {
+ for (int i = 0; i < count; ++i) {
+ inorderDst[i] = reversedSrc[~i];
+ }
+}
+
int SkPath::getVerbs(uint8_t dst[], int max) const {
SkDEBUGCODE(this->validate();)
SkASSERT(max >= 0);
SkASSERT(!max || dst);
- fVerbs.copyRange(dst, 0, max);
- return fVerbs.count();
+ int count = SkMin32(max, fPathRef->countVerbs());
+ copy_verbs_reverse(dst, fPathRef->verbs(), count);
+ return fPathRef->countVerbs();
}
bool SkPath::getLastPt(SkPoint* lastPt) const {
SkDEBUGCODE(this->validate();)
- int count = fPts.count();
+ int count = fPathRef->countPoints();
if (count > 0) {
if (lastPt) {
- *lastPt = fPts[count - 1];
+ *lastPt = fPathRef->atPoint(count - 1);
}
return true;
}
void SkPath::setLastPt(SkScalar x, SkScalar y) {
SkDEBUGCODE(this->validate();)
- int count = fPts.count();
+ int count = fPathRef->countPoints();
if (count == 0) {
this->moveTo(x, y);
} else {
fIsOval = false;
- fPts[count - 1].set(x, y);
+ SkPathRef::Editor ed(&fPathRef);
+ ed.atPoint(count-1)->set(x, y);
GEN_ID_INC;
}
}
SkDEBUGCODE(this->validate();)
SkASSERT(fBoundsIsDirty);
- fIsFinite = compute_pt_bounds(&fBounds, fPts);
+ fIsFinite = compute_pt_bounds(&fBounds, *fPathRef.get());
fBoundsIsDirty = false;
}
void SkPath::incReserve(U16CPU inc) {
SkDEBUGCODE(this->validate();)
-
- fVerbs.setReserve(fVerbs.count() + inc);
- fPts.setReserve(fPts.count() + inc);
-
+ SkPathRef::Editor(&fPathRef, inc, inc);
SkDEBUGCODE(this->validate();)
}
void SkPath::moveTo(SkScalar x, SkScalar y) {
SkDEBUGCODE(this->validate();)
- SkPoint* pt;
+ SkPathRef::Editor ed(&fPathRef);
// remember our index
- fLastMoveToIndex = fPts.count();
+ fLastMoveToIndex = ed.pathRef()->countPoints();
- pt = fPts.append();
- *fVerbs.append() = kMove_Verb;
- pt->set(x, y);
+ ed.growForVerb(kMove_Verb)->set(x, y);
GEN_ID_INC;
DIRTY_AFTER_EDIT_NO_CONVEXITY_CHANGE;
void SkPath::injectMoveToIfNeeded() {
if (fLastMoveToIndex < 0) {
SkScalar x, y;
- if (fVerbs.count() == 0) {
+ if (fPathRef->countVerbs() == 0) {
x = y = 0;
} else {
- const SkPoint& pt = fPts[~fLastMoveToIndex];
+ const SkPoint& pt = fPathRef->atPoint(~fLastMoveToIndex);
x = pt.fX;
y = pt.fY;
}
this->injectMoveToIfNeeded();
- fPts.append()->set(x, y);
- *fVerbs.append() = kLine_Verb;
+ SkPathRef::Editor ed(&fPathRef);
+ ed.growForVerb(kLine_Verb)->set(x, y);
fSegmentMask |= kLine_SegmentMask;
GEN_ID_INC;
this->injectMoveToIfNeeded();
- SkPoint* pts = fPts.append(2);
+ SkPathRef::Editor ed(&fPathRef);
+ SkPoint* pts = ed.growForVerb(kQuad_Verb);
pts[0].set(x1, y1);
pts[1].set(x2, y2);
- *fVerbs.append() = kQuad_Verb;
fSegmentMask |= kQuad_SegmentMask;
GEN_ID_INC;
this->injectMoveToIfNeeded();
- SkPoint* pts = fPts.append(3);
+ SkPathRef::Editor ed(&fPathRef);
+ SkPoint* pts = ed.growForVerb(kCubic_Verb);
pts[0].set(x1, y1);
pts[1].set(x2, y2);
pts[2].set(x3, y3);
- *fVerbs.append() = kCubic_Verb;
fSegmentMask |= kCubic_SegmentMask;
GEN_ID_INC;
void SkPath::close() {
SkDEBUGCODE(this->validate();)
- int count = fVerbs.count();
+ int count = fPathRef->countVerbs();
if (count > 0) {
- switch (fVerbs[count - 1]) {
+ switch (fPathRef->atVerb(count - 1)) {
case kLine_Verb:
case kQuad_Verb:
case kCubic_Verb:
- case kMove_Verb:
- *fVerbs.append() = kClose_Verb;
+ case kMove_Verb: {
+ SkPathRef::Editor ed(&fPathRef);
+ ed.growForVerb(kClose_Verb);
GEN_ID_INC;
break;
+ }
default:
// don't add a close if it's the first verb or a repeat
break;
return;
}
- fLastMoveToIndex = fPts.count();
- fPts.append(count, pts);
-
+ SkPathRef::Editor ed(&fPathRef);
+ fLastMoveToIndex = ed.pathRef()->countPoints();
+ uint8_t* vb;
+ SkPoint* p;
// +close makes room for the extra kClose_Verb
- uint8_t* vb = fVerbs.append(count + close);
- vb[0] = kMove_Verb;
+ ed.grow(count + close, count, &vb, &p);
+ memcpy(p, pts, count * sizeof(SkPoint));
+ vb[~0] = kMove_Verb;
if (count > 1) {
// cast to unsigned, so if MIN_COUNT_FOR_MEMSET_TO_BE_FAST is defined to
// be 0, the compiler will remove the test/branch entirely.
if ((unsigned)count >= MIN_COUNT_FOR_MEMSET_TO_BE_FAST) {
- memset(&vb[1], kLine_Verb, count - 1);
+ memset(vb - count, kLine_Verb, count - 1);
} else {
for (int i = 1; i < count; ++i) {
- vb[i] = kLine_Verb;
+ vb[~i] = kLine_Verb;
}
}
fSegmentMask |= kLine_SegmentMask;
}
if (close) {
- vb[count] = kClose_Verb;
+ vb[~count] = kClose_Verb;
}
GEN_ID_INC;
DIRTY_AFTER_EDIT;
+ SkDEBUGCODE(this->validate();)
}
#define CUBIC_ARC_FACTOR ((SK_ScalarSqrt2 - SK_Scalar1) * 4 / 3)
}
bool SkPath::hasOnlyMoveTos() const {
- const uint8_t* verbs = fVerbs.begin();
- const uint8_t* verbStop = fVerbs.end();
- while (verbs != verbStop) {
+ int count = fPathRef->countVerbs();
+ const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbsMemBegin();
+ for (int i = 0; i < count; ++i) {
if (*verbs == kLine_Verb ||
*verbs == kQuad_Verb ||
*verbs == kCubic_Verb) {
int count = build_arc_points(oval, startAngle, sweepAngle, pts);
SkASSERT((count & 1) == 1);
- if (fVerbs.count() == 0) {
+ if (fPathRef->countVerbs() == 0) {
forceMoveTo = true;
}
this->incReserve(count);
}
void SkPath::addPath(const SkPath& path, const SkMatrix& matrix) {
- this->incReserve(path.fPts.count());
+ SkPathRef::Editor(&fPathRef, path.countVerbs(), path.countPoints());
fIsOval = false;
// ignore the initial moveto, and stop when the 1st contour ends
void SkPath::pathTo(const SkPath& path) {
- int i, vcount = path.fVerbs.count();
- if (vcount == 0) {
+ int i, vcount = path.fPathRef->countVerbs();
+ // exit early if the path is empty, or just has a moveTo.
+ if (vcount < 2) {
return;
}
- this->incReserve(vcount);
+ SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
fIsOval = false;
- const uint8_t* verbs = path.fVerbs.begin();
- const SkPoint* pts = path.fPts.begin() + 1; // 1 for the initial moveTo
+ const uint8_t* verbs = path.fPathRef->verbs();
+ // skip the initial moveTo
+ const SkPoint* pts = path.fPathRef->points() + 1;
- SkASSERT(verbs[0] == kMove_Verb);
+ SkASSERT(verbs[~0] == kMove_Verb);
for (i = 1; i < vcount; i++) {
- switch (verbs[i]) {
+ switch (verbs[~i]) {
case kLine_Verb:
this->lineTo(pts[0].fX, pts[0].fY);
break;
this->quadTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY);
break;
case kCubic_Verb:
- this->cubicTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY,
- pts[2].fX, pts[2].fY);
+ this->cubicTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
break;
case kClose_Verb:
return;
}
- pts += gPtsInVerb[verbs[i]];
+ pts += gPtsInVerb[verbs[~i]];
}
}
// ignore the last point of the 1st contour
void SkPath::reversePathTo(const SkPath& path) {
- int i, vcount = path.fVerbs.count();
- if (vcount == 0) {
+ int i, vcount = path.fPathRef->countVerbs();
+ // exit early if the path is empty, or just has a moveTo.
+ if (vcount < 2) {
return;
}
- this->incReserve(vcount);
+ SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
fIsOval = false;
- const uint8_t* verbs = path.fVerbs.begin();
- const SkPoint* pts = path.fPts.begin();
+ const uint8_t* verbs = path.fPathRef->verbs();
+ const SkPoint* pts = path.fPathRef->points();
- SkASSERT(verbs[0] == kMove_Verb);
- for (i = 1; i < vcount; i++) {
- int n = gPtsInVerb[verbs[i]];
+ SkASSERT(verbs[~0] == kMove_Verb);
+ for (i = 1; i < vcount; ++i) {
+ int n = gPtsInVerb[verbs[~i]];
if (n == 0) {
break;
}
}
while (--i > 0) {
- switch (verbs[i]) {
+ switch (verbs[~i]) {
case kLine_Verb:
this->lineTo(pts[-1].fX, pts[-1].fY);
break;
SkDEBUGFAIL("bad verb");
break;
}
- pts -= gPtsInVerb[verbs[i]];
+ pts -= gPtsInVerb[verbs[~i]];
}
}
void SkPath::reverseAddPath(const SkPath& src) {
- this->incReserve(src.fPts.count());
+ SkPathRef::Editor ed(&fPathRef, src.fPathRef->countPoints(), src.fPathRef->countVerbs());
- const SkPoint* pts = src.fPts.end();
- const uint8_t* startVerbs = src.fVerbs.begin();
- const uint8_t* verbs = src.fVerbs.end();
+ const SkPoint* pts = src.fPathRef->pointsEnd();
+ // we will iterator through src's verbs backwards
+ const uint8_t* verbs = src.fPathRef->verbsMemBegin(); // points at the last verb
+ const uint8_t* verbsEnd = src.fPathRef->verbs(); // points just past the first verb
fIsOval = false;
bool needMove = true;
bool needClose = false;
- while (verbs > startVerbs) {
- uint8_t v = *--verbs;
+ while (verbs < verbsEnd) {
+ uint8_t v = *(verbs++);
int n = gPtsInVerb[v];
if (needMove) {
}
dst->swap(tmp);
- matrix.mapPoints(dst->fPts.begin(), dst->fPts.count());
+ SkPathRef::Editor ed(&dst->fPathRef);
+ matrix.mapPoints(ed.points(), ed.pathRef()->countPoints());
} else {
/*
* If we're not in perspective, we can transform all of the points at
* if it is non-finite. In those cases bounds need to stay empty,
* regardless of the matrix.
*/
- if (!fBoundsIsDirty && matrix.rectStaysRect() && fPts.count() > 1) {
+ if (!fBoundsIsDirty && matrix.rectStaysRect() && fPathRef->countPoints() > 1) {
dst->fBoundsIsDirty = false;
if (fIsFinite) {
matrix.mapRect(&dst->fBounds, fBounds);
dst->fBoundsIsDirty = true;
}
+ SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef.get(), matrix);
+
if (this != dst) {
- dst->fVerbs = fVerbs;
- dst->fPts.setCount(fPts.count());
dst->fFillType = fFillType;
dst->fSegmentMask = fSegmentMask;
dst->fConvexity = fConvexity;
- dst->fIsOval = fIsOval;
}
- matrix.mapPoints(dst->fPts.begin(), fPts.begin(), fPts.count());
-
- if (fIsOval) {
- // It's an oval only if it stays a rect.
- dst->fIsOval = matrix.rectStaysRect();
- }
+ // It's an oval only if it stays a rect.
+ dst->fIsOval = fIsOval && matrix.rectStaysRect();
SkDEBUGCODE(dst->validate();)
}
}
void SkPath::Iter::setPath(const SkPath& path, bool forceClose) {
- fPts = path.fPts.begin();
- fVerbs = path.fVerbs.begin();
- fVerbStop = path.fVerbs.end();
+ fPts = path.fPathRef->points();
+ fVerbs = path.fPathRef->verbs();
+ fVerbStop = path.fPathRef->verbsMemBegin();
fLastPt.fX = fLastPt.fY = 0;
fMoveTo.fX = fMoveTo.fY = 0;
fForceClose = SkToU8(forceClose);
const uint8_t* verbs = fVerbs;
const uint8_t* stop = fVerbStop;
- if (kMove_Verb == *verbs) {
- verbs += 1; // skip the initial moveto
+ if (kMove_Verb == *(verbs - 1)) {
+ verbs -= 1; // skip the initial moveto
}
- while (verbs < stop) {
- unsigned v = *verbs++;
+ while (verbs > stop) {
+ // verbs points one beyond the current verb, decrement first.
+ unsigned v = *(--verbs);
if (kMove_Verb == v) {
break;
}
const SkPoint* lastMovePt = 0;
SkPoint lastPt = fLastPt;
while (fVerbs != fVerbStop) {
- unsigned verb = *fVerbs;
+ unsigned verb = *(fVerbs - 1); // fVerbs is one beyond the current verb
switch (verb) {
case kMove_Verb:
// Keep a record of this most recent move
lastMoveVerb = fVerbs;
lastMovePt = fPts;
lastPt = fPts[0];
- fVerbs++;
+ fVerbs--;
fPts++;
break;
return;
}
// A close at any other time must be ignored
- fVerbs++;
+ fVerbs--;
break;
case kLine_Verb:
return;
}
// Ignore this line and continue
- fVerbs++;
+ fVerbs--;
fPts++;
break;
return;
}
// Ignore this line and continue
- fVerbs++;
+ fVerbs--;
fPts += 2;
break;
return;
}
// Ignore this line and continue
- fVerbs++;
+ fVerbs--;
fPts += 3;
break;
return kDone_Verb;
}
- unsigned verb = *fVerbs++;
+ // fVerbs is one beyond the current verb, decrement first
+ unsigned verb = *(--fVerbs);
const SkPoint* SK_RESTRICT srcPts = fPts;
SkPoint* SK_RESTRICT pts = ptsParam;
switch (verb) {
case kMove_Verb:
if (fNeedClose) {
- fVerbs -= 1;
+ fVerbs++; // move back one verb
verb = this->autoClose(pts);
if (verb == kClose_Verb) {
fNeedClose = false;
case kClose_Verb:
verb = this->autoClose(pts);
if (verb == kLine_Verb) {
- fVerbs -= 1;
+ fVerbs++; // move back one verb
} else {
fNeedClose = false;
fSegmentState = kEmptyContour_SegmentState;
}
void SkPath::RawIter::setPath(const SkPath& path) {
- fPts = path.fPts.begin();
- fVerbs = path.fVerbs.begin();
- fVerbStop = path.fVerbs.end();
+ fPts = path.fPathRef->points();
+ fVerbs = path.fPathRef->verbs();
+ fVerbStop = path.fPathRef->verbsMemBegin();
fMoveTo.fX = fMoveTo.fY = 0;
fLastPt.fX = fLastPt.fY = 0;
}
return kDone_Verb;
}
- unsigned verb = *fVerbs++;
- const SkPoint* srcPts = fPts;
+ // fVerbs points one beyond next verb so decrement first.
+ unsigned verb = *(--fVerbs);
+ const SkPoint* srcPts = fPts;
switch (verb) {
case kMove_Verb:
SkDEBUGCODE(this->validate();)
if (NULL == storage) {
- const int byteCount = 3 * sizeof(int32_t)
- + sizeof(SkPoint) * fPts.count()
- + sizeof(uint8_t) * fVerbs.count()
+ const int byteCount = sizeof(int32_t)
+#if NEW_PICTURE_FORMAT
+ + fPathRef->writeSize()
+#else
+ + 2 * sizeof(int32_t)
+ + sizeof(SkPoint) * fPathRef->countPoints()
+ + sizeof(uint8_t) * fPathRef->countVerbs()
+#endif
+ sizeof(SkRect);
return SkAlign4(byteCount);
}
SkWBuffer buffer(storage);
- buffer.write32(fPts.count());
- buffer.write32(fVerbs.count());
+#if !NEW_PICTURE_FORMAT
+ buffer.write32(fPathRef->countPoints());
+ buffer.write32(fPathRef->countVerbs());
+#endif
// Call getBounds() to ensure (as a side-effect) that fBounds
// and fIsFinite are computed.
buffer.write32(packed);
- buffer.write(fPts.begin(), sizeof(SkPoint) * fPts.count());
- buffer.write(fVerbs.begin(), fVerbs.count());
+ fPathRef->writeToBuffer(&buffer);
buffer.write(&bounds, sizeof(bounds));
uint32_t SkPath::readFromMemory(const void* storage) {
SkRBuffer buffer(storage);
- fPts.setCount(buffer.readS32());
- fVerbs.setCount(buffer.readS32());
+#if !NEW_PICTURE_FORMAT
+ int32_t pcount = buffer.readS32();
+ int32_t vcount = buffer.readS32();
+#endif
uint32_t packed = buffer.readS32();
fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
fFillType = (packed >> kFillType_SerializationShift) & 0xFF;
fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0xFF;
- buffer.read(fPts.begin(), sizeof(SkPoint) * fPts.count());
- buffer.read(fVerbs.begin(), fVerbs.count());
+#if NEW_PICTURE_FORMAT
+ fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer));
+#else
+ fPathRef.reset(SkPathRef::CreateFromBuffer(vcount, pcount, &buffer));
+#endif
buffer.read(&fBounds, sizeof(fBounds));
fBoundsIsDirty = false;
void SkPath::validate() const {
SkASSERT(this != NULL);
SkASSERT((fFillType & ~3) == 0);
- fPts.validate();
- fVerbs.validate();
if (!fBoundsIsDirty) {
SkRect bounds;
- bool isFinite = compute_pt_bounds(&bounds, fPts);
+ bool isFinite = compute_pt_bounds(&bounds, *fPathRef.get());
SkASSERT(SkToBool(fIsFinite) == isFinite);
- if (fPts.count() <= 1) {
+ if (fPathRef->countPoints() <= 1) {
// if we're empty, fBounds may be empty but translated, so we can't
// necessarily compare to bounds directly
// try path.addOval(2, 2, 2, 2) which is empty, but the bounds will
}
uint32_t mask = 0;
- for (int i = 0; i < fVerbs.count(); i++) {
- switch (fVerbs[i]) {
+ const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbs();
+ for (int i = 0; i < fPathRef->countVerbs(); i++) {
+ switch (verbs[~i]) {
case kLine_Verb:
mask |= kLine_SegmentMask;
break;
break;
case kCubic_Verb:
mask |= kCubic_SegmentMask;
+ case kMove_Verb: // these verbs aren't included in the segment mask.
+ case kClose_Verb:
+ break;
+ case kDone_Verb:
+ SkDEBUGFAIL("Done verb shouldn't be recorded.");
+ break;
+ default:
+ SkDEBUGFAIL("Unknown Verb");
+ break;
}
}
SkASSERT(mask == fSegmentMask);
class ContourIter {
public:
- ContourIter(const SkTDArray<uint8_t>& verbs, const SkTDArray<SkPoint>& pts);
+ ContourIter(const SkPathRef& pathRef);
bool done() const { return fDone; }
// if !done() then these may be called
SkDEBUGCODE(int fContourCounter;)
};
-ContourIter::ContourIter(const SkTDArray<uint8_t>& verbs,
- const SkTDArray<SkPoint>& pts) {
- fStopVerbs = verbs.begin() + verbs.count();
-
+ContourIter::ContourIter(const SkPathRef& pathRef) {
+ fStopVerbs = pathRef.verbsMemBegin();
fDone = false;
- fCurrPt = pts.begin();
- fCurrVerb = verbs.begin();
+ fCurrPt = pathRef.points();
+ fCurrVerb = pathRef.verbs();
fCurrPtCount = 0;
SkDEBUGCODE(fContourCounter = 0;)
this->next();
}
void ContourIter::next() {
- if (fCurrVerb >= fStopVerbs) {
+ if (fCurrVerb <= fStopVerbs) {
fDone = true;
}
if (fDone) {
// skip pts of prev contour
fCurrPt += fCurrPtCount;
- SkASSERT(SkPath::kMove_Verb == fCurrVerb[0]);
+ SkASSERT(SkPath::kMove_Verb == fCurrVerb[~0]);
int ptCount = 1; // moveTo
const uint8_t* verbs = fCurrVerb;
- for (++verbs; verbs < fStopVerbs; ++verbs) {
- switch (*verbs) {
+ for (--verbs; verbs > fStopVerbs; --verbs) {
+ switch (verbs[~0]) {
case SkPath::kMove_Verb:
goto CONTOUR_END;
case SkPath::kLine_Verb:
// is unknown, so we don't call isConvex()
const Convexity conv = this->getConvexityOrUnknown();
- ContourIter iter(fVerbs, fPts);
+ ContourIter iter(*fPathRef.get());
// initialize with our logical y-min
SkScalar ymax = this->getBounds().fTop;
--- /dev/null
+
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathRef_DEFINED
+#define SkPathRef_DEFINED
+
+#include "SkRefCnt.h"
+#include <stddef.h> // ptrdiff_t
+
+// When we're ready to break the picture format. Changes:
+// * Write genID.
+// * SkPathRef read/write counts (which will change the field order)
+// * SkPathRef reads/writes verbs backwards.
+#define NEW_PICTURE_FORMAT 0
+
+/**
+ * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
+ * modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
+ * SkPathRef::Editor object. Installing the editor resets the generation ID. It also performs
+ * copy-on-write if the SkPathRef is shared by multipls SkPaths. The caller passes the Editor's
+ * constructor a SkAutoTUnref, which may be updated to point to a new SkPathRef after the editor's
+ * constructor returns.
+ *
+ * The points and verbs are stored in a single allocation. The points are at the begining of the
+ * allocation while the verbs are stored at end of the allocation, in reverse order. Thus the points
+ * and verbs both grow into the middle of the allocation until the meet. To access verb i in the
+ * verb array use ref.verbs()[~i] (because verbs() returns a pointer just beyond the first
+ * logical verb or the last verb in memory).
+ */
+class SkPathRef : public ::SkRefCnt {
+public:
+ SK_DECLARE_INST_COUNT(SkPathRef);
+
+ class Editor {
+ public:
+ Editor(SkAutoTUnref<SkPathRef>* pathRef,
+ int incReserveVerbs = 0,
+ int incReservePoints = 0) {
+ if (pathRef->get()->getRefCnt() > 1) {
+ SkPathRef* copy = SkNEW(SkPathRef);
+ copy->copy(*pathRef->get(), incReserveVerbs, incReservePoints);
+ pathRef->reset(copy);
+ } else {
+ (*pathRef)->incReserve(incReserveVerbs, incReservePoints);
+ }
+ fPathRef = pathRef->get();
+ fPathRef->fGenerationID = 0;
+ SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
+ }
+
+ ~Editor() { SkDEBUGCODE(sk_atomic_dec(&fPathRef->fEditorsAttached);) }
+
+ /**
+ * Returns the array of points.
+ */
+ SkPoint* points() { return fPathRef->fPoints; }
+
+ /**
+ * Gets the ith point. Shortcut for this->points() + i
+ */
+ SkPoint* atPoint(int i) {
+ SkASSERT((unsigned) i < (unsigned) fPathRef->fPointCnt);
+ return this->points() + i;
+ };
+
+ /**
+ * Adds the verb and allocates space for the number of points indicated by the verb. The
+ * return value is a pointer to where the points for the verb should be written.
+ */
+ SkPoint* growForVerb(SkPath::Verb verb) {
+ fPathRef->validate();
+ return fPathRef->growForVerb(verb);
+ }
+
+ /**
+ * Allocates space for additional verbs and points and returns pointers to the new verbs and
+ * points. verbs will point one beyond the first new verb (index it using [~<i>]). pts points
+ * at the first new point (indexed normally [<i>]).
+ */
+ void grow(int newVerbs, int newPts, uint8_t** verbs, SkPoint** pts) {
+ SkASSERT(NULL != verbs);
+ SkASSERT(NULL != pts);
+ fPathRef->validate();
+ int oldVerbCnt = fPathRef->fVerbCnt;
+ int oldPointCnt = fPathRef->fPointCnt;
+ SkASSERT(verbs && pts);
+ fPathRef->grow(newVerbs, newPts);
+ *verbs = fPathRef->fVerbs - oldVerbCnt;
+ *pts = fPathRef->fPoints + oldPointCnt;
+ fPathRef->validate();
+ }
+
+ /**
+ * Resets the path ref to a new verb and point count. The new verbs and points are
+ * uninitialized.
+ */
+ void resetToSize(int newVerbCnt, int newPointCnt) {
+ fPathRef->resetToSize(newVerbCnt, newPointCnt);
+ }
+ /**
+ * Gets the path ref that is wrapped in the Editor.
+ */
+ SkPathRef* pathRef() { return fPathRef; }
+
+ private:
+ SkPathRef* fPathRef;
+ };
+
+public:
+
+ /**
+ * Gets a path ref with no verbs or points.
+ */
+ static SkPathRef* CreateEmpty() {
+ static SkAutoTUnref<SkPathRef> gEmptyPathRef(SkNEW(SkPathRef));
+ gEmptyPathRef.get()->ref();
+ return gEmptyPathRef.get();
+ }
+
+ /**
+ * Transforms a path ref by a matrix, allocating a new one only if necessary.
+ */
+ static void CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
+ const SkPathRef& src,
+ const SkMatrix& matrix) {
+ src.validate();
+ if (matrix.isIdentity()) {
+ if (dst->get() != &src) {
+ dst->reset(const_cast<SkPathRef*>(&src));
+ (*dst)->validate();
+ src.ref();
+ }
+ return;
+ }
+ int32_t rcnt = dst->get()->getRefCnt();
+ if (&src == dst->get() && 1 == rcnt) {
+ matrix.mapPoints((*dst)->fPoints, (*dst)->fPointCnt);
+ return;
+ } else if (rcnt > 1) {
+ dst->reset(SkNEW(SkPathRef));
+ }
+ (*dst)->resetToSize(src.fVerbCnt, src.fPointCnt);
+ memcpy((*dst)->verbsMemWritable(), src.verbsMemBegin(), src.fVerbCnt * sizeof(uint8_t));
+ matrix.mapPoints((*dst)->fPoints, src.points(), src.fPointCnt);
+ (*dst)->validate();
+ }
+
+#if NEW_PICTURE_FORMAT
+ static SkPathRef* CreateFromBuffer(SkRBuffer* buffer) {
+ SkPathRef* ref = SkNEW(SkPathRef);
+ ref->fGenerationID = buffer->readU32();
+ int32_t verbCount = buffer->readS32();
+ int32_t pointCount = buffer->readS32();
+ ref->resetToSize(verbCount, pointCount);
+
+ SkASSERT(verbCount == ref->countVerbs());
+ SkASSERT(pointCount == ref->countPoints());
+ buffer->read(ref->verbsMemWritable(), verbCount * sizeof(uint8_t));
+ buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
+ return ref;
+ }
+#else
+ static SkPathRef* CreateFromBuffer(int verbCount, int pointCount, SkRBuffer* buffer) {
+ SkPathRef* ref = SkNEW(SkPathRef);
+
+ ref->resetToSize(verbCount, pointCount);
+ SkASSERT(verbCount == ref->countVerbs());
+ SkASSERT(pointCount == ref->countPoints());
+ buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
+ for (int i = 0; i < verbCount; ++i) {
+ ref->fVerbs[~i] = buffer->readU8();
+ }
+ return ref;
+ }
+#endif
+
+ /**
+ * Rollsback a path ref to zero verbs and points with the assumption that the path ref will be
+ * repopulated with approximately the same number of verbs and points. A new path ref is created
+ * only if necessary.
+ */
+ static void Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
+ if (1 == (*pathRef)->getRefCnt()) {
+ (*pathRef)->validate();
+ (*pathRef)->fVerbCnt = 0;
+ (*pathRef)->fPointCnt = 0;
+ (*pathRef)->fFreeSpace = (*pathRef)->currSize();
+ (*pathRef)->fGenerationID = 0;
+ (*pathRef)->validate();
+ } else {
+ int oldVCnt = (*pathRef)->countVerbs();
+ int oldPCnt = (*pathRef)->countPoints();
+ pathRef->reset(SkNEW(SkPathRef));
+ (*pathRef)->resetToSize(0, 0, oldVCnt, oldPCnt);
+ }
+ }
+
+ virtual ~SkPathRef() {
+ this->validate();
+ sk_free(fPoints);
+ }
+
+ int countPoints() const { this->validate(); return fPointCnt; }
+ int countVerbs() const { this->validate(); return fVerbCnt; }
+
+ /**
+ * Returns a pointer one beyond the first logical verb (last verb in memory order).
+ */
+ const uint8_t* verbs() const { this->validate(); return fVerbs; }
+
+ /**
+ * Returns a const pointer to the first verb in memory (which is the last logical verb).
+ */
+ const uint8_t* verbsMemBegin() const { return this->verbs() - fVerbCnt; }
+
+ /**
+ * Returns a const pointer to the first point.
+ */
+ const SkPoint* points() const { this->validate(); return fPoints; }
+
+ /**
+ * Shortcut for this->points() + this->countPoints()
+ */
+ const SkPoint* pointsEnd() const { return this->points() + this->countPoints(); }
+
+ /**
+ * Convenience methods for getting to a verb or point by index.
+ */
+ uint8_t atVerb(int index) {
+ SkASSERT((unsigned) index < (unsigned) fVerbCnt);
+ return this->verbs()[~index];
+ }
+ const SkPoint& atPoint(int index) const {
+ SkASSERT((unsigned) index < (unsigned) fPointCnt);
+ return this->points()[index];
+ }
+
+ bool operator== (const SkPathRef& ref) const {
+ this->validate();
+ ref.validate();
+ bool genIDMatch = fGenerationID && fGenerationID == ref.fGenerationID;
+#ifdef SK_RELEASE
+ if (genIDMatch) {
+ return true;
+ }
+#endif
+ if (fPointCnt != ref.fPointCnt ||
+ fVerbCnt != ref.fVerbCnt) {
+ SkASSERT(!genIDMatch);
+ return false;
+ }
+ if (0 != memcmp(this->verbsMemBegin(),
+ ref.verbsMemBegin(),
+ ref.fVerbCnt * sizeof(uint8_t))) {
+ SkASSERT(!genIDMatch);
+ return false;
+ }
+ if (0 != memcmp(this->points(),
+ ref.points(),
+ ref.fPointCnt * sizeof(SkPoint))) {
+ SkASSERT(!genIDMatch);
+ return false;
+ }
+ // We've done the work to determine that these are equal. If either has a zero genID, copy
+ // the other's. If both are 0 then genID() will compute the next ID.
+ if (0 == fGenerationID) {
+ fGenerationID = ref.genID();
+ } else if (0 == ref.fGenerationID) {
+ ref.fGenerationID = this->genID();
+ }
+ return true;
+ }
+
+ /**
+ * Writes the path points and verbs to a buffer.
+ */
+#if NEW_PICTURE_FORMAT
+ void writeToBuffer(SkWBuffer* buffer) {
+ this->validate();
+ SkDEBUGCODE(size_t beforePos = buffer->pos();)
+
+ // TODO: write gen ID here. Problem: We don't know if we're cross process or not from
+ // SkWBuffer. Until this is fixed we write 0.
+ buffer->write32(0);
+ buffer->write32(this->fVerbCnt);
+ buffer->write32(this->fPointCnt);
+ buffer->write(this->verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
+ buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
+
+ SkASSERT(buffer->pos() - beforePos == (size_t) this->writeSize());
+ }
+
+ /**
+ * Gets the number of bytes that would be written in writeBuffer()
+ */
+ uint32_t writeSize() {
+ return 3 * sizeof(uint32_t) + fVerbCnt * sizeof(uint8_t) + fPointCnt * sizeof(SkPoint);
+ }
+#else
+ void writeToBuffer(SkWBuffer* buffer) {
+ this->validate();
+ buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
+ for (int i = 0; i < fVerbCnt; ++i) {
+ buffer->write8(fVerbs[~i]);
+ }
+ }
+#endif
+
+private:
+ SkPathRef() {
+ fPointCnt = 0;
+ fVerbCnt = 0;
+ fVerbs = NULL;
+ fPoints = NULL;
+ fFreeSpace = 0;
+ fGenerationID = kEmptyGenID;
+ SkDEBUGCODE(fEditorsAttached = 0;)
+ this->validate();
+ }
+
+ void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints) {
+ this->validate();
+ this->resetToSize(ref.fVerbCnt, ref.fPointCnt,
+ additionalReserveVerbs, additionalReservePoints);
+ memcpy(this->verbsMemWritable(), ref.verbsMemBegin(), ref.fVerbCnt * sizeof(uint8_t));
+ memcpy(this->fPoints, ref.fPoints, ref.fPointCnt * sizeof(SkPoint));
+ // We could call genID() here to force a real ID (instead of 0). However, if we're making
+ // a copy then presumably we intend to make a modification immediately afterwards.
+ fGenerationID = ref.fGenerationID;
+ this->validate();
+ }
+
+ /** Makes additional room but does not change the counts or change the genID */
+ void incReserve(int additionalVerbs, int additionalPoints) {
+ this->validate();
+ size_t space = additionalVerbs * sizeof(uint8_t) + additionalPoints * sizeof (SkPoint);
+ this->makeSpace(space);
+ this->validate();
+ }
+
+ /** Resets the path ref with verbCount verbs and pointCount points, all unitialized. Also
+ * allocates space for reserveVerb additional verbs and reservePoints additional points.*/
+ void resetToSize(int verbCount, int pointCount, int reserveVerbs = 0, int reservePoints = 0) {
+ this->validate();
+ fGenerationID = 0;
+
+ size_t newSize = sizeof(uint8_t) * verbCount + sizeof(SkPoint) * pointCount;
+ size_t newReserve = sizeof(uint8_t) * reserveVerbs + sizeof(SkPoint) * reservePoints;
+ size_t minSize = newSize + newReserve;
+
+ ptrdiff_t sizeDelta = this->currSize() - minSize;
+
+ if (sizeDelta < 0 || static_cast<size_t>(sizeDelta) >= 3 * minSize) {
+ sk_free(fPoints);
+ fPoints = NULL;
+ fVerbs = NULL;
+ fFreeSpace = 0;
+ fVerbCnt = 0;
+ fPointCnt = 0;
+ this->makeSpace(minSize);
+ fVerbCnt = verbCount;
+ fPointCnt = pointCount;
+ fFreeSpace -= newSize;
+ } else {
+ fPointCnt = pointCount;
+ fVerbCnt = verbCount;
+ fFreeSpace = this->currSize() - minSize;
+ }
+ this->validate();
+ }
+
+ /**
+ * Increases the verb count by newVerbs and the point count be newPoints. New verbs and points
+ * are uninitialized.
+ */
+ void grow(int newVerbs, int newPoints) {
+ this->validate();
+ size_t space = newVerbs * sizeof(uint8_t) + newPoints * sizeof (SkPoint);
+ this->makeSpace(space);
+ fVerbCnt += newVerbs;
+ fPointCnt += newPoints;
+ fFreeSpace -= space;
+ this->validate();
+ }
+
+ /**
+ * Increases the verb count 1, records the new verb, and creates room for the requisite number
+ * of additional points. A pointer to the first point is returned. Any new points are
+ * uninitialized.
+ */
+ SkPoint* growForVerb(SkPath::Verb verb) {
+ this->validate();
+ int pCnt;
+ switch (verb) {
+ case SkPath::kMove_Verb:
+ pCnt = 1;
+ break;
+ case SkPath::kLine_Verb:
+ pCnt = 1;
+ break;
+ case SkPath::kQuad_Verb:
+ pCnt = 2;
+ break;
+ case SkPath::kCubic_Verb:
+ pCnt = 3;
+ break;
+ default:
+ pCnt = 0;
+ }
+ size_t space = sizeof(uint8_t) + pCnt * sizeof (SkPoint);
+ this->makeSpace(space);
+ this->fVerbs[~fVerbCnt] = verb;
+ SkPoint* ret = fPoints + fPointCnt;
+ fVerbCnt += 1;
+ fPointCnt += pCnt;
+ fFreeSpace -= space;
+ this->validate();
+ return ret;
+ }
+
+ /**
+ * Ensures that the free space available in the path ref is >= size. The verb and point counts
+ * are not changed.
+ */
+ void makeSpace(size_t size) {
+ this->validate();
+ ptrdiff_t growSize = size - fFreeSpace;
+ if (growSize <= 0) {
+ return;
+ }
+ size_t oldSize = this->currSize();
+ // round to next multiple of 8 bytes
+ growSize = (growSize + 7) & ~static_cast<size_t>(7);
+ // we always at least double the allocation
+ if (static_cast<size_t>(growSize) < oldSize) {
+ growSize = oldSize;
+ }
+ if (growSize < kMinSize) {
+ growSize = kMinSize;
+ }
+ size_t newSize = oldSize + growSize;
+ // Note that realloc could memcpy more than we need. It seems to be a win anyway. TODO:
+ // encapsulate this.
+ fPoints = reinterpret_cast<SkPoint*>(sk_realloc_throw(fPoints, newSize));
+ size_t oldVerbSize = fVerbCnt * sizeof(uint8_t);
+ void* newVerbsDst = reinterpret_cast<void*>(
+ reinterpret_cast<intptr_t>(fPoints) + newSize - oldVerbSize);
+ void* oldVerbsSrc = reinterpret_cast<void*>(
+ reinterpret_cast<intptr_t>(fPoints) + oldSize - oldVerbSize);
+ memmove(newVerbsDst, oldVerbsSrc, oldVerbSize);
+ fVerbs = reinterpret_cast<uint8_t*>(reinterpret_cast<intptr_t>(fPoints) + newSize);
+ fFreeSpace += growSize;
+ this->validate();
+ }
+
+ /**
+ * Private, non-const-ptr version of the public function verbsMemBegin().
+ */
+ uint8_t* verbsMemWritable() {
+ this->validate();
+ return fVerbs - fVerbCnt;
+ }
+
+ /**
+ * Gets the total amount of space allocated for verbs, points, and reserve.
+ */
+ size_t currSize() const {
+ return reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints);
+ }
+
+ /**
+ * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
+ * same ID then they have the same verbs and points. However, two path refs may have the same
+ * contents but different genIDs. Zero is reserved and means an ID has not yet been determined
+ * for the path ref.
+ */
+ int32_t genID() const {
+ SkDEBUGCODE(SkASSERT(!fEditorsAttached));
+ if (!fGenerationID) {
+ if (0 == fPointCnt && 0 == fVerbCnt) {
+ fGenerationID = kEmptyGenID;
+ } else {
+ static int32_t gPathRefGenerationID;
+ // do a loop in case our global wraps around, as we never want to return a 0 or the
+ // empty ID
+ do {
+ fGenerationID = sk_atomic_inc(&gPathRefGenerationID) + 1;
+ } while (fGenerationID <= kEmptyGenID);
+ }
+ }
+ return fGenerationID;
+ }
+
+ void validate() const {
+ SkASSERT(static_cast<ptrdiff_t>(fFreeSpace) >= 0);
+ SkASSERT(reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) >= 0);
+ SkASSERT((NULL == fPoints) == (NULL == fVerbs));
+ SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
+ SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
+ SkASSERT(!(NULL == fPoints && fPointCnt));
+ SkASSERT(!(NULL == fVerbs && fVerbCnt));
+ SkASSERT(this->currSize() ==
+ fFreeSpace + sizeof(SkPoint) * fPointCnt + sizeof(uint8_t) * fVerbCnt);
+ }
+
+ enum {
+ kMinSize = 256,
+ };
+
+ SkPoint* fPoints; // points to begining of the allocation
+ uint8_t* fVerbs; // points just past the end of the allocation (verbs grow backwards)
+ int fVerbCnt;
+ int fPointCnt;
+ size_t fFreeSpace; // redundant but saves computation
+ enum {
+ kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
+ };
+ mutable int32_t fGenerationID;
+ SkDEBUGCODE(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
+
+ typedef SkRefCnt INHERITED;
+};
+
+SK_DEFINE_INST_COUNT(SkPathRef);
+
+#endif
projects / platform / upstream / libSkiaSharp.git / commitdiff