/*
|
* Copyright 2011 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#ifndef SkReadBuffer_DEFINED
|
#define SkReadBuffer_DEFINED
|
|
#include "SkColorFilter.h"
|
#include "SkSerialProcs.h"
|
#include "SkDrawLooper.h"
|
#include "SkFont.h"
|
#include "SkImageFilter.h"
|
#include "SkMaskFilterBase.h"
|
#include "SkPaintPriv.h"
|
#include "SkPath.h"
|
#include "SkPathEffect.h"
|
#include "SkPicture.h"
|
#include "SkReader32.h"
|
#include "SkRefCnt.h"
|
#include "SkShaderBase.h"
|
#include "SkWriteBuffer.h"
|
|
class SkData;
|
class SkImage;
|
|
#ifndef SK_DISABLE_READBUFFER
|
|
class SkReadBuffer {
|
public:
|
SkReadBuffer();
|
SkReadBuffer(const void* data, size_t size);
|
|
enum Version {
|
kTileModeInBlurImageFilter_Version = 56,
|
kTileInfoInSweepGradient_Version = 57,
|
k2PtConicalNoFlip_Version = 58,
|
kRemovePictureImageFilterLocalSpace = 59,
|
kRemoveHeaderFlags_Version = 60,
|
kTwoColorDrawShadow_Version = 61,
|
kDontNegateImageSize_Version = 62,
|
kStoreImageBounds_Version = 63,
|
kRemoveOccluderFromBlurMaskFilter = 64,
|
kFloat4PaintColor_Version = 65,
|
kSaveBehind_Version = 66,
|
kSerializeFonts_Version = 67,
|
kPaintDoesntSerializeFonts_Version = 68,
|
};
|
|
/**
|
* Returns true IFF the version is older than the specified version.
|
*/
|
bool isVersionLT(Version targetVersion) const {
|
SkASSERT(targetVersion > 0);
|
return fVersion > 0 && fVersion < targetVersion;
|
}
|
|
uint32_t getVersion() const { return fVersion; }
|
|
/** This may be called at most once; most clients of SkReadBuffer should not mess with it. */
|
void setVersion(int version) {
|
SkASSERT(0 == fVersion || version == fVersion);
|
fVersion = version;
|
}
|
|
size_t size() const { return fReader.size(); }
|
size_t offset() const { return fReader.offset(); }
|
bool eof() { return fReader.eof(); }
|
const void* skip(size_t size);
|
const void* skip(size_t count, size_t size); // does safe multiply
|
size_t available() const { return fReader.available(); }
|
|
template <typename T> const T* skipT() {
|
return static_cast<const T*>(this->skip(sizeof(T)));
|
}
|
template <typename T> const T* skipT(size_t count) {
|
return static_cast<const T*>(this->skip(count, sizeof(T)));
|
}
|
|
// primitives
|
bool readBool();
|
SkColor readColor();
|
int32_t readInt();
|
SkScalar readScalar();
|
uint32_t readUInt();
|
int32_t read32();
|
|
template <typename T> T read32LE(T max) {
|
uint32_t value = this->readUInt();
|
if (!this->validate(value <= static_cast<uint32_t>(max))) {
|
value = 0;
|
}
|
return static_cast<T>(value);
|
}
|
|
// peek
|
uint8_t peekByte();
|
|
// strings -- the caller is responsible for freeing the string contents
|
void readString(SkString* string);
|
|
// common data structures
|
void readColor4f(SkColor4f* color);
|
void readPoint(SkPoint* point);
|
SkPoint readPoint() { SkPoint p; this->readPoint(&p); return p; }
|
void readPoint3(SkPoint3* point);
|
void readMatrix(SkMatrix* matrix);
|
void readIRect(SkIRect* rect);
|
void readRect(SkRect* rect);
|
void readRRect(SkRRect* rrect);
|
void readRegion(SkRegion* region);
|
|
void readPath(SkPath* path);
|
|
SkReadPaintResult readPaint(SkPaint* paint, SkFont* font) {
|
return SkPaintPriv::Unflatten(paint, *this, font);
|
}
|
|
SkFlattenable* readFlattenable(SkFlattenable::Type);
|
template <typename T> sk_sp<T> readFlattenable() {
|
return sk_sp<T>((T*)this->readFlattenable(T::GetFlattenableType()));
|
}
|
sk_sp<SkColorFilter> readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
|
sk_sp<SkDrawLooper> readDrawLooper() { return this->readFlattenable<SkDrawLooper>(); }
|
sk_sp<SkImageFilter> readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
|
sk_sp<SkMaskFilter> readMaskFilter() { return this->readFlattenable<SkMaskFilterBase>(); }
|
sk_sp<SkPathEffect> readPathEffect() { return this->readFlattenable<SkPathEffect>(); }
|
sk_sp<SkShader> readShader() { return this->readFlattenable<SkShaderBase>(); }
|
|
// Reads SkAlign4(bytes), but will only copy bytes into the buffer.
|
bool readPad32(void* buffer, size_t bytes);
|
|
// binary data and arrays
|
bool readByteArray(void* value, size_t size);
|
bool readColorArray(SkColor* colors, size_t size);
|
bool readColor4fArray(SkColor4f* colors, size_t size);
|
bool readIntArray(int32_t* values, size_t size);
|
bool readPointArray(SkPoint* points, size_t size);
|
bool readScalarArray(SkScalar* values, size_t size);
|
|
sk_sp<SkData> readByteArrayAsData();
|
|
// helpers to get info about arrays and binary data
|
uint32_t getArrayCount();
|
|
// If there is a real error (e.g. data is corrupted) this returns null. If the image cannot
|
// be created (e.g. it was not originally encoded) then this returns an image that doesn't
|
// draw.
|
sk_sp<SkImage> readImage();
|
sk_sp<SkTypeface> readTypeface();
|
|
void setTypefaceArray(sk_sp<SkTypeface> array[], int count) {
|
fTFArray = array;
|
fTFCount = count;
|
}
|
|
/**
|
* Call this with a pre-loaded array of Factories, in the same order as
|
* were created/written by the writer. SkPicture uses this.
|
*/
|
void setFactoryPlayback(SkFlattenable::Factory array[], int count) {
|
fFactoryArray = array;
|
fFactoryCount = count;
|
}
|
|
void setDeserialProcs(const SkDeserialProcs& procs);
|
const SkDeserialProcs& getDeserialProcs() const { return fProcs; }
|
|
/**
|
* If isValid is false, sets the buffer to be "invalid". Returns true if the buffer
|
* is still valid.
|
*/
|
bool validate(bool isValid) {
|
if (!isValid) {
|
this->setInvalid();
|
}
|
return !fError;
|
}
|
|
/**
|
* Helper function to do a preflight check before a large allocation or read.
|
* Returns true if there is enough bytes in the buffer to read n elements of T.
|
* If not, the buffer will be "invalid" and false will be returned.
|
*/
|
template <typename T>
|
bool validateCanReadN(size_t n) {
|
return this->validate(n <= (fReader.available() / sizeof(T)));
|
}
|
|
bool isValid() const { return !fError; }
|
bool validateIndex(int index, int count) {
|
return this->validate(index >= 0 && index < count);
|
}
|
|
// Utilities that mark the buffer invalid if the requested value is out-of-range
|
|
// If the read value is outside of the range, validate(false) is called, and min
|
// is returned, else the value is returned.
|
int32_t checkInt(int min, int max);
|
|
template <typename T> T checkRange(T min, T max) {
|
return static_cast<T>(this->checkInt(static_cast<int32_t>(min),
|
static_cast<int32_t>(max)));
|
}
|
|
SkFilterQuality checkFilterQuality();
|
|
private:
|
void setInvalid();
|
bool readArray(void* value, size_t size, size_t elementSize);
|
void setMemory(const void*, size_t);
|
|
SkReader32 fReader;
|
|
// Only used if we do not have an fFactoryArray.
|
SkTHashMap<uint32_t, SkFlattenable::Factory> fFlattenableDict;
|
|
int fVersion;
|
|
sk_sp<SkTypeface>* fTFArray;
|
int fTFCount;
|
|
SkFlattenable::Factory* fFactoryArray;
|
int fFactoryCount;
|
|
SkDeserialProcs fProcs;
|
|
static bool IsPtrAlign4(const void* ptr) {
|
return SkIsAlign4((uintptr_t)ptr);
|
}
|
|
bool fError = false;
|
};
|
|
#else // #ifndef SK_DISABLE_READBUFFER
|
|
class SkReadBuffer {
|
public:
|
SkReadBuffer() {}
|
SkReadBuffer(const void*, size_t) {}
|
|
enum Version {
|
kTileModeInBlurImageFilter_Version = 56,
|
kTileInfoInSweepGradient_Version = 57,
|
k2PtConicalNoFlip_Version = 58,
|
kRemovePictureImageFilterLocalSpace = 59,
|
kRemoveHeaderFlags_Version = 60,
|
kTwoColorDrawShadow_Version = 61,
|
kDontNegateImageSize_Version = 62,
|
kStoreImageBounds_Version = 63,
|
kRemoveOccluderFromBlurMaskFilter = 64,
|
kFloat4PaintColor_Version = 65,
|
kSaveBehind_Version = 66,
|
kSerializeFonts_Version = 67,
|
kPaintDoesntSerializeFonts_Version = 68,
|
};
|
|
bool isVersionLT(Version) const { return false; }
|
uint32_t getVersion() const { return 0xffffffff; }
|
void setVersion(int) {}
|
|
size_t size() const { return 0; }
|
size_t offset() const { return 0; }
|
bool eof() { return true; }
|
size_t available() const { return 0; }
|
|
const void* skip(size_t) { return nullptr; }
|
const void* skip(size_t, size_t) { return nullptr; }
|
template <typename T> const T* skipT() { return nullptr; }
|
template <typename T> const T* skipT(size_t) { return nullptr; }
|
|
bool readBool() { return 0; }
|
SkColor readColor() { return 0; }
|
int32_t readInt() { return 0; }
|
SkScalar readScalar() { return 0; }
|
uint32_t readUInt() { return 0; }
|
int32_t read32() { return 0; }
|
|
template <typename T> T read32LE(T max) { return max; }
|
|
uint8_t peekByte() { return 0; }
|
|
void readColor4f(SkColor4f* out) { *out = SkColor4f{0,0,0,0}; }
|
void readPoint (SkPoint* out) { *out = SkPoint{0,0}; }
|
void readPoint3 (SkPoint3* out) { *out = SkPoint3{0,0,0}; }
|
void readMatrix (SkMatrix* out) { *out = SkMatrix::I(); }
|
void readIRect (SkIRect* out) { *out = SkIRect{0,0,0,0}; }
|
void readRect (SkRect* out) { *out = SkRect{0,0,0,0}; }
|
void readRRect (SkRRect* out) { *out = SkRRect(); }
|
void readRegion (SkRegion* out) { *out = SkRegion(); }
|
void readString (SkString* out) { *out = SkString(); }
|
void readPath (SkPath* out) { *out = SkPath(); }
|
SkReadPaintResult readPaint (SkPaint* out, SkFont* font) {
|
*out = SkPaint();
|
if (font) {
|
*font = SkFont();
|
}
|
return kFailed_ReadPaint;
|
}
|
|
SkPoint readPoint() { return {0,0}; }
|
|
SkFlattenable* readFlattenable(SkFlattenable::Type) { return nullptr; }
|
|
template <typename T> sk_sp<T> readFlattenable() { return nullptr; }
|
sk_sp<SkColorFilter> readColorFilter() { return nullptr; }
|
sk_sp<SkDrawLooper> readDrawLooper() { return nullptr; }
|
sk_sp<SkImageFilter> readImageFilter() { return nullptr; }
|
sk_sp<SkMaskFilter> readMaskFilter() { return nullptr; }
|
sk_sp<SkPathEffect> readPathEffect() { return nullptr; }
|
sk_sp<SkShader> readShader() { return nullptr; }
|
|
bool readPad32 (void*, size_t) { return false; }
|
bool readByteArray (void*, size_t) { return false; }
|
bool readColorArray (SkColor*, size_t) { return false; }
|
bool readColor4fArray(SkColor4f*, size_t) { return false; }
|
bool readIntArray (int32_t*, size_t) { return false; }
|
bool readPointArray (SkPoint*, size_t) { return false; }
|
bool readScalarArray (SkScalar*, size_t) { return false; }
|
|
sk_sp<SkData> readByteArrayAsData() { return nullptr; }
|
uint32_t getArrayCount() { return 0; }
|
|
sk_sp<SkImage> readImage() { return nullptr; }
|
sk_sp<SkTypeface> readTypeface() { return nullptr; }
|
|
bool validate(bool) { return false; }
|
template <typename T> bool validateCanReadN(size_t) { return false; }
|
bool isValid() const { return false; }
|
bool validateIndex(int, int) { return false; }
|
|
int32_t checkInt(int min, int) { return min; }
|
template <typename T> T checkRange(T min, T) { return min; }
|
|
SkFilterQuality checkFilterQuality() { return SkFilterQuality::kNone_SkFilterQuality; }
|
|
void setTypefaceArray(sk_sp<SkTypeface>[], int) {}
|
void setFactoryPlayback(SkFlattenable::Factory[], int) {}
|
void setDeserialProcs(const SkDeserialProcs&) {}
|
|
const SkDeserialProcs& getDeserialProcs() const {
|
static const SkDeserialProcs procs;
|
return procs;
|
}
|
};
|
|
#endif // #ifndef SK_DISABLE_READBUFFER
|
|
#endif // SkReadBuffer_DEFINED
|
