1 2/* 3 * Copyright 2011 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10#include "SkBitmapHeap.h" 11#include "SkCanvas.h" 12#include "SkPaint.h" 13#include "SkGPipe.h" 14#include "SkGPipePriv.h" 15#include "SkReader32.h" 16#include "SkStream.h" 17 18#include "SkAnnotation.h" 19#include "SkColorFilter.h" 20#include "SkDrawLooper.h" 21#include "SkImageFilter.h" 22#include "SkMaskFilter.h" 23#include "SkReadBuffer.h" 24#include "SkPatchUtils.h" 25#include "SkPathEffect.h" 26#include "SkRasterizer.h" 27#include "SkRRect.h" 28#include "SkShader.h" 29#include "SkTextBlob.h" 30#include "SkTypeface.h" 31#include "SkXfermode.h" 32 33static SkFlattenable::Type paintflat_to_flattype(PaintFlats pf) { 34 static const uint8_t gEffectTypesInPaintFlatsOrder[] = { 35 SkFlattenable::kSkColorFilter_Type, 36 SkFlattenable::kSkDrawLooper_Type, 37 SkFlattenable::kSkImageFilter_Type, 38 SkFlattenable::kSkMaskFilter_Type, 39 SkFlattenable::kSkPathEffect_Type, 40 SkFlattenable::kSkRasterizer_Type, 41 SkFlattenable::kSkShader_Type, 42 SkFlattenable::kSkXfermode_Type, 43 }; 44 45 SkASSERT((size_t)pf < SK_ARRAY_COUNT(gEffectTypesInPaintFlatsOrder)); 46 return (SkFlattenable::Type)gEffectTypesInPaintFlatsOrder[pf]; 47} 48 49static void set_paintflat(SkPaint* paint, SkFlattenable* obj, unsigned paintFlat) { 50 SkASSERT(paintFlat < kCount_PaintFlats); 51 switch (paintFlat) { 52 case kColorFilter_PaintFlat: 53 paint->setColorFilter((SkColorFilter*)obj); 54 break; 55 case kDrawLooper_PaintFlat: 56 paint->setLooper((SkDrawLooper*)obj); 57 break; 58 case kMaskFilter_PaintFlat: 59 paint->setMaskFilter((SkMaskFilter*)obj); 60 break; 61 case kPathEffect_PaintFlat: 62 paint->setPathEffect((SkPathEffect*)obj); 63 break; 64 case kRasterizer_PaintFlat: 65 paint->setRasterizer((SkRasterizer*)obj); 66 break; 67 case kShader_PaintFlat: 68 paint->setShader((SkShader*)obj); 69 break; 70 case kImageFilter_PaintFlat: 71 paint->setImageFilter((SkImageFilter*)obj); 72 break; 73 case kXfermode_PaintFlat: 74 paint->setXfermode((SkXfermode*)obj); 75 break; 76 default: 77 SkDEBUGFAIL("never gets here"); 78 } 79} 80 81template <typename T> class SkRefCntTDArray : public SkTDArray<T> { 82public: 83 ~SkRefCntTDArray() { this->unrefAll(); } 84}; 85 86class SkGPipeState : public SkBitmapHeapReader { 87public: 88 SkGPipeState(); 89 ~SkGPipeState(); 90 91 void setSilent(bool silent) { 92 fSilent = silent; 93 } 94 95 bool shouldDraw() { 96 return !fSilent; 97 } 98 99 void setFlags(unsigned flags) { 100 if (fFlags != flags) { 101 fFlags = flags; 102 this->updateReader(); 103 } 104 } 105 106 unsigned getFlags() const { 107 return fFlags; 108 } 109 110 void setReader(SkReadBuffer* reader) { 111 fReader = reader; 112 this->updateReader(); 113 } 114 115 const SkPaint& paint() const { return fPaint; } 116 SkPaint* editPaint() { return &fPaint; } 117 118 SkFlattenable* getFlat(unsigned index) const { 119 if (0 == index) { 120 return NULL; 121 } 122 return fFlatArray[index - 1]; 123 } 124 125 void defFlattenable(PaintFlats pf, int index) { 126 index--; 127 SkFlattenable* obj = fReader->readFlattenable(paintflat_to_flattype(pf)); 128 if (fFlatArray.count() == index) { 129 *fFlatArray.append() = obj; 130 } else { 131 SkSafeUnref(fFlatArray[index]); 132 fFlatArray[index] = obj; 133 } 134 } 135 136 void defFactory(const char* name) { 137 SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name); 138 if (factory) { 139 SkASSERT(fFactoryArray.find(factory) < 0); 140 *fFactoryArray.append() = factory; 141 } 142 } 143 144 /** 145 * Add a bitmap to the array of bitmaps, or replace an existing one. 146 * This is only used when in cross process mode without a shared heap. 147 */ 148 void addBitmap(int index) { 149 SkASSERT(shouldFlattenBitmaps(fFlags)); 150 SkBitmap* bm; 151 if(fBitmaps.count() == index) { 152 bm = SkNEW(SkBitmap); 153 *fBitmaps.append() = bm; 154 } else { 155 bm = fBitmaps[index]; 156 } 157 fReader->readBitmap(bm); 158 } 159 160 /** 161 * Override of SkBitmapHeapReader, so that SkReadBuffer can use 162 * these SkBitmaps for bitmap shaders. Used only in cross process mode 163 * without a shared heap. 164 */ 165 virtual SkBitmap* getBitmap(int32_t index) const SK_OVERRIDE { 166 SkASSERT(shouldFlattenBitmaps(fFlags)); 167 return fBitmaps[index]; 168 } 169 170 /** 171 * Needed to be a non-abstract subclass of SkBitmapHeapReader. 172 */ 173 virtual void releaseRef(int32_t) SK_OVERRIDE {} 174 175 void setSharedHeap(SkBitmapHeap* heap) { 176 SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap); 177 SkRefCnt_SafeAssign(fSharedHeap, heap); 178 this->updateReader(); 179 } 180 181 /** 182 * Access the shared heap. Only used in the case when bitmaps are not 183 * flattened. 184 */ 185 SkBitmapHeap* getSharedHeap() const { 186 SkASSERT(!shouldFlattenBitmaps(fFlags)); 187 return fSharedHeap; 188 } 189 190 void addTypeface() { 191 size_t size = fReader->read32(); 192 const void* data = fReader->skip(SkAlign4(size)); 193 SkMemoryStream stream(data, size, false); 194 *fTypefaces.append() = SkTypeface::Deserialize(&stream); 195 } 196 197 SkTypeface* getTypeface(unsigned id) const { 198 return id ? fTypefaces[id - 1] : NULL; 199 } 200 201private: 202 void updateReader() { 203 if (NULL == fReader) { 204 return; 205 } 206 bool crossProcess = SkToBool(fFlags & SkGPipeWriter::kCrossProcess_Flag); 207 fReader->setFlags(SkSetClearMask(fReader->getFlags(), crossProcess, 208 SkReadBuffer::kCrossProcess_Flag)); 209 if (crossProcess) { 210 fReader->setFactoryArray(&fFactoryArray); 211 } else { 212 fReader->setFactoryArray(NULL); 213 } 214 215 if (shouldFlattenBitmaps(fFlags)) { 216 fReader->setBitmapStorage(this); 217 } else { 218 fReader->setBitmapStorage(fSharedHeap); 219 } 220 } 221 SkReadBuffer* fReader; 222 SkPaint fPaint; 223 SkTDArray<SkFlattenable*> fFlatArray; 224 SkTDArray<SkTypeface*> fTypefaces; 225 SkTDArray<SkFlattenable::Factory> fFactoryArray; 226 SkTDArray<SkBitmap*> fBitmaps; 227 bool fSilent; 228 // Only used when sharing bitmaps with the writer. 229 SkBitmapHeap* fSharedHeap; 230 unsigned fFlags; 231}; 232 233/////////////////////////////////////////////////////////////////////////////// 234 235template <typename T> const T* skip(SkReader32* reader, size_t count = 1) { 236 size_t size = sizeof(T) * count; 237 SkASSERT(SkAlign4(size) == size); 238 return reinterpret_cast<const T*>(reader->skip(size)); 239} 240 241template <typename T> const T* skipAlign(SkReader32* reader, size_t count = 1) { 242 size_t size = SkAlign4(sizeof(T) * count); 243 return reinterpret_cast<const T*>(reader->skip(size)); 244} 245 246/////////////////////////////////////////////////////////////////////////////// 247/////////////////////////////////////////////////////////////////////////////// 248 249static void clipPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 250 SkGPipeState* state) { 251 SkPath path; 252 reader->readPath(&path); 253 bool doAA = SkToBool(DrawOp_unpackFlags(op32) & kClip_HasAntiAlias_DrawOpFlag); 254 canvas->clipPath(path, (SkRegion::Op)DrawOp_unpackData(op32), doAA); 255} 256 257static void clipRegion_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 258 SkGPipeState* state) { 259 SkRegion rgn; 260 reader->readRegion(&rgn); 261 canvas->clipRegion(rgn, (SkRegion::Op)DrawOp_unpackData(op32)); 262} 263 264static void clipRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 265 SkGPipeState* state) { 266 const SkRect* rect = skip<SkRect>(reader); 267 bool doAA = SkToBool(DrawOp_unpackFlags(op32) & kClip_HasAntiAlias_DrawOpFlag); 268 canvas->clipRect(*rect, (SkRegion::Op)DrawOp_unpackData(op32), doAA); 269} 270 271static void clipRRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 272 SkGPipeState* state) { 273 SkRRect rrect; 274 reader->readRRect(&rrect); 275 bool doAA = SkToBool(DrawOp_unpackFlags(op32) & kClip_HasAntiAlias_DrawOpFlag); 276 canvas->clipRRect(rrect, (SkRegion::Op)DrawOp_unpackData(op32), doAA); 277} 278 279/////////////////////////////////////////////////////////////////////////////// 280 281static void setMatrix_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 282 SkGPipeState* state) { 283 SkMatrix matrix; 284 reader->readMatrix(&matrix); 285 canvas->setMatrix(matrix); 286} 287 288static void concat_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 289 SkGPipeState* state) { 290 SkMatrix matrix; 291 reader->readMatrix(&matrix); 292 canvas->concat(matrix); 293} 294 295static void scale_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 296 SkGPipeState* state) { 297 const SkScalar* param = skip<SkScalar>(reader, 2); 298 canvas->scale(param[0], param[1]); 299} 300 301static void skew_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 302 SkGPipeState* state) { 303 const SkScalar* param = skip<SkScalar>(reader, 2); 304 canvas->skew(param[0], param[1]); 305} 306 307static void rotate_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 308 SkGPipeState* state) { 309 canvas->rotate(reader->readScalar()); 310} 311 312static void translate_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 313 SkGPipeState* state) { 314 const SkScalar* param = skip<SkScalar>(reader, 2); 315 canvas->translate(param[0], param[1]); 316} 317 318/////////////////////////////////////////////////////////////////////////////// 319 320static void save_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 321 SkGPipeState* state) { 322 canvas->save(); 323} 324 325static void saveLayer_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 326 SkGPipeState* state) { 327 unsigned flags = DrawOp_unpackFlags(op32); 328 SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags)DrawOp_unpackData(op32); 329 330 const SkRect* bounds = NULL; 331 if (flags & kSaveLayer_HasBounds_DrawOpFlag) { 332 bounds = skip<SkRect>(reader); 333 } 334 const SkPaint* paint = NULL; 335 if (flags & kSaveLayer_HasPaint_DrawOpFlag) { 336 paint = &state->paint(); 337 } 338 canvas->saveLayer(bounds, paint, saveFlags); 339} 340 341static void restore_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 342 SkGPipeState* state) { 343 canvas->restore(); 344} 345 346/////////////////////////////////////////////////////////////////////////////// 347 348static void drawClear_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 349 SkGPipeState* state) { 350 SkColor color = 0; 351 if (DrawOp_unpackFlags(op32) & kClear_HasColor_DrawOpFlag) { 352 color = reader->readU32(); 353 } 354 canvas->clear(color); 355} 356 357static void drawPaint_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 358 SkGPipeState* state) { 359 if (state->shouldDraw()) { 360 canvas->drawPaint(state->paint()); 361 } 362} 363 364static void drawPoints_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 365 SkGPipeState* state) { 366 SkCanvas::PointMode mode = (SkCanvas::PointMode)DrawOp_unpackFlags(op32); 367 size_t count = reader->readU32(); 368 const SkPoint* pts = skip<SkPoint>(reader, count); 369 if (state->shouldDraw()) { 370 canvas->drawPoints(mode, count, pts, state->paint()); 371 } 372} 373 374static void drawOval_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 375 SkGPipeState* state) { 376 const SkRect* rect = skip<SkRect>(reader); 377 if (state->shouldDraw()) { 378 canvas->drawOval(*rect, state->paint()); 379 } 380} 381 382static void drawRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 383 SkGPipeState* state) { 384 const SkRect* rect = skip<SkRect>(reader); 385 if (state->shouldDraw()) { 386 canvas->drawRect(*rect, state->paint()); 387 } 388} 389 390static void drawRRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 391 SkGPipeState* state) { 392 SkRRect rrect; 393 reader->readRRect(&rrect); 394 if (state->shouldDraw()) { 395 canvas->drawRRect(rrect, state->paint()); 396 } 397} 398 399static void drawDRRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 400 SkGPipeState* state) { 401 SkRRect outer, inner; 402 reader->readRRect(&outer); 403 reader->readRRect(&inner); 404 if (state->shouldDraw()) { 405 canvas->drawDRRect(outer, inner, state->paint()); 406 } 407} 408 409static void drawPatch_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 410 SkGPipeState* state) { 411 412 unsigned flags = DrawOp_unpackFlags(op32); 413 414 const SkPoint* cubics = skip<SkPoint>(reader, SkPatchUtils::kNumCtrlPts); 415 416 const SkColor* colors = NULL; 417 if (flags & kDrawVertices_HasColors_DrawOpFlag) { 418 colors = skip<SkColor>(reader, SkPatchUtils::kNumCorners); 419 } 420 const SkPoint* texCoords = NULL; 421 if (flags & kDrawVertices_HasTexs_DrawOpFlag) { 422 texCoords = skip<SkPoint>(reader, SkPatchUtils::kNumCorners); 423 } 424 SkAutoTUnref<SkXfermode> xfer; 425 if (flags & kDrawVertices_HasXfermode_DrawOpFlag) { 426 int mode = reader->readInt(); 427 if (mode < 0 || mode > SkXfermode::kLastMode) { 428 mode = SkXfermode::kModulate_Mode; 429 } 430 xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode)); 431 } 432 if (state->shouldDraw()) { 433 canvas->drawPatch(cubics, colors, texCoords, xfer, state->paint()); 434 } 435} 436 437static void drawPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 438 SkGPipeState* state) { 439 SkPath path; 440 reader->readPath(&path); 441 if (state->shouldDraw()) { 442 canvas->drawPath(path, state->paint()); 443 } 444} 445 446static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 447 SkGPipeState* state) { 448 unsigned flags = DrawOp_unpackFlags(op32); 449 450 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readU32(); 451 int vertexCount = reader->readU32(); 452 const SkPoint* verts = skip<SkPoint>(reader, vertexCount); 453 454 const SkPoint* texs = NULL; 455 if (flags & kDrawVertices_HasTexs_DrawOpFlag) { 456 texs = skip<SkPoint>(reader, vertexCount); 457 } 458 459 const SkColor* colors = NULL; 460 if (flags & kDrawVertices_HasColors_DrawOpFlag) { 461 colors = skip<SkColor>(reader, vertexCount); 462 } 463 464 SkAutoTUnref<SkXfermode> xfer; 465 if (flags & kDrawVertices_HasXfermode_DrawOpFlag) { 466 SkXfermode::Mode mode = (SkXfermode::Mode)reader->readU32(); 467 xfer.reset(SkXfermode::Create(mode)); 468 } 469 470 int indexCount = 0; 471 const uint16_t* indices = NULL; 472 if (flags & kDrawVertices_HasIndices_DrawOpFlag) { 473 indexCount = reader->readU32(); 474 indices = skipAlign<uint16_t>(reader, indexCount); 475 } 476 if (state->shouldDraw()) { 477 canvas->drawVertices(vmode, vertexCount, verts, texs, colors, xfer, 478 indices, indexCount, state->paint()); 479 } 480} 481 482/////////////////////////////////////////////////////////////////////////////// 483 484static void drawText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 485 SkGPipeState* state) { 486 size_t len = reader->readU32(); 487 const void* text = reader->skip(SkAlign4(len)); 488 const SkScalar* xy = skip<SkScalar>(reader, 2); 489 if (state->shouldDraw()) { 490 canvas->drawText(text, len, xy[0], xy[1], state->paint()); 491 } 492} 493 494static void drawPosText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 495 SkGPipeState* state) { 496 size_t len = reader->readU32(); 497 const void* text = reader->skip(SkAlign4(len)); 498 size_t posCount = reader->readU32(); // compute by our writer 499 const SkPoint* pos = skip<SkPoint>(reader, posCount); 500 if (state->shouldDraw()) { 501 canvas->drawPosText(text, len, pos, state->paint()); 502 } 503} 504 505static void drawPosTextH_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 506 SkGPipeState* state) { 507 size_t len = reader->readU32(); 508 const void* text = reader->skip(SkAlign4(len)); 509 size_t posCount = reader->readU32(); // compute by our writer 510 const SkScalar* xpos = skip<SkScalar>(reader, posCount); 511 SkScalar constY = reader->readScalar(); 512 if (state->shouldDraw()) { 513 canvas->drawPosTextH(text, len, xpos, constY, state->paint()); 514 } 515} 516 517static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 518 SkGPipeState* state) { 519 size_t len = reader->readU32(); 520 const void* text = reader->skip(SkAlign4(len)); 521 522 SkPath path; 523 reader->readPath(&path); 524 525 SkMatrix matrixStorage; 526 const SkMatrix* matrix = NULL; 527 if (DrawOp_unpackFlags(op32) & kDrawTextOnPath_HasMatrix_DrawOpFlag) { 528 reader->readMatrix(&matrixStorage); 529 matrix = &matrixStorage; 530 } 531 if (state->shouldDraw()) { 532 canvas->drawTextOnPath(text, len, path, matrix, state->paint()); 533 } 534} 535 536/////////////////////////////////////////////////////////////////////////////// 537 538class BitmapHolder : SkNoncopyable { 539public: 540 BitmapHolder(SkReader32* reader, uint32_t op32, SkGPipeState* state); 541 ~BitmapHolder() { 542 if (fHeapEntry != NULL) { 543 fHeapEntry->releaseRef(); 544 } 545 } 546 const SkBitmap* getBitmap() { 547 return fBitmap; 548 } 549private: 550 SkBitmapHeapEntry* fHeapEntry; 551 const SkBitmap* fBitmap; 552 SkBitmap fBitmapStorage; 553}; 554 555BitmapHolder::BitmapHolder(SkReader32* reader, uint32_t op32, 556 SkGPipeState* state) { 557 const unsigned flags = state->getFlags(); 558 const unsigned index = DrawOp_unpackData(op32); 559 if (shouldFlattenBitmaps(flags)) { 560 fHeapEntry = NULL; 561 fBitmap = state->getBitmap(index); 562 } else { 563 SkBitmapHeapEntry* entry = state->getSharedHeap()->getEntry(index); 564 if (SkToBool(flags & SkGPipeWriter::kSimultaneousReaders_Flag)) { 565 // Make a shallow copy for thread safety. Each thread will point to the same SkPixelRef, 566 // which is thread safe. 567 fBitmapStorage = *entry->getBitmap(); 568 fBitmap = &fBitmapStorage; 569 // Release the ref on the bitmap now, since we made our own copy. 570 entry->releaseRef(); 571 fHeapEntry = NULL; 572 } else { 573 SkASSERT(!shouldFlattenBitmaps(flags)); 574 SkASSERT(!SkToBool(flags & SkGPipeWriter::kSimultaneousReaders_Flag)); 575 fHeapEntry = entry; 576 fBitmap = fHeapEntry->getBitmap(); 577 } 578 } 579} 580 581static void drawBitmap_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 582 SkGPipeState* state) { 583 BitmapHolder holder(reader, op32, state); 584 bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag); 585 SkScalar left = reader->readScalar(); 586 SkScalar top = reader->readScalar(); 587 const SkBitmap* bitmap = holder.getBitmap(); 588 if (state->shouldDraw()) { 589 canvas->drawBitmap(*bitmap, left, top, hasPaint ? &state->paint() : NULL); 590 } 591} 592 593static void drawBitmapMatrix_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 594 SkGPipeState* state) { 595 BitmapHolder holder(reader, op32, state); 596 bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag); 597 SkMatrix matrix; 598 reader->readMatrix(&matrix); 599 const SkBitmap* bitmap = holder.getBitmap(); 600 if (state->shouldDraw()) { 601 canvas->drawBitmapMatrix(*bitmap, matrix, 602 hasPaint ? &state->paint() : NULL); 603 } 604} 605 606static void drawBitmapNine_rp(SkCanvas* canvas, SkReader32* reader, 607 uint32_t op32, SkGPipeState* state) { 608 BitmapHolder holder(reader, op32, state); 609 bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag); 610 const SkIRect* center = skip<SkIRect>(reader); 611 const SkRect* dst = skip<SkRect>(reader); 612 const SkBitmap* bitmap = holder.getBitmap(); 613 if (state->shouldDraw()) { 614 canvas->drawBitmapNine(*bitmap, *center, *dst, 615 hasPaint ? &state->paint() : NULL); 616 } 617} 618 619static void drawBitmapRect_rp(SkCanvas* canvas, SkReader32* reader, 620 uint32_t op32, SkGPipeState* state) { 621 BitmapHolder holder(reader, op32, state); 622 unsigned flags = DrawOp_unpackFlags(op32); 623 bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag); 624 bool hasSrc = SkToBool(flags & kDrawBitmap_HasSrcRect_DrawOpFlag); 625 const SkRect* src; 626 if (hasSrc) { 627 src = skip<SkRect>(reader); 628 } else { 629 src = NULL; 630 } 631 SkCanvas::DrawBitmapRectFlags dbmrFlags = SkCanvas::kNone_DrawBitmapRectFlag; 632 if (flags & kDrawBitmap_Bleed_DrawOpFlag) { 633 dbmrFlags = (SkCanvas::DrawBitmapRectFlags)(dbmrFlags|SkCanvas::kBleed_DrawBitmapRectFlag); 634 } 635 const SkRect* dst = skip<SkRect>(reader); 636 const SkBitmap* bitmap = holder.getBitmap(); 637 if (state->shouldDraw()) { 638 canvas->drawBitmapRectToRect(*bitmap, src, *dst, 639 hasPaint ? &state->paint() : NULL, dbmrFlags); 640 } 641} 642 643static void drawSprite_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 644 SkGPipeState* state) { 645 BitmapHolder holder(reader, op32, state); 646 bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag); 647 const SkIPoint* point = skip<SkIPoint>(reader); 648 const SkBitmap* bitmap = holder.getBitmap(); 649 if (state->shouldDraw()) { 650 canvas->drawSprite(*bitmap, point->fX, point->fY, hasPaint ? &state->paint() : NULL); 651 } 652} 653 654/////////////////////////////////////////////////////////////////////////////// 655 656static void drawData_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 657 SkGPipeState* state) { 658 // since we don't have a paint, we can use data for our (small) sizes 659 size_t size = DrawOp_unpackData(op32); 660 if (0 == size) { 661 size = reader->readU32(); 662 } 663 const void* data = reader->skip(SkAlign4(size)); 664 if (state->shouldDraw()) { 665 canvas->drawData(data, size); 666 } 667} 668 669static void drawPicture_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 670 SkGPipeState* state) { 671 UNIMPLEMENTED 672} 673 674static void drawTextBlob_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, 675 SkGPipeState* state) { 676 SkScalar x = reader->readScalar(); 677 SkScalar y = reader->readScalar(); 678 679 int typefaceCount = reader->readU32(); 680 SkAutoSTMalloc<16, SkTypeface*> typefaceArray(typefaceCount); 681 if (state->getFlags() & SkGPipeWriter::kCrossProcess_Flag) { 682 for (int i = 0; i < typefaceCount; ++i) { 683 typefaceArray[i] = state->getTypeface(reader->readU32()); 684 } 685 } else { 686 reader->read(typefaceArray.get(), typefaceCount * sizeof(SkTypeface*)); 687 } 688 689 size_t blobSize = reader->readU32(); 690 const void* data = reader->skip(SkAlign4(blobSize)); 691 692 if (state->shouldDraw()) { 693 SkReadBuffer blobBuffer(data, blobSize); 694 blobBuffer.setTypefaceArray(typefaceArray.get(), typefaceCount); 695 SkAutoTUnref<const SkTextBlob> blob(SkTextBlob::CreateFromBuffer(blobBuffer)); 696 SkASSERT(blob.get()); 697 698 canvas->drawTextBlob(blob, x, y, state->paint()); 699 } 700} 701/////////////////////////////////////////////////////////////////////////////// 702 703static void paintOp_rp(SkCanvas*, SkReader32* reader, uint32_t op32, 704 SkGPipeState* state) { 705 size_t offset = reader->offset(); 706 size_t stop = offset + PaintOp_unpackData(op32); 707 SkPaint* p = state->editPaint(); 708 709 do { 710 uint32_t p32 = reader->readU32(); 711 unsigned op = PaintOp_unpackOp(p32); 712 unsigned data = PaintOp_unpackData(p32); 713 714// SkDebugf(" read %08X op=%d flags=%d data=%d\n", p32, op, done, data); 715 716 switch (op) { 717 case kReset_PaintOp: p->reset(); break; 718 case kFlags_PaintOp: p->setFlags(data); break; 719 case kColor_PaintOp: p->setColor(reader->readU32()); break; 720 case kFilterLevel_PaintOp: p->setFilterLevel((SkPaint::FilterLevel)data); break; 721 case kStyle_PaintOp: p->setStyle((SkPaint::Style)data); break; 722 case kJoin_PaintOp: p->setStrokeJoin((SkPaint::Join)data); break; 723 case kCap_PaintOp: p->setStrokeCap((SkPaint::Cap)data); break; 724 case kWidth_PaintOp: p->setStrokeWidth(reader->readScalar()); break; 725 case kMiter_PaintOp: p->setStrokeMiter(reader->readScalar()); break; 726 case kEncoding_PaintOp: 727 p->setTextEncoding((SkPaint::TextEncoding)data); 728 break; 729 case kHinting_PaintOp: p->setHinting((SkPaint::Hinting)data); break; 730 case kAlign_PaintOp: p->setTextAlign((SkPaint::Align)data); break; 731 case kTextSize_PaintOp: p->setTextSize(reader->readScalar()); break; 732 case kTextScaleX_PaintOp: p->setTextScaleX(reader->readScalar()); break; 733 case kTextSkewX_PaintOp: p->setTextSkewX(reader->readScalar()); break; 734 735 case kFlatIndex_PaintOp: { 736 PaintFlats pf = (PaintFlats)PaintOp_unpackFlags(p32); 737 unsigned index = data; 738 set_paintflat(p, state->getFlat(index), pf); 739 break; 740 } 741 742 case kTypeface_PaintOp: 743 SkASSERT(SkToBool(state->getFlags() & 744 SkGPipeWriter::kCrossProcess_Flag)); 745 p->setTypeface(state->getTypeface(data)); 746 break; 747 default: SkDEBUGFAIL("bad paintop"); return; 748 } 749 SkASSERT(reader->offset() <= stop); 750 } while (reader->offset() < stop); 751} 752 753static void typeface_rp(SkCanvas*, SkReader32* reader, uint32_t, 754 SkGPipeState* state) { 755 SkASSERT(!SkToBool(state->getFlags() & SkGPipeWriter::kCrossProcess_Flag)); 756 SkPaint* p = state->editPaint(); 757 p->setTypeface(static_cast<SkTypeface*>(reader->readPtr())); 758} 759 760static void annotation_rp(SkCanvas*, SkReader32* reader, uint32_t op32, 761 SkGPipeState* state) { 762 SkPaint* p = state->editPaint(); 763 764 const size_t size = DrawOp_unpackData(op32); 765 if (size > 0) { 766 SkReadBuffer buffer(reader->skip(size), size); 767 p->setAnnotation(SkAnnotation::Create(buffer))->unref(); 768 SkASSERT(buffer.offset() == size); 769 } else { 770 p->setAnnotation(NULL); 771 } 772} 773 774/////////////////////////////////////////////////////////////////////////////// 775 776static void def_Typeface_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState* state) { 777 state->addTypeface(); 778} 779 780static void def_PaintFlat_rp(SkCanvas*, SkReader32*, uint32_t op32, 781 SkGPipeState* state) { 782 PaintFlats pf = (PaintFlats)DrawOp_unpackFlags(op32); 783 unsigned index = DrawOp_unpackData(op32); 784 state->defFlattenable(pf, index); 785} 786 787static void def_Bitmap_rp(SkCanvas*, SkReader32*, uint32_t op32, 788 SkGPipeState* state) { 789 unsigned index = DrawOp_unpackData(op32); 790 state->addBitmap(index); 791} 792 793static void def_Factory_rp(SkCanvas*, SkReader32* reader, uint32_t, 794 SkGPipeState* state) { 795 state->defFactory(reader->readString()); 796} 797 798/////////////////////////////////////////////////////////////////////////////// 799 800static void skip_rp(SkCanvas*, SkReader32* reader, uint32_t op32, SkGPipeState*) { 801 size_t bytes = DrawOp_unpackData(op32); 802 (void)reader->skip(bytes); 803} 804 805static void reportFlags_rp(SkCanvas*, SkReader32*, uint32_t op32, 806 SkGPipeState* state) { 807 unsigned flags = DrawOp_unpackFlags(op32); 808 state->setFlags(flags); 809} 810 811static void shareBitmapHeap_rp(SkCanvas*, SkReader32* reader, uint32_t, 812 SkGPipeState* state) { 813 state->setSharedHeap(static_cast<SkBitmapHeap*>(reader->readPtr())); 814} 815 816static void done_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState*) {} 817 818typedef void (*ReadProc)(SkCanvas*, SkReader32*, uint32_t op32, SkGPipeState*); 819 820static const ReadProc gReadTable[] = { 821 skip_rp, 822 clipPath_rp, 823 clipRegion_rp, 824 clipRect_rp, 825 clipRRect_rp, 826 concat_rp, 827 drawBitmap_rp, 828 drawBitmapMatrix_rp, 829 drawBitmapNine_rp, 830 drawBitmapRect_rp, 831 drawClear_rp, 832 drawData_rp, 833 drawDRRect_rp, 834 drawOval_rp, 835 drawPaint_rp, 836 drawPatch_rp, 837 drawPath_rp, 838 drawPicture_rp, 839 drawPoints_rp, 840 drawPosText_rp, 841 drawPosTextH_rp, 842 drawRect_rp, 843 drawRRect_rp, 844 drawSprite_rp, 845 drawText_rp, 846 drawTextBlob_rp, 847 drawTextOnPath_rp, 848 drawVertices_rp, 849 restore_rp, 850 rotate_rp, 851 save_rp, 852 saveLayer_rp, 853 scale_rp, 854 setMatrix_rp, 855 skew_rp, 856 translate_rp, 857 858 paintOp_rp, 859 typeface_rp, 860 annotation_rp, 861 862 def_Typeface_rp, 863 def_PaintFlat_rp, 864 def_Bitmap_rp, 865 def_Factory_rp, 866 867 reportFlags_rp, 868 shareBitmapHeap_rp, 869 done_rp 870}; 871 872/////////////////////////////////////////////////////////////////////////////// 873 874SkGPipeState::SkGPipeState() 875 : fReader(0) 876 , fSilent(false) 877 , fSharedHeap(NULL) 878 , fFlags(0) { 879 880} 881 882SkGPipeState::~SkGPipeState() { 883 fTypefaces.safeUnrefAll(); 884 fFlatArray.safeUnrefAll(); 885 fBitmaps.deleteAll(); 886 SkSafeUnref(fSharedHeap); 887} 888 889/////////////////////////////////////////////////////////////////////////////// 890 891#include "SkGPipe.h" 892 893SkGPipeReader::SkGPipeReader() { 894 fCanvas = NULL; 895 fState = NULL; 896 fProc = NULL; 897} 898 899SkGPipeReader::SkGPipeReader(SkCanvas* target) { 900 fCanvas = NULL; 901 this->setCanvas(target); 902 fState = NULL; 903 fProc = NULL; 904} 905 906void SkGPipeReader::setCanvas(SkCanvas *target) { 907 SkRefCnt_SafeAssign(fCanvas, target); 908} 909 910SkGPipeReader::~SkGPipeReader() { 911 SkSafeUnref(fCanvas); 912 delete fState; 913} 914 915SkGPipeReader::Status SkGPipeReader::playback(const void* data, size_t length, 916 uint32_t playbackFlags, size_t* bytesRead) { 917 if (NULL == fCanvas) { 918 return kError_Status; 919 } 920 921 if (NULL == fState) { 922 fState = new SkGPipeState; 923 } 924 925 fState->setSilent(playbackFlags & kSilent_PlaybackFlag); 926 927 SkASSERT(SK_ARRAY_COUNT(gReadTable) == (kDone_DrawOp + 1)); 928 929 const ReadProc* table = gReadTable; 930 SkReadBuffer reader(data, length); 931 reader.setBitmapDecoder(fProc); 932 SkCanvas* canvas = fCanvas; 933 Status status = kEOF_Status; 934 935 fState->setReader(&reader); 936 while (!reader.eof()) { 937 uint32_t op32 = reader.readUInt(); 938 unsigned op = DrawOp_unpackOp(op32); 939 // SkDEBUGCODE(DrawOps drawOp = (DrawOps)op;) 940 941 if (op >= SK_ARRAY_COUNT(gReadTable)) { 942 SkDebugf("---- bad op during GPipeState::playback\n"); 943 status = kError_Status; 944 break; 945 } 946 if (kDone_DrawOp == op) { 947 status = kDone_Status; 948 break; 949 } 950 table[op](canvas, reader.getReader32(), op32, fState); 951 if ((playbackFlags & kReadAtom_PlaybackFlag) && 952 (table[op] != paintOp_rp && 953 table[op] != def_Typeface_rp && 954 table[op] != def_PaintFlat_rp && 955 table[op] != def_Bitmap_rp 956 )) { 957 status = kReadAtom_Status; 958 break; 959 } 960 } 961 962 if (bytesRead) { 963 *bytesRead = reader.offset(); 964 } 965 return status; 966} 967