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