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
8#ifndef SkPictureRecord_DEFINED
9#define SkPictureRecord_DEFINED
10
11#include "SkCanvas.h"
12#include "SkFlattenable.h"
13#include "SkPicture.h"
14#include "SkPictureData.h"
15#include "SkTArray.h"
16#include "SkTDArray.h"
17#include "SkTHash.h"
18#include "SkWriter32.h"
19
20// These macros help with packing and unpacking a single byte value and
21// a 3 byte value into/out of a uint32_t
22#define MASK_24 0x00FFFFFF
23#define UNPACK_8_24(combined, small, large)             \
24    small = (combined >> 24) & 0xFF;                    \
25    large = combined & MASK_24;
26#define PACK_8_24(small, large) ((small << 24) | large)
27
28
29class SkPictureRecord : public SkCanvas {
30public:
31    SkPictureRecord(const SkISize& dimensions, uint32_t recordFlags);
32    virtual ~SkPictureRecord();
33
34    const SkTDArray<const SkPicture* >& getPictureRefs() const {
35        return fPictureRefs;
36    }
37
38    const SkTDArray<const SkTextBlob* >& getTextBlobRefs() const {
39        return fTextBlobRefs;
40    }
41
42    const SkTDArray<const SkImage* >& getImageRefs() const {
43        return fImageRefs;
44    }
45
46    SkData* opData(bool deepCopy) const {
47        this->validate(fWriter.bytesWritten(), 0);
48
49        if (fWriter.bytesWritten() == 0) {
50            return SkData::NewEmpty();
51        }
52
53        if (deepCopy) {
54            return SkData::NewWithCopy(fWriter.contiguousArray(), fWriter.bytesWritten());
55        }
56
57        return fWriter.snapshotAsData();
58    }
59
60    const SkPictureContentInfo& contentInfo() const {
61        return fContentInfo;
62    }
63
64    void setFlags(uint32_t recordFlags) {
65        fRecordFlags = recordFlags;
66    }
67
68    const SkWriter32& writeStream() const {
69        return fWriter;
70    }
71
72    void beginRecording();
73    void endRecording();
74
75protected:
76    void addNoOp();
77
78private:
79    void handleOptimization(int opt);
80    size_t recordRestoreOffsetPlaceholder(SkRegion::Op);
81    void fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset);
82
83    SkTDArray<int32_t> fRestoreOffsetStack;
84
85    SkTDArray<uint32_t> fCullOffsetStack;
86
87    /*
88     * Write the 'drawType' operation and chunk size to the skp. 'size'
89     * can potentially be increased if the chunk size needs its own storage
90     * location (i.e., it overflows 24 bits).
91     * Returns the start offset of the chunk. This is the location at which
92     * the opcode & size are stored.
93     * TODO: since we are handing the size into here we could call reserve
94     * and then return a pointer to the memory storage. This could decrease
95     * allocation overhead but could lead to more wasted space (the tail
96     * end of blocks could go unused). Possibly add a second addDraw that
97     * operates in this manner.
98     */
99    size_t addDraw(DrawType drawType, size_t* size) {
100        size_t offset = fWriter.bytesWritten();
101
102        this->predrawNotify();
103        fContentInfo.addOperation();
104
105        SkASSERT(0 != *size);
106        SkASSERT(((uint8_t) drawType) == drawType);
107
108        if (0 != (*size & ~MASK_24) || *size == MASK_24) {
109            fWriter.writeInt(PACK_8_24(drawType, MASK_24));
110            *size += 1;
111            fWriter.writeInt(SkToU32(*size));
112        } else {
113            fWriter.writeInt(PACK_8_24(drawType, SkToU32(*size)));
114        }
115
116        return offset;
117    }
118
119    void addInt(int value) {
120        fWriter.writeInt(value);
121    }
122    void addScalar(SkScalar scalar) {
123        fWriter.writeScalar(scalar);
124    }
125
126    void addBitmap(const SkBitmap& bitmap);
127    void addImage(const SkImage*);
128    void addMatrix(const SkMatrix& matrix);
129    void addPaint(const SkPaint& paint) { this->addPaintPtr(&paint); }
130    void addPaintPtr(const SkPaint* paint);
131    void addPatch(const SkPoint cubics[12]);
132    void addPath(const SkPath& path);
133    void addPicture(const SkPicture* picture);
134    void addPoint(const SkPoint& point);
135    void addPoints(const SkPoint pts[], int count);
136    void addRect(const SkRect& rect);
137    void addRectPtr(const SkRect* rect);
138    void addIRect(const SkIRect& rect);
139    void addIRectPtr(const SkIRect* rect);
140    void addRRect(const SkRRect&);
141    void addRegion(const SkRegion& region);
142    void addText(const void* text, size_t byteLength);
143    void addTextBlob(const SkTextBlob* blob);
144
145    int find(const SkBitmap& bitmap);
146
147protected:
148    void validate(size_t initialOffset, size_t size) const {
149        SkASSERT(fWriter.bytesWritten() == initialOffset + size);
150    }
151
152    SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override;
153    bool onPeekPixels(SkPixmap*) override { return false; }
154
155    void willSave() override;
156    SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec&) override;
157    void willRestore() override;
158
159    void didConcat(const SkMatrix&) override;
160    void didSetMatrix(const SkMatrix&) override;
161
162    void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
163
164    void onDrawText(const void* text, size_t, SkScalar x, SkScalar y, const SkPaint&) override;
165    void onDrawPosText(const void* text, size_t, const SkPoint pos[], const SkPaint&) override;
166    void onDrawPosTextH(const void* text, size_t, const SkScalar xpos[], SkScalar constY,
167                        const SkPaint&) override;
168    void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
169                                  const SkMatrix* matrix, const SkPaint&) override;
170    void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
171                                const SkPaint& paint) override;
172
173    void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
174                             const SkPoint texCoords[4], SkXfermode* xmode,
175                             const SkPaint& paint) override;
176    void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
177                     SkXfermode::Mode, const SkRect*, const SkPaint*) override;
178
179    void onDrawPaint(const SkPaint&) override;
180    void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
181    void onDrawRect(const SkRect&, const SkPaint&) override;
182    void onDrawOval(const SkRect&, const SkPaint&) override;
183    void onDrawRRect(const SkRRect&, const SkPaint&) override;
184    void onDrawPath(const SkPath&, const SkPaint&) override;
185    void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
186    void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
187                          SrcRectConstraint) override;
188    void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
189    void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
190                         const SkPaint*, SrcRectConstraint) override;
191    void onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
192                         const SkPaint*) override;
193    void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
194                          const SkPaint*) override;
195    void onDrawVertices(VertexMode vmode, int vertexCount,
196                        const SkPoint vertices[], const SkPoint texs[],
197                        const SkColor colors[], SkXfermode* xmode,
198                        const uint16_t indices[], int indexCount,
199                        const SkPaint&) override;
200
201    void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
202    void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
203    void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
204    void onClipRegion(const SkRegion&, SkRegion::Op) override;
205
206    void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
207
208    int addPathToHeap(const SkPath& path);  // does not write to ops stream
209
210    // These entry points allow the writing of matrices, clips, saves &
211    // restores to be deferred (e.g., if the MC state is being collapsed and
212    // only written out as needed).
213    void recordConcat(const SkMatrix& matrix);
214    void recordTranslate(const SkMatrix& matrix);
215    void recordScale(const SkMatrix& matrix);
216    size_t recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
217    size_t recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
218    size_t recordClipPath(int pathID, SkRegion::Op op, bool doAA);
219    size_t recordClipRegion(const SkRegion& region, SkRegion::Op op);
220    void recordSave();
221    void recordSaveLayer(const SaveLayerRec&);
222    void recordRestore(bool fillInSkips = true);
223
224private:
225    SkPictureContentInfo fContentInfo;
226
227    SkTArray<SkBitmap> fBitmaps;
228    SkTArray<SkPaint>  fPaints;
229
230    struct PathHash {
231        uint32_t operator()(const SkPath& p) { return p.getGenerationID(); }
232    };
233    SkTHashMap<SkPath, int, PathHash> fPaths;
234
235    SkWriter32 fWriter;
236
237    // we ref each item in these arrays
238    SkTDArray<const SkImage*>    fImageRefs;
239    SkTDArray<const SkPicture*>  fPictureRefs;
240    SkTDArray<const SkTextBlob*> fTextBlobRefs;
241
242    uint32_t fRecordFlags;
243    int      fInitialSaveCount;
244
245    friend class SkPictureData;   // for SkPictureData's SkPictureRecord-based constructor
246
247    typedef SkCanvas INHERITED;
248};
249
250#endif
251