blob: d53e40d83c74c6d3da302cd2216b2d924ccb8839 [file] [log] [blame]
reed54dc4872016-09-13 08:09:45 -07001/*
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
Hal Canary95e3c052017-01-11 12:44:43 -05008#include "SkAutoMalloc.h"
reed54dc4872016-09-13 08:09:45 -07009#include "SkColorFilter.h"
10#include "SkDrawLooper.h"
11#include "SkImageFilter.h"
12#include "SkMaskFilter.h"
Hal Canary95e3c052017-01-11 12:44:43 -050013#include "SkPathEffect.h"
reed54dc4872016-09-13 08:09:45 -070014#include "SkPipeCanvas.h"
15#include "SkPipeFormat.h"
Mike Reed60691a52017-12-05 15:11:24 -050016#include "SkPixelSerializer.h"
Kevin Lubickc456b732017-01-11 17:21:57 +000017#include "SkRSXform.h"
Hal Canary95e3c052017-01-11 12:44:43 -050018#include "SkRasterizer.h"
reed54dc4872016-09-13 08:09:45 -070019#include "SkShader.h"
20#include "SkStream.h"
21#include "SkTextBlob.h"
22#include "SkTypeface.h"
23
24template <typename T> void write_rrect(T* writer, const SkRRect& rrect) {
25 char tmp[SkRRect::kSizeInMemory];
26 rrect.writeToMemory(tmp);
27 writer->write(tmp, SkRRect::kSizeInMemory);
28}
29
30template <typename T> void write_pad(T* writer, const void* buffer, size_t len) {
31 writer->write(buffer, len & ~3);
32 if (len & 3) {
33 const char* src = (const char*)buffer + (len & ~3);
34 len &= 3;
35 uint32_t tmp = 0;
36 memcpy(&tmp, src, len);
37 writer->write(&tmp, 4);
38 }
39}
40
41///////////////////////////////////////////////////////////////////////////////////////////////////
42
43static uint16_t compute_nondef(const SkPaint& paint, PaintUsage usage) {
44 // kRespectsStroke_PaintUsage is only valid if other bits are also set
45 SkASSERT(0 != (usage & ~kRespectsStroke_PaintUsage));
46
47 const SkScalar kTextSize_Default = 12;
48 const SkScalar kTextScaleX_Default = 1;
49 const SkScalar kTextSkewX_Default = 0;
50 const SkScalar kStrokeWidth_Default = 0;
51 const SkScalar kStrokeMiter_Default = 4;
52 const SkColor kColor_Default = SK_ColorBLACK;
53
54 unsigned bits = (paint.getColor() != kColor_Default) ? kColor_NonDef : 0;
55
56 if (usage & kText_PaintUsage) {
57 bits |= (paint.getTextSize() != kTextSize_Default ? kTextSize_NonDef : 0);
58 bits |= (paint.getTextScaleX() != kTextScaleX_Default ? kTextScaleX_NonDef : 0);
59 bits |= (paint.getTextSkewX() != kTextSkewX_Default ? kTextSkewX_NonDef : 0);
60 bits |= (paint.getTypeface() ? kTypeface_NonDef : 0);
61 }
62
63 // TODO: kImage_PaintUsage only needs the shader/maskfilter IF its colortype is kAlpha_8
64
65 if (usage & (kVertices_PaintUsage | kDrawPaint_PaintUsage | kImage_PaintUsage |
66 kText_PaintUsage | kGeometry_PaintUsage | kTextBlob_PaintUsage)) {
67 bits |= (paint.getShader() ? kShader_NonDef : 0);
68 }
69
70 if (usage & (kText_PaintUsage | kGeometry_PaintUsage | kTextBlob_PaintUsage)) {
71 bits |= (paint.getPathEffect() ? kPathEffect_NonDef : 0);
72 bits |= (paint.getRasterizer() ? kRasterizer_NonDef : 0);
73
74 if (paint.getStyle() != SkPaint::kFill_Style || (usage & kRespectsStroke_PaintUsage)) {
75 bits |= (paint.getStrokeWidth() != kStrokeWidth_Default ? kStrokeWidth_NonDef : 0);
76 bits |= (paint.getStrokeMiter() != kStrokeMiter_Default ? kStrokeMiter_NonDef : 0);
77 }
78 }
79
80 if (usage &
81 (kText_PaintUsage | kGeometry_PaintUsage | kImage_PaintUsage | kTextBlob_PaintUsage))
82 {
83 bits |= (paint.getMaskFilter() ? kMaskFilter_NonDef : 0);
84 }
85
reed54dc4872016-09-13 08:09:45 -070086 bits |= (paint.getColorFilter() ? kColorFilter_NonDef : 0);
87 bits |= (paint.getImageFilter() ? kImageFilter_NonDef : 0);
88 bits |= (paint.getDrawLooper() ? kDrawLooper_NonDef : 0);
89
90 return SkToU16(bits);
91}
92
93static uint32_t pack_paint_flags(unsigned flags, unsigned hint, unsigned align,
94 unsigned filter, unsigned style, unsigned caps, unsigned joins,
95 unsigned encoding) {
96 SkASSERT(kFlags_BPF + kHint_BPF + kAlign_BPF + kFilter_BPF <= 32);
97
98 ASSERT_FITS_IN(flags, kFlags_BPF);
99 ASSERT_FITS_IN(filter, kFilter_BPF);
100 ASSERT_FITS_IN(style, kStyle_BPF);
101 ASSERT_FITS_IN(caps, kCaps_BPF);
102 ASSERT_FITS_IN(joins, kJoins_BPF);
103 ASSERT_FITS_IN(hint, kHint_BPF);
104 ASSERT_FITS_IN(align, kAlign_BPF);
105 ASSERT_FITS_IN(encoding, kEncoding_BPF);
106
107 // left-align the fields of "known" size, and right-align the last (flatFlags) so it can easly
108 // add more bits in the future.
109
110 uint32_t packed = 0;
111 int shift = 32;
112
113 shift -= kFlags_BPF; packed |= (flags << shift);
114 shift -= kFilter_BPF; packed |= (filter << shift);
115 shift -= kStyle_BPF; packed |= (style << shift);
116 // these are only needed for stroking (geometry or text)
117 shift -= kCaps_BPF; packed |= (caps << shift);
118 shift -= kJoins_BPF; packed |= (joins << shift);
119 // these are only needed for text
120 shift -= kHint_BPF; packed |= (hint << shift);
121 shift -= kAlign_BPF; packed |= (align << shift);
122 shift -= kEncoding_BPF; packed |= (encoding << shift);
123
124 return packed;
125}
126
127#define CHECK_WRITE_SCALAR(writer, nondef, paint, Field) \
128 do { if (nondef & (k##Field##_NonDef)) { \
129 writer.writeScalar(paint.get##Field()); \
130 }} while (0)
131
132#define CHECK_WRITE_FLATTENABLE(writer, nondef, paint, Field) \
133 do { if (nondef & (k##Field##_NonDef)) { \
134 SkFlattenable* f = paint.get##Field(); \
135 SkASSERT(f != nullptr); \
136 writer.writeFlattenable(f); \
137 } } while (0)
138
139/*
140 * Header:
141 * paint flags : 32
142 * non_def bits : 16
143 * xfermode enum : 8
144 * pad zeros : 8
145 */
146static void write_paint(SkWriteBuffer& writer, const SkPaint& paint, unsigned usage) {
147 uint32_t packedFlags = pack_paint_flags(paint.getFlags(), paint.getHinting(),
148 paint.getTextAlign(), paint.getFilterQuality(),
149 paint.getStyle(), paint.getStrokeCap(),
150 paint.getStrokeJoin(), paint.getTextEncoding());
151 writer.write32(packedFlags);
152
153 unsigned nondef = compute_nondef(paint, (PaintUsage)usage);
reed54dc4872016-09-13 08:09:45 -0700154 const uint8_t pad = 0;
reed374772b2016-10-05 17:33:02 -0700155 writer.write32((nondef << 16) | ((unsigned)paint.getBlendMode() << 8) | pad);
reed54dc4872016-09-13 08:09:45 -0700156
157 CHECK_WRITE_SCALAR(writer, nondef, paint, TextSize);
158 CHECK_WRITE_SCALAR(writer, nondef, paint, TextScaleX);
159 CHECK_WRITE_SCALAR(writer, nondef, paint, TextSkewX);
160 CHECK_WRITE_SCALAR(writer, nondef, paint, StrokeWidth);
161 CHECK_WRITE_SCALAR(writer, nondef, paint, StrokeMiter);
162
163 if (nondef & kColor_NonDef) {
164 writer.write32(paint.getColor());
165 }
166 if (nondef & kTypeface_NonDef) {
167 // TODO: explore idea of writing bits indicating "use the prev (or prev N) face"
168 // e.g. 1-N bits is an index into a ring buffer of typefaces
169 SkTypeface* tf = paint.getTypeface();
170 SkASSERT(tf);
171 writer.writeTypeface(tf);
172 }
173
174 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, PathEffect);
175 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, Shader);
reed54dc4872016-09-13 08:09:45 -0700176 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, MaskFilter);
177 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, ColorFilter);
178 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, Rasterizer);
179 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, ImageFilter);
180 CHECK_WRITE_FLATTENABLE(writer, nondef, paint, DrawLooper);
181}
182
183class SkPipeWriter : public SkBinaryWriteBuffer {
184 enum {
185 N = 1024/4,
186 };
187 uint32_t fStorage[N];
188 SkWStream* fStream;
189
190public:
191 SkPipeWriter(SkWStream* stream, SkDeduper* deduper)
192 : SkBinaryWriteBuffer(fStorage, sizeof(fStorage))
193 , fStream(stream)
194 {
195 this->setDeduper(deduper);
196 }
197
198 SkPipeWriter(SkPipeCanvas* pc) : SkPipeWriter(pc->fStream, pc->fDeduper) {}
199
200 ~SkPipeWriter() override {
201 SkASSERT(SkIsAlign4(fStream->bytesWritten()));
202 this->writeToStream(fStream);
203 }
204
205 void writePaint(const SkPaint& paint) override {
206 write_paint(*this, paint, kUnknown_PaintUsage);
207 }
208};
209
210///////////////////////////////////////////////////////////////////////////////////////////////////
211
212SkPipeCanvas::SkPipeCanvas(const SkRect& cull, SkPipeDeduper* deduper, SkWStream* stream)
Florin Malita439ace92016-12-02 12:05:41 -0500213 : INHERITED(cull.roundOut())
reed54dc4872016-09-13 08:09:45 -0700214 , fDeduper(deduper)
215 , fStream(stream)
216{}
217
218SkPipeCanvas::~SkPipeCanvas() {}
219
220void SkPipeCanvas::willSave() {
221 fStream->write32(pack_verb(SkPipeVerb::kSave));
222 this->INHERITED::willSave();
223}
224
225SkCanvas::SaveLayerStrategy SkPipeCanvas::getSaveLayerStrategy(const SaveLayerRec& rec) {
226 SkPipeWriter writer(this);
227 uint32_t extra = rec.fSaveLayerFlags;
228
229 // remap this wacky flag
230 if (extra & (1 << 31)/*SkCanvas::kDontClipToLayer_PrivateSaveLayerFlag*/) {
231 extra &= ~(1 << 31);
232 extra |= kDontClipToLayer_SaveLayerMask;
233 }
234
235 if (rec.fBounds) {
236 extra |= kHasBounds_SaveLayerMask;
237 }
238 if (rec.fPaint) {
239 extra |= kHasPaint_SaveLayerMask;
240 }
241 if (rec.fBackdrop) {
242 extra |= kHasBackdrop_SaveLayerMask;
243 }
Florin Malita53f77bd2017-04-28 13:48:37 -0400244 if (rec.fClipMask) {
245 extra |= kHasClipMask_SaveLayerMask;
246 }
247 if (rec.fClipMatrix) {
248 extra |= kHasClipMatrix_SaveLayerMask;
249 }
Mike Kleinb3384842017-03-27 14:28:07 -0400250
reed54dc4872016-09-13 08:09:45 -0700251 writer.write32(pack_verb(SkPipeVerb::kSaveLayer, extra));
252 if (rec.fBounds) {
253 writer.writeRect(*rec.fBounds);
254 }
255 if (rec.fPaint) {
256 write_paint(writer, *rec.fPaint, kSaveLayer_PaintUsage);
257 }
258 if (rec.fBackdrop) {
259 writer.writeFlattenable(rec.fBackdrop);
260 }
Florin Malita53f77bd2017-04-28 13:48:37 -0400261 if (rec.fClipMask) {
Mike Kleinb34ab042017-05-01 21:34:14 +0000262 writer.writeImage(rec.fClipMask);
Florin Malita53f77bd2017-04-28 13:48:37 -0400263 }
264 if (rec.fClipMatrix) {
265 writer.writeMatrix(*rec.fClipMatrix);
266 }
267
reed54dc4872016-09-13 08:09:45 -0700268 return kNoLayer_SaveLayerStrategy;
269}
270
271void SkPipeCanvas::willRestore() {
272 fStream->write32(pack_verb(SkPipeVerb::kRestore));
273 this->INHERITED::willRestore();
274}
275
276template <typename T> void write_sparse_matrix(T* writer, const SkMatrix& matrix) {
277 SkMatrix::TypeMask tm = matrix.getType();
278 SkScalar tmp[9];
279 if (tm & SkMatrix::kPerspective_Mask) {
280 matrix.get9(tmp);
281 writer->write(tmp, 9 * sizeof(SkScalar));
282 } else if (tm & SkMatrix::kAffine_Mask) {
283 tmp[0] = matrix[SkMatrix::kMScaleX];
284 tmp[1] = matrix[SkMatrix::kMSkewX];
285 tmp[2] = matrix[SkMatrix::kMTransX];
286 tmp[3] = matrix[SkMatrix::kMScaleY];
287 tmp[4] = matrix[SkMatrix::kMSkewY];
288 tmp[5] = matrix[SkMatrix::kMTransY];
289 writer->write(tmp, 6 * sizeof(SkScalar));
290 } else if (tm & SkMatrix::kScale_Mask) {
291 tmp[0] = matrix[SkMatrix::kMScaleX];
292 tmp[1] = matrix[SkMatrix::kMTransX];
293 tmp[2] = matrix[SkMatrix::kMScaleY];
294 tmp[3] = matrix[SkMatrix::kMTransY];
295 writer->write(tmp, 4 * sizeof(SkScalar));
296 } else if (tm & SkMatrix::kTranslate_Mask) {
297 tmp[0] = matrix[SkMatrix::kMTransX];
298 tmp[1] = matrix[SkMatrix::kMTransY];
299 writer->write(tmp, 2 * sizeof(SkScalar));
300 }
301 // else write nothing for Identity
302}
303
304static void do_concat(SkWStream* stream, const SkMatrix& matrix, bool isSetMatrix) {
305 unsigned mtype = matrix.getType();
306 SkASSERT(0 == (mtype & ~kTypeMask_ConcatMask));
307 unsigned extra = mtype;
308 if (isSetMatrix) {
309 extra |= kSetMatrix_ConcatMask;
310 }
311 if (mtype || isSetMatrix) {
312 stream->write32(pack_verb(SkPipeVerb::kConcat, extra));
313 write_sparse_matrix(stream, matrix);
314 }
315}
316
317void SkPipeCanvas::didConcat(const SkMatrix& matrix) {
318 do_concat(fStream, matrix, false);
319 this->INHERITED::didConcat(matrix);
320}
321
322void SkPipeCanvas::didSetMatrix(const SkMatrix& matrix) {
323 do_concat(fStream, matrix, true);
324 this->INHERITED::didSetMatrix(matrix);
325}
326
Mike Reedc1f77742016-12-09 09:00:50 -0500327void SkPipeCanvas::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle) {
reed54dc4872016-09-13 08:09:45 -0700328 fStream->write32(pack_verb(SkPipeVerb::kClipRect, ((unsigned)op << 1) | edgeStyle));
329 fStream->write(&rect, 4 * sizeof(SkScalar));
330
331 this->INHERITED::onClipRect(rect, op, edgeStyle);
332}
333
Mike Reedc1f77742016-12-09 09:00:50 -0500334void SkPipeCanvas::onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle) {
reed54dc4872016-09-13 08:09:45 -0700335 fStream->write32(pack_verb(SkPipeVerb::kClipRRect, ((unsigned)op << 1) | edgeStyle));
336 write_rrect(fStream, rrect);
337
338 this->INHERITED::onClipRRect(rrect, op, edgeStyle);
339}
340
Mike Reedc1f77742016-12-09 09:00:50 -0500341void SkPipeCanvas::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle) {
reed54dc4872016-09-13 08:09:45 -0700342 SkPipeWriter writer(this);
343 writer.write32(pack_verb(SkPipeVerb::kClipPath, ((unsigned)op << 1) | edgeStyle));
344 writer.writePath(path);
345
346 this->INHERITED::onClipPath(path, op, edgeStyle);
347}
348
Mike Reedc1f77742016-12-09 09:00:50 -0500349void SkPipeCanvas::onClipRegion(const SkRegion& deviceRgn, SkClipOp op) {
reed54dc4872016-09-13 08:09:45 -0700350 SkPipeWriter writer(this);
351 writer.write32(pack_verb(SkPipeVerb::kClipRegion, (unsigned)op << 1));
352 writer.writeRegion(deviceRgn);
353
354 this->INHERITED::onClipRegion(deviceRgn, op);
355}
356
357///////////////////////////////////////////////////////////////////////////////////////////////////
358
359void SkPipeCanvas::onDrawArc(const SkRect& bounds, SkScalar startAngle, SkScalar sweepAngle,
360 bool useCenter, const SkPaint& paint) {
361 SkPipeWriter writer(this);
362 writer.write32(pack_verb(SkPipeVerb::kDrawArc, (int)useCenter));
363 writer.writeRect(bounds);
364 writer.writeScalar(startAngle);
365 writer.writeScalar(sweepAngle);
366 write_paint(writer, paint, kGeometry_PaintUsage);
367}
368
369void SkPipeCanvas::onDrawAtlas(const SkImage* image, const SkRSXform xform[], const SkRect rect[],
Mike Reedfaba3712016-11-03 14:45:31 -0400370 const SkColor colors[], int count, SkBlendMode mode,
reed54dc4872016-09-13 08:09:45 -0700371 const SkRect* cull, const SkPaint* paint) {
372 unsigned extra = (unsigned)mode;
373 SkASSERT(0 == (extra & ~kMode_DrawAtlasMask));
374 if (colors) {
375 extra |= kHasColors_DrawAtlasMask;
376 }
377 if (cull) {
378 extra |= kHasCull_DrawAtlasMask;
379 }
380 if (paint) {
381 extra |= kHasPaint_DrawAtlasMask;
382 }
383
384 SkPipeWriter writer(this);
385 writer.write32(pack_verb(SkPipeVerb::kDrawAtlas, extra));
386 writer.writeImage(image);
387 writer.write32(count);
388 writer.write(xform, count * sizeof(SkRSXform));
389 writer.write(rect, count * sizeof(SkRect));
390 if (colors) {
391 writer.write(colors, count * sizeof(SkColor));
392 }
393 if (cull) {
394 writer.writeRect(*cull);
395 }
396 if (paint) {
397 write_paint(writer, *paint, kImage_PaintUsage);
398 }
399}
400
401void SkPipeCanvas::onDrawPaint(const SkPaint& paint) {
402 SkPipeWriter writer(this);
403 writer.write32(pack_verb(SkPipeVerb::kDrawPaint));
404 write_paint(writer, paint, kDrawPaint_PaintUsage);
405}
406
407void SkPipeCanvas::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
408 const SkPaint& paint) {
409 SkPipeWriter writer(this);
410 writer.write32(pack_verb(SkPipeVerb::kDrawPoints, mode));
411 writer.write32(SkToU32(count));
412 writer.write(pts, count * sizeof(SkPoint));
413 write_paint(writer, paint, kGeometry_PaintUsage | kRespectsStroke_PaintUsage);
414}
415
416void SkPipeCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
417 SkPipeWriter writer(this);
418 writer.write32(pack_verb(SkPipeVerb::kDrawRect));
419 writer.write(&rect, sizeof(SkRect));
420 write_paint(writer, paint, kGeometry_PaintUsage);
421}
422
423void SkPipeCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
424 SkPipeWriter writer(this);
425 writer.write32(pack_verb(SkPipeVerb::kDrawOval));
426 writer.write(&rect, sizeof(SkRect));
427 write_paint(writer, paint, kGeometry_PaintUsage);
428}
429
430void SkPipeCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
431 SkPipeWriter writer(this);
432 writer.write32(pack_verb(SkPipeVerb::kDrawRRect));
433 write_rrect(&writer, rrect);
434 write_paint(writer, paint, kGeometry_PaintUsage);
435}
436
437void SkPipeCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) {
438 SkPipeWriter writer(this);
439 writer.write32(pack_verb(SkPipeVerb::kDrawDRRect));
440 write_rrect(&writer, outer);
441 write_rrect(&writer, inner);
442 write_paint(writer, paint, kGeometry_PaintUsage);
443}
444
445void SkPipeCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
446 SkPipeWriter writer(this);
447 writer.write32(pack_verb(SkPipeVerb::kDrawPath));
448 writer.writePath(path);
449 write_paint(writer, paint, kGeometry_PaintUsage);
450}
451
452///////////////////////////////////////////////////////////////////////////////////////////////////
453
454static sk_sp<SkImage> make_from_bitmap(const SkBitmap& bitmap) {
455 // If we just "make" an image, it will force a CPU copy (if its mutable), only to have
456 // us then either find it in our cache, or compress and send it.
457 //
458 // Better could be to look it up in our cache first, and only create/compress it if we have to.
459 //
460 // But for now, just do the dumb thing...
461 return SkImage::MakeFromBitmap(bitmap);
462}
463
464void SkPipeCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
465 const SkPaint* paint) {
466 sk_sp<SkImage> image = make_from_bitmap(bitmap);
467 if (image) {
468 this->onDrawImage(image.get(), x, y, paint);
469 }
470}
471
472void SkPipeCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
473 const SkPaint* paint, SrcRectConstraint constraint) {
474 sk_sp<SkImage> image = make_from_bitmap(bitmap);
475 if (image) {
476 this->onDrawImageRect(image.get(), src, dst, paint, constraint);
477 }
478}
479
480void SkPipeCanvas::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
481 const SkRect& dst, const SkPaint* paint) {
482 sk_sp<SkImage> image = make_from_bitmap(bitmap);
483 if (image) {
484 this->onDrawImageNine(image.get(), center, dst, paint);
485 }
486}
487
488void SkPipeCanvas::onDrawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice,
489 const SkRect& dst, const SkPaint* paint) {
490 sk_sp<SkImage> image = make_from_bitmap(bitmap);
491 if (image) {
492 this->onDrawImageLattice(image.get(), lattice, dst, paint);
493 }
494}
495
496///////////////////////////////////////////////////////////////////////////////////////////////////
Mike Kleinb3384842017-03-27 14:28:07 -0400497
reed54dc4872016-09-13 08:09:45 -0700498void SkPipeCanvas::onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
499 const SkPaint* paint) {
500 unsigned extra = 0;
501 if (paint) {
502 extra |= kHasPaint_DrawImageMask;
503 }
504 SkPipeWriter writer(this);
505 writer.write32(pack_verb(SkPipeVerb::kDrawImage, extra));
506 writer.writeImage(image);
507 writer.writeScalar(left);
508 writer.writeScalar(top);
509 if (paint) {
510 write_paint(writer, *paint, kImage_PaintUsage);
511 }
512}
513
514void SkPipeCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
515 const SkPaint* paint, SrcRectConstraint constraint) {
516 SkASSERT(0 == ((unsigned)constraint & ~1));
517 unsigned extra = (unsigned)constraint;
518 if (paint) {
519 extra |= kHasPaint_DrawImageRectMask;
520 }
521 if (src) {
522 extra |= kHasSrcRect_DrawImageRectMask;
523 }
524
525 SkPipeWriter writer(this);
526 writer.write32(pack_verb(SkPipeVerb::kDrawImageRect, extra));
527 writer.writeImage(image);
528 if (src) {
529 writer.write(src, sizeof(*src));
530 }
531 writer.write(&dst, sizeof(dst));
532 if (paint) {
533 write_paint(writer, *paint, kImage_PaintUsage);
534 }
535}
536
537void SkPipeCanvas::onDrawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst,
538 const SkPaint* paint) {
539 unsigned extra = 0;
540 if (paint) {
541 extra |= kHasPaint_DrawImageNineMask;
542 }
543 SkPipeWriter writer(this);
544 writer.write32(pack_verb(SkPipeVerb::kDrawImageNine, extra));
545 writer.writeImage(image);
546 writer.write(&center, sizeof(center));
547 writer.write(&dst, sizeof(dst));
548 if (paint) {
549 write_paint(writer, *paint, kImage_PaintUsage);
550 }
551}
552
553void SkPipeCanvas::onDrawImageLattice(const SkImage* image, const Lattice& lattice,
554 const SkRect& dst, const SkPaint* paint) {
555 unsigned extra = 0;
556 if (paint) {
557 extra |= kHasPaint_DrawImageLatticeMask;
558 }
Stan Ilievca8c0952017-12-11 13:01:58 -0500559 if (lattice.fRectTypes) {
reed54dc4872016-09-13 08:09:45 -0700560 extra |= kHasFlags_DrawImageLatticeMask;
561 }
562 if (lattice.fXCount >= kCount_DrawImageLatticeMask) {
563 extra |= kCount_DrawImageLatticeMask << kXCount_DrawImageLatticeShift;
564 } else {
565 extra |= lattice.fXCount << kXCount_DrawImageLatticeShift;
566 }
567 if (lattice.fYCount >= kCount_DrawImageLatticeMask) {
568 extra |= kCount_DrawImageLatticeMask << kYCount_DrawImageLatticeShift;
569 } else {
570 extra |= lattice.fYCount << kYCount_DrawImageLatticeShift;
571 }
572
573 SkPipeWriter writer(this);
574 writer.write32(pack_verb(SkPipeVerb::kDrawImageLattice, extra));
575 writer.writeImage(image);
576 if (lattice.fXCount >= kCount_DrawImageLatticeMask) {
577 writer.write32(lattice.fXCount);
578 }
579 if (lattice.fYCount >= kCount_DrawImageLatticeMask) {
580 writer.write32(lattice.fYCount);
581 }
582 // Often these divs will be small (8 or 16 bits). Consider sniffing that and writing a flag
583 // so we can store them smaller.
584 writer.write(lattice.fXDivs, lattice.fXCount * sizeof(int32_t));
585 writer.write(lattice.fYDivs, lattice.fYCount * sizeof(int32_t));
Stan Ilievca8c0952017-12-11 13:01:58 -0500586 if (lattice.fRectTypes) {
reed54dc4872016-09-13 08:09:45 -0700587 int32_t count = (lattice.fXCount + 1) * (lattice.fYCount + 1);
588 SkASSERT(count > 0);
Stan Ilievca8c0952017-12-11 13:01:58 -0500589 write_pad(&writer, lattice.fRectTypes, count);
590 write_pad(&writer, lattice.fColors, count*sizeof(SkColor));
reed54dc4872016-09-13 08:09:45 -0700591 }
msarett71df2d72016-09-30 12:41:42 -0700592 SkASSERT(lattice.fBounds);
593 writer.write(&lattice.fBounds, sizeof(*lattice.fBounds));
reed54dc4872016-09-13 08:09:45 -0700594 writer.write(&dst, sizeof(dst));
595 if (paint) {
596 write_paint(writer, *paint, kImage_PaintUsage);
597 }
598}
599
600///////////////////////////////////////////////////////////////////////////////////////////////////
601
602void SkPipeCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
603 const SkPaint& paint) {
604 SkASSERT(byteLength);
605
606 bool compact = fits_in(byteLength, 24);
607
608 SkPipeWriter writer(this);
609 writer.write32(pack_verb(SkPipeVerb::kDrawText, compact ? (unsigned)byteLength : 0));
610 if (!compact) {
611 writer.write32(SkToU32(byteLength));
612 }
613 write_pad(&writer, text, byteLength);
614 writer.writeScalar(x);
615 writer.writeScalar(y);
616 write_paint(writer, paint, kText_PaintUsage);
617}
618
619void SkPipeCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
620 const SkPaint& paint) {
621 SkASSERT(byteLength);
Mike Kleinb3384842017-03-27 14:28:07 -0400622
reed54dc4872016-09-13 08:09:45 -0700623 bool compact = fits_in(byteLength, 24);
Mike Kleinb3384842017-03-27 14:28:07 -0400624
reed54dc4872016-09-13 08:09:45 -0700625 SkPipeWriter writer(this);
626 writer.write32(pack_verb(SkPipeVerb::kDrawPosText, compact ? (unsigned)byteLength : 0));
627 if (!compact) {
628 writer.write32(SkToU32(byteLength));
629 }
630 write_pad(&writer, text, byteLength);
631 writer.writePointArray(pos, paint.countText(text, byteLength));
632 write_paint(writer, paint, kText_PaintUsage);
633}
634
635void SkPipeCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
636 SkScalar constY, const SkPaint& paint) {
637 SkASSERT(byteLength);
Mike Kleinb3384842017-03-27 14:28:07 -0400638
reed54dc4872016-09-13 08:09:45 -0700639 bool compact = fits_in(byteLength, 24);
Mike Kleinb3384842017-03-27 14:28:07 -0400640
reed54dc4872016-09-13 08:09:45 -0700641 SkPipeWriter writer(this);
642 writer.write32(pack_verb(SkPipeVerb::kDrawPosTextH, compact ? (unsigned)byteLength : 0));
643 if (!compact) {
644 writer.write32(SkToU32(byteLength));
645 }
646 write_pad(&writer, text, byteLength);
647 writer.writeScalarArray(xpos, paint.countText(text, byteLength));
648 writer.writeScalar(constY);
649 write_paint(writer, paint, kText_PaintUsage);
650}
651
652void SkPipeCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
653 const SkMatrix* matrix, const SkPaint& paint) {
654 SkASSERT(byteLength > 0);
655
656 unsigned extra = 0;
657 if (byteLength <= kTextLength_DrawTextOnPathMask) {
658 extra |= byteLength;
659 } // else we will write the length after the packedverb
660 SkMatrix::TypeMask tm = matrix ? matrix->getType() : SkMatrix::kIdentity_Mask;
661 extra |= (unsigned)tm << kMatrixType_DrawTextOnPathShift;
662
663 SkPipeWriter writer(this);
664 writer.write32(pack_verb(SkPipeVerb::kDrawTextOnPath, extra));
665 if (byteLength > kTextLength_DrawTextOnPathMask) {
666 writer.write32(byteLength);
667 }
668 write_pad(&writer, text, byteLength);
669 writer.writePath(path);
670 if (matrix) {
671 write_sparse_matrix(&writer, *matrix);
672 }
673 write_paint(writer, paint, kText_PaintUsage);
674}
675
676void SkPipeCanvas::onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[],
677 const SkRect* cull, const SkPaint& paint) {
678 SkASSERT(byteLength);
Mike Kleinb3384842017-03-27 14:28:07 -0400679
reed54dc4872016-09-13 08:09:45 -0700680 bool compact = fits_in(byteLength, 23);
681 unsigned extra = compact ? (byteLength << 1) : 0;
682 if (cull) {
683 extra |= 1;
684 }
Mike Kleinb3384842017-03-27 14:28:07 -0400685
reed54dc4872016-09-13 08:09:45 -0700686 SkPipeWriter writer(this);
687 writer.write32(pack_verb(SkPipeVerb::kDrawTextRSXform, extra));
688 if (!compact) {
689 writer.write32(SkToU32(byteLength));
690 }
691 write_pad(&writer, text, byteLength);
692
693 int count = paint.countText(text, byteLength);
694 writer.write32(count); // maybe we can/should store this in extra as well?
695 writer.write(xform, count * sizeof(SkRSXform));
696 if (cull) {
697 writer.writeRect(*cull);
698 }
699 write_paint(writer, paint, kText_PaintUsage);
700}
701
702void SkPipeCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
703 const SkPaint &paint) {
704 SkPipeWriter writer(this);
705 writer.write32(pack_verb(SkPipeVerb::kDrawTextBlob, 0));
706 blob->flatten(writer);
707 writer.writeScalar(x);
708 writer.writeScalar(y);
709 write_paint(writer, paint, kTextBlob_PaintUsage);
710}
711
712void SkPipeCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
713 const SkPaint* paint) {
714 unsigned extra = fDeduper->findOrDefinePicture(const_cast<SkPicture*>(picture));
715 if (matrix) {
716 extra |= kHasMatrix_DrawPictureExtra;
717 }
718 if (paint) {
719 extra |= kHasPaint_DrawPictureExtra;
720 }
721 SkPipeWriter writer(this);
722 writer.write32(pack_verb(SkPipeVerb::kDrawPicture, extra));
723 if (matrix) {
724 writer.writeMatrix(*matrix);
725 }
726 if (paint) {
727 write_paint(writer, *paint, kSaveLayer_PaintUsage);
728 }
729}
730
731void SkPipeCanvas::onDrawRegion(const SkRegion& region, const SkPaint& paint) {
732 size_t size = region.writeToMemory(nullptr);
733 unsigned extra = 0;
734 if (fits_in(size, 24)) {
735 extra = SkToUInt(size);
736 }
737
738 SkPipeWriter writer(this);
739 writer.write32(pack_verb(SkPipeVerb::kDrawRegion, extra));
740 if (0 == extra) {
741 writer.write32(size);
742 }
743 SkAutoSMalloc<2048> storage(size);
744 region.writeToMemory(storage.get());
745 write_pad(&writer, storage.get(), size);
746 write_paint(writer, paint, kGeometry_PaintUsage);
747}
748
Mike Reedfed9cfd2017-03-17 12:09:04 -0400749void SkPipeCanvas::onDrawVerticesObject(const SkVertices* vertices, SkBlendMode bmode,
750 const SkPaint& paint) {
751 unsigned extra = static_cast<unsigned>(bmode);
reed54dc4872016-09-13 08:09:45 -0700752
753 SkPipeWriter writer(this);
754 writer.write32(pack_verb(SkPipeVerb::kDrawVertices, extra));
Mike Reedfed9cfd2017-03-17 12:09:04 -0400755 // TODO: dedup vertices?
756 writer.writeDataAsByteArray(vertices->encode().get());
reed54dc4872016-09-13 08:09:45 -0700757 write_paint(writer, paint, kVertices_PaintUsage);
758}
759
760void SkPipeCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
Mike Reedfaba3712016-11-03 14:45:31 -0400761 const SkPoint texCoords[4], SkBlendMode bmode,
reed54dc4872016-09-13 08:09:45 -0700762 const SkPaint& paint) {
763 SkPipeWriter writer(this);
764 unsigned extra = 0;
Mike Reed7d954ad2016-10-28 15:42:34 -0400765 SkASSERT(0 == ((int)bmode & ~kModeEnum_DrawPatchExtraMask));
766 extra = (unsigned)bmode;
reed54dc4872016-09-13 08:09:45 -0700767 if (colors) {
768 extra |= kHasColors_DrawPatchExtraMask;
769 }
770 if (texCoords) {
771 extra |= kHasTexture_DrawPatchExtraMask;
772 }
773 writer.write32(pack_verb(SkPipeVerb::kDrawPatch, extra));
774 writer.write(cubics, sizeof(SkPoint) * 12);
775 if (colors) {
776 writer.write(colors, sizeof(SkColor) * 4);
777 }
778 if (texCoords) {
779 writer.write(texCoords, sizeof(SkPoint) * 4);
780 }
reed54dc4872016-09-13 08:09:45 -0700781 write_paint(writer, paint, kGeometry_PaintUsage);
782}
783
784void SkPipeCanvas::onDrawAnnotation(const SkRect& rect, const char key[], SkData* data) {
785 const size_t len = strlen(key) + 1; // must write the trailing 0
786 bool compact = fits_in(len, 23);
787 uint32_t extra = compact ? (unsigned)len : 0;
788 extra <<= 1; // make room for has_data_sentinel
789 if (data) {
790 extra |= 1;
791 }
792
793 fStream->write32(pack_verb(SkPipeVerb::kDrawAnnotation, extra));
794 fStream->write(&rect, sizeof(SkRect));
795 if (!compact) {
796 fStream->write32(SkToU32(len));
797 }
798 write_pad(fStream, key, len);
799 if (data) {
800 fStream->write32(SkToU32(data->size()));
801 write_pad(fStream, data->data(), data->size());
802 }
803}
804
805///////////////////////////////////////////////////////////////////////////////////////////////////
806
807class A8Serializer : public SkPixelSerializer {
808protected:
809 bool onUseEncodedData(const void* data, size_t len) {
810 return true;
811 }
812
813 SkData* onEncode(const SkPixmap& pmap) {
814 if (kAlpha_8_SkColorType == pmap.colorType()) {
815 SkDynamicMemoryWStream stream;
816 stream.write("skiaimgf", 8);
817 stream.write32(pmap.width());
818 stream.write32(pmap.height());
819 stream.write16(pmap.colorType());
820 stream.write16(pmap.alphaType());
821 stream.write32(0); // no colorspace for now
822 for (int y = 0; y < pmap.height(); ++y) {
823 stream.write(pmap.addr8(0, y), pmap.width());
824 }
825 return stream.detachAsData().release();
826 }
827 return nullptr;
828 }
829};
830
Mike Reed3ac64b42016-10-18 19:34:08 -0400831static sk_sp<SkData> default_image_serializer(SkImage* image) {
832 A8Serializer serial;
Mike Reed6409f842017-07-11 16:03:13 -0400833 sk_sp<SkData> data = image->encodeToData(&serial);
Mike Reed3ac64b42016-10-18 19:34:08 -0400834 if (!data) {
Mike Reed6409f842017-07-11 16:03:13 -0400835 data = image->encodeToData();
Mike Reed3ac64b42016-10-18 19:34:08 -0400836 }
837 return data;
838}
839
reed54dc4872016-09-13 08:09:45 -0700840static bool show_deduper_traffic = false;
841
842int SkPipeDeduper::findOrDefineImage(SkImage* image) {
843 int index = fImages.find(image->uniqueID());
844 SkASSERT(index >= 0);
845 if (index) {
846 if (show_deduper_traffic) {
847 SkDebugf(" reuseImage(%d)\n", index - 1);
848 }
849 return index;
850 }
851
Mike Reed3ac64b42016-10-18 19:34:08 -0400852 sk_sp<SkData> data = fIMSerializer ? fIMSerializer->serialize(image)
853 : default_image_serializer(image);
reed54dc4872016-09-13 08:09:45 -0700854 if (data) {
855 index = fImages.add(image->uniqueID());
856 SkASSERT(index > 0);
857 SkASSERT(fits_in(index, 24));
858 fStream->write32(pack_verb(SkPipeVerb::kDefineImage, index));
859
860 uint32_t len = SkToU32(data->size());
861 fStream->write32(SkAlign4(len));
862 write_pad(fStream, data->data(), len);
863
864 if (show_deduper_traffic) {
865 int size = image->width() * image->height() << 2;
866 SkDebugf(" defineImage(%d) %d -> %d\n", index - 1, size, len);
867 }
868 return index;
869 }
870 SkDebugf("+++ failed to encode image [%d %d]\n", image->width(), image->height());
871 return 0; // failed to encode
872}
873
874int SkPipeDeduper::findOrDefinePicture(SkPicture* picture) {
875 int index = fPictures.find(picture->uniqueID());
876 SkASSERT(index >= 0);
877 if (index) {
878 if (show_deduper_traffic) {
879 SkDebugf(" reusePicture(%d)\n", index - 1);
880 }
881 return index;
882 }
883
884 size_t prevWritten = fStream->bytesWritten();
885 unsigned extra = 0; // 0 means we're defining a new picture, non-zero means undef_index + 1
886 fStream->write32(pack_verb(SkPipeVerb::kDefinePicture, extra));
887 const SkRect cull = picture->cullRect();
888 fStream->write(&cull, sizeof(cull));
889 picture->playback(fPipeCanvas);
890 // call fPictures.add *after* we're written the picture, so that any nested pictures will have
891 // already been defined, and we get the "last" index value.
892 index = fPictures.add(picture->uniqueID());
893 ASSERT_FITS_IN(index, kObjectDefinitionBits);
894 fStream->write32(pack_verb(SkPipeVerb::kEndPicture, index));
895
Mike Kleinb3384842017-03-27 14:28:07 -0400896 if (show_deduper_traffic) {
897 SkDebugf(" definePicture(%d) %d\n",
898 index - 1, SkToU32(fStream->bytesWritten() - prevWritten));
899 }
reed54dc4872016-09-13 08:09:45 -0700900 return index;
901}
902
903static sk_sp<SkData> encode(SkTypeface* tf) {
904 SkDynamicMemoryWStream stream;
905 tf->serialize(&stream);
906 return sk_sp<SkData>(stream.detachAsData());
907}
908
909int SkPipeDeduper::findOrDefineTypeface(SkTypeface* typeface) {
910 if (!typeface) {
911 return 0; // default
912 }
913
914 int index = fTypefaces.find(typeface->uniqueID());
915 SkASSERT(index >= 0);
916 if (index) {
917 if (show_deduper_traffic) {
918 SkDebugf(" reuseTypeface(%d)\n", index - 1);
919 }
920 return index;
921 }
922
923 sk_sp<SkData> data = fTFSerializer ? fTFSerializer->serialize(typeface) : encode(typeface);
924 if (data) {
925 index = fTypefaces.add(typeface->uniqueID());
926 SkASSERT(index > 0);
927 SkASSERT(fits_in(index, 24));
928 fStream->write32(pack_verb(SkPipeVerb::kDefineTypeface, index));
929
930 uint32_t len = SkToU32(data->size());
931 fStream->write32(SkAlign4(len));
932 write_pad(fStream, data->data(), len);
933
934 if (show_deduper_traffic) {
935 SkDebugf(" defineTypeface(%d) %d\n", index - 1, len);
936 }
937 return index;
938 }
939 SkDebugf("+++ failed to encode typeface %d\n", typeface->uniqueID());
940 return 0; // failed to encode
941}
942
943int SkPipeDeduper::findOrDefineFactory(SkFlattenable* flattenable) {
944 if (!flattenable) {
945 return 0;
946 }
947
948 int index = fFactories.find(flattenable->getFactory());
949 SkASSERT(index >= 0);
950 if (index) {
951 if (show_deduper_traffic) {
952 SkDebugf(" reuseFactory(%d)\n", index - 1);
953 }
954 return index;
955 }
956
957 index = fFactories.add(flattenable->getFactory());
958 ASSERT_FITS_IN(index, kIndex_DefineFactoryExtraBits);
959 const char* name = flattenable->getTypeName();
960 size_t len = strlen(name);
961 ASSERT_FITS_IN(len, kNameLength_DefineFactoryExtraBits);
962 unsigned extra = (index << kNameLength_DefineFactoryExtraBits) | len;
963 size_t prevWritten = fStream->bytesWritten();
964 fStream->write32(pack_verb(SkPipeVerb::kDefineFactory, extra));
965 write_pad(fStream, name, len + 1);
966 if (false) {
967 SkDebugf(" defineFactory(%d) %d %s\n",
968 index - 1, SkToU32(fStream->bytesWritten() - prevWritten), name);
969 }
970 return index;
971}
972
973///////////////////////////////////////////////////////////////////////////////////////////////////
974#include "SkPipe.h"
975
976class SkPipeSerializer::Impl {
977public:
978 SkPipeDeduper fDeduper;
979 std::unique_ptr<SkPipeCanvas> fCanvas;
980};
981
982SkPipeSerializer::SkPipeSerializer() : fImpl(new Impl) {}
983
984SkPipeSerializer::~SkPipeSerializer() {
985 if (fImpl->fCanvas) {
986 this->endWrite();
987 }
988}
989
990void SkPipeSerializer::setTypefaceSerializer(SkTypefaceSerializer* tfs) {
991 fImpl->fDeduper.setTypefaceSerializer(tfs);
992}
993
Mike Reed3ac64b42016-10-18 19:34:08 -0400994void SkPipeSerializer::setImageSerializer(SkImageSerializer* ims) {
995 fImpl->fDeduper.setImageSerializer(ims);
996}
997
reed54dc4872016-09-13 08:09:45 -0700998void SkPipeSerializer::resetCache() {
999 fImpl->fDeduper.resetCaches();
1000}
1001
reed262052c2016-09-15 14:24:53 -07001002sk_sp<SkData> SkPipeSerializer::writeImage(SkImage* image) {
1003 SkDynamicMemoryWStream stream;
1004 this->writeImage(image, &stream);
1005 return stream.detachAsData();
reed54dc4872016-09-13 08:09:45 -07001006}
1007
reed262052c2016-09-15 14:24:53 -07001008sk_sp<SkData> SkPipeSerializer::writePicture(SkPicture* picture) {
1009 SkDynamicMemoryWStream stream;
1010 this->writePicture(picture, &stream);
1011 return stream.detachAsData();
1012}
1013
1014void SkPipeSerializer::writePicture(SkPicture* picture, SkWStream* stream) {
1015 int index = fImpl->fDeduper.findPicture(picture);
1016 if (0 == index) {
1017 // Try to define the picture
1018 this->beginWrite(picture->cullRect(), stream);
1019 index = fImpl->fDeduper.findOrDefinePicture(picture);
1020 this->endWrite();
1021 }
1022 stream->write32(pack_verb(SkPipeVerb::kWritePicture, index));
1023}
1024
1025void SkPipeSerializer::writeImage(SkImage* image, SkWStream* stream) {
reed7e3ba9f2016-09-13 17:25:19 -07001026 int index = fImpl->fDeduper.findImage(image);
1027 if (0 == index) {
1028 // Try to define the image
1029 fImpl->fDeduper.setStream(stream);
1030 index = fImpl->fDeduper.findOrDefineImage(image);
1031 }
1032 stream->write32(pack_verb(SkPipeVerb::kWriteImage, index));
reed54dc4872016-09-13 08:09:45 -07001033}
1034
1035SkCanvas* SkPipeSerializer::beginWrite(const SkRect& cull, SkWStream* stream) {
1036 SkASSERT(nullptr == fImpl->fCanvas);
1037 fImpl->fCanvas.reset(new SkPipeCanvas(cull, &fImpl->fDeduper, stream));
1038 fImpl->fDeduper.setStream(stream);
1039 fImpl->fDeduper.setCanvas(fImpl->fCanvas.get());
1040 return fImpl->fCanvas.get();
1041}
1042
1043void SkPipeSerializer::endWrite() {
1044 fImpl->fCanvas->restoreToCount(1);
1045 fImpl->fCanvas.reset(nullptr);
reed7e3ba9f2016-09-13 17:25:19 -07001046 fImpl->fDeduper.setCanvas(nullptr);
reed54dc4872016-09-13 08:09:45 -07001047}