OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2011 Google Inc. | 3 * Copyright 2011 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 #include "SkPicturePlayback.h" | 8 #include "SkPicturePlayback.h" |
9 #include "SkPictureRecord.h" | 9 #include "SkPictureRecord.h" |
10 #include "SkTypeface.h" | 10 #include "SkTypeface.h" |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
89 void* buffer = sk_malloc_throw(size); | 89 void* buffer = sk_malloc_throw(size); |
90 writer.flatten(buffer); | 90 writer.flatten(buffer); |
91 SkASSERT(!fOpData); | 91 SkASSERT(!fOpData); |
92 fOpData = SkData::NewFromMalloc(buffer, size); | 92 fOpData = SkData::NewFromMalloc(buffer, size); |
93 } | 93 } |
94 | 94 |
95 // copy over the refcnt dictionary to our reader | 95 // copy over the refcnt dictionary to our reader |
96 record.fFlattenableHeap.setupPlaybacks(); | 96 record.fFlattenableHeap.setupPlaybacks(); |
97 | 97 |
98 fBitmaps = record.fBitmapHeap->extractBitmaps(); | 98 fBitmaps = record.fBitmapHeap->extractBitmaps(); |
99 fMatrices = record.fMatrices.unflattenToArray(); | |
100 fPaints = record.fPaints.unflattenToArray(); | 99 fPaints = record.fPaints.unflattenToArray(); |
101 fRegions = record.fRegions.unflattenToArray(); | |
102 | 100 |
103 fBitmapHeap.reset(SkSafeRef(record.fBitmapHeap)); | 101 fBitmapHeap.reset(SkSafeRef(record.fBitmapHeap)); |
104 fPathHeap.reset(SkSafeRef(record.fPathHeap)); | 102 fPathHeap.reset(SkSafeRef(record.fPathHeap)); |
105 | 103 |
106 // ensure that the paths bounds are pre-computed | 104 // ensure that the paths bounds are pre-computed |
107 if (fPathHeap.get()) { | 105 if (fPathHeap.get()) { |
108 for (int i = 0; i < fPathHeap->count(); i++) { | 106 for (int i = 0; i < fPathHeap->count(); i++) { |
109 (*fPathHeap)[i].updateBoundsCache(); | 107 (*fPathHeap)[i].updateBoundsCache(); |
110 } | 108 } |
111 } | 109 } |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
163 paint.getLooper() || | 161 paint.getLooper() || |
164 paint.getImageFilter(); | 162 paint.getImageFilter(); |
165 } | 163 } |
166 | 164 |
167 SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInf
o* deepCopyInfo) { | 165 SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInf
o* deepCopyInfo) { |
168 this->init(); | 166 this->init(); |
169 | 167 |
170 fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get())); | 168 fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get())); |
171 fPathHeap.reset(SkSafeRef(src.fPathHeap.get())); | 169 fPathHeap.reset(SkSafeRef(src.fPathHeap.get())); |
172 | 170 |
173 fMatrices = SkSafeRef(src.fMatrices); | |
174 fRegions = SkSafeRef(src.fRegions); | |
175 fOpData = SkSafeRef(src.fOpData); | 171 fOpData = SkSafeRef(src.fOpData); |
176 | 172 |
177 fBoundingHierarchy = src.fBoundingHierarchy; | 173 fBoundingHierarchy = src.fBoundingHierarchy; |
178 fStateTree = src.fStateTree; | 174 fStateTree = src.fStateTree; |
179 | 175 |
180 SkSafeRef(fBoundingHierarchy); | 176 SkSafeRef(fBoundingHierarchy); |
181 SkSafeRef(fStateTree); | 177 SkSafeRef(fStateTree); |
182 | 178 |
183 if (deepCopyInfo) { | 179 if (deepCopyInfo) { |
184 int paintCount = SafeCount(src.fPaints); | 180 int paintCount = SafeCount(src.fPaints); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
254 fPictureRefs[i] = src.fPictureRefs[i]->clone(); | 250 fPictureRefs[i] = src.fPictureRefs[i]->clone(); |
255 } else { | 251 } else { |
256 fPictureRefs[i] = src.fPictureRefs[i]; | 252 fPictureRefs[i] = src.fPictureRefs[i]; |
257 fPictureRefs[i]->ref(); | 253 fPictureRefs[i]->ref(); |
258 } | 254 } |
259 } | 255 } |
260 } | 256 } |
261 | 257 |
262 void SkPicturePlayback::init() { | 258 void SkPicturePlayback::init() { |
263 fBitmaps = NULL; | 259 fBitmaps = NULL; |
264 fMatrices = NULL; | |
265 fPaints = NULL; | 260 fPaints = NULL; |
266 fPictureRefs = NULL; | 261 fPictureRefs = NULL; |
267 fRegions = NULL; | |
268 fPictureCount = 0; | 262 fPictureCount = 0; |
269 fOpData = NULL; | 263 fOpData = NULL; |
270 fFactoryPlayback = NULL; | 264 fFactoryPlayback = NULL; |
271 fBoundingHierarchy = NULL; | 265 fBoundingHierarchy = NULL; |
272 fStateTree = NULL; | 266 fStateTree = NULL; |
273 } | 267 } |
274 | 268 |
275 SkPicturePlayback::~SkPicturePlayback() { | 269 SkPicturePlayback::~SkPicturePlayback() { |
276 fOpData->unref(); | 270 fOpData->unref(); |
277 | 271 |
278 SkSafeUnref(fBitmaps); | 272 SkSafeUnref(fBitmaps); |
279 SkSafeUnref(fMatrices); | |
280 SkSafeUnref(fPaints); | 273 SkSafeUnref(fPaints); |
281 SkSafeUnref(fRegions); | |
282 SkSafeUnref(fBoundingHierarchy); | 274 SkSafeUnref(fBoundingHierarchy); |
283 SkSafeUnref(fStateTree); | 275 SkSafeUnref(fStateTree); |
284 | 276 |
285 for (int i = 0; i < fPictureCount; i++) { | 277 for (int i = 0; i < fPictureCount; i++) { |
286 fPictureRefs[i]->unref(); | 278 fPictureRefs[i]->unref(); |
287 } | 279 } |
288 SkDELETE_ARRAY(fPictureRefs); | 280 SkDELETE_ARRAY(fPictureRefs); |
289 | 281 |
290 SkDELETE(fFactoryPlayback); | 282 SkDELETE(fFactoryPlayback); |
291 } | 283 } |
292 | 284 |
293 void SkPicturePlayback::dumpSize() const { | 285 void SkPicturePlayback::dumpSize() const { |
294 SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] matrices=%d [%d] paints=%
d [%d] paths=%d regions=%d\n", | 286 SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] paints=%d [%d] paths=%d\n
", |
295 fOpData->size(), | 287 fOpData->size(), |
296 SafeCount(fBitmaps), SafeCount(fBitmaps) * sizeof(SkBitmap), | 288 SafeCount(fBitmaps), SafeCount(fBitmaps) * sizeof(SkBitmap), |
297 SafeCount(fMatrices), SafeCount(fMatrices) * sizeof(SkMatrix), | |
298 SafeCount(fPaints), SafeCount(fPaints) * sizeof(SkPaint), | 289 SafeCount(fPaints), SafeCount(fPaints) * sizeof(SkPaint), |
299 SafeCount(fPathHeap.get()), | 290 SafeCount(fPathHeap.get())); |
300 SafeCount(fRegions)); | |
301 } | 291 } |
302 | 292 |
303 bool SkPicturePlayback::containsBitmaps() const { | 293 bool SkPicturePlayback::containsBitmaps() const { |
304 if (fBitmaps && fBitmaps->count() > 0) { | 294 if (fBitmaps && fBitmaps->count() > 0) { |
305 return true; | 295 return true; |
306 } | 296 } |
307 for (int i = 0; i < fPictureCount; ++i) { | 297 for (int i = 0; i < fPictureCount; ++i) { |
308 if (fPictureRefs[i]->willPlayBackBitmaps()) { | 298 if (fPictureRefs[i]->willPlayBackBitmaps()) { |
309 return true; | 299 return true; |
310 } | 300 } |
311 } | 301 } |
312 return false; | 302 return false; |
313 } | 303 } |
314 | 304 |
315 /////////////////////////////////////////////////////////////////////////////// | 305 /////////////////////////////////////////////////////////////////////////////// |
316 /////////////////////////////////////////////////////////////////////////////// | 306 /////////////////////////////////////////////////////////////////////////////// |
317 | 307 |
318 #define PICT_READER_TAG SkSetFourByteTag('r', 'e', 'a', 'd') | 308 #define PICT_READER_TAG SkSetFourByteTag('r', 'e', 'a', 'd') |
319 #define PICT_FACTORY_TAG SkSetFourByteTag('f', 'a', 'c', 't') | 309 #define PICT_FACTORY_TAG SkSetFourByteTag('f', 'a', 'c', 't') |
320 #define PICT_TYPEFACE_TAG SkSetFourByteTag('t', 'p', 'f', 'c') | 310 #define PICT_TYPEFACE_TAG SkSetFourByteTag('t', 'p', 'f', 'c') |
321 #define PICT_PICTURE_TAG SkSetFourByteTag('p', 'c', 't', 'r') | 311 #define PICT_PICTURE_TAG SkSetFourByteTag('p', 'c', 't', 'r') |
322 | 312 |
323 // This tag specifies the size of the ReadBuffer, needed for the following tags | 313 // This tag specifies the size of the ReadBuffer, needed for the following tags |
324 #define PICT_BUFFER_SIZE_TAG SkSetFourByteTag('a', 'r', 'a', 'y') | 314 #define PICT_BUFFER_SIZE_TAG SkSetFourByteTag('a', 'r', 'a', 'y') |
325 // these are all inside the ARRAYS tag | 315 // these are all inside the ARRAYS tag |
326 #define PICT_BITMAP_BUFFER_TAG SkSetFourByteTag('b', 't', 'm', 'p') | 316 #define PICT_BITMAP_BUFFER_TAG SkSetFourByteTag('b', 't', 'm', 'p') |
327 #define PICT_MATRIX_BUFFER_TAG SkSetFourByteTag('m', 't', 'r', 'x') | |
328 #define PICT_PAINT_BUFFER_TAG SkSetFourByteTag('p', 'n', 't', ' ') | 317 #define PICT_PAINT_BUFFER_TAG SkSetFourByteTag('p', 'n', 't', ' ') |
329 #define PICT_PATH_BUFFER_TAG SkSetFourByteTag('p', 't', 'h', ' ') | 318 #define PICT_PATH_BUFFER_TAG SkSetFourByteTag('p', 't', 'h', ' ') |
330 #define PICT_REGION_BUFFER_TAG SkSetFourByteTag('r', 'g', 'n', ' ') | |
331 | 319 |
332 // Always write this guy last (with no length field afterwards) | 320 // Always write this guy last (with no length field afterwards) |
333 #define PICT_EOF_TAG SkSetFourByteTag('e', 'o', 'f', ' ') | 321 #define PICT_EOF_TAG SkSetFourByteTag('e', 'o', 'f', ' ') |
334 | 322 |
335 #include "SkStream.h" | 323 #include "SkStream.h" |
336 | 324 |
337 static void writeTagSize(SkOrderedWriteBuffer& buffer, uint32_t tag, | 325 static void writeTagSize(SkOrderedWriteBuffer& buffer, uint32_t tag, |
338 uint32_t size) { | 326 uint32_t size) { |
339 buffer.writeUInt(tag); | 327 buffer.writeUInt(tag); |
340 buffer.writeUInt(size); | 328 buffer.writeUInt(size); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
385 void SkPicturePlayback::flattenToBuffer(SkOrderedWriteBuffer& buffer) const { | 373 void SkPicturePlayback::flattenToBuffer(SkOrderedWriteBuffer& buffer) const { |
386 int i, n; | 374 int i, n; |
387 | 375 |
388 if ((n = SafeCount(fBitmaps)) > 0) { | 376 if ((n = SafeCount(fBitmaps)) > 0) { |
389 writeTagSize(buffer, PICT_BITMAP_BUFFER_TAG, n); | 377 writeTagSize(buffer, PICT_BITMAP_BUFFER_TAG, n); |
390 for (i = 0; i < n; i++) { | 378 for (i = 0; i < n; i++) { |
391 buffer.writeBitmap((*fBitmaps)[i]); | 379 buffer.writeBitmap((*fBitmaps)[i]); |
392 } | 380 } |
393 } | 381 } |
394 | 382 |
395 if ((n = SafeCount(fMatrices)) > 0) { | |
396 writeTagSize(buffer, PICT_MATRIX_BUFFER_TAG, n); | |
397 for (i = 0; i < n; i++) { | |
398 buffer.writeMatrix((*fMatrices)[i]); | |
399 } | |
400 | |
401 } | |
402 | |
403 if ((n = SafeCount(fPaints)) > 0) { | 383 if ((n = SafeCount(fPaints)) > 0) { |
404 writeTagSize(buffer, PICT_PAINT_BUFFER_TAG, n); | 384 writeTagSize(buffer, PICT_PAINT_BUFFER_TAG, n); |
405 for (i = 0; i < n; i++) { | 385 for (i = 0; i < n; i++) { |
406 buffer.writePaint((*fPaints)[i]); | 386 buffer.writePaint((*fPaints)[i]); |
407 } | 387 } |
408 } | 388 } |
409 | 389 |
410 if ((n = SafeCount(fPathHeap.get())) > 0) { | 390 if ((n = SafeCount(fPathHeap.get())) > 0) { |
411 writeTagSize(buffer, PICT_PATH_BUFFER_TAG, n); | 391 writeTagSize(buffer, PICT_PATH_BUFFER_TAG, n); |
412 fPathHeap->flatten(buffer); | 392 fPathHeap->flatten(buffer); |
413 } | 393 } |
414 | |
415 if ((n = SafeCount(fRegions)) > 0) { | |
416 writeTagSize(buffer, PICT_REGION_BUFFER_TAG, n); | |
417 for (i = 0; i < n; i++) { | |
418 buffer.writeRegion((*fRegions)[i]); | |
419 } | |
420 } | |
421 } | 394 } |
422 | 395 |
423 void SkPicturePlayback::serialize(SkWStream* stream, | 396 void SkPicturePlayback::serialize(SkWStream* stream, |
424 SkPicture::EncodeBitmap encoder) const { | 397 SkPicture::EncodeBitmap encoder) const { |
425 writeTagSize(stream, PICT_READER_TAG, fOpData->size()); | 398 writeTagSize(stream, PICT_READER_TAG, fOpData->size()); |
426 stream->write(fOpData->bytes(), fOpData->size()); | 399 stream->write(fOpData->bytes(), fOpData->size()); |
427 | 400 |
428 if (fPictureCount > 0) { | 401 if (fPictureCount > 0) { |
429 writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount); | 402 writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount); |
430 for (int i = 0; i < fPictureCount; i++) { | 403 for (int i = 0; i < fPictureCount; i++) { |
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
585 uint32_t tag, size_t size) { | 558 uint32_t tag, size_t size) { |
586 switch (tag) { | 559 switch (tag) { |
587 case PICT_BITMAP_BUFFER_TAG: { | 560 case PICT_BITMAP_BUFFER_TAG: { |
588 fBitmaps = SkTRefArray<SkBitmap>::Create(size); | 561 fBitmaps = SkTRefArray<SkBitmap>::Create(size); |
589 for (size_t i = 0; i < size; ++i) { | 562 for (size_t i = 0; i < size; ++i) { |
590 SkBitmap* bm = &fBitmaps->writableAt(i); | 563 SkBitmap* bm = &fBitmaps->writableAt(i); |
591 buffer.readBitmap(bm); | 564 buffer.readBitmap(bm); |
592 bm->setImmutable(); | 565 bm->setImmutable(); |
593 } | 566 } |
594 } break; | 567 } break; |
595 case PICT_MATRIX_BUFFER_TAG: | |
596 fMatrices = SkTRefArray<SkMatrix>::Create(size); | |
597 for (size_t i = 0; i < size; ++i) { | |
598 buffer.readMatrix(&fMatrices->writableAt(i)); | |
599 } | |
600 break; | |
601 case PICT_PAINT_BUFFER_TAG: { | 568 case PICT_PAINT_BUFFER_TAG: { |
602 fPaints = SkTRefArray<SkPaint>::Create(size); | 569 fPaints = SkTRefArray<SkPaint>::Create(size); |
603 for (size_t i = 0; i < size; ++i) { | 570 for (size_t i = 0; i < size; ++i) { |
604 buffer.readPaint(&fPaints->writableAt(i)); | 571 buffer.readPaint(&fPaints->writableAt(i)); |
605 } | 572 } |
606 } break; | 573 } break; |
607 case PICT_PATH_BUFFER_TAG: | 574 case PICT_PATH_BUFFER_TAG: |
608 if (size > 0) { | 575 if (size > 0) { |
609 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer))); | 576 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer))); |
610 } | 577 } |
611 break; | 578 break; |
612 case PICT_REGION_BUFFER_TAG: { | |
613 fRegions = SkTRefArray<SkRegion>::Create(size); | |
614 for (size_t i = 0; i < size; ++i) { | |
615 buffer.readRegion(&fRegions->writableAt(i)); | |
616 } | |
617 } break; | |
618 default: | 579 default: |
619 // The tag was invalid. | 580 // The tag was invalid. |
620 return false; | 581 return false; |
621 } | 582 } |
622 return true; // success | 583 return true; // success |
623 } | 584 } |
624 | 585 |
625 SkPicturePlayback* SkPicturePlayback::CreateFromStream(SkStream* stream, | 586 SkPicturePlayback* SkPicturePlayback::CreateFromStream(SkStream* stream, |
626 const SkPictInfo& info, | 587 const SkPictInfo& info, |
627 SkPicture::InstallPixelRe
fProc proc) { | 588 SkPicture::InstallPixelRe
fProc proc) { |
(...skipping 187 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
815 SkASSERT(!offsetToRestore || \ | 776 SkASSERT(!offsetToRestore || \ |
816 offsetToRestore >= reader.offset()); | 777 offsetToRestore >= reader.offset()); |
817 if (!canvas.clipPath(path, regionOp, doAA) && offsetToRestore) { | 778 if (!canvas.clipPath(path, regionOp, doAA) && offsetToRestore) { |
818 #ifdef SPEW_CLIP_SKIPPING | 779 #ifdef SPEW_CLIP_SKIPPING |
819 skipPath.recordSkip(offsetToRestore - reader.offset()); | 780 skipPath.recordSkip(offsetToRestore - reader.offset()); |
820 #endif | 781 #endif |
821 reader.setOffset(offsetToRestore); | 782 reader.setOffset(offsetToRestore); |
822 } | 783 } |
823 } break; | 784 } break; |
824 case CLIP_REGION: { | 785 case CLIP_REGION: { |
825 const SkRegion& region = getRegion(reader); | 786 SkRegion region; |
| 787 this->getRegion(reader, ®ion); |
826 uint32_t packed = reader.readInt(); | 788 uint32_t packed = reader.readInt(); |
827 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); | 789 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed); |
828 size_t offsetToRestore = reader.readInt(); | 790 size_t offsetToRestore = reader.readInt(); |
829 SkASSERT(!offsetToRestore || \ | 791 SkASSERT(!offsetToRestore || \ |
830 offsetToRestore >= reader.offset()); | 792 offsetToRestore >= reader.offset()); |
831 if (!canvas.clipRegion(region, regionOp) && offsetToRestore) { | 793 if (!canvas.clipRegion(region, regionOp) && offsetToRestore) { |
832 #ifdef SPEW_CLIP_SKIPPING | 794 #ifdef SPEW_CLIP_SKIPPING |
833 skipRegion.recordSkip(offsetToRestore - reader.offset()); | 795 skipRegion.recordSkip(offsetToRestore - reader.offset()); |
834 #endif | 796 #endif |
835 reader.setOffset(offsetToRestore); | 797 reader.setOffset(offsetToRestore); |
(...skipping 23 matching lines...) Expand all Loading... |
859 size_t offsetToRestore = reader.readInt(); | 821 size_t offsetToRestore = reader.readInt(); |
860 SkASSERT(!offsetToRestore || \ | 822 SkASSERT(!offsetToRestore || \ |
861 offsetToRestore >= reader.offset()); | 823 offsetToRestore >= reader.offset()); |
862 if (!canvas.clipRRect(rrect, regionOp, doAA) && offsetToRestore)
{ | 824 if (!canvas.clipRRect(rrect, regionOp, doAA) && offsetToRestore)
{ |
863 #ifdef SPEW_CLIP_SKIPPING | 825 #ifdef SPEW_CLIP_SKIPPING |
864 skipRRect.recordSkip(offsetToRestore - reader.offset()); | 826 skipRRect.recordSkip(offsetToRestore - reader.offset()); |
865 #endif | 827 #endif |
866 reader.setOffset(offsetToRestore); | 828 reader.setOffset(offsetToRestore); |
867 } | 829 } |
868 } break; | 830 } break; |
869 case CONCAT: | 831 case CONCAT: { |
870 canvas.concat(*getMatrix(reader)); | 832 SkMatrix matrix; |
| 833 this->getMatrix(reader, &matrix); |
| 834 canvas.concat(matrix); |
871 break; | 835 break; |
| 836 } |
872 case DRAW_BITMAP: { | 837 case DRAW_BITMAP: { |
873 const SkPaint* paint = getPaint(reader); | 838 const SkPaint* paint = getPaint(reader); |
874 const SkBitmap& bitmap = getBitmap(reader); | 839 const SkBitmap& bitmap = getBitmap(reader); |
875 const SkPoint& loc = reader.skipT<SkPoint>(); | 840 const SkPoint& loc = reader.skipT<SkPoint>(); |
876 canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint); | 841 canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint); |
877 } break; | 842 } break; |
878 case DRAW_BITMAP_RECT_TO_RECT: { | 843 case DRAW_BITMAP_RECT_TO_RECT: { |
879 const SkPaint* paint = getPaint(reader); | 844 const SkPaint* paint = getPaint(reader); |
880 const SkBitmap& bitmap = getBitmap(reader); | 845 const SkBitmap& bitmap = getBitmap(reader); |
881 const SkRect* src = this->getRectPtr(reader); // may be null | 846 const SkRect* src = this->getRectPtr(reader); // may be null |
882 const SkRect& dst = reader.skipT<SkRect>(); // required | 847 const SkRect& dst = reader.skipT<SkRect>(); // required |
883 SkCanvas::DrawBitmapRectFlags flags; | 848 SkCanvas::DrawBitmapRectFlags flags; |
884 flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt(); | 849 flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt(); |
885 canvas.drawBitmapRectToRect(bitmap, src, dst, paint, flags); | 850 canvas.drawBitmapRectToRect(bitmap, src, dst, paint, flags); |
886 } break; | 851 } break; |
887 case DRAW_BITMAP_MATRIX: { | 852 case DRAW_BITMAP_MATRIX: { |
888 const SkPaint* paint = getPaint(reader); | 853 const SkPaint* paint = getPaint(reader); |
889 const SkBitmap& bitmap = getBitmap(reader); | 854 const SkBitmap& bitmap = getBitmap(reader); |
890 const SkMatrix* matrix = getMatrix(reader); | 855 SkMatrix matrix; |
891 canvas.drawBitmapMatrix(bitmap, *matrix, paint); | 856 this->getMatrix(reader, &matrix); |
| 857 canvas.drawBitmapMatrix(bitmap, matrix, paint); |
892 } break; | 858 } break; |
893 case DRAW_BITMAP_NINE: { | 859 case DRAW_BITMAP_NINE: { |
894 const SkPaint* paint = getPaint(reader); | 860 const SkPaint* paint = getPaint(reader); |
895 const SkBitmap& bitmap = getBitmap(reader); | 861 const SkBitmap& bitmap = getBitmap(reader); |
896 const SkIRect& src = reader.skipT<SkIRect>(); | 862 const SkIRect& src = reader.skipT<SkIRect>(); |
897 const SkRect& dst = reader.skipT<SkRect>(); | 863 const SkRect& dst = reader.skipT<SkRect>(); |
898 canvas.drawBitmapNine(bitmap, src, dst, paint); | 864 canvas.drawBitmapNine(bitmap, src, dst, paint); |
899 } break; | 865 } break; |
900 case DRAW_CLEAR: | 866 case DRAW_CLEAR: |
901 canvas.clear(reader.readInt()); | 867 canvas.clear(reader.readInt()); |
(...skipping 110 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1012 // ptr[3] == bottom | 978 // ptr[3] == bottom |
1013 if (!canvas.quickRejectY(ptr[2], ptr[3])) { | 979 if (!canvas.quickRejectY(ptr[2], ptr[3])) { |
1014 canvas.drawText(text.text(), text.length(), ptr[0], ptr[1], | 980 canvas.drawText(text.text(), text.length(), ptr[0], ptr[1], |
1015 paint); | 981 paint); |
1016 } | 982 } |
1017 } break; | 983 } break; |
1018 case DRAW_TEXT_ON_PATH: { | 984 case DRAW_TEXT_ON_PATH: { |
1019 const SkPaint& paint = *getPaint(reader); | 985 const SkPaint& paint = *getPaint(reader); |
1020 getText(reader, &text); | 986 getText(reader, &text); |
1021 const SkPath& path = getPath(reader); | 987 const SkPath& path = getPath(reader); |
1022 const SkMatrix* matrix = getMatrix(reader); | 988 SkMatrix matrix; |
1023 canvas.drawTextOnPath(text.text(), text.length(), path, | 989 this->getMatrix(reader, &matrix); |
1024 matrix, paint); | 990 canvas.drawTextOnPath(text.text(), text.length(), path, &matrix,
paint); |
1025 } break; | 991 } break; |
1026 case DRAW_VERTICES: { | 992 case DRAW_VERTICES: { |
1027 SkAutoTUnref<SkXfermode> xfer; | 993 SkAutoTUnref<SkXfermode> xfer; |
1028 const SkPaint& paint = *getPaint(reader); | 994 const SkPaint& paint = *getPaint(reader); |
1029 DrawVertexFlags flags = (DrawVertexFlags)reader.readInt(); | 995 DrawVertexFlags flags = (DrawVertexFlags)reader.readInt(); |
1030 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readIn
t(); | 996 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readIn
t(); |
1031 int vCount = reader.readInt(); | 997 int vCount = reader.readInt(); |
1032 const SkPoint* verts = (const SkPoint*)reader.skip( | 998 const SkPoint* verts = (const SkPoint*)reader.skip( |
1033 vCount * sizeof(SkPoint)); | 999 vCount * sizeof(SkPoint)); |
1034 const SkPoint* texs = NULL; | 1000 const SkPoint* texs = NULL; |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1072 const SkPaint* paint = getPaint(reader); | 1038 const SkPaint* paint = getPaint(reader); |
1073 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.
readInt()); | 1039 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.
readInt()); |
1074 } break; | 1040 } break; |
1075 case SCALE: { | 1041 case SCALE: { |
1076 SkScalar sx = reader.readScalar(); | 1042 SkScalar sx = reader.readScalar(); |
1077 SkScalar sy = reader.readScalar(); | 1043 SkScalar sy = reader.readScalar(); |
1078 canvas.scale(sx, sy); | 1044 canvas.scale(sx, sy); |
1079 } break; | 1045 } break; |
1080 case SET_MATRIX: { | 1046 case SET_MATRIX: { |
1081 SkMatrix matrix; | 1047 SkMatrix matrix; |
1082 matrix.setConcat(initialMatrix, *getMatrix(reader)); | 1048 this->getMatrix(reader, &matrix); |
| 1049 matrix.postConcat(initialMatrix); |
1083 canvas.setMatrix(matrix); | 1050 canvas.setMatrix(matrix); |
1084 } break; | 1051 } break; |
1085 case SKEW: { | 1052 case SKEW: { |
1086 SkScalar sx = reader.readScalar(); | 1053 SkScalar sx = reader.readScalar(); |
1087 SkScalar sy = reader.readScalar(); | 1054 SkScalar sy = reader.readScalar(); |
1088 canvas.skew(sx, sy); | 1055 canvas.skew(sx, sy); |
1089 } break; | 1056 } break; |
1090 case TRANSLATE: { | 1057 case TRANSLATE: { |
1091 SkScalar dx = reader.readScalar(); | 1058 SkScalar dx = reader.readScalar(); |
1092 SkScalar dy = reader.readScalar(); | 1059 SkScalar dy = reader.readScalar(); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1155 | 1122 |
1156 int SkPicturePlayback::paths(size_t* size) { | 1123 int SkPicturePlayback::paths(size_t* size) { |
1157 size_t result = 0; | 1124 size_t result = 0; |
1158 for (int index = 0; index < fPathCount; index++) { | 1125 for (int index = 0; index < fPathCount; index++) { |
1159 const SkPath& path = fPaths[index]; | 1126 const SkPath& path = fPaths[index]; |
1160 result += path.flatten(NULL); | 1127 result += path.flatten(NULL); |
1161 } | 1128 } |
1162 *size = result; | 1129 *size = result; |
1163 return fPathCount; | 1130 return fPathCount; |
1164 } | 1131 } |
1165 | |
1166 int SkPicturePlayback::regions(size_t* size) { | |
1167 size_t result = 0; | |
1168 for (int index = 0; index < fRegionCount; index++) { | |
1169 // const SkRegion& region = fRegions[index]; | |
1170 result += sizeof(SkRegion); // region->size(); | |
1171 } | |
1172 *size = result; | |
1173 return fRegionCount; | |
1174 } | |
1175 #endif | 1132 #endif |
1176 | 1133 |
1177 #ifdef SK_DEBUG_DUMP | 1134 #ifdef SK_DEBUG_DUMP |
1178 void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const { | 1135 void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const { |
1179 char pBuffer[DUMP_BUFFER_SIZE]; | 1136 char pBuffer[DUMP_BUFFER_SIZE]; |
1180 char* bufferPtr = pBuffer; | 1137 char* bufferPtr = pBuffer; |
1181 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), | 1138 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), |
1182 "BitmapData bitmap%p = {", &bitmap); | 1139 "BitmapData bitmap%p = {", &bitmap); |
1183 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), | 1140 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), |
1184 "{kWidth, %d}, ", bitmap.width()); | 1141 "{kWidth, %d}, ", bitmap.width()); |
(...skipping 279 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1464 while (fReadStream.read(&drawType, sizeof(drawType))) { | 1421 while (fReadStream.read(&drawType, sizeof(drawType))) { |
1465 bufferPtr = buffer; | 1422 bufferPtr = buffer; |
1466 DUMP_DRAWTYPE(drawType); | 1423 DUMP_DRAWTYPE(drawType); |
1467 switch (drawType) { | 1424 switch (drawType) { |
1468 case CLIP_PATH: { | 1425 case CLIP_PATH: { |
1469 DUMP_PTR(SkPath, &getPath()); | 1426 DUMP_PTR(SkPath, &getPath()); |
1470 DUMP_INT(SkRegion::Op); | 1427 DUMP_INT(SkRegion::Op); |
1471 DUMP_INT(offsetToRestore); | 1428 DUMP_INT(offsetToRestore); |
1472 } break; | 1429 } break; |
1473 case CLIP_REGION: { | 1430 case CLIP_REGION: { |
1474 DUMP_PTR(SkRegion, &getRegion()); | |
1475 DUMP_INT(SkRegion::Op); | 1431 DUMP_INT(SkRegion::Op); |
1476 DUMP_INT(offsetToRestore); | 1432 DUMP_INT(offsetToRestore); |
1477 } break; | 1433 } break; |
1478 case CLIP_RECT: { | 1434 case CLIP_RECT: { |
1479 DUMP_RECT(rect); | 1435 DUMP_RECT(rect); |
1480 DUMP_INT(SkRegion::Op); | 1436 DUMP_INT(SkRegion::Op); |
1481 DUMP_INT(offsetToRestore); | 1437 DUMP_INT(offsetToRestore); |
1482 } break; | 1438 } break; |
1483 case CONCAT: | 1439 case CONCAT: |
1484 DUMP_PTR(SkMatrix, getMatrix()); | |
1485 break; | 1440 break; |
1486 case DRAW_BITMAP: { | 1441 case DRAW_BITMAP: { |
1487 DUMP_PTR(SkPaint, getPaint()); | 1442 DUMP_PTR(SkPaint, getPaint()); |
1488 DUMP_PTR(SkBitmap, &getBitmap()); | 1443 DUMP_PTR(SkBitmap, &getBitmap()); |
1489 DUMP_SCALAR(left); | 1444 DUMP_SCALAR(left); |
1490 DUMP_SCALAR(top); | 1445 DUMP_SCALAR(top); |
1491 } break; | 1446 } break; |
1492 case DRAW_PAINT: | 1447 case DRAW_PAINT: |
1493 DUMP_PTR(SkPaint, getPaint()); | 1448 DUMP_PTR(SkPaint, getPaint()); |
1494 break; | 1449 break; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1536 case DRAW_TEXT: { | 1491 case DRAW_TEXT: { |
1537 DUMP_PTR(SkPaint, getPaint()); | 1492 DUMP_PTR(SkPaint, getPaint()); |
1538 DUMP_TEXT(); | 1493 DUMP_TEXT(); |
1539 DUMP_SCALAR(x); | 1494 DUMP_SCALAR(x); |
1540 DUMP_SCALAR(y); | 1495 DUMP_SCALAR(y); |
1541 } break; | 1496 } break; |
1542 case DRAW_TEXT_ON_PATH: { | 1497 case DRAW_TEXT_ON_PATH: { |
1543 DUMP_PTR(SkPaint, getPaint()); | 1498 DUMP_PTR(SkPaint, getPaint()); |
1544 DUMP_TEXT(); | 1499 DUMP_TEXT(); |
1545 DUMP_PTR(SkPath, &getPath()); | 1500 DUMP_PTR(SkPath, &getPath()); |
1546 DUMP_PTR(SkMatrix, getMatrix()); | |
1547 } break; | 1501 } break; |
1548 case RESTORE: | 1502 case RESTORE: |
1549 break; | 1503 break; |
1550 case ROTATE: | 1504 case ROTATE: |
1551 DUMP_SCALAR(rotate); | 1505 DUMP_SCALAR(rotate); |
1552 break; | 1506 break; |
1553 case SAVE: | 1507 case SAVE: |
1554 DUMP_INT(SkCanvas::SaveFlags); | 1508 DUMP_INT(SkCanvas::SaveFlags); |
1555 break; | 1509 break; |
1556 case SAVE_LAYER: { | 1510 case SAVE_LAYER: { |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1589 } | 1543 } |
1590 if (fBitmapCount > 0) | 1544 if (fBitmapCount > 0) |
1591 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | 1545 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), |
1592 "Bitmaps bitmaps = {"); | 1546 "Bitmaps bitmaps = {"); |
1593 for (index = 0; index < fBitmapCount; index++) | 1547 for (index = 0; index < fBitmapCount; index++) |
1594 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | 1548 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), |
1595 "bitmap%p, ", &fBitmaps[index]); | 1549 "bitmap%p, ", &fBitmaps[index]); |
1596 if (fBitmapCount > 0) | 1550 if (fBitmapCount > 0) |
1597 SkDebugf("%s0};\n", pBuffer); | 1551 SkDebugf("%s0};\n", pBuffer); |
1598 | 1552 |
1599 if (fMatrixCount > 0) | |
1600 SkDebugf("// matrices (%d)\n", fMatrixCount); | |
1601 for (index = 0; index < fMatrixCount; index++) { | |
1602 const SkMatrix& matrix = fMatrices[index]; | |
1603 dumpMatrix(matrix); | |
1604 } | |
1605 bufferPtr = pBuffer; | |
1606 if (fMatrixCount > 0) | |
1607 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | |
1608 "Matrices matrices = {"); | |
1609 for (index = 0; index < fMatrixCount; index++) | |
1610 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | |
1611 "matrix%p, ", &fMatrices[index]); | |
1612 if (fMatrixCount > 0) | |
1613 SkDebugf("%s0};\n", pBuffer); | |
1614 | 1553 |
1615 if (fPaintCount > 0) | 1554 if (fPaintCount > 0) |
1616 SkDebugf("// paints (%d)\n", fPaintCount); | 1555 SkDebugf("// paints (%d)\n", fPaintCount); |
1617 for (index = 0; index < fPaintCount; index++) { | 1556 for (index = 0; index < fPaintCount; index++) { |
1618 const SkPaint& paint = fPaints[index]; | 1557 const SkPaint& paint = fPaints[index]; |
1619 dumpPaint(paint); | 1558 dumpPaint(paint); |
1620 } | 1559 } |
1621 bufferPtr = pBuffer; | 1560 bufferPtr = pBuffer; |
1622 if (fPaintCount > 0) | 1561 if (fPaintCount > 0) |
1623 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | 1562 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), |
(...skipping 24 matching lines...) Expand all Loading... |
1648 bufferPtr = pBuffer; | 1587 bufferPtr = pBuffer; |
1649 if (fPictureCount > 0) | 1588 if (fPictureCount > 0) |
1650 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | 1589 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), |
1651 "Pictures pictures = {"); | 1590 "Pictures pictures = {"); |
1652 for (index = 0; index < fPictureCount; index++) | 1591 for (index = 0; index < fPictureCount; index++) |
1653 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | 1592 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), |
1654 "picture%p, ", fPictureRefs[index]); | 1593 "picture%p, ", fPictureRefs[index]); |
1655 if (fPictureCount > 0) | 1594 if (fPictureCount > 0) |
1656 SkDebugf("%s0};\n", pBuffer); | 1595 SkDebugf("%s0};\n", pBuffer); |
1657 | 1596 |
1658 for (index = 0; index < fRegionCount; index++) { | |
1659 const SkRegion& region = fRegions[index]; | |
1660 dumpRegion(region); | |
1661 } | |
1662 bufferPtr = pBuffer; | |
1663 if (fRegionCount > 0) | |
1664 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | |
1665 "Regions regions = {"); | |
1666 for (index = 0; index < fRegionCount; index++) | |
1667 bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer
), | |
1668 "region%p, ", &fRegions[index]); | |
1669 if (fRegionCount > 0) | |
1670 SkDebugf("%s0};\n", pBuffer); | |
1671 | |
1672 const_cast<SkPicturePlayback*>(this)->dumpStream(); | 1597 const_cast<SkPicturePlayback*>(this)->dumpStream(); |
1673 } | 1598 } |
1674 | 1599 |
1675 #endif | 1600 #endif |
OLD | NEW |