1 :
2 : /*
3 : * Copyright 2011 Google Inc.
4 : *
5 : * Use of this source code is governed by a BSD-style license that can be
6 : * found in the LICENSE file.
7 : */
8 : #ifndef SkPictureFlat_DEFINED
9 : #define SkPictureFlat_DEFINED
10 :
11 : #include "SkChunkAlloc.h"
12 : #include "SkBitmap.h"
13 : #include "SkPicture.h"
14 : #include "SkMatrix.h"
15 : #include "SkPaint.h"
16 : #include "SkPath.h"
17 : #include "SkRegion.h"
18 :
19 : enum DrawType {
20 : UNUSED,
21 : CLIP_PATH,
22 : CLIP_REGION,
23 : CLIP_RECT,
24 : CONCAT,
25 : DRAW_BITMAP,
26 : DRAW_BITMAP_MATRIX,
27 : DRAW_BITMAP_NINE,
28 : DRAW_BITMAP_RECT,
29 : DRAW_CLEAR,
30 : DRAW_DATA,
31 : DRAW_PAINT,
32 : DRAW_PATH,
33 : DRAW_PICTURE,
34 : DRAW_POINTS,
35 : DRAW_POS_TEXT,
36 : DRAW_POS_TEXT_H,
37 : DRAW_POS_TEXT_H_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT_H
38 : DRAW_RECT,
39 : DRAW_SPRITE,
40 : DRAW_TEXT,
41 : DRAW_TEXT_ON_PATH,
42 : DRAW_TEXT_TOP_BOTTOM, // fast variant of DRAW_TEXT
43 : DRAW_VERTICES,
44 : RESTORE,
45 : ROTATE,
46 : SAVE,
47 : SAVE_LAYER,
48 : SCALE,
49 : SET_MATRIX,
50 : SKEW,
51 : TRANSLATE
52 : };
53 :
54 : enum DrawVertexFlags {
55 : DRAW_VERTICES_HAS_TEXS = 0x01,
56 : DRAW_VERTICES_HAS_COLORS = 0x02,
57 : DRAW_VERTICES_HAS_INDICES = 0x04
58 : };
59 :
60 : ///////////////////////////////////////////////////////////////////////////////
61 : // clipparams are packed in 5 bits
62 : // doAA:1 | regionOp:4
63 :
64 0 : static inline uint32_t ClipParams_pack(SkRegion::Op op, bool doAA) {
65 0 : unsigned doAABit = doAA ? 1 : 0;
66 0 : return (doAABit << 4) | op;
67 : }
68 :
69 0 : static inline SkRegion::Op ClipParams_unpackRegionOp(uint32_t packed) {
70 0 : return (SkRegion::Op)(packed & 0xF);
71 : }
72 :
73 0 : static inline bool ClipParams_unpackDoAA(uint32_t packed) {
74 0 : return SkToBool((packed >> 4) & 1);
75 : }
76 :
77 : ///////////////////////////////////////////////////////////////////////////////
78 :
79 : class SkRefCntPlayback {
80 : public:
81 : SkRefCntPlayback();
82 : virtual ~SkRefCntPlayback();
83 :
84 : int count() const { return fCount; }
85 :
86 : void reset(const SkRefCntSet*);
87 :
88 : void setCount(int count);
89 : SkRefCnt* set(int index, SkRefCnt*);
90 :
91 0 : virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
92 0 : buffer.setRefCntArray(fArray, fCount);
93 0 : }
94 :
95 : protected:
96 : int fCount;
97 : SkRefCnt** fArray;
98 : };
99 :
100 0 : class SkTypefacePlayback : public SkRefCntPlayback {
101 : public:
102 0 : virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
103 0 : buffer.setTypefaceArray((SkTypeface**)fArray, fCount);
104 0 : }
105 : };
106 :
107 : class SkFactoryPlayback {
108 : public:
109 0 : SkFactoryPlayback(int count) : fCount(count) {
110 0 : fArray = SkNEW_ARRAY(SkFlattenable::Factory, count);
111 0 : }
112 :
113 0 : ~SkFactoryPlayback() {
114 0 : SkDELETE_ARRAY(fArray);
115 0 : }
116 :
117 0 : SkFlattenable::Factory* base() const { return fArray; }
118 :
119 0 : void setupBuffer(SkFlattenableReadBuffer& buffer) const {
120 0 : buffer.setFactoryPlayback(fArray, fCount);
121 0 : }
122 :
123 : private:
124 : int fCount;
125 : SkFlattenable::Factory* fArray;
126 : };
127 :
128 : class SkFlatData {
129 : public:
130 0 : static int Compare(const SkFlatData* a, const SkFlatData* b) {
131 0 : return memcmp(&a->fAllocSize, &b->fAllocSize, a->fAllocSize);
132 : }
133 :
134 0 : int index() const { return fIndex; }
135 :
136 : #ifdef SK_DEBUG_SIZE
137 : size_t size() const { return sizeof(fIndex) + fAllocSize; }
138 : #endif
139 :
140 : protected:
141 : static SkFlatData* Alloc(SkChunkAlloc* heap, int32_t size, int index);
142 :
143 : int fIndex;
144 : int32_t fAllocSize;
145 : };
146 :
147 : class SkFlatBitmap : public SkFlatData {
148 : public:
149 : static SkFlatBitmap* Flatten(SkChunkAlloc*, const SkBitmap&, int index,
150 : SkRefCntSet*);
151 :
152 0 : void unflatten(SkBitmap* bitmap, SkRefCntPlayback* rcp) const {
153 0 : SkFlattenableReadBuffer buffer(fBitmapData);
154 0 : if (rcp) {
155 0 : rcp->setupBuffer(buffer);
156 : }
157 0 : bitmap->unflatten(buffer);
158 0 : }
159 :
160 : #ifdef SK_DEBUG_VALIDATE
161 : void validate() const {
162 : // to be written
163 : }
164 : #endif
165 :
166 : private:
167 : char fBitmapData[1];
168 : typedef SkFlatData INHERITED;
169 : };
170 :
171 : class SkFlatMatrix : public SkFlatData {
172 : public:
173 : static SkFlatMatrix* Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index);
174 :
175 0 : void unflatten(SkMatrix* result) const {
176 0 : result->unflatten(fMatrixData);
177 0 : }
178 :
179 : #ifdef SK_DEBUG_DUMP
180 : void dump() const;
181 : #endif
182 :
183 : #ifdef SK_DEBUG_VALIDATE
184 : void validate() const {
185 : // to be written
186 : }
187 : #endif
188 :
189 : private:
190 : char fMatrixData[1];
191 : typedef SkFlatData INHERITED;
192 : };
193 :
194 : class SkFlatPaint : public SkFlatData {
195 : public:
196 : static SkFlatPaint* Flatten(SkChunkAlloc* heap, const SkPaint& paint,
197 : int index, SkRefCntSet*,
198 : SkRefCntSet* faceRecorder);
199 :
200 0 : void unflatten(SkPaint* result, SkRefCntPlayback* rcp,
201 : SkTypefacePlayback* facePlayback) const {
202 0 : Read(fPaintData, result, rcp, facePlayback);
203 0 : }
204 :
205 : static void Read(const void* storage, SkPaint* paint, SkRefCntPlayback*,
206 : SkTypefacePlayback* facePlayback);
207 :
208 : #ifdef SK_DEBUG_DUMP
209 : void dump() const;
210 : #endif
211 :
212 : private:
213 : char fPaintData[1];
214 : typedef SkFlatData INHERITED;
215 : };
216 :
217 : class SkFlatRegion : public SkFlatData {
218 : public:
219 : static SkFlatRegion* Flatten(SkChunkAlloc* heap, const SkRegion& region, int index);
220 :
221 0 : void unflatten(SkRegion* result) const {
222 0 : result->unflatten(fRegionData);
223 0 : }
224 :
225 : #ifdef SK_DEBUG_VALIDATE
226 : void validate() const {
227 : // to be written
228 : }
229 : #endif
230 :
231 : private:
232 : char fRegionData[1];
233 : typedef SkFlatData INHERITED;
234 : };
235 :
236 : #endif
|