1 
2 /*
3  * Copyright 2011 Google Inc.
4  *
5  * Use of this source code is governed by a BSD-style license that can be
6  * found in the LICENSE file.
7  */
8 
9 #ifndef SkWriteBuffer_DEFINED
10 #define SkWriteBuffer_DEFINED
11 
12 #include "SkData.h"
13 #include "SkPath.h"
14 #include "SkPicture.h"
15 #include "SkPixelSerializer.h"
16 #include "SkRefCnt.h"
17 #include "SkWriter32.h"
18 
19 class SkBitmap;
20 class SkBitmapHeap;
21 class SkFactorySet;
22 class SkFlattenable;
23 class SkNamedFactorySet;
24 class SkRefCntSet;
25 
26 class SkWriteBuffer {
27 public:
28     enum Flags {
29         kCrossProcess_Flag  = 1 << 0,
30         kValidation_Flag    = 1 << 1,
31     };
32 
33     SkWriteBuffer(uint32_t flags = 0);
34     SkWriteBuffer(void* initialStorage, size_t storageSize, uint32_t flags = 0);
35     ~SkWriteBuffer();
36 
isCrossProcess()37     bool isCrossProcess() const {
38         return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
39     }
40 
getWriter32()41     SkWriter32* getWriter32() { return &fWriter; }
42     void reset(void* storage = NULL, size_t storageSize = 0) {
43         fWriter.reset(storage, storageSize);
44     }
45 
reserve(size_t size)46     uint32_t* reserve(size_t size) { return fWriter.reserve(size); }
47 
bytesWritten()48     size_t bytesWritten() const { return fWriter.bytesWritten(); }
49 
50     void writeByteArray(const void* data, size_t size);
writeDataAsByteArray(SkData * data)51     void writeDataAsByteArray(SkData* data) { this->writeByteArray(data->data(), data->size()); }
52     void writeBool(bool value);
53     void writeFixed(SkFixed value);
54     void writeScalar(SkScalar value);
55     void writeScalarArray(const SkScalar* value, uint32_t count);
56     void writeInt(int32_t value);
57     void writeIntArray(const int32_t* value, uint32_t count);
58     void writeUInt(uint32_t value);
59     void write32(int32_t value);
60     void writeString(const char* value);
61     void writeEncodedString(const void* value, size_t byteLength, SkPaint::TextEncoding encoding);
writeFunctionPtr(void * ptr)62     void writeFunctionPtr(void* ptr) { fWriter.writePtr(ptr); }
63 
64     void writeFlattenable(const SkFlattenable* flattenable);
65     void writeColor(const SkColor& color);
66     void writeColorArray(const SkColor* color, uint32_t count);
67     void writePoint(const SkPoint& point);
68     void writePointArray(const SkPoint* point, uint32_t count);
69     void writeMatrix(const SkMatrix& matrix);
70     void writeIRect(const SkIRect& rect);
71     void writeRect(const SkRect& rect);
72     void writeRegion(const SkRegion& region);
73     void writePath(const SkPath& path);
74     size_t writeStream(SkStream* stream, size_t length);
75     void writeBitmap(const SkBitmap& bitmap);
76     void writeImage(const SkImage*);
77     void writeTypeface(SkTypeface* typeface);
writePaint(const SkPaint & paint)78     void writePaint(const SkPaint& paint) { paint.flatten(*this); }
79 
80     bool writeToStream(SkWStream*);
writeToMemory(void * dst)81     void writeToMemory(void* dst) { fWriter.flatten(dst); }
82 
83     SkFactorySet* setFactoryRecorder(SkFactorySet*);
84     SkNamedFactorySet* setNamedFactoryRecorder(SkNamedFactorySet*);
85 
getTypefaceRecorder()86     SkRefCntSet* getTypefaceRecorder() const { return fTFSet; }
87     SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);
88 
89     /**
90      * Set an SkBitmapHeap to store bitmaps rather than flattening.
91      *
92      * Incompatible with an SkPixelSerializer. If an SkPixelSerializer is set,
93      * setting an SkBitmapHeap will set the SkPixelSerializer to NULL in release
94      * and crash in debug.
95      */
96     void setBitmapHeap(SkBitmapHeap*);
97 
98     /**
99      * Set an SkPixelSerializer to store an encoded representation of pixels,
100      * e.g. SkBitmaps.
101      *
102      * Calls ref() on the serializer.
103      *
104      * TODO: Encode SkImage pixels as well.
105      *
106      * Incompatible with the SkBitmapHeap. If an encoder is set fBitmapHeap will
107      * be set to NULL in release and crash in debug.
108      */
109     void setPixelSerializer(SkPixelSerializer*);
getPixelSerializer()110     SkPixelSerializer* getPixelSerializer() const { return fPixelSerializer; }
111 
112 private:
isValidating()113     bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
114 
115     const uint32_t fFlags;
116     SkFactorySet* fFactorySet;
117     SkNamedFactorySet* fNamedFactorySet;
118     SkWriter32 fWriter;
119 
120     SkBitmapHeap* fBitmapHeap;
121     SkRefCntSet* fTFSet;
122 
123     SkAutoTUnref<SkPixelSerializer> fPixelSerializer;
124 };
125 
126 #endif // SkWriteBuffer_DEFINED
127