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> 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> 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); }
SkMorphologyImageFilter::SkMorphologyImageFilter(SkReadBuffer& buffer) : INHERITED(1, buffer) { fRadius.fWidth = buffer.readInt(); fRadius.fHeight = buffer.readInt(); buffer.validate((fRadius.fWidth >= 0) && (fRadius.fHeight >= 0)); }
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()); }
SkModeColorFilter(SkReadBuffer& buffer) { fColor = buffer.readColor(); fMode = (SkXfermode::Mode)buffer.readUInt(); if (buffer.isValid()) { this->updateCache(); buffer.validate(SkIsValidMode(fMode)); } }
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> SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) { int cubeDimension = buffer.readInt(); auto cubeData(buffer.readByteArrayAsData()); if (!buffer.validate(is_valid_3D_lut(cubeData.get(), cubeDimension))) { return nullptr; } return Make(std::move(cubeData), cubeDimension); }
SkBlurImageFilter::SkBlurImageFilter(SkReadBuffer& buffer) : INHERITED(1, buffer) { fSigma.fWidth = buffer.readScalar(); fSigma.fHeight = buffer.readScalar(); buffer.validate(SkScalarIsFinite(fSigma.fWidth) && SkScalarIsFinite(fSigma.fHeight) && (fSigma.fWidth >= 0) && (fSigma.fHeight >= 0)); }
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; } }
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> 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); }
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()); }
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); }
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())); }
SkDownSampleImageFilter::SkDownSampleImageFilter(SkReadBuffer& buffer) : INHERITED(1, buffer) { fScale = buffer.readScalar(); buffer.validate(SkScalarIsFinite(fScale)); }
SkSSE2ProcCoeffXfermode::SkSSE2ProcCoeffXfermode(SkReadBuffer& buffer) : INHERITED(buffer) { fProcSIMD = reinterpret_cast<void*>(gSSE2XfermodeProcs[this->getMode()]); buffer.validate(fProcSIMD != NULL); }
SkOffsetImageFilter::SkOffsetImageFilter(SkReadBuffer& buffer) : INHERITED(1, buffer) { buffer.readPoint(&fOffset); buffer.validate(SkScalarIsFinite(fOffset.fX) && SkScalarIsFinite(fOffset.fY)); }
SkColorCubeFilter::SkColorCubeFilter(SkReadBuffer& buffer) : fCache(buffer.readInt()) { fCubeData.reset(buffer.readByteArrayAsData()); buffer.validate(is_valid_3D_lut(fCubeData, fCache.cubeDimension())); fUniqueID = SkNextColorCubeUniqueID(); }