1 /*
2 * Copyright 2014 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 #include "src/core/SkPicturePlayback.h"
8
9 #include "include/core/SkBlendMode.h"
10 #include "include/core/SkCanvas.h"
11 #include "include/core/SkClipOp.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkData.h"
14 #include "include/core/SkImage.h"
15 #include "include/core/SkImageFilter.h"
16 #include "include/core/SkMatrix.h"
17 #include "include/core/SkPaint.h"
18 #include "include/core/SkPoint.h"
19 #include "include/core/SkRRect.h"
20 #include "include/core/SkRSXform.h"
21 #include "include/core/SkRect.h"
22 #include "include/core/SkRefCnt.h"
23 #include "include/core/SkRegion.h"
24 #include "include/core/SkSamplingOptions.h"
25 #include "include/core/SkScalar.h"
26 #include "include/core/SkString.h"
27 #include "include/core/SkTileMode.h"
28 #include "include/core/SkTypes.h"
29 #include "include/private/base/SkAlign.h"
30 #include "include/private/base/SkTArray.h"
31 #include "include/private/base/SkTemplates.h"
32 #include "include/private/base/SkTo.h"
33 #include "src/base/SkSafeMath.h"
34 #include "src/core/SkCanvasPriv.h"
35 #include "src/core/SkDrawShadowInfo.h"
36 #include "src/core/SkPictureData.h"
37 #include "src/core/SkPictureFlat.h"
38 #include "src/core/SkPicturePriv.h"
39 #include "src/core/SkReadBuffer.h"
40 #include "src/core/SkVerticesPriv.h"
41 #include "src/utils/SkPatchUtils.h"
42
43 class SkDrawable;
44 class SkPath;
45 class SkTextBlob;
46 class SkVertices;
47
48 namespace sktext { namespace gpu { class Slug; } }
49
50 using namespace skia_private;
51
get_rect_ptr(SkReadBuffer * reader,SkRect * storage)52 static const SkRect* get_rect_ptr(SkReadBuffer* reader, SkRect* storage) {
53 if (reader->readBool()) {
54 reader->readRect(storage);
55 return storage;
56 } else {
57 return nullptr;
58 }
59 }
60
draw(SkCanvas * canvas,SkPicture::AbortCallback * callback,SkReadBuffer * buffer)61 void SkPicturePlayback::draw(SkCanvas* canvas,
62 SkPicture::AbortCallback* callback,
63 SkReadBuffer* buffer) {
64 AutoResetOpID aroi(this);
65 SkASSERT(0 == fCurOffset);
66
67 SkReadBuffer reader(fPictureData->opData()->bytes(),
68 fPictureData->opData()->size());
69 reader.setVersion(fPictureData->info().getVersion());
70
71 // Record this, so we can concat w/ it if we encounter a setMatrix()
72 SkM44 initialMatrix = canvas->getLocalToDevice();
73
74 SkAutoCanvasRestore acr(canvas, false);
75
76 while (!reader.eof() && reader.isValid()) {
77 if (callback && callback->abort()) {
78 return;
79 }
80
81 fCurOffset = reader.offset();
82
83 uint32_t bits = reader.readInt();
84 uint32_t op = bits >> 24,
85 size = bits & 0xffffff;
86 if (size == 0xffffff) {
87 size = reader.readInt();
88 }
89
90 if (!reader.validate(size > 0 && op > UNUSED && op <= LAST_DRAWTYPE_ENUM)) {
91 return;
92 }
93
94 this->handleOp(&reader, (DrawType)op, size, canvas, initialMatrix);
95 }
96
97 // need to propagate invalid state to the parent reader
98 if (buffer) {
99 buffer->validate(reader.isValid());
100 }
101 }
102
validate_offsetToRestore(SkReadBuffer * reader,size_t offsetToRestore)103 static void validate_offsetToRestore(SkReadBuffer* reader, size_t offsetToRestore) {
104 if (offsetToRestore) {
105 reader->validate(SkIsAlign4(offsetToRestore) && offsetToRestore >= reader->offset());
106 }
107 }
108
do_clip_op(SkReadBuffer * reader,SkCanvas * canvas,SkRegion::Op op,SkClipOp * clipOpToUse)109 static bool do_clip_op(SkReadBuffer* reader, SkCanvas* canvas, SkRegion::Op op,
110 SkClipOp* clipOpToUse) {
111 switch(op) {
112 case SkRegion::kDifference_Op:
113 case SkRegion::kIntersect_Op:
114 // Fully supported, identity mapping between SkClipOp and Region::Op
115 *clipOpToUse = static_cast<SkClipOp>(op);
116 return true;
117 case SkRegion::kReplace_Op:
118 // Emulate the replace by resetting first and following it up with an intersect
119 SkASSERT(reader->isVersionLT(SkPicturePriv::kNoExpandingClipOps));
120 SkCanvasPriv::ResetClip(canvas);
121 *clipOpToUse = SkClipOp::kIntersect;
122 return true;
123 default:
124 // An expanding clip op, which if encountered on an old SKP, we just silently ignore
125 SkASSERT(reader->isVersionLT(SkPicturePriv::kNoExpandingClipOps));
126 return false;
127 }
128 }
129
handleOp(SkReadBuffer * reader,DrawType op,uint32_t size,SkCanvas * canvas,const SkM44 & initialMatrix)130 void SkPicturePlayback::handleOp(SkReadBuffer* reader,
131 DrawType op,
132 uint32_t size,
133 SkCanvas* canvas,
134 const SkM44& initialMatrix) {
135 #define BREAK_ON_READ_ERROR(r) if (!r->isValid()) break
136
137 switch (op) {
138 case NOOP: {
139 SkASSERT(size >= 4);
140 reader->skip(size - 4);
141 } break;
142 case FLUSH:
143 break;
144 case CLIP_PATH: {
145 const SkPath& path = fPictureData->getPath(reader);
146 uint32_t packed = reader->readInt();
147 SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed);
148 bool doAA = ClipParams_unpackDoAA(packed);
149 size_t offsetToRestore = reader->readInt();
150 validate_offsetToRestore(reader, offsetToRestore);
151 BREAK_ON_READ_ERROR(reader);
152
153 SkClipOp clipOp;
154 if (do_clip_op(reader, canvas, rgnOp, &clipOp)) {
155 canvas->clipPath(path, clipOp, doAA);
156 }
157 if (canvas->isClipEmpty() && offsetToRestore) {
158 reader->skip(offsetToRestore - reader->offset());
159 }
160 } break;
161 case CLIP_REGION: {
162 SkRegion region;
163 reader->readRegion(®ion);
164 uint32_t packed = reader->readInt();
165 SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed);
166 size_t offsetToRestore = reader->readInt();
167 validate_offsetToRestore(reader, offsetToRestore);
168 BREAK_ON_READ_ERROR(reader);
169
170 SkClipOp clipOp;
171 if (do_clip_op(reader, canvas, rgnOp, &clipOp)) {
172 canvas->clipRegion(region, clipOp);
173 }
174 if (canvas->isClipEmpty() && offsetToRestore) {
175 reader->skip(offsetToRestore - reader->offset());
176 }
177 } break;
178 case CLIP_RECT: {
179 SkRect rect;
180 reader->readRect(&rect);
181 uint32_t packed = reader->readInt();
182 SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed);
183 bool doAA = ClipParams_unpackDoAA(packed);
184 size_t offsetToRestore = reader->readInt();
185 validate_offsetToRestore(reader, offsetToRestore);
186 BREAK_ON_READ_ERROR(reader);
187
188 SkClipOp clipOp;
189 if (do_clip_op(reader, canvas, rgnOp, &clipOp)) {
190 canvas->clipRect(rect, clipOp, doAA);
191 }
192 if (canvas->isClipEmpty() && offsetToRestore) {
193 reader->skip(offsetToRestore - reader->offset());
194 }
195 } break;
196 case CLIP_RRECT: {
197 SkRRect rrect;
198 reader->readRRect(&rrect);
199 uint32_t packed = reader->readInt();
200 SkRegion::Op rgnOp = ClipParams_unpackRegionOp(reader, packed);
201 bool doAA = ClipParams_unpackDoAA(packed);
202 size_t offsetToRestore = reader->readInt();
203 validate_offsetToRestore(reader, offsetToRestore);
204 BREAK_ON_READ_ERROR(reader);
205
206 SkClipOp clipOp;
207 if (do_clip_op(reader, canvas, rgnOp, &clipOp)) {
208 canvas->clipRRect(rrect, clipOp, doAA);
209 }
210 if (canvas->isClipEmpty() && offsetToRestore) {
211 reader->skip(offsetToRestore - reader->offset());
212 }
213 } break;
214 case CLIP_SHADER_IN_PAINT: {
215 const SkPaint& paint = fPictureData->requiredPaint(reader);
216 // clipShader() was never used in conjunction with deprecated, expanding clip ops, so
217 // it requires the op to just be intersect or difference.
218 SkClipOp clipOp = reader->checkRange(SkClipOp::kDifference, SkClipOp::kIntersect);
219 BREAK_ON_READ_ERROR(reader);
220
221 canvas->clipShader(paint.refShader(), clipOp);
222 } break;
223 case RESET_CLIP:
224 // For Android, an emulated "replace" clip op appears as a manual reset followed by
225 // an intersect operation (equivalent to the above handling of replace ops encountered
226 // in old serialized pictures).
227 SkCanvasPriv::ResetClip(canvas);
228 break;
229 case PUSH_CULL: break; // Deprecated, safe to ignore both push and pop.
230 case POP_CULL: break;
231 case CONCAT: {
232 SkMatrix matrix;
233 reader->readMatrix(&matrix);
234 BREAK_ON_READ_ERROR(reader);
235
236 canvas->concat(matrix);
237 break;
238 }
239 case CONCAT44: {
240 const SkScalar* colMaj = reader->skipT<SkScalar>(16);
241 BREAK_ON_READ_ERROR(reader);
242 canvas->concat(SkM44::ColMajor(colMaj));
243 break;
244 }
245 case DRAW_ANNOTATION: {
246 SkRect rect;
247 reader->readRect(&rect);
248 SkString key;
249 reader->readString(&key);
250 sk_sp<SkData> data = reader->readByteArrayAsData();
251 BREAK_ON_READ_ERROR(reader);
252 SkASSERT(data);
253
254 canvas->drawAnnotation(rect, key.c_str(), data.get());
255 } break;
256 case DRAW_ARC: {
257 const SkPaint& paint = fPictureData->requiredPaint(reader);
258 SkRect rect;
259 reader->readRect(&rect);
260 SkScalar startAngle = reader->readScalar();
261 SkScalar sweepAngle = reader->readScalar();
262 int useCenter = reader->readInt();
263 BREAK_ON_READ_ERROR(reader);
264
265 canvas->drawArc(rect, startAngle, sweepAngle, SkToBool(useCenter), paint);
266 } break;
267 case DRAW_ATLAS: {
268 const SkPaint* paint = fPictureData->optionalPaint(reader);
269 const SkImage* atlas = fPictureData->getImage(reader);
270 const uint32_t flags = reader->readUInt();
271 const int count = reader->readUInt();
272 const SkRSXform* xform = (const SkRSXform*)reader->skip(count, sizeof(SkRSXform));
273 const SkRect* tex = (const SkRect*)reader->skip(count, sizeof(SkRect));
274 const SkColor* colors = nullptr;
275 SkBlendMode mode = SkBlendMode::kDst;
276 if (flags & DRAW_ATLAS_HAS_COLORS) {
277 colors = (const SkColor*)reader->skip(count, sizeof(SkColor));
278 mode = reader->read32LE(SkBlendMode::kLastMode);
279 BREAK_ON_READ_ERROR(reader);
280 }
281 const SkRect* cull = nullptr;
282 if (flags & DRAW_ATLAS_HAS_CULL) {
283 cull = (const SkRect*)reader->skip(sizeof(SkRect));
284 }
285 BREAK_ON_READ_ERROR(reader);
286
287 SkSamplingOptions sampling;
288 if (flags & DRAW_ATLAS_HAS_SAMPLING) {
289 sampling = reader->readSampling();
290 BREAK_ON_READ_ERROR(reader);
291 }
292 canvas->drawAtlas(atlas, xform, tex, colors, count, mode, sampling, cull, paint);
293 } break;
294 case DRAW_CLEAR: {
295 auto c = reader->readInt();
296 BREAK_ON_READ_ERROR(reader);
297
298 canvas->clear(c);
299 } break;
300 case DRAW_DATA: {
301 // This opcode is now dead, just need to skip it for backwards compatibility
302 size_t length = reader->readInt();
303 (void)reader->skip(length);
304 // skip handles padding the read out to a multiple of 4
305 } break;
306 case DRAW_DRAWABLE: {
307 auto* d = fPictureData->getDrawable(reader);
308 BREAK_ON_READ_ERROR(reader);
309
310 canvas->drawDrawable(d);
311 } break;
312 case DRAW_DRAWABLE_MATRIX: {
313 SkMatrix matrix;
314 reader->readMatrix(&matrix);
315 SkDrawable* drawable = fPictureData->getDrawable(reader);
316 BREAK_ON_READ_ERROR(reader);
317
318 canvas->drawDrawable(drawable, &matrix);
319 } break;
320 case DRAW_DRRECT: {
321 const SkPaint& paint = fPictureData->requiredPaint(reader);
322 SkRRect outer, inner;
323 reader->readRRect(&outer);
324 reader->readRRect(&inner);
325 BREAK_ON_READ_ERROR(reader);
326
327 canvas->drawDRRect(outer, inner, paint);
328 } break;
329 case DRAW_EDGEAA_QUAD: {
330 SkRect rect;
331 reader->readRect(&rect);
332 SkCanvas::QuadAAFlags aaFlags = static_cast<SkCanvas::QuadAAFlags>(reader->read32());
333 SkColor4f color;
334 reader->readColor4f(&color);
335 SkBlendMode blend = reader->read32LE(SkBlendMode::kLastMode);
336 BREAK_ON_READ_ERROR(reader);
337 bool hasClip = reader->readInt();
338 const SkPoint* clip = nullptr;
339 if (hasClip) {
340 clip = (const SkPoint*) reader->skip(4, sizeof(SkPoint));
341 }
342 BREAK_ON_READ_ERROR(reader);
343 canvas->experimental_DrawEdgeAAQuad(rect, clip, aaFlags, color, blend);
344 } break;
345 case DRAW_EDGEAA_IMAGE_SET:
346 case DRAW_EDGEAA_IMAGE_SET2: {
347 static const size_t kEntryReadSize =
348 4 * sizeof(uint32_t) + 2 * sizeof(SkRect) + sizeof(SkScalar);
349 static const size_t kMatrixSize = 9 * sizeof(SkScalar); // != sizeof(SkMatrix)
350
351 int cnt = reader->readInt();
352 if (!reader->validate(cnt >= 0)) {
353 break;
354 }
355 const SkPaint* paint = fPictureData->optionalPaint(reader);
356
357 SkSamplingOptions sampling;
358 if (op == DRAW_EDGEAA_IMAGE_SET2) {
359 sampling = reader->readSampling();
360 } else {
361 sampling = SkSamplingOptions(SkFilterMode::kNearest);
362 }
363
364 SkCanvas::SrcRectConstraint constraint =
365 reader->checkRange(SkCanvas::kStrict_SrcRectConstraint,
366 SkCanvas::kFast_SrcRectConstraint);
367
368 if (!reader->validate(SkSafeMath::Mul(cnt, kEntryReadSize) <= reader->available())) {
369 break;
370 }
371
372 // Track minimum necessary clip points and matrices that must be provided to satisfy
373 // the entries.
374 int expectedClipPointCount = 0;
375 int maxMatrixIndex = -1;
376 AutoTArray<SkCanvas::ImageSetEntry> set(cnt);
377 for (int i = 0; i < cnt && reader->isValid(); ++i) {
378 set[i].fImage = sk_ref_sp(fPictureData->getImage(reader));
379 reader->readRect(&set[i].fSrcRect);
380 reader->readRect(&set[i].fDstRect);
381 set[i].fMatrixIndex = reader->readInt();
382 set[i].fAlpha = reader->readScalar();
383 set[i].fAAFlags = reader->readUInt();
384 set[i].fHasClip = reader->readInt();
385
386 expectedClipPointCount += set[i].fHasClip ? 4 : 0; // 4 points per clip quad
387 if (set[i].fMatrixIndex > maxMatrixIndex) {
388 maxMatrixIndex = set[i].fMatrixIndex;
389 }
390 }
391
392 int dstClipPointCount = reader->readInt();
393 const SkPoint* dstClips = nullptr;
394 if (!reader->validate(dstClipPointCount >= 0) ||
395 !reader->validate(expectedClipPointCount == dstClipPointCount)) {
396 // A bad dstClipCount (either negative, or not enough to satisfy entries).
397 // Use exact comparison; the serialized SKP should only have included the exact
398 // amount used by the recorded draw, even if the original array was larger.
399 break;
400 } else if (dstClipPointCount > 0) {
401 dstClips = (const SkPoint*) reader->skip(dstClipPointCount, sizeof(SkPoint));
402 if (dstClips == nullptr) {
403 // Not enough bytes remaining so the reader has been invalidated
404 break;
405 }
406 }
407 int matrixCount = reader->readInt();
408 if (!reader->validate(matrixCount >= 0) ||
409 !reader->validate(maxMatrixIndex == (matrixCount - 1)) ||
410 !reader->validate(
411 SkSafeMath::Mul(matrixCount, kMatrixSize) <= reader->available())) {
412 // Entries access out-of-bound matrix indices, given provided matrices or
413 // there aren't enough bytes to provide that many matrices
414 break;
415 }
416 TArray<SkMatrix> matrices(matrixCount);
417 for (int i = 0; i < matrixCount && reader->isValid(); ++i) {
418 reader->readMatrix(&matrices.push_back());
419 }
420 BREAK_ON_READ_ERROR(reader);
421
422 canvas->experimental_DrawEdgeAAImageSet(set.get(), cnt, dstClips, matrices.begin(),
423 sampling, paint, constraint);
424 } break;
425 case DRAW_IMAGE: {
426 const SkPaint* paint = fPictureData->optionalPaint(reader);
427 const SkImage* image = fPictureData->getImage(reader);
428 SkPoint loc;
429 reader->readPoint(&loc);
430 BREAK_ON_READ_ERROR(reader);
431
432 canvas->drawImage(image, loc.fX, loc.fY,
433 SkSamplingOptions(SkFilterMode::kNearest),
434 paint);
435 } break;
436 case DRAW_IMAGE2: {
437 const SkPaint* paint = fPictureData->optionalPaint(reader);
438 const SkImage* image = fPictureData->getImage(reader);
439 SkPoint loc;
440 reader->readPoint(&loc);
441 SkSamplingOptions sampling = reader->readSampling();
442 BREAK_ON_READ_ERROR(reader);
443
444 canvas->drawImage(image, loc.fX, loc.fY, sampling, paint);
445 } break;
446 case DRAW_IMAGE_LATTICE: {
447 const SkPaint* paint = fPictureData->optionalPaint(reader);
448 const SkImage* image = fPictureData->getImage(reader);
449 SkCanvas::Lattice lattice;
450 (void)SkCanvasPriv::ReadLattice(*reader, &lattice);
451 const SkRect* dst = reader->skipT<SkRect>();
452 BREAK_ON_READ_ERROR(reader);
453
454 canvas->drawImageLattice(image, lattice, *dst, SkFilterMode::kNearest, paint);
455 } break;
456 case DRAW_IMAGE_LATTICE2: {
457 const SkPaint* paint = fPictureData->optionalPaint(reader);
458 const SkImage* image = fPictureData->getImage(reader);
459 SkCanvas::Lattice lattice;
460 (void)SkCanvasPriv::ReadLattice(*reader, &lattice);
461 const SkRect* dst = reader->skipT<SkRect>();
462 SkFilterMode filter = reader->read32LE(SkFilterMode::kLinear);
463 BREAK_ON_READ_ERROR(reader);
464
465 canvas->drawImageLattice(image, lattice, *dst, filter, paint);
466 } break;
467 case DRAW_IMAGE_NINE: {
468 const SkPaint* paint = fPictureData->optionalPaint(reader);
469 const SkImage* image = fPictureData->getImage(reader);
470 SkIRect center;
471 reader->readIRect(¢er);
472 SkRect dst;
473 reader->readRect(&dst);
474 BREAK_ON_READ_ERROR(reader);
475
476 canvas->drawImageNine(image, center, dst, SkFilterMode::kNearest, paint);
477 } break;
478 case DRAW_IMAGE_RECT: {
479 const SkPaint* paint = fPictureData->optionalPaint(reader);
480 const SkImage* image = fPictureData->getImage(reader);
481 SkRect storage;
482 const SkRect* src = get_rect_ptr(reader, &storage); // may be null
483 SkRect dst;
484 reader->readRect(&dst); // required
485 // DRAW_IMAGE_RECT_STRICT assumes this constraint, and doesn't store it
486 SkCanvas::SrcRectConstraint constraint = SkCanvas::kStrict_SrcRectConstraint;
487 if (DRAW_IMAGE_RECT == op) {
488 // newer op-code stores the constraint explicitly
489 constraint = reader->checkRange(SkCanvas::kStrict_SrcRectConstraint,
490 SkCanvas::kFast_SrcRectConstraint);
491 }
492 BREAK_ON_READ_ERROR(reader);
493
494 auto sampling = SkSamplingOptions(SkFilterMode::kNearest);
495 if (src) {
496 canvas->drawImageRect(image, *src, dst, sampling, paint, constraint);
497 } else {
498 canvas->drawImageRect(image, dst, sampling, paint);
499 }
500 } break;
501 case DRAW_IMAGE_RECT2: {
502 const SkPaint* paint = fPictureData->optionalPaint(reader);
503 const SkImage* image = fPictureData->getImage(reader);
504 SkRect src = reader->readRect();
505 SkRect dst = reader->readRect();
506 SkSamplingOptions sampling = reader->readSampling();
507 auto constraint = reader->read32LE(SkCanvas::kFast_SrcRectConstraint);
508 BREAK_ON_READ_ERROR(reader);
509
510 canvas->drawImageRect(image, src, dst, sampling, paint, constraint);
511 } break;
512 case DRAW_OVAL: {
513 const SkPaint& paint = fPictureData->requiredPaint(reader);
514 SkRect rect;
515 reader->readRect(&rect);
516 BREAK_ON_READ_ERROR(reader);
517
518 canvas->drawOval(rect, paint);
519 } break;
520 case DRAW_PAINT: {
521 const SkPaint& paint = fPictureData->requiredPaint(reader);
522 BREAK_ON_READ_ERROR(reader);
523
524 canvas->drawPaint(paint);
525 } break;
526 case DRAW_BEHIND_PAINT: {
527 const SkPaint& paint = fPictureData->requiredPaint(reader);
528 BREAK_ON_READ_ERROR(reader);
529
530 SkCanvasPriv::DrawBehind(canvas, paint);
531 } break;
532 case DRAW_PATCH: {
533 const SkPaint& paint = fPictureData->requiredPaint(reader);
534
535 const SkPoint* cubics = (const SkPoint*)reader->skip(SkPatchUtils::kNumCtrlPts,
536 sizeof(SkPoint));
537 uint32_t flag = reader->readInt();
538 const SkColor* colors = nullptr;
539 if (flag & DRAW_VERTICES_HAS_COLORS) {
540 colors = (const SkColor*)reader->skip(SkPatchUtils::kNumCorners, sizeof(SkColor));
541 }
542 const SkPoint* texCoords = nullptr;
543 if (flag & DRAW_VERTICES_HAS_TEXS) {
544 texCoords = (const SkPoint*)reader->skip(SkPatchUtils::kNumCorners,
545 sizeof(SkPoint));
546 }
547 SkBlendMode bmode = SkBlendMode::kModulate;
548 if (flag & DRAW_VERTICES_HAS_XFER) {
549 unsigned mode = reader->readInt();
550 if (mode <= (unsigned)SkBlendMode::kLastMode) {
551 bmode = (SkBlendMode)mode;
552 }
553 }
554 BREAK_ON_READ_ERROR(reader);
555
556 canvas->drawPatch(cubics, colors, texCoords, bmode, paint);
557 } break;
558 case DRAW_PATH: {
559 const SkPaint& paint = fPictureData->requiredPaint(reader);
560 const auto& path = fPictureData->getPath(reader);
561 BREAK_ON_READ_ERROR(reader);
562
563 canvas->drawPath(path, paint);
564 } break;
565 case DRAW_PICTURE: {
566 const auto* pic = fPictureData->getPicture(reader);
567 BREAK_ON_READ_ERROR(reader);
568
569 canvas->drawPicture(pic);
570 } break;
571 case DRAW_PICTURE_MATRIX_PAINT: {
572 const SkPaint* paint = fPictureData->optionalPaint(reader);
573 SkMatrix matrix;
574 reader->readMatrix(&matrix);
575 const SkPicture* pic = fPictureData->getPicture(reader);
576 BREAK_ON_READ_ERROR(reader);
577
578 canvas->drawPicture(pic, &matrix, paint);
579 } break;
580 case DRAW_POINTS: {
581 const SkPaint& paint = fPictureData->requiredPaint(reader);
582 SkCanvas::PointMode mode = reader->checkRange(SkCanvas::kPoints_PointMode,
583 SkCanvas::kPolygon_PointMode);
584 size_t count = reader->readInt();
585 const SkPoint* pts = (const SkPoint*)reader->skip(count, sizeof(SkPoint));
586 BREAK_ON_READ_ERROR(reader);
587
588 canvas->drawPoints(mode, count, pts, paint);
589 } break;
590 case DRAW_RECT: {
591 const SkPaint& paint = fPictureData->requiredPaint(reader);
592 SkRect rect;
593 reader->readRect(&rect);
594 BREAK_ON_READ_ERROR(reader);
595
596 canvas->drawRect(rect, paint);
597 } break;
598 case DRAW_REGION: {
599 const SkPaint& paint = fPictureData->requiredPaint(reader);
600 SkRegion region;
601 reader->readRegion(®ion);
602 BREAK_ON_READ_ERROR(reader);
603
604 canvas->drawRegion(region, paint);
605 } break;
606 case DRAW_RRECT: {
607 const SkPaint& paint = fPictureData->requiredPaint(reader);
608 SkRRect rrect;
609 reader->readRRect(&rrect);
610 BREAK_ON_READ_ERROR(reader);
611
612 canvas->drawRRect(rrect, paint);
613 } break;
614 case DRAW_SHADOW_REC: {
615 const auto& path = fPictureData->getPath(reader);
616 SkDrawShadowRec rec;
617 reader->readPoint3(&rec.fZPlaneParams);
618 reader->readPoint3(&rec.fLightPos);
619 rec.fLightRadius = reader->readScalar();
620 rec.fAmbientColor = reader->read32();
621 rec.fSpotColor = reader->read32();
622 rec.fFlags = reader->read32();
623 BREAK_ON_READ_ERROR(reader);
624
625 canvas->private_draw_shadow_rec(path, rec);
626 } break;
627 case DRAW_TEXT_BLOB: {
628 const SkPaint& paint = fPictureData->requiredPaint(reader);
629 const SkTextBlob* blob = fPictureData->getTextBlob(reader);
630 SkScalar x = reader->readScalar();
631 SkScalar y = reader->readScalar();
632 BREAK_ON_READ_ERROR(reader);
633
634 canvas->drawTextBlob(blob, x, y, paint);
635 } break;
636 case DRAW_SLUG: {
637 const SkPaint& paint = fPictureData->requiredPaint(reader);
638 const sktext::gpu::Slug* slug = fPictureData->getSlug(reader);
639 BREAK_ON_READ_ERROR(reader);
640
641 canvas->drawSlug(slug, paint);
642 } break;
643 case DRAW_VERTICES_OBJECT: {
644 const SkPaint& paint = fPictureData->requiredPaint(reader);
645 const SkVertices* vertices = fPictureData->getVertices(reader);
646 const int boneCount = reader->readInt();
647 (void)reader->skip(boneCount, sizeof(SkVertices_DeprecatedBone));
648 SkBlendMode bmode = reader->read32LE(SkBlendMode::kLastMode);
649 BREAK_ON_READ_ERROR(reader);
650
651 if (vertices) { // TODO: read error if vertices == null?
652 canvas->drawVertices(vertices, bmode, paint);
653 }
654 } break;
655 case RESTORE:
656 canvas->restore();
657 break;
658 case ROTATE: {
659 auto deg = reader->readScalar();
660 canvas->rotate(deg);
661 } break;
662 case SAVE:
663 canvas->save();
664 break;
665 case SAVE_BEHIND: {
666 uint32_t flags = reader->readInt();
667 const SkRect* subset = nullptr;
668 SkRect storage;
669 if (flags & SAVEBEHIND_HAS_SUBSET) {
670 reader->readRect(&storage);
671 subset = &storage;
672 }
673 SkCanvasPriv::SaveBehind(canvas, subset);
674 } break;
675 case SAVE_LAYER_SAVELAYERREC: {
676 SkCanvas::SaveLayerRec rec(nullptr, nullptr, nullptr, 0);
677 const uint32_t flatFlags = reader->readInt();
678 SkRect bounds;
679 skia_private::AutoSTArray<2, sk_sp<SkImageFilter>> filters;
680 if (flatFlags & SAVELAYERREC_HAS_BOUNDS) {
681 reader->readRect(&bounds);
682 rec.fBounds = &bounds;
683 }
684 if (flatFlags & SAVELAYERREC_HAS_PAINT) {
685 rec.fPaint = &fPictureData->requiredPaint(reader);
686 }
687 if (flatFlags & SAVELAYERREC_HAS_BACKDROP) {
688 const SkPaint& paint = fPictureData->requiredPaint(reader);
689 rec.fBackdrop = paint.getImageFilter();
690 }
691 if (flatFlags & SAVELAYERREC_HAS_FLAGS) {
692 rec.fSaveLayerFlags = reader->readInt();
693 }
694 if (flatFlags & SAVELAYERREC_HAS_CLIPMASK_OBSOLETE) {
695 (void)fPictureData->getImage(reader);
696 }
697 if (flatFlags & SAVELAYERREC_HAS_CLIPMATRIX_OBSOLETE) {
698 SkMatrix clipMatrix_ignored;
699 reader->readMatrix(&clipMatrix_ignored);
700 }
701 if (!reader->isVersionLT(SkPicturePriv::Version::kBackdropScaleFactor) &&
702 (flatFlags & SAVELAYERREC_HAS_BACKDROP_SCALE)) {
703 SkCanvasPriv::SetBackdropScaleFactor(&rec, reader->readScalar());
704 }
705 if (!reader->isVersionLT(SkPicturePriv::Version::kMultipleFiltersOnSaveLayer) &&
706 (flatFlags & SAVELAYERREC_HAS_MULTIPLE_FILTERS)) {
707 int filterCount = reader->readUInt();
708 reader->validate(filterCount > 0 && filterCount <= SkCanvas::kMaxFiltersPerLayer);
709 BREAK_ON_READ_ERROR(reader);
710 filters.reset(filterCount);
711 for (int i = 0; i < filterCount; ++i) {
712 const SkPaint& paint = fPictureData->requiredPaint(reader);
713 filters[i] = paint.refImageFilter();
714 }
715 rec.fFilters = filters;
716 }
717 if (!reader->isVersionLT(SkPicturePriv::Version::kSaveLayerBackdropTileMode) &&
718 (flatFlags & SAVELAYERREC_HAS_BACKDROP_TILEMODE)) {
719 rec.fBackdropTileMode = reader->read32LE(SkTileMode::kLastTileMode);
720 }
721 BREAK_ON_READ_ERROR(reader);
722
723 canvas->saveLayer(rec);
724 } break;
725 case SCALE: {
726 SkScalar sx = reader->readScalar();
727 SkScalar sy = reader->readScalar();
728 canvas->scale(sx, sy);
729 } break;
730 case SET_M44: {
731 SkM44 m;
732 reader->read(&m);
733 canvas->setMatrix(initialMatrix * m);
734 } break;
735 case SET_MATRIX: {
736 SkMatrix matrix;
737 reader->readMatrix(&matrix);
738 canvas->setMatrix(initialMatrix * SkM44(matrix));
739 } break;
740 case SKEW: {
741 SkScalar sx = reader->readScalar();
742 SkScalar sy = reader->readScalar();
743 canvas->skew(sx, sy);
744 } break;
745 case TRANSLATE: {
746 SkScalar dx = reader->readScalar();
747 SkScalar dy = reader->readScalar();
748 canvas->translate(dx, dy);
749 } break;
750 default:
751 reader->validate(false); // unknown op
752 break;
753 }
754
755 #undef BREAK_ON_READ_ERROR
756 }
757