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