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(); }