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