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