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
9
10
11 #ifndef SkGPipePriv_DEFINED
12 #define SkGPipePriv_DEFINED
13
14 #include "SkTypes.h"
15
16 #define UNIMPLEMENTED
17
18 // these must be contiguous, 0...N-1
19 enum PaintFlats {
20 kColorFilter_PaintFlat,
21 kDrawLooper_PaintFlat,
22 kMaskFilter_PaintFlat,
23 kPathEffect_PaintFlat,
24 kRasterizer_PaintFlat,
25 kShader_PaintFlat,
26 kImageFilter_PaintFlat,
27 kXfermode_PaintFlat,
28
29 kLast_PaintFlat = kXfermode_PaintFlat
30 };
31 #define kCount_PaintFlats (kLast_PaintFlat + 1)
32
33 enum DrawOps {
34 kSkip_DrawOp, // skip an addition N bytes (N == data)
35
36 // these match Canvas apis
37 kClipPath_DrawOp,
38 kClipRegion_DrawOp,
39 kClipRect_DrawOp,
40 kClipRRect_DrawOp,
41 kConcat_DrawOp,
42 kDrawBitmap_DrawOp,
43 kDrawBitmapMatrix_DrawOp,
44 kDrawBitmapNine_DrawOp,
45 kDrawBitmapRectToRect_DrawOp,
46 kDrawClear_DrawOp,
47 kDrawData_DrawOp,
48 kDrawOval_DrawOp,
49 kDrawPaint_DrawOp,
50 kDrawPath_DrawOp,
51 kDrawPicture_DrawOp,
52 kDrawPoints_DrawOp,
53 kDrawPosText_DrawOp,
54 kDrawPosTextH_DrawOp,
55 kDrawRect_DrawOp,
56 kDrawRRect_DrawOp,
57 kDrawSprite_DrawOp,
58 kDrawText_DrawOp,
59 kDrawTextOnPath_DrawOp,
60 kDrawVertices_DrawOp,
61 kRestore_DrawOp,
62 kRotate_DrawOp,
63 kSave_DrawOp,
64 kSaveLayer_DrawOp,
65 kScale_DrawOp,
66 kSetMatrix_DrawOp,
67 kSkew_DrawOp,
68 kTranslate_DrawOp,
69
70 kPaintOp_DrawOp,
71 kSetTypeface_DrawOp,
72
73 kDef_Typeface_DrawOp,
74 kDef_Flattenable_DrawOp,
75 kDef_Bitmap_DrawOp,
76 kDef_Factory_DrawOp,
77
78 // these are signals to playback, not drawing verbs
79 kReportFlags_DrawOp,
80 kShareBitmapHeap_DrawOp,
81 kDone_DrawOp,
82 };
83
84 /**
85 * DrawOp packs into a 32bit int as follows
86 *
87 * DrawOp:8 - Flags:4 - Data:20
88 *
89 * Flags and Data are called out separately, so we can reuse Data between
90 * different Ops that might have different Flags. e.g. Data might be a Paint
91 * index for both drawRect (no flags) and saveLayer (does have flags).
92 *
93 * All Ops that take a SkPaint use their Data field to store the index to
94 * the paint (previously defined with kPaintOp_DrawOp).
95 */
96
97 #define DRAWOPS_OP_BITS 8
98 #define DRAWOPS_FLAG_BITS 4
99 #define DRAWOPS_DATA_BITS 20
100
101 #define DRAWOPS_OP_MASK ((1 << DRAWOPS_OP_BITS) - 1)
102 #define DRAWOPS_FLAG_MASK ((1 << DRAWOPS_FLAG_BITS) - 1)
103 #define DRAWOPS_DATA_MASK ((1 << DRAWOPS_DATA_BITS) - 1)
104
DrawOp_unpackOp(uint32_t op32)105 static inline unsigned DrawOp_unpackOp(uint32_t op32) {
106 return (op32 >> (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS));
107 }
108
DrawOp_unpackFlags(uint32_t op32)109 static inline unsigned DrawOp_unpackFlags(uint32_t op32) {
110 return (op32 >> DRAWOPS_DATA_BITS) & DRAWOPS_FLAG_MASK;
111 }
112
DrawOp_unpackData(uint32_t op32)113 static inline unsigned DrawOp_unpackData(uint32_t op32) {
114 return op32 & DRAWOPS_DATA_MASK;
115 }
116
DrawOp_packOpFlagData(DrawOps op,unsigned flags,unsigned data)117 static inline uint32_t DrawOp_packOpFlagData(DrawOps op, unsigned flags, unsigned data) {
118 SkASSERT(0 == (op & ~DRAWOPS_OP_MASK));
119 SkASSERT(0 == (flags & ~DRAWOPS_FLAG_MASK));
120 SkASSERT(0 == (data & ~DRAWOPS_DATA_MASK));
121
122 return (op << (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS)) |
123 (flags << DRAWOPS_DATA_BITS) |
124 data;
125 }
126
127 /** DrawOp specific flag bits
128 */
129
130 enum {
131 kSaveLayer_HasBounds_DrawOpFlag = 1 << 0,
132 kSaveLayer_HasPaint_DrawOpFlag = 1 << 1,
133 };
134 enum {
135 kClear_HasColor_DrawOpFlag = 1 << 0
136 };
137 enum {
138 kDrawTextOnPath_HasMatrix_DrawOpFlag = 1 << 0
139 };
140 enum {
141 kDrawVertices_HasTexs_DrawOpFlag = 1 << 0,
142 kDrawVertices_HasColors_DrawOpFlag = 1 << 1,
143 kDrawVertices_HasIndices_DrawOpFlag = 1 << 2,
144 };
145 enum {
146 kDrawBitmap_HasPaint_DrawOpFlag = 1 << 0,
147 // Specific to drawBitmapRect, but needs to be different from HasPaint,
148 // which is used for all drawBitmap calls, so include it here.
149 kDrawBitmap_HasSrcRect_DrawOpFlag = 1 << 1,
150 };
151 enum {
152 kClip_HasAntiAlias_DrawOpFlag = 1 << 0,
153 };
154 ///////////////////////////////////////////////////////////////////////////////
155
156 class BitmapInfo : SkNoncopyable {
157 public:
BitmapInfo(SkBitmap * bitmap,uint32_t genID,int toBeDrawnCount)158 BitmapInfo(SkBitmap* bitmap, uint32_t genID, int toBeDrawnCount)
159 : fBitmap(bitmap)
160 , fGenID(genID)
161 , fBytesAllocated(0)
162 , fMoreRecentlyUsed(NULL)
163 , fLessRecentlyUsed(NULL)
164 , fToBeDrawnCount(toBeDrawnCount)
165 {}
166
~BitmapInfo()167 ~BitmapInfo() {
168 SkASSERT(0 == fToBeDrawnCount);
169 SkDELETE(fBitmap);
170 }
171
addDraws(int drawsToAdd)172 void addDraws(int drawsToAdd) {
173 if (0 == fToBeDrawnCount) {
174 // The readers will only ever decrement the count, so once the
175 // count is zero, the writer will be the only one modifying it,
176 // so it does not need to be an atomic operation.
177 fToBeDrawnCount = drawsToAdd;
178 } else {
179 sk_atomic_add(&fToBeDrawnCount, drawsToAdd);
180 }
181 }
182
decDraws()183 void decDraws() {
184 sk_atomic_dec(&fToBeDrawnCount);
185 }
186
drawCount()187 int drawCount() const {
188 return fToBeDrawnCount;
189 }
190
191 SkBitmap* fBitmap;
192 // Store the generation ID of the original bitmap, since copying does
193 // not copy this field, so fBitmap's generation ID will not be useful
194 // for comparing.
195 // FIXME: Is it reasonable to make copying a bitmap/pixelref copy the
196 // generation ID?
197 uint32_t fGenID;
198 // Keep track of the bytes allocated for this bitmap. When replacing the
199 // bitmap or removing this BitmapInfo we know how much memory has been
200 // reclaimed.
201 size_t fBytesAllocated;
202 // TODO: Generalize the LRU caching mechanism
203 BitmapInfo* fMoreRecentlyUsed;
204 BitmapInfo* fLessRecentlyUsed;
205 private:
206 int fToBeDrawnCount;
207 };
208
shouldFlattenBitmaps(uint32_t flags)209 static inline bool shouldFlattenBitmaps(uint32_t flags) {
210 return SkToBool(flags & SkGPipeWriter::kCrossProcess_Flag
211 && !(flags & SkGPipeWriter::kSharedAddressSpace_Flag));
212 }
213
214 ///////////////////////////////////////////////////////////////////////////////
215
216 enum PaintOps {
217 kReset_PaintOp, // no arg
218
219 kFlags_PaintOp, // arg inline
220 kColor_PaintOp, // arg 32
221 kStyle_PaintOp, // arg inline
222 kJoin_PaintOp, // arg inline
223 kCap_PaintOp, // arg inline
224 kWidth_PaintOp, // arg scalar
225 kMiter_PaintOp,// arg scalar
226
227 kEncoding_PaintOp, // arg inline - text
228 kHinting_PaintOp, // arg inline - text
229 kAlign_PaintOp, // arg inline - text
230 kTextSize_PaintOp, // arg scalar - text
231 kTextScaleX_PaintOp,// arg scalar - text
232 kTextSkewX_PaintOp, // arg scalar - text
233 kTypeface_PaintOp, // arg inline (index) - text
234
235 kFlatIndex_PaintOp, // flags=paintflat, data=index
236 };
237
238 #define PAINTOPS_OP_BITS 8
239 #define PAINTOPS_FLAG_BITS 4
240 #define PAINTOPS_DATA_BITS 20
241
242 #define PAINTOPS_OP_MASK ((1 << PAINTOPS_OP_BITS) - 1)
243 #define PAINTOPS_FLAG_MASK ((1 << PAINTOPS_FLAG_BITS) - 1)
244 #define PAINTOPS_DATA_MASK ((1 << PAINTOPS_DATA_BITS) - 1)
245
PaintOp_unpackOp(uint32_t op32)246 static inline unsigned PaintOp_unpackOp(uint32_t op32) {
247 return (op32 >> (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS));
248 }
249
PaintOp_unpackFlags(uint32_t op32)250 static inline unsigned PaintOp_unpackFlags(uint32_t op32) {
251 return (op32 >> PAINTOPS_DATA_BITS) & PAINTOPS_FLAG_MASK;
252 }
253
PaintOp_unpackData(uint32_t op32)254 static inline unsigned PaintOp_unpackData(uint32_t op32) {
255 return op32 & PAINTOPS_DATA_MASK;
256 }
257
PaintOp_packOp(PaintOps op)258 static inline uint32_t PaintOp_packOp(PaintOps op) {
259 SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
260
261 return op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS);
262 }
263
PaintOp_packOpData(PaintOps op,unsigned data)264 static inline uint32_t PaintOp_packOpData(PaintOps op, unsigned data) {
265 SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
266 SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
267
268 return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) | data;
269 }
270
PaintOp_packOpFlagData(PaintOps op,unsigned flags,unsigned data)271 static inline uint32_t PaintOp_packOpFlagData(PaintOps op, unsigned flags, unsigned data) {
272 SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
273 SkASSERT(0 == (flags & ~PAINTOPS_FLAG_MASK));
274 SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
275
276 return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) |
277 (flags << PAINTOPS_DATA_BITS) |
278 data;
279 }
280
281 #endif
282