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