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(); }
SkEmbossMaskFilter::SkEmbossMaskFilter(SkReadBuffer& buffer) : SkMaskFilter(buffer) { SkASSERT(buffer.getArrayCount() == sizeof(Light)); buffer.readByteArray(&fLight, sizeof(Light)); SkASSERT(fLight.fPad == 0); // for the font-cache lookup to be clean fBlurSigma = buffer.readScalar(); }
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()); }
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); } }
void SkColorTable::Skip(SkReadBuffer& buffer) { const int count = buffer.getArrayCount(); if (count < 0 || count > 256) { buffer.validate(false); } else { buffer.skip(count * sizeof(SkPMColor)); } }
sk_sp<SkFlattenable> SkDashPathEffect::CreateProc(SkReadBuffer& buffer) { const SkScalar phase = buffer.readScalar(); uint32_t count = buffer.getArrayCount(); SkAutoSTArray<32, SkScalar> intervals(count); if (buffer.readScalarArray(intervals.get(), count)) { return Make(intervals.get(), SkToInt(count), phase); } return nullptr; }
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; } }
SkColorTable::SkColorTable(SkReadBuffer& buffer) { if (buffer.isVersionLT(SkReadBuffer::kRemoveColorTableAlpha_Version)) { /*fAlphaType = */buffer.readUInt(); } fCount = buffer.getArrayCount(); size_t allocSize = fCount * sizeof(SkPMColor); SkDEBUGCODE(bool success = false;) if (buffer.validateAvailable(allocSize)) {
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; } }
sk_sp<SkFlattenable> SkDashImpl::CreateProc(SkReadBuffer& buffer) { const SkScalar phase = buffer.readScalar(); uint32_t count = buffer.getArrayCount(); // Don't allocate gigantic buffers if there's not data for them. if (count > buffer.size() / sizeof(SkScalar)) { return nullptr; } SkAutoSTArray<32, SkScalar> intervals(count); if (buffer.readScalarArray(intervals.get(), count)) { return SkDashPathEffect::Make(intervals.get(), SkToInt(count), phase); } return nullptr; }
SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buffer) { if (buffer.isVersionLT(SkReadBuffer::kNoUnitMappers_Version)) { // skip the old SkUnitMapper slot buffer.skipFlattenable(); } int colorCount = fColorCount = buffer.getArrayCount(); if (colorCount > kColorStorageCount) { size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar) + sizeof(Rec)) * colorCount; if (buffer.validateAvailable(allocSize)) { fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(allocSize)); } else { fOrigColors = NULL; colorCount = fColorCount = 0; } } else { fOrigColors = fStorage; } buffer.readColorArray(fOrigColors, colorCount); fOrigPos = (SkScalar*)(fOrigColors + colorCount); { uint32_t packed = buffer.readUInt(); fGradFlags = SkToU8(unpack_flags(packed)); fTileMode = unpack_mode(packed); } fTileProc = gTileProcs[fTileMode]; fRecs = (Rec*)(fOrigPos + colorCount); if (colorCount > 2) { Rec* recs = fRecs; recs[0].fPos = 0; fOrigPos[0] = 0; for (int i = 1; i < colorCount; i++) { recs[i].fPos = buffer.readInt(); recs[i].fScale = buffer.readUInt(); fOrigPos[i] = SkFixedToScalar(recs[i].fPos); } } else { fOrigPos = NULL; } buffer.readMatrix(&fPtsToUnit); this->initCommon(); }
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()); }
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); } }
SkTableMaskFilter::SkTableMaskFilter(SkReadBuffer& rb) : INHERITED(rb) { SkASSERT(256 == rb.getArrayCount()); rb.readByteArray(fTable, 256); }