1 /*
2 * Copyright 2016 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 "SkCanvas.h"
9 #include "SkDeduper.h"
10 #include "SkPicture.h"
11 #include "SkPictureRecorder.h"
12 #include "SkPipe.h"
13 #include "SkPipeFormat.h"
14 #include "SkReadBuffer.h"
15 #include "SkRefSet.h"
16 #include "SkRSXform.h"
17 #include "SkTextBlob.h"
18 #include "SkTypeface.h"
19
20 class SkPipeReader;
21
22 static bool do_playback(SkPipeReader& reader, SkCanvas* canvas, int* endPictureIndex = nullptr);
23
24 ///////////////////////////////////////////////////////////////////////////////////////////////////
25
26 class SkPipeInflator : public SkInflator {
27 public:
SkPipeInflator(SkRefSet<SkImage> * images,SkRefSet<SkPicture> * pictures,SkRefSet<SkTypeface> * typefaces,SkTDArray<SkFlattenable::Factory> * factories,SkTypefaceDeserializer * tfd)28 SkPipeInflator(SkRefSet<SkImage>* images, SkRefSet<SkPicture>* pictures,
29 SkRefSet<SkTypeface>* typefaces, SkTDArray<SkFlattenable::Factory>* factories,
30 SkTypefaceDeserializer* tfd)
31 : fImages(images)
32 , fPictures(pictures)
33 , fTypefaces(typefaces)
34 , fFactories(factories)
35 , fTFDeserializer(tfd)
36 {}
37
getImage(int index)38 SkImage* getImage(int index) override {
39 return index ? fImages->get(index - 1) : nullptr;
40 }
getPicture(int index)41 SkPicture* getPicture(int index) override {
42 return index ? fPictures->get(index - 1) : nullptr;
43 }
getTypeface(int index)44 SkTypeface* getTypeface(int index) override {
45 return fTypefaces->get(index - 1);
46 }
getFactory(int index)47 SkFlattenable::Factory getFactory(int index) override {
48 return index ? fFactories->getAt(index - 1) : nullptr;
49 }
50
setImage(int index,SkImage * img)51 bool setImage(int index, SkImage* img) {
52 return fImages->set(index - 1, img);
53 }
setPicture(int index,SkPicture * pic)54 bool setPicture(int index, SkPicture* pic) {
55 return fPictures->set(index - 1, pic);
56 }
setTypeface(int index,SkTypeface * face)57 bool setTypeface(int index, SkTypeface* face) {
58 return fTypefaces->set(index - 1, face);
59 }
setFactory(int index,SkFlattenable::Factory factory)60 bool setFactory(int index, SkFlattenable::Factory factory) {
61 SkASSERT(index > 0);
62 SkASSERT(factory);
63 index -= 1;
64 if ((unsigned)index < (unsigned)fFactories->count()) {
65 (*fFactories)[index] = factory;
66 return true;
67 }
68 if (fFactories->count() == index) {
69 *fFactories->append() = factory;
70 return true;
71 }
72 SkDebugf("setFactory: index [%d] out of range %d\n", index, fFactories->count());
73 return false;
74 }
75
setTypefaceDeserializer(SkTypefaceDeserializer * tfd)76 void setTypefaceDeserializer(SkTypefaceDeserializer* tfd) {
77 fTFDeserializer = tfd;
78 }
79
80 sk_sp<SkTypeface> makeTypeface(const void* data, size_t size);
81
82 private:
83 SkRefSet<SkImage>* fImages;
84 SkRefSet<SkPicture>* fPictures;
85 SkRefSet<SkTypeface>* fTypefaces;
86 SkTDArray<SkFlattenable::Factory>* fFactories;
87
88 SkTypefaceDeserializer* fTFDeserializer;
89 };
90
91 ///////////////////////////////////////////////////////////////////////////////////////////////////
92
skip(SkReadBuffer & reader,int count=1)93 template <typename T> const T* skip(SkReadBuffer& reader, int count = 1) {
94 return (const T*)reader.skip(count * sizeof(T));
95 }
96
read_rrect(SkReadBuffer & reader)97 static SkRRect read_rrect(SkReadBuffer& reader) {
98 SkRRect rrect;
99 rrect.readFromMemory(reader.skip(SkRRect::kSizeInMemory), SkRRect::kSizeInMemory);
100 return rrect;
101 }
102
read_sparse_matrix(SkReadBuffer & reader,SkMatrix::TypeMask tm)103 static SkMatrix read_sparse_matrix(SkReadBuffer& reader, SkMatrix::TypeMask tm) {
104 SkMatrix matrix;
105 matrix.reset();
106
107 if (tm & SkMatrix::kPerspective_Mask) {
108 matrix.set9(skip<SkScalar>(reader, 9));
109 } else if (tm & SkMatrix::kAffine_Mask) {
110 const SkScalar* tmp = skip<SkScalar>(reader, 6);
111 matrix[SkMatrix::kMScaleX] = tmp[0];
112 matrix[SkMatrix::kMSkewX] = tmp[1];
113 matrix[SkMatrix::kMTransX] = tmp[2];
114 matrix[SkMatrix::kMScaleY] = tmp[3];
115 matrix[SkMatrix::kMSkewY] = tmp[4];
116 matrix[SkMatrix::kMTransY] = tmp[5];
117 } else if (tm & SkMatrix::kScale_Mask) {
118 const SkScalar* tmp = skip<SkScalar>(reader, 4);
119 matrix[SkMatrix::kMScaleX] = tmp[0];
120 matrix[SkMatrix::kMTransX] = tmp[1];
121 matrix[SkMatrix::kMScaleY] = tmp[2];
122 matrix[SkMatrix::kMTransY] = tmp[3];
123 } else if (tm & SkMatrix::kTranslate_Mask) {
124 const SkScalar* tmp = skip<SkScalar>(reader, 2);
125 matrix[SkMatrix::kMTransX] = tmp[0];
126 matrix[SkMatrix::kMTransY] = tmp[1];
127 }
128 // else read nothing for Identity
129 return matrix;
130 }
131
132 ///////////////////////////////////////////////////////////////////////////////////////////////////
133
134 #define CHECK_SET_SCALAR(Field) \
135 do { if (nondef & k##Field##_NonDef) { \
136 paint.set##Field(reader.readScalar()); \
137 }} while (0)
138
139 #define CHECK_SET_FLATTENABLE(Field) \
140 do { if (nondef & k##Field##_NonDef) { \
141 paint.set##Field(reader.read##Field()); \
142 }} while (0)
143
144 /*
145 * Header:
146 * paint flags : 32
147 * non_def bits : 16
148 * xfermode enum : 8
149 * pad zeros : 8
150 */
read_paint(SkReadBuffer & reader)151 static SkPaint read_paint(SkReadBuffer& reader) {
152 SkPaint paint;
153
154 uint32_t packedFlags = reader.read32();
155 uint32_t extra = reader.read32();
156 unsigned nondef = extra >> 16;
157 paint.setBlendMode(SkBlendMode((extra >> 8) & 0xFF));
158 SkASSERT((extra & 0xFF) == 0); // zero pad byte
159
160 packedFlags >>= 2; // currently unused
161 paint.setTextEncoding((SkPaint::TextEncoding)(packedFlags & 3)); packedFlags >>= 2;
162 paint.setTextAlign((SkPaint::Align)(packedFlags & 3)); packedFlags >>= 2;
163 paint.setHinting((SkPaint::Hinting)(packedFlags & 3)); packedFlags >>= 2;
164 paint.setStrokeJoin((SkPaint::Join)(packedFlags & 3)); packedFlags >>= 2;
165 paint.setStrokeCap((SkPaint::Cap)(packedFlags & 3)); packedFlags >>= 2;
166 paint.setStyle((SkPaint::Style)(packedFlags & 3)); packedFlags >>= 2;
167 paint.setFilterQuality((SkFilterQuality)(packedFlags & 3)); packedFlags >>= 2;
168 paint.setFlags(packedFlags);
169
170 CHECK_SET_SCALAR(TextSize);
171 CHECK_SET_SCALAR(TextScaleX);
172 CHECK_SET_SCALAR(TextSkewX);
173 CHECK_SET_SCALAR(StrokeWidth);
174 CHECK_SET_SCALAR(StrokeMiter);
175
176 if (nondef & kColor_NonDef) {
177 paint.setColor(reader.read32());
178 }
179
180 CHECK_SET_FLATTENABLE(Typeface);
181 CHECK_SET_FLATTENABLE(PathEffect);
182 CHECK_SET_FLATTENABLE(Shader);
183 CHECK_SET_FLATTENABLE(MaskFilter);
184 CHECK_SET_FLATTENABLE(ColorFilter);
185 CHECK_SET_FLATTENABLE(Rasterizer);
186 CHECK_SET_FLATTENABLE(ImageFilter);
187 CHECK_SET_FLATTENABLE(DrawLooper);
188
189 return paint;
190 }
191
192 class SkPipeReader : public SkReadBuffer {
193 public:
SkPipeReader(SkPipeDeserializer * sink,const void * data,size_t size)194 SkPipeReader(SkPipeDeserializer* sink, const void* data, size_t size)
195 : SkReadBuffer(data, size)
196 , fSink(sink)
197 {}
198
199 SkPipeDeserializer* fSink;
200
findFactory(const char name[])201 SkFlattenable::Factory findFactory(const char name[]) {
202 SkFlattenable::Factory factory;
203 // Check if a custom Factory has been specified for this flattenable.
204 if (!(factory = this->getCustomFactory(SkString(name)))) {
205 // If there is no custom Factory, check for a default.
206 factory = SkFlattenable::NameToFactory(name);
207 }
208 return factory;
209 }
210
readPaint(SkPaint * paint)211 void readPaint(SkPaint* paint) override {
212 *paint = read_paint(*this);
213 }
214 };
215
216 ///////////////////////////////////////////////////////////////////////////////////////////////////
217
218 typedef void (*SkPipeHandler)(SkPipeReader&, uint32_t packedVerb, SkCanvas*);
219
save_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)220 static void save_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
221 SkASSERT(SkPipeVerb::kSave == unpack_verb(packedVerb));
222 canvas->save();
223 }
224
saveLayer_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)225 static void saveLayer_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
226 SkASSERT(SkPipeVerb::kSaveLayer == unpack_verb(packedVerb));
227 unsigned extra = unpack_verb_extra(packedVerb);
228 const SkRect* bounds = (extra & kHasBounds_SaveLayerMask) ? skip<SkRect>(reader) : nullptr;
229 SkPaint paintStorage, *paint = nullptr;
230 if (extra & kHasPaint_SaveLayerMask) {
231 paintStorage = read_paint(reader);
232 paint = &paintStorage;
233 }
234 sk_sp<SkImageFilter> backdrop;
235 if (extra & kHasBackdrop_SaveLayerMask) {
236 backdrop = reader.readImageFilter();
237 }
238 SkCanvas::SaveLayerFlags flags = (SkCanvas::SaveLayerFlags)(extra & kFlags_SaveLayerMask);
239
240 // unremap this wacky flag
241 if (extra & kDontClipToLayer_SaveLayerMask) {
242 flags |= (1 << 31);//SkCanvas::kDontClipToLayer_PrivateSaveLayerFlag;
243 }
244
245 canvas->saveLayer(SkCanvas::SaveLayerRec(bounds, paint, backdrop.get(), flags));
246 }
247
restore_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)248 static void restore_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
249 SkASSERT(SkPipeVerb::kRestore == unpack_verb(packedVerb));
250 canvas->restore();
251 }
252
concat_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)253 static void concat_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
254 SkASSERT(SkPipeVerb::kConcat == unpack_verb(packedVerb));
255 SkMatrix::TypeMask tm = (SkMatrix::TypeMask)(packedVerb & kTypeMask_ConcatMask);
256 const SkMatrix matrix = read_sparse_matrix(reader, tm);
257 if (packedVerb & kSetMatrix_ConcatMask) {
258 canvas->setMatrix(matrix);
259 } else {
260 canvas->concat(matrix);
261 }
262 }
263
clipRect_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)264 static void clipRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
265 SkASSERT(SkPipeVerb::kClipRect == unpack_verb(packedVerb));
266 SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
267 bool isAA = unpack_verb_extra(packedVerb) & 1;
268 canvas->clipRect(*skip<SkRect>(reader), op, isAA);
269 }
270
clipRRect_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)271 static void clipRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
272 SkASSERT(SkPipeVerb::kClipRRect == unpack_verb(packedVerb));
273 SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
274 bool isAA = unpack_verb_extra(packedVerb) & 1;
275 canvas->clipRRect(read_rrect(reader), op, isAA);
276 }
277
clipPath_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)278 static void clipPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
279 SkASSERT(SkPipeVerb::kClipPath == unpack_verb(packedVerb));
280 SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
281 bool isAA = unpack_verb_extra(packedVerb) & 1;
282 SkPath path;
283 reader.readPath(&path);
284 canvas->clipPath(path, op, isAA);
285 }
286
clipRegion_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)287 static void clipRegion_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
288 SkASSERT(SkPipeVerb::kClipRegion == unpack_verb(packedVerb));
289 SkCanvas::ClipOp op = (SkCanvas::ClipOp)(unpack_verb_extra(packedVerb) >> 1);
290 SkRegion region;
291 reader.readRegion(®ion);
292 canvas->clipRegion(region, op);
293 }
294
drawArc_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)295 static void drawArc_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
296 SkASSERT(SkPipeVerb::kDrawArc == unpack_verb(packedVerb));
297 const bool useCenter = (bool)(unpack_verb_extra(packedVerb) & 1);
298 const SkScalar* scalars = skip<SkScalar>(reader, 6); // bounds[0..3], start[4], sweep[5]
299 const SkRect* bounds = (const SkRect*)scalars;
300 canvas->drawArc(*bounds, scalars[4], scalars[5], useCenter, read_paint(reader));
301 }
302
drawAtlas_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)303 static void drawAtlas_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
304 SkASSERT(SkPipeVerb::kDrawAtlas == unpack_verb(packedVerb));
305 SkXfermode::Mode mode = (SkXfermode::Mode)(packedVerb & kMode_DrawAtlasMask);
306 sk_sp<SkImage> image(reader.readImage());
307 int count = reader.read32();
308 const SkRSXform* xform = skip<SkRSXform>(reader, count);
309 const SkRect* rect = skip<SkRect>(reader, count);
310 const SkColor* color = nullptr;
311 if (packedVerb & kHasColors_DrawAtlasMask) {
312 color = skip<SkColor>(reader, count);
313 }
314 const SkRect* cull = nullptr;
315 if (packedVerb & kHasCull_DrawAtlasMask) {
316 cull = skip<SkRect>(reader);
317 }
318 SkPaint paintStorage, *paint = nullptr;
319 if (packedVerb & kHasPaint_DrawAtlasMask) {
320 paintStorage = read_paint(reader);
321 paint = &paintStorage;
322 }
323 canvas->drawAtlas(image, xform, rect, color, count, mode, cull, paint);
324 }
325
drawDRRect_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)326 static void drawDRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
327 SkASSERT(SkPipeVerb::kDrawDRRect == unpack_verb(packedVerb));
328 const SkRRect outer = read_rrect(reader);
329 const SkRRect inner = read_rrect(reader);
330 canvas->drawDRRect(outer, inner, read_paint(reader));
331 }
332
drawText_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)333 static void drawText_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
334 SkASSERT(SkPipeVerb::kDrawText == unpack_verb(packedVerb));
335 uint32_t len = unpack_verb_extra(packedVerb);
336 if (0 == len) {
337 len = reader.read32();
338 }
339 const void* text = reader.skip(SkAlign4(len));
340 SkScalar x = reader.readScalar();
341 SkScalar y = reader.readScalar();
342 canvas->drawText(text, len, x, y, read_paint(reader));
343 }
344
drawPosText_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)345 static void drawPosText_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
346 SkASSERT(SkPipeVerb::kDrawPosText == unpack_verb(packedVerb));
347 uint32_t len = unpack_verb_extra(packedVerb);
348 if (0 == len) {
349 len = reader.read32();
350 }
351 const void* text = reader.skip(SkAlign4(len));
352 int count = reader.read32();
353 const SkPoint* pos = skip<SkPoint>(reader, count);
354 SkPaint paint = read_paint(reader);
355 SkASSERT(paint.countText(text, len) == count);
356 canvas->drawPosText(text, len, pos, paint);
357 }
358
drawPosTextH_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)359 static void drawPosTextH_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
360 SkASSERT(SkPipeVerb::kDrawPosTextH == unpack_verb(packedVerb));
361 uint32_t len = unpack_verb_extra(packedVerb);
362 if (0 == len) {
363 len = reader.read32();
364 }
365 const void* text = reader.skip(SkAlign4(len));
366 int count = reader.read32();
367 const SkScalar* xpos = skip<SkScalar>(reader, count);
368 SkScalar constY = reader.readScalar();
369 SkPaint paint = read_paint(reader);
370 SkASSERT(paint.countText(text, len) == count);
371 canvas->drawPosTextH(text, len, xpos, constY, paint);
372 }
373
drawTextOnPath_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)374 static void drawTextOnPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
375 SkASSERT(SkPipeVerb::kDrawTextOnPath == unpack_verb(packedVerb));
376 uint32_t byteLength = packedVerb & kTextLength_DrawTextOnPathMask;
377 SkMatrix::TypeMask tm = (SkMatrix::TypeMask)
378 ((packedVerb & kMatrixType_DrawTextOnPathMask) >> kMatrixType_DrawTextOnPathShift);
379
380 if (0 == byteLength) {
381 byteLength = reader.read32();
382 }
383 const void* text = reader.skip(SkAlign4(byteLength));
384 SkPath path;
385 reader.readPath(&path);
386 const SkMatrix* matrix = nullptr;
387 SkMatrix matrixStorage;
388 if (tm != SkMatrix::kIdentity_Mask) {
389 matrixStorage = read_sparse_matrix(reader, tm);
390 matrix = &matrixStorage;
391 }
392 canvas->drawTextOnPath(text, byteLength, path, matrix, read_paint(reader));
393 }
394
drawTextBlob_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)395 static void drawTextBlob_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
396 sk_sp<SkTextBlob> tb = SkTextBlob::MakeFromBuffer(reader);
397 SkScalar x = reader.readScalar();
398 SkScalar y = reader.readScalar();
399 canvas->drawTextBlob(tb, x, y, read_paint(reader));
400 }
401
drawTextRSXform_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)402 static void drawTextRSXform_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
403 SkASSERT(SkPipeVerb::kDrawTextRSXform == unpack_verb(packedVerb));
404 uint32_t len = unpack_verb_extra(packedVerb) >> 1;
405 if (0 == len) {
406 len = reader.read32();
407 }
408 const void* text = reader.skip(SkAlign4(len));
409 int count = reader.read32();
410 const SkRSXform* xform = skip<SkRSXform>(reader, count);
411 const SkRect* cull = (packedVerb & 1) ? skip<SkRect>(reader) : nullptr;
412 SkPaint paint = read_paint(reader);
413 SkASSERT(paint.countText(text, len) == count);
414 canvas->drawTextRSXform(text, len, xform, cull, paint);
415 }
416
drawPatch_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)417 static void drawPatch_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
418 SkASSERT(SkPipeVerb::kDrawPatch == unpack_verb(packedVerb));
419 const SkColor* colors = nullptr;
420 const SkPoint* tex = nullptr;
421 const SkPoint* cubics = skip<SkPoint>(reader, 12);
422 if (packedVerb & kHasColors_DrawPatchExtraMask) {
423 colors = skip<SkColor>(reader, 4);
424 }
425 if (packedVerb & kHasTexture_DrawPatchExtraMask) {
426 tex = skip<SkPoint>(reader, 4);
427 }
428 sk_sp<SkXfermode> xfer;
429 unsigned mode = packedVerb & kModeEnum_DrawPatchExtraMask;
430 if (kExplicitXfer_DrawPatchExtraValue == mode) {
431 xfer = reader.readXfermode();
432 } else {
433 if (mode != SkXfermode::kSrcOver_Mode) {
434 xfer = SkXfermode::Make((SkXfermode::Mode)mode);
435 }
436 }
437 canvas->drawPatch(cubics, colors, tex, xfer.get(), read_paint(reader));
438 }
439
drawPaint_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)440 static void drawPaint_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
441 SkASSERT(SkPipeVerb::kDrawPaint == unpack_verb(packedVerb));
442 canvas->drawPaint(read_paint(reader));
443 }
444
drawRect_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)445 static void drawRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
446 SkASSERT(SkPipeVerb::kDrawRect == unpack_verb(packedVerb));
447 const SkRect* rect = skip<SkRect>(reader);
448 canvas->drawRect(*rect, read_paint(reader));
449 }
450
drawRegion_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)451 static void drawRegion_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
452 SkASSERT(SkPipeVerb::kDrawRegion == unpack_verb(packedVerb));
453 size_t size = unpack_verb_extra(packedVerb);
454 if (0 == size) {
455 size = reader.read32();
456 }
457 SkRegion region;
458 region.readFromMemory(skip<char>(reader, SkAlign4(size)), size);
459 canvas->drawRegion(region, read_paint(reader));
460 }
461
drawOval_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)462 static void drawOval_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
463 SkASSERT(SkPipeVerb::kDrawOval == unpack_verb(packedVerb));
464 const SkRect* rect = skip<SkRect>(reader);
465 canvas->drawOval(*rect, read_paint(reader));
466 }
467
drawRRect_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)468 static void drawRRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
469 SkASSERT(SkPipeVerb::kDrawRRect == unpack_verb(packedVerb));
470 SkRRect rrect = read_rrect(reader);
471 canvas->drawRRect(rrect, read_paint(reader));
472 }
473
drawPath_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)474 static void drawPath_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
475 SkASSERT(SkPipeVerb::kDrawPath == unpack_verb(packedVerb));
476 SkPath path;
477 reader.readPath(&path);
478 canvas->drawPath(path, read_paint(reader));
479 }
480
drawPoints_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)481 static void drawPoints_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
482 SkASSERT(SkPipeVerb::kDrawPoints == unpack_verb(packedVerb));
483 SkCanvas::PointMode mode = (SkCanvas::PointMode)unpack_verb_extra(packedVerb);
484 int count = reader.read32();
485 const SkPoint* points = skip<SkPoint>(reader, count);
486 canvas->drawPoints(mode, count, points, read_paint(reader));
487 }
488
drawImage_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)489 static void drawImage_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
490 SkASSERT(SkPipeVerb::kDrawImage == unpack_verb(packedVerb));
491 sk_sp<SkImage> image(reader.readImage());
492 SkScalar x = reader.readScalar();
493 SkScalar y = reader.readScalar();
494 SkPaint paintStorage, *paint = nullptr;
495 if (packedVerb & kHasPaint_DrawImageMask) {
496 paintStorage = read_paint(reader);
497 paint = &paintStorage;
498 }
499 canvas->drawImage(image, x, y, paint);
500 }
501
drawImageRect_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)502 static void drawImageRect_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
503 SkASSERT(SkPipeVerb::kDrawImageRect == unpack_verb(packedVerb));
504 sk_sp<SkImage> image(reader.readImage());
505 SkCanvas::SrcRectConstraint constraint =
506 (SkCanvas::SrcRectConstraint)(packedVerb & kConstraint_DrawImageRectMask);
507 const SkRect* src = (packedVerb & kHasSrcRect_DrawImageRectMask) ?
508 skip<SkRect>(reader) : nullptr;
509 const SkRect* dst = skip<SkRect>(reader);
510 SkPaint paintStorage, *paint = nullptr;
511 if (packedVerb & kHasPaint_DrawImageRectMask) {
512 paintStorage = read_paint(reader);
513 paint = &paintStorage;
514 }
515 if (src) {
516 canvas->drawImageRect(image, *src, *dst, paint, constraint);
517 } else {
518 canvas->drawImageRect(image, *dst, paint);
519 }
520 }
521
drawImageNine_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)522 static void drawImageNine_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
523 SkASSERT(SkPipeVerb::kDrawImageNine == unpack_verb(packedVerb));
524 sk_sp<SkImage> image(reader.readImage());
525 const SkIRect* center = skip<SkIRect>(reader);
526 const SkRect* dst = skip<SkRect>(reader);
527 SkPaint paintStorage, *paint = nullptr;
528 if (packedVerb & kHasPaint_DrawImageNineMask) {
529 paintStorage = read_paint(reader);
530 paint = &paintStorage;
531 }
532 canvas->drawImageNine(image, *center, *dst, paint);
533 }
534
drawImageLattice_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)535 static void drawImageLattice_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
536 SkASSERT(SkPipeVerb::kDrawImageLattice == unpack_verb(packedVerb));
537 sk_sp<SkImage> image(reader.readImage());
538
539 SkCanvas::Lattice lattice;
540 lattice.fXCount = (packedVerb >> kXCount_DrawImageLatticeShift) & kCount_DrawImageLatticeMask;
541 if (lattice.fXCount == kCount_DrawImageLatticeMask) {
542 lattice.fXCount = reader.read32();
543 }
544 lattice.fYCount = (packedVerb >> kXCount_DrawImageLatticeShift) & kCount_DrawImageLatticeMask;
545 if (lattice.fYCount == kCount_DrawImageLatticeMask) {
546 lattice.fYCount = reader.read32();
547 }
548 lattice.fXDivs = skip<int32_t>(reader, lattice.fXCount);
549 lattice.fYDivs = skip<int32_t>(reader, lattice.fYCount);
550 if (packedVerb & kHasFlags_DrawImageLatticeMask) {
551 int32_t count = (lattice.fXCount + 1) * (lattice.fYCount + 1);
552 SkASSERT(count > 0);
553 lattice.fFlags = skip<SkCanvas::Lattice::Flags>(reader, SkAlign4(count));
554 } else {
555 lattice.fFlags = nullptr;
556 }
557 lattice.fBounds = skip<SkIRect>(reader);
558 const SkRect* dst = skip<SkRect>(reader);
559
560 SkPaint paintStorage, *paint = nullptr;
561 if (packedVerb & kHasPaint_DrawImageLatticeMask) {
562 paintStorage = read_paint(reader);
563 paint = &paintStorage;
564 }
565 canvas->drawImageLattice(image.get(), lattice, *dst, paint);
566 }
567
drawVertices_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)568 static void drawVertices_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
569 SkASSERT(SkPipeVerb::kDrawVertices == unpack_verb(packedVerb));
570 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)
571 ((packedVerb & kVMode_DrawVerticesMask) >> kVMode_DrawVerticesShift);
572 int vertexCount = packedVerb & kVCount_DrawVerticesMask;
573 if (0 == vertexCount) {
574 vertexCount = reader.read32();
575 }
576 sk_sp<SkXfermode> xfer;
577 unsigned xmode = (packedVerb & kXMode_DrawVerticesMask) >> kXMode_DrawVerticesShift;
578 if (0xFF == xmode) {
579 xfer = reader.readXfermode();
580 } else {
581 xfer = SkXfermode::Make((SkXfermode::Mode)xmode);
582 }
583 const SkPoint* vertices = skip<SkPoint>(reader, vertexCount);
584 const SkPoint* texs = nullptr;
585 if (packedVerb & kHasTex_DrawVerticesMask) {
586 texs = skip<SkPoint>(reader, vertexCount);
587 }
588 const SkColor* colors = nullptr;
589 if (packedVerb & kHasColors_DrawVerticesMask) {
590 colors = skip<SkColor>(reader, vertexCount);
591 }
592 int indexCount = 0;
593 const uint16_t* indices = nullptr;
594 if (packedVerb & kHasIndices_DrawVerticesMask) {
595 indexCount = reader.read32();
596 indices = skip<uint16_t>(reader, indexCount);
597 }
598
599 canvas->drawVertices(vmode, vertexCount, vertices, texs, colors, xfer.get(),
600 indices, indexCount, read_paint(reader));
601 }
602
drawPicture_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)603 static void drawPicture_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
604 SkASSERT(SkPipeVerb::kDrawPicture == unpack_verb(packedVerb));
605 unsigned extra = unpack_verb_extra(packedVerb);
606 int index = extra & kIndex_ObjectDefinitionMask;
607 SkPicture* pic = reader.getInflator()->getPicture(index);
608 SkMatrix matrixStorage, *matrix = nullptr;
609 SkPaint paintStorage, *paint = nullptr;
610 if (extra & kHasMatrix_DrawPictureExtra) {
611 reader.readMatrix(&matrixStorage);
612 matrix = &matrixStorage;
613 }
614 if (extra & kHasPaint_DrawPictureExtra) {
615 paintStorage = read_paint(reader);
616 paint = &paintStorage;
617 }
618 canvas->drawPicture(pic, matrix, paint);
619 }
620
drawAnnotation_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)621 static void drawAnnotation_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
622 SkASSERT(SkPipeVerb::kDrawAnnotation == unpack_verb(packedVerb));
623 const SkRect* rect = skip<SkRect>(reader);
624
625 // len includes the key's trailing 0
626 uint32_t len = unpack_verb_extra(packedVerb) >> 1;
627 if (0 == len) {
628 len = reader.read32();
629 }
630 const char* key = skip<char>(reader, len);
631 sk_sp<SkData> data;
632 if (packedVerb & 1) {
633 uint32_t size = reader.read32();
634 data = SkData::MakeWithCopy(reader.skip(SkAlign4(size)), size);
635 }
636 canvas->drawAnnotation(*rect, key, data);
637 }
638
639 #if 0
640 stream.write("skiacodc", 8);
641 stream.write32(pmap.width());
642 stream.write32(pmap.height());
643 stream.write16(pmap.colorType());
644 stream.write16(pmap.alphaType());
645 stream.write32(0); // no colorspace for now
646 for (int y = 0; y < pmap.height(); ++y) {
647 stream.write(pmap.addr8(0, y), pmap.width());
648 }
649 #endif
650
make_from_skiaimageformat(const void * encoded,size_t encodedSize)651 static sk_sp<SkImage> make_from_skiaimageformat(const void* encoded, size_t encodedSize) {
652 if (encodedSize < 24) {
653 return nullptr;
654 }
655
656 SkMemoryStream stream(encoded, encodedSize);
657 char signature[8];
658 stream.read(signature, 8);
659 if (memcmp(signature, "skiaimgf", 8)) {
660 return nullptr;
661 }
662
663 int width = stream.readU32();
664 int height = stream.readU32();
665 SkColorType ct = (SkColorType)stream.readU16();
666 SkAlphaType at = (SkAlphaType)stream.readU16();
667 SkASSERT(kAlpha_8_SkColorType == ct);
668
669 SkDEBUGCODE(size_t colorSpaceSize =) stream.readU32();
670 SkASSERT(0 == colorSpaceSize);
671
672 SkImageInfo info = SkImageInfo::Make(width, height, ct, at);
673 size_t size = width * height;
674 sk_sp<SkData> pixels = SkData::MakeUninitialized(size);
675 stream.read(pixels->writable_data(), size);
676 SkASSERT(encodedSize == SkAlign4(stream.getPosition()));
677 return SkImage::MakeRasterData(info, pixels, width);
678 }
679
make_from_encoded(const sk_sp<SkData> & data)680 static sk_sp<SkImage> make_from_encoded(const sk_sp<SkData>& data) {
681 sk_sp<SkImage> image = make_from_skiaimageformat(data->data(), data->size());
682 if (!image) {
683 image = SkImage::MakeFromEncoded(data);
684 }
685 return image;
686 }
687
defineImage_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas *)688 static void defineImage_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas*) {
689 SkASSERT(SkPipeVerb::kDefineImage == unpack_verb(packedVerb));
690 SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
691 uint32_t extra = unpack_verb_extra(packedVerb);
692 int index = extra & kIndex_ObjectDefinitionMask;
693
694 if (extra & kUndef_ObjectDefinitionMask) {
695 // zero-index means we are "forgetting" that cache entry
696 inflator->setImage(index, nullptr);
697 } else {
698 // we are defining a new image
699 sk_sp<SkData> data = reader.readByteArrayAsData();
700 sk_sp<SkImage> image = make_from_encoded(data);
701 if (!image) {
702 SkDebugf("-- failed to decode\n");
703 }
704 inflator->setImage(index, image.get());
705 }
706 }
707
makeTypeface(const void * data,size_t size)708 sk_sp<SkTypeface> SkPipeInflator::makeTypeface(const void* data, size_t size) {
709 if (fTFDeserializer) {
710 return fTFDeserializer->deserialize(data, size);
711 }
712 SkMemoryStream stream(data, size, false);
713 return SkTypeface::MakeDeserialize(&stream);
714 }
715
defineTypeface_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)716 static void defineTypeface_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
717 SkASSERT(SkPipeVerb::kDefineTypeface == unpack_verb(packedVerb));
718 SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
719 uint32_t extra = unpack_verb_extra(packedVerb);
720 int index = extra & kIndex_ObjectDefinitionMask;
721
722 if (extra & kUndef_ObjectDefinitionMask) {
723 // zero-index means we are "forgetting" that cache entry
724 inflator->setTypeface(index, nullptr);
725 } else {
726 // we are defining a new image
727 sk_sp<SkData> data = reader.readByteArrayAsData();
728 // TODO: seems like we could "peek" to see the array, and not need to copy it.
729 sk_sp<SkTypeface> tf = inflator->makeTypeface(data->data(), data->size());
730 inflator->setTypeface(index, tf.get());
731 }
732 }
733
defineFactory_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)734 static void defineFactory_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
735 SkASSERT(SkPipeVerb::kDefineFactory == unpack_verb(packedVerb));
736 SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
737 uint32_t extra = unpack_verb_extra(packedVerb);
738 int index = extra >> kNameLength_DefineFactoryExtraBits;
739 size_t len = extra & kNameLength_DefineFactoryExtraMask;
740 // +1 for the trailing null char
741 const char* name = (const char*)reader.skip(SkAlign4(len + 1));
742 SkFlattenable::Factory factory = reader.findFactory(name);
743 if (factory) {
744 inflator->setFactory(index, factory);
745 }
746 }
747
definePicture_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)748 static void definePicture_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
749 SkASSERT(SkPipeVerb::kDefinePicture == unpack_verb(packedVerb));
750 int deleteIndex = unpack_verb_extra(packedVerb);
751
752 SkPipeInflator* inflator = (SkPipeInflator*)reader.getInflator();
753
754 if (deleteIndex) {
755 inflator->setPicture(deleteIndex - 1, nullptr);
756 } else {
757 SkPictureRecorder recorder;
758 int pictureIndex = -1; // invalid
759 const SkRect* cull = skip<SkRect>(reader);
760 do_playback(reader, recorder.beginRecording(*cull), &pictureIndex);
761 SkASSERT(pictureIndex > 0);
762 sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
763 inflator->setPicture(pictureIndex, picture.get());
764 }
765 }
766
endPicture_handler(SkPipeReader & reader,uint32_t packedVerb,SkCanvas * canvas)767 static void endPicture_handler(SkPipeReader& reader, uint32_t packedVerb, SkCanvas* canvas) {
768 sk_throw(); // never call me
769 }
770
771 ///////////////////////////////////////////////////////////////////////////////////////////////////
772
773 struct HandlerRec {
774 SkPipeHandler fProc;
775 const char* fName;
776 };
777
778 #define HANDLER(name) { name##_handler, #name }
779 const HandlerRec gPipeHandlers[] = {
780 HANDLER(save),
781 HANDLER(saveLayer),
782 HANDLER(restore),
783 HANDLER(concat),
784
785 HANDLER(clipRect),
786 HANDLER(clipRRect),
787 HANDLER(clipPath),
788 HANDLER(clipRegion),
789
790 HANDLER(drawArc),
791 HANDLER(drawAtlas),
792 HANDLER(drawDRRect),
793 HANDLER(drawText),
794 HANDLER(drawPosText),
795 HANDLER(drawPosTextH),
796 HANDLER(drawRegion),
797 HANDLER(drawTextOnPath),
798 HANDLER(drawTextBlob),
799 HANDLER(drawTextRSXform),
800 HANDLER(drawPatch),
801 HANDLER(drawPaint),
802 HANDLER(drawPoints),
803 HANDLER(drawRect),
804 HANDLER(drawPath),
805 HANDLER(drawOval),
806 HANDLER(drawRRect),
807
808 HANDLER(drawImage),
809 HANDLER(drawImageRect),
810 HANDLER(drawImageNine),
811 HANDLER(drawImageLattice),
812
813 HANDLER(drawVertices),
814
815 HANDLER(drawPicture),
816 HANDLER(drawAnnotation),
817
818 HANDLER(defineImage),
819 HANDLER(defineTypeface),
820 HANDLER(defineFactory),
821 HANDLER(definePicture),
822 HANDLER(endPicture), // handled special -- should never be called
823 };
824 #undef HANDLER
825
826 ///////////////////////////////////////////////////////////////////////////////////////////////////
827
828 class SkPipeDeserializer::Impl {
829 public:
830 SkRefSet<SkImage> fImages;
831 SkRefSet<SkPicture> fPictures;
832 SkRefSet<SkTypeface> fTypefaces;
833 SkTDArray<SkFlattenable::Factory> fFactories;
834
835 SkTypefaceDeserializer* fTFDeserializer = nullptr;
836 };
837
SkPipeDeserializer()838 SkPipeDeserializer::SkPipeDeserializer() : fImpl(new Impl) {}
~SkPipeDeserializer()839 SkPipeDeserializer::~SkPipeDeserializer() {}
840
setTypefaceDeserializer(SkTypefaceDeserializer * tfd)841 void SkPipeDeserializer::setTypefaceDeserializer(SkTypefaceDeserializer* tfd) {
842 fImpl->fTFDeserializer = tfd;
843 }
844
readImage(const void * data,size_t size)845 sk_sp<SkImage> SkPipeDeserializer::readImage(const void* data, size_t size) {
846 if (size < sizeof(uint32_t)) {
847 SkDebugf("-------- data length too short for readImage %d\n", size);
848 return nullptr;
849 }
850
851 const uint32_t* ptr = (const uint32_t*)data;
852 uint32_t packedVerb = *ptr++;
853 size -= 4;
854
855 if (SkPipeVerb::kDefineImage == unpack_verb(packedVerb)) {
856 SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
857 &fImpl->fTypefaces, &fImpl->fFactories,
858 fImpl->fTFDeserializer);
859 SkPipeReader reader(this, ptr, size);
860 reader.setInflator(&inflator);
861 defineImage_handler(reader, packedVerb, nullptr);
862 packedVerb = reader.read32(); // read the next verb
863 }
864 if (SkPipeVerb::kWriteImage != unpack_verb(packedVerb)) {
865 SkDebugf("-------- unexpected verb for readImage %d\n", unpack_verb(packedVerb));
866 return nullptr;
867 }
868 int index = unpack_verb_extra(packedVerb);
869 if (0 == index) {
870 return nullptr; // writer failed
871 }
872 return sk_ref_sp(fImpl->fImages.get(index - 1));
873 }
874
readPicture(const void * data,size_t size)875 sk_sp<SkPicture> SkPipeDeserializer::readPicture(const void* data, size_t size) {
876 if (size < sizeof(uint32_t)) {
877 SkDebugf("-------- data length too short for readPicture %d\n", size);
878 return nullptr;
879 }
880
881 const uint32_t* ptr = (const uint32_t*)data;
882 uint32_t packedVerb = *ptr++;
883 size -= 4;
884
885 if (SkPipeVerb::kDefinePicture == unpack_verb(packedVerb)) {
886 SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
887 &fImpl->fTypefaces, &fImpl->fFactories,
888 fImpl->fTFDeserializer);
889 SkPipeReader reader(this, ptr, size);
890 reader.setInflator(&inflator);
891 definePicture_handler(reader, packedVerb, nullptr);
892 packedVerb = reader.read32(); // read the next verb
893 }
894 if (SkPipeVerb::kWritePicture != unpack_verb(packedVerb)) {
895 SkDebugf("-------- unexpected verb for readPicture %d\n", unpack_verb(packedVerb));
896 return nullptr;
897 }
898 int index = unpack_verb_extra(packedVerb);
899 if (0 == index) {
900 return nullptr; // writer failed
901 }
902 return sk_ref_sp(fImpl->fPictures.get(index - 1));
903 }
904
do_playback(SkPipeReader & reader,SkCanvas * canvas,int * endPictureIndex)905 static bool do_playback(SkPipeReader& reader, SkCanvas* canvas, int* endPictureIndex) {
906 int indent = 0;
907
908 const bool showEachVerb = false;
909 int counter = 0;
910 while (!reader.eof()) {
911 uint32_t prevOffset = reader.offset();
912 uint32_t packedVerb = reader.read32();
913 SkPipeVerb verb = unpack_verb(packedVerb);
914 if ((unsigned)verb >= SK_ARRAY_COUNT(gPipeHandlers)) {
915 SkDebugf("------- bad verb %d\n", verb);
916 return false;
917 }
918 if (SkPipeVerb::kRestore == verb) {
919 indent -= 1;
920 SkASSERT(indent >= 0);
921 }
922
923 if (SkPipeVerb::kEndPicture == verb) {
924 if (endPictureIndex) {
925 *endPictureIndex = unpack_verb_extra(packedVerb);
926 }
927 return true;
928 }
929 HandlerRec rec = gPipeHandlers[(unsigned)verb];
930 rec.fProc(reader, packedVerb, canvas);
931 if (showEachVerb) {
932 for (int i = 0; i < indent; ++i) {
933 SkDebugf(" ");
934 }
935 SkDebugf("%d [%d] %s %d\n", prevOffset, counter++, rec.fName, reader.offset() - prevOffset);
936 }
937 if (!reader.isValid()) {
938 SkDebugf("-------- bad reader\n");
939 return false;
940 }
941
942 switch (verb) {
943 case SkPipeVerb::kSave:
944 case SkPipeVerb::kSaveLayer:
945 indent += 1;
946 break;
947 default:
948 break;
949 }
950 }
951 return true;
952 }
953
playback(const void * data,size_t size,SkCanvas * canvas)954 bool SkPipeDeserializer::playback(const void* data, size_t size, SkCanvas* canvas) {
955 SkPipeInflator inflator(&fImpl->fImages, &fImpl->fPictures,
956 &fImpl->fTypefaces, &fImpl->fFactories,
957 fImpl->fTFDeserializer);
958 SkPipeReader reader(this, data, size);
959 reader.setInflator(&inflator);
960 return do_playback(reader, canvas);
961 }
962
963