1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #undef LOG_TAG
18 #define LOG_TAG "BLASTBufferQueue"
19
20 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
21
22 #include <gui/BLASTBufferQueue.h>
23 #include <gui/BufferItemConsumer.h>
24 #include <gui/GLConsumer.h>
25
26 #include <utils/Trace.h>
27
28 #include <chrono>
29
30 using namespace std::chrono_literals;
31
32 namespace android {
33
onDisconnect()34 void BLASTBufferItemConsumer::onDisconnect() {
35 Mutex::Autolock lock(mFrameEventHistoryMutex);
36 mPreviouslyConnected = mCurrentlyConnected;
37 mCurrentlyConnected = false;
38 if (mPreviouslyConnected) {
39 mDisconnectEvents.push(mCurrentFrameNumber);
40 }
41 mFrameEventHistory.onDisconnect();
42 }
43
addAndGetFrameTimestamps(const NewFrameEventsEntry * newTimestamps,FrameEventHistoryDelta * outDelta)44 void BLASTBufferItemConsumer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps,
45 FrameEventHistoryDelta* outDelta) {
46 Mutex::Autolock lock(mFrameEventHistoryMutex);
47 if (newTimestamps) {
48 // BufferQueueProducer only adds a new timestamp on
49 // queueBuffer
50 mCurrentFrameNumber = newTimestamps->frameNumber;
51 mFrameEventHistory.addQueue(*newTimestamps);
52 }
53 if (outDelta) {
54 // frame event histories will be processed
55 // only after the producer connects and requests
56 // deltas for the first time. Forward this intent
57 // to SF-side to turn event processing back on
58 mPreviouslyConnected = mCurrentlyConnected;
59 mCurrentlyConnected = true;
60 mFrameEventHistory.getAndResetDelta(outDelta);
61 }
62 }
63
updateFrameTimestamps(uint64_t frameNumber,nsecs_t refreshStartTime,const sp<Fence> & glDoneFence,const sp<Fence> & presentFence,const sp<Fence> & prevReleaseFence,CompositorTiming compositorTiming,nsecs_t latchTime,nsecs_t dequeueReadyTime)64 void BLASTBufferItemConsumer::updateFrameTimestamps(uint64_t frameNumber, nsecs_t refreshStartTime,
65 const sp<Fence>& glDoneFence,
66 const sp<Fence>& presentFence,
67 const sp<Fence>& prevReleaseFence,
68 CompositorTiming compositorTiming,
69 nsecs_t latchTime, nsecs_t dequeueReadyTime) {
70 Mutex::Autolock lock(mFrameEventHistoryMutex);
71
72 // if the producer is not connected, don't bother updating,
73 // the next producer that connects won't access this frame event
74 if (!mCurrentlyConnected) return;
75 std::shared_ptr<FenceTime> glDoneFenceTime = std::make_shared<FenceTime>(glDoneFence);
76 std::shared_ptr<FenceTime> presentFenceTime = std::make_shared<FenceTime>(presentFence);
77 std::shared_ptr<FenceTime> releaseFenceTime = std::make_shared<FenceTime>(prevReleaseFence);
78
79 mFrameEventHistory.addLatch(frameNumber, latchTime);
80 mFrameEventHistory.addRelease(frameNumber, dequeueReadyTime, std::move(releaseFenceTime));
81 mFrameEventHistory.addPreComposition(frameNumber, refreshStartTime);
82 mFrameEventHistory.addPostComposition(frameNumber, glDoneFenceTime, presentFenceTime,
83 compositorTiming);
84 }
85
getConnectionEvents(uint64_t frameNumber,bool * needsDisconnect)86 void BLASTBufferItemConsumer::getConnectionEvents(uint64_t frameNumber, bool* needsDisconnect) {
87 bool disconnect = false;
88 Mutex::Autolock lock(mFrameEventHistoryMutex);
89 while (!mDisconnectEvents.empty() && mDisconnectEvents.front() <= frameNumber) {
90 disconnect = true;
91 mDisconnectEvents.pop();
92 }
93 if (needsDisconnect != nullptr) *needsDisconnect = disconnect;
94 }
95
BLASTBufferQueue(const sp<SurfaceControl> & surface,int width,int height,bool enableTripleBuffering)96 BLASTBufferQueue::BLASTBufferQueue(const sp<SurfaceControl>& surface, int width, int height,
97 bool enableTripleBuffering)
98 : mSurfaceControl(surface),
99 mWidth(width),
100 mHeight(height),
101 mNextTransaction(nullptr) {
102 BufferQueue::createBufferQueue(&mProducer, &mConsumer);
103 // since the adapter is in the client process, set dequeue timeout
104 // explicitly so that dequeueBuffer will block
105 mProducer->setDequeueTimeout(std::numeric_limits<int64_t>::max());
106
107 if (enableTripleBuffering) {
108 mProducer->setMaxDequeuedBufferCount(2);
109 }
110 mBufferItemConsumer =
111 new BLASTBufferItemConsumer(mConsumer, GraphicBuffer::USAGE_HW_COMPOSER, 1, true);
112 static int32_t id = 0;
113 auto name = std::string("BLAST Consumer") + std::to_string(id);
114 id++;
115 mBufferItemConsumer->setName(String8(name.c_str()));
116 mBufferItemConsumer->setFrameAvailableListener(this);
117 mBufferItemConsumer->setBufferFreedListener(this);
118 mBufferItemConsumer->setDefaultBufferSize(mWidth, mHeight);
119 mBufferItemConsumer->setDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888);
120
121 mTransformHint = mSurfaceControl->getTransformHint();
122 mBufferItemConsumer->setTransformHint(mTransformHint);
123
124 mNumAcquired = 0;
125 mNumFrameAvailable = 0;
126 mPendingReleaseItem.item = BufferItem();
127 mPendingReleaseItem.releaseFence = nullptr;
128 }
129
update(const sp<SurfaceControl> & surface,int width,int height)130 void BLASTBufferQueue::update(const sp<SurfaceControl>& surface, int width, int height) {
131 std::unique_lock _lock{mMutex};
132 mSurfaceControl = surface;
133
134 if (mWidth != width || mHeight != height) {
135 mWidth = width;
136 mHeight = height;
137 mBufferItemConsumer->setDefaultBufferSize(mWidth, mHeight);
138 }
139 }
140
transactionCallbackThunk(void * context,nsecs_t latchTime,const sp<Fence> & presentFence,const std::vector<SurfaceControlStats> & stats)141 static void transactionCallbackThunk(void* context, nsecs_t latchTime,
142 const sp<Fence>& presentFence,
143 const std::vector<SurfaceControlStats>& stats) {
144 if (context == nullptr) {
145 return;
146 }
147 BLASTBufferQueue* bq = static_cast<BLASTBufferQueue*>(context);
148 bq->transactionCallback(latchTime, presentFence, stats);
149 }
150
transactionCallback(nsecs_t,const sp<Fence> &,const std::vector<SurfaceControlStats> & stats)151 void BLASTBufferQueue::transactionCallback(nsecs_t /*latchTime*/, const sp<Fence>& /*presentFence*/,
152 const std::vector<SurfaceControlStats>& stats) {
153 std::unique_lock _lock{mMutex};
154 ATRACE_CALL();
155
156 if (!stats.empty()) {
157 mTransformHint = stats[0].transformHint;
158 mBufferItemConsumer->setTransformHint(mTransformHint);
159 mBufferItemConsumer->updateFrameTimestamps(stats[0].frameEventStats.frameNumber,
160 stats[0].frameEventStats.refreshStartTime,
161 stats[0].frameEventStats.gpuCompositionDoneFence,
162 stats[0].presentFence,
163 stats[0].previousReleaseFence,
164 stats[0].frameEventStats.compositorTiming,
165 stats[0].latchTime,
166 stats[0].frameEventStats.dequeueReadyTime);
167 }
168 if (mPendingReleaseItem.item.mGraphicBuffer != nullptr) {
169 if (!stats.empty()) {
170 mPendingReleaseItem.releaseFence = stats[0].previousReleaseFence;
171 } else {
172 ALOGE("Warning: no SurfaceControlStats returned in BLASTBufferQueue callback");
173 mPendingReleaseItem.releaseFence = nullptr;
174 }
175 mBufferItemConsumer->releaseBuffer(mPendingReleaseItem.item,
176 mPendingReleaseItem.releaseFence
177 ? mPendingReleaseItem.releaseFence
178 : Fence::NO_FENCE);
179 mNumAcquired--;
180 mPendingReleaseItem.item = BufferItem();
181 mPendingReleaseItem.releaseFence = nullptr;
182 }
183
184 if (mSubmitted.empty()) {
185 ALOGE("ERROR: callback with no corresponding submitted buffer item");
186 }
187 mPendingReleaseItem.item = std::move(mSubmitted.front());
188 mSubmitted.pop();
189
190 processNextBufferLocked(false);
191
192 mCallbackCV.notify_all();
193 decStrong((void*)transactionCallbackThunk);
194 }
195
processNextBufferLocked(bool useNextTransaction)196 void BLASTBufferQueue::processNextBufferLocked(bool useNextTransaction) {
197 ATRACE_CALL();
198 if (mNumFrameAvailable == 0 || mNumAcquired == MAX_ACQUIRED_BUFFERS + 1) {
199 return;
200 }
201
202 if (mSurfaceControl == nullptr) {
203 ALOGE("ERROR : surface control is null");
204 return;
205 }
206
207 SurfaceComposerClient::Transaction localTransaction;
208 bool applyTransaction = true;
209 SurfaceComposerClient::Transaction* t = &localTransaction;
210 if (mNextTransaction != nullptr && useNextTransaction) {
211 t = mNextTransaction;
212 mNextTransaction = nullptr;
213 applyTransaction = false;
214 }
215
216 BufferItem bufferItem;
217
218 status_t status = mBufferItemConsumer->acquireBuffer(&bufferItem, -1, false);
219 if (status != OK) {
220 return;
221 }
222 auto buffer = bufferItem.mGraphicBuffer;
223 mNumFrameAvailable--;
224
225 if (buffer == nullptr) {
226 mBufferItemConsumer->releaseBuffer(bufferItem, Fence::NO_FENCE);
227 return;
228 }
229
230 mNumAcquired++;
231 mSubmitted.push(bufferItem);
232
233 bool needsDisconnect = false;
234 mBufferItemConsumer->getConnectionEvents(bufferItem.mFrameNumber, &needsDisconnect);
235
236 // if producer disconnected before, notify SurfaceFlinger
237 if (needsDisconnect) {
238 t->notifyProducerDisconnect(mSurfaceControl);
239 }
240
241 // Ensure BLASTBufferQueue stays alive until we receive the transaction complete callback.
242 incStrong((void*)transactionCallbackThunk);
243
244 t->setBuffer(mSurfaceControl, buffer);
245 t->setAcquireFence(mSurfaceControl,
246 bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE);
247 t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));
248
249 t->setFrame(mSurfaceControl, {0, 0, mWidth, mHeight});
250 t->setCrop(mSurfaceControl, computeCrop(bufferItem));
251 t->setTransform(mSurfaceControl, bufferItem.mTransform);
252 t->setTransformToDisplayInverse(mSurfaceControl, bufferItem.mTransformToDisplayInverse);
253 t->setDesiredPresentTime(bufferItem.mTimestamp);
254
255 if (applyTransaction) {
256 t->apply();
257 }
258 }
259
computeCrop(const BufferItem & item)260 Rect BLASTBufferQueue::computeCrop(const BufferItem& item) {
261 if (item.mScalingMode == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP) {
262 return GLConsumer::scaleDownCrop(item.mCrop, mWidth, mHeight);
263 }
264 return item.mCrop;
265 }
266
onFrameAvailable(const BufferItem &)267 void BLASTBufferQueue::onFrameAvailable(const BufferItem& /*item*/) {
268 ATRACE_CALL();
269 std::unique_lock _lock{mMutex};
270
271 if (mNextTransaction != nullptr) {
272 while (mNumFrameAvailable > 0 || mNumAcquired == MAX_ACQUIRED_BUFFERS + 1) {
273 mCallbackCV.wait(_lock);
274 }
275 }
276 // add to shadow queue
277 mNumFrameAvailable++;
278 processNextBufferLocked(true);
279 }
280
setNextTransaction(SurfaceComposerClient::Transaction * t)281 void BLASTBufferQueue::setNextTransaction(SurfaceComposerClient::Transaction* t) {
282 std::lock_guard _lock{mMutex};
283 mNextTransaction = t;
284 }
285
286 } // namespace android
287