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