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