sk_sp<SkFlattenable> SkDisplacementMapEffect::CreateProc(SkReadBuffer& buffer) { SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2); ChannelSelectorType xsel = (ChannelSelectorType)buffer.readInt(); ChannelSelectorType ysel = (ChannelSelectorType)buffer.readInt(); SkScalar scale = buffer.readScalar(); return Make(xsel, ysel, scale, common.getInput(0), common.getInput(1), &common.cropRect()); }
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; }
SkLocalMatrixShader::SkLocalMatrixShader(SkReadBuffer& buffer) : INHERITED(buffer) { if (buffer.isVersionLT(SkReadBuffer::kSimplifyLocalMatrix_Version)) { buffer.readMatrix(&(INHERITED::fLocalMatrix)); } fProxyShader.reset(buffer.readShader()); if (NULL == fProxyShader.get()) { sk_throw(); } }
sk_sp<SkFlattenable> SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) { SkMatrix lm; buffer.readMatrix(&lm); auto baseShader(buffer.readShader()); if (!baseShader) { return nullptr; } return baseShader->makeWithLocalMatrix(lm); }
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)) {
sk_sp<SkFlattenable> SkComposeShader::CreateProc(SkReadBuffer& buffer) { sk_sp<SkShader> shaderA(buffer.readShader()); sk_sp<SkShader> shaderB(buffer.readShader()); sk_sp<SkXfermode> mode(buffer.readXfermode()); if (!shaderA || !shaderB) { return nullptr; } return sk_make_sp<SkComposeShader>(std::move(shaderA), std::move(shaderB), std::move(mode)); }
SkShader::SkShader(SkReadBuffer& buffer) : INHERITED(buffer) { if (buffer.readBool()) { buffer.readMatrix(&fLocalMatrix); } else { fLocalMatrix.reset(); } SkDEBUGCODE(fInSetContext = false;) }
SkDisplacementMapEffect::SkDisplacementMapEffect(SkReadBuffer& buffer) : INHERITED(2, buffer) { fXChannelSelector = (SkDisplacementMapEffect::ChannelSelectorType) buffer.readInt(); fYChannelSelector = (SkDisplacementMapEffect::ChannelSelectorType) buffer.readInt(); fScale = buffer.readScalar(); buffer.validate(channel_selector_type_is_valid(fXChannelSelector) && channel_selector_type_is_valid(fYChannelSelector) && SkScalarIsFinite(fScale)); }
sk_sp<SkFlattenable> SkRadialGradient::CreateProc(SkReadBuffer& buffer) { DescriptorScope desc; if (!desc.unflatten(buffer)) { return nullptr; } const SkPoint center = buffer.readPoint(); const SkScalar radius = buffer.readScalar(); return SkGradientShader::MakeRadial(center, radius, desc.fColors, desc.fPos, desc.fCount, desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix); }
SkBlurDrawLooper::SkBlurDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) { fSigma = buffer.readScalar(); fDx = buffer.readScalar(); fDy = buffer.readScalar(); fBlurColor = buffer.readColor(); fBlurFlags = buffer.readUInt() & kAll_BlurFlag; this->initEffects(); }
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> 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); } }
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); }
sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) { const TileMode tx = (TileMode)buffer.readUInt(); const TileMode ty = (TileMode)buffer.readUInt(); SkMatrix localMatrix; buffer.readMatrix(&localMatrix); sk_sp<SkImage> img = buffer.readImage(); if (!img) { return nullptr; } return SkImageShader::Make(std::move(img), tx, ty, &localMatrix); }
SkComposeShader::SkComposeShader(SkReadBuffer& buffer) : INHERITED(buffer) { fShaderA = buffer.readShader(); if (NULL == fShaderA) { fShaderA = SkNEW_ARGS(SkColorShader, ((SkColor)0)); } fShaderB = buffer.readShader(); if (NULL == fShaderB) { fShaderB = SkNEW_ARGS(SkColorShader, ((SkColor)0)); } fMode = buffer.readXfermode(); }
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); }
sk_sp<SkFlattenable> SkPath1DPathEffect::CreateProc(SkReadBuffer& buffer) { SkScalar advance = buffer.readScalar(); if (advance > 0) { SkPath path; buffer.readPath(&path); SkScalar phase = buffer.readScalar(); Style style = (Style)buffer.readUInt(); return SkPath1DPathEffect::Make(path, advance, phase, style); } return 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(); }
sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) { const TileMode tx = (TileMode)buffer.readUInt(); const TileMode ty = (TileMode)buffer.readUInt(); SkMatrix matrix; buffer.readMatrix(&matrix); SkAutoTUnref<SkImage> img(buffer.readImage()); if (!img) { return nullptr; } return SkImageShader::Make(img, tx, ty, &matrix); }
sk_sp<SkFlattenable> SkComposeShader::CreateProc(SkReadBuffer& buffer) { sk_sp<SkShader> dst(buffer.readShader()); sk_sp<SkShader> src(buffer.readShader()); unsigned mode = buffer.read32(); float lerp = buffer.readScalar(); // check for valid mode before we cast to the enum type if (!buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode)) { return nullptr; } return MakeCompose(std::move(dst), std::move(src), static_cast<SkBlendMode>(mode), lerp); }
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; }
SkDropShadowImageFilter::SkDropShadowImageFilter(SkReadBuffer& buffer) : INHERITED(1, buffer) { fDx = buffer.readScalar(); fDy = buffer.readScalar(); fSigmaX = buffer.readScalar(); fSigmaY = buffer.readScalar(); fColor = buffer.readColor(); buffer.validate(SkScalarIsFinite(fDx) && SkScalarIsFinite(fDy) && SkScalarIsFinite(fSigmaX) && SkScalarIsFinite(fSigmaY)); }
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); }
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(); }
void SkImageInfo::unflatten(SkReadBuffer& buffer) { fWidth = buffer.read32(); fHeight = buffer.read32(); uint32_t packed = buffer.read32(); fColorType = stored_to_live((packed >> 0) & kColorTypeMask); fAlphaType = (SkAlphaType)((packed >> 8) & kAlphaTypeMask); buffer.validate(alpha_type_is_valid(fAlphaType) && color_type_is_valid(fColorType)); sk_sp<SkData> data = buffer.readByteArrayAsData(); fColorSpace = SkColorSpace::Deserialize(data->data(), data->size()); }
sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) { SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); SkScalar dx = buffer.readScalar(); SkScalar dy = buffer.readScalar(); SkScalar sigmaX = buffer.readScalar(); SkScalar sigmaY = buffer.readScalar(); SkColor color = buffer.readColor(); ShadowMode shadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Version) ? kDrawShadowAndForeground_ShadowMode : static_cast<ShadowMode>(buffer.readInt()); return Make(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0), &common.cropRect()); }
sk_sp<SkFlattenable> SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) { SkMatrix lm; buffer.readMatrix(&lm); SkBitmap bm; if (!buffer.readBitmap(&bm)) { return nullptr; } bm.setImmutable(); TileMode mx = (TileMode)buffer.readUInt(); TileMode my = (TileMode)buffer.readUInt(); return SkShader::MakeBitmapShader(bm, mx, my, &lm); }
sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) { SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); SkScalar dx = buffer.readScalar(); SkScalar dy = buffer.readScalar(); SkScalar sigmaX = buffer.readScalar(); SkScalar sigmaY = buffer.readScalar(); SkColor color = buffer.readColor(); ShadowMode shadowMode = buffer.read32LE(kLast_ShadowMode); return Make(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0), &common.cropRect()); }
SkPath1DPathEffect::SkPath1DPathEffect(SkReadBuffer& buffer) { fAdvance = buffer.readScalar(); if (fAdvance > 0) { buffer.readPath(&fPath); fInitialOffset = buffer.readScalar(); fStyle = (Style) buffer.readUInt(); } else { SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n")); // Make Coverity happy. fInitialOffset = 0; fStyle = kStyleCount; } }