michael@0: 
michael@0: /*
michael@0:  * Copyright 2011 Google Inc.
michael@0:  *
michael@0:  * Use of this source code is governed by a BSD-style license that can be
michael@0:  * found in the LICENSE file.
michael@0:  */
michael@0: 
michael@0: #ifndef SkReadBuffer_DEFINED
michael@0: #define SkReadBuffer_DEFINED
michael@0: 
michael@0: #include "SkBitmapHeap.h"
michael@0: #include "SkColorFilter.h"
michael@0: #include "SkData.h"
michael@0: #include "SkDrawLooper.h"
michael@0: #include "SkImageFilter.h"
michael@0: #include "SkMaskFilter.h"
michael@0: #include "SkPath.h"
michael@0: #include "SkPathEffect.h"
michael@0: #include "SkPicture.h"
michael@0: #include "SkPixelRef.h"
michael@0: #include "SkRasterizer.h"
michael@0: #include "SkReadBuffer.h"
michael@0: #include "SkReader32.h"
michael@0: #include "SkRefCnt.h"
michael@0: #include "SkShader.h"
michael@0: #include "SkUnitMapper.h"
michael@0: #include "SkWriteBuffer.h"
michael@0: #include "SkXfermode.h"
michael@0: 
michael@0: class SkBitmap;
michael@0: 
michael@0: #if defined(SK_DEBUG) && defined(SK_BUILD_FOR_MAC)
michael@0:     #define DEBUG_NON_DETERMINISTIC_ASSERT
michael@0: #endif
michael@0: 
michael@0: class SkReadBuffer {
michael@0: public:
michael@0:     SkReadBuffer();
michael@0:     SkReadBuffer(const void* data, size_t size);
michael@0:     SkReadBuffer(SkStream* stream);
michael@0:     virtual ~SkReadBuffer();
michael@0: 
michael@0:     enum Flags {
michael@0:         kCrossProcess_Flag  = 1 << 0,
michael@0:         kScalarIsFloat_Flag = 1 << 1,
michael@0:         kPtrIs64Bit_Flag    = 1 << 2,
michael@0:         kValidation_Flag    = 1 << 3,
michael@0:     };
michael@0: 
michael@0:     void setFlags(uint32_t flags) { fFlags = flags; }
michael@0:     uint32_t getFlags() const { return fFlags; }
michael@0: 
michael@0:     bool isCrossProcess() const {
michael@0:         return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
michael@0:     }
michael@0:     bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
michael@0:     bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
michael@0:     bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
michael@0: 
michael@0:     SkReader32* getReader32() { return &fReader; }
michael@0: 
michael@0:     uint32_t size() { return fReader.size(); }
michael@0:     uint32_t offset() { return fReader.offset(); }
michael@0:     bool eof() { return fReader.eof(); }
michael@0:     const void* skip(size_t size) { return fReader.skip(size); }
michael@0: 
michael@0:     // primitives
michael@0:     virtual bool readBool();
michael@0:     virtual SkColor readColor();
michael@0:     virtual SkFixed readFixed();
michael@0:     virtual int32_t readInt();
michael@0:     virtual SkScalar readScalar();
michael@0:     virtual uint32_t readUInt();
michael@0:     virtual int32_t read32();
michael@0: 
michael@0:     void* readFunctionPtr() {
michael@0:         void* ptr;
michael@0:         this->readByteArray(&ptr, sizeof(ptr));
michael@0:         return ptr;
michael@0:     }
michael@0: 
michael@0:     // strings -- the caller is responsible for freeing the string contents
michael@0:     virtual void readString(SkString* string);
michael@0:     virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding);
michael@0: 
michael@0:     // common data structures
michael@0:     virtual void readPoint(SkPoint* point);
michael@0:     SkPoint readPoint() { SkPoint p; this->readPoint(&p); return p; }
michael@0:     virtual void readMatrix(SkMatrix* matrix);
michael@0:     virtual void readIRect(SkIRect* rect);
michael@0:     virtual void readRect(SkRect* rect);
michael@0:     virtual void readRegion(SkRegion* region);
michael@0:     virtual void readPath(SkPath* path);
michael@0:     void readPaint(SkPaint* paint) { paint->unflatten(*this); }
michael@0: 
michael@0:     virtual SkFlattenable* readFlattenable(SkFlattenable::Type);
michael@0:     template <typename T> T* readFlattenable() {
michael@0:         return (T*) this->readFlattenable(T::GetFlattenableType());
michael@0:     }
michael@0:     SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
michael@0:     SkDrawLooper*  readDrawLooper()  { return this->readFlattenable<SkDrawLooper>(); }
michael@0:     SkImageFilter* readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
michael@0:     SkMaskFilter*  readMaskFilter()  { return this->readFlattenable<SkMaskFilter>(); }
michael@0:     SkPathEffect*  readPathEffect()  { return this->readFlattenable<SkPathEffect>(); }
michael@0:     SkPixelRef*    readPixelRef()    { return this->readFlattenable<SkPixelRef>(); }
michael@0:     SkRasterizer*  readRasterizer()  { return this->readFlattenable<SkRasterizer>(); }
michael@0:     SkShader*      readShader()      { return this->readFlattenable<SkShader>(); }
michael@0:     SkUnitMapper*  readUnitMapper()  { return this->readFlattenable<SkUnitMapper>(); }
michael@0:     SkXfermode*    readXfermode()    { return this->readFlattenable<SkXfermode>(); }
michael@0: 
michael@0: 
michael@0:     // binary data and arrays
michael@0:     virtual bool readByteArray(void* value, size_t size);
michael@0:     virtual bool readColorArray(SkColor* colors, size_t size);
michael@0:     virtual bool readIntArray(int32_t* values, size_t size);
michael@0:     virtual bool readPointArray(SkPoint* points, size_t size);
michael@0:     virtual bool readScalarArray(SkScalar* values, size_t size);
michael@0: 
michael@0:     SkData* readByteArrayAsData() {
michael@0:         size_t len = this->getArrayCount();
michael@0:         if (!this->validateAvailable(len)) {
michael@0:             return SkData::NewEmpty();
michael@0:         }
michael@0:         void* buffer = sk_malloc_throw(len);
michael@0:         this->readByteArray(buffer, len);
michael@0:         return SkData::NewFromMalloc(buffer, len);
michael@0:     }
michael@0: 
michael@0:     // helpers to get info about arrays and binary data
michael@0:     virtual uint32_t getArrayCount();
michael@0: 
michael@0:     virtual void readBitmap(SkBitmap* bitmap);
michael@0:     virtual SkTypeface* readTypeface();
michael@0: 
michael@0:     void setBitmapStorage(SkBitmapHeapReader* bitmapStorage) {
michael@0:         SkRefCnt_SafeAssign(fBitmapStorage, bitmapStorage);
michael@0:     }
michael@0: 
michael@0:     void setTypefaceArray(SkTypeface* array[], int count) {
michael@0:         fTFArray = array;
michael@0:         fTFCount = count;
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      *  Call this with a pre-loaded array of Factories, in the same order as
michael@0:      *  were created/written by the writer. SkPicture uses this.
michael@0:      */
michael@0:     void setFactoryPlayback(SkFlattenable::Factory array[], int count) {
michael@0:         fFactoryTDArray = NULL;
michael@0:         fFactoryArray = array;
michael@0:         fFactoryCount = count;
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      *  Call this with an initially empty array, so the reader can cache each
michael@0:      *  factory it sees by name. Used by the pipe code in conjunction with
michael@0:      *  SkWriteBuffer::setNamedFactoryRecorder.
michael@0:      */
michael@0:     void setFactoryArray(SkTDArray<SkFlattenable::Factory>* array) {
michael@0:         fFactoryTDArray = array;
michael@0:         fFactoryArray = NULL;
michael@0:         fFactoryCount = 0;
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      *  Provide a function to decode an SkBitmap from encoded data. Only used if the writer
michael@0:      *  encoded the SkBitmap. If the proper decoder cannot be used, a red bitmap with the
michael@0:      *  appropriate size will be used.
michael@0:      */
michael@0:     void setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder) {
michael@0:         fBitmapDecoder = bitmapDecoder;
michael@0:     }
michael@0: 
michael@0:     // Default impelementations don't check anything.
michael@0:     virtual bool validate(bool isValid) { return true; }
michael@0:     virtual bool isValid() const { return true; }
michael@0:     virtual bool validateAvailable(size_t size) { return true; }
michael@0: 
michael@0: protected:
michael@0:     SkReader32 fReader;
michael@0: 
michael@0: private:
michael@0:     bool readArray(void* value, size_t size, size_t elementSize);
michael@0: 
michael@0:     uint32_t fFlags;
michael@0: 
michael@0:     void* fMemoryPtr;
michael@0: 
michael@0:     SkBitmapHeapReader* fBitmapStorage;
michael@0:     SkTypeface** fTFArray;
michael@0:     int        fTFCount;
michael@0: 
michael@0:     SkTDArray<SkFlattenable::Factory>* fFactoryTDArray;
michael@0:     SkFlattenable::Factory* fFactoryArray;
michael@0:     int                     fFactoryCount;
michael@0: 
michael@0:     SkPicture::InstallPixelRefProc fBitmapDecoder;
michael@0: 
michael@0: #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
michael@0:     // Debugging counter to keep track of how many bitmaps we
michael@0:     // have decoded.
michael@0:     int fDecodedBitmapIndex;
michael@0: #endif // DEBUG_NON_DETERMINISTIC_ASSERT
michael@0: };
michael@0: 
michael@0: #endif // SkReadBuffer_DEFINED