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