• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2014 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 #include "SkBigPicture.h"
9 #include "SkData.h"
10 #include "SkDrawable.h"
11 #include "SkMiniRecorder.h"
12 #include "SkPictureRecorder.h"
13 #include "SkRecord.h"
14 #include "SkRecordDraw.h"
15 #include "SkRecordOpts.h"
16 #include "SkRecordedDrawable.h"
17 #include "SkRecorder.h"
18 #include "SkTypes.h"
19 
SkPictureRecorder()20 SkPictureRecorder::SkPictureRecorder() {
21     fActivelyRecording = false;
22     fMiniRecorder.reset(new SkMiniRecorder);
23     fRecorder.reset(new SkRecorder(nullptr, SkRect::MakeEmpty(), fMiniRecorder.get()));
24 }
25 
~SkPictureRecorder()26 SkPictureRecorder::~SkPictureRecorder() {}
27 
beginRecording(const SkRect & userCullRect,SkBBHFactory * bbhFactory,uint32_t recordFlags)28 SkCanvas* SkPictureRecorder::beginRecording(const SkRect& userCullRect,
29                                             SkBBHFactory* bbhFactory /* = nullptr */,
30                                             uint32_t recordFlags /* = 0 */) {
31     const SkRect cullRect = userCullRect.isEmpty() ? SkRect::MakeEmpty() : userCullRect;
32 
33     fCullRect = cullRect;
34     fFlags = recordFlags;
35 
36     if (bbhFactory) {
37         fBBH.reset((*bbhFactory)(cullRect));
38         SkASSERT(fBBH.get());
39     }
40 
41     if (!fRecord) {
42         fRecord.reset(new SkRecord);
43     }
44     SkRecorder::DrawPictureMode dpm = (recordFlags & kPlaybackDrawPicture_RecordFlag)
45         ? SkRecorder::Playback_DrawPictureMode
46         : SkRecorder::Record_DrawPictureMode;
47     fRecorder->reset(fRecord.get(), cullRect, dpm, fMiniRecorder.get());
48     fActivelyRecording = true;
49     return this->getRecordingCanvas();
50 }
51 
getRecordingCanvas()52 SkCanvas* SkPictureRecorder::getRecordingCanvas() {
53     return fActivelyRecording ? fRecorder.get() : nullptr;
54 }
55 
finishRecordingAsPicture(uint32_t finishFlags)56 sk_sp<SkPicture> SkPictureRecorder::finishRecordingAsPicture(uint32_t finishFlags) {
57     fActivelyRecording = false;
58     fRecorder->restoreToCount(1);  // If we were missing any restores, add them now.
59 
60     if (fRecord->count() == 0) {
61         auto pic = fMiniRecorder->detachAsPicture(fBBH ? nullptr : &fCullRect);
62         fBBH.reset(nullptr);
63         return pic;
64     }
65 
66     // TODO: delay as much of this work until just before first playback?
67     SkRecordOptimize(fRecord.get());
68 
69     SkDrawableList* drawableList = fRecorder->getDrawableList();
70     SkBigPicture::SnapshotArray* pictList =
71         drawableList ? drawableList->newDrawableSnapshot() : nullptr;
72 
73     if (fBBH.get()) {
74         SkAutoTMalloc<SkRect> bounds(fRecord->count());
75         SkRecordFillBounds(fCullRect, *fRecord, bounds);
76         fBBH->insert(bounds, fRecord->count());
77 
78         // Now that we've calculated content bounds, we can update fCullRect, often trimming it.
79         // TODO: get updated fCullRect from bounds instead of forcing the BBH to return it?
80         SkRect bbhBound = fBBH->getRootBound();
81         SkASSERT((bbhBound.isEmpty() || fCullRect.contains(bbhBound))
82             || (bbhBound.isEmpty() && fCullRect.isEmpty()));
83         fCullRect = bbhBound;
84     }
85 
86     size_t subPictureBytes = fRecorder->approxBytesUsedBySubPictures();
87     for (int i = 0; pictList && i < pictList->count(); i++) {
88         subPictureBytes += pictList->begin()[i]->approximateBytesUsed();
89     }
90     return sk_make_sp<SkBigPicture>(fCullRect, fRecord.release(), pictList, fBBH.release(),
91                                     subPictureBytes);
92 }
93 
finishRecordingAsPictureWithCull(const SkRect & cullRect,uint32_t finishFlags)94 sk_sp<SkPicture> SkPictureRecorder::finishRecordingAsPictureWithCull(const SkRect& cullRect,
95                                                                      uint32_t finishFlags) {
96     fCullRect = cullRect;
97     return this->finishRecordingAsPicture(finishFlags);
98 }
99 
100 
partialReplay(SkCanvas * canvas) const101 void SkPictureRecorder::partialReplay(SkCanvas* canvas) const {
102     if (nullptr == canvas) {
103         return;
104     }
105 
106     int drawableCount = 0;
107     SkDrawable* const* drawables = nullptr;
108     SkDrawableList* drawableList = fRecorder->getDrawableList();
109     if (drawableList) {
110         drawableCount = drawableList->count();
111         drawables = drawableList->begin();
112     }
113     SkRecordDraw(*fRecord, canvas, nullptr, drawables, drawableCount, nullptr/*bbh*/, nullptr/*callback*/);
114 }
115 
finishRecordingAsDrawable(uint32_t finishFlags)116 sk_sp<SkDrawable> SkPictureRecorder::finishRecordingAsDrawable(uint32_t finishFlags) {
117     fActivelyRecording = false;
118     fRecorder->flushMiniRecorder();
119     fRecorder->restoreToCount(1);  // If we were missing any restores, add them now.
120 
121     SkRecordOptimize(fRecord.get());
122 
123     if (fBBH.get()) {
124         SkAutoTMalloc<SkRect> bounds(fRecord->count());
125         SkRecordFillBounds(fCullRect, *fRecord, bounds);
126         fBBH->insert(bounds, fRecord->count());
127     }
128 
129     sk_sp<SkDrawable> drawable =
130          sk_make_sp<SkRecordedDrawable>(std::move(fRecord), std::move(fBBH),
131                                         fRecorder->detachDrawableList(), fCullRect);
132 
133     return drawable;
134 }
135