1 /*
2 * Copyright 2012 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 #include "src/core/SkWriteBuffer.h"
9
10 #include "include/core/SkAlphaType.h"
11 #include "include/core/SkData.h"
12 #include "include/core/SkFlattenable.h"
13 #include "include/core/SkImage.h"
14 #include "include/core/SkPoint.h"
15 #include "include/core/SkPoint3.h"
16 #include "include/core/SkRect.h"
17 #include "include/core/SkTypeface.h"
18 #include "include/private/base/SkAssert.h"
19 #include "include/private/base/SkTFitsIn.h"
20 #include "include/private/base/SkTo.h"
21 #include "src/core/SkMatrixPriv.h"
22 #include "src/core/SkMipmap.h"
23 #include "src/core/SkPaintPriv.h"
24 #include "src/core/SkPtrRecorder.h"
25 #include "src/image/SkImage_Base.h"
26
27 #include <cstring>
28 #include <utility>
29
30 class SkMatrix;
31 class SkPaint;
32 class SkRegion;
33 class SkStream;
34 class SkWStream;
35
36 ///////////////////////////////////////////////////////////////////////////////////////////////////
37
SkBinaryWriteBuffer()38 SkBinaryWriteBuffer::SkBinaryWriteBuffer()
39 : fFactorySet(nullptr)
40 , fTFSet(nullptr) {
41 }
42
SkBinaryWriteBuffer(void * storage,size_t storageSize)43 SkBinaryWriteBuffer::SkBinaryWriteBuffer(void* storage, size_t storageSize)
44 : fFactorySet(nullptr)
45 , fTFSet(nullptr)
46 , fWriter(storage, storageSize)
47 {}
48
~SkBinaryWriteBuffer()49 SkBinaryWriteBuffer::~SkBinaryWriteBuffer() {}
50
usingInitialStorage() const51 bool SkBinaryWriteBuffer::usingInitialStorage() const {
52 return fWriter.usingInitialStorage();
53 }
54
writeByteArray(const void * data,size_t size)55 void SkBinaryWriteBuffer::writeByteArray(const void* data, size_t size) {
56 fWriter.write32(SkToU32(size));
57 fWriter.writePad(data, size);
58 }
59
writeBool(bool value)60 void SkBinaryWriteBuffer::writeBool(bool value) {
61 fWriter.writeBool(value);
62 }
63
writeScalar(SkScalar value)64 void SkBinaryWriteBuffer::writeScalar(SkScalar value) {
65 fWriter.writeScalar(value);
66 }
67
writeScalarArray(const SkScalar * value,uint32_t count)68 void SkBinaryWriteBuffer::writeScalarArray(const SkScalar* value, uint32_t count) {
69 fWriter.write32(count);
70 fWriter.write(value, count * sizeof(SkScalar));
71 }
72
writeInt(int32_t value)73 void SkBinaryWriteBuffer::writeInt(int32_t value) {
74 fWriter.write32(value);
75 }
76
writeIntArray(const int32_t * value,uint32_t count)77 void SkBinaryWriteBuffer::writeIntArray(const int32_t* value, uint32_t count) {
78 fWriter.write32(count);
79 fWriter.write(value, count * sizeof(int32_t));
80 }
81
writeUInt(uint32_t value)82 void SkBinaryWriteBuffer::writeUInt(uint32_t value) {
83 fWriter.write32(value);
84 }
85
writeString(std::string_view value)86 void SkBinaryWriteBuffer::writeString(std::string_view value) {
87 fWriter.writeString(value.data(), value.size());
88 }
89
writeColor(SkColor color)90 void SkBinaryWriteBuffer::writeColor(SkColor color) {
91 fWriter.write32(color);
92 }
93
writeColorArray(const SkColor * color,uint32_t count)94 void SkBinaryWriteBuffer::writeColorArray(const SkColor* color, uint32_t count) {
95 fWriter.write32(count);
96 fWriter.write(color, count * sizeof(SkColor));
97 }
98
writeColor4f(const SkColor4f & color)99 void SkBinaryWriteBuffer::writeColor4f(const SkColor4f& color) {
100 fWriter.write(&color, sizeof(SkColor4f));
101 }
102
writeColor4fArray(const SkColor4f * color,uint32_t count)103 void SkBinaryWriteBuffer::writeColor4fArray(const SkColor4f* color, uint32_t count) {
104 fWriter.write32(count);
105 fWriter.write(color, count * sizeof(SkColor4f));
106 }
107
writePoint(const SkPoint & point)108 void SkBinaryWriteBuffer::writePoint(const SkPoint& point) {
109 fWriter.writeScalar(point.fX);
110 fWriter.writeScalar(point.fY);
111 }
112
writePoint3(const SkPoint3 & point)113 void SkBinaryWriteBuffer::writePoint3(const SkPoint3& point) {
114 this->writePad32(&point, sizeof(SkPoint3));
115 }
116
writePointArray(const SkPoint * point,uint32_t count)117 void SkBinaryWriteBuffer::writePointArray(const SkPoint* point, uint32_t count) {
118 fWriter.write32(count);
119 fWriter.write(point, count * sizeof(SkPoint));
120 }
121
write(const SkM44 & matrix)122 void SkBinaryWriteBuffer::write(const SkM44& matrix) {
123 fWriter.write(SkMatrixPriv::M44ColMajor(matrix), sizeof(float) * 16);
124 }
125
writeMatrix(const SkMatrix & matrix)126 void SkBinaryWriteBuffer::writeMatrix(const SkMatrix& matrix) {
127 fWriter.writeMatrix(matrix);
128 }
129
writeIRect(const SkIRect & rect)130 void SkBinaryWriteBuffer::writeIRect(const SkIRect& rect) {
131 fWriter.write(&rect, sizeof(SkIRect));
132 }
133
writeRect(const SkRect & rect)134 void SkBinaryWriteBuffer::writeRect(const SkRect& rect) {
135 fWriter.writeRect(rect);
136 }
137
writeRegion(const SkRegion & region)138 void SkBinaryWriteBuffer::writeRegion(const SkRegion& region) {
139 fWriter.writeRegion(region);
140 }
141
writeSampling(const SkSamplingOptions & sampling)142 void SkBinaryWriteBuffer::writeSampling(const SkSamplingOptions& sampling) {
143 fWriter.writeSampling(sampling);
144 }
145
writePath(const SkPath & path)146 void SkBinaryWriteBuffer::writePath(const SkPath& path) {
147 fWriter.writePath(path);
148 }
149
writeStream(SkStream * stream,size_t length)150 size_t SkBinaryWriteBuffer::writeStream(SkStream* stream, size_t length) {
151 fWriter.write32(SkToU32(length));
152 size_t bytesWritten = fWriter.readFromStream(stream, length);
153 if (bytesWritten < length) {
154 fWriter.reservePad(length - bytesWritten);
155 }
156 return bytesWritten;
157 }
158
writeToStream(SkWStream * stream) const159 bool SkBinaryWriteBuffer::writeToStream(SkWStream* stream) const {
160 return fWriter.writeToStream(stream);
161 }
162
163 /* Format:
164 * flags: U32
165 * encoded : size_32 + data[]
166 * [subset: IRect]
167 * [mips] : size_32 + data[]
168 */
writeImage(const SkImage * image)169 void SkBinaryWriteBuffer::writeImage(const SkImage* image) {
170 uint32_t flags = 0;
171 const SkMipmap* mips = as_IB(image)->onPeekMips();
172 if (mips) {
173 flags |= SkWriteBufferImageFlags::kHasMipmap;
174 }
175 if (image->alphaType() == kUnpremul_SkAlphaType) {
176 flags |= SkWriteBufferImageFlags::kUnpremul;
177 }
178
179 this->write32(flags);
180
181 sk_sp<SkData> data;
182 if (fProcs.fImageProc) {
183 data = fProcs.fImageProc(const_cast<SkImage*>(image), fProcs.fImageCtx);
184 }
185 if (!data) {
186 data = image->encodeToData();
187 }
188 this->writeDataAsByteArray(data.get());
189
190 if (flags & SkWriteBufferImageFlags::kHasMipmap) {
191 this->writeDataAsByteArray(mips->serialize().get());
192 }
193 }
194
writeTypeface(SkTypeface * obj)195 void SkBinaryWriteBuffer::writeTypeface(SkTypeface* obj) {
196 // Write 32 bits (signed)
197 // 0 -- default font
198 // >0 -- index
199 // <0 -- custom (serial procs)
200
201 if (obj == nullptr) {
202 fWriter.write32(0);
203 } else if (fProcs.fTypefaceProc) {
204 auto data = fProcs.fTypefaceProc(obj, fProcs.fTypefaceCtx);
205 if (data) {
206 size_t size = data->size();
207 if (!SkTFitsIn<int32_t>(size)) {
208 size = 0; // fall back to default font
209 }
210 int32_t ssize = SkToS32(size);
211 fWriter.write32(-ssize); // negative to signal custom
212 if (size) {
213 this->writePad32(data->data(), size);
214 }
215 return;
216 }
217 // no data means fall through for std behavior
218 }
219 fWriter.write32(fTFSet ? fTFSet->add(obj) : 0);
220 }
221
writePaint(const SkPaint & paint)222 void SkBinaryWriteBuffer::writePaint(const SkPaint& paint) {
223 SkPaintPriv::Flatten(paint, *this);
224 }
225
setFactoryRecorder(sk_sp<SkFactorySet> rec)226 void SkBinaryWriteBuffer::setFactoryRecorder(sk_sp<SkFactorySet> rec) {
227 fFactorySet = std::move(rec);
228 }
229
setTypefaceRecorder(sk_sp<SkRefCntSet> rec)230 void SkBinaryWriteBuffer::setTypefaceRecorder(sk_sp<SkRefCntSet> rec) {
231 fTFSet = std::move(rec);
232 }
233
writeFlattenable(const SkFlattenable * flattenable)234 void SkBinaryWriteBuffer::writeFlattenable(const SkFlattenable* flattenable) {
235 if (nullptr == flattenable) {
236 this->write32(0);
237 return;
238 }
239
240 /*
241 * We can write 1 of 2 versions of the flattenable:
242 *
243 * 1. index into fFactorySet: This assumes the writer will later resolve the function-ptrs
244 * into strings for its reader. SkPicture does exactly this, by writing a table of names
245 * (matching the indices) up front in its serialized form.
246 *
247 * 2. string name of the flattenable or index into fFlattenableDict: We store the string to
248 * allow the reader to specify its own factories after write time. In order to improve
249 * compression, if we have already written the string, we write its index instead.
250 */
251
252 if (SkFlattenable::Factory factory = flattenable->getFactory(); factory && fFactorySet) {
253 this->write32(fFactorySet->add(factory));
254 } else {
255 const char* name = flattenable->getTypeName();
256 SkASSERT(name);
257 SkASSERT(0 != strcmp("", name));
258
259 if (uint32_t* indexPtr = fFlattenableDict.find(name)) {
260 // We will write the index as a 32-bit int. We want the first byte
261 // that we send to be zero - this will act as a sentinel that we
262 // have an index (not a string). This means that we will send the
263 // the index shifted left by 8. The remaining 24-bits should be
264 // plenty to store the index. Note that this strategy depends on
265 // being little endian, and type names being non-empty.
266 SkASSERT(0 == *indexPtr >> 24);
267 this->write32(*indexPtr << 8);
268 } else {
269 this->writeString(name);
270 fFlattenableDict.set(name, fFlattenableDict.count() + 1);
271 }
272 }
273
274 // make room for the size of the flattened object
275 (void)fWriter.reserve(sizeof(uint32_t));
276 // record the current size, so we can subtract after the object writes.
277 size_t offset = fWriter.bytesWritten();
278 // now flatten the object
279 flattenable->flatten(*this);
280 size_t objSize = fWriter.bytesWritten() - offset;
281 // record the obj's size
282 fWriter.overwriteTAt(offset - sizeof(uint32_t), SkToU32(objSize));
283 }
284