bool SkGradientShaderBase::DescriptorScope::unflatten(SkReadBuffer& buffer) {
fCount = buffer.getArrayCount();
if (fCount > kStorageCount) {
size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar)) * fCount;
fDynamicStorage.reset(allocSize);
fColors = (SkColor*)fDynamicStorage.get();
fPos = (SkScalar*)(fColors + fCount);
} else {
fColors = fColorStorage;
fPos = fPosStorage;
}
if (!buffer.readColorArray(const_cast<SkColor*>(fColors), fCount)) {
return false;
}
if (buffer.readBool()) {
if (!buffer.readScalarArray(const_cast<SkScalar*>(fPos), fCount)) {
return false;
}
} else {
fPos = nullptr;
}
fTileMode = (SkShader::TileMode)buffer.read32();
fGradFlags = buffer.read32();
if (buffer.readBool()) {
fLocalMatrix = &fLocalMatrixStorage;
buffer.readMatrix(&fLocalMatrixStorage);
} else {
fLocalMatrix = nullptr;
}
return buffer.isValid();
}
sk_sp<SkFlattenable> SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) {
sk_sp<SkPicture> picture;
SkRect cropRect;
if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) {
buffer.validate(!buffer.readBool());
} else {
if (buffer.readBool()) {
picture = SkPicture::MakeFromBuffer(buffer);
}
}
buffer.readRect(&cropRect);
PictureResolution pictureResolution;
if (buffer.isVersionLT(SkReadBuffer::kPictureImageFilterResolution_Version)) {
pictureResolution = kDeviceSpace_PictureResolution;
} else {
pictureResolution = (PictureResolution)buffer.readInt();
}
if (kLocalSpace_PictureResolution == pictureResolution) {
//filterLevel is only serialized if pictureResolution is LocalSpace
SkFilterQuality filterQuality;
if (buffer.isVersionLT(SkReadBuffer::kPictureImageFilterLevel_Version)) {
filterQuality = kLow_SkFilterQuality;
} else {
filterQuality = (SkFilterQuality)buffer.readInt();
}
return MakeForLocalSpace(picture, cropRect, filterQuality);
}
return Make(picture, cropRect);
}
SkPictureImageFilter::SkPictureImageFilter(SkReadBuffer& buffer)
: INHERITED(0, buffer),
fPicture(NULL) {
if (!buffer.isCrossProcess()) {
if (buffer.readBool()) {
fPicture = SkPicture::CreateFromBuffer(buffer);
}
} else {
buffer.validate(!buffer.readBool());
}
buffer.readRect(&fCropRect);
}
sk_sp<SkFlattenable> SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkISize kernelSize;
kernelSize.fWidth = buffer.readInt();
kernelSize.fHeight = buffer.readInt();
const int count = buffer.getArrayCount();
const int64_t kernelArea = sk_64_mul(kernelSize.width(), kernelSize.height());
if (!buffer.validate(kernelArea == count)) {
return nullptr;
}
SkAutoSTArray<16, SkScalar> kernel(count);
if (!buffer.readScalarArray(kernel.get(), count)) {
return nullptr;
}
SkScalar gain = buffer.readScalar();
SkScalar bias = buffer.readScalar();
SkIPoint kernelOffset;
kernelOffset.fX = buffer.readInt();
kernelOffset.fY = buffer.readInt();
TileMode tileMode = (TileMode)buffer.readInt();
bool convolveAlpha = buffer.readBool();
return Make(kernelSize, kernel.get(), gain, bias, kernelOffset, tileMode,
convolveAlpha, common.getInput(0), &common.cropRect());
}
sk_sp<SkFlattenable> SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
Common common;
if (!common.unflatten(buffer, -1)) {
return nullptr;
}
const int count = common.inputCount();
bool hasModes = buffer.readBool();
if (hasModes) {
SkAutoSTArray<4, SkXfermode::Mode> modes(count);
SkAutoSTArray<4, uint8_t> modes8(count);
if (!buffer.readByteArray(modes8.get(), count)) {
return nullptr;
}
for (int i = 0; i < count; ++i) {
modes[i] = (SkXfermode::Mode)modes8[i];
buffer.validate(SkIsValidMode(modes[i]));
}
if (!buffer.isValid()) {
return nullptr;
}
return Make(common.inputs(), count, modes.get(), &common.cropRect());
}
return Make(common.inputs(), count, nullptr, &common.cropRect());
}
SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
bool useOldPic = buffer.isVersionLT(SkReadBuffer::kDashWritesPhaseIntervals_Version);
if (useOldPic) {
fInitialDashIndex = buffer.readInt();
fInitialDashLength = buffer.readScalar();
fIntervalLength = buffer.readScalar();
buffer.readBool(); // Dummy for old ScalarToFit field
} else {
fPhase = buffer.readScalar();
}
fCount = buffer.getArrayCount();
size_t allocSize = sizeof(SkScalar) * fCount;
if (buffer.validateAvailable(allocSize)) {
fIntervals = (SkScalar*)sk_malloc_throw(allocSize);
buffer.readScalarArray(fIntervals, fCount);
} else {
fIntervals = NULL;
}
if (useOldPic) {
fPhase = 0;
if (fInitialDashLength != -1) { // Signal for bad dash interval
for (int i = 0; i < fInitialDashIndex; ++i) {
fPhase += fIntervals[i];
}
fPhase += fIntervals[fInitialDashIndex] - fInitialDashLength;
}
} else {
this->setInternalMembers(fPhase);
}
}
bool SkImageFilter::Common::unflatten(SkReadBuffer& buffer, int expectedCount) {
const int count = buffer.readInt();
if (!buffer.validate(count >= 0)) {
return false;
}
if (!buffer.validate(expectedCount < 0 || count == expectedCount)) {
return false;
}
this->allocInputs(count);
for (int i = 0; i < count; i++) {
if (buffer.readBool()) {
fInputs[i] = buffer.readImageFilter();
}
if (!buffer.isValid()) {
return false;
}
}
SkRect rect;
buffer.readRect(&rect);
if (!buffer.isValid() || !buffer.validate(SkIsValidRect(rect))) {
return false;
}
uint32_t flags = buffer.readUInt();
fCropRect = CropRect(rect, flags);
if (buffer.isVersionLT(SkReadBuffer::kImageFilterNoUniqueID_Version)) {
(void) buffer.readUInt();
}
return buffer.isValid();
}
bool SkImageFilter::Common::unflatten(SkReadBuffer& buffer, int expectedCount) {
int count = buffer.readInt();
if (expectedCount < 0) { // means the caller doesn't care how many
expectedCount = count;
}
if (!buffer.validate((count == expectedCount) && (count >= 0))) {
return false;
}
this->allocInputs(count);
for (int i = 0; i < count; i++) {
if (buffer.readBool()) {
fInputs[i] = buffer.readImageFilter();
}
if (!buffer.isValid()) {
return false;
}
}
SkRect rect;
buffer.readRect(&rect);
if (!buffer.isValid() || !buffer.validate(SkIsValidRect(rect))) {
return false;
}
uint32_t flags = buffer.readUInt();
fCropRect = CropRect(rect, flags);
return buffer.isValid();
}
sk_sp<SkFlattenable> SkColor4Shader::CreateProc(SkReadBuffer& buffer) {
SkColor4f color;
buffer.readColor4f(&color);
if (buffer.readBool()) {
// TODO how do we unflatten colorspaces
}
return SkShader::MakeColorShader(color, nullptr);
}
sk_sp<SkPicture> SkPicture::MakeFromBuffer(SkReadBuffer& buffer) {
SkPictInfo info;
if (!InternalOnly_BufferIsSKP(&buffer, &info) || !buffer.readBool()) {
return nullptr;
}
SkAutoTDelete<SkPictureData> data(SkPictureData::CreateFromBuffer(buffer, info));
return Forwardport(info, data, &buffer);
}
SkShader::SkShader(SkReadBuffer& buffer) : INHERITED(buffer) {
inc_shader_counter();
if (buffer.readBool()) {
buffer.readMatrix(&fLocalMatrix);
} else {
fLocalMatrix.reset();
}
}
SkShader::SkShader(SkReadBuffer& buffer)
: INHERITED(buffer) {
if (buffer.readBool()) {
buffer.readMatrix(&fLocalMatrix);
} else {
fLocalMatrix.reset();
}
SkDEBUGCODE(fInSetContext = false;)
}
sk_sp<SkFlattenable> SkColor4Shader::CreateProc(SkReadBuffer& buffer) {
SkColor4f color;
color.fR = buffer.readScalar(); // readFloat()
color.fG = buffer.readScalar();
color.fB = buffer.readScalar();
color.fA = buffer.readScalar();
if (buffer.readBool()) {
// TODO how do we unflatten colorspaces
}
return SkShader::MakeColorShader(color, nullptr);
}
void SkPaintOptionsAndroid::unflatten(SkReadBuffer& buffer) {
fFontVariant = (FontVariant)buffer.readUInt();
SkString tag;
buffer.readString(&tag);
#ifdef SKLANG_OPT
setLanguage(tag);
#else
fLanguage = SkLanguage(tag);
#endif
fUseFontFallbacks = buffer.readBool();
}
SkPixelRef::SkPixelRef(SkReadBuffer& buffer, SkBaseMutex* mutex)
: INHERITED(buffer)
, fInfo(read_info(buffer))
{
this->setMutex(mutex);
fRec.zero();
fLockCount = 0;
fIsImmutable = buffer.readBool();
fGenerationID = buffer.readUInt();
fUniqueGenerationID = false; // Conservatively assuming the original still exists.
fPreLocked = false;
}
SkColorShader::SkColorShader(SkReadBuffer& b) : INHERITED(b) {
// V25_COMPATIBILITY_CODE We had a boolean to make the color shader inherit the paint's
// color. We don't support that any more.
if (b.isVersionLT(SkReadBuffer::kColorShaderNoBool_Version)) {
if (b.readBool()) {
SkDEBUGFAIL("We shouldn't have pictures that recorded the inherited case.");
fColor = SK_ColorWHITE;
return;
}
}
fColor = b.readColor();
}
SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) : INHERITED(buffer) {
fType = (SkPerlinNoiseShader::Type) buffer.readInt();
fBaseFrequencyX = buffer.readScalar();
fBaseFrequencyY = buffer.readScalar();
fNumOctaves = buffer.readInt();
fSeed = buffer.readScalar();
fStitchTiles = buffer.readBool();
fTileSize.fWidth = buffer.readInt();
fTileSize.fHeight = buffer.readInt();
buffer.validate(perlin_noise_type_is_valid(fType) &&
(fNumOctaves >= 0) && (fNumOctaves <= 255) &&
(fStitchTiles != fTileSize.isEmpty()));
}
SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
fInitialDashIndex = buffer.readInt();
fInitialDashLength = buffer.readScalar();
fIntervalLength = buffer.readScalar();
fScaleToFit = buffer.readBool();
fCount = buffer.getArrayCount();
size_t allocSize = sizeof(SkScalar) * fCount;
if (buffer.validateAvailable(allocSize)) {
fIntervals = (SkScalar*)sk_malloc_throw(allocSize);
buffer.readScalarArray(fIntervals, fCount);
} else {
fIntervals = NULL;
}
}
SkMergeImageFilter::SkMergeImageFilter(SkReadBuffer& buffer)
: INHERITED(-1, buffer) {
bool hasModes = buffer.readBool();
if (hasModes) {
this->initAllocModes();
int nbInputs = countInputs();
size_t size = nbInputs * sizeof(fModes[0]);
SkASSERT(buffer.getArrayCount() == size);
if (buffer.validate(buffer.getArrayCount() == size) &&
buffer.readByteArray(fModes, size)) {
for (int i = 0; i < nbInputs; ++i) {
buffer.validate(SkIsValidMode((SkXfermode::Mode)fModes[i]));
}
}
} else {
fModes = 0;
}
}
SkImageRef::SkImageRef(SkReadBuffer& buffer, SkBaseMutex* mutex)
: INHERITED(buffer, mutex), fErrorInDecoding(false) {
fSampleSize = buffer.readInt();
fDoDither = buffer.readBool();
size_t length = buffer.getArrayCount();
if (buffer.validateAvailable(length)) {
fStream = SkNEW_ARGS(SkMemoryStream, (length));
buffer.readByteArray((void*)fStream->getMemoryBase(), length);
} else {
fStream = NULL;
}
fPrev = fNext = NULL;
fFactory = NULL;
// This sets the colortype/alphatype to exactly match our info, so that this
// can get communicated down to the codec.
fBitmap.setInfo(this->info());
}
sk_sp<SkFlattenable> SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
int count = buffer.readInt();
Builder builder;
for (int i = 0; i < count; i++) {
LayerInfo info;
// Legacy "flagsmask" field -- now ignored, remove when we bump version
(void)buffer.readInt();
info.fPaintBits = buffer.readInt();
info.fColorMode = (SkBlendMode)buffer.readInt();
buffer.readPoint(&info.fOffset);
info.fPostTranslate = buffer.readBool();
buffer.readPaint(builder.addLayerOnTop(info));
if (!buffer.isValid()) {
return nullptr;
}
}
return builder.detach();
}
SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer)
: INHERITED(buffer)
, fPhase(0)
, fInitialDashLength(0)
, fInitialDashIndex(0)
, fIntervalLength(0) {
bool useOldPic = buffer.isVersionLT(SkReadBuffer::kDashWritesPhaseIntervals_Version);
if (useOldPic) {
fInitialDashIndex = buffer.readInt();
fInitialDashLength = buffer.readScalar();
fIntervalLength = buffer.readScalar();
buffer.readBool(); // Dummy for old ScalarToFit field
} else {
fPhase = buffer.readScalar();
}
fCount = buffer.getArrayCount();
size_t allocSize = sizeof(SkScalar) * fCount;
if (buffer.validateAvailable(allocSize)) {
fIntervals = (SkScalar*)sk_malloc_throw(allocSize);
buffer.readScalarArray(fIntervals, fCount);
} else {
fIntervals = NULL;
}
if (useOldPic) {
fPhase = 0;
if (fInitialDashLength != -1) { // Signal for bad dash interval
for (int i = 0; i < fInitialDashIndex; ++i) {
fPhase += fIntervals[i];
}
fPhase += fIntervals[fInitialDashIndex] - fInitialDashLength;
}
} else {
// set the internal data members, fPhase should have been between 0 and intervalLength
// when written to buffer so no need to adjust it
SkDashPath::CalcDashParameters(fPhase, fIntervals, fCount,
&fInitialDashLength, &fInitialDashIndex, &fIntervalLength);
}
}
SkMallocPixelRef::SkMallocPixelRef(SkReadBuffer& buffer)
: INHERITED(buffer, NULL)
, fReleaseProc(sk_free_releaseproc)
, fReleaseProcContext(NULL)
{
fRB = buffer.read32();
size_t size = buffer.isValid() ? this->info().getSafeSize(fRB) : 0;
if (buffer.validateAvailable(size)) {
fStorage = sk_malloc_throw(size);
buffer.readByteArray(fStorage, size);
} else {
fStorage = NULL;
}
if (buffer.readBool()) {
fCTable = SkNEW_ARGS(SkColorTable, (buffer));
} else {
fCTable = NULL;
}
this->setPreLocked(fStorage, fRB, fCTable);
}
sk_sp<SkLights> SkLights::MakeFromBuffer(SkReadBuffer& buf) {
Builder builder;
SkColor3f ambColor;
if (!buf.readScalarArray(&ambColor.fX, 3)) {
return nullptr;
}
builder.setAmbientLightColor(ambColor);
int numLights = buf.readInt();
for (int l = 0; l < numLights; ++l) {
bool isPoint = buf.readBool();
SkColor3f color;
if (!buf.readScalarArray(&color.fX, 3)) {
return nullptr;
}
SkVector3 dirOrPos;
if (!buf.readScalarArray(&dirOrPos.fX, 3)) {
return nullptr;
}
if (isPoint) {
SkScalar intensity;
intensity = buf.readScalar();
Light light = Light::MakePoint(color, dirOrPos, intensity);
builder.add(light);
} else {
Light light = Light::MakeDirectional(color, dirOrPos);
builder.add(light);
}
}
return builder.finish();
}
