[go: nahoru, domu]
Google Git
Sign in
android / platform / external / chromium_org / third_party / skia / src / cb3f436b7cf9abedc24f6cc02a081fed7cbc81ee / . / core / SkPicture.cpp
blob: 3b04906e0919e2358d4e22e1e15d76e7418ceea2 [file] [log] [blame]
epoger@google.com685cfc02011-07-28 14:26:00 +0000[diff] [blame]1
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]2/*
epoger@google.com685cfc02011-07-28 14:26:00 +0000[diff] [blame]3 * Copyright 2007 The Android Open Source Project
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
scroggo@google.com8b854502013-05-07 14:45:40 +0000[diff] [blame]9
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]10#include "SkPictureFlat.h"
11#include "SkPicturePlayback.h"
12#include "SkPictureRecord.h"
13
robertphillips@google.com7aefc822014-04-18 18:04:41 +0000[diff] [blame]14#include "SkBBHFactory.h"
robertphillips@google.com2fd23902013-08-29 11:54:56 +0000[diff] [blame]15#include "SkBitmapDevice.h"
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]16#include "SkCanvas.h"
17#include "SkChunkAlloc.h"
18#include "SkPicture.h"
19#include "SkRegion.h"
20#include "SkStream.h"
21#include "SkTDArray.h"
22#include "SkTSearch.h"
23#include "SkTime.h"
24
25#include "SkReader32.h"
26#include "SkWriter32.h"
rileya@google.com7fb3d2f2012-09-13 21:41:51 +0000[diff] [blame]27#include "SkRTree.h"
28#include "SkBBoxHierarchyRecord.h"
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]29
commit-bot@chromium.org95cdc162014-03-19 21:24:25 +0000[diff] [blame]30#if SK_SUPPORT_GPU
31#include "GrContext.h"
32#endif
33
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]34template <typename T> int SafeCount(const T* obj) {
35 return obj ? obj->count() : 0;
36}
37
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]38#define DUMP_BUFFER_SIZE 65536
39
40//#define ENABLE_TIME_DRAW // dumps milliseconds for each draw
41
42
43#ifdef SK_DEBUG
reed@google.com91911482011-02-07 15:30:46 +0000[diff] [blame]44// enable SK_DEBUG_TRACE to trace DrawType elements when
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]45// recorded and played back
46// #define SK_DEBUG_TRACE
47// enable SK_DEBUG_SIZE to see the size of picture components
48// #define SK_DEBUG_SIZE
49// enable SK_DEBUG_DUMP to see the contents of recorded elements
50// #define SK_DEBUG_DUMP
51// enable SK_DEBUG_VALIDATE to check internal structures for consistency
52// #define SK_DEBUG_VALIDATE
53#endif
54
55#if defined SK_DEBUG_TRACE || defined SK_DEBUG_DUMP
56const char* DrawTypeToString(DrawType drawType) {
57 switch (drawType) {
58 case UNUSED: SkDebugf("DrawType UNUSED\n"); SkASSERT(0); break;
59 case CLIP_PATH: return "CLIP_PATH";
60 case CLIP_REGION: return "CLIP_REGION";
61 case CLIP_RECT: return "CLIP_RECT";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]62 case CLIP_RRECT: return "CLIP_RRECT";
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]63 case CONCAT: return "CONCAT";
64 case DRAW_BITMAP: return "DRAW_BITMAP";
65 case DRAW_BITMAP_MATRIX: return "DRAW_BITMAP_MATRIX";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]66 case DRAW_BITMAP_NINE: return "DRAW_BITMAP_NINE";
67 case DRAW_BITMAP_RECT_TO_RECT: return "DRAW_BITMAP_RECT_TO_RECT";
68 case DRAW_CLEAR: return "DRAW_CLEAR";
69 case DRAW_DATA: return "DRAW_DATA";
70 case DRAW_OVAL: return "DRAW_OVAL";
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]71 case DRAW_PAINT: return "DRAW_PAINT";
72 case DRAW_PATH: return "DRAW_PATH";
73 case DRAW_PICTURE: return "DRAW_PICTURE";
74 case DRAW_POINTS: return "DRAW_POINTS";
75 case DRAW_POS_TEXT: return "DRAW_POS_TEXT";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]76 case DRAW_POS_TEXT_TOP_BOTTOM: return "DRAW_POS_TEXT_TOP_BOTTOM";
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]77 case DRAW_POS_TEXT_H: return "DRAW_POS_TEXT_H";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]78 case DRAW_POS_TEXT_H_TOP_BOTTOM: return "DRAW_POS_TEXT_H_TOP_BOTTOM";
79 case DRAW_RECT: return "DRAW_RECT";
80 case DRAW_RRECT: return "DRAW_RRECT";
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]81 case DRAW_SPRITE: return "DRAW_SPRITE";
82 case DRAW_TEXT: return "DRAW_TEXT";
83 case DRAW_TEXT_ON_PATH: return "DRAW_TEXT_ON_PATH";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]84 case DRAW_TEXT_TOP_BOTTOM: return "DRAW_TEXT_TOP_BOTTOM";
85 case DRAW_VERTICES: return "DRAW_VERTICES";
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]86 case RESTORE: return "RESTORE";
87 case ROTATE: return "ROTATE";
88 case SAVE: return "SAVE";
89 case SAVE_LAYER: return "SAVE_LAYER";
90 case SCALE: return "SCALE";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]91 case SET_MATRIX: return "SET_MATRIX";
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]92 case SKEW: return "SKEW";
93 case TRANSLATE: return "TRANSLATE";
robertphillips@google.come7189be2013-02-15 17:19:15 +0000[diff] [blame]94 case NOOP: return "NOOP";
reed@google.com91911482011-02-07 15:30:46 +0000[diff] [blame]95 default:
96 SkDebugf("DrawType error 0x%08x\n", drawType);
97 SkASSERT(0);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]98 break;
99 }
reed@google.com91911482011-02-07 15:30:46 +0000[diff] [blame]100 SkASSERT(0);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]101 return NULL;
102}
103#endif
104
105#ifdef SK_DEBUG_VALIDATE
106static void validateMatrix(const SkMatrix* matrix) {
107 SkScalar scaleX = matrix->getScaleX();
108 SkScalar scaleY = matrix->getScaleY();
109 SkScalar skewX = matrix->getSkewX();
110 SkScalar skewY = matrix->getSkewY();
111 SkScalar perspX = matrix->getPerspX();
112 SkScalar perspY = matrix->getPerspY();
113 if (scaleX != 0 && skewX != 0)
114 SkDebugf("scaleX != 0 && skewX != 0\n");
115 SkASSERT(scaleX == 0 || skewX == 0);
116 SkASSERT(scaleY == 0 || skewY == 0);
117 SkASSERT(perspX == 0);
118 SkASSERT(perspY == 0);
119}
120#endif
121
122
123///////////////////////////////////////////////////////////////////////////////
124
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]125SkPicture::SkPicture()
126 : fAccelData(NULL) {
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]127 this->needsNewGenID();
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]128 fRecord = NULL;
129 fPlayback = NULL;
130 fWidth = fHeight = 0;
131}
132
skia.committer@gmail.com8b5598b2014-03-17 03:02:17 +0000[diff] [blame]133SkPicture::SkPicture(const SkPicture& src)
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]134 : INHERITED()
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]135 , fAccelData(NULL)
136 , fContentInfo(src.fContentInfo) {
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]137 this->needsNewGenID();
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]138 fWidth = src.fWidth;
139 fHeight = src.fHeight;
140 fRecord = NULL;
141
142 /* We want to copy the src's playback. However, if that hasn't been built
143 yet, we need to fake a call to endRecording() without actually calling
144 it (since it is destructive, and we don't want to change src).
145 */
146 if (src.fPlayback) {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]147 fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, *src.fPlayback));
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]148 SkASSERT(NULL == src.fRecord);
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]149 fUniqueID = src.uniqueID(); // need to call method to ensure != 0
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]150 } else if (src.fRecord) {
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]151 SkPictInfo info;
152 this->createHeader(&info);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]153 // here we do a fake src.endRecording()
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]154 fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, *src.fRecord, info));
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]155 } else {
156 fPlayback = NULL;
157 }
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]158
159 fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
160}
161
162const SkPath& SkPicture::getPath(int index) const {
163 return (*fPathHeap.get())[index];
164}
165
166int SkPicture::addPathToHeap(const SkPath& path) {
167 if (NULL == fPathHeap) {
168 fPathHeap.reset(SkNEW(SkPathHeap));
169 }
170#ifdef SK_DEDUP_PICTURE_PATHS
171 return fPathHeap->insert(path);
172#else
173 return fPathHeap->append(path);
174#endif
175}
176
177void SkPicture::initForPlayback() const {
178 // ensure that the paths bounds are pre-computed
179 if (NULL != fPathHeap.get()) {
180 for (int i = 0; i < fPathHeap->count(); i++) {
181 (*fPathHeap.get())[i].updateBoundsCache();
182 }
183 }
184}
185
186void SkPicture::dumpSize() const {
187 SkDebugf("--- picture size: paths=%d\n",
188 SafeCount(fPathHeap.get()));
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]189}
190
191SkPicture::~SkPicture() {
reed@google.com91911482011-02-07 15:30:46 +0000[diff] [blame]192 SkSafeUnref(fRecord);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]193 SkDELETE(fPlayback);
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]194 SkSafeUnref(fAccelData);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]195}
196
commit-bot@chromium.orge6e785e2014-03-04 19:08:57 +0000[diff] [blame]197void SkPicture::internalOnly_EnableOpts(bool enableOpts) {
198 if (NULL != fRecord) {
199 fRecord->internalOnly_EnableOpts(enableOpts);
200 }
201}
202
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]203void SkPicture::swap(SkPicture& other) {
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]204 SkTSwap(fUniqueID, other.fUniqueID);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]205 SkTSwap(fRecord, other.fRecord);
206 SkTSwap(fPlayback, other.fPlayback);
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]207 SkTSwap(fAccelData, other.fAccelData);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]208 SkTSwap(fWidth, other.fWidth);
209 SkTSwap(fHeight, other.fHeight);
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]210 fPathHeap.swap(&other.fPathHeap);
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]211 fContentInfo.swap(&other.fContentInfo);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]212}
213
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]214SkPicture* SkPicture::clone() const {
215 SkPicture* clonedPicture = SkNEW(SkPicture);
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]216 this->clone(clonedPicture, 1);
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]217 return clonedPicture;
218}
219
commit-bot@chromium.orgf143d1b2014-04-29 17:22:54 +0000[diff] [blame]220static bool needs_deep_copy(const SkPaint& paint) {
221 /*
222 * These fields are known to be immutable, and so can be shallow-copied
223 *
224 * getTypeface()
225 * getAnnotation()
226 * paint.getColorFilter()
227 * getXfermode()
228 * getPathEffect()
229 * getMaskFilter()
230 */
231
232 return paint.getShader() ||
233#ifdef SK_SUPPORT_LEGACY_LAYERRASTERIZER_API
234 paint.getRasterizer() ||
235#endif
236 paint.getLooper() || // needs to hide its addLayer...
237 paint.getImageFilter();
238}
239
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]240void SkPicture::clone(SkPicture* pictures, int count) const {
241 SkPictCopyInfo copyInfo;
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]242 SkPictInfo info;
243 this->createHeader(&info);
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]244
245 for (int i = 0; i < count; i++) {
246 SkPicture* clone = &pictures[i];
247
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]248 clone->needsNewGenID();
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]249 clone->fWidth = fWidth;
250 clone->fHeight = fHeight;
commit-bot@chromium.orgefea6992014-02-14 17:27:10 +0000[diff] [blame]251 SkSafeSetNull(clone->fRecord);
scroggo@google.coma0dd4332012-11-02 20:51:19 +0000[diff] [blame]252 SkDELETE(clone->fPlayback);
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]253 clone->fContentInfo.set(fContentInfo);
scroggo@google.coma0dd4332012-11-02 20:51:19 +0000[diff] [blame]254
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]255 /* We want to copy the src's playback. However, if that hasn't been built
256 yet, we need to fake a call to endRecording() without actually calling
257 it (since it is destructive, and we don't want to change src).
258 */
259 if (fPlayback) {
commit-bot@chromium.orgf143d1b2014-04-29 17:22:54 +0000[diff] [blame]260 if (!copyInfo.initialized) {
261 int paintCount = SafeCount(fPlayback->fPaints);
262
263 /* The alternative to doing this is to have a clone method on the paint and have it
264 * make the deep copy of its internal structures as needed. The holdup to doing
skia.committer@gmail.com87e78422014-04-30 03:05:25 +0000[diff] [blame]265 * that is at this point we would need to pass the SkBitmapHeap so that we don't
commit-bot@chromium.orgf143d1b2014-04-29 17:22:54 +0000[diff] [blame]266 * unnecessarily flatten the pixels in a bitmap shader.
267 */
268 copyInfo.paintData.setCount(paintCount);
269
skia.committer@gmail.com87e78422014-04-30 03:05:25 +0000[diff] [blame]270 /* Use an SkBitmapHeap to avoid flattening bitmaps in shaders. If there already is
271 * one, use it. If this SkPicturePlayback was created from a stream, fBitmapHeap
commit-bot@chromium.orgf143d1b2014-04-29 17:22:54 +0000[diff] [blame]272 * will be NULL, so create a new one.
273 */
274 if (fPlayback->fBitmapHeap.get() == NULL) {
275 // FIXME: Put this on the stack inside SkPicture::clone.
276 SkBitmapHeap* heap = SkNEW(SkBitmapHeap);
277 copyInfo.controller.setBitmapStorage(heap);
278 heap->unref();
279 } else {
280 copyInfo.controller.setBitmapStorage(fPlayback->fBitmapHeap);
281 }
282
283 SkDEBUGCODE(int heapSize = SafeCount(fPlayback->fBitmapHeap.get());)
284 for (int i = 0; i < paintCount; i++) {
285 if (needs_deep_copy(fPlayback->fPaints->at(i))) {
286 copyInfo.paintData[i] =
287 SkFlatData::Create<SkPaint::FlatteningTraits>(&copyInfo.controller,
288 fPlayback->fPaints->at(i), 0);
289
290 } else {
291 // this is our sentinel, which we use in the unflatten loop
292 copyInfo.paintData[i] = NULL;
293 }
294 }
295 SkASSERT(SafeCount(fPlayback->fBitmapHeap.get()) == heapSize);
296
297 // needed to create typeface playback
298 copyInfo.controller.setupPlaybacks();
299 copyInfo.initialized = true;
300 }
301
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]302 clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (clone, *fPlayback, &copyInfo));
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]303 SkASSERT(NULL == fRecord);
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]304 clone->fUniqueID = this->uniqueID(); // need to call method to ensure != 0
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]305 } else if (fRecord) {
306 // here we do a fake src.endRecording()
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]307 clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (clone, *fRecord, info, true));
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]308 } else {
309 clone->fPlayback = NULL;
310 }
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]311
312 clone->fPathHeap.reset(SkSafeRef(fPathHeap.get()));
djsollen@google.com3855f872012-08-29 18:52:07 +0000[diff] [blame]313 }
314}
315
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]316SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
317 static int32_t gNextID = 0;
318
319 int32_t id = sk_atomic_inc(&gNextID);
320 if (id >= 1 << (8 * sizeof(Domain))) {
321 SK_CRASH();
322 }
323
324 return static_cast<Domain>(id);
325}
326
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]327///////////////////////////////////////////////////////////////////////////////
328
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]329#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
330
reed@android.comc4a55d72009-02-13 14:56:09 +0000[diff] [blame]331SkCanvas* SkPicture::beginRecording(int width, int height,
332 uint32_t recordingFlags) {
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]333 if (fPlayback) {
334 SkDELETE(fPlayback);
335 fPlayback = NULL;
336 }
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]337 SkSafeUnref(fAccelData);
commit-bot@chromium.orgefea6992014-02-14 17:27:10 +0000[diff] [blame]338 SkSafeSetNull(fRecord);
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]339 fContentInfo.reset();
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]340
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]341 this->needsNewGenID();
342
junov@chromium.orgbb78c442012-11-01 17:10:32 +0000[diff] [blame]343 // Must be set before calling createBBoxHierarchy
344 fWidth = width;
345 fHeight = height;
346
commit-bot@chromium.orgca101d62014-02-17 15:28:00 +0000[diff] [blame]347 const SkISize size = SkISize::Make(width, height);
348
rileya@google.com7fb3d2f2012-09-13 21:41:51 +0000[diff] [blame]349 if (recordingFlags & kOptimizeForClippedPlayback_RecordingFlag) {
junov@chromium.orgbb78c442012-11-01 17:10:32 +0000[diff] [blame]350 SkBBoxHierarchy* tree = this->createBBoxHierarchy();
rileya@google.com7fb3d2f2012-09-13 21:41:51 +0000[diff] [blame]351 SkASSERT(NULL != tree);
robertphillips@google.com7c64bc92014-04-24 00:42:23 +0000[diff] [blame]352 fRecord = SkNEW_ARGS(SkBBoxHierarchyRecord, (this, size, recordingFlags, tree));
rileya@google.com7fb3d2f2012-09-13 21:41:51 +0000[diff] [blame]353 tree->unref();
354 } else {
robertphillips@google.com7c64bc92014-04-24 00:42:23 +0000[diff] [blame]355 fRecord = SkNEW_ARGS(SkPictureRecord, (this, size, recordingFlags));
rileya@google.com7fb3d2f2012-09-13 21:41:51 +0000[diff] [blame]356 }
reed@google.com118a6d02012-09-27 20:31:31 +0000[diff] [blame]357 fRecord->beginRecording();
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]358
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]359 return fRecord;
360}
361
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]362#endif
363
skia.committer@gmail.com0f1b1d62014-04-18 03:03:54 +0000[diff] [blame]364SkCanvas* SkPicture::beginRecording(int width, int height,
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]365 SkBBHFactory* bbhFactory,
366 uint32_t recordingFlags) {
367 if (fPlayback) {
368 SkDELETE(fPlayback);
369 fPlayback = NULL;
370 }
371 SkSafeUnref(fAccelData);
372 SkSafeSetNull(fRecord);
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]373 SkASSERT(NULL == fPathHeap);
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]374 fContentInfo.reset();
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]375
376 this->needsNewGenID();
377
378 fWidth = width;
379 fHeight = height;
380
381 const SkISize size = SkISize::Make(width, height);
382
383 if (NULL != bbhFactory) {
384 SkAutoTUnref<SkBBoxHierarchy> tree((*bbhFactory)(width, height));
385 SkASSERT(NULL != tree);
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]386 fRecord = SkNEW_ARGS(SkBBoxHierarchyRecord, (this, size,
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]387 recordingFlags|
388 kOptimizeForClippedPlayback_RecordingFlag,
389 tree.get()));
390 } else {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]391 fRecord = SkNEW_ARGS(SkPictureRecord, (this, size, recordingFlags));
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]392 }
393 fRecord->beginRecording();
394
395 return fRecord;
396}
397
398
399#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
400
junov@chromium.orgbb78c442012-11-01 17:10:32 +0000[diff] [blame]401SkBBoxHierarchy* SkPicture::createBBoxHierarchy() const {
commit-bot@chromium.orgfd73c592014-04-16 16:02:10 +0000[diff] [blame]402 // TODO: this code is now replicated in SkRTreePicture. Once all external
403 // clients have been weaned off of kOptimizeForClippedPlayback_RecordingFlag,
404 // this code can be removed.
405
skia.committer@gmail.com8d230dd2012-11-02 02:01:24 +0000[diff] [blame]406 // These values were empirically determined to produce reasonable
junov@chromium.orgbb78c442012-11-01 17:10:32 +0000[diff] [blame]407 // performance in most cases.
408 static const int kRTreeMinChildren = 6;
409 static const int kRTreeMaxChildren = 11;
410
411 SkScalar aspectRatio = SkScalarDiv(SkIntToScalar(fWidth),
412 SkIntToScalar(fHeight));
sglez@google.com9baab6f2013-08-30 17:27:47 +0000[diff] [blame]413 bool sortDraws = false; // Do not sort draw calls when bulk loading.
414
junov@chromium.orgbb78c442012-11-01 17:10:32 +0000[diff] [blame]415 return SkRTree::Create(kRTreeMinChildren, kRTreeMaxChildren,
sglez@google.com9baab6f2013-08-30 17:27:47 +0000[diff] [blame]416 aspectRatio, sortDraws);
junov@chromium.orgbb78c442012-11-01 17:10:32 +0000[diff] [blame]417}
418
commit-bot@chromium.org48da8612014-04-17 23:35:06 +0000[diff] [blame]419#endif
420
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]421SkCanvas* SkPicture::getRecordingCanvas() const {
422 // will be null if we are not recording
423 return fRecord;
424}
425
426void SkPicture::endRecording() {
427 if (NULL == fPlayback) {
428 if (NULL != fRecord) {
junov@chromium.org9aa18db2012-07-12 17:47:34 +0000[diff] [blame]429 fRecord->endRecording();
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]430 SkPictInfo info;
431 this->createHeader(&info);
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]432 fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, *fRecord, info));
commit-bot@chromium.orgefea6992014-02-14 17:27:10 +0000[diff] [blame]433 SkSafeSetNull(fRecord);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]434 }
435 }
436 SkASSERT(NULL == fRecord);
437}
438
commit-bot@chromium.org4b918972014-03-18 17:45:32 +0000[diff] [blame]439const SkPicture::OperationList& SkPicture::OperationList::InvalidList() {
440 static OperationList gInvalid;
441 return gInvalid;
442}
443
444const SkPicture::OperationList& SkPicture::EXPERIMENTAL_getActiveOps(const SkIRect& queryRect) {
robertphillips@google.com6dd381b2014-04-13 19:09:42 +0000[diff] [blame]445 this->endRecording(); // TODO: remove eventually
commit-bot@chromium.org4b918972014-03-18 17:45:32 +0000[diff] [blame]446 if (NULL != fPlayback) {
447 return fPlayback->getActiveOps(queryRect);
448 }
449 return OperationList::InvalidList();
450}
451
commit-bot@chromium.org0ea71132014-03-24 19:40:49 +0000[diff] [blame]452size_t SkPicture::EXPERIMENTAL_curOpID() const {
453 if (NULL != fPlayback) {
454 return fPlayback->curOpID();
455 }
456 return 0;
457}
458
reed@google.com2b3a5082013-05-20 17:02:41 +0000[diff] [blame]459void SkPicture::draw(SkCanvas* surface, SkDrawPictureCallback* callback) {
robertphillips@google.com6dd381b2014-04-13 19:09:42 +0000[diff] [blame]460 this->endRecording(); // TODO: remove eventually
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]461 if (NULL != fPlayback) {
reed@google.com2b3a5082013-05-20 17:02:41 +0000[diff] [blame]462 fPlayback->draw(*surface, callback);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]463 }
464}
465
466///////////////////////////////////////////////////////////////////////////////
467
468#include "SkStream.h"
469
rmistry@google.com8793ad72013-12-02 13:50:38 +0000[diff] [blame]470static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
commit-bot@chromium.org060e3a52014-03-12 14:46:41 +0000[diff] [blame]471
472bool SkPicture::IsValidPictInfo(const SkPictInfo& info) {
473 if (0 != memcmp(info.fMagic, kMagic, sizeof(kMagic))) {
474 return false;
475 }
476
477 if (info.fVersion < MIN_PICTURE_VERSION ||
478 info.fVersion > CURRENT_PICTURE_VERSION) {
479 return false;
480 }
481
482 return true;
483}
rmistry@google.com8793ad72013-12-02 13:50:38 +0000[diff] [blame]484
commit-bot@chromium.orgabad6d62014-03-03 19:18:39 +0000[diff] [blame]485bool SkPicture::InternalOnly_StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) {
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]486 if (NULL == stream) {
487 return false;
borenet@google.com30dda202012-09-17 18:26:06 +0000[diff] [blame]488 }
reed@google.com4bca7f62012-06-22 15:38:39 +0000[diff] [blame]489
rmistry@google.com8793ad72013-12-02 13:50:38 +0000[diff] [blame]490 // Check magic bytes.
reed@google.com4bca7f62012-06-22 15:38:39 +0000[diff] [blame]491 SkPictInfo info;
commit-bot@chromium.org060e3a52014-03-12 14:46:41 +0000[diff] [blame]492 SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
493 if (!stream->read(&info, sizeof(info)) || !IsValidPictInfo(info)) {
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]494 return false;
reed@google.com4bca7f62012-06-22 15:38:39 +0000[diff] [blame]495 }
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]496
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]497 if (pInfo != NULL) {
498 *pInfo = info;
499 }
500 return true;
501}
502
commit-bot@chromium.orgabad6d62014-03-03 19:18:39 +0000[diff] [blame]503bool SkPicture::InternalOnly_BufferIsSKP(SkReadBuffer& buffer, SkPictInfo* pInfo) {
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]504 // Check magic bytes.
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]505 SkPictInfo info;
commit-bot@chromium.org060e3a52014-03-12 14:46:41 +0000[diff] [blame]506 SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
507 if (!buffer.readByteArray(&info, sizeof(info)) || !IsValidPictInfo(info)) {
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]508 return false;
509 }
510
511 if (pInfo != NULL) {
512 *pInfo = info;
513 }
514 return true;
515}
516
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]517SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
518 : fPlayback(playback)
519 , fRecord(NULL)
520 , fWidth(width)
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]521 , fHeight(height)
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]522 , fAccelData(NULL) {
523 this->needsNewGenID();
524}
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]525
526SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
527 SkPictInfo info;
528
commit-bot@chromium.orgabad6d62014-03-03 19:18:39 +0000[diff] [blame]529 if (!InternalOnly_StreamIsSKP(stream, &info)) {
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]530 return NULL;
531 }
532
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]533 SkPicture* newPict = SkNEW_ARGS(SkPicture, (NULL, info.fWidth, info.fHeight));
534
scroggo@google.com3b990302013-06-28 21:32:00 +0000[diff] [blame]535 // Check to see if there is a playback to recreate.
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]536 if (stream->readBool()) {
skia.committer@gmail.com88c3a5d2014-04-24 03:05:07 +0000[diff] [blame]537 SkPicturePlayback* playback = SkPicturePlayback::CreateFromStream(newPict, stream,
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]538 info, proc);
scroggo@google.com3b7431c2013-10-01 15:30:46 +0000[diff] [blame]539 if (NULL == playback) {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]540 SkDELETE(newPict);
scroggo@google.com3b7431c2013-10-01 15:30:46 +0000[diff] [blame]541 return NULL;
542 }
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]543 newPict->fPlayback = playback;
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]544 }
reed@google.com4bca7f62012-06-22 15:38:39 +0000[diff] [blame]545
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]546 return newPict;
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]547}
548
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]549SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
550 SkPictInfo info;
551
commit-bot@chromium.orgabad6d62014-03-03 19:18:39 +0000[diff] [blame]552 if (!InternalOnly_BufferIsSKP(buffer, &info)) {
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]553 return NULL;
554 }
555
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]556 SkPicture* newPict = SkNEW_ARGS(SkPicture, (NULL, info.fWidth, info.fHeight));
557
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]558 // Check to see if there is a playback to recreate.
559 if (buffer.readBool()) {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]560 SkPicturePlayback* playback = SkPicturePlayback::CreateFromBuffer(newPict, buffer, info);
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]561 if (NULL == playback) {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]562 SkDELETE(newPict);
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]563 return NULL;
564 }
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]565 newPict->fPlayback = playback;
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]566 }
567
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]568 return newPict;
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]569}
570
commit-bot@chromium.org060e3a52014-03-12 14:46:41 +0000[diff] [blame]571void SkPicture::createHeader(SkPictInfo* info) const {
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]572 // Copy magic bytes at the beginning of the header
573 SkASSERT(sizeof(kMagic) == 8);
commit-bot@chromium.org060e3a52014-03-12 14:46:41 +0000[diff] [blame]574 SkASSERT(sizeof(kMagic) == sizeof(info->fMagic));
575 memcpy(info->fMagic, kMagic, sizeof(kMagic));
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]576
commit-bot@chromium.orgabad6d62014-03-03 19:18:39 +0000[diff] [blame]577 // Set picture info after magic bytes in the header
commit-bot@chromium.org338284f2014-02-25 02:16:10 +0000[diff] [blame]578 info->fVersion = CURRENT_PICTURE_VERSION;
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]579 info->fWidth = fWidth;
580 info->fHeight = fHeight;
581 info->fFlags = SkPictInfo::kCrossProcess_Flag;
582 // TODO: remove this flag, since we're always float (now)
583 info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
584
585 if (8 == sizeof(void*)) {
586 info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
587 }
588}
589
scroggo@google.com2e727312013-02-22 22:04:19 +0000[diff] [blame]590void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]591 SkPicturePlayback* playback = fPlayback;
reed@google.com91911482011-02-07 15:30:46 +0000[diff] [blame]592
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]593 SkPictInfo info;
594 this->createHeader(&info);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]595 if (NULL == playback && fRecord) {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]596 playback = SkNEW_ARGS(SkPicturePlayback, (this, *fRecord, info));
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]597 }
598
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]599 stream->write(&info, sizeof(info));
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]600 if (playback) {
601 stream->writeBool(true);
scroggo@google.com6ff73172012-10-04 21:46:08 +0000[diff] [blame]602 playback->serialize(stream, encoder);
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]603 // delete playback if it is a local version (i.e. cons'd up just now)
604 if (playback != fPlayback) {
605 SkDELETE(playback);
606 }
607 } else {
608 stream->writeBool(false);
609 }
610}
611
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]612void SkPicture::WriteTagSize(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
613 buffer.writeUInt(tag);
614 buffer.writeUInt(SkToU32(size));
615}
616
617void SkPicture::WriteTagSize(SkWStream* stream, uint32_t tag, size_t size) {
618 stream->write32(tag);
619 stream->write32(SkToU32(size));
620}
621
622bool SkPicture::parseBufferTag(SkReadBuffer& buffer,
skia.committer@gmail.com88c3a5d2014-04-24 03:05:07 +0000[diff] [blame]623 uint32_t tag,
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]624 uint32_t size) {
625 switch (tag) {
626 case SK_PICT_PATH_BUFFER_TAG:
627 if (size > 0) {
628 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
629 }
630 break;
631 default:
632 // The tag was invalid.
633 return false;
634 }
635
636 return true; // success
637}
638
639void SkPicture::flattenToBuffer(SkWriteBuffer& buffer) const {
640 int n;
641
642 if ((n = SafeCount(fPathHeap.get())) > 0) {
643 WriteTagSize(buffer, SK_PICT_PATH_BUFFER_TAG, n);
644 fPathHeap->flatten(buffer);
645 }
646}
647
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]648void SkPicture::flatten(SkWriteBuffer& buffer) const {
649 SkPicturePlayback* playback = fPlayback;
650
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]651 SkPictInfo info;
652 this->createHeader(&info);
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]653 if (NULL == playback && fRecord) {
commit-bot@chromium.orgfc486cd2014-04-23 22:35:42 +0000[diff] [blame]654 playback = SkNEW_ARGS(SkPicturePlayback, (this, *fRecord, info));
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]655 }
656
commit-bot@chromium.org206dc582014-03-28 18:05:47 +0000[diff] [blame]657 buffer.writeByteArray(&info, sizeof(info));
commit-bot@chromium.org7183ff62014-02-07 12:20:04 +0000[diff] [blame]658 if (playback) {
659 buffer.writeBool(true);
660 playback->flatten(buffer);
661 // delete playback if it is a local version (i.e. cons'd up just now)
662 if (playback != fPlayback) {
663 SkDELETE(playback);
664 }
665 } else {
666 buffer.writeBool(false);
667 }
668}
669
commit-bot@chromium.org05937b42014-03-19 22:54:40 +0000[diff] [blame]670#if SK_SUPPORT_GPU
commit-bot@chromium.org95cdc162014-03-19 21:24:25 +0000[diff] [blame]671bool SkPicture::suitableForGpuRasterization(GrContext* context) const {
commit-bot@chromium.org7a1832f2014-04-24 21:53:13 +0000[diff] [blame]672 // TODO: the heuristic used here needs to be refined
673 static const int kNumPaintWithPathEffectUsesTol = 1;
674 static const int kNumAAConcavePaths = 5;
675
676 SkASSERT(this->numAAHairlineConcavePaths() <= this->numAAConcavePaths());
677
678 return this->numPaintWithPathEffectUses() < kNumPaintWithPathEffectUsesTol &&
679 (this->numAAConcavePaths()-this->numAAHairlineConcavePaths()) < kNumAAConcavePaths;
commit-bot@chromium.org95cdc162014-03-19 21:24:25 +0000[diff] [blame]680}
commit-bot@chromium.org05937b42014-03-19 22:54:40 +0000[diff] [blame]681#endif
commit-bot@chromium.org95cdc162014-03-19 21:24:25 +0000[diff] [blame]682
tomhudson@google.comc7941702013-10-24 11:12:47 +0000[diff] [blame]683bool SkPicture::willPlayBackBitmaps() const {
commit-bot@chromium.org73857a32014-03-16 19:46:36 +0000[diff] [blame]684 if (!fPlayback) {
685 return false;
686 }
tomhudson@google.comc7941702013-10-24 11:12:47 +0000[diff] [blame]687 return fPlayback->containsBitmaps();
688}
689
djsollen@google.com6789a342013-02-01 16:18:09 +0000[diff] [blame]690#ifdef SK_BUILD_FOR_ANDROID
reed@android.combcd4d5a2008-12-17 15:59:43 +0000[diff] [blame]691void SkPicture::abortPlayback() {
692 if (NULL == fPlayback) {
693 return;
694 }
695 fPlayback->abort();
696}
djsollen@google.com6789a342013-02-01 16:18:09 +0000[diff] [blame]697#endif
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]698
699static int32_t next_picture_generation_id() {
700 static int32_t gPictureGenerationID = 0;
701 // do a loop in case our global wraps around, as we never want to
702 // return a 0
703 int32_t genID;
704 do {
705 genID = sk_atomic_inc(&gPictureGenerationID) + 1;
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]706 } while (SK_InvalidGenID == genID);
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]707 return genID;
708}
709
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]710uint32_t SkPicture::uniqueID() const {
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]711 if (NULL != fRecord) {
712 SkASSERT(NULL == fPlayback);
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]713 return SK_InvalidGenID;
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]714 }
715
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]716 if (SK_InvalidGenID == fUniqueID) {
717 fUniqueID = next_picture_generation_id();
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]718 }
commit-bot@chromium.orgb50bcb92014-04-07 18:26:22 +0000[diff] [blame]719 return fUniqueID;
robertphillips@google.com647fe7f2014-04-02 23:51:13 +0000[diff] [blame]720}