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