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 SkWriteBuffer_DEFINED
      9 #define SkWriteBuffer_DEFINED
     10 
     11 #include "SkData.h"
     12 #include "SkSerialProcs.h"
     13 #include "SkWriter32.h"
     14 #include "../private/SkTHash.h"
     15 
     16 class SkDeduper;
     17 class SkFactorySet;
     18 class SkFlattenable;
     19 class SkImage;
     20 class SkPath;
     21 class SkRefCntSet;
     22 
     23 class SkWriteBuffer {
     24 public:
     25     SkWriteBuffer() {}
     26     virtual ~SkWriteBuffer() {}
     27 
     28     virtual void writePad32(const void* buffer, size_t bytes) = 0;
     29 
     30     virtual void writeByteArray(const void* data, size_t size) = 0;
     31     void writeDataAsByteArray(SkData* data) {
     32         this->writeByteArray(data->data(), data->size());
     33     }
     34     virtual void writeBool(bool value) = 0;
     35     virtual void writeScalar(SkScalar value) = 0;
     36     virtual void writeScalarArray(const SkScalar* value, uint32_t count) = 0;
     37     virtual void writeInt(int32_t value) = 0;
     38     virtual void writeIntArray(const int32_t* value, uint32_t count) = 0;
     39     virtual void writeUInt(uint32_t value) = 0;
     40     void write32(int32_t value) {
     41         this->writeInt(value);
     42     }
     43     virtual void writeString(const char* value) = 0;
     44 
     45     virtual void writeFlattenable(const SkFlattenable* flattenable) = 0;
     46     virtual void writeColor(SkColor color) = 0;
     47     virtual void writeColorArray(const SkColor* color, uint32_t count) = 0;
     48     virtual void writeColor4f(const SkColor4f& color) = 0;
     49     virtual void writeColor4fArray(const SkColor4f* color, uint32_t count) = 0;
     50     virtual void writePoint(const SkPoint& point) = 0;
     51     virtual void writePointArray(const SkPoint* point, uint32_t count) = 0;
     52     virtual void writeMatrix(const SkMatrix& matrix) = 0;
     53     virtual void writeIRect(const SkIRect& rect) = 0;
     54     virtual void writeRect(const SkRect& rect) = 0;
     55     virtual void writeRegion(const SkRegion& region) = 0;
     56     virtual void writePath(const SkPath& path) = 0;
     57     virtual size_t writeStream(SkStream* stream, size_t length) = 0;
     58     virtual void writeImage(const SkImage*) = 0;
     59     virtual void writeTypeface(SkTypeface* typeface) = 0;
     60     virtual void writePaint(const SkPaint& paint) = 0;
     61 
     62     void setDeduper(SkDeduper* deduper) { fDeduper = deduper; }
     63 
     64     void setSerialProcs(const SkSerialProcs& procs) { fProcs = procs; }
     65 
     66 protected:
     67     SkDeduper*      fDeduper = nullptr;
     68     SkSerialProcs   fProcs;
     69 
     70     friend class SkPicture; // fProcs
     71 };
     72 
     73 /**
     74  * Concrete implementation that serializes to a flat binary blob.
     75  */
     76 class SkBinaryWriteBuffer : public SkWriteBuffer {
     77 public:
     78     SkBinaryWriteBuffer();
     79     SkBinaryWriteBuffer(void* initialStorage, size_t storageSize);
     80     ~SkBinaryWriteBuffer() override;
     81 
     82     void write(const void* buffer, size_t bytes) {
     83         fWriter.write(buffer, bytes);
     84     }
     85     void writePad32(const void* buffer, size_t bytes) override {
     86         fWriter.writePad(buffer, bytes);
     87     }
     88 
     89     void reset(void* storage = nullptr, size_t storageSize = 0) {
     90         fWriter.reset(storage, storageSize);
     91     }
     92 
     93     size_t bytesWritten() const { return fWriter.bytesWritten(); }
     94 
     95     void writeByteArray(const void* data, size_t size) override;
     96     void writeBool(bool value) override;
     97     void writeScalar(SkScalar value) override;
     98     void writeScalarArray(const SkScalar* value, uint32_t count) override;
     99     void writeInt(int32_t value) override;
    100     void writeIntArray(const int32_t* value, uint32_t count) override;
    101     void writeUInt(uint32_t value) override;
    102     void writeString(const char* value) override;
    103 
    104     void writeFlattenable(const SkFlattenable* flattenable) override;
    105     void writeColor(SkColor color) override;
    106     void writeColorArray(const SkColor* color, uint32_t count) override;
    107     void writeColor4f(const SkColor4f& color) override;
    108     void writeColor4fArray(const SkColor4f* color, uint32_t count) override;
    109     void writePoint(const SkPoint& point) override;
    110     void writePointArray(const SkPoint* point, uint32_t count) override;
    111     void writeMatrix(const SkMatrix& matrix) override;
    112     void writeIRect(const SkIRect& rect) override;
    113     void writeRect(const SkRect& rect) override;
    114     void writeRegion(const SkRegion& region) override;
    115     void writePath(const SkPath& path) override;
    116     size_t writeStream(SkStream* stream, size_t length) override;
    117     void writeImage(const SkImage*) override;
    118     void writeTypeface(SkTypeface* typeface) override;
    119     void writePaint(const SkPaint& paint) override;
    120 
    121     bool writeToStream(SkWStream*);
    122     void writeToMemory(void* dst) { fWriter.flatten(dst); }
    123 
    124     SkFactorySet* setFactoryRecorder(SkFactorySet*);
    125     SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);
    126 
    127 private:
    128     SkFactorySet* fFactorySet;
    129     SkWriter32 fWriter;
    130 
    131     SkRefCntSet*    fTFSet;
    132 
    133     // Only used if we do not have an fFactorySet
    134     SkTHashMap<SkString, uint32_t> fFlattenableDict;
    135 };
    136 
    137 #endif // SkWriteBuffer_DEFINED
    138