1 /* 2 * Copyright 2011 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkReadBuffer_DEFINED 9 #define SkReadBuffer_DEFINED 10 11 #include "SkBitmapHeap.h" 12 #include "SkColorFilter.h" 13 #include "SkData.h" 14 #include "SkDrawLooper.h" 15 #include "SkImageFilter.h" 16 #include "SkMaskFilter.h" 17 #include "SkPath.h" 18 #include "SkPathEffect.h" 19 #include "SkPicture.h" 20 #include "SkRasterizer.h" 21 #include "SkReadBuffer.h" 22 #include "SkReader32.h" 23 #include "SkRefCnt.h" 24 #include "SkShader.h" 25 #include "SkWriteBuffer.h" 26 #include "SkXfermode.h" 27 28 class SkBitmap; 29 class SkImage; 30 31 #if defined(SK_DEBUG) && defined(SK_BUILD_FOR_MAC) 32 #define DEBUG_NON_DETERMINISTIC_ASSERT 33 #endif 34 35 class SkReadBuffer { 36 public: 37 SkReadBuffer(); 38 SkReadBuffer(const void* data, size_t size); 39 SkReadBuffer(SkStream* stream); 40 virtual ~SkReadBuffer(); 41 42 enum Version { 43 /* 44 kFilterLevelIsEnum_Version = 23, 45 kGradientFlippedFlag_Version = 24, 46 kDashWritesPhaseIntervals_Version = 25, 47 kColorShaderNoBool_Version = 26, 48 kNoUnitMappers_Version = 27, 49 kNoMoreBitmapFlatten_Version = 28, 50 kSimplifyLocalMatrix_Version = 30, 51 kImageFilterUniqueID_Version = 31, 52 kRemoveAndroidPaintOpts_Version = 32, 53 kFlattenCreateProc_Version = 33, 54 */ 55 kRemoveColorTableAlpha_Version = 36, 56 kDropShadowMode_Version = 37, 57 kPictureImageFilterResolution_Version = 38, 58 kPictureImageFilterLevel_Version = 39, 59 kImageFilterNoUniqueID_Version = 40, 60 kBitmapSourceFilterQuality_Version = 41, 61 kPictureShaderHasPictureBool_Version = 42, 62 kHasDrawImageOpCodes_Version = 43, 63 }; 64 65 /** 66 * Returns true IFF the version is older than the specified version. 67 */ isVersionLT(Version targetVersion)68 bool isVersionLT(Version targetVersion) const { 69 SkASSERT(targetVersion > 0); 70 return fVersion > 0 && fVersion < targetVersion; 71 } 72 73 /** This may be called at most once; most clients of SkReadBuffer should not mess with it. */ setVersion(int version)74 void setVersion(int version) { 75 SkASSERT(0 == fVersion || version == fVersion); 76 fVersion = version; 77 } 78 79 enum Flags { 80 kCrossProcess_Flag = 1 << 0, 81 kScalarIsFloat_Flag = 1 << 1, 82 kPtrIs64Bit_Flag = 1 << 2, 83 kValidation_Flag = 1 << 3, 84 }; 85 setFlags(uint32_t flags)86 void setFlags(uint32_t flags) { fFlags = flags; } getFlags()87 uint32_t getFlags() const { return fFlags; } 88 isCrossProcess()89 bool isCrossProcess() const { 90 return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag); 91 } isScalarFloat()92 bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); } isPtr64Bit()93 bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); } isValidating()94 bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); } 95 getReader32()96 SkReader32* getReader32() { return &fReader; } 97 size()98 size_t size() { return fReader.size(); } offset()99 size_t offset() { return fReader.offset(); } eof()100 bool eof() { return fReader.eof(); } skip(size_t size)101 virtual const void* skip(size_t size) { return fReader.skip(size); } readFunctionPtr()102 void* readFunctionPtr() { return fReader.readPtr(); } 103 104 // primitives 105 virtual bool readBool(); 106 virtual SkColor readColor(); 107 virtual SkFixed readFixed(); 108 virtual int32_t readInt(); 109 virtual SkScalar readScalar(); 110 virtual uint32_t readUInt(); 111 virtual int32_t read32(); 112 113 // strings -- the caller is responsible for freeing the string contents 114 virtual void readString(SkString* string); 115 virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding); 116 117 // common data structures 118 virtual void readPoint(SkPoint* point); readPoint()119 SkPoint readPoint() { SkPoint p; this->readPoint(&p); return p; } 120 virtual void readMatrix(SkMatrix* matrix); 121 virtual void readIRect(SkIRect* rect); 122 virtual void readRect(SkRect* rect); 123 virtual void readRegion(SkRegion* region); 124 125 virtual void readPath(SkPath* path); readPaint(SkPaint * paint)126 void readPaint(SkPaint* paint) { paint->unflatten(*this); } 127 128 virtual SkFlattenable* readFlattenable(SkFlattenable::Type); readFlattenable()129 template <typename T> T* readFlattenable() { 130 return (T*) this->readFlattenable(T::GetFlattenableType()); 131 } readColorFilter()132 SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); } readDrawLooper()133 SkDrawLooper* readDrawLooper() { return this->readFlattenable<SkDrawLooper>(); } readImageFilter()134 SkImageFilter* readImageFilter() { return this->readFlattenable<SkImageFilter>(); } readMaskFilter()135 SkMaskFilter* readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); } readPathEffect()136 SkPathEffect* readPathEffect() { return this->readFlattenable<SkPathEffect>(); } readRasterizer()137 SkRasterizer* readRasterizer() { return this->readFlattenable<SkRasterizer>(); } readShader()138 SkShader* readShader() { return this->readFlattenable<SkShader>(); } readXfermode()139 SkXfermode* readXfermode() { return this->readFlattenable<SkXfermode>(); } 140 141 /** 142 * Like readFlattenable() but explicitly just skips the data that was written for the 143 * flattenable (or the sentinel that there wasn't one). 144 */ 145 virtual void skipFlattenable(); 146 147 // binary data and arrays 148 virtual bool readByteArray(void* value, size_t size); 149 virtual bool readColorArray(SkColor* colors, size_t size); 150 virtual bool readIntArray(int32_t* values, size_t size); 151 virtual bool readPointArray(SkPoint* points, size_t size); 152 virtual bool readScalarArray(SkScalar* values, size_t size); 153 readByteArrayAsData()154 SkData* readByteArrayAsData() { 155 size_t len = this->getArrayCount(); 156 if (!this->validateAvailable(len)) { 157 return SkData::NewEmpty(); 158 } 159 void* buffer = sk_malloc_throw(len); 160 this->readByteArray(buffer, len); 161 return SkData::NewFromMalloc(buffer, len); 162 } 163 164 // helpers to get info about arrays and binary data 165 virtual uint32_t getArrayCount(); 166 167 /** 168 * Returns false if the bitmap could not be completely read. In that case, it will be set 169 * to have width/height, but no pixels. 170 */ 171 bool readBitmap(SkBitmap* bitmap); 172 173 SkImage* readImage(); 174 175 virtual SkTypeface* readTypeface(); 176 setBitmapStorage(SkBitmapHeapReader * bitmapStorage)177 void setBitmapStorage(SkBitmapHeapReader* bitmapStorage) { 178 SkRefCnt_SafeAssign(fBitmapStorage, bitmapStorage); 179 } 180 setTypefaceArray(SkTypeface * array[],int count)181 void setTypefaceArray(SkTypeface* array[], int count) { 182 fTFArray = array; 183 fTFCount = count; 184 } 185 186 /** 187 * Call this with a pre-loaded array of Factories, in the same order as 188 * were created/written by the writer. SkPicture uses this. 189 */ setFactoryPlayback(SkFlattenable::Factory array[],int count)190 void setFactoryPlayback(SkFlattenable::Factory array[], int count) { 191 fFactoryTDArray = nullptr; 192 fFactoryArray = array; 193 fFactoryCount = count; 194 } 195 196 /** 197 * Call this with an initially empty array, so the reader can cache each 198 * factory it sees by name. Used by the pipe code in conjunction with 199 * SkWriteBuffer::setNamedFactoryRecorder. 200 */ setFactoryArray(SkTDArray<SkFlattenable::Factory> * array)201 void setFactoryArray(SkTDArray<SkFlattenable::Factory>* array) { 202 fFactoryTDArray = array; 203 fFactoryArray = nullptr; 204 fFactoryCount = 0; 205 } 206 207 /** 208 * Provide a function to decode an SkBitmap from encoded data. Only used if the writer 209 * encoded the SkBitmap. If the proper decoder cannot be used, a red bitmap with the 210 * appropriate size will be used. 211 */ setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder)212 void setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder) { 213 fBitmapDecoder = bitmapDecoder; 214 } 215 216 // Default impelementations don't check anything. validate(bool isValid)217 virtual bool validate(bool isValid) { return true; } isValid()218 virtual bool isValid() const { return true; } validateAvailable(size_t size)219 virtual bool validateAvailable(size_t size) { return true; } 220 221 protected: 222 SkReader32 fReader; 223 224 private: 225 bool readArray(void* value, size_t size, size_t elementSize); 226 227 uint32_t fFlags; 228 int fVersion; 229 230 void* fMemoryPtr; 231 232 SkBitmapHeapReader* fBitmapStorage; 233 SkTypeface** fTFArray; 234 int fTFCount; 235 236 SkTDArray<SkFlattenable::Factory>* fFactoryTDArray; 237 SkFlattenable::Factory* fFactoryArray; 238 int fFactoryCount; 239 240 SkPicture::InstallPixelRefProc fBitmapDecoder; 241 242 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT 243 // Debugging counter to keep track of how many bitmaps we 244 // have decoded. 245 int fDecodedBitmapIndex; 246 #endif // DEBUG_NON_DETERMINISTIC_ASSERT 247 }; 248 249 #endif // SkReadBuffer_DEFINED 250