SkPicturePlayback.cpp revision 392c9be344549e809d0468abafdbeb6e32135bcd
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#include "SkPicturePlayback.h" 9#include "SkPictureRecord.h" 10#include "SkTypeface.h" 11#include "SkReadBuffer.h" 12#include "SkWriteBuffer.h" 13#include <new> 14#include "SkBBoxHierarchy.h" 15#include "SkPictureStateTree.h" 16#include "SkTSort.h" 17 18template <typename T> int SafeCount(const T* obj) { 19 return obj ? obj->count() : 0; 20} 21 22/* Define this to spew out a debug statement whenever we skip the remainder of 23 a save/restore block because a clip... command returned false (empty). 24 */ 25#define SPEW_CLIP_SKIPPINGx 26 27SkPicturePlayback::SkPicturePlayback() { 28 this->init(); 29} 30 31SkPicturePlayback::SkPicturePlayback(const SkPictureRecord& record, bool deepCopy) { 32#ifdef SK_DEBUG_SIZE 33 size_t overallBytes, bitmapBytes, matricesBytes, 34 paintBytes, pathBytes, pictureBytes, regionBytes; 35 int bitmaps = record.bitmaps(&bitmapBytes); 36 int matrices = record.matrices(&matricesBytes); 37 int paints = record.paints(&paintBytes); 38 int paths = record.paths(&pathBytes); 39 int pictures = record.pictures(&pictureBytes); 40 int regions = record.regions(®ionBytes); 41 SkDebugf("picture record mem used %zd (stream %zd) ", record.size(), 42 record.streamlen()); 43 if (bitmaps != 0) 44 SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps); 45 if (matrices != 0) 46 SkDebugf("matrices size %zd (matrices:%d) ", matricesBytes, matrices); 47 if (paints != 0) 48 SkDebugf("paints size %zd (paints:%d) ", paintBytes, paints); 49 if (paths != 0) 50 SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths); 51 if (pictures != 0) 52 SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures); 53 if (regions != 0) 54 SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions); 55 if (record.fPointWrites != 0) 56 SkDebugf("points size %zd (points:%d) ", record.fPointBytes, record.fPointWrites); 57 if (record.fRectWrites != 0) 58 SkDebugf("rects size %zd (rects:%d) ", record.fRectBytes, record.fRectWrites); 59 if (record.fTextWrites != 0) 60 SkDebugf("text size %zd (text strings:%d) ", record.fTextBytes, record.fTextWrites); 61 62 SkDebugf("\n"); 63#endif 64#ifdef SK_DEBUG_DUMP 65 record.dumpMatrices(); 66 record.dumpPaints(); 67#endif 68 69 record.validate(record.writeStream().bytesWritten(), 0); 70 const SkWriter32& writer = record.writeStream(); 71 init(); 72 if (writer.bytesWritten() == 0) { 73 fOpData = SkData::NewEmpty(); 74 return; 75 } 76 77 fBoundingHierarchy = record.fBoundingHierarchy; 78 fStateTree = record.fStateTree; 79 80 SkSafeRef(fBoundingHierarchy); 81 SkSafeRef(fStateTree); 82 83 if (NULL != fBoundingHierarchy) { 84 fBoundingHierarchy->flushDeferredInserts(); 85 } 86 87 { 88 size_t size = writer.bytesWritten(); 89 void* buffer = sk_malloc_throw(size); 90 writer.flatten(buffer); 91 SkASSERT(!fOpData); 92 fOpData = SkData::NewFromMalloc(buffer, size); 93 } 94 95 // copy over the refcnt dictionary to our reader 96 record.fFlattenableHeap.setupPlaybacks(); 97 98 fBitmaps = record.fBitmapHeap->extractBitmaps(); 99 fPaints = record.fPaints.unflattenToArray(); 100 101 fBitmapHeap.reset(SkSafeRef(record.fBitmapHeap)); 102 fPathHeap.reset(SkSafeRef(record.fPathHeap)); 103 104 // ensure that the paths bounds are pre-computed 105 if (fPathHeap.get()) { 106 for (int i = 0; i < fPathHeap->count(); i++) { 107 (*fPathHeap)[i].updateBoundsCache(); 108 } 109 } 110 111 const SkTDArray<SkPicture* >& pictures = record.getPictureRefs(); 112 fPictureCount = pictures.count(); 113 if (fPictureCount > 0) { 114 fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); 115 for (int i = 0; i < fPictureCount; i++) { 116 if (deepCopy) { 117 fPictureRefs[i] = pictures[i]->clone(); 118 } else { 119 fPictureRefs[i] = pictures[i]; 120 fPictureRefs[i]->ref(); 121 } 122 } 123 } 124 125#ifdef SK_DEBUG_SIZE 126 int overall = fPlayback->size(&overallBytes); 127 bitmaps = fPlayback->bitmaps(&bitmapBytes); 128 paints = fPlayback->paints(&paintBytes); 129 paths = fPlayback->paths(&pathBytes); 130 pictures = fPlayback->pictures(&pictureBytes); 131 regions = fPlayback->regions(®ionBytes); 132 SkDebugf("playback size %zd (objects:%d) ", overallBytes, overall); 133 if (bitmaps != 0) 134 SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps); 135 if (paints != 0) 136 SkDebugf("paints size %zd (paints:%d) ", paintBytes, paints); 137 if (paths != 0) 138 SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths); 139 if (pictures != 0) 140 SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures); 141 if (regions != 0) 142 SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions); 143 SkDebugf("\n"); 144#endif 145} 146 147static bool needs_deep_copy(const SkPaint& paint) { 148 /* 149 * These fields are known to be immutable, and so can be shallow-copied 150 * 151 * getTypeface() 152 * getAnnotation() 153 * paint.getColorFilter() 154 * getXfermode() 155 */ 156 157 return paint.getPathEffect() || 158 paint.getShader() || 159 paint.getMaskFilter() || 160 paint.getRasterizer() || 161 paint.getLooper() || 162 paint.getImageFilter(); 163} 164 165SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInfo* deepCopyInfo) { 166 this->init(); 167 168 fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get())); 169 fPathHeap.reset(SkSafeRef(src.fPathHeap.get())); 170 171 fOpData = SkSafeRef(src.fOpData); 172 173 fBoundingHierarchy = src.fBoundingHierarchy; 174 fStateTree = src.fStateTree; 175 176 SkSafeRef(fBoundingHierarchy); 177 SkSafeRef(fStateTree); 178 179 if (deepCopyInfo) { 180 int paintCount = SafeCount(src.fPaints); 181 182 if (src.fBitmaps) { 183 fBitmaps = SkTRefArray<SkBitmap>::Create(src.fBitmaps->begin(), src.fBitmaps->count()); 184 } 185 186 if (!deepCopyInfo->initialized) { 187 /* The alternative to doing this is to have a clone method on the paint and have it make 188 * the deep copy of its internal structures as needed. The holdup to doing that is at 189 * this point we would need to pass the SkBitmapHeap so that we don't unnecessarily 190 * flatten the pixels in a bitmap shader. 191 */ 192 deepCopyInfo->paintData.setCount(paintCount); 193 194 /* Use an SkBitmapHeap to avoid flattening bitmaps in shaders. If there already is one, 195 * use it. If this SkPicturePlayback was created from a stream, fBitmapHeap will be 196 * NULL, so create a new one. 197 */ 198 if (fBitmapHeap.get() == NULL) { 199 // FIXME: Put this on the stack inside SkPicture::clone. Further, is it possible to 200 // do the rest of this initialization in SkPicture::clone as well? 201 SkBitmapHeap* heap = SkNEW(SkBitmapHeap); 202 deepCopyInfo->controller.setBitmapStorage(heap); 203 heap->unref(); 204 } else { 205 deepCopyInfo->controller.setBitmapStorage(fBitmapHeap); 206 } 207 208 SkDEBUGCODE(int heapSize = SafeCount(fBitmapHeap.get());) 209 for (int i = 0; i < paintCount; i++) { 210 if (needs_deep_copy(src.fPaints->at(i))) { 211 deepCopyInfo->paintData[i] = 212 SkFlatData::Create<SkPaint::FlatteningTraits>(&deepCopyInfo->controller, 213 src.fPaints->at(i), 0); 214 215 } else { 216 // this is our sentinel, which we use in the unflatten loop 217 deepCopyInfo->paintData[i] = NULL; 218 } 219 } 220 SkASSERT(SafeCount(fBitmapHeap.get()) == heapSize); 221 222 // needed to create typeface playback 223 deepCopyInfo->controller.setupPlaybacks(); 224 deepCopyInfo->initialized = true; 225 } 226 227 fPaints = SkTRefArray<SkPaint>::Create(paintCount); 228 SkASSERT(deepCopyInfo->paintData.count() == paintCount); 229 SkBitmapHeap* bmHeap = deepCopyInfo->controller.getBitmapHeap(); 230 SkTypefacePlayback* tfPlayback = deepCopyInfo->controller.getTypefacePlayback(); 231 for (int i = 0; i < paintCount; i++) { 232 if (deepCopyInfo->paintData[i]) { 233 deepCopyInfo->paintData[i]->unflatten<SkPaint::FlatteningTraits>( 234 &fPaints->writableAt(i), bmHeap, tfPlayback); 235 } else { 236 // needs_deep_copy was false, so just need to assign 237 fPaints->writableAt(i) = src.fPaints->at(i); 238 } 239 } 240 241 } else { 242 fBitmaps = SkSafeRef(src.fBitmaps); 243 fPaints = SkSafeRef(src.fPaints); 244 } 245 246 fPictureCount = src.fPictureCount; 247 fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); 248 for (int i = 0; i < fPictureCount; i++) { 249 if (deepCopyInfo) { 250 fPictureRefs[i] = src.fPictureRefs[i]->clone(); 251 } else { 252 fPictureRefs[i] = src.fPictureRefs[i]; 253 fPictureRefs[i]->ref(); 254 } 255 } 256} 257 258void SkPicturePlayback::init() { 259 fBitmaps = NULL; 260 fPaints = NULL; 261 fPictureRefs = NULL; 262 fPictureCount = 0; 263 fOpData = NULL; 264 fFactoryPlayback = NULL; 265 fBoundingHierarchy = NULL; 266 fStateTree = NULL; 267} 268 269SkPicturePlayback::~SkPicturePlayback() { 270 fOpData->unref(); 271 272 SkSafeUnref(fBitmaps); 273 SkSafeUnref(fPaints); 274 SkSafeUnref(fBoundingHierarchy); 275 SkSafeUnref(fStateTree); 276 277 for (int i = 0; i < fPictureCount; i++) { 278 fPictureRefs[i]->unref(); 279 } 280 SkDELETE_ARRAY(fPictureRefs); 281 282 SkDELETE(fFactoryPlayback); 283} 284 285void SkPicturePlayback::dumpSize() const { 286 SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] paints=%d [%d] paths=%d\n", 287 fOpData->size(), 288 SafeCount(fBitmaps), SafeCount(fBitmaps) * sizeof(SkBitmap), 289 SafeCount(fPaints), SafeCount(fPaints) * sizeof(SkPaint), 290 SafeCount(fPathHeap.get())); 291} 292 293bool SkPicturePlayback::containsBitmaps() const { 294 if (fBitmaps && fBitmaps->count() > 0) { 295 return true; 296 } 297 for (int i = 0; i < fPictureCount; ++i) { 298 if (fPictureRefs[i]->willPlayBackBitmaps()) { 299 return true; 300 } 301 } 302 return false; 303} 304 305/////////////////////////////////////////////////////////////////////////////// 306/////////////////////////////////////////////////////////////////////////////// 307 308#define PICT_READER_TAG SkSetFourByteTag('r', 'e', 'a', 'd') 309#define PICT_FACTORY_TAG SkSetFourByteTag('f', 'a', 'c', 't') 310#define PICT_TYPEFACE_TAG SkSetFourByteTag('t', 'p', 'f', 'c') 311#define PICT_PICTURE_TAG SkSetFourByteTag('p', 'c', 't', 'r') 312 313// This tag specifies the size of the ReadBuffer, needed for the following tags 314#define PICT_BUFFER_SIZE_TAG SkSetFourByteTag('a', 'r', 'a', 'y') 315// these are all inside the ARRAYS tag 316#define PICT_BITMAP_BUFFER_TAG SkSetFourByteTag('b', 't', 'm', 'p') 317#define PICT_PAINT_BUFFER_TAG SkSetFourByteTag('p', 'n', 't', ' ') 318#define PICT_PATH_BUFFER_TAG SkSetFourByteTag('p', 't', 'h', ' ') 319 320// Always write this guy last (with no length field afterwards) 321#define PICT_EOF_TAG SkSetFourByteTag('e', 'o', 'f', ' ') 322 323#include "SkStream.h" 324 325static void writeTagSize(SkWriteBuffer& buffer, uint32_t tag, 326 uint32_t size) { 327 buffer.writeUInt(tag); 328 buffer.writeUInt(size); 329} 330 331static void writeTagSize(SkWStream* stream, uint32_t tag, 332 uint32_t size) { 333 stream->write32(tag); 334 stream->write32(size); 335} 336 337static void writeFactories(SkWStream* stream, const SkFactorySet& rec) { 338 int count = rec.count(); 339 340 writeTagSize(stream, PICT_FACTORY_TAG, count); 341 342 SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count); 343 SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get(); 344 rec.copyToArray(array); 345 346 for (int i = 0; i < count; i++) { 347 const char* name = SkFlattenable::FactoryToName(array[i]); 348// SkDebugf("---- write factories [%d] %p <%s>\n", i, array[i], name); 349 if (NULL == name || 0 == *name) { 350 stream->writePackedUInt(0); 351 } else { 352 uint32_t len = strlen(name); 353 stream->writePackedUInt(len); 354 stream->write(name, len); 355 } 356 } 357} 358 359static void writeTypefaces(SkWStream* stream, const SkRefCntSet& rec) { 360 int count = rec.count(); 361 362 writeTagSize(stream, PICT_TYPEFACE_TAG, count); 363 364 SkAutoSTMalloc<16, SkTypeface*> storage(count); 365 SkTypeface** array = (SkTypeface**)storage.get(); 366 rec.copyToArray((SkRefCnt**)array); 367 368 for (int i = 0; i < count; i++) { 369 array[i]->serialize(stream); 370 } 371} 372 373void SkPicturePlayback::flattenToBuffer(SkWriteBuffer& buffer) const { 374 int i, n; 375 376 if ((n = SafeCount(fBitmaps)) > 0) { 377 writeTagSize(buffer, PICT_BITMAP_BUFFER_TAG, n); 378 for (i = 0; i < n; i++) { 379 buffer.writeBitmap((*fBitmaps)[i]); 380 } 381 } 382 383 if ((n = SafeCount(fPaints)) > 0) { 384 writeTagSize(buffer, PICT_PAINT_BUFFER_TAG, n); 385 for (i = 0; i < n; i++) { 386 buffer.writePaint((*fPaints)[i]); 387 } 388 } 389 390 if ((n = SafeCount(fPathHeap.get())) > 0) { 391 writeTagSize(buffer, PICT_PATH_BUFFER_TAG, n); 392 fPathHeap->flatten(buffer); 393 } 394} 395 396void SkPicturePlayback::serialize(SkWStream* stream, 397 SkPicture::EncodeBitmap encoder) const { 398 writeTagSize(stream, PICT_READER_TAG, fOpData->size()); 399 stream->write(fOpData->bytes(), fOpData->size()); 400 401 if (fPictureCount > 0) { 402 writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount); 403 for (int i = 0; i < fPictureCount; i++) { 404 fPictureRefs[i]->serialize(stream, encoder); 405 } 406 } 407 408 // Write some of our data into a writebuffer, and then serialize that 409 // into our stream 410 { 411 SkRefCntSet typefaceSet; 412 SkFactorySet factSet; 413 414 SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag); 415 buffer.setTypefaceRecorder(&typefaceSet); 416 buffer.setFactoryRecorder(&factSet); 417 buffer.setBitmapEncoder(encoder); 418 419 this->flattenToBuffer(buffer); 420 421 // We have to write these to sets into the stream *before* we write 422 // the buffer, since parsing that buffer will require that we already 423 // have these sets available to use. 424 writeFactories(stream, factSet); 425 writeTypefaces(stream, typefaceSet); 426 427 writeTagSize(stream, PICT_BUFFER_SIZE_TAG, buffer.bytesWritten()); 428 buffer.writeToStream(stream); 429 } 430 431 stream->write32(PICT_EOF_TAG); 432} 433 434void SkPicturePlayback::flatten(SkWriteBuffer& buffer) const { 435 writeTagSize(buffer, PICT_READER_TAG, fOpData->size()); 436 buffer.writeByteArray(fOpData->bytes(), fOpData->size()); 437 438 if (fPictureCount > 0) { 439 writeTagSize(buffer, PICT_PICTURE_TAG, fPictureCount); 440 for (int i = 0; i < fPictureCount; i++) { 441 fPictureRefs[i]->flatten(buffer); 442 } 443 } 444 445 // Write this picture playback's data into a writebuffer 446 this->flattenToBuffer(buffer); 447 buffer.write32(PICT_EOF_TAG); 448} 449 450/////////////////////////////////////////////////////////////////////////////// 451 452/** 453 * Return the corresponding SkReadBuffer flags, given a set of 454 * SkPictInfo flags. 455 */ 456static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) { 457 static const struct { 458 uint32_t fSrc; 459 uint32_t fDst; 460 } gSD[] = { 461 { SkPictInfo::kCrossProcess_Flag, SkReadBuffer::kCrossProcess_Flag }, 462 { SkPictInfo::kScalarIsFloat_Flag, SkReadBuffer::kScalarIsFloat_Flag }, 463 { SkPictInfo::kPtrIs64Bit_Flag, SkReadBuffer::kPtrIs64Bit_Flag }, 464 }; 465 466 uint32_t rbMask = 0; 467 for (size_t i = 0; i < SK_ARRAY_COUNT(gSD); ++i) { 468 if (pictInfoFlags & gSD[i].fSrc) { 469 rbMask |= gSD[i].fDst; 470 } 471 } 472 return rbMask; 473} 474 475bool SkPicturePlayback::parseStreamTag(SkStream* stream, const SkPictInfo& info, uint32_t tag, 476 size_t size, SkPicture::InstallPixelRefProc proc) { 477 /* 478 * By the time we encounter BUFFER_SIZE_TAG, we need to have already seen 479 * its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required 480 * but if they are present, they need to have been seen before the buffer. 481 * 482 * We assert that if/when we see either of these, that we have not yet seen 483 * the buffer tag, because if we have, then its too-late to deal with the 484 * factories or typefaces. 485 */ 486 SkDEBUGCODE(bool haveBuffer = false;) 487 488 switch (tag) { 489 case PICT_READER_TAG: { 490 SkAutoMalloc storage(size); 491 if (stream->read(storage.get(), size) != size) { 492 return false; 493 } 494 SkASSERT(NULL == fOpData); 495 fOpData = SkData::NewFromMalloc(storage.detach(), size); 496 } break; 497 case PICT_FACTORY_TAG: { 498 SkASSERT(!haveBuffer); 499 fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (size)); 500 for (size_t i = 0; i < size; i++) { 501 SkString str; 502 const size_t len = stream->readPackedUInt(); 503 str.resize(len); 504 if (stream->read(str.writable_str(), len) != len) { 505 return false; 506 } 507 fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str()); 508 } 509 } break; 510 case PICT_TYPEFACE_TAG: { 511 SkASSERT(!haveBuffer); 512 fTFPlayback.setCount(size); 513 for (size_t i = 0; i < size; i++) { 514 SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream)); 515 if (!tf.get()) { // failed to deserialize 516 // fTFPlayback asserts it never has a null, so we plop in 517 // the default here. 518 tf.reset(SkTypeface::RefDefault()); 519 } 520 fTFPlayback.set(i, tf); 521 } 522 } break; 523 case PICT_PICTURE_TAG: { 524 fPictureCount = size; 525 fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); 526 bool success = true; 527 int i = 0; 528 for ( ; i < fPictureCount; i++) { 529 fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc); 530 if (NULL == fPictureRefs[i]) { 531 success = false; 532 break; 533 } 534 } 535 if (!success) { 536 // Delete all of the pictures that were already created (up to but excluding i): 537 for (int j = 0; j < i; j++) { 538 fPictureRefs[j]->unref(); 539 } 540 // Delete the array 541 SkDELETE_ARRAY(fPictureRefs); 542 fPictureCount = 0; 543 return false; 544 } 545 } break; 546 case PICT_BUFFER_SIZE_TAG: { 547 SkAutoMalloc storage(size); 548 if (stream->read(storage.get(), size) != size) { 549 return false; 550 } 551 552 SkReadBuffer buffer(storage.get(), size); 553 buffer.setFlags(pictInfoFlagsToReadBufferFlags(info.fFlags)); 554 555 fFactoryPlayback->setupBuffer(buffer); 556 fTFPlayback.setupBuffer(buffer); 557 buffer.setBitmapDecoder(proc); 558 559 while (!buffer.eof()) { 560 tag = buffer.readUInt(); 561 size = buffer.readUInt(); 562 if (!this->parseBufferTag(buffer, tag, size)) { 563 return false; 564 } 565 } 566 SkDEBUGCODE(haveBuffer = true;) 567 } break; 568 } 569 return true; // success 570} 571 572bool SkPicturePlayback::parseBufferTag(SkReadBuffer& buffer, 573 uint32_t tag, size_t size) { 574 switch (tag) { 575 case PICT_BITMAP_BUFFER_TAG: { 576 fBitmaps = SkTRefArray<SkBitmap>::Create(size); 577 for (size_t i = 0; i < size; ++i) { 578 SkBitmap* bm = &fBitmaps->writableAt(i); 579 buffer.readBitmap(bm); 580 bm->setImmutable(); 581 } 582 } break; 583 case PICT_PAINT_BUFFER_TAG: { 584 fPaints = SkTRefArray<SkPaint>::Create(size); 585 for (size_t i = 0; i < size; ++i) { 586 buffer.readPaint(&fPaints->writableAt(i)); 587 } 588 } break; 589 case PICT_PATH_BUFFER_TAG: 590 if (size > 0) { 591 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer))); 592 } 593 break; 594 default: 595 // The tag was invalid. 596 return false; 597 } 598 return true; // success 599} 600 601SkPicturePlayback* SkPicturePlayback::CreateFromStream(SkStream* stream, 602 const SkPictInfo& info, 603 SkPicture::InstallPixelRefProc proc) { 604 SkAutoTDelete<SkPicturePlayback> playback(SkNEW(SkPicturePlayback)); 605 606 if (!playback->parseStream(stream, info, proc)) { 607 return NULL; 608 } 609 return playback.detach(); 610} 611 612SkPicturePlayback* SkPicturePlayback::CreateFromBuffer(SkReadBuffer& buffer) { 613 SkAutoTDelete<SkPicturePlayback> playback(SkNEW(SkPicturePlayback)); 614 615 if (!playback->parseBuffer(buffer)) { 616 return NULL; 617 } 618 return playback.detach(); 619} 620 621bool SkPicturePlayback::parseStream(SkStream* stream, const SkPictInfo& info, 622 SkPicture::InstallPixelRefProc proc) { 623 for (;;) { 624 uint32_t tag = stream->readU32(); 625 if (PICT_EOF_TAG == tag) { 626 break; 627 } 628 629 uint32_t size = stream->readU32(); 630 if (!this->parseStreamTag(stream, info, tag, size, proc)) { 631 return false; // we're invalid 632 } 633 } 634 return true; 635} 636 637bool SkPicturePlayback::parseBuffer(SkReadBuffer& buffer) { 638 for (;;) { 639 uint32_t tag = buffer.readUInt(); 640 if (PICT_EOF_TAG == tag) { 641 break; 642 } 643 644 uint32_t size = buffer.readUInt(); 645 if (!this->parseBufferTag(buffer, tag, size)) { 646 return false; // we're invalid 647 } 648 } 649 return true; 650} 651 652/////////////////////////////////////////////////////////////////////////////// 653/////////////////////////////////////////////////////////////////////////////// 654 655#ifdef SPEW_CLIP_SKIPPING 656struct SkipClipRec { 657 int fCount; 658 size_t fSize; 659 660 SkipClipRec() { 661 fCount = 0; 662 fSize = 0; 663 } 664 665 void recordSkip(size_t bytes) { 666 fCount += 1; 667 fSize += bytes; 668 } 669}; 670#endif 671 672#ifdef SK_DEVELOPER 673bool SkPicturePlayback::preDraw(int opIndex, int type) { 674 return false; 675} 676 677void SkPicturePlayback::postDraw(int opIndex) { 678} 679#endif 680 681/* 682 * Read the next op code and chunk size from 'reader'. The returned size 683 * is the entire size of the chunk (including the opcode). Thus, the 684 * offset just prior to calling read_op_and_size + 'size' is the offset 685 * to the next chunk's op code. This also means that the size of a chunk 686 * with no arguments (just an opcode) will be 4. 687 */ 688static DrawType read_op_and_size(SkReader32* reader, uint32_t* size) { 689 uint32_t temp = reader->readInt(); 690 uint32_t op; 691 if (((uint8_t) temp) == temp) { 692 // old skp file - no size information 693 op = temp; 694 *size = 0; 695 } else { 696 UNPACK_8_24(temp, op, *size); 697 if (MASK_24 == *size) { 698 *size = reader->readInt(); 699 } 700 } 701 return (DrawType) op; 702} 703 704void SkPicturePlayback::draw(SkCanvas& canvas, SkDrawPictureCallback* callback) { 705#ifdef ENABLE_TIME_DRAW 706 SkAutoTime at("SkPicture::draw", 50); 707#endif 708 709#ifdef SPEW_CLIP_SKIPPING 710 SkipClipRec skipRect, skipRRect, skipRegion, skipPath, skipCull; 711 int opCount = 0; 712#endif 713 714#ifdef SK_BUILD_FOR_ANDROID 715 SkAutoMutexAcquire autoMutex(fDrawMutex); 716#endif 717 718 // kDrawComplete will be the signal that we have reached the end of 719 // the command stream 720 static const uint32_t kDrawComplete = SK_MaxU32; 721 722 SkReader32 reader(fOpData->bytes(), fOpData->size()); 723 TextContainer text; 724 SkTDArray<void*> results; 725 726 if (NULL != fStateTree && NULL != fBoundingHierarchy) { 727 SkRect clipBounds; 728 if (canvas.getClipBounds(&clipBounds)) { 729 SkIRect query; 730 clipBounds.roundOut(&query); 731 fBoundingHierarchy->search(query, &results); 732 if (results.count() == 0) { 733 return; 734 } 735 SkTQSort<SkPictureStateTree::Draw>( 736 reinterpret_cast<SkPictureStateTree::Draw**>(results.begin()), 737 reinterpret_cast<SkPictureStateTree::Draw**>(results.end()-1)); 738 } 739 } 740 741 SkPictureStateTree::Iterator it = (NULL == fStateTree) ? 742 SkPictureStateTree::Iterator() : 743 fStateTree->getIterator(results, &canvas); 744 745 if (it.isValid()) { 746 uint32_t skipTo = it.draw(); 747 if (kDrawComplete == skipTo) { 748 return; 749 } 750 reader.setOffset(skipTo); 751 } 752 753 // Record this, so we can concat w/ it if we encounter a setMatrix() 754 SkMatrix initialMatrix = canvas.getTotalMatrix(); 755 int originalSaveCount = canvas.getSaveCount(); 756 757#ifdef SK_BUILD_FOR_ANDROID 758 fAbortCurrentPlayback = false; 759#endif 760 761#ifdef SK_DEVELOPER 762 int opIndex = -1; 763#endif 764 765 while (!reader.eof()) { 766 if (callback && callback->abortDrawing()) { 767 canvas.restoreToCount(originalSaveCount); 768 return; 769 } 770#ifdef SK_BUILD_FOR_ANDROID 771 if (fAbortCurrentPlayback) { 772 return; 773 } 774#endif 775 776#ifdef SPEW_CLIP_SKIPPING 777 opCount++; 778#endif 779 780 size_t curOffset = reader.offset(); 781 uint32_t size; 782 DrawType op = read_op_and_size(&reader, &size); 783 size_t skipTo = 0; 784 if (NOOP == op) { 785 // NOOPs are to be ignored - do not propagate them any further 786 skipTo = curOffset + size; 787#ifdef SK_DEVELOPER 788 } else { 789 opIndex++; 790 if (this->preDraw(opIndex, op)) { 791 skipTo = curOffset + size; 792 } 793#endif 794 } 795 796 if (0 != skipTo) { 797 if (it.isValid()) { 798 // If using a bounding box hierarchy, advance the state tree 799 // iterator until at or after skipTo 800 uint32_t adjustedSkipTo; 801 do { 802 adjustedSkipTo = it.draw(); 803 } while (adjustedSkipTo < skipTo); 804 skipTo = adjustedSkipTo; 805 } 806 if (kDrawComplete == skipTo) { 807 break; 808 } 809 reader.setOffset(skipTo); 810 continue; 811 } 812 813 switch (op) { 814 case CLIP_PATH: { 815 const SkPath& path = getPath(reader); 816 uint32_t packed = reader.readInt(); 817 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); 818 bool doAA = ClipParams_unpackDoAA(packed); 819 size_t offsetToRestore = reader.readInt(); 820 SkASSERT(!offsetToRestore || \ 821 offsetToRestore >= reader.offset()); 822 canvas.clipPath(path, regionOp, doAA); 823 if (canvas.isClipEmpty() && offsetToRestore) { 824#ifdef SPEW_CLIP_SKIPPING 825 skipPath.recordSkip(offsetToRestore - reader.offset()); 826#endif 827 reader.setOffset(offsetToRestore); 828 } 829 } break; 830 case CLIP_REGION: { 831 SkRegion region; 832 this->getRegion(reader, ®ion); 833 uint32_t packed = reader.readInt(); 834 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); 835 size_t offsetToRestore = reader.readInt(); 836 SkASSERT(!offsetToRestore || \ 837 offsetToRestore >= reader.offset()); 838 canvas.clipRegion(region, regionOp); 839 if (canvas.isClipEmpty() && offsetToRestore) { 840#ifdef SPEW_CLIP_SKIPPING 841 skipRegion.recordSkip(offsetToRestore - reader.offset()); 842#endif 843 reader.setOffset(offsetToRestore); 844 } 845 } break; 846 case CLIP_RECT: { 847 const SkRect& rect = reader.skipT<SkRect>(); 848 uint32_t packed = reader.readInt(); 849 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); 850 bool doAA = ClipParams_unpackDoAA(packed); 851 size_t offsetToRestore = reader.readInt(); 852 SkASSERT(!offsetToRestore || \ 853 offsetToRestore >= reader.offset()); 854 canvas.clipRect(rect, regionOp, doAA); 855 if (canvas.isClipEmpty() && offsetToRestore) { 856#ifdef SPEW_CLIP_SKIPPING 857 skipRect.recordSkip(offsetToRestore - reader.offset()); 858#endif 859 reader.setOffset(offsetToRestore); 860 } 861 } break; 862 case CLIP_RRECT: { 863 SkRRect rrect; 864 reader.readRRect(&rrect); 865 uint32_t packed = reader.readInt(); 866 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); 867 bool doAA = ClipParams_unpackDoAA(packed); 868 size_t offsetToRestore = reader.readInt(); 869 SkASSERT(!offsetToRestore || \ 870 offsetToRestore >= reader.offset()); 871 canvas.clipRRect(rrect, regionOp, doAA); 872 if (canvas.isClipEmpty() && offsetToRestore) { 873#ifdef SPEW_CLIP_SKIPPING 874 skipRRect.recordSkip(offsetToRestore - reader.offset()); 875#endif 876 reader.setOffset(offsetToRestore); 877 } 878 } break; 879 case PUSH_CULL: { 880 const SkRect& cullRect = reader.skipT<SkRect>(); 881 size_t offsetToRestore = reader.readInt(); 882 if (offsetToRestore && canvas.quickReject(cullRect)) { 883#ifdef SPEW_CLIP_SKIPPING 884 skipCull.recordSkip(offsetToRestore - reader.offset()); 885#endif 886 reader.setOffset(offsetToRestore); 887 } else { 888 canvas.pushCull(cullRect); 889 } 890 } break; 891 case POP_CULL: 892 canvas.popCull(); 893 break; 894 case CONCAT: { 895 SkMatrix matrix; 896 this->getMatrix(reader, &matrix); 897 canvas.concat(matrix); 898 break; 899 } 900 case DRAW_BITMAP: { 901 const SkPaint* paint = getPaint(reader); 902 const SkBitmap& bitmap = getBitmap(reader); 903 const SkPoint& loc = reader.skipT<SkPoint>(); 904 canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint); 905 } break; 906 case DRAW_BITMAP_RECT_TO_RECT: { 907 const SkPaint* paint = getPaint(reader); 908 const SkBitmap& bitmap = getBitmap(reader); 909 const SkRect* src = this->getRectPtr(reader); // may be null 910 const SkRect& dst = reader.skipT<SkRect>(); // required 911 SkCanvas::DrawBitmapRectFlags flags; 912 flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt(); 913 canvas.drawBitmapRectToRect(bitmap, src, dst, paint, flags); 914 } break; 915 case DRAW_BITMAP_MATRIX: { 916 const SkPaint* paint = getPaint(reader); 917 const SkBitmap& bitmap = getBitmap(reader); 918 SkMatrix matrix; 919 this->getMatrix(reader, &matrix); 920 canvas.drawBitmapMatrix(bitmap, matrix, paint); 921 } break; 922 case DRAW_BITMAP_NINE: { 923 const SkPaint* paint = getPaint(reader); 924 const SkBitmap& bitmap = getBitmap(reader); 925 const SkIRect& src = reader.skipT<SkIRect>(); 926 const SkRect& dst = reader.skipT<SkRect>(); 927 canvas.drawBitmapNine(bitmap, src, dst, paint); 928 } break; 929 case DRAW_CLEAR: 930 canvas.clear(reader.readInt()); 931 break; 932 case DRAW_DATA: { 933 size_t length = reader.readInt(); 934 canvas.drawData(reader.skip(length), length); 935 // skip handles padding the read out to a multiple of 4 936 } break; 937 case DRAW_DRRECT: { 938 const SkPaint& paint = *getPaint(reader); 939 SkRRect outer, inner; 940 reader.readRRect(&outer); 941 reader.readRRect(&inner); 942 canvas.drawDRRect(outer, inner, paint); 943 } break; 944 case BEGIN_COMMENT_GROUP: { 945 const char* desc = reader.readString(); 946 canvas.beginCommentGroup(desc); 947 } break; 948 case COMMENT: { 949 const char* kywd = reader.readString(); 950 const char* value = reader.readString(); 951 canvas.addComment(kywd, value); 952 } break; 953 case END_COMMENT_GROUP: { 954 canvas.endCommentGroup(); 955 } break; 956 case DRAW_OVAL: { 957 const SkPaint& paint = *getPaint(reader); 958 canvas.drawOval(reader.skipT<SkRect>(), paint); 959 } break; 960 case DRAW_PAINT: 961 canvas.drawPaint(*getPaint(reader)); 962 break; 963 case DRAW_PATH: { 964 const SkPaint& paint = *getPaint(reader); 965 canvas.drawPath(getPath(reader), paint); 966 } break; 967 case DRAW_PICTURE: 968 canvas.drawPicture(getPicture(reader)); 969 break; 970 case DRAW_POINTS: { 971 const SkPaint& paint = *getPaint(reader); 972 SkCanvas::PointMode mode = (SkCanvas::PointMode)reader.readInt(); 973 size_t count = reader.readInt(); 974 const SkPoint* pts = (const SkPoint*)reader.skip(sizeof(SkPoint) * count); 975 canvas.drawPoints(mode, count, pts, paint); 976 } break; 977 case DRAW_POS_TEXT: { 978 const SkPaint& paint = *getPaint(reader); 979 getText(reader, &text); 980 size_t points = reader.readInt(); 981 const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint)); 982 canvas.drawPosText(text.text(), text.length(), pos, paint); 983 } break; 984 case DRAW_POS_TEXT_TOP_BOTTOM: { 985 const SkPaint& paint = *getPaint(reader); 986 getText(reader, &text); 987 size_t points = reader.readInt(); 988 const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint)); 989 const SkScalar top = reader.readScalar(); 990 const SkScalar bottom = reader.readScalar(); 991 if (!canvas.quickRejectY(top, bottom)) { 992 canvas.drawPosText(text.text(), text.length(), pos, paint); 993 } 994 } break; 995 case DRAW_POS_TEXT_H: { 996 const SkPaint& paint = *getPaint(reader); 997 getText(reader, &text); 998 size_t xCount = reader.readInt(); 999 const SkScalar constY = reader.readScalar(); 1000 const SkScalar* xpos = (const SkScalar*)reader.skip(xCount * sizeof(SkScalar)); 1001 canvas.drawPosTextH(text.text(), text.length(), xpos, constY, 1002 paint); 1003 } break; 1004 case DRAW_POS_TEXT_H_TOP_BOTTOM: { 1005 const SkPaint& paint = *getPaint(reader); 1006 getText(reader, &text); 1007 size_t xCount = reader.readInt(); 1008 const SkScalar* xpos = (const SkScalar*)reader.skip((3 + xCount) * sizeof(SkScalar)); 1009 const SkScalar top = *xpos++; 1010 const SkScalar bottom = *xpos++; 1011 const SkScalar constY = *xpos++; 1012 if (!canvas.quickRejectY(top, bottom)) { 1013 canvas.drawPosTextH(text.text(), text.length(), xpos, 1014 constY, paint); 1015 } 1016 } break; 1017 case DRAW_RECT: { 1018 const SkPaint& paint = *getPaint(reader); 1019 canvas.drawRect(reader.skipT<SkRect>(), paint); 1020 } break; 1021 case DRAW_RRECT: { 1022 const SkPaint& paint = *getPaint(reader); 1023 SkRRect rrect; 1024 reader.readRRect(&rrect); 1025 canvas.drawRRect(rrect, paint); 1026 } break; 1027 case DRAW_SPRITE: { 1028 const SkPaint* paint = getPaint(reader); 1029 const SkBitmap& bitmap = getBitmap(reader); 1030 int left = reader.readInt(); 1031 int top = reader.readInt(); 1032 canvas.drawSprite(bitmap, left, top, paint); 1033 } break; 1034 case DRAW_TEXT: { 1035 const SkPaint& paint = *getPaint(reader); 1036 getText(reader, &text); 1037 SkScalar x = reader.readScalar(); 1038 SkScalar y = reader.readScalar(); 1039 canvas.drawText(text.text(), text.length(), x, y, paint); 1040 } break; 1041 case DRAW_TEXT_TOP_BOTTOM: { 1042 const SkPaint& paint = *getPaint(reader); 1043 getText(reader, &text); 1044 const SkScalar* ptr = (const SkScalar*)reader.skip(4 * sizeof(SkScalar)); 1045 // ptr[0] == x 1046 // ptr[1] == y 1047 // ptr[2] == top 1048 // ptr[3] == bottom 1049 if (!canvas.quickRejectY(ptr[2], ptr[3])) { 1050 canvas.drawText(text.text(), text.length(), ptr[0], ptr[1], 1051 paint); 1052 } 1053 } break; 1054 case DRAW_TEXT_ON_PATH: { 1055 const SkPaint& paint = *getPaint(reader); 1056 getText(reader, &text); 1057 const SkPath& path = getPath(reader); 1058 SkMatrix matrix; 1059 this->getMatrix(reader, &matrix); 1060 canvas.drawTextOnPath(text.text(), text.length(), path, &matrix, paint); 1061 } break; 1062 case DRAW_VERTICES: { 1063 SkAutoTUnref<SkXfermode> xfer; 1064 const SkPaint& paint = *getPaint(reader); 1065 DrawVertexFlags flags = (DrawVertexFlags)reader.readInt(); 1066 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readInt(); 1067 int vCount = reader.readInt(); 1068 const SkPoint* verts = (const SkPoint*)reader.skip( 1069 vCount * sizeof(SkPoint)); 1070 const SkPoint* texs = NULL; 1071 const SkColor* colors = NULL; 1072 const uint16_t* indices = NULL; 1073 int iCount = 0; 1074 if (flags & DRAW_VERTICES_HAS_TEXS) { 1075 texs = (const SkPoint*)reader.skip( 1076 vCount * sizeof(SkPoint)); 1077 } 1078 if (flags & DRAW_VERTICES_HAS_COLORS) { 1079 colors = (const SkColor*)reader.skip( 1080 vCount * sizeof(SkColor)); 1081 } 1082 if (flags & DRAW_VERTICES_HAS_INDICES) { 1083 iCount = reader.readInt(); 1084 indices = (const uint16_t*)reader.skip( 1085 iCount * sizeof(uint16_t)); 1086 } 1087 if (flags & DRAW_VERTICES_HAS_XFER) { 1088 int mode = reader.readInt(); 1089 if (mode < 0 || mode > SkXfermode::kLastMode) { 1090 mode = SkXfermode::kModulate_Mode; 1091 } 1092 xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode)); 1093 } 1094 canvas.drawVertices(vmode, vCount, verts, texs, colors, xfer, 1095 indices, iCount, paint); 1096 } break; 1097 case RESTORE: 1098 canvas.restore(); 1099 break; 1100 case ROTATE: 1101 canvas.rotate(reader.readScalar()); 1102 break; 1103 case SAVE: 1104 canvas.save((SkCanvas::SaveFlags) reader.readInt()); 1105 break; 1106 case SAVE_LAYER: { 1107 const SkRect* boundsPtr = getRectPtr(reader); 1108 const SkPaint* paint = getPaint(reader); 1109 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.readInt()); 1110 } break; 1111 case SCALE: { 1112 SkScalar sx = reader.readScalar(); 1113 SkScalar sy = reader.readScalar(); 1114 canvas.scale(sx, sy); 1115 } break; 1116 case SET_MATRIX: { 1117 SkMatrix matrix; 1118 this->getMatrix(reader, &matrix); 1119 matrix.postConcat(initialMatrix); 1120 canvas.setMatrix(matrix); 1121 } break; 1122 case SKEW: { 1123 SkScalar sx = reader.readScalar(); 1124 SkScalar sy = reader.readScalar(); 1125 canvas.skew(sx, sy); 1126 } break; 1127 case TRANSLATE: { 1128 SkScalar dx = reader.readScalar(); 1129 SkScalar dy = reader.readScalar(); 1130 canvas.translate(dx, dy); 1131 } break; 1132 default: 1133 SkASSERT(0); 1134 } 1135 1136#ifdef SK_DEVELOPER 1137 this->postDraw(opIndex); 1138#endif 1139 1140 if (it.isValid()) { 1141 uint32_t skipTo = it.draw(); 1142 if (kDrawComplete == skipTo) { 1143 break; 1144 } 1145 reader.setOffset(skipTo); 1146 } 1147 } 1148 1149#ifdef SPEW_CLIP_SKIPPING 1150 { 1151 size_t size = skipRect.fSize + skipRRect.fSize + skipPath.fSize + skipRegion.fSize + 1152 skipCull.fSize; 1153 SkDebugf("--- Clip skips %d%% rect:%d rrect:%d path:%d rgn:%d cull:%d\n", 1154 size * 100 / reader.offset(), skipRect.fCount, skipRRect.fCount, 1155 skipPath.fCount, skipRegion.fCount, skipCull.fCount); 1156 SkDebugf("--- Total ops: %d\n", opCount); 1157 } 1158#endif 1159// this->dumpSize(); 1160} 1161 1162/////////////////////////////////////////////////////////////////////////////// 1163 1164#ifdef SK_DEBUG_SIZE 1165int SkPicturePlayback::size(size_t* sizePtr) { 1166 int objects = bitmaps(sizePtr); 1167 objects += paints(sizePtr); 1168 objects += paths(sizePtr); 1169 objects += pictures(sizePtr); 1170 objects += regions(sizePtr); 1171 *sizePtr = fOpData.size(); 1172 return objects; 1173} 1174 1175int SkPicturePlayback::bitmaps(size_t* size) { 1176 size_t result = 0; 1177 for (int index = 0; index < fBitmapCount; index++) { 1178 // const SkBitmap& bitmap = fBitmaps[index]; 1179 result += sizeof(SkBitmap); // bitmap->size(); 1180 } 1181 *size = result; 1182 return fBitmapCount; 1183} 1184 1185int SkPicturePlayback::paints(size_t* size) { 1186 size_t result = 0; 1187 for (int index = 0; index < fPaintCount; index++) { 1188 // const SkPaint& paint = fPaints[index]; 1189 result += sizeof(SkPaint); // paint->size(); 1190 } 1191 *size = result; 1192 return fPaintCount; 1193} 1194 1195int SkPicturePlayback::paths(size_t* size) { 1196 size_t result = 0; 1197 for (int index = 0; index < fPathCount; index++) { 1198 const SkPath& path = fPaths[index]; 1199 result += path.flatten(NULL); 1200 } 1201 *size = result; 1202 return fPathCount; 1203} 1204#endif 1205 1206#ifdef SK_DEBUG_DUMP 1207void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const { 1208 char pBuffer[DUMP_BUFFER_SIZE]; 1209 char* bufferPtr = pBuffer; 1210 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1211 "BitmapData bitmap%p = {", &bitmap); 1212 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1213 "{kWidth, %d}, ", bitmap.width()); 1214 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1215 "{kHeight, %d}, ", bitmap.height()); 1216 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1217 "{kRowBytes, %d}, ", bitmap.rowBytes()); 1218// start here; 1219 SkDebugf("%s{0}};\n", pBuffer); 1220} 1221 1222void dumpMatrix(const SkMatrix& matrix) const { 1223 SkMatrix defaultMatrix; 1224 defaultMatrix.reset(); 1225 char pBuffer[DUMP_BUFFER_SIZE]; 1226 char* bufferPtr = pBuffer; 1227 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1228 "MatrixData matrix%p = {", &matrix); 1229 SkScalar scaleX = matrix.getScaleX(); 1230 if (scaleX != defaultMatrix.getScaleX()) 1231 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1232 "{kScaleX, %g}, ", SkScalarToFloat(scaleX)); 1233 SkScalar scaleY = matrix.getScaleY(); 1234 if (scaleY != defaultMatrix.getScaleY()) 1235 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1236 "{kScaleY, %g}, ", SkScalarToFloat(scaleY)); 1237 SkScalar skewX = matrix.getSkewX(); 1238 if (skewX != defaultMatrix.getSkewX()) 1239 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1240 "{kSkewX, %g}, ", SkScalarToFloat(skewX)); 1241 SkScalar skewY = matrix.getSkewY(); 1242 if (skewY != defaultMatrix.getSkewY()) 1243 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1244 "{kSkewY, %g}, ", SkScalarToFloat(skewY)); 1245 SkScalar translateX = matrix.getTranslateX(); 1246 if (translateX != defaultMatrix.getTranslateX()) 1247 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1248 "{kTranslateX, %g}, ", SkScalarToFloat(translateX)); 1249 SkScalar translateY = matrix.getTranslateY(); 1250 if (translateY != defaultMatrix.getTranslateY()) 1251 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1252 "{kTranslateY, %g}, ", SkScalarToFloat(translateY)); 1253 SkScalar perspX = matrix.getPerspX(); 1254 if (perspX != defaultMatrix.getPerspX()) 1255 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1256 "{kPerspX, %g}, ", perspX); 1257 SkScalar perspY = matrix.getPerspY(); 1258 if (perspY != defaultMatrix.getPerspY()) 1259 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1260 "{kPerspY, %g}, ", perspY); 1261 SkDebugf("%s{0}};\n", pBuffer); 1262} 1263 1264void dumpPaint(const SkPaint& paint) const { 1265 SkPaint defaultPaint; 1266 char pBuffer[DUMP_BUFFER_SIZE]; 1267 char* bufferPtr = pBuffer; 1268 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1269 "PaintPointers paintPtrs%p = {", &paint); 1270 const SkTypeface* typeface = paint.getTypeface(); 1271 if (typeface != defaultPaint.getTypeface()) 1272 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1273 "{kTypeface, %p}, ", typeface); 1274 const SkPathEffect* pathEffect = paint.getPathEffect(); 1275 if (pathEffect != defaultPaint.getPathEffect()) 1276 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1277 "{kPathEffect, %p}, ", pathEffect); 1278 const SkShader* shader = paint.getShader(); 1279 if (shader != defaultPaint.getShader()) 1280 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1281 "{kShader, %p}, ", shader); 1282 const SkXfermode* xfermode = paint.getXfermode(); 1283 if (xfermode != defaultPaint.getXfermode()) 1284 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1285 "{kXfermode, %p}, ", xfermode); 1286 const SkMaskFilter* maskFilter = paint.getMaskFilter(); 1287 if (maskFilter != defaultPaint.getMaskFilter()) 1288 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1289 "{kMaskFilter, %p}, ", maskFilter); 1290 const SkColorFilter* colorFilter = paint.getColorFilter(); 1291 if (colorFilter != defaultPaint.getColorFilter()) 1292 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1293 "{kColorFilter, %p}, ", colorFilter); 1294 const SkRasterizer* rasterizer = paint.getRasterizer(); 1295 if (rasterizer != defaultPaint.getRasterizer()) 1296 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1297 "{kRasterizer, %p}, ", rasterizer); 1298 const SkDrawLooper* drawLooper = paint.getLooper(); 1299 if (drawLooper != defaultPaint.getLooper()) 1300 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1301 "{kDrawLooper, %p}, ", drawLooper); 1302 SkDebugf("%s{0}};\n", pBuffer); 1303 bufferPtr = pBuffer; 1304 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1305 "PaintScalars paintScalars%p = {", &paint); 1306 SkScalar textSize = paint.getTextSize(); 1307 if (textSize != defaultPaint.getTextSize()) 1308 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1309 "{kTextSize, %g}, ", SkScalarToFloat(textSize)); 1310 SkScalar textScaleX = paint.getTextScaleX(); 1311 if (textScaleX != defaultPaint.getTextScaleX()) 1312 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1313 "{kTextScaleX, %g}, ", SkScalarToFloat(textScaleX)); 1314 SkScalar textSkewX = paint.getTextSkewX(); 1315 if (textSkewX != defaultPaint.getTextSkewX()) 1316 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1317 "{kTextSkewX, %g}, ", SkScalarToFloat(textSkewX)); 1318 SkScalar strokeWidth = paint.getStrokeWidth(); 1319 if (strokeWidth != defaultPaint.getStrokeWidth()) 1320 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1321 "{kStrokeWidth, %g}, ", SkScalarToFloat(strokeWidth)); 1322 SkScalar strokeMiter = paint.getStrokeMiter(); 1323 if (strokeMiter != defaultPaint.getStrokeMiter()) 1324 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1325 "{kStrokeMiter, %g}, ", SkScalarToFloat(strokeMiter)); 1326 SkDebugf("%s{0}};\n", pBuffer); 1327 bufferPtr = pBuffer; 1328 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1329 "PaintInts = paintInts%p = {", &paint); 1330 unsigned color = paint.getColor(); 1331 if (color != defaultPaint.getColor()) 1332 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1333 "{kColor, 0x%x}, ", color); 1334 unsigned flags = paint.getFlags(); 1335 if (flags != defaultPaint.getFlags()) 1336 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1337 "{kFlags, 0x%x}, ", flags); 1338 int align = paint.getTextAlign(); 1339 if (align != defaultPaint.getTextAlign()) 1340 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1341 "{kAlign, 0x%x}, ", align); 1342 int strokeCap = paint.getStrokeCap(); 1343 if (strokeCap != defaultPaint.getStrokeCap()) 1344 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1345 "{kStrokeCap, 0x%x}, ", strokeCap); 1346 int strokeJoin = paint.getStrokeJoin(); 1347 if (strokeJoin != defaultPaint.getStrokeJoin()) 1348 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1349 "{kAlign, 0x%x}, ", strokeJoin); 1350 int style = paint.getStyle(); 1351 if (style != defaultPaint.getStyle()) 1352 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1353 "{kStyle, 0x%x}, ", style); 1354 int textEncoding = paint.getTextEncoding(); 1355 if (textEncoding != defaultPaint.getTextEncoding()) 1356 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1357 "{kTextEncoding, 0x%x}, ", textEncoding); 1358 SkDebugf("%s{0}};\n", pBuffer); 1359 1360 SkDebugf("PaintData paint%p = {paintPtrs%p, paintScalars%p, paintInts%p};\n", 1361 &paint, &paint, &paint, &paint); 1362} 1363 1364void SkPicturePlayback::dumpPath(const SkPath& path) const { 1365 SkDebugf("path dump unimplemented\n"); 1366} 1367 1368void SkPicturePlayback::dumpPicture(const SkPicture& picture) const { 1369 SkDebugf("picture dump unimplemented\n"); 1370} 1371 1372void SkPicturePlayback::dumpRegion(const SkRegion& region) const { 1373 SkDebugf("region dump unimplemented\n"); 1374} 1375 1376int SkPicturePlayback::dumpDrawType(char* bufferPtr, char* buffer, DrawType drawType) { 1377 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1378 "k%s, ", DrawTypeToString(drawType)); 1379} 1380 1381int SkPicturePlayback::dumpInt(char* bufferPtr, char* buffer, char* name) { 1382 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1383 "%s:%d, ", name, getInt()); 1384} 1385 1386int SkPicturePlayback::dumpRect(char* bufferPtr, char* buffer, char* name) { 1387 const SkRect* rect = fReader.skipRect(); 1388 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1389 "%s:{l:%g t:%g r:%g b:%g}, ", name, SkScalarToFloat(rect.fLeft), 1390 SkScalarToFloat(rect.fTop), 1391 SkScalarToFloat(rect.fRight), SkScalarToFloat(rect.fBottom)); 1392} 1393 1394int SkPicturePlayback::dumpPoint(char* bufferPtr, char* buffer, char* name) { 1395 SkPoint pt; 1396 getPoint(&pt); 1397 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1398 "%s:{x:%g y:%g}, ", name, SkScalarToFloat(pt.fX), 1399 SkScalarToFloat(pt.fY)); 1400} 1401 1402void SkPicturePlayback::dumpPointArray(char** bufferPtrPtr, char* buffer, int count) { 1403 char* bufferPtr = *bufferPtrPtr; 1404 const SkPoint* pts = (const SkPoint*)fReadStream.getAtPos(); 1405 fReadStream.skip(sizeof(SkPoint) * count); 1406 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1407 "count:%d {", count); 1408 for (int index = 0; index < count; index++) 1409 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1410 "{x:%g y:%g}, ", SkScalarToFloat(pts[index].fX), 1411 SkScalarToFloat(pts[index].fY)); 1412 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1413 "} "); 1414 *bufferPtrPtr = bufferPtr; 1415} 1416 1417int SkPicturePlayback::dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr) { 1418 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1419 "%s:%p, ", name, ptr); 1420} 1421 1422int SkPicturePlayback::dumpRectPtr(char* bufferPtr, char* buffer, char* name) { 1423 char result; 1424 fReadStream.read(&result, sizeof(result)); 1425 if (result) 1426 return dumpRect(bufferPtr, buffer, name); 1427 else 1428 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1429 "%s:NULL, ", name); 1430} 1431 1432int SkPicturePlayback::dumpScalar(char* bufferPtr, char* buffer, char* name) { 1433 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1434 "%s:%d, ", name, getScalar()); 1435} 1436 1437void SkPicturePlayback::dumpText(char** bufferPtrPtr, char* buffer) { 1438 char* bufferPtr = *bufferPtrPtr; 1439 int length = getInt(); 1440 bufferPtr += dumpDrawType(bufferPtr, buffer); 1441 fReadStream.skipToAlign4(); 1442 char* text = (char*) fReadStream.getAtPos(); 1443 fReadStream.skip(length); 1444 bufferPtr += dumpInt(bufferPtr, buffer, "length"); 1445 int limit = DUMP_BUFFER_SIZE - (bufferPtr - buffer) - 2; 1446 length >>= 1; 1447 if (limit > length) 1448 limit = length; 1449 if (limit > 0) { 1450 *bufferPtr++ = '"'; 1451 for (int index = 0; index < limit; index++) { 1452 *bufferPtr++ = *(unsigned short*) text; 1453 text += sizeof(unsigned short); 1454 } 1455 *bufferPtr++ = '"'; 1456 } 1457 *bufferPtrPtr = bufferPtr; 1458} 1459 1460#define DUMP_DRAWTYPE(drawType) \ 1461 bufferPtr += dumpDrawType(bufferPtr, buffer, drawType) 1462 1463#define DUMP_INT(name) \ 1464 bufferPtr += dumpInt(bufferPtr, buffer, #name) 1465 1466#define DUMP_RECT_PTR(name) \ 1467 bufferPtr += dumpRectPtr(bufferPtr, buffer, #name) 1468 1469#define DUMP_POINT(name) \ 1470 bufferPtr += dumpRect(bufferPtr, buffer, #name) 1471 1472#define DUMP_RECT(name) \ 1473 bufferPtr += dumpRect(bufferPtr, buffer, #name) 1474 1475#define DUMP_POINT_ARRAY(count) \ 1476 dumpPointArray(&bufferPtr, buffer, count) 1477 1478#define DUMP_PTR(name, ptr) \ 1479 bufferPtr += dumpPtr(bufferPtr, buffer, #name, (void*) ptr) 1480 1481#define DUMP_SCALAR(name) \ 1482 bufferPtr += dumpScalar(bufferPtr, buffer, #name) 1483 1484#define DUMP_TEXT() \ 1485 dumpText(&bufferPtr, buffer) 1486 1487void SkPicturePlayback::dumpStream() { 1488 SkDebugf("RecordStream stream = {\n"); 1489 DrawType drawType; 1490 TextContainer text; 1491 fReadStream.rewind(); 1492 char buffer[DUMP_BUFFER_SIZE], * bufferPtr; 1493 while (fReadStream.read(&drawType, sizeof(drawType))) { 1494 bufferPtr = buffer; 1495 DUMP_DRAWTYPE(drawType); 1496 switch (drawType) { 1497 case CLIP_PATH: { 1498 DUMP_PTR(SkPath, &getPath()); 1499 DUMP_INT(SkRegion::Op); 1500 DUMP_INT(offsetToRestore); 1501 } break; 1502 case CLIP_REGION: { 1503 DUMP_INT(SkRegion::Op); 1504 DUMP_INT(offsetToRestore); 1505 } break; 1506 case CLIP_RECT: { 1507 DUMP_RECT(rect); 1508 DUMP_INT(SkRegion::Op); 1509 DUMP_INT(offsetToRestore); 1510 } break; 1511 case CONCAT: 1512 break; 1513 case DRAW_BITMAP: { 1514 DUMP_PTR(SkPaint, getPaint()); 1515 DUMP_PTR(SkBitmap, &getBitmap()); 1516 DUMP_SCALAR(left); 1517 DUMP_SCALAR(top); 1518 } break; 1519 case DRAW_PAINT: 1520 DUMP_PTR(SkPaint, getPaint()); 1521 break; 1522 case DRAW_PATH: { 1523 DUMP_PTR(SkPaint, getPaint()); 1524 DUMP_PTR(SkPath, &getPath()); 1525 } break; 1526 case DRAW_PICTURE: { 1527 DUMP_PTR(SkPicture, &getPicture()); 1528 } break; 1529 case DRAW_POINTS: { 1530 DUMP_PTR(SkPaint, getPaint()); 1531 (void)getInt(); // PointMode 1532 size_t count = getInt(); 1533 fReadStream.skipToAlign4(); 1534 DUMP_POINT_ARRAY(count); 1535 } break; 1536 case DRAW_POS_TEXT: { 1537 DUMP_PTR(SkPaint, getPaint()); 1538 DUMP_TEXT(); 1539 size_t points = getInt(); 1540 fReadStream.skipToAlign4(); 1541 DUMP_POINT_ARRAY(points); 1542 } break; 1543 case DRAW_POS_TEXT_H: { 1544 DUMP_PTR(SkPaint, getPaint()); 1545 DUMP_TEXT(); 1546 size_t points = getInt(); 1547 fReadStream.skipToAlign4(); 1548 DUMP_SCALAR(top); 1549 DUMP_SCALAR(bottom); 1550 DUMP_SCALAR(constY); 1551 DUMP_POINT_ARRAY(points); 1552 } break; 1553 case DRAW_RECT: { 1554 DUMP_PTR(SkPaint, getPaint()); 1555 DUMP_RECT(rect); 1556 } break; 1557 case DRAW_SPRITE: { 1558 DUMP_PTR(SkPaint, getPaint()); 1559 DUMP_PTR(SkBitmap, &getBitmap()); 1560 DUMP_SCALAR(left); 1561 DUMP_SCALAR(top); 1562 } break; 1563 case DRAW_TEXT: { 1564 DUMP_PTR(SkPaint, getPaint()); 1565 DUMP_TEXT(); 1566 DUMP_SCALAR(x); 1567 DUMP_SCALAR(y); 1568 } break; 1569 case DRAW_TEXT_ON_PATH: { 1570 DUMP_PTR(SkPaint, getPaint()); 1571 DUMP_TEXT(); 1572 DUMP_PTR(SkPath, &getPath()); 1573 } break; 1574 case RESTORE: 1575 break; 1576 case ROTATE: 1577 DUMP_SCALAR(rotate); 1578 break; 1579 case SAVE: 1580 DUMP_INT(SkCanvas::SaveFlags); 1581 break; 1582 case SAVE_LAYER: { 1583 DUMP_RECT_PTR(layer); 1584 DUMP_PTR(SkPaint, getPaint()); 1585 DUMP_INT(SkCanvas::SaveFlags); 1586 } break; 1587 case SCALE: { 1588 DUMP_SCALAR(sx); 1589 DUMP_SCALAR(sy); 1590 } break; 1591 case SKEW: { 1592 DUMP_SCALAR(sx); 1593 DUMP_SCALAR(sy); 1594 } break; 1595 case TRANSLATE: { 1596 DUMP_SCALAR(dx); 1597 DUMP_SCALAR(dy); 1598 } break; 1599 default: 1600 SkASSERT(0); 1601 } 1602 SkDebugf("%s\n", buffer); 1603 } 1604} 1605 1606void SkPicturePlayback::dump() const { 1607 char pBuffer[DUMP_BUFFER_SIZE]; 1608 char* bufferPtr = pBuffer; 1609 int index; 1610 if (fBitmapCount > 0) 1611 SkDebugf("// bitmaps (%d)\n", fBitmapCount); 1612 for (index = 0; index < fBitmapCount; index++) { 1613 const SkBitmap& bitmap = fBitmaps[index]; 1614 dumpBitmap(bitmap); 1615 } 1616 if (fBitmapCount > 0) 1617 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1618 "Bitmaps bitmaps = {"); 1619 for (index = 0; index < fBitmapCount; index++) 1620 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1621 "bitmap%p, ", &fBitmaps[index]); 1622 if (fBitmapCount > 0) 1623 SkDebugf("%s0};\n", pBuffer); 1624 1625 1626 if (fPaintCount > 0) 1627 SkDebugf("// paints (%d)\n", fPaintCount); 1628 for (index = 0; index < fPaintCount; index++) { 1629 const SkPaint& paint = fPaints[index]; 1630 dumpPaint(paint); 1631 } 1632 bufferPtr = pBuffer; 1633 if (fPaintCount > 0) 1634 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1635 "Paints paints = {"); 1636 for (index = 0; index < fPaintCount; index++) 1637 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1638 "paint%p, ", &fPaints[index]); 1639 if (fPaintCount > 0) 1640 SkDebugf("%s0};\n", pBuffer); 1641 1642 for (index = 0; index < fPathCount; index++) { 1643 const SkPath& path = fPaths[index]; 1644 dumpPath(path); 1645 } 1646 bufferPtr = pBuffer; 1647 if (fPathCount > 0) 1648 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1649 "Paths paths = {"); 1650 for (index = 0; index < fPathCount; index++) 1651 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1652 "path%p, ", &fPaths[index]); 1653 if (fPathCount > 0) 1654 SkDebugf("%s0};\n", pBuffer); 1655 1656 for (index = 0; index < fPictureCount; index++) { 1657 dumpPicture(*fPictureRefs[index]); 1658 } 1659 bufferPtr = pBuffer; 1660 if (fPictureCount > 0) 1661 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1662 "Pictures pictures = {"); 1663 for (index = 0; index < fPictureCount; index++) 1664 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1665 "picture%p, ", fPictureRefs[index]); 1666 if (fPictureCount > 0) 1667 SkDebugf("%s0};\n", pBuffer); 1668 1669 const_cast<SkPicturePlayback*>(this)->dumpStream(); 1670} 1671 1672#endif 1673