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