/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkPathRef.h"
#include "SkBuffer.h"
#include "SkNx.h"
#include "SkOnce.h"
#include "SkPath.h"
#include "SkPathPriv.h"
#include "SkSafeMath.h"
#include "SkTo.h"
// Conic weights must be 0 < weight <= finite
static bool validate_conic_weights(const SkScalar weights[], int count) {
for (int i = 0; i < count; ++i) {
if (weights[i] <= 0 || !SkScalarIsFinite(weights[i])) {
return false;
}
}
return true;
}
//////////////////////////////////////////////////////////////////////////////
SkPathRef::Editor::Editor(sk_sp<SkPathRef>* pathRef,
int incReserveVerbs,
int incReservePoints)
{
SkASSERT(incReserveVerbs >= 0);
SkASSERT(incReservePoints >= 0);
if ((*pathRef)->unique()) {
(*pathRef)->incReserve(incReserveVerbs, incReservePoints);
} else {
SkPathRef* copy = new SkPathRef;
copy->copy(**pathRef, incReserveVerbs, incReservePoints);
pathRef->reset(copy);
}
fPathRef = pathRef->get();
fPathRef->callGenIDChangeListeners();
fPathRef->fGenerationID = 0;
fPathRef->fBoundsIsDirty = true;
SkDEBUGCODE(fPathRef->fEditorsAttached++;)
}
// Sort of like makeSpace(0) but the the additional requirement that we actively shrink the
// allocations to just fit the current needs. makeSpace() will only grow, but never shrinks.
//
void SkPath::shrinkToFit() {
const size_t kMinFreeSpaceForShrink = 8; // just made up a small number
if (fPathRef->fFreeSpace <= kMinFreeSpaceForShrink) {
return;
}
if (fPathRef->unique()) {
int pointCount = fPathRef->fPointCnt;
int verbCount = fPathRef->fVerbCnt;
size_t ptsSize = sizeof(SkPoint) * pointCount;
size_t vrbSize = sizeof(uint8_t) * verbCount;
size_t minSize = ptsSize + vrbSize;
void* newAlloc = sk_malloc_canfail(minSize);
if (!newAlloc) {
return; // couldn't allocate the smaller buffer, but that's ok
}
sk_careful_memcpy(newAlloc, fPathRef->fPoints, ptsSize);
sk_careful_memcpy((char*)newAlloc + minSize - vrbSize, fPathRef->verbsMemBegin(), vrbSize);
sk_free(fPathRef->fPoints);
fPathRef->fPoints = static_cast<SkPoint*>(newAlloc);
fPathRef->fVerbs = (uint8_t*)newAlloc + minSize;
fPathRef->fFreeSpace = 0;
fPathRef->fConicWeights.shrinkToFit();
} else {
sk_sp<SkPathRef> pr(new SkPathRef);
pr->copy(*fPathRef, 0, 0);
fPathRef = std::move(pr);
}
SkDEBUGCODE(fPathRef->validate();)
}
//////////////////////////////////////////////////////////////////////////////
SkPathRef::~SkPathRef() {
// Deliberately don't validate() this path ref, otherwise there's no way
// to read one that's not valid and then free its memory without asserting.
this->callGenIDChangeListeners();
SkASSERT(fGenIDChangeListeners.empty()); // These are raw ptrs.
sk_free(fPoints);
SkDEBUGCODE(fPoints = nullptr;)
SkDEBUGCODE(fVerbs = nullptr;)
SkDEBUGCODE(fVerbCnt = 0x9999999;)
SkDEBUGCODE(fPointCnt = 0xAAAAAAA;)
SkDEBUGCODE(fPointCnt = 0xBBBBBBB;)
SkDEBUGCODE(fGenerationID = 0xEEEEEEEE;)
SkDEBUGCODE(fEditorsAttached.store(0x7777777);)
}
static SkPathRef* gEmpty = nullptr;
SkPathRef* SkPathRef::CreateEmpty() {
static SkOnce once;
once([]{
gEmpty = new SkPathRef;
gEmpty->computeBounds(); // Avoids races later to be the first to do this.
});
return SkRef(gEmpty);
}
static void transform_dir_and_start(const SkMatrix& matrix, bool isRRect, bool* isCCW,
unsigned* start) {
int inStart = *start;
int rm = 0;
if (isRRect) {
// Degenerate rrect indices to oval indices and remember the remainder.
// Ovals have one index per side whereas rrects have two.
rm = inStart & 0b1;
inStart /= 2;
}
// Is the antidiagonal non-zero (otherwise the diagonal is zero)
int antiDiag;
// Is the non-zero value in the top row (either kMScaleX or kMSkewX) negative
int topNeg;
// Are the two non-zero diagonal or antidiagonal values the same sign.
int sameSign;
if (matrix.get(SkMatrix::kMScaleX) != 0) {
antiDiag = 0b00;
if (matrix.get(SkMatrix::kMScaleX) > 0) {
topNeg = 0b00;
sameSign = matrix.get(SkMatrix::kMScaleY) > 0 ? 0b01 : 0b00;
} else {
topNeg = 0b10;
sameSign = matrix.get(SkMatrix::kMScaleY) > 0 ? 0b00 : 0b01;
}
} else {
antiDiag = 0b01;
if (matrix.get(SkMatrix::kMSkewX) > 0) {
topNeg = 0b00;
sameSign = matrix.get(SkMatrix::kMSkewY) > 0 ? 0b01 : 0b00;
} else {
topNeg = 0b10;
sameSign = matrix.get(SkMatrix::kMSkewY) > 0 ? 0b00 : 0b01;
}
}
if (sameSign != antiDiag) {
// This is a rotation (and maybe scale). The direction is unchanged.
// Trust me on the start computation (or draw yourself some pictures)
*start = (inStart + 4 - (topNeg | antiDiag)) % 4;
SkASSERT(*start < 4);
if (isRRect) {
*start = 2 * *start + rm;
}
} else {
// This is a mirror (and maybe scale). The direction is reversed.
*isCCW = !*isCCW;
// Trust me on the start computation (or draw yourself some pictures)
*start = (6 + (topNeg | antiDiag) - inStart) % 4;
SkASSERT(*start < 4);
if (isRRect) {
*start = 2 * *start + (rm ? 0 : 1);
}
}
}
void SkPathRef::CreateTransformedCopy(sk_sp<SkPathRef>* dst,
const SkPathRef& src,
const SkMatrix& matrix) {
SkDEBUGCODE(src.validate();)
if (matrix.isIdentity()) {
if (dst->get() != &src) {
src.ref();
dst->reset(const_cast<SkPathRef*>(&src));
SkDEBUGCODE((*dst)->validate();)
}
return;
}
if (!(*dst)->unique()) {
dst->reset(new SkPathRef);
}
if (dst->get() != &src) {
(*dst)->resetToSize(src.fVerbCnt, src.fPointCnt, src.fConicWeights.count());
sk_careful_memcpy((*dst)->verbsMemWritable(), src.verbsMemBegin(),
src.fVerbCnt * sizeof(uint8_t));
(*dst)->fConicWeights = src.fConicWeights;
}
SkASSERT((*dst)->countPoints() == src.countPoints());
SkASSERT((*dst)->countVerbs() == src.countVerbs());
SkASSERT((*dst)->fConicWeights.count() == src.fConicWeights.count());
// Need to check this here in case (&src == dst)
bool canXformBounds = !src.fBoundsIsDirty && matrix.rectStaysRect() && src.countPoints() > 1;
matrix.mapPoints((*dst)->fPoints, src.points(), src.fPointCnt);
/*
* Here we optimize the bounds computation, by noting if the bounds are
* already known, and if so, we just transform those as well and mark
* them as "known", rather than force the transformed path to have to
* recompute them.
*
* Special gotchas if the path is effectively empty (<= 1 point) or
* if it is non-finite. In those cases bounds need to stay empty,
* regardless of the matrix.
*/
if (canXformBounds) {
(*dst)->fBoundsIsDirty = false;
if (src.fIsFinite) {
matrix.mapRect(&(*dst)->fBounds, src.fBounds);
if (!((*dst)->fIsFinite = (*dst)->fBounds.isFinite())) {
(*dst)->fBounds.setEmpty();
}
} else {
(*dst)->fIsFinite = false;
(*dst)->fBounds.setEmpty();
}
} else {
(*dst)->fBoundsIsDirty = true;
}
(*dst)->fSegmentMask = src.fSegmentMask;
// It's an oval only if it stays a rect.
bool rectStaysRect = matrix.rectStaysRect();
(*dst)->fIsOval = src.fIsOval && rectStaysRect;
(*dst)->fIsRRect = src.fIsRRect && rectStaysRect;
if ((*dst)->fIsOval || (*dst)->fIsRRect) {
unsigned start = src.fRRectOrOvalStartIdx;
bool isCCW = SkToBool(src.fRRectOrOvalIsCCW);
transform_dir_and_start(matrix, (*dst)->fIsRRect, &isCCW, &start);
(*dst)->fRRectOrOvalIsCCW = isCCW;
(*dst)->fRRectOrOvalStartIdx = start;
}
SkDEBUGCODE((*dst)->validate();)
}
static bool validate_verb_sequence(const uint8_t verbs[], int vCount) {
// verbs are stored backwards, but we need to visit them in logical order to determine if
// they form a valid sequence.
bool needsMoveTo = true;
bool invalidSequence = false;
for (int i = vCount - 1; i >= 0; --i) {
switch (verbs[i]) {
case SkPath::kMove_Verb:
needsMoveTo = false;
break;
case SkPath::kLine_Verb:
case SkPath::kQuad_Verb:
case SkPath::kConic_Verb:
case SkPath::kCubic_Verb:
invalidSequence |= needsMoveTo;
break;
case SkPath::kClose_Verb:
needsMoveTo = true;
break;
default:
return false; // unknown verb
}
}
return !invalidSequence;
}
// Given the verb array, deduce the required number of pts and conics,
// or if an invalid verb is encountered, return false.
static bool deduce_pts_conics(const uint8_t verbs[], int vCount, int* ptCountPtr,
int* conicCountPtr) {
// When there is at least one verb, the first is required to be kMove_Verb.
if (0 < vCount && verbs[vCount-1] != SkPath::kMove_Verb) {
return false;
}
SkSafeMath safe;
int ptCount = 0;
int conicCount = 0;
for (int i = 0; i < vCount; ++i) {
switch (verbs[i]) {
case SkPath::kMove_Verb:
case SkPath::kLine_Verb:
ptCount = safe.addInt(ptCount, 1);
break;
case SkPath::kConic_Verb:
conicCount += 1;
// fall-through
case SkPath::kQuad_Verb:
ptCount = safe.addInt(ptCount, 2);
break;
case SkPath::kCubic_Verb:
ptCount = safe.addInt(ptCount, 3);
break;
case SkPath::kClose_Verb:
break;
default:
return false;
}
}
if (!safe) {
return false;
}
*ptCountPtr = ptCount;
*conicCountPtr = conicCount;
return true;
}
SkPathRef* SkPathRef::CreateFromBuffer(SkRBuffer* buffer) {
std::unique_ptr<SkPathRef> ref(new SkPathRef);
int32_t packed;
if (!buffer->readS32(&packed)) {
return nullptr;
}
ref->fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
int32_t verbCount, pointCount, conicCount;
if (!buffer->readU32(&(ref->fGenerationID)) ||
!buffer->readS32(&verbCount) || (verbCount < 0) ||
!buffer->readS32(&pointCount) || (pointCount < 0) ||
!buffer->readS32(&conicCount) || (conicCount < 0))
{
return nullptr;
}
uint64_t pointSize64 = sk_64_mul(pointCount, sizeof(SkPoint));
uint64_t conicSize64 = sk_64_mul(conicCount, sizeof(SkScalar));
if (!SkTFitsIn<size_t>(pointSize64) || !SkTFitsIn<size_t>(conicSize64)) {
return nullptr;
}
size_t verbSize = verbCount * sizeof(uint8_t);
size_t pointSize = SkToSizeT(pointSize64);
size_t conicSize = SkToSizeT(conicSize64);
{
uint64_t requiredBufferSize = sizeof(SkRect);
requiredBufferSize += verbSize;
requiredBufferSize += pointSize;
requiredBufferSize += conicSize;
if (buffer->available() < requiredBufferSize) {
return nullptr;
}
}
ref->resetToSize(verbCount, pointCount, conicCount);
SkASSERT(verbCount == ref->countVerbs());
SkASSERT(pointCount == ref->countPoints());
SkASSERT(conicCount == ref->fConicWeights.count());
if (!buffer->read(ref->verbsMemWritable(), verbSize) ||
!buffer->read(ref->fPoints, pointSize) ||
!buffer->read(ref->fConicWeights.begin(), conicSize) ||
!buffer->read(&ref->fBounds, sizeof(SkRect))) {
return nullptr;
}
// Check that the verbs are valid, and imply the correct number of pts and conics
{
int pCount, cCount;
if (!validate_verb_sequence(ref->verbsMemBegin(), ref->countVerbs())) {
return nullptr;
}
if (!deduce_pts_conics(ref->verbsMemBegin(), ref->countVerbs(), &pCount, &cCount) ||
pCount != ref->countPoints() || cCount != ref->fConicWeights.count()) {
return nullptr;
}
if (!validate_conic_weights(ref->fConicWeights.begin(), ref->fConicWeights.count())) {
return nullptr;
}
// Check that the bounds match the serialized bounds.
SkRect bounds;
if (ComputePtBounds(&bounds, *ref) != SkToBool(ref->fIsFinite) || bounds != ref->fBounds) {
return nullptr;
}
// call this after validate_verb_sequence, since it relies on valid verbs
ref->fSegmentMask = ref->computeSegmentMask();
}
ref->fBoundsIsDirty = false;
return ref.release();
}
void SkPathRef::Rewind(sk_sp<SkPathRef>* pathRef) {
if ((*pathRef)->unique()) {
SkDEBUGCODE((*pathRef)->validate();)
(*pathRef)->callGenIDChangeListeners();
(*pathRef)->fBoundsIsDirty = true; // this also invalidates fIsFinite
(*pathRef)->fVerbCnt = 0;
(*pathRef)->fPointCnt = 0;
(*pathRef)->fFreeSpace = (*pathRef)->currSize();
(*pathRef)->fGenerationID = 0;
(*pathRef)->fConicWeights.rewind();
(*pathRef)->fSegmentMask = 0;
(*pathRef)->fIsOval = false;
(*pathRef)->fIsRRect = false;
SkDEBUGCODE((*pathRef)->validate();)
} else {
int oldVCnt = (*pathRef)->countVerbs();
int oldPCnt = (*pathRef)->countPoints();
pathRef->reset(new SkPathRef);
(*pathRef)->resetToSize(0, 0, 0, oldVCnt, oldPCnt);
}
}
bool SkPathRef::operator== (const SkPathRef& ref) const {
SkDEBUGCODE(this->validate();)
SkDEBUGCODE(ref.validate();)
// We explicitly check fSegmentMask as a quick-reject. We could skip it,
// since it is only a cache of info in the fVerbs, but its a fast way to
// notice a difference
if (fSegmentMask != ref.fSegmentMask) {
return false;
}
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 == ref.fVerbCnt) {
SkASSERT(0 == ref.fPointCnt);
return true;
}
SkASSERT(this->verbsMemBegin() && ref.verbsMemBegin());
if (0 != memcmp(this->verbsMemBegin(),
ref.verbsMemBegin(),
ref.fVerbCnt * sizeof(uint8_t))) {
SkASSERT(!genIDMatch);
return false;
}
SkASSERT(this->points() && ref.points());
if (0 != memcmp(this->points(),
ref.points(),
ref.fPointCnt * sizeof(SkPoint))) {
SkASSERT(!genIDMatch);
return false;
}
if (fConicWeights != ref.fConicWeights) {
SkASSERT(!genIDMatch);
return false;
}
return true;
}
void SkPathRef::writeToBuffer(SkWBuffer* buffer) const {
SkDEBUGCODE(this->validate();)
SkDEBUGCODE(size_t beforePos = buffer->pos();)
// Call getBounds() to ensure (as a side-effect) that fBounds
// and fIsFinite are computed.
const SkRect& bounds = this->getBounds();
// We store fSegmentMask for older readers, but current readers can't trust it, so they
// don't read it.
int32_t packed = ((fIsFinite & 1) << kIsFinite_SerializationShift) |
(fSegmentMask << kSegmentMask_SerializationShift);
buffer->write32(packed);
// 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(fVerbCnt);
buffer->write32(fPointCnt);
buffer->write32(fConicWeights.count());
buffer->write(verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
buffer->write(fConicWeights.begin(), fConicWeights.bytes());
buffer->write(&bounds, sizeof(bounds));
SkASSERT(buffer->pos() - beforePos == (size_t) this->writeSize());
}
uint32_t SkPathRef::writeSize() const {
return uint32_t(5 * sizeof(uint32_t) +
fVerbCnt * sizeof(uint8_t) +
fPointCnt * sizeof(SkPoint) +
fConicWeights.bytes() +
sizeof(SkRect));
}
void SkPathRef::copy(const SkPathRef& ref,
int additionalReserveVerbs,
int additionalReservePoints) {
SkDEBUGCODE(this->validate();)
this->resetToSize(ref.fVerbCnt, ref.fPointCnt, ref.fConicWeights.count(),
additionalReserveVerbs, additionalReservePoints);
sk_careful_memcpy(this->verbsMemWritable(), ref.verbsMemBegin(), ref.fVerbCnt*sizeof(uint8_t));
sk_careful_memcpy(this->fPoints, ref.fPoints, ref.fPointCnt * sizeof(SkPoint));
fConicWeights = ref.fConicWeights;
fBoundsIsDirty = ref.fBoundsIsDirty;
if (!fBoundsIsDirty) {
fBounds = ref.fBounds;
fIsFinite = ref.fIsFinite;
}
fSegmentMask = ref.fSegmentMask;
fIsOval = ref.fIsOval;
fIsRRect = ref.fIsRRect;
fRRectOrOvalIsCCW = ref.fRRectOrOvalIsCCW;
fRRectOrOvalStartIdx = ref.fRRectOrOvalStartIdx;
SkDEBUGCODE(this->validate();)
}
unsigned SkPathRef::computeSegmentMask() const {
const uint8_t* verbs = this->verbsMemBegin();
unsigned mask = 0;
for (int i = this->countVerbs() - 1; i >= 0; --i) {
switch (verbs[i]) {
case SkPath::kLine_Verb: mask |= SkPath::kLine_SegmentMask; break;
case SkPath::kQuad_Verb: mask |= SkPath::kQuad_SegmentMask; break;
case SkPath::kConic_Verb: mask |= SkPath::kConic_SegmentMask; break;
case SkPath::kCubic_Verb: mask |= SkPath::kCubic_SegmentMask; break;
default: break;
}
}
return mask;
}
void SkPathRef::interpolate(const SkPathRef& ending, SkScalar weight, SkPathRef* out) const {
const SkScalar* inValues = &ending.getPoints()->fX;
SkScalar* outValues = &out->getPoints()->fX;
int count = out->countPoints() * 2;
for (int index = 0; index < count; ++index) {
outValues[index] = outValues[index] * weight + inValues[index] * (1 - weight);
}
out->fBoundsIsDirty = true;
out->fIsOval = false;
out->fIsRRect = false;
}
SkPoint* SkPathRef::growForRepeatedVerb(int /*SkPath::Verb*/ verb,
int numVbs,
SkScalar** weights) {
// This value is just made-up for now. When count is 4, calling memset was much
// slower than just writing the loop. This seems odd, and hopefully in the
// future this will appear to have been a fluke...
static const unsigned int kMIN_COUNT_FOR_MEMSET_TO_BE_FAST = 16;
SkDEBUGCODE(this->validate();)
int pCnt;
switch (verb) {
case SkPath::kMove_Verb:
pCnt = numVbs;
break;
case SkPath::kLine_Verb:
fSegmentMask |= SkPath::kLine_SegmentMask;
pCnt = numVbs;
break;
case SkPath::kQuad_Verb:
fSegmentMask |= SkPath::kQuad_SegmentMask;
pCnt = 2 * numVbs;
break;
case SkPath::kConic_Verb:
fSegmentMask |= SkPath::kConic_SegmentMask;
pCnt = 2 * numVbs;
break;
case SkPath::kCubic_Verb:
fSegmentMask |= SkPath::kCubic_SegmentMask;
pCnt = 3 * numVbs;
break;
case SkPath::kClose_Verb:
SkDEBUGFAIL("growForRepeatedVerb called for kClose_Verb");
pCnt = 0;
break;
case SkPath::kDone_Verb:
SkDEBUGFAIL("growForRepeatedVerb called for kDone");
// fall through
default:
SkDEBUGFAIL("default should not be reached");
pCnt = 0;
}
size_t space = numVbs * sizeof(uint8_t) + pCnt * sizeof (SkPoint);
this->makeSpace(space);
SkPoint* ret = fPoints + fPointCnt;
uint8_t* vb = fVerbs - fVerbCnt;
// cast to unsigned, so if kMIN_COUNT_FOR_MEMSET_TO_BE_FAST is defined to
// be 0, the compiler will remove the test/branch entirely.
if ((unsigned)numVbs >= kMIN_COUNT_FOR_MEMSET_TO_BE_FAST) {
memset(vb - numVbs, verb, numVbs);
} else {
for (int i = 0; i < numVbs; ++i) {
vb[~i] = verb;
}
}
SkSafeMath safe;
fVerbCnt = safe.addInt(fVerbCnt, numVbs);
fPointCnt = safe.addInt(fPointCnt, pCnt);
if (!safe) {
SK_ABORT("cannot grow path");
}
fFreeSpace -= space;
fBoundsIsDirty = true; // this also invalidates fIsFinite
fIsOval = false;
fIsRRect = false;
if (SkPath::kConic_Verb == verb) {
SkASSERT(weights);
*weights = fConicWeights.append(numVbs);
}
SkDEBUGCODE(this->validate();)
return ret;
}
SkPoint* SkPathRef::growForVerb(int /* SkPath::Verb*/ verb, SkScalar weight) {
SkDEBUGCODE(this->validate();)
int pCnt;
unsigned mask = 0;
switch (verb) {
case SkPath::kMove_Verb:
pCnt = 1;
break;
case SkPath::kLine_Verb:
mask = SkPath::kLine_SegmentMask;
pCnt = 1;
break;
case SkPath::kQuad_Verb:
mask = SkPath::kQuad_SegmentMask;
pCnt = 2;
break;
case SkPath::kConic_Verb:
mask = SkPath::kConic_SegmentMask;
pCnt = 2;
break;
case SkPath::kCubic_Verb:
mask = SkPath::kCubic_SegmentMask;
pCnt = 3;
break;
case SkPath::kClose_Verb:
pCnt = 0;
break;
case SkPath::kDone_Verb:
SkDEBUGFAIL("growForVerb called for kDone");
// fall through
default:
SkDEBUGFAIL("default is not reached");
pCnt = 0;
}
SkSafeMath safe;
int newPointCnt = safe.addInt(fPointCnt, pCnt);
int newVerbCnt = safe.addInt(fVerbCnt, 1);
if (!safe) {
SK_ABORT("cannot grow path");
}
size_t space = sizeof(uint8_t) + pCnt * sizeof (SkPoint);
this->makeSpace(space);
this->fVerbs[~fVerbCnt] = verb;
SkPoint* ret = fPoints + fPointCnt;
fVerbCnt = newVerbCnt;
fPointCnt = newPointCnt;
fSegmentMask |= mask;
fFreeSpace -= space;
fBoundsIsDirty = true; // this also invalidates fIsFinite
fIsOval = false;
fIsRRect = false;
if (SkPath::kConic_Verb == verb) {
*fConicWeights.append() = weight;
}
SkDEBUGCODE(this->validate();)
return ret;
}
uint32_t SkPathRef::genID() const {
SkASSERT(fEditorsAttached.load() == 0);
static const uint32_t kMask = (static_cast<int64_t>(1) << SkPathPriv::kPathRefGenIDBitCnt) - 1;
if (fGenerationID == 0) {
if (fPointCnt == 0 && fVerbCnt == 0) {
fGenerationID = kEmptyGenID;
} else {
static std::atomic<uint32_t> nextID{kEmptyGenID + 1};
do {
fGenerationID = nextID.fetch_add(1, std::memory_order_relaxed) & kMask;
} while (fGenerationID == 0 || fGenerationID == kEmptyGenID);
}
}
return fGenerationID;
}
void SkPathRef::addGenIDChangeListener(sk_sp<GenIDChangeListener> listener) {
if (nullptr == listener || this == gEmpty) {
return;
}
SkAutoMutexAcquire lock(fGenIDChangeListenersMutex);
// Clean out any stale listeners before we append the new one.
for (int i = 0; i < fGenIDChangeListeners.count(); ++i) {
if (fGenIDChangeListeners[i]->shouldUnregisterFromPath()) {
fGenIDChangeListeners[i]->unref();
fGenIDChangeListeners.removeShuffle(i--); // No need to preserve the order after i.
}
}
SkASSERT(!listener->shouldUnregisterFromPath());
*fGenIDChangeListeners.append() = listener.release();
}
// we need to be called *before* the genID gets changed or zerod
void SkPathRef::callGenIDChangeListeners() {
SkAutoMutexAcquire lock(fGenIDChangeListenersMutex);
for (GenIDChangeListener* listener : fGenIDChangeListeners) {
if (!listener->shouldUnregisterFromPath()) {
listener->onChange();
}
// Listeners get at most one shot, so whether these triggered or not, blow them away.
listener->unref();
}
fGenIDChangeListeners.reset();
}
SkRRect SkPathRef::getRRect() const {
const SkRect& bounds = this->getBounds();
SkVector radii[4] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
Iter iter(*this);
SkPoint pts[4];
uint8_t verb = iter.next(pts);
SkASSERT(SkPath::kMove_Verb == verb);
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
if (SkPath::kConic_Verb == verb) {
SkVector v1_0 = pts[1] - pts[0];
SkVector v2_1 = pts[2] - pts[1];
SkVector dxdy;
if (v1_0.fX) {
SkASSERT(!v2_1.fX && !v1_0.fY);
dxdy.set(SkScalarAbs(v1_0.fX), SkScalarAbs(v2_1.fY));
} else if (!v1_0.fY) {
SkASSERT(!v2_1.fX || !v2_1.fY);
dxdy.set(SkScalarAbs(v2_1.fX), SkScalarAbs(v2_1.fY));
} else {
SkASSERT(!v2_1.fY);
dxdy.set(SkScalarAbs(v2_1.fX), SkScalarAbs(v1_0.fY));
}
SkRRect::Corner corner =
pts[1].fX == bounds.fLeft ?
pts[1].fY == bounds.fTop ?
SkRRect::kUpperLeft_Corner : SkRRect::kLowerLeft_Corner :
pts[1].fY == bounds.fTop ?
SkRRect::kUpperRight_Corner : SkRRect::kLowerRight_Corner;
SkASSERT(!radii[corner].fX && !radii[corner].fY);
radii[corner] = dxdy;
} else {
SkASSERT((verb == SkPath::kLine_Verb
&& (!(pts[1].fX - pts[0].fX) || !(pts[1].fY - pts[0].fY)))
|| verb == SkPath::kClose_Verb);
}
}
SkRRect rrect;
rrect.setRectRadii(bounds, radii);
return rrect;
}
///////////////////////////////////////////////////////////////////////////////
SkPathRef::Iter::Iter() {
#ifdef SK_DEBUG
fPts = nullptr;
fConicWeights = nullptr;
#endif
// need to init enough to make next() harmlessly return kDone_Verb
fVerbs = nullptr;
fVerbStop = nullptr;
}
SkPathRef::Iter::Iter(const SkPathRef& path) {
this->setPathRef(path);
}
void SkPathRef::Iter::setPathRef(const SkPathRef& path) {
fPts = path.points();
fVerbs = path.verbs();
fVerbStop = path.verbsMemBegin();
fConicWeights = path.conicWeights();
if (fConicWeights) {
fConicWeights -= 1; // begin one behind
}
// Don't allow iteration through non-finite points.
if (!path.isFinite()) {
fVerbStop = fVerbs;
}
}
uint8_t SkPathRef::Iter::next(SkPoint pts[4]) {
SkASSERT(pts);
if (fVerbs == fVerbStop) {
return (uint8_t) SkPath::kDone_Verb;
}
// fVerbs points one beyond next verb so decrement first.
unsigned verb = *(--fVerbs);
const SkPoint* srcPts = fPts;
switch (verb) {
case SkPath::kMove_Verb:
pts[0] = srcPts[0];
srcPts += 1;
break;
case SkPath::kLine_Verb:
pts[0] = srcPts[-1];
pts[1] = srcPts[0];
srcPts += 1;
break;
case SkPath::kConic_Verb:
fConicWeights += 1;
// fall-through
case SkPath::kQuad_Verb:
pts[0] = srcPts[-1];
pts[1] = srcPts[0];
pts[2] = srcPts[1];
srcPts += 2;
break;
case SkPath::kCubic_Verb:
pts[0] = srcPts[-1];
pts[1] = srcPts[0];
pts[2] = srcPts[1];
pts[3] = srcPts[2];
srcPts += 3;
break;
case SkPath::kClose_Verb:
break;
case SkPath::kDone_Verb:
SkASSERT(fVerbs == fVerbStop);
break;
}
fPts = srcPts;
return (uint8_t) verb;
}
uint8_t SkPathRef::Iter::peek() const {
const uint8_t* next = fVerbs - 1;
return next <= fVerbStop ? (uint8_t) SkPath::kDone_Verb : *next;
}
bool SkPathRef::isValid() const {
if (static_cast<ptrdiff_t>(fFreeSpace) < 0) {
return false;
}
if (reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) < 0) {
return false;
}
if ((nullptr == fPoints) != (nullptr == fVerbs)) {
return false;
}
if (nullptr == fPoints && 0 != fFreeSpace) {
return false;
}
if (nullptr == fPoints && fPointCnt) {
return false;
}
if (nullptr == fVerbs && fVerbCnt) {
return false;
}
if (this->currSize() !=
fFreeSpace + sizeof(SkPoint) * fPointCnt + sizeof(uint8_t) * fVerbCnt) {
return false;
}
if (fIsOval || fIsRRect) {
// Currently we don't allow both of these to be set, even though ovals are ro
if (fIsOval == fIsRRect) {
return false;
}
if (fIsOval) {
if (fRRectOrOvalStartIdx >= 4) {
return false;
}
} else {
if (fRRectOrOvalStartIdx >= 8) {
return false;
}
}
}
if (!fBoundsIsDirty && !fBounds.isEmpty()) {
bool isFinite = true;
Sk2s leftTop = Sk2s(fBounds.fLeft, fBounds.fTop);
Sk2s rightBot = Sk2s(fBounds.fRight, fBounds.fBottom);
for (int i = 0; i < fPointCnt; ++i) {
Sk2s point = Sk2s(fPoints[i].fX, fPoints[i].fY);
#ifdef SK_DEBUG
if (fPoints[i].isFinite() &&
((point < leftTop).anyTrue() || (point > rightBot).anyTrue())) {
SkDebugf("bad SkPathRef bounds: %g %g %g %g\n",
fBounds.fLeft, fBounds.fTop, fBounds.fRight, fBounds.fBottom);
for (int j = 0; j < fPointCnt; ++j) {
if (i == j) {
SkDebugf("*** bounds do not contain: ");
}
SkDebugf("%g %g\n", fPoints[j].fX, fPoints[j].fY);
}
return false;
}
#endif
if (fPoints[i].isFinite() && (point < leftTop).anyTrue() && !(point > rightBot).anyTrue())
return false;
if (!fPoints[i].isFinite()) {
isFinite = false;
}
}
if (SkToBool(fIsFinite) != isFinite) {
return false;
}
}
return true;
}