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