• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
29 class SkPictureRecord : public SkCanvas {
30 public:
31     SkPictureRecord(const SkISize& dimensions, uint32_t recordFlags);
32     virtual ~SkPictureRecord();
33 
getPictureRefs()34     const SkTDArray<const SkPicture* >& getPictureRefs() const {
35         return fPictureRefs;
36     }
37 
getTextBlobRefs()38     const SkTDArray<const SkTextBlob* >& getTextBlobRefs() const {
39         return fTextBlobRefs;
40     }
41 
getImageRefs()42     const SkTDArray<const SkImage* >& getImageRefs() const {
43         return fImageRefs;
44     }
45 
opData(bool deepCopy)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 
contentInfo()60     const SkPictureContentInfo& contentInfo() const {
61         return fContentInfo;
62     }
63 
setFlags(uint32_t recordFlags)64     void setFlags(uint32_t recordFlags) {
65         fRecordFlags = recordFlags;
66     }
67 
writeStream()68     const SkWriter32& writeStream() const {
69         return fWriter;
70     }
71 
72     void beginRecording();
73     void endRecording();
74 
75 protected:
76     void addNoOp();
77 
78 private:
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      */
addDraw(DrawType drawType,size_t * size)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 
addInt(int value)119     void addInt(int value) {
120         fWriter.writeInt(value);
121     }
addScalar(SkScalar scalar)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);
addPaint(const SkPaint & paint)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 
147 protected:
validate(size_t initialOffset,size_t size)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;
onPeekPixels(SkPixmap *)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 
224 private:
225     SkPictureContentInfo fContentInfo;
226 
227     SkTArray<SkBitmap> fBitmaps;
228     SkTArray<SkPaint>  fPaints;
229 
230     struct PathHash {
operatorPathHash231         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