/*
|
* Copyright 2018 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "SkBuffer.h"
|
#include "SkData.h"
|
#include "SkMath.h"
|
#include "SkPathPriv.h"
|
#include "SkPathRef.h"
|
#include "SkRRectPriv.h"
|
#include "SkSafeMath.h"
|
#include "SkTo.h"
|
|
#include <cmath>
|
|
enum SerializationOffsets {
|
kType_SerializationShift = 28, // requires 4 bits
|
kDirection_SerializationShift = 26, // requires 2 bits
|
kFillType_SerializationShift = 8, // requires 8 bits
|
// low-8-bits are version
|
kVersion_SerializationMask = 0xFF,
|
};
|
|
enum SerializationVersions {
|
// kPathPrivFirstDirection_Version = 1,
|
kPathPrivLastMoveToIndex_Version = 2,
|
kPathPrivTypeEnumVersion = 3,
|
kJustPublicData_Version = 4, // introduced Feb/2018
|
|
kCurrent_Version = kJustPublicData_Version
|
};
|
|
enum SerializationType {
|
kGeneral = 0,
|
kRRect = 1
|
};
|
|
static unsigned extract_version(uint32_t packed) {
|
return packed & kVersion_SerializationMask;
|
}
|
|
static SkPath::FillType extract_filltype(uint32_t packed) {
|
return static_cast<SkPath::FillType>((packed >> kFillType_SerializationShift) & 0x3);
|
}
|
|
static SerializationType extract_serializationtype(uint32_t packed) {
|
return static_cast<SerializationType>((packed >> kType_SerializationShift) & 0xF);
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
size_t SkPath::writeToMemoryAsRRect(void* storage) const {
|
SkRect oval;
|
SkRRect rrect;
|
bool isCCW;
|
unsigned start;
|
if (fPathRef->isOval(&oval, &isCCW, &start)) {
|
rrect.setOval(oval);
|
// Convert to rrect start indices.
|
start *= 2;
|
} else if (!fPathRef->isRRect(&rrect, &isCCW, &start)) {
|
return 0;
|
}
|
|
// packed header, rrect, start index.
|
const size_t sizeNeeded = sizeof(int32_t) + SkRRect::kSizeInMemory + sizeof(int32_t);
|
if (!storage) {
|
return sizeNeeded;
|
}
|
|
int firstDir = isCCW ? SkPathPriv::kCCW_FirstDirection : SkPathPriv::kCW_FirstDirection;
|
int32_t packed = (fFillType << kFillType_SerializationShift) |
|
(firstDir << kDirection_SerializationShift) |
|
(SerializationType::kRRect << kType_SerializationShift) |
|
kCurrent_Version;
|
|
SkWBuffer buffer(storage);
|
buffer.write32(packed);
|
SkRRectPriv::WriteToBuffer(rrect, &buffer);
|
buffer.write32(SkToS32(start));
|
buffer.padToAlign4();
|
SkASSERT(sizeNeeded == buffer.pos());
|
return buffer.pos();
|
}
|
|
size_t SkPath::writeToMemory(void* storage) const {
|
SkDEBUGCODE(this->validate();)
|
|
if (size_t bytes = this->writeToMemoryAsRRect(storage)) {
|
return bytes;
|
}
|
|
int32_t packed = (fFillType << kFillType_SerializationShift) |
|
(SerializationType::kGeneral << kType_SerializationShift) |
|
kCurrent_Version;
|
|
int32_t pts = fPathRef->countPoints();
|
int32_t cnx = fPathRef->countWeights();
|
int32_t vbs = fPathRef->countVerbs();
|
|
SkSafeMath safe;
|
size_t size = 4 * sizeof(int32_t);
|
size = safe.add(size, safe.mul(pts, sizeof(SkPoint)));
|
size = safe.add(size, safe.mul(cnx, sizeof(SkScalar)));
|
size = safe.add(size, safe.mul(vbs, sizeof(uint8_t)));
|
size = safe.alignUp(size, 4);
|
if (!safe) {
|
return 0;
|
}
|
if (!storage) {
|
return size;
|
}
|
|
SkWBuffer buffer(storage);
|
buffer.write32(packed);
|
buffer.write32(pts);
|
buffer.write32(cnx);
|
buffer.write32(vbs);
|
buffer.write(fPathRef->points(), pts * sizeof(SkPoint));
|
buffer.write(fPathRef->conicWeights(), cnx * sizeof(SkScalar));
|
buffer.write(fPathRef->verbsMemBegin(), vbs * sizeof(uint8_t));
|
buffer.padToAlign4();
|
|
SkASSERT(buffer.pos() == size);
|
return size;
|
}
|
|
sk_sp<SkData> SkPath::serialize() const {
|
size_t size = this->writeToMemory(nullptr);
|
sk_sp<SkData> data = SkData::MakeUninitialized(size);
|
this->writeToMemory(data->writable_data());
|
return data;
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
// reading
|
|
size_t SkPath::readFromMemory(const void* storage, size_t length) {
|
SkRBuffer buffer(storage, length);
|
uint32_t packed;
|
if (!buffer.readU32(&packed)) {
|
return 0;
|
}
|
unsigned version = extract_version(packed);
|
if (version <= kPathPrivTypeEnumVersion) {
|
return this->readFromMemory_LE3(storage, length);
|
}
|
if (version == kJustPublicData_Version) {
|
return this->readFromMemory_EQ4(storage, length);
|
}
|
return 0;
|
}
|
|
size_t SkPath::readAsRRect(const void* storage, size_t length) {
|
SkRBuffer buffer(storage, length);
|
uint32_t packed;
|
if (!buffer.readU32(&packed)) {
|
return 0;
|
}
|
|
SkASSERT(extract_serializationtype(packed) == SerializationType::kRRect);
|
|
uint8_t dir = (packed >> kDirection_SerializationShift) & 0x3;
|
FillType fillType = extract_filltype(packed);
|
|
Direction rrectDir;
|
SkRRect rrect;
|
int32_t start;
|
switch (dir) {
|
case SkPathPriv::kCW_FirstDirection:
|
rrectDir = kCW_Direction;
|
break;
|
case SkPathPriv::kCCW_FirstDirection:
|
rrectDir = kCCW_Direction;
|
break;
|
default:
|
return 0;
|
}
|
if (!SkRRectPriv::ReadFromBuffer(&buffer, &rrect)) {
|
return 0;
|
}
|
if (!buffer.readS32(&start) || start != SkTPin(start, 0, 7)) {
|
return 0;
|
}
|
this->reset();
|
this->addRRect(rrect, rrectDir, SkToUInt(start));
|
this->setFillType(fillType);
|
buffer.skipToAlign4();
|
return buffer.pos();
|
}
|
|
size_t SkPath::readFromMemory_EQ4(const void* storage, size_t length) {
|
SkRBuffer buffer(storage, length);
|
uint32_t packed;
|
if (!buffer.readU32(&packed)) {
|
return 0;
|
}
|
|
SkASSERT(extract_version(packed) == 4);
|
|
switch (extract_serializationtype(packed)) {
|
case SerializationType::kRRect:
|
return this->readAsRRect(storage, length);
|
case SerializationType::kGeneral:
|
break; // fall through
|
default:
|
return 0;
|
}
|
|
int32_t pts, cnx, vbs;
|
if (!buffer.readS32(&pts) || !buffer.readS32(&cnx) || !buffer.readS32(&vbs)) {
|
return 0;
|
}
|
|
const SkPoint* points = buffer.skipCount<SkPoint>(pts);
|
const SkScalar* conics = buffer.skipCount<SkScalar>(cnx);
|
const uint8_t* verbs = buffer.skipCount<uint8_t>(vbs);
|
buffer.skipToAlign4();
|
if (!buffer.isValid()) {
|
return 0;
|
}
|
SkASSERT(buffer.pos() <= length);
|
|
#define CHECK_POINTS_CONICS(p, c) \
|
do { \
|
if (p && ((pts -= p) < 0)) { \
|
return 0; \
|
} \
|
if (c && ((cnx -= c) < 0)) { \
|
return 0; \
|
} \
|
} while (0)
|
|
SkPath tmp;
|
tmp.setFillType(extract_filltype(packed));
|
tmp.incReserve(pts);
|
for (int i = vbs - 1; i >= 0; --i) {
|
switch (verbs[i]) {
|
case kMove_Verb:
|
CHECK_POINTS_CONICS(1, 0);
|
tmp.moveTo(*points++);
|
break;
|
case kLine_Verb:
|
CHECK_POINTS_CONICS(1, 0);
|
tmp.lineTo(*points++);
|
break;
|
case kQuad_Verb:
|
CHECK_POINTS_CONICS(2, 0);
|
tmp.quadTo(points[0], points[1]);
|
points += 2;
|
break;
|
case kConic_Verb:
|
CHECK_POINTS_CONICS(2, 1);
|
tmp.conicTo(points[0], points[1], *conics++);
|
points += 2;
|
break;
|
case kCubic_Verb:
|
CHECK_POINTS_CONICS(3, 0);
|
tmp.cubicTo(points[0], points[1], points[2]);
|
points += 3;
|
break;
|
case kClose_Verb:
|
tmp.close();
|
break;
|
default:
|
return 0; // bad verb
|
}
|
}
|
#undef CHECK_POINTS_CONICS
|
if (pts || cnx) {
|
return 0; // leftover points and/or conics
|
}
|
|
*this = std::move(tmp);
|
return buffer.pos();
|
}
|
|
size_t SkPath::readFromMemory_LE3(const void* storage, size_t length) {
|
SkRBuffer buffer(storage, length);
|
|
int32_t packed;
|
if (!buffer.readS32(&packed)) {
|
return 0;
|
}
|
|
unsigned version = extract_version(packed);
|
SkASSERT(version <= 3);
|
|
FillType fillType = extract_filltype(packed);
|
if (version >= kPathPrivTypeEnumVersion) {
|
switch (extract_serializationtype(packed)) {
|
case SerializationType::kRRect:
|
return this->readAsRRect(storage, length);
|
case SerializationType::kGeneral:
|
// Fall through to general path deserialization
|
break;
|
default:
|
return 0;
|
}
|
}
|
if (version >= kPathPrivLastMoveToIndex_Version && !buffer.readS32(&fLastMoveToIndex)) {
|
return 0;
|
}
|
|
// These are written into the serialized data but we no longer use them in the deserialized
|
// path. If convexity is corrupted it may cause the GPU backend to make incorrect
|
// rendering choices, possibly crashing. We set them to unknown so that they'll be recomputed if
|
// requested.
|
fConvexity = kUnknown_Convexity;
|
fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
|
|
fFillType = fillType;
|
fIsVolatile = 0;
|
SkPathRef* pathRef = SkPathRef::CreateFromBuffer(&buffer);
|
if (!pathRef) {
|
return 0;
|
}
|
|
fPathRef.reset(pathRef);
|
SkDEBUGCODE(this->validate();)
|
buffer.skipToAlign4();
|
return buffer.pos();
|
}
|
