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
28class SkBitmap;
29class SkImage;
30
31#if defined(SK_DEBUG) && defined(SK_BUILD_FOR_MAC)
32    #define DEBUG_NON_DETERMINISTIC_ASSERT
33#endif
34
35class SkReadBuffer {
36public:
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     */
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. */
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
86    void setFlags(uint32_t flags) { fFlags = flags; }
87    uint32_t getFlags() const { return fFlags; }
88
89    bool isCrossProcess() const {
90        return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
91    }
92    bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
93    bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
94    bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
95
96    SkReader32* getReader32() { return &fReader; }
97
98    size_t size() { return fReader.size(); }
99    size_t offset() { return fReader.offset(); }
100    bool eof() { return fReader.eof(); }
101    virtual const void* skip(size_t size) { return fReader.skip(size); }
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);
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);
126    void readPaint(SkPaint* paint) { paint->unflatten(*this); }
127
128    virtual SkFlattenable* readFlattenable(SkFlattenable::Type);
129    template <typename T> T* readFlattenable() {
130        return (T*) this->readFlattenable(T::GetFlattenableType());
131    }
132    SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
133    SkDrawLooper*  readDrawLooper()  { return this->readFlattenable<SkDrawLooper>(); }
134    SkImageFilter* readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
135    SkMaskFilter*  readMaskFilter()  { return this->readFlattenable<SkMaskFilter>(); }
136    SkPathEffect*  readPathEffect()  { return this->readFlattenable<SkPathEffect>(); }
137    SkRasterizer*  readRasterizer()  { return this->readFlattenable<SkRasterizer>(); }
138    SkShader*      readShader()      { return this->readFlattenable<SkShader>(); }
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
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
177    void setBitmapStorage(SkBitmapHeapReader* bitmapStorage) {
178        SkRefCnt_SafeAssign(fBitmapStorage, bitmapStorage);
179    }
180
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     */
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     */
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     */
212    void setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder) {
213        fBitmapDecoder = bitmapDecoder;
214    }
215
216    // Default impelementations don't check anything.
217    virtual bool validate(bool isValid) { return true; }
218    virtual bool isValid() const { return true; }
219    virtual bool validateAvailable(size_t size) { return true; }
220
221protected:
222    SkReader32 fReader;
223
224private:
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