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 "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      */
     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 
    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