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