1 #include "SkPicturePlayback.h" 2 #include "SkPictureRecord.h" 3 #include "SkTypeface.h" 4 #include <new> 5 6 /* Define this to spew out a debug statement whenever we skip the remainder of 7 a save/restore block because a clip... command returned false (empty). 8 */ 9 #define SPEW_CLIP_SKIPPINGx 10 11 SkPicturePlayback::SkPicturePlayback() { 12 this->init(); 13 } 14 15 SkPicturePlayback::SkPicturePlayback(const SkPictureRecord& record) { 16 #ifdef SK_DEBUG_SIZE 17 size_t overallBytes, bitmapBytes, matricesBytes, 18 paintBytes, pathBytes, pictureBytes, regionBytes; 19 int bitmaps = record.bitmaps(&bitmapBytes); 20 int matrices = record.matrices(&matricesBytes); 21 int paints = record.paints(&paintBytes); 22 int paths = record.paths(&pathBytes); 23 int pictures = record.pictures(&pictureBytes); 24 int regions = record.regions(®ionBytes); 25 SkDebugf("picture record mem used %zd (stream %zd) ", record.size(), 26 record.streamlen()); 27 if (bitmaps != 0) 28 SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps); 29 if (matrices != 0) 30 SkDebugf("matrices size %zd (matrices:%d) ", matricesBytes, matrices); 31 if (paints != 0) 32 SkDebugf("paints size %zd (paints:%d) ", paintBytes, paints); 33 if (paths != 0) 34 SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths); 35 if (pictures != 0) 36 SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures); 37 if (regions != 0) 38 SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions); 39 if (record.fPointWrites != 0) 40 SkDebugf("points size %zd (points:%d) ", record.fPointBytes, record.fPointWrites); 41 if (record.fRectWrites != 0) 42 SkDebugf("rects size %zd (rects:%d) ", record.fRectBytes, record.fRectWrites); 43 if (record.fTextWrites != 0) 44 SkDebugf("text size %zd (text strings:%d) ", record.fTextBytes, record.fTextWrites); 45 46 SkDebugf("\n"); 47 #endif 48 #ifdef SK_DEBUG_DUMP 49 record.dumpMatrices(); 50 record.dumpPaints(); 51 #endif 52 53 record.validate(); 54 const SkWriter32& writer = record.writeStream(); 55 init(); 56 if (writer.size() == 0) 57 return; 58 59 { 60 size_t size = writer.size(); 61 void* buffer = sk_malloc_throw(size); 62 writer.flatten(buffer); 63 fReader.setMemory(buffer, size); // fReader owns buffer now 64 } 65 66 // copy over the refcnt dictionary to our reader 67 // 68 fRCPlayback.reset(&record.fRCSet); 69 fRCPlayback.setupBuffer(fReader); 70 71 fTFPlayback.reset(&record.fTFSet); 72 fTFPlayback.setupBuffer(fReader); 73 74 const SkTDArray<const SkFlatBitmap* >& bitmaps = record.getBitmaps(); 75 fBitmapCount = bitmaps.count(); 76 if (fBitmapCount > 0) { 77 fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount); 78 for (const SkFlatBitmap** flatBitmapPtr = bitmaps.begin(); 79 flatBitmapPtr != bitmaps.end(); flatBitmapPtr++) { 80 const SkFlatBitmap* flatBitmap = *flatBitmapPtr; 81 int index = flatBitmap->index() - 1; 82 flatBitmap->unflatten(&fBitmaps[index], &fRCPlayback); 83 } 84 } 85 86 const SkTDArray<const SkFlatMatrix* >& matrices = record.getMatrices(); 87 fMatrixCount = matrices.count(); 88 if (fMatrixCount > 0) { 89 fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount); 90 for (const SkFlatMatrix** matrixPtr = matrices.begin(); 91 matrixPtr != matrices.end(); matrixPtr++) { 92 const SkFlatMatrix* flatMatrix = *matrixPtr; 93 flatMatrix->unflatten(&fMatrices[flatMatrix->index() - 1]); 94 } 95 } 96 97 const SkTDArray<const SkFlatPaint* >& paints = record.getPaints(); 98 fPaintCount = paints.count(); 99 if (fPaintCount > 0) { 100 fPaints = SkNEW_ARRAY(SkPaint, fPaintCount); 101 for (const SkFlatPaint** flatPaintPtr = paints.begin(); 102 flatPaintPtr != paints.end(); flatPaintPtr++) { 103 const SkFlatPaint* flatPaint = *flatPaintPtr; 104 int index = flatPaint->index() - 1; 105 SkASSERT((unsigned)index < (unsigned)fPaintCount); 106 flatPaint->unflatten(&fPaints[index], &fRCPlayback, &fTFPlayback); 107 } 108 } 109 110 fPathHeap = record.fPathHeap; 111 SkSafeRef(fPathHeap); 112 113 const SkTDArray<SkPicture* >& pictures = record.getPictureRefs(); 114 fPictureCount = pictures.count(); 115 if (fPictureCount > 0) { 116 fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); 117 for (int i = 0; i < fPictureCount; i++) { 118 fPictureRefs[i] = pictures[i]; 119 fPictureRefs[i]->ref(); 120 } 121 } 122 123 const SkTDArray<SkShape* >& shapes = record.getShapes(); 124 fShapeCount = shapes.count(); 125 if (fShapeCount > 0) { 126 fShapes = SkNEW_ARRAY(SkShape*, fShapeCount); 127 for (int i = 0; i < fShapeCount; i++) { 128 SkShape* s = shapes[i]; 129 SkSafeRef(s); 130 fShapes[i] = s; 131 } 132 } 133 134 const SkTDArray<const SkFlatRegion* >& regions = record.getRegions(); 135 fRegionCount = regions.count(); 136 if (fRegionCount > 0) { 137 fRegions = SkNEW_ARRAY(SkRegion, fRegionCount); 138 for (const SkFlatRegion** flatRegionPtr = regions.begin(); 139 flatRegionPtr != regions.end(); flatRegionPtr++) { 140 const SkFlatRegion* flatRegion = *flatRegionPtr; 141 flatRegion->unflatten(&fRegions[flatRegion->index() - 1]); 142 } 143 } 144 145 #ifdef SK_DEBUG_SIZE 146 int overall = fPlayback->size(&overallBytes); 147 bitmaps = fPlayback->bitmaps(&bitmapBytes); 148 paints = fPlayback->paints(&paintBytes); 149 paths = fPlayback->paths(&pathBytes); 150 pictures = fPlayback->pictures(&pictureBytes); 151 regions = fPlayback->regions(®ionBytes); 152 SkDebugf("playback size %zd (objects:%d) ", overallBytes, overall); 153 if (bitmaps != 0) 154 SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps); 155 if (paints != 0) 156 SkDebugf("paints size %zd (paints:%d) ", paintBytes, paints); 157 if (paths != 0) 158 SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths); 159 if (pictures != 0) 160 SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures); 161 if (regions != 0) 162 SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions); 163 SkDebugf("\n"); 164 #endif 165 } 166 167 SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src) { 168 this->init(); 169 170 // copy the data from fReader 171 { 172 size_t size = src.fReader.size(); 173 void* buffer = sk_malloc_throw(size); 174 memcpy(buffer, src.fReader.base(), size); 175 fReader.setMemory(buffer, size); 176 } 177 178 int i; 179 180 fBitmapCount = src.fBitmapCount; 181 fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount); 182 for (i = 0; i < fBitmapCount; i++) { 183 fBitmaps[i] = src.fBitmaps[i]; 184 } 185 186 fMatrixCount = src.fMatrixCount; 187 fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount); 188 memcpy(fMatrices, src.fMatrices, fMatrixCount * sizeof(SkMatrix)); 189 190 fPaintCount = src.fPaintCount; 191 fPaints = SkNEW_ARRAY(SkPaint, fPaintCount); 192 for (i = 0; i < fPaintCount; i++) { 193 fPaints[i] = src.fPaints[i]; 194 } 195 196 fPathHeap = src.fPathHeap; 197 SkSafeRef(fPathHeap); 198 199 fPictureCount = src.fPictureCount; 200 fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); 201 for (int i = 0; i < fPictureCount; i++) { 202 fPictureRefs[i] = src.fPictureRefs[i]; 203 fPictureRefs[i]->ref(); 204 } 205 206 fShapeCount = src.fShapeCount; 207 fShapes = SkNEW_ARRAY(SkShape*, fShapeCount); 208 for (int i = 0; i < fShapeCount; i++) { 209 SkShape* s = src.fShapes[i]; 210 SkSafeRef(s); 211 fShapes[i] = s; 212 } 213 214 fRegionCount = src.fRegionCount; 215 fRegions = SkNEW_ARRAY(SkRegion, fRegionCount); 216 for (i = 0; i < fRegionCount; i++) { 217 fRegions[i] = src.fRegions[i]; 218 } 219 } 220 221 void SkPicturePlayback::init() { 222 fBitmaps = NULL; 223 fMatrices = NULL; 224 fPaints = NULL; 225 fPathHeap = NULL; 226 fPictureRefs = NULL; 227 fShapes = NULL; 228 fRegions = NULL; 229 fBitmapCount = fMatrixCount = fPaintCount = fPictureCount = 230 fRegionCount = fShapeCount = 0; 231 232 fFactoryPlayback = NULL; 233 } 234 235 SkPicturePlayback::~SkPicturePlayback() { 236 sk_free((void*) fReader.base()); 237 238 SkDELETE_ARRAY(fBitmaps); 239 SkDELETE_ARRAY(fMatrices); 240 SkDELETE_ARRAY(fPaints); 241 SkDELETE_ARRAY(fRegions); 242 243 SkSafeUnref(fPathHeap); 244 245 for (int i = 0; i < fPictureCount; i++) { 246 fPictureRefs[i]->unref(); 247 } 248 SkDELETE_ARRAY(fPictureRefs); 249 250 for (int i = 0; i < fShapeCount; i++) { 251 SkSafeUnref(fShapes[i]); 252 } 253 SkDELETE_ARRAY(fShapes); 254 255 SkDELETE(fFactoryPlayback); 256 } 257 258 void SkPicturePlayback::dumpSize() const { 259 SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] matrices=%d [%d] paints=%d [%d] paths=%d regions=%d\n", 260 fReader.size(), 261 fBitmapCount, fBitmapCount * sizeof(SkBitmap), 262 fMatrixCount, fMatrixCount * sizeof(SkMatrix), 263 fPaintCount, fPaintCount * sizeof(SkPaint), 264 fPathHeap ? fPathHeap->count() : 0, 265 fRegionCount); 266 } 267 268 /////////////////////////////////////////////////////////////////////////////// 269 /////////////////////////////////////////////////////////////////////////////// 270 271 // The chunks are writte/read in this order... 272 273 #define PICT_READER_TAG SkSetFourByteTag('r', 'e', 'a', 'd') 274 #define PICT_FACTORY_TAG SkSetFourByteTag('f', 'a', 'c', 't') 275 #define PICT_TYPEFACE_TAG SkSetFourByteTag('t', 'p', 'f', 'c') 276 #define PICT_PICTURE_TAG SkSetFourByteTag('p', 'c', 't', 'r') 277 #define PICT_ARRAYS_TAG SkSetFourByteTag('a', 'r', 'a', 'y') 278 // these are all inside the ARRAYS tag 279 #define PICT_BITMAP_TAG SkSetFourByteTag('b', 't', 'm', 'p') 280 #define PICT_MATRIX_TAG SkSetFourByteTag('m', 't', 'r', 'x') 281 #define PICT_PAINT_TAG SkSetFourByteTag('p', 'n', 't', ' ') 282 #define PICT_PATH_TAG SkSetFourByteTag('p', 't', 'h', ' ') 283 #define PICT_REGION_TAG SkSetFourByteTag('r', 'g', 'n', ' ') 284 #define PICT_SHAPE_TAG SkSetFourByteTag('s', 'h', 'p', ' ') 285 286 #include "SkStream.h" 287 288 static void writeTagSize(SkFlattenableWriteBuffer& buffer, uint32_t tag, 289 uint32_t size) { 290 buffer.write32(tag); 291 buffer.write32(size); 292 } 293 294 static void writeTagSize(SkWStream* stream, uint32_t tag, 295 uint32_t size) { 296 stream->write32(tag); 297 stream->write32(size); 298 } 299 300 static void writeFactories(SkWStream* stream, const SkFactorySet& rec) { 301 int count = rec.count(); 302 303 writeTagSize(stream, PICT_FACTORY_TAG, count); 304 305 SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count); 306 SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get(); 307 rec.copyToArray(array); 308 309 for (int i = 0; i < count; i++) { 310 const char* name = SkFlattenable::FactoryToName(array[i]); 311 // SkDebugf("---- write factories [%d] %p <%s>\n", i, array[i], name); 312 if (NULL == name || 0 == *name) { 313 stream->writePackedUInt(0); 314 } else { 315 uint32_t len = strlen(name); 316 stream->writePackedUInt(len); 317 stream->write(name, len); 318 } 319 } 320 } 321 322 static void writeTypefaces(SkWStream* stream, const SkRefCntSet& rec) { 323 int count = rec.count(); 324 325 writeTagSize(stream, PICT_TYPEFACE_TAG, count); 326 327 SkAutoSTMalloc<16, SkTypeface*> storage(count); 328 SkTypeface** array = (SkTypeface**)storage.get(); 329 rec.copyToArray((SkRefCnt**)array); 330 331 for (int i = 0; i < count; i++) { 332 array[i]->serialize(stream); 333 } 334 } 335 336 void SkPicturePlayback::serialize(SkWStream* stream) const { 337 writeTagSize(stream, PICT_READER_TAG, fReader.size()); 338 stream->write(fReader.base(), fReader.size()); 339 340 SkRefCntSet typefaceSet; 341 SkFactorySet factSet; 342 343 SkFlattenableWriteBuffer buffer(1024); 344 345 buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag); 346 buffer.setTypefaceRecorder(&typefaceSet); 347 buffer.setFactoryRecorder(&factSet); 348 349 int i; 350 351 writeTagSize(buffer, PICT_BITMAP_TAG, fBitmapCount); 352 for (i = 0; i < fBitmapCount; i++) { 353 fBitmaps[i].flatten(buffer); 354 } 355 356 writeTagSize(buffer, PICT_MATRIX_TAG, fMatrixCount); 357 buffer.writeMul4(fMatrices, fMatrixCount * sizeof(SkMatrix)); 358 359 writeTagSize(buffer, PICT_PAINT_TAG, fPaintCount); 360 for (i = 0; i < fPaintCount; i++) { 361 fPaints[i].flatten(buffer); 362 } 363 364 { 365 int count = fPathHeap ? fPathHeap->count() : 0; 366 writeTagSize(buffer, PICT_PATH_TAG, count); 367 if (count > 0) { 368 fPathHeap->flatten(buffer); 369 } 370 } 371 372 writeTagSize(buffer, PICT_REGION_TAG, fRegionCount); 373 for (i = 0; i < fRegionCount; i++) { 374 uint32_t size = fRegions[i].flatten(NULL); 375 buffer.write32(size); 376 SkAutoSMalloc<512> storage(size); 377 fRegions[i].flatten(storage.get()); 378 buffer.writePad(storage.get(), size); 379 } 380 381 writeTagSize(buffer, PICT_SHAPE_TAG, fShapeCount); 382 for (i = 0; i < fShapeCount; i++) { 383 buffer.writeFlattenable(fShapes[i]); 384 } 385 386 // now we can write to the stream again 387 388 writeFactories(stream, factSet); 389 writeTypefaces(stream, typefaceSet); 390 391 writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount); 392 for (i = 0; i < fPictureCount; i++) { 393 fPictureRefs[i]->serialize(stream); 394 } 395 396 writeTagSize(stream, PICT_ARRAYS_TAG, buffer.size()); 397 buffer.writeToStream(stream); 398 } 399 400 /////////////////////////////////////////////////////////////////////////////// 401 402 static int readTagSize(SkFlattenableReadBuffer& buffer, uint32_t expectedTag) { 403 uint32_t tag = buffer.readU32(); 404 if (tag != expectedTag) { 405 sk_throw(); 406 } 407 return buffer.readU32(); 408 } 409 410 static int readTagSize(SkStream* stream, uint32_t expectedTag) { 411 uint32_t tag = stream->readU32(); 412 if (tag != expectedTag) { 413 sk_throw(); 414 } 415 return stream->readU32(); 416 } 417 418 SkPicturePlayback::SkPicturePlayback(SkStream* stream) { 419 this->init(); 420 421 int i; 422 423 { 424 size_t size = readTagSize(stream, PICT_READER_TAG); 425 void* storage = sk_malloc_throw(size); 426 stream->read(storage, size); 427 fReader.setMemory(storage, size); 428 } 429 430 int factoryCount = readTagSize(stream, PICT_FACTORY_TAG); 431 fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (factoryCount)); 432 for (i = 0; i < factoryCount; i++) { 433 SkString str; 434 int len = stream->readPackedUInt(); 435 str.resize(len); 436 stream->read(str.writable_str(), len); 437 // SkDebugf("--- factory playback [%d] <%s>\n", i, str.c_str()); 438 fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str()); 439 } 440 441 int typefaceCount = readTagSize(stream, PICT_TYPEFACE_TAG); 442 fTFPlayback.setCount(typefaceCount); 443 for (i = 0; i < typefaceCount; i++) { 444 SkSafeUnref(fTFPlayback.set(i, SkTypeface::Deserialize(stream))); 445 } 446 447 fPictureCount = readTagSize(stream, PICT_PICTURE_TAG); 448 fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); 449 for (i = 0; i < fPictureCount; i++) { 450 fPictureRefs[i] = SkNEW_ARGS(SkPicture, (stream)); 451 } 452 453 /* 454 Now read the arrays chunk, and parse using a read buffer 455 */ 456 uint32_t size = readTagSize(stream, PICT_ARRAYS_TAG); 457 SkAutoMalloc storage(size); 458 stream->read(storage.get(), size); 459 460 SkFlattenableReadBuffer buffer(storage.get(), size); 461 fFactoryPlayback->setupBuffer(buffer); 462 fTFPlayback.setupBuffer(buffer); 463 464 fBitmapCount = readTagSize(buffer, PICT_BITMAP_TAG); 465 fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount); 466 for (i = 0; i < fBitmapCount; i++) { 467 fBitmaps[i].unflatten(buffer); 468 } 469 470 fMatrixCount = readTagSize(buffer, PICT_MATRIX_TAG); 471 fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount); 472 buffer.read(fMatrices, fMatrixCount * sizeof(SkMatrix)); 473 474 fPaintCount = readTagSize(buffer, PICT_PAINT_TAG); 475 fPaints = SkNEW_ARRAY(SkPaint, fPaintCount); 476 for (i = 0; i < fPaintCount; i++) { 477 fPaints[i].unflatten(buffer); 478 } 479 480 { 481 int count = readTagSize(buffer, PICT_PATH_TAG); 482 if (count > 0) { 483 fPathHeap = SkNEW_ARGS(SkPathHeap, (buffer)); 484 } 485 } 486 487 fRegionCount = readTagSize(buffer, PICT_REGION_TAG); 488 fRegions = SkNEW_ARRAY(SkRegion, fRegionCount); 489 for (i = 0; i < fRegionCount; i++) { 490 uint32_t size = buffer.readU32(); 491 SkDEBUGCODE(uint32_t bytes =) fRegions[i].unflatten(buffer.skip(size)); 492 SkASSERT(size == bytes); 493 } 494 495 fShapeCount = readTagSize(buffer, PICT_SHAPE_TAG); 496 fShapes = SkNEW_ARRAY(SkShape*, fShapeCount); 497 for (i = 0; i < fShapeCount; i++) { 498 fShapes[i] = reinterpret_cast<SkShape*>(buffer.readFlattenable()); 499 } 500 } 501 502 /////////////////////////////////////////////////////////////////////////////// 503 /////////////////////////////////////////////////////////////////////////////// 504 505 #ifdef SPEW_CLIP_SKIPPING 506 struct SkipClipRec { 507 int fCount; 508 size_t fSize; 509 510 SkipClipRec() { 511 fCount = 0; 512 fSize = 0; 513 } 514 515 void recordSkip(size_t bytes) { 516 fCount += 1; 517 fSize += bytes; 518 } 519 }; 520 #endif 521 522 void SkPicturePlayback::draw(SkCanvas& canvas) { 523 #ifdef ENABLE_TIME_DRAW 524 SkAutoTime at("SkPicture::draw", 50); 525 #endif 526 527 #ifdef SPEW_CLIP_SKIPPING 528 SkipClipRec skipRect, skipRegion, skipPath; 529 #endif 530 531 #ifdef ANDROID 532 SkAutoMutexAcquire autoMutex(fDrawMutex); 533 #endif 534 535 TextContainer text; 536 fReader.rewind(); 537 538 while (!fReader.eof()) { 539 switch (fReader.readInt()) { 540 case CLIP_PATH: { 541 const SkPath& path = getPath(); 542 SkRegion::Op op = (SkRegion::Op) getInt(); 543 size_t offsetToRestore = getInt(); 544 // HACK (false) until I can handle op==kReplace 545 if (!canvas.clipPath(path, op)) { 546 #ifdef SPEW_CLIP_SKIPPING 547 skipPath.recordSkip(offsetToRestore - fReader.offset()); 548 #endif 549 fReader.setOffset(offsetToRestore); 550 } 551 } break; 552 case CLIP_REGION: { 553 const SkRegion& region = getRegion(); 554 SkRegion::Op op = (SkRegion::Op) getInt(); 555 size_t offsetToRestore = getInt(); 556 if (!canvas.clipRegion(region, op)) { 557 #ifdef SPEW_CLIP_SKIPPING 558 skipRegion.recordSkip(offsetToRestore - fReader.offset()); 559 #endif 560 fReader.setOffset(offsetToRestore); 561 } 562 } break; 563 case CLIP_RECT: { 564 const SkRect* rect = fReader.skipRect(); 565 SkRegion::Op op = (SkRegion::Op) getInt(); 566 size_t offsetToRestore = getInt(); 567 if (!canvas.clipRect(*rect, op)) { 568 #ifdef SPEW_CLIP_SKIPPING 569 skipRect.recordSkip(offsetToRestore - fReader.offset()); 570 #endif 571 fReader.setOffset(offsetToRestore); 572 } 573 } break; 574 case CONCAT: 575 canvas.concat(*getMatrix()); 576 break; 577 case DRAW_BITMAP: { 578 const SkPaint* paint = getPaint(); 579 const SkBitmap& bitmap = getBitmap(); 580 const SkPoint* loc = fReader.skipPoint(); 581 canvas.drawBitmap(bitmap, loc->fX, loc->fY, paint); 582 } break; 583 case DRAW_BITMAP_RECT: { 584 const SkPaint* paint = getPaint(); 585 const SkBitmap& bitmap = getBitmap(); 586 const SkIRect* src = this->getIRectPtr(); // may be null 587 const SkRect* dst = fReader.skipRect(); // required 588 canvas.drawBitmapRect(bitmap, src, *dst, paint); 589 } break; 590 case DRAW_BITMAP_MATRIX: { 591 const SkPaint* paint = getPaint(); 592 const SkBitmap& bitmap = getBitmap(); 593 const SkMatrix* matrix = getMatrix(); 594 canvas.drawBitmapMatrix(bitmap, *matrix, paint); 595 } break; 596 case DRAW_CLEAR: 597 canvas.clear(getInt()); 598 break; 599 case DRAW_DATA: { 600 size_t length = getInt(); 601 canvas.drawData(fReader.skip(length), length); 602 // skip handles padding the read out to a multiple of 4 603 } break; 604 case DRAW_PAINT: 605 canvas.drawPaint(*getPaint()); 606 break; 607 case DRAW_PATH: { 608 const SkPaint& paint = *getPaint(); 609 canvas.drawPath(getPath(), paint); 610 } break; 611 case DRAW_PICTURE: 612 canvas.drawPicture(getPicture()); 613 break; 614 case DRAW_POINTS: { 615 const SkPaint& paint = *getPaint(); 616 SkCanvas::PointMode mode = (SkCanvas::PointMode)getInt(); 617 size_t count = getInt(); 618 const SkPoint* pts = (const SkPoint*)fReader.skip(sizeof(SkPoint) * count); 619 canvas.drawPoints(mode, count, pts, paint); 620 } break; 621 case DRAW_POS_TEXT: { 622 const SkPaint& paint = *getPaint(); 623 getText(&text); 624 size_t points = getInt(); 625 const SkPoint* pos = (const SkPoint*)fReader.skip(points * sizeof(SkPoint)); 626 canvas.drawPosText(text.text(), text.length(), pos, paint); 627 } break; 628 case DRAW_POS_TEXT_H: { 629 const SkPaint& paint = *getPaint(); 630 getText(&text); 631 size_t xCount = getInt(); 632 const SkScalar constY = getScalar(); 633 const SkScalar* xpos = (const SkScalar*)fReader.skip(xCount * sizeof(SkScalar)); 634 canvas.drawPosTextH(text.text(), text.length(), xpos, constY, 635 paint); 636 } break; 637 case DRAW_POS_TEXT_H_TOP_BOTTOM: { 638 const SkPaint& paint = *getPaint(); 639 getText(&text); 640 size_t xCount = getInt(); 641 const SkScalar* xpos = (const SkScalar*)fReader.skip((3 + xCount) * sizeof(SkScalar)); 642 const SkScalar top = *xpos++; 643 const SkScalar bottom = *xpos++; 644 const SkScalar constY = *xpos++; 645 if (!canvas.quickRejectY(top, bottom, SkCanvas::kAA_EdgeType)) { 646 canvas.drawPosTextH(text.text(), text.length(), xpos, 647 constY, paint); 648 } 649 } break; 650 case DRAW_RECT: { 651 const SkPaint& paint = *getPaint(); 652 canvas.drawRect(*fReader.skipRect(), paint); 653 } break; 654 case DRAW_SHAPE: { 655 SkShape* shape = getShape(); 656 if (shape) { 657 canvas.drawShape(shape); 658 } 659 } break; 660 case DRAW_SPRITE: { 661 const SkPaint* paint = getPaint(); 662 const SkBitmap& bitmap = getBitmap(); 663 int left = getInt(); 664 int top = getInt(); 665 canvas.drawSprite(bitmap, left, top, paint); 666 } break; 667 case DRAW_TEXT: { 668 const SkPaint& paint = *getPaint(); 669 getText(&text); 670 SkScalar x = getScalar(); 671 SkScalar y = getScalar(); 672 canvas.drawText(text.text(), text.length(), x, y, paint); 673 } break; 674 case DRAW_TEXT_TOP_BOTTOM: { 675 const SkPaint& paint = *getPaint(); 676 getText(&text); 677 const SkScalar* ptr = (const SkScalar*)fReader.skip(4 * sizeof(SkScalar)); 678 // ptr[0] == x 679 // ptr[1] == y 680 // ptr[2] == top 681 // ptr[3] == bottom 682 if (!canvas.quickRejectY(ptr[2], ptr[3], 683 SkCanvas::kAA_EdgeType)) { 684 canvas.drawText(text.text(), text.length(), ptr[0], ptr[1], 685 paint); 686 } 687 } break; 688 case DRAW_TEXT_ON_PATH: { 689 const SkPaint& paint = *getPaint(); 690 getText(&text); 691 const SkPath& path = getPath(); 692 const SkMatrix* matrix = getMatrix(); 693 canvas.drawTextOnPath(text.text(), text.length(), path, 694 matrix, paint); 695 } break; 696 case DRAW_VERTICES: { 697 const SkPaint& paint = *getPaint(); 698 DrawVertexFlags flags = (DrawVertexFlags)getInt(); 699 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)getInt(); 700 int vCount = getInt(); 701 const SkPoint* verts = (const SkPoint*)fReader.skip( 702 vCount * sizeof(SkPoint)); 703 const SkPoint* texs = NULL; 704 const SkColor* colors = NULL; 705 const uint16_t* indices = NULL; 706 int iCount = 0; 707 if (flags & DRAW_VERTICES_HAS_TEXS) { 708 texs = (const SkPoint*)fReader.skip( 709 vCount * sizeof(SkPoint)); 710 } 711 if (flags & DRAW_VERTICES_HAS_COLORS) { 712 colors = (const SkColor*)fReader.skip( 713 vCount * sizeof(SkColor)); 714 } 715 if (flags & DRAW_VERTICES_HAS_INDICES) { 716 iCount = getInt(); 717 indices = (const uint16_t*)fReader.skip( 718 iCount * sizeof(uint16_t)); 719 } 720 canvas.drawVertices(vmode, vCount, verts, texs, colors, NULL, 721 indices, iCount, paint); 722 } break; 723 case RESTORE: 724 canvas.restore(); 725 break; 726 case ROTATE: 727 canvas.rotate(getScalar()); 728 break; 729 case SAVE: 730 canvas.save((SkCanvas::SaveFlags) getInt()); 731 break; 732 case SAVE_LAYER: { 733 const SkRect* boundsPtr = getRectPtr(); 734 const SkPaint* paint = getPaint(); 735 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) getInt()); 736 } break; 737 case SCALE: { 738 SkScalar sx = getScalar(); 739 SkScalar sy = getScalar(); 740 canvas.scale(sx, sy); 741 } break; 742 case SET_MATRIX: 743 canvas.setMatrix(*getMatrix()); 744 break; 745 case SKEW: { 746 SkScalar sx = getScalar(); 747 SkScalar sy = getScalar(); 748 canvas.skew(sx, sy); 749 } break; 750 case TRANSLATE: { 751 SkScalar dx = getScalar(); 752 SkScalar dy = getScalar(); 753 canvas.translate(dx, dy); 754 } break; 755 default: 756 SkASSERT(0); 757 } 758 } 759 760 #ifdef SPEW_CLIP_SKIPPING 761 { 762 size_t size = skipRect.fSize + skipPath.fSize + skipRegion.fSize; 763 SkDebugf("--- Clip skips %d%% rect:%d path:%d rgn:%d\n", 764 size * 100 / fReader.offset(), skipRect.fCount, skipPath.fCount, 765 skipRegion.fCount); 766 } 767 #endif 768 // this->dumpSize(); 769 } 770 771 void SkPicturePlayback::abort() { 772 fReader.skip(fReader.size() - fReader.offset()); 773 } 774 775 /////////////////////////////////////////////////////////////////////////////// 776 777 #if 0 778 uint32_t SkPicturePlayback::flatten(void* storage) const { 779 SkWBuffer buffer(storage); 780 buffer.write32(fBitmapCount); 781 int index; 782 for (index = 0; index < fBitmapCount; index++) { 783 const SkBitmap& bitmap = fBitmaps[index]; 784 uint32_t size = bitmap.flatten(NULL, true); 785 buffer.write32(size); 786 void* local = buffer.skip(size); 787 bitmap.flatten(local, true); 788 } 789 buffer.write32(fPaintCount); 790 for (index = 0; index < fPaintCount; index++) { 791 SkFlattenableWriteBuffer flatWrite; 792 const SkPaint& paint = fPaints[index]; 793 SkFlatPaint::Write(&flatWrite, paint); 794 uint32_t size = flatWrite.pos(); 795 buffer.write32(size); 796 void* local = buffer.skip(size); 797 flatWrite.reset(local); 798 SkFlatPaint::Write(&flatWrite, paint); 799 } 800 buffer.write32(fPathCount); 801 for (index = 0; index < fPathCount; index++) { 802 const SkPath& path = fPaths[index]; 803 uint32_t size = path.flatten(NULL); 804 buffer.write32(size); 805 void* local = buffer.skip(size); 806 path.flatten(local); 807 } 808 809 #if 0 810 buffer.write32(fPictureCount); 811 for (index = 0; index < fPictureCount; index++) { 812 const SkPicture& picture = fPictures[index]; 813 uint32_t size = picture.flatten(NULL); 814 buffer.write32(size); 815 void* local = buffer.skip(size); 816 picture.flatten(local); 817 } 818 #endif 819 820 buffer.write32(fRegionCount); 821 for (index = 0; index < fRegionCount; index++) { 822 const SkRegion& region = fRegions[index]; 823 size_t size = region.computeBufferSize(); 824 buffer.write32(size); 825 void* local = buffer.skip(size); 826 region.writeToBuffer(local); 827 } 828 fReader.rewind(); 829 size_t length = fReader.size(); 830 buffer.write32(length); 831 memcpy(buffer.skip(length), fReader.base(), length); 832 return (uint32_t) buffer.pos(); 833 } 834 835 void SkPicturePlayback::unflatten(const void* storage) { 836 SkRBuffer buffer(storage); 837 int index; 838 fBitmapCount = buffer.readU32(); 839 fBitmaps = new SkBitmap[fBitmapCount]; 840 for (index = 0; index < fBitmapCount; index++) { 841 uint32_t size = buffer.readU32(); 842 const void* local = buffer.skip(size); 843 fBitmaps[index].unflatten(local); 844 } 845 fPaintCount = buffer.readU32(); 846 fPaints = new SkPaint[fPaintCount]; 847 for (index = 0; index < fPaintCount; index++) { 848 uint32_t size = buffer.readU32(); 849 const void* local = buffer.skip(size); 850 SkFlatPaint::Read(local, &fPaints[index]); 851 } 852 fPathCount = buffer.readU32(); 853 fPaths = new SkPath[fPathCount]; 854 for (index = 0; index < fPathCount; index++) { 855 uint32_t size = buffer.readU32(); 856 const void* local = buffer.skip(size); 857 fPaths[index].unflatten(local); 858 } 859 860 #if 0 861 fPictureCount = buffer.readU32(); 862 fPictures = new SkPicture[fPictureCount]; 863 for (index = 0; index < fPictureCount; index++) { 864 uint32_t size = buffer.readU32(); 865 const void* local = buffer.skip(size); 866 fPictures[index].unflatten(local); 867 } 868 #endif 869 870 fRegionCount = buffer.readU32(); 871 fRegions = new SkRegion[fRegionCount]; 872 for (index = 0; index < fRegionCount; index++) { 873 uint32_t size = buffer.readU32(); 874 const void* local = buffer.skip(size); 875 fRegions[index].readFromBuffer(local); 876 } 877 int32_t length = buffer.readS32(); 878 const void* stream = buffer.skip(length); 879 fReader.setMemory(stream, length); 880 } 881 #endif 882 883 /////////////////////////////////////////////////////////////////////////////// 884 885 #ifdef SK_DEBUG_SIZE 886 int SkPicturePlayback::size(size_t* sizePtr) { 887 int objects = bitmaps(sizePtr); 888 objects += paints(sizePtr); 889 objects += paths(sizePtr); 890 objects += pictures(sizePtr); 891 objects += regions(sizePtr); 892 *sizePtr = fReader.size(); 893 return objects; 894 } 895 896 int SkPicturePlayback::bitmaps(size_t* size) { 897 size_t result = 0; 898 for (int index = 0; index < fBitmapCount; index++) { 899 // const SkBitmap& bitmap = fBitmaps[index]; 900 result += sizeof(SkBitmap); // bitmap->size(); 901 } 902 *size = result; 903 return fBitmapCount; 904 } 905 906 int SkPicturePlayback::paints(size_t* size) { 907 size_t result = 0; 908 for (int index = 0; index < fPaintCount; index++) { 909 // const SkPaint& paint = fPaints[index]; 910 result += sizeof(SkPaint); // paint->size(); 911 } 912 *size = result; 913 return fPaintCount; 914 } 915 916 int SkPicturePlayback::paths(size_t* size) { 917 size_t result = 0; 918 for (int index = 0; index < fPathCount; index++) { 919 const SkPath& path = fPaths[index]; 920 result += path.flatten(NULL); 921 } 922 *size = result; 923 return fPathCount; 924 } 925 926 int SkPicturePlayback::regions(size_t* size) { 927 size_t result = 0; 928 for (int index = 0; index < fRegionCount; index++) { 929 // const SkRegion& region = fRegions[index]; 930 result += sizeof(SkRegion); // region->size(); 931 } 932 *size = result; 933 return fRegionCount; 934 } 935 #endif 936 937 #ifdef SK_DEBUG_DUMP 938 void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const { 939 char pBuffer[DUMP_BUFFER_SIZE]; 940 char* bufferPtr = pBuffer; 941 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 942 "BitmapData bitmap%p = {", &bitmap); 943 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 944 "{kWidth, %d}, ", bitmap.width()); 945 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 946 "{kHeight, %d}, ", bitmap.height()); 947 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 948 "{kRowBytes, %d}, ", bitmap.rowBytes()); 949 // start here; 950 SkDebugf("%s{0}};\n", pBuffer); 951 } 952 953 void dumpMatrix(const SkMatrix& matrix) const { 954 SkMatrix defaultMatrix; 955 defaultMatrix.reset(); 956 char pBuffer[DUMP_BUFFER_SIZE]; 957 char* bufferPtr = pBuffer; 958 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 959 "MatrixData matrix%p = {", &matrix); 960 SkScalar scaleX = matrix.getScaleX(); 961 if (scaleX != defaultMatrix.getScaleX()) 962 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 963 "{kScaleX, %g}, ", SkScalarToFloat(scaleX)); 964 SkScalar scaleY = matrix.getScaleY(); 965 if (scaleY != defaultMatrix.getScaleY()) 966 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 967 "{kScaleY, %g}, ", SkScalarToFloat(scaleY)); 968 SkScalar skewX = matrix.getSkewX(); 969 if (skewX != defaultMatrix.getSkewX()) 970 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 971 "{kSkewX, %g}, ", SkScalarToFloat(skewX)); 972 SkScalar skewY = matrix.getSkewY(); 973 if (skewY != defaultMatrix.getSkewY()) 974 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 975 "{kSkewY, %g}, ", SkScalarToFloat(skewY)); 976 SkScalar translateX = matrix.getTranslateX(); 977 if (translateX != defaultMatrix.getTranslateX()) 978 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 979 "{kTranslateX, %g}, ", SkScalarToFloat(translateX)); 980 SkScalar translateY = matrix.getTranslateY(); 981 if (translateY != defaultMatrix.getTranslateY()) 982 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 983 "{kTranslateY, %g}, ", SkScalarToFloat(translateY)); 984 SkScalar perspX = matrix.getPerspX(); 985 if (perspX != defaultMatrix.getPerspX()) 986 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 987 "{kPerspX, %g}, ", SkFractToFloat(perspX)); 988 SkScalar perspY = matrix.getPerspY(); 989 if (perspY != defaultMatrix.getPerspY()) 990 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 991 "{kPerspY, %g}, ", SkFractToFloat(perspY)); 992 SkDebugf("%s{0}};\n", pBuffer); 993 } 994 995 void dumpPaint(const SkPaint& paint) const { 996 SkPaint defaultPaint; 997 char pBuffer[DUMP_BUFFER_SIZE]; 998 char* bufferPtr = pBuffer; 999 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1000 "PaintPointers paintPtrs%p = {", &paint); 1001 const SkTypeface* typeface = paint.getTypeface(); 1002 if (typeface != defaultPaint.getTypeface()) 1003 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1004 "{kTypeface, %p}, ", typeface); 1005 const SkPathEffect* pathEffect = paint.getPathEffect(); 1006 if (pathEffect != defaultPaint.getPathEffect()) 1007 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1008 "{kPathEffect, %p}, ", pathEffect); 1009 const SkShader* shader = paint.getShader(); 1010 if (shader != defaultPaint.getShader()) 1011 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1012 "{kShader, %p}, ", shader); 1013 const SkXfermode* xfermode = paint.getXfermode(); 1014 if (xfermode != defaultPaint.getXfermode()) 1015 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1016 "{kXfermode, %p}, ", xfermode); 1017 const SkMaskFilter* maskFilter = paint.getMaskFilter(); 1018 if (maskFilter != defaultPaint.getMaskFilter()) 1019 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1020 "{kMaskFilter, %p}, ", maskFilter); 1021 const SkColorFilter* colorFilter = paint.getColorFilter(); 1022 if (colorFilter != defaultPaint.getColorFilter()) 1023 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1024 "{kColorFilter, %p}, ", colorFilter); 1025 const SkRasterizer* rasterizer = paint.getRasterizer(); 1026 if (rasterizer != defaultPaint.getRasterizer()) 1027 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1028 "{kRasterizer, %p}, ", rasterizer); 1029 const SkDrawLooper* drawLooper = paint.getLooper(); 1030 if (drawLooper != defaultPaint.getLooper()) 1031 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1032 "{kDrawLooper, %p}, ", drawLooper); 1033 SkDebugf("%s{0}};\n", pBuffer); 1034 bufferPtr = pBuffer; 1035 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1036 "PaintScalars paintScalars%p = {", &paint); 1037 SkScalar textSize = paint.getTextSize(); 1038 if (textSize != defaultPaint.getTextSize()) 1039 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1040 "{kTextSize, %g}, ", SkScalarToFloat(textSize)); 1041 SkScalar textScaleX = paint.getTextScaleX(); 1042 if (textScaleX != defaultPaint.getTextScaleX()) 1043 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1044 "{kTextScaleX, %g}, ", SkScalarToFloat(textScaleX)); 1045 SkScalar textSkewX = paint.getTextSkewX(); 1046 if (textSkewX != defaultPaint.getTextSkewX()) 1047 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1048 "{kTextSkewX, %g}, ", SkScalarToFloat(textSkewX)); 1049 SkScalar strokeWidth = paint.getStrokeWidth(); 1050 if (strokeWidth != defaultPaint.getStrokeWidth()) 1051 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1052 "{kStrokeWidth, %g}, ", SkScalarToFloat(strokeWidth)); 1053 SkScalar strokeMiter = paint.getStrokeMiter(); 1054 if (strokeMiter != defaultPaint.getStrokeMiter()) 1055 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1056 "{kStrokeMiter, %g}, ", SkScalarToFloat(strokeMiter)); 1057 SkDebugf("%s{0}};\n", pBuffer); 1058 bufferPtr = pBuffer; 1059 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1060 "PaintInts = paintInts%p = {", &paint); 1061 unsigned color = paint.getColor(); 1062 if (color != defaultPaint.getColor()) 1063 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1064 "{kColor, 0x%x}, ", color); 1065 unsigned flags = paint.getFlags(); 1066 if (flags != defaultPaint.getFlags()) 1067 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1068 "{kFlags, 0x%x}, ", flags); 1069 int align = paint.getTextAlign(); 1070 if (align != defaultPaint.getTextAlign()) 1071 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1072 "{kAlign, 0x%x}, ", align); 1073 int strokeCap = paint.getStrokeCap(); 1074 if (strokeCap != defaultPaint.getStrokeCap()) 1075 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1076 "{kStrokeCap, 0x%x}, ", strokeCap); 1077 int strokeJoin = paint.getStrokeJoin(); 1078 if (strokeJoin != defaultPaint.getStrokeJoin()) 1079 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1080 "{kAlign, 0x%x}, ", strokeJoin); 1081 int style = paint.getStyle(); 1082 if (style != defaultPaint.getStyle()) 1083 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1084 "{kStyle, 0x%x}, ", style); 1085 int textEncoding = paint.getTextEncoding(); 1086 if (textEncoding != defaultPaint.getTextEncoding()) 1087 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1088 "{kTextEncoding, 0x%x}, ", textEncoding); 1089 SkDebugf("%s{0}};\n", pBuffer); 1090 1091 SkDebugf("PaintData paint%p = {paintPtrs%p, paintScalars%p, paintInts%p};\n", 1092 &paint, &paint, &paint, &paint); 1093 } 1094 1095 void SkPicturePlayback::dumpPath(const SkPath& path) const { 1096 SkDebugf("path dump unimplemented\n"); 1097 } 1098 1099 void SkPicturePlayback::dumpPicture(const SkPicture& picture) const { 1100 SkDebugf("picture dump unimplemented\n"); 1101 } 1102 1103 void SkPicturePlayback::dumpRegion(const SkRegion& region) const { 1104 SkDebugf("region dump unimplemented\n"); 1105 } 1106 1107 int SkPicturePlayback::dumpDrawType(char* bufferPtr, char* buffer, DrawType drawType) { 1108 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1109 "k%s, ", DrawTypeToString(drawType)); 1110 } 1111 1112 int SkPicturePlayback::dumpInt(char* bufferPtr, char* buffer, char* name) { 1113 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1114 "%s:%d, ", name, getInt()); 1115 } 1116 1117 int SkPicturePlayback::dumpRect(char* bufferPtr, char* buffer, char* name) { 1118 const SkRect* rect = fReader.skipRect(); 1119 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1120 "%s:{l:%g t:%g r:%g b:%g}, ", name, SkScalarToFloat(rect.fLeft), 1121 SkScalarToFloat(rect.fTop), 1122 SkScalarToFloat(rect.fRight), SkScalarToFloat(rect.fBottom)); 1123 } 1124 1125 int SkPicturePlayback::dumpPoint(char* bufferPtr, char* buffer, char* name) { 1126 SkPoint pt; 1127 getPoint(&pt); 1128 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1129 "%s:{x:%g y:%g}, ", name, SkScalarToFloat(pt.fX), 1130 SkScalarToFloat(pt.fY)); 1131 } 1132 1133 void SkPicturePlayback::dumpPointArray(char** bufferPtrPtr, char* buffer, int count) { 1134 char* bufferPtr = *bufferPtrPtr; 1135 const SkPoint* pts = (const SkPoint*)fReadStream.getAtPos(); 1136 fReadStream.skip(sizeof(SkPoint) * count); 1137 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1138 "count:%d {", count); 1139 for (int index = 0; index < count; index++) 1140 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1141 "{x:%g y:%g}, ", SkScalarToFloat(pts[index].fX), 1142 SkScalarToFloat(pts[index].fY)); 1143 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1144 "} "); 1145 *bufferPtrPtr = bufferPtr; 1146 } 1147 1148 int SkPicturePlayback::dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr) { 1149 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1150 "%s:%p, ", name, ptr); 1151 } 1152 1153 int SkPicturePlayback::dumpRectPtr(char* bufferPtr, char* buffer, char* name) { 1154 char result; 1155 fReadStream.read(&result, sizeof(result)); 1156 if (result) 1157 return dumpRect(bufferPtr, buffer, name); 1158 else 1159 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1160 "%s:NULL, ", name); 1161 } 1162 1163 int SkPicturePlayback::dumpScalar(char* bufferPtr, char* buffer, char* name) { 1164 return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer), 1165 "%s:%d, ", name, getScalar()); 1166 } 1167 1168 void SkPicturePlayback::dumpText(char** bufferPtrPtr, char* buffer) { 1169 char* bufferPtr = *bufferPtrPtr; 1170 int length = getInt(); 1171 bufferPtr += dumpDrawType(bufferPtr, buffer); 1172 fReadStream.skipToAlign4(); 1173 char* text = (char*) fReadStream.getAtPos(); 1174 fReadStream.skip(length); 1175 bufferPtr += dumpInt(bufferPtr, buffer, "length"); 1176 int limit = DUMP_BUFFER_SIZE - (bufferPtr - buffer) - 2; 1177 length >>= 1; 1178 if (limit > length) 1179 limit = length; 1180 if (limit > 0) { 1181 *bufferPtr++ = '"'; 1182 for (int index = 0; index < limit; index++) { 1183 *bufferPtr++ = *(unsigned short*) text; 1184 text += sizeof(unsigned short); 1185 } 1186 *bufferPtr++ = '"'; 1187 } 1188 *bufferPtrPtr = bufferPtr; 1189 } 1190 1191 #define DUMP_DRAWTYPE(drawType) \ 1192 bufferPtr += dumpDrawType(bufferPtr, buffer, drawType) 1193 1194 #define DUMP_INT(name) \ 1195 bufferPtr += dumpInt(bufferPtr, buffer, #name) 1196 1197 #define DUMP_RECT_PTR(name) \ 1198 bufferPtr += dumpRectPtr(bufferPtr, buffer, #name) 1199 1200 #define DUMP_POINT(name) \ 1201 bufferPtr += dumpRect(bufferPtr, buffer, #name) 1202 1203 #define DUMP_RECT(name) \ 1204 bufferPtr += dumpRect(bufferPtr, buffer, #name) 1205 1206 #define DUMP_POINT_ARRAY(count) \ 1207 dumpPointArray(&bufferPtr, buffer, count) 1208 1209 #define DUMP_PTR(name, ptr) \ 1210 bufferPtr += dumpPtr(bufferPtr, buffer, #name, (void*) ptr) 1211 1212 #define DUMP_SCALAR(name) \ 1213 bufferPtr += dumpScalar(bufferPtr, buffer, #name) 1214 1215 #define DUMP_TEXT() \ 1216 dumpText(&bufferPtr, buffer) 1217 1218 void SkPicturePlayback::dumpStream() { 1219 SkDebugf("RecordStream stream = {\n"); 1220 DrawType drawType; 1221 TextContainer text; 1222 fReadStream.rewind(); 1223 char buffer[DUMP_BUFFER_SIZE], * bufferPtr; 1224 while (fReadStream.read(&drawType, sizeof(drawType))) { 1225 bufferPtr = buffer; 1226 DUMP_DRAWTYPE(drawType); 1227 switch (drawType) { 1228 case CLIP_PATH: { 1229 DUMP_PTR(SkPath, &getPath()); 1230 DUMP_INT(SkRegion::Op); 1231 DUMP_INT(offsetToRestore); 1232 } break; 1233 case CLIP_REGION: { 1234 DUMP_PTR(SkRegion, &getRegion()); 1235 DUMP_INT(SkRegion::Op); 1236 DUMP_INT(offsetToRestore); 1237 } break; 1238 case CLIP_RECT: { 1239 DUMP_RECT(rect); 1240 DUMP_INT(SkRegion::Op); 1241 DUMP_INT(offsetToRestore); 1242 } break; 1243 case CONCAT: 1244 DUMP_PTR(SkMatrix, getMatrix()); 1245 break; 1246 case DRAW_BITMAP: { 1247 DUMP_PTR(SkPaint, getPaint()); 1248 DUMP_PTR(SkBitmap, &getBitmap()); 1249 DUMP_SCALAR(left); 1250 DUMP_SCALAR(top); 1251 } break; 1252 case DRAW_PAINT: 1253 DUMP_PTR(SkPaint, getPaint()); 1254 break; 1255 case DRAW_PATH: { 1256 DUMP_PTR(SkPaint, getPaint()); 1257 DUMP_PTR(SkPath, &getPath()); 1258 } break; 1259 case DRAW_PICTURE: { 1260 DUMP_PTR(SkPicture, &getPicture()); 1261 } break; 1262 case DRAW_POINTS: { 1263 DUMP_PTR(SkPaint, getPaint()); 1264 (void)getInt(); // PointMode 1265 size_t count = getInt(); 1266 fReadStream.skipToAlign4(); 1267 DUMP_POINT_ARRAY(count); 1268 } break; 1269 case DRAW_POS_TEXT: { 1270 DUMP_PTR(SkPaint, getPaint()); 1271 DUMP_TEXT(); 1272 size_t points = getInt(); 1273 fReadStream.skipToAlign4(); 1274 DUMP_POINT_ARRAY(points); 1275 } break; 1276 case DRAW_POS_TEXT_H: { 1277 DUMP_PTR(SkPaint, getPaint()); 1278 DUMP_TEXT(); 1279 size_t points = getInt(); 1280 fReadStream.skipToAlign4(); 1281 DUMP_SCALAR(top); 1282 DUMP_SCALAR(bottom); 1283 DUMP_SCALAR(constY); 1284 DUMP_POINT_ARRAY(points); 1285 } break; 1286 case DRAW_RECT: { 1287 DUMP_PTR(SkPaint, getPaint()); 1288 DUMP_RECT(rect); 1289 } break; 1290 case DRAW_SPRITE: { 1291 DUMP_PTR(SkPaint, getPaint()); 1292 DUMP_PTR(SkBitmap, &getBitmap()); 1293 DUMP_SCALAR(left); 1294 DUMP_SCALAR(top); 1295 } break; 1296 case DRAW_TEXT: { 1297 DUMP_PTR(SkPaint, getPaint()); 1298 DUMP_TEXT(); 1299 DUMP_SCALAR(x); 1300 DUMP_SCALAR(y); 1301 } break; 1302 case DRAW_TEXT_ON_PATH: { 1303 DUMP_PTR(SkPaint, getPaint()); 1304 DUMP_TEXT(); 1305 DUMP_PTR(SkPath, &getPath()); 1306 DUMP_PTR(SkMatrix, getMatrix()); 1307 } break; 1308 case RESTORE: 1309 break; 1310 case ROTATE: 1311 DUMP_SCALAR(rotate); 1312 break; 1313 case SAVE: 1314 DUMP_INT(SkCanvas::SaveFlags); 1315 break; 1316 case SAVE_LAYER: { 1317 DUMP_RECT_PTR(layer); 1318 DUMP_PTR(SkPaint, getPaint()); 1319 DUMP_INT(SkCanvas::SaveFlags); 1320 } break; 1321 case SCALE: { 1322 DUMP_SCALAR(sx); 1323 DUMP_SCALAR(sy); 1324 } break; 1325 case SKEW: { 1326 DUMP_SCALAR(sx); 1327 DUMP_SCALAR(sy); 1328 } break; 1329 case TRANSLATE: { 1330 DUMP_SCALAR(dx); 1331 DUMP_SCALAR(dy); 1332 } break; 1333 default: 1334 SkASSERT(0); 1335 } 1336 SkDebugf("%s\n", buffer); 1337 } 1338 } 1339 1340 void SkPicturePlayback::dump() const { 1341 char pBuffer[DUMP_BUFFER_SIZE]; 1342 char* bufferPtr = pBuffer; 1343 int index; 1344 if (fBitmapCount > 0) 1345 SkDebugf("// bitmaps (%d)\n", fBitmapCount); 1346 for (index = 0; index < fBitmapCount; index++) { 1347 const SkBitmap& bitmap = fBitmaps[index]; 1348 dumpBitmap(bitmap); 1349 } 1350 if (fBitmapCount > 0) 1351 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1352 "Bitmaps bitmaps = {"); 1353 for (index = 0; index < fBitmapCount; index++) 1354 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1355 "bitmap%p, ", &fBitmaps[index]); 1356 if (fBitmapCount > 0) 1357 SkDebugf("%s0};\n", pBuffer); 1358 1359 if (fMatrixCount > 0) 1360 SkDebugf("// matrices (%d)\n", fMatrixCount); 1361 for (index = 0; index < fMatrixCount; index++) { 1362 const SkMatrix& matrix = fMatrices[index]; 1363 dumpMatrix(matrix); 1364 } 1365 bufferPtr = pBuffer; 1366 if (fMatrixCount > 0) 1367 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1368 "Matrices matrices = {"); 1369 for (index = 0; index < fMatrixCount; index++) 1370 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1371 "matrix%p, ", &fMatrices[index]); 1372 if (fMatrixCount > 0) 1373 SkDebugf("%s0};\n", pBuffer); 1374 1375 if (fPaintCount > 0) 1376 SkDebugf("// paints (%d)\n", fPaintCount); 1377 for (index = 0; index < fPaintCount; index++) { 1378 const SkPaint& paint = fPaints[index]; 1379 dumpPaint(paint); 1380 } 1381 bufferPtr = pBuffer; 1382 if (fPaintCount > 0) 1383 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1384 "Paints paints = {"); 1385 for (index = 0; index < fPaintCount; index++) 1386 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1387 "paint%p, ", &fPaints[index]); 1388 if (fPaintCount > 0) 1389 SkDebugf("%s0};\n", pBuffer); 1390 1391 for (index = 0; index < fPathCount; index++) { 1392 const SkPath& path = fPaths[index]; 1393 dumpPath(path); 1394 } 1395 bufferPtr = pBuffer; 1396 if (fPathCount > 0) 1397 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1398 "Paths paths = {"); 1399 for (index = 0; index < fPathCount; index++) 1400 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1401 "path%p, ", &fPaths[index]); 1402 if (fPathCount > 0) 1403 SkDebugf("%s0};\n", pBuffer); 1404 1405 for (index = 0; index < fPictureCount; index++) { 1406 dumpPicture(*fPictureRefs[index]); 1407 } 1408 bufferPtr = pBuffer; 1409 if (fPictureCount > 0) 1410 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1411 "Pictures pictures = {"); 1412 for (index = 0; index < fPictureCount; index++) 1413 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1414 "picture%p, ", fPictureRefs[index]); 1415 if (fPictureCount > 0) 1416 SkDebugf("%s0};\n", pBuffer); 1417 1418 for (index = 0; index < fRegionCount; index++) { 1419 const SkRegion& region = fRegions[index]; 1420 dumpRegion(region); 1421 } 1422 bufferPtr = pBuffer; 1423 if (fRegionCount > 0) 1424 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1425 "Regions regions = {"); 1426 for (index = 0; index < fRegionCount; index++) 1427 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), 1428 "region%p, ", &fRegions[index]); 1429 if (fRegionCount > 0) 1430 SkDebugf("%s0};\n", pBuffer); 1431 1432 const_cast<SkPicturePlayback*>(this)->dumpStream(); 1433 } 1434 1435 #endif 1436
