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()); }
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> SkEmbossMaskFilter::CreateProc(SkReadBuffer& buffer) { Light light; if (buffer.readByteArray(&light, sizeof(Light))) { light.fPad = 0; // for the font-cache lookup to be clean const SkScalar sigma = buffer.readScalar(); return Make(sigma, light); } return nullptr; }
bool SkPicture::InternalOnly_BufferIsSKP(SkReadBuffer& buffer, SkPictInfo* pInfo) { // Check magic bytes. SkPictInfo info; SkASSERT(sizeof(kMagic) == sizeof(info.fMagic)); if (!buffer.readByteArray(&info, sizeof(info)) || !IsValidPictInfo(info)) { return false; } if (pInfo != NULL) { *pInfo = info; } return true; }
bool SkPicture::InternalOnly_BufferIsSKP(SkReadBuffer& buffer, SkPictInfo* pInfo) { // Check magic bytes. char magic[sizeof(kMagic)]; if (!buffer.readByteArray(magic, sizeof(kMagic)) || (0 != memcmp(magic, kMagic, sizeof(kMagic)))) { return false; } SkPictInfo info; if (!buffer.readByteArray(&info, sizeof(SkPictInfo))) { return false; } if (info.fVersion < MIN_PICTURE_VERSION || info.fVersion > CURRENT_PICTURE_VERSION) { return false; } if (pInfo != NULL) { *pInfo = info; } return true; }
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()); }
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); }
static bool Read(SkReadBuffer& reader, unsigned char* data, uint32_t arraySize) { return reader.readByteArray(data, arraySize); }
SkTableMaskFilter::SkTableMaskFilter(SkReadBuffer& rb) : INHERITED(rb) { SkASSERT(256 == rb.getArrayCount()); rb.readByteArray(fTable, 256); }