Home | History | Annotate | Download | only in core 
      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 "SkColorFilter.h"
     12 #include "SkData.h"
     13 #include "SkDrawLooper.h"
     14 #include "SkImageFilter.h"
     15 #include "SkMaskFilter.h"
     16 #include "SkPath.h"
     17 #include "SkPathEffect.h"
     18 #include "SkPicture.h"
     19 #include "SkRasterizer.h"
     20 #include "SkReadBuffer.h"
     21 #include "SkReader32.h"
     22 #include "SkRefCnt.h"
     23 #include "SkShader.h"
     24 #include "SkTHash.h"
     25 #include "SkWriteBuffer.h"
     26 #include "SkXfermodePriv.h"
     27 
     28 class SkBitmap;
     29 class SkImage;
     30 class SkInflator;
     31 
     32 #if defined(SK_DEBUG) && defined(SK_BUILD_FOR_MAC)
     33     #define DEBUG_NON_DETERMINISTIC_ASSERT
     34 #endif
     35 
     36 class SkReadBuffer {
     37 public:
     38     SkReadBuffer();
     39     SkReadBuffer(const void* data, size_t size);
     40     SkReadBuffer(SkStream* stream);
     41     virtual ~SkReadBuffer();
     42 
     43     virtual SkReadBuffer* clone(const void* data, size_t size) const {
     44         return new SkReadBuffer(data, size);
     45     }
     46 
     47     enum Version {
     48         /*
     49         kFilterLevelIsEnum_Version         = 23,
     50         kGradientFlippedFlag_Version       = 24,
     51         kDashWritesPhaseIntervals_Version  = 25,
     52         kColorShaderNoBool_Version         = 26,
     53         kNoUnitMappers_Version             = 27,
     54         kNoMoreBitmapFlatten_Version       = 28,
     55         kSimplifyLocalMatrix_Version       = 30,
     56         kImageFilterUniqueID_Version       = 31,
     57         kRemoveAndroidPaintOpts_Version    = 32,
     58         kFlattenCreateProc_Version         = 33,
     59         */
     60         kRemoveColorTableAlpha_Version     = 36,
     61         kDropShadowMode_Version            = 37,
     62         kPictureImageFilterResolution_Version = 38,
     63         kPictureImageFilterLevel_Version   = 39,
     64         kImageFilterNoUniqueID_Version     = 40,
     65         kBitmapSourceFilterQuality_Version = 41,
     66         kPictureShaderHasPictureBool_Version = 42,
     67         kHasDrawImageOpCodes_Version       = 43,
     68         kAnnotationsMovedToCanvas_Version  = 44,
     69         kLightingShaderWritesInvNormRotation = 45,
     70         kBlurMaskFilterWritesOccluder      = 47,
     71         kGradientShaderFloatColor_Version  = 49,
     72         kXfermodeToBlendMode_Version       = 50,
     73         kXfermodeToBlendMode2_Version      = 51,
     74         kTextBlobImplicitRunCount_Version  = 52,
     75     };
     76 
     77     /**
     78      *  Returns true IFF the version is older than the specified version.
     79      */
     80     bool isVersionLT(Version targetVersion) const {
     81         SkASSERT(targetVersion > 0);
     82         return fVersion > 0 && fVersion < targetVersion;
     83     }
     84 
     85     uint32_t getVersion() const { return fVersion; }
     86 
     87     /** This may be called at most once; most clients of SkReadBuffer should not mess with it. */
     88     void setVersion(int version) {
     89         SkASSERT(0 == fVersion || version == fVersion);
     90         fVersion = version;
     91     }
     92 
     93     enum Flags {
     94         kCrossProcess_Flag  = 1 << 0,
     95         kScalarIsFloat_Flag = 1 << 1,
     96         kPtrIs64Bit_Flag    = 1 << 2,
     97         kValidation_Flag    = 1 << 3,
     98     };
     99 
    100     void setFlags(uint32_t flags) { fFlags = flags; }
    101     uint32_t getFlags() const { return fFlags; }
    102 
    103     bool isCrossProcess() const {
    104         return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
    105     }
    106     bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
    107     bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
    108     bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
    109 
    110     size_t size() { return fReader.size(); }
    111     size_t offset() { return fReader.offset(); }
    112     bool eof() { return fReader.eof(); }
    113     virtual const void* skip(size_t size) { return fReader.skip(size); }
    114 
    115     // primitives
    116     virtual bool readBool();
    117     virtual SkColor readColor();
    118     virtual int32_t readInt();
    119     virtual SkScalar readScalar();
    120     virtual uint32_t readUInt();
    121     virtual int32_t read32();
    122 
    123     // peek
    124     virtual uint8_t peekByte();
    125 
    126     // strings -- the caller is responsible for freeing the string contents
    127     virtual void readString(SkString* string);
    128 
    129     // common data structures
    130     virtual void readColor4f(SkColor4f* color);
    131     virtual void readPoint(SkPoint* point);
    132     SkPoint readPoint() { SkPoint p; this->readPoint(&p); return p; }
    133     virtual void readMatrix(SkMatrix* matrix);
    134     virtual void readIRect(SkIRect* rect);
    135     virtual void readRect(SkRect* rect);
    136     virtual void readRRect(SkRRect* rrect);
    137     virtual void readRegion(SkRegion* region);
    138 
    139     virtual void readPath(SkPath* path);
    140     virtual void readPaint(SkPaint* paint) { paint->unflatten(*this); }
    141 
    142     virtual SkFlattenable* readFlattenable(SkFlattenable::Type);
    143     template <typename T> sk_sp<T> readFlattenable() {
    144         return sk_sp<T>((T*)this->readFlattenable(T::GetFlattenableType()));
    145     }
    146     sk_sp<SkColorFilter> readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
    147     sk_sp<SkDrawLooper> readDrawLooper() { return this->readFlattenable<SkDrawLooper>(); }
    148     sk_sp<SkImageFilter> readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
    149     sk_sp<SkMaskFilter> readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); }
    150     sk_sp<SkPathEffect> readPathEffect() { return this->readFlattenable<SkPathEffect>(); }
    151     sk_sp<SkRasterizer> readRasterizer() { return this->readFlattenable<SkRasterizer>(); }
    152     sk_sp<SkShader> readShader() { return this->readFlattenable<SkShader>(); }
    153     sk_sp<SkXfermode> readXfermode() { return this->readFlattenable<SkXfermode>(); }
    154 
    155     // binary data and arrays
    156     virtual bool readByteArray(void* value, size_t size);
    157     virtual bool readColorArray(SkColor* colors, size_t size);
    158     virtual bool readColor4fArray(SkColor4f* colors, size_t size);
    159     virtual bool readIntArray(int32_t* values, size_t size);
    160     virtual bool readPointArray(SkPoint* points, size_t size);
    161     virtual bool readScalarArray(SkScalar* values, size_t size);
    162 
    163     sk_sp<SkData> readByteArrayAsData() {
    164         size_t len = this->getArrayCount();
    165         if (!this->validateAvailable(len)) {
    166             return SkData::MakeEmpty();
    167         }
    168         void* buffer = sk_malloc_throw(len);
    169         this->readByteArray(buffer, len);
    170         return SkData::MakeFromMalloc(buffer, len);
    171     }
    172 
    173     // helpers to get info about arrays and binary data
    174     virtual uint32_t getArrayCount();
    175 
    176     sk_sp<SkImage> readBitmapAsImage();
    177     sk_sp<SkImage> readImage();
    178     virtual sk_sp<SkTypeface> readTypeface();
    179 
    180     void setTypefaceArray(SkTypeface* array[], int count) {
    181         fTFArray = array;
    182         fTFCount = count;
    183     }
    184 
    185     /**
    186      *  Call this with a pre-loaded array of Factories, in the same order as
    187      *  were created/written by the writer. SkPicture uses this.
    188      */
    189     void setFactoryPlayback(SkFlattenable::Factory array[], int count) {
    190         fFactoryArray = array;
    191         fFactoryCount = count;
    192     }
    193 
    194     /**
    195      *  For an input flattenable (specified by name), set a custom factory proc
    196      *  to use when unflattening.  Will make a copy of |name|.
    197      *
    198      *  If the global registry already has a default factory for the flattenable,
    199      *  this will override that factory.  If a custom factory has already been
    200      *  set for the flattenable, this will override that factory.
    201      *
    202      *  Custom factories can be removed by calling setCustomFactory("...", nullptr).
    203      */
    204     void setCustomFactory(const SkString& name, SkFlattenable::Factory factory) {
    205         fCustomFactory.set(name, factory);
    206     }
    207 
    208     // If nullptr is passed, then the default deserializer will be used
    209     // which calls SkImage::MakeFromEncoded()
    210     void setImageDeserializer(SkImageDeserializer* factory);
    211 
    212     // Default impelementations don't check anything.
    213     virtual bool validate(bool isValid) { return isValid; }
    214     virtual bool isValid() const { return true; }
    215     virtual bool validateAvailable(size_t size) { return true; }
    216     bool validateIndex(int index, int count) {
    217         return this->validate(index >= 0 && index < count);
    218     }
    219 
    220     SkInflator* getInflator() const { return fInflator; }
    221     void setInflator(SkInflator* inf) { fInflator = inf; }
    222 
    223 //    sk_sp<SkImage> inflateImage();
    224 
    225 protected:
    226     /**
    227      *  Allows subclass to check if we are using factories for expansion
    228      *  of flattenables.
    229      */
    230     int factoryCount() { return fFactoryCount; }
    231 
    232     /**
    233      *  Checks if a custom factory has been set for a given flattenable.
    234      *  Returns the custom factory if it exists, or nullptr otherwise.
    235      */
    236     SkFlattenable::Factory getCustomFactory(const SkString& name) {
    237         SkFlattenable::Factory* factoryPtr = fCustomFactory.find(name);
    238         return factoryPtr ? *factoryPtr : nullptr;
    239     }
    240 
    241     SkReader32 fReader;
    242 
    243     // Only used if we do not have an fFactoryArray.
    244     SkTHashMap<uint32_t, SkString> fFlattenableDict;
    245 
    246 private:
    247     bool readArray(void* value, size_t size, size_t elementSize);
    248 
    249     uint32_t fFlags;
    250     int fVersion;
    251 
    252     void* fMemoryPtr;
    253 
    254     SkTypeface** fTFArray;
    255     int        fTFCount;
    256 
    257     SkFlattenable::Factory* fFactoryArray;
    258     int                     fFactoryCount;
    259 
    260     // Only used if we do not have an fFactoryArray.
    261     SkTHashMap<SkString, SkFlattenable::Factory> fCustomFactory;
    262 
    263     // We do not own this ptr, we just use it (guaranteed to never be null)
    264     SkImageDeserializer* fImageDeserializer;
    265 
    266 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
    267     // Debugging counter to keep track of how many bitmaps we
    268     // have decoded.
    269     int fDecodedBitmapIndex;
    270 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
    271 
    272     SkInflator* fInflator = nullptr;
    273 };
    274 
    275 #endif // SkReadBuffer_DEFINED
    276