blob: c88511049b70657a825b9e3b2f0545751b46a813 [file] [log] [blame]
Marissa Wall61c58622018-07-18 10:12:20 -07001/*
2 * Copyright (C) 2017 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//#define LOG_NDEBUG 0
18#undef LOG_TAG
19#define LOG_TAG "BufferStateLayer"
20#define ATRACE_TAG ATRACE_TAG_GRAPHICS
21
Lloyd Pique9755fb72019-03-26 14:44:40 -070022#include "BufferStateLayer.h"
23
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080024#include <limits>
Marissa Wall61c58622018-07-18 10:12:20 -070025
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +000026#include <FrameTimeline/FrameTimeline.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070027#include <compositionengine/LayerFECompositionState.h>
Marissa Wall947d34e2019-03-29 14:03:53 -070028#include <gui/BufferQueue.h>
Marissa Wall61c58622018-07-18 10:12:20 -070029#include <private/gui/SyncFeatures.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070030#include <renderengine/Image.h>
Robert Carr38d25002021-06-11 14:30:09 -070031#include "TunnelModeEnabledReporter.h"
Marissa Wall61c58622018-07-18 10:12:20 -070032
Vishnu Nairfa247b12020-02-11 08:58:26 -080033#include "EffectLayer.h"
Adithya Srinivasanb238cd52021-02-04 17:54:05 +000034#include "FrameTracer/FrameTracer.h"
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080035#include "TimeStats/TimeStats.h"
Valerie Hau0bc09152018-12-20 07:42:47 -080036
Marissa Wall61c58622018-07-18 10:12:20 -070037namespace android {
38
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +000039using PresentState = frametimeline::SurfaceFrame::PresentState;
Vishnu Nair1506b182021-02-22 14:35:15 -080040namespace {
41void callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -070042 const sp<GraphicBuffer>& buffer, uint64_t framenumber,
chaviw69058fb2021-09-27 09:37:30 -050043 const sp<Fence>& releaseFence,
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -070044 uint32_t currentMaxAcquiredBufferCount) {
Vishnu Nair1506b182021-02-22 14:35:15 -080045 if (!listener) {
46 return;
47 }
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -070048 listener->onReleaseBuffer({buffer->getId(), framenumber},
chaviw69058fb2021-09-27 09:37:30 -050049 releaseFence ? releaseFence : Fence::NO_FENCE,
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -070050 currentMaxAcquiredBufferCount);
Vishnu Nair1506b182021-02-22 14:35:15 -080051}
52} // namespace
53
Marissa Wall947d34e2019-03-29 14:03:53 -070054BufferStateLayer::BufferStateLayer(const LayerCreationArgs& args)
55 : BufferLayer(args), mHwcSlotGenerator(new HwcSlotGenerator()) {
Robert Carr6a160312021-05-17 12:08:20 -070056 mDrawingState.dataspace = ui::Dataspace::V0_SRGB;
Vishnu Nair60356342018-11-13 13:00:45 -080057}
Marissa Wall61c58622018-07-18 10:12:20 -070058
Alec Mouri4545a8a2019-08-08 20:05:32 -070059BufferStateLayer::~BufferStateLayer() {
chaviwb4c6e582019-08-16 14:35:07 -070060 // The original layer and the clone layer share the same texture and buffer. Therefore, only
61 // one of the layers, in this case the original layer, needs to handle the deletion. The
62 // original layer and the clone should be removed at the same time so there shouldn't be any
63 // issue with the clone layer trying to use the texture.
Vishnu Nair3bb11d02021-11-26 09:24:11 -080064 if (mBufferInfo.mBuffer != nullptr) {
Alec Mouria90a5702021-04-16 16:36:21 +000065 callReleaseBufferCallback(mDrawingState.releaseBufferListener,
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -070066 mBufferInfo.mBuffer->getBuffer(), mBufferInfo.mFrameNumber,
chaviw69058fb2021-09-27 09:37:30 -050067 mBufferInfo.mFence,
Ady Abraham899dcdb2021-06-15 16:56:21 -070068 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(
69 mOwnerUid));
Alec Mouri4545a8a2019-08-08 20:05:32 -070070 }
71}
72
Marissa Wall61c58622018-07-18 10:12:20 -070073// -----------------------------------------------------------------------
74// Interface implementation for Layer
75// -----------------------------------------------------------------------
Dominik Laskowskibb448ce2022-05-07 15:52:55 -070076void BufferStateLayer::onLayerDisplayed(std::shared_future<FenceResult> futureFenceResult) {
Robert Carrc2f84132022-03-09 16:26:43 -080077 // If we are displayed on multiple displays in a single composition cycle then we would
78 // need to do careful tracking to enable the use of the mLastClientCompositionFence.
79 // For example we can only use it if all the displays are client comp, and we need
80 // to merge all the client comp fences. We could do this, but for now we just
81 // disable the optimization when a layer is composed on multiple displays.
82 if (mAlreadyDisplayedThisCompose) {
Robert Carrccab4242021-09-28 16:53:03 -070083 mLastClientCompositionFence = nullptr;
Robert Carrc2f84132022-03-09 16:26:43 -080084 } else {
85 mAlreadyDisplayedThisCompose = true;
Robert Carrccab4242021-09-28 16:53:03 -070086 }
87
Marissa Wall5a68a772018-12-22 17:43:42 -080088 // The previous release fence notifies the client that SurfaceFlinger is done with the previous
89 // buffer that was presented on this layer. The first transaction that came in this frame that
90 // replaced the previous buffer on this layer needs this release fence, because the fence will
91 // let the client know when that previous buffer is removed from the screen.
92 //
93 // Every other transaction on this layer does not need a release fence because no other
94 // Transactions that were set on this layer this frame are going to have their preceeding buffer
95 // removed from the display this frame.
96 //
97 // For example, if we have 3 transactions this frame. The first transaction doesn't contain a
98 // buffer so it doesn't need a previous release fence because the layer still needs the previous
99 // buffer. The second transaction contains a buffer so it needs a previous release fence because
100 // the previous buffer will be released this frame. The third transaction also contains a
101 // buffer. It replaces the buffer in the second transaction. The buffer in the second
102 // transaction will now no longer be presented so it is released immediately and the third
103 // transaction doesn't need a previous release fence.
Robert Carr8d958532020-11-10 14:09:16 -0800104 sp<CallbackHandle> ch;
Marissa Wall5a68a772018-12-22 17:43:42 -0800105 for (auto& handle : mDrawingState.callbackHandles) {
chaviw0b06a8d2021-08-06 11:49:08 -0500106 if (handle->releasePreviousBuffer &&
107 mDrawingState.releaseBufferEndpoint == handle->listener) {
Robert Carr8d958532020-11-10 14:09:16 -0800108 ch = handle;
Marissa Wall5a68a772018-12-22 17:43:42 -0800109 break;
110 }
111 }
Valerie Haubf784642020-01-29 07:25:23 -0800112
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700113 // Prevent tracing the same release multiple times.
114 if (mPreviousFrameNumber != mPreviousReleasedFrameNumber) {
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700115 mPreviousReleasedFrameNumber = mPreviousFrameNumber;
116 }
Sally Qi59a9f502021-10-12 18:53:23 +0000117
118 if (ch != nullptr) {
119 ch->previousReleaseCallbackId = mPreviousReleaseCallbackId;
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700120 ch->previousReleaseFences.emplace_back(std::move(futureFenceResult));
Sally Qi59a9f502021-10-12 18:53:23 +0000121 ch->name = mName;
122 }
Marissa Wall61c58622018-07-18 10:12:20 -0700123}
124
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100125void BufferStateLayer::onSurfaceFrameCreated(
126 const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame) {
Adithya Srinivasand17c7da2021-03-05 20:43:32 +0000127 while (mPendingJankClassifications.size() >= kPendingClassificationMaxSurfaceFrames) {
128 // Too many SurfaceFrames pending classification. The front of the deque is probably not
129 // tracked by FrameTimeline and will never be presented. This will only result in a memory
130 // leak.
131 ALOGW("Removing the front of pending jank deque from layer - %s to prevent memory leak",
132 mName.c_str());
Adithya Srinivasan785addd2021-03-09 00:38:00 +0000133 std::string miniDump = mPendingJankClassifications.front()->miniDump();
134 ALOGD("Head SurfaceFrame mini dump\n%s", miniDump.c_str());
Adithya Srinivasand17c7da2021-03-05 20:43:32 +0000135 mPendingJankClassifications.pop_front();
136 }
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100137 mPendingJankClassifications.emplace_back(surfaceFrame);
138}
139
Valerie Haubf784642020-01-29 07:25:23 -0800140void BufferStateLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) {
Valerie Hau32cdc1f2019-10-21 14:45:54 -0700141 for (const auto& handle : mDrawingState.callbackHandles) {
142 handle->transformHint = mTransformHint;
Valerie Hau871d6352020-01-29 08:44:02 -0800143 handle->dequeueReadyTime = dequeueReadyTime;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700144 handle->currentMaxAcquiredBufferCount =
145 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(mOwnerUid);
Valerie Hau32cdc1f2019-10-21 14:45:54 -0700146 }
147
Vishnu Nair1506b182021-02-22 14:35:15 -0800148 for (auto& handle : mDrawingState.callbackHandles) {
chaviw0b06a8d2021-08-06 11:49:08 -0500149 if (handle->releasePreviousBuffer &&
150 mDrawingState.releaseBufferEndpoint == handle->listener) {
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700151 handle->previousReleaseCallbackId = mPreviousReleaseCallbackId;
Vishnu Nair1506b182021-02-22 14:35:15 -0800152 break;
153 }
154 }
155
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100156 std::vector<JankData> jankData;
157 jankData.reserve(mPendingJankClassifications.size());
158 while (!mPendingJankClassifications.empty()
159 && mPendingJankClassifications.front()->getJankType()) {
160 std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame =
161 mPendingJankClassifications.front();
162 mPendingJankClassifications.pop_front();
163 jankData.emplace_back(
164 JankData(surfaceFrame->getToken(), surfaceFrame->getJankType().value()));
165 }
166
Robert Carr3d1047b2021-09-20 18:22:32 -0700167 mFlinger->getTransactionCallbackInvoker().addCallbackHandles(
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100168 mDrawingState.callbackHandles, jankData);
Marissa Wall5a68a772018-12-22 17:43:42 -0800169
Sally Qi59a9f502021-10-12 18:53:23 +0000170 sp<Fence> releaseFence = Fence::NO_FENCE;
171 for (auto& handle : mDrawingState.callbackHandles) {
172 if (handle->releasePreviousBuffer &&
173 mDrawingState.releaseBufferEndpoint == handle->listener) {
174 releaseFence =
175 handle->previousReleaseFence ? handle->previousReleaseFence : Fence::NO_FENCE;
176 break;
177 }
178 }
179
Marissa Wall5a68a772018-12-22 17:43:42 -0800180 mDrawingState.callbackHandles = {};
Valerie Haubf784642020-01-29 07:25:23 -0800181
Valerie Haubf784642020-01-29 07:25:23 -0800182 std::shared_ptr<FenceTime> releaseFenceTime = std::make_shared<FenceTime>(releaseFence);
183 {
184 Mutex::Autolock lock(mFrameEventHistoryMutex);
185 if (mPreviousFrameNumber != 0) {
186 mFrameEventHistory.addRelease(mPreviousFrameNumber, dequeueReadyTime,
187 std::move(releaseFenceTime));
188 }
189 }
Marissa Wall61c58622018-07-18 10:12:20 -0700190}
191
Valerie Hau871d6352020-01-29 08:44:02 -0800192void BufferStateLayer::finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& glDoneFence,
193 const CompositorTiming& compositorTiming) {
194 for (const auto& handle : mDrawingState.callbackHandles) {
195 handle->gpuCompositionDoneFence = glDoneFence;
196 handle->compositorTiming = compositorTiming;
197 }
198}
199
Marissa Walle2ffb422018-10-12 11:33:52 -0700200bool BufferStateLayer::willPresentCurrentTransaction() const {
201 // Returns true if the most recent Transaction applied to CurrentState will be presented.
Robert Carr321e83c2019-08-19 15:49:30 -0700202 return (getSidebandStreamChanged() || getAutoRefresh() ||
Robert Carr6a160312021-05-17 12:08:20 -0700203 (mDrawingState.modified &&
204 (mDrawingState.buffer != nullptr || mDrawingState.bgColorLayer != nullptr)));
Marissa Wall61c58622018-07-18 10:12:20 -0700205}
206
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000207Rect BufferStateLayer::getCrop(const Layer::State& s) const {
208 return s.crop;
Marissa Wall61c58622018-07-18 10:12:20 -0700209}
210
211bool BufferStateLayer::setTransform(uint32_t transform) {
Robert Carr6a160312021-05-17 12:08:20 -0700212 if (mDrawingState.bufferTransform == transform) return false;
213 mDrawingState.bufferTransform = transform;
214 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700215 setTransactionFlags(eTransactionNeeded);
216 return true;
217}
218
219bool BufferStateLayer::setTransformToDisplayInverse(bool transformToDisplayInverse) {
Robert Carr6a160312021-05-17 12:08:20 -0700220 if (mDrawingState.transformToDisplayInverse == transformToDisplayInverse) return false;
221 mDrawingState.sequence++;
222 mDrawingState.transformToDisplayInverse = transformToDisplayInverse;
223 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700224 setTransactionFlags(eTransactionNeeded);
225 return true;
226}
227
228bool BufferStateLayer::setCrop(const Rect& crop) {
Robert Carr6a160312021-05-17 12:08:20 -0700229 if (mDrawingState.crop == crop) return false;
230 mDrawingState.sequence++;
231 mDrawingState.crop = crop;
Marissa Wall290ad082019-03-06 13:23:47 -0800232
Robert Carr6a160312021-05-17 12:08:20 -0700233 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700234 setTransactionFlags(eTransactionNeeded);
235 return true;
236}
237
chaviwf3f40fe2021-04-27 15:54:02 -0500238bool BufferStateLayer::setBufferCrop(const Rect& bufferCrop) {
Robert Carr6a160312021-05-17 12:08:20 -0700239 if (mDrawingState.bufferCrop == bufferCrop) return false;
chaviwf3f40fe2021-04-27 15:54:02 -0500240
Robert Carr6a160312021-05-17 12:08:20 -0700241 mDrawingState.sequence++;
242 mDrawingState.bufferCrop = bufferCrop;
chaviwf3f40fe2021-04-27 15:54:02 -0500243
Robert Carr6a160312021-05-17 12:08:20 -0700244 mDrawingState.modified = true;
chaviwf3f40fe2021-04-27 15:54:02 -0500245 setTransactionFlags(eTransactionNeeded);
246 return true;
247}
248
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700249bool BufferStateLayer::setDestinationFrame(const Rect& destinationFrame) {
Robert Carr6a160312021-05-17 12:08:20 -0700250 if (mDrawingState.destinationFrame == destinationFrame) return false;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700251
Robert Carr6a160312021-05-17 12:08:20 -0700252 mDrawingState.sequence++;
253 mDrawingState.destinationFrame = destinationFrame;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700254
Robert Carr6a160312021-05-17 12:08:20 -0700255 mDrawingState.modified = true;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700256 setTransactionFlags(eTransactionNeeded);
257 return true;
258}
259
Robert Carr6a160312021-05-17 12:08:20 -0700260static bool assignTransform(ui::Transform* dst, ui::Transform& from) {
261 if (*dst == from) {
262 return false;
263 }
264 *dst = from;
265 return true;
266}
267
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700268// Translate destination frame into scale and position. If a destination frame is not set, use the
269// provided scale and position
Robert Carr6a160312021-05-17 12:08:20 -0700270bool BufferStateLayer::updateGeometry() {
Vishnu Naird2aaab12022-02-10 14:49:09 -0800271 if ((mDrawingState.flags & layer_state_t::eIgnoreDestinationFrame) ||
272 mDrawingState.destinationFrame.isEmpty()) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700273 // If destination frame is not set, use the requested transform set via
274 // BufferStateLayer::setPosition and BufferStateLayer::setMatrix.
Robert Carr6a160312021-05-17 12:08:20 -0700275 return assignTransform(&mDrawingState.transform, mRequestedTransform);
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700276 }
277
Robert Carr6a160312021-05-17 12:08:20 -0700278 Rect destRect = mDrawingState.destinationFrame;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700279 int32_t destW = destRect.width();
280 int32_t destH = destRect.height();
281 if (destRect.left < 0) {
282 destRect.left = 0;
283 destRect.right = destW;
284 }
285 if (destRect.top < 0) {
286 destRect.top = 0;
287 destRect.bottom = destH;
288 }
289
Robert Carr6a160312021-05-17 12:08:20 -0700290 if (!mDrawingState.buffer) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700291 ui::Transform t;
292 t.set(destRect.left, destRect.top);
Robert Carr6a160312021-05-17 12:08:20 -0700293 return assignTransform(&mDrawingState.transform, t);
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700294 }
295
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800296 uint32_t bufferWidth = mDrawingState.buffer->getWidth();
297 uint32_t bufferHeight = mDrawingState.buffer->getHeight();
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700298 // Undo any transformations on the buffer.
Robert Carr6a160312021-05-17 12:08:20 -0700299 if (mDrawingState.bufferTransform & ui::Transform::ROT_90) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700300 std::swap(bufferWidth, bufferHeight);
301 }
302 uint32_t invTransform = DisplayDevice::getPrimaryDisplayRotationFlags();
Robert Carr6a160312021-05-17 12:08:20 -0700303 if (mDrawingState.transformToDisplayInverse) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700304 if (invTransform & ui::Transform::ROT_90) {
305 std::swap(bufferWidth, bufferHeight);
306 }
307 }
308
309 float sx = destW / static_cast<float>(bufferWidth);
310 float sy = destH / static_cast<float>(bufferHeight);
311 ui::Transform t;
312 t.set(sx, 0, 0, sy);
313 t.set(destRect.left, destRect.top);
Robert Carr6a160312021-05-17 12:08:20 -0700314 return assignTransform(&mDrawingState.transform, t);
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700315}
316
Robert Carrde6d7b42022-01-07 18:23:06 -0800317bool BufferStateLayer::setMatrix(const layer_state_t::matrix22_t& matrix) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700318 if (mRequestedTransform.dsdx() == matrix.dsdx && mRequestedTransform.dtdy() == matrix.dtdy &&
319 mRequestedTransform.dtdx() == matrix.dtdx && mRequestedTransform.dsdy() == matrix.dsdy) {
Marissa Wall861616d2018-10-22 12:52:23 -0700320 return false;
321 }
322
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000323 ui::Transform t;
324 t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
325
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700326 mRequestedTransform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
chaviw9a93ea62021-03-11 16:44:42 -0600327
Robert Carr6a160312021-05-17 12:08:20 -0700328 mDrawingState.sequence++;
329 mDrawingState.modified = true;
chaviw9a93ea62021-03-11 16:44:42 -0600330 setTransactionFlags(eTransactionNeeded);
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000331
332 return true;
333}
334
335bool BufferStateLayer::setPosition(float x, float y) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700336 if (mRequestedTransform.tx() == x && mRequestedTransform.ty() == y) {
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000337 return false;
338 }
339
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700340 mRequestedTransform.set(x, y);
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000341
Robert Carr6a160312021-05-17 12:08:20 -0700342 mDrawingState.sequence++;
343 mDrawingState.modified = true;
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000344 setTransactionFlags(eTransactionNeeded);
345
Marissa Wall861616d2018-10-22 12:52:23 -0700346 return true;
347}
348
Valerie Hau871d6352020-01-29 08:44:02 -0800349bool BufferStateLayer::addFrameEvent(const sp<Fence>& acquireFence, nsecs_t postedTime,
350 nsecs_t desiredPresentTime) {
Valerie Haubf784642020-01-29 07:25:23 -0800351 Mutex::Autolock lock(mFrameEventHistoryMutex);
352 mAcquireTimeline.updateSignalTimes();
353 std::shared_ptr<FenceTime> acquireFenceTime =
354 std::make_shared<FenceTime>((acquireFence ? acquireFence : Fence::NO_FENCE));
Robert Carr6a160312021-05-17 12:08:20 -0700355 NewFrameEventsEntry newTimestamps = {mDrawingState.frameNumber, postedTime, desiredPresentTime,
Valerie Haubf784642020-01-29 07:25:23 -0800356 acquireFenceTime};
Valerie Hau871d6352020-01-29 08:44:02 -0800357 mFrameEventHistory.setProducerWantsEvents();
Valerie Haubf784642020-01-29 07:25:23 -0800358 mFrameEventHistory.addQueue(newTimestamps);
359 return true;
360}
361
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800362bool BufferStateLayer::setBuffer(std::shared_ptr<renderengine::ExternalTexture>& buffer,
363 const BufferData& bufferData, nsecs_t postTime,
Alec Mouria90a5702021-04-16 16:36:21 +0000364 nsecs_t desiredPresentTime, bool isAutoTimestamp,
chaviwba4320c2021-09-15 15:20:53 -0500365 std::optional<nsecs_t> dequeueTime,
366 const FrameTimelineInfo& info) {
Alex Chaucf6b4b42021-12-07 10:48:52 +0000367 ATRACE_CALL();
Robert Carr0c1966e2020-10-19 12:12:08 -0700368
chaviwba4320c2021-09-15 15:20:53 -0500369 if (!buffer) {
370 return false;
371 }
372
373 const bool frameNumberChanged =
374 bufferData.flags.test(BufferData::BufferDataChange::frameNumberChanged);
375 const uint64_t frameNumber =
376 frameNumberChanged ? bufferData.frameNumber : mDrawingState.frameNumber + 1;
377
Robert Carr6a160312021-05-17 12:08:20 -0700378 if (mDrawingState.buffer) {
Marissa Wallfda30bb2018-10-12 11:34:28 -0700379 mReleasePreviousBuffer = true;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800380 if (!mBufferInfo.mBuffer ||
381 (!mDrawingState.buffer->hasSameBuffer(*mBufferInfo.mBuffer) ||
382 mDrawingState.frameNumber != mBufferInfo.mFrameNumber)) {
Robert Carr6a160312021-05-17 12:08:20 -0700383 // If mDrawingState has a buffer, and we are about to update again
Robert Carr7121caf2020-12-15 13:07:32 -0800384 // before swapping to drawing state, then the first buffer will be
Vishnu Nair1506b182021-02-22 14:35:15 -0800385 // dropped and we should decrement the pending buffer count and
386 // call any release buffer callbacks if set.
Robert Carr6a160312021-05-17 12:08:20 -0700387 callReleaseBufferCallback(mDrawingState.releaseBufferListener,
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700388 mDrawingState.buffer->getBuffer(), mDrawingState.frameNumber,
chaviw69058fb2021-09-27 09:37:30 -0500389 mDrawingState.acquireFence,
Ady Abraham899dcdb2021-06-15 16:56:21 -0700390 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(
391 mOwnerUid));
Robert Carr7121caf2020-12-15 13:07:32 -0800392 decrementPendingBufferCount();
Robert Carr6a160312021-05-17 12:08:20 -0700393 if (mDrawingState.bufferSurfaceFrameTX != nullptr &&
394 mDrawingState.bufferSurfaceFrameTX->getPresentState() != PresentState::Presented) {
395 addSurfaceFrameDroppedForBuffer(mDrawingState.bufferSurfaceFrameTX);
396 mDrawingState.bufferSurfaceFrameTX.reset();
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000397 }
Robert Carrccab4242021-09-28 16:53:03 -0700398 } else if (mLastClientCompositionFence != nullptr) {
399 callReleaseBufferCallback(mDrawingState.releaseBufferListener,
400 mDrawingState.buffer->getBuffer(), mDrawingState.frameNumber,
chaviw69058fb2021-09-27 09:37:30 -0500401 mLastClientCompositionFence,
Robert Carrccab4242021-09-28 16:53:03 -0700402 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(
chaviw69058fb2021-09-27 09:37:30 -0500403 mOwnerUid));
Robert Carrccab4242021-09-28 16:53:03 -0700404 mLastClientCompositionFence = nullptr;
Robert Carr7121caf2020-12-15 13:07:32 -0800405 }
Marissa Wallfda30bb2018-10-12 11:34:28 -0700406 }
Robert Carr6a160312021-05-17 12:08:20 -0700407
408 mDrawingState.frameNumber = frameNumber;
chaviwba4320c2021-09-15 15:20:53 -0500409 mDrawingState.releaseBufferListener = bufferData.releaseBufferListener;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800410 mDrawingState.buffer = std::move(buffer);
chaviwba4320c2021-09-15 15:20:53 -0500411 mDrawingState.clientCacheId = bufferData.cachedBuffer;
412
413 mDrawingState.acquireFence = bufferData.flags.test(BufferData::BufferDataChange::fenceChanged)
414 ? bufferData.acquireFence
415 : Fence::NO_FENCE;
416 mDrawingState.acquireFenceTime = std::make_unique<FenceTime>(mDrawingState.acquireFence);
Ady Abraham461296a2022-01-21 11:11:31 -0800417 if (mDrawingState.acquireFenceTime->getSignalTime() == Fence::SIGNAL_TIME_PENDING) {
418 // We latched this buffer unsiganled, so we need to pass the acquire fence
419 // on the callback instead of just the acquire time, since it's unknown at
420 // this point.
421 mCallbackHandleAcquireTimeOrFence = mDrawingState.acquireFence;
422 } else {
423 mCallbackHandleAcquireTimeOrFence = mDrawingState.acquireFenceTime->getSignalTime();
424 }
chaviwba4320c2021-09-15 15:20:53 -0500425
Robert Carr6a160312021-05-17 12:08:20 -0700426 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700427 setTransactionFlags(eTransactionNeeded);
Ady Abraham09bd3922019-04-08 10:44:56 -0700428
Yiwei Zhang1a88c402019-11-18 10:43:58 -0800429 const int32_t layerId = getSequence();
Robert Carr6a160312021-05-17 12:08:20 -0700430 mFlinger->mTimeStats->setPostTime(layerId, mDrawingState.frameNumber, getName().c_str(),
Adithya Srinivasan58069dc2021-06-04 20:37:02 +0000431 mOwnerUid, postTime, getGameMode());
Robert Carr6a160312021-05-17 12:08:20 -0700432 mDrawingState.desiredPresentTime = desiredPresentTime;
433 mDrawingState.isAutoTimestamp = isAutoTimestamp;
Ady Abraham09bd3922019-04-08 10:44:56 -0700434
Ady Abrahamb7f15562021-03-15 18:34:08 -0700435 const nsecs_t presentTime = [&] {
436 if (!isAutoTimestamp) return desiredPresentTime;
437
438 const auto prediction =
439 mFlinger->mFrameTimeline->getTokenManager()->getPredictionsForToken(info.vsyncId);
440 if (prediction.has_value()) return prediction->presentTime;
441
442 return static_cast<nsecs_t>(0);
443 }();
Dominik Laskowski068173d2021-08-11 17:22:59 -0700444
445 using LayerUpdateType = scheduler::LayerHistory::LayerUpdateType;
446 mFlinger->mScheduler->recordLayerHistory(this, presentTime, LayerUpdateType::Buffer);
Ady Abraham09bd3922019-04-08 10:44:56 -0700447
chaviwba4320c2021-09-15 15:20:53 -0500448 addFrameEvent(mDrawingState.acquireFence, postTime, isAutoTimestamp ? 0 : desiredPresentTime);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000449
Adithya Srinivasan891004e2021-02-12 20:20:47 +0000450 setFrameTimelineVsyncForBufferTransaction(info, postTime);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000451
Vishnu Nair26c49762022-01-18 22:58:52 +0000452 if (dequeueTime && *dequeueTime != 0) {
453 const uint64_t bufferId = mDrawingState.buffer->getId();
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000454 mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
455 mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, frameNumber, *dequeueTime,
456 FrameTracer::FrameEvent::DEQUEUE);
457 mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, frameNumber, postTime,
458 FrameTracer::FrameEvent::QUEUE);
459 }
Chavi Weingartena5aedbd2021-04-09 13:37:33 +0000460
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800461 mDrawingState.width = mDrawingState.buffer->getWidth();
462 mDrawingState.height = mDrawingState.buffer->getHeight();
chaviwba4320c2021-09-15 15:20:53 -0500463 mDrawingState.releaseBufferEndpoint = bufferData.releaseBufferEndpoint;
Marissa Wall61c58622018-07-18 10:12:20 -0700464 return true;
465}
466
467bool BufferStateLayer::setDataspace(ui::Dataspace dataspace) {
Robert Carr6a160312021-05-17 12:08:20 -0700468 if (mDrawingState.dataspace == dataspace) return false;
469 mDrawingState.dataspace = dataspace;
470 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700471 setTransactionFlags(eTransactionNeeded);
472 return true;
473}
474
475bool BufferStateLayer::setHdrMetadata(const HdrMetadata& hdrMetadata) {
Robert Carr6a160312021-05-17 12:08:20 -0700476 if (mDrawingState.hdrMetadata == hdrMetadata) return false;
477 mDrawingState.hdrMetadata = hdrMetadata;
478 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700479 setTransactionFlags(eTransactionNeeded);
480 return true;
481}
482
483bool BufferStateLayer::setSurfaceDamageRegion(const Region& surfaceDamage) {
Robert Carr6a160312021-05-17 12:08:20 -0700484 mDrawingState.surfaceDamageRegion = surfaceDamage;
485 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700486 setTransactionFlags(eTransactionNeeded);
487 return true;
488}
489
490bool BufferStateLayer::setApi(int32_t api) {
Robert Carr6a160312021-05-17 12:08:20 -0700491 if (mDrawingState.api == api) return false;
492 mDrawingState.api = api;
493 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700494 setTransactionFlags(eTransactionNeeded);
495 return true;
496}
497
498bool BufferStateLayer::setSidebandStream(const sp<NativeHandle>& sidebandStream) {
Robert Carr6a160312021-05-17 12:08:20 -0700499 if (mDrawingState.sidebandStream == sidebandStream) return false;
Robert Carr3e2a2992021-06-11 13:42:55 -0700500
501 if (mDrawingState.sidebandStream != nullptr && sidebandStream == nullptr) {
502 mFlinger->mTunnelModeEnabledReporter->decrementTunnelModeCount();
503 } else if (sidebandStream != nullptr) {
504 mFlinger->mTunnelModeEnabledReporter->incrementTunnelModeCount();
505 }
506
Robert Carr6a160312021-05-17 12:08:20 -0700507 mDrawingState.sidebandStream = sidebandStream;
508 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700509 setTransactionFlags(eTransactionNeeded);
Marissa Wall61c58622018-07-18 10:12:20 -0700510 if (!mSidebandStreamChanged.exchange(true)) {
511 // mSidebandStreamChanged was false
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700512 mFlinger->onLayerUpdate();
Marissa Wall61c58622018-07-18 10:12:20 -0700513 }
514 return true;
515}
516
Marissa Walle2ffb422018-10-12 11:33:52 -0700517bool BufferStateLayer::setTransactionCompletedListeners(
Jiakai Zhanga5505cb2021-11-09 11:46:30 +0000518 const std::vector<sp<CallbackHandle>>& handles) {
Marissa Wallfda30bb2018-10-12 11:34:28 -0700519 // If there is no handle, we will not send a callback so reset mReleasePreviousBuffer and return
Jiakai Zhanga5505cb2021-11-09 11:46:30 +0000520 if (handles.empty()) {
Marissa Wallfda30bb2018-10-12 11:34:28 -0700521 mReleasePreviousBuffer = false;
Marissa Walle2ffb422018-10-12 11:33:52 -0700522 return false;
523 }
524
525 const bool willPresent = willPresentCurrentTransaction();
526
527 for (const auto& handle : handles) {
Marissa Wallfda30bb2018-10-12 11:34:28 -0700528 // If this transaction set a buffer on this layer, release its previous buffer
529 handle->releasePreviousBuffer = mReleasePreviousBuffer;
530
Marissa Walle2ffb422018-10-12 11:33:52 -0700531 // If this layer will be presented in this frame
532 if (willPresent) {
Marissa Wallfda30bb2018-10-12 11:34:28 -0700533 // If this transaction set an acquire fence on this layer, set its acquire time
Ady Abraham461296a2022-01-21 11:11:31 -0800534 handle->acquireTimeOrFence = mCallbackHandleAcquireTimeOrFence;
Robert Carr6a160312021-05-17 12:08:20 -0700535 handle->frameNumber = mDrawingState.frameNumber;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700536
Marissa Walle2ffb422018-10-12 11:33:52 -0700537 // Store so latched time and release fence can be set
Robert Carr6a160312021-05-17 12:08:20 -0700538 mDrawingState.callbackHandles.push_back(handle);
Marissa Walle2ffb422018-10-12 11:33:52 -0700539
Jiakai Zhanga5505cb2021-11-09 11:46:30 +0000540 } else { // If this layer will NOT need to be relatched and presented this frame
Marissa Walle2ffb422018-10-12 11:33:52 -0700541 // Notify the transaction completed thread this handle is done
Jiakai Zhanga5505cb2021-11-09 11:46:30 +0000542 mFlinger->getTransactionCallbackInvoker().registerUnpresentedCallbackHandle(handle);
Marissa Walle2ffb422018-10-12 11:33:52 -0700543 }
544 }
545
Marissa Wallfda30bb2018-10-12 11:34:28 -0700546 mReleasePreviousBuffer = false;
Ady Abraham461296a2022-01-21 11:11:31 -0800547 mCallbackHandleAcquireTimeOrFence = -1;
Marissa Wallfda30bb2018-10-12 11:34:28 -0700548
Marissa Walle2ffb422018-10-12 11:33:52 -0700549 return willPresent;
550}
551
Marissa Wall61c58622018-07-18 10:12:20 -0700552bool BufferStateLayer::setTransparentRegionHint(const Region& transparent) {
Vishnu Nair27e3ed52021-07-08 18:24:25 -0700553 mDrawingState.sequence++;
Robert Carr6a160312021-05-17 12:08:20 -0700554 mDrawingState.transparentRegionHint = transparent;
555 mDrawingState.modified = true;
Marissa Wall61c58622018-07-18 10:12:20 -0700556 setTransactionFlags(eTransactionNeeded);
557 return true;
558}
559
rnleeed20fa42021-08-10 18:00:03 -0700560Rect BufferStateLayer::getBufferSize(const State& /*s*/) const {
Marissa Wall861616d2018-10-22 12:52:23 -0700561 // for buffer state layers we use the display frame size as the buffer size.
Marissa Wall61c58622018-07-18 10:12:20 -0700562
chaviw7e72caf2020-12-02 16:50:43 -0800563 if (mBufferInfo.mBuffer == nullptr) {
564 return Rect::INVALID_RECT;
565 }
566
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800567 uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
568 uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700569
570 // Undo any transformations on the buffer and return the result.
571 if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
572 std::swap(bufWidth, bufHeight);
573 }
574
575 if (getTransformToDisplayInverse()) {
576 uint32_t invTransform = DisplayDevice::getPrimaryDisplayRotationFlags();
577 if (invTransform & ui::Transform::ROT_90) {
578 std::swap(bufWidth, bufHeight);
Marissa Wall861616d2018-10-22 12:52:23 -0700579 }
580 }
581
rnleeed20fa42021-08-10 18:00:03 -0700582 return Rect(0, 0, static_cast<int32_t>(bufWidth), static_cast<int32_t>(bufHeight));
Marissa Wall61c58622018-07-18 10:12:20 -0700583}
Vishnu Nair4351ad52019-02-11 14:13:02 -0800584
585FloatRect BufferStateLayer::computeSourceBounds(const FloatRect& parentBounds) const {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700586 if (mBufferInfo.mBuffer == nullptr) {
587 return parentBounds;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800588 }
589
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700590 return getBufferSize(getDrawingState()).toFloatRect();
Vishnu Nair4351ad52019-02-11 14:13:02 -0800591}
592
Marissa Wall61c58622018-07-18 10:12:20 -0700593// -----------------------------------------------------------------------
594
595// -----------------------------------------------------------------------
596// Interface implementation for BufferLayer
597// -----------------------------------------------------------------------
598bool BufferStateLayer::fenceHasSignaled() const {
ramindani4d48f902021-09-20 21:07:45 +0000599 if (SurfaceFlinger::enableLatchUnsignaledConfig != LatchUnsignaledConfig::Disabled) {
Huihong Luo86c80e32021-06-16 15:41:07 -0700600 return true;
601 }
602
Alec Mouri91f6df32020-01-30 08:48:58 -0800603 const bool fenceSignaled =
604 getDrawingState().acquireFence->getStatus() == Fence::Status::Signaled;
605 if (!fenceSignaled) {
606 mFlinger->mTimeStats->incrementLatchSkipped(getSequence(),
607 TimeStats::LatchSkipReason::LateAcquire);
608 }
609
610 return fenceSignaled;
Marissa Wall61c58622018-07-18 10:12:20 -0700611}
612
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700613bool BufferStateLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const {
Ady Abrahamcd1580c2019-04-29 15:40:03 -0700614 if (!hasFrameUpdate() || isRemovedFromCurrentState()) {
615 return true;
616 }
617
Robert Carr6a160312021-05-17 12:08:20 -0700618 return mDrawingState.isAutoTimestamp || mDrawingState.desiredPresentTime <= expectedPresentTime;
Ady Abrahamcd1580c2019-04-29 15:40:03 -0700619}
620
Valerie Hau871d6352020-01-29 08:44:02 -0800621bool BufferStateLayer::onPreComposition(nsecs_t refreshStartTime) {
622 for (const auto& handle : mDrawingState.callbackHandles) {
623 handle->refreshStartTime = refreshStartTime;
624 }
625 return BufferLayer::onPreComposition(refreshStartTime);
626}
627
Vishnu Naircf26a0a2020-11-13 12:56:20 -0800628void BufferStateLayer::setAutoRefresh(bool autoRefresh) {
Vishnu Nair86653e92021-11-03 17:19:36 -0700629 mDrawingState.autoRefresh = autoRefresh;
Marissa Wall61c58622018-07-18 10:12:20 -0700630}
631
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800632bool BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
baocheng suna663c2b2021-05-13 18:51:28 +0800633 // We need to update the sideband stream if the layer has both a buffer and a sideband stream.
baocheng sun9691b9c2021-08-03 19:27:06 +0800634 editCompositionState()->sidebandStreamHasFrame = hasFrameUpdate() && mSidebandStream.get();
baocheng suna663c2b2021-05-13 18:51:28 +0800635
baocheng sun9691b9c2021-08-03 19:27:06 +0800636 if (mSidebandStreamChanged.exchange(false)) {
Marissa Wall61c58622018-07-18 10:12:20 -0700637 const State& s(getDrawingState());
638 // mSidebandStreamChanged was true
Lloyd Pique0b785d82018-12-04 17:25:27 -0800639 mSidebandStream = s.sidebandStream;
Lloyd Piquede196652020-01-22 17:29:58 -0800640 editCompositionState()->sidebandStream = mSidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800641 if (mSidebandStream != nullptr) {
Marissa Wall61c58622018-07-18 10:12:20 -0700642 setTransactionFlags(eTransactionNeeded);
643 mFlinger->setTransactionFlags(eTraversalNeeded);
644 }
645 recomputeVisibleRegions = true;
646
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800647 return true;
Marissa Wall61c58622018-07-18 10:12:20 -0700648 }
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800649 return false;
Marissa Wall61c58622018-07-18 10:12:20 -0700650}
651
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800652bool BufferStateLayer::hasFrameUpdate() const {
Robert Carr6a160312021-05-17 12:08:20 -0700653 const State& c(getDrawingState());
Robert Carr315f3c72021-06-24 21:58:09 -0700654 return (mDrawingStateModified || mDrawingState.modified) && (c.buffer != nullptr || c.bgColorLayer != nullptr);
Marissa Wall61c58622018-07-18 10:12:20 -0700655}
656
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700657status_t BufferStateLayer::updateTexImage(bool& /*recomputeVisibleRegions*/, nsecs_t latchTime,
658 nsecs_t /*expectedPresentTime*/) {
Marissa Wall61c58622018-07-18 10:12:20 -0700659 const State& s(getDrawingState());
660
661 if (!s.buffer) {
Valerie Hauaa194562019-02-05 16:21:38 -0800662 if (s.bgColorLayer) {
663 for (auto& handle : mDrawingState.callbackHandles) {
664 handle->latchTime = latchTime;
665 }
666 }
Marissa Wall61c58622018-07-18 10:12:20 -0700667 return NO_ERROR;
668 }
669
Marissa Wall5a68a772018-12-22 17:43:42 -0800670 for (auto& handle : mDrawingState.callbackHandles) {
Vishnu Nair935590e2021-02-10 13:05:52 -0800671 if (handle->frameNumber == mDrawingState.frameNumber) {
672 handle->latchTime = latchTime;
673 }
Marissa Wall5a68a772018-12-22 17:43:42 -0800674 }
Marissa Walle2ffb422018-10-12 11:33:52 -0700675
Vishnu Nairea0de002020-11-17 17:42:37 -0800676 const int32_t layerId = getSequence();
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800677 const uint64_t bufferId = mDrawingState.buffer->getId();
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000678 const uint64_t frameNumber = mDrawingState.frameNumber;
679 const auto acquireFence = std::make_shared<FenceTime>(mDrawingState.acquireFence);
680 mFlinger->mTimeStats->setAcquireFence(layerId, frameNumber, acquireFence);
681 mFlinger->mTimeStats->setLatchTime(layerId, frameNumber, latchTime);
682
683 mFlinger->mFrameTracer->traceFence(layerId, bufferId, frameNumber, acquireFence,
684 FrameTracer::FrameEvent::ACQUIRE_FENCE);
685 mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, frameNumber, latchTime,
686 FrameTracer::FrameEvent::LATCH);
Marissa Wall61c58622018-07-18 10:12:20 -0700687
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000688 auto& bufferSurfaceFrame = mDrawingState.bufferSurfaceFrameTX;
689 if (bufferSurfaceFrame != nullptr &&
690 bufferSurfaceFrame->getPresentState() != PresentState::Presented) {
691 // Update only if the bufferSurfaceFrame wasn't already presented. A Presented
692 // bufferSurfaceFrame could be seen here if a pending state was applied successfully and we
693 // are processing the next state.
694 addSurfaceFramePresentedForBuffer(bufferSurfaceFrame,
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700695 mDrawingState.acquireFenceTime->getSignalTime(),
696 latchTime);
Robert Carr6a160312021-05-17 12:08:20 -0700697 mDrawingState.bufferSurfaceFrameTX.reset();
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000698 }
699
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700700 std::deque<sp<CallbackHandle>> remainingHandles;
701 mFlinger->getTransactionCallbackInvoker()
Robert Carr3d1047b2021-09-20 18:22:32 -0700702 .addOnCommitCallbackHandles(mDrawingState.callbackHandles, remainingHandles);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700703 mDrawingState.callbackHandles = remainingHandles;
704
Robert Carr6a160312021-05-17 12:08:20 -0700705 mDrawingStateModified = false;
Marissa Wall16c112d2019-03-20 13:21:13 -0700706
Marissa Wall61c58622018-07-18 10:12:20 -0700707 return NO_ERROR;
708}
709
710status_t BufferStateLayer::updateActiveBuffer() {
711 const State& s(getDrawingState());
712
713 if (s.buffer == nullptr) {
714 return BAD_VALUE;
715 }
chaviwdf3c5e82021-01-07 13:00:37 -0800716
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800717 if (!mBufferInfo.mBuffer || !s.buffer->hasSameBuffer(*mBufferInfo.mBuffer)) {
chaviwdf3c5e82021-01-07 13:00:37 -0800718 decrementPendingBufferCount();
719 }
Marissa Wall61c58622018-07-18 10:12:20 -0700720
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700721 mPreviousReleaseCallbackId = {getCurrentBufferId(), mBufferInfo.mFrameNumber};
chaviwd62d3062019-09-04 14:48:02 -0700722 mBufferInfo.mBuffer = s.buffer;
723 mBufferInfo.mFence = s.acquireFence;
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700724 mBufferInfo.mFrameNumber = s.frameNumber;
Marissa Wall61c58622018-07-18 10:12:20 -0700725
726 return NO_ERROR;
727}
728
Valerie Haubf784642020-01-29 07:25:23 -0800729status_t BufferStateLayer::updateFrameNumber(nsecs_t latchTime) {
Marissa Wall61c58622018-07-18 10:12:20 -0700730 // TODO(marissaw): support frame history events
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700731 mPreviousFrameNumber = mCurrentFrameNumber;
Valerie Hau134651a2020-01-28 16:21:22 -0800732 mCurrentFrameNumber = mDrawingState.frameNumber;
Valerie Haubf784642020-01-29 07:25:23 -0800733 {
734 Mutex::Autolock lock(mFrameEventHistoryMutex);
735 mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime);
736 }
Marissa Wall61c58622018-07-18 10:12:20 -0700737 return NO_ERROR;
738}
739
Marissa Wall947d34e2019-03-29 14:03:53 -0700740void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {
741 std::lock_guard lock(mMutex);
742 if (!clientCacheId.isValid()) {
743 ALOGE("invalid process, failed to erase buffer");
744 return;
745 }
746 eraseBufferLocked(clientCacheId);
747}
748
rnleeed20fa42021-08-10 18:00:03 -0700749int BufferStateLayer::HwcSlotGenerator::getHwcCacheSlot(const client_cache_t& clientCacheId) {
Marissa Wall947d34e2019-03-29 14:03:53 -0700750 std::lock_guard<std::mutex> lock(mMutex);
751 auto itr = mCachedBuffers.find(clientCacheId);
752 if (itr == mCachedBuffers.end()) {
753 return addCachedBuffer(clientCacheId);
754 }
755 auto& [hwcCacheSlot, counter] = itr->second;
756 counter = mCounter++;
757 return hwcCacheSlot;
758}
759
rnleeed20fa42021-08-10 18:00:03 -0700760int BufferStateLayer::HwcSlotGenerator::addCachedBuffer(const client_cache_t& clientCacheId)
Marissa Wall947d34e2019-03-29 14:03:53 -0700761 REQUIRES(mMutex) {
762 if (!clientCacheId.isValid()) {
763 ALOGE("invalid process, returning invalid slot");
764 return BufferQueue::INVALID_BUFFER_SLOT;
765 }
766
767 ClientCache::getInstance().registerErasedRecipient(clientCacheId, wp<ErasedRecipient>(this));
768
rnleeed20fa42021-08-10 18:00:03 -0700769 int hwcCacheSlot = getFreeHwcCacheSlot();
Marissa Wall947d34e2019-03-29 14:03:53 -0700770 mCachedBuffers[clientCacheId] = {hwcCacheSlot, mCounter++};
771 return hwcCacheSlot;
772}
773
rnleeed20fa42021-08-10 18:00:03 -0700774int BufferStateLayer::HwcSlotGenerator::getFreeHwcCacheSlot() REQUIRES(mMutex) {
Marissa Wall947d34e2019-03-29 14:03:53 -0700775 if (mFreeHwcCacheSlots.empty()) {
776 evictLeastRecentlyUsed();
777 }
778
rnleeed20fa42021-08-10 18:00:03 -0700779 int hwcCacheSlot = mFreeHwcCacheSlots.top();
Marissa Wall947d34e2019-03-29 14:03:53 -0700780 mFreeHwcCacheSlots.pop();
781 return hwcCacheSlot;
782}
783
784void BufferStateLayer::HwcSlotGenerator::evictLeastRecentlyUsed() REQUIRES(mMutex) {
785 uint64_t minCounter = UINT_MAX;
786 client_cache_t minClientCacheId = {};
787 for (const auto& [clientCacheId, slotCounter] : mCachedBuffers) {
788 const auto& [hwcCacheSlot, counter] = slotCounter;
789 if (counter < minCounter) {
790 minCounter = counter;
791 minClientCacheId = clientCacheId;
792 }
793 }
794 eraseBufferLocked(minClientCacheId);
795
796 ClientCache::getInstance().unregisterErasedRecipient(minClientCacheId, this);
797}
798
799void BufferStateLayer::HwcSlotGenerator::eraseBufferLocked(const client_cache_t& clientCacheId)
800 REQUIRES(mMutex) {
801 auto itr = mCachedBuffers.find(clientCacheId);
802 if (itr == mCachedBuffers.end()) {
803 return;
804 }
805 auto& [hwcCacheSlot, counter] = itr->second;
806
807 // TODO send to hwc cache and resources
808
809 mFreeHwcCacheSlots.push(hwcCacheSlot);
810 mCachedBuffers.erase(clientCacheId);
811}
chaviw4244e032019-09-04 11:27:49 -0700812
813void BufferStateLayer::gatherBufferInfo() {
chaviwdebadb82020-03-26 14:57:24 -0700814 BufferLayer::gatherBufferInfo();
chaviw4244e032019-09-04 11:27:49 -0700815
chaviwdebadb82020-03-26 14:57:24 -0700816 const State& s(getDrawingState());
chaviw4244e032019-09-04 11:27:49 -0700817 mBufferInfo.mDesiredPresentTime = s.desiredPresentTime;
818 mBufferInfo.mFenceTime = std::make_shared<FenceTime>(s.acquireFence);
819 mBufferInfo.mFence = s.acquireFence;
chaviw766c9c52021-02-10 17:36:47 -0800820 mBufferInfo.mTransform = s.bufferTransform;
Robert Carr167bdde2021-07-28 11:26:51 -0700821 auto lastDataspace = mBufferInfo.mDataspace;
chaviw4244e032019-09-04 11:27:49 -0700822 mBufferInfo.mDataspace = translateDataspace(s.dataspace);
Robert Carr167bdde2021-07-28 11:26:51 -0700823 if (lastDataspace != mBufferInfo.mDataspace) {
824 mFlinger->mSomeDataspaceChanged = true;
825 }
Vishnu Nair5cc9ac02021-04-19 13:23:38 -0700826 mBufferInfo.mCrop = computeBufferCrop(s);
chaviw4244e032019-09-04 11:27:49 -0700827 mBufferInfo.mScaleMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
828 mBufferInfo.mSurfaceDamage = s.surfaceDamageRegion;
829 mBufferInfo.mHdrMetadata = s.hdrMetadata;
830 mBufferInfo.mApi = s.api;
chaviw4244e032019-09-04 11:27:49 -0700831 mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;
chaviwf83ce182019-09-12 14:43:08 -0700832 mBufferInfo.mBufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);
chaviw4244e032019-09-04 11:27:49 -0700833}
834
Robert Carr916b0362020-10-06 13:53:03 -0700835uint32_t BufferStateLayer::getEffectiveScalingMode() const {
836 return NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
837}
838
Vishnu Nair5cc9ac02021-04-19 13:23:38 -0700839Rect BufferStateLayer::computeBufferCrop(const State& s) {
chaviwf3f40fe2021-04-27 15:54:02 -0500840 if (s.buffer && !s.bufferCrop.isEmpty()) {
841 Rect bufferCrop;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800842 s.buffer->getBounds().intersect(s.bufferCrop, &bufferCrop);
chaviwf3f40fe2021-04-27 15:54:02 -0500843 return bufferCrop;
844 } else if (s.buffer) {
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800845 return s.buffer->getBounds();
chaviwf3f40fe2021-04-27 15:54:02 -0500846 } else {
847 return s.bufferCrop;
chaviw4244e032019-09-04 11:27:49 -0700848 }
chaviw4244e032019-09-04 11:27:49 -0700849}
850
chaviwb4c6e582019-08-16 14:35:07 -0700851sp<Layer> BufferStateLayer::createClone() {
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800852 LayerCreationArgs args(mFlinger.get(), nullptr, mName + " (Mirror)", 0, LayerMetadata());
chaviwb4c6e582019-08-16 14:35:07 -0700853 args.textureName = mTextureName;
Lloyd Pique1c3a5eb2019-10-03 13:07:08 -0700854 sp<BufferStateLayer> layer = mFlinger->getFactory().createBufferStateLayer(args);
chaviwb4c6e582019-08-16 14:35:07 -0700855 layer->mHwcSlotGenerator = mHwcSlotGenerator;
856 layer->setInitialValuesForClone(this);
857 return layer;
858}
Valerie Hau92bf5482020-02-10 09:49:08 -0800859
Vishnu Naire7f79c52020-10-29 14:45:03 -0700860bool BufferStateLayer::bufferNeedsFiltering() const {
861 const State& s(getDrawingState());
862 if (!s.buffer) {
863 return false;
864 }
865
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800866 int32_t bufferWidth = static_cast<int32_t>(s.buffer->getWidth());
867 int32_t bufferHeight = static_cast<int32_t>(s.buffer->getHeight());
Vishnu Naire7f79c52020-10-29 14:45:03 -0700868
869 // Undo any transformations on the buffer and return the result.
chaviw766c9c52021-02-10 17:36:47 -0800870 if (s.bufferTransform & ui::Transform::ROT_90) {
Vishnu Naire7f79c52020-10-29 14:45:03 -0700871 std::swap(bufferWidth, bufferHeight);
872 }
873
874 if (s.transformToDisplayInverse) {
875 uint32_t invTransform = DisplayDevice::getPrimaryDisplayRotationFlags();
876 if (invTransform & ui::Transform::ROT_90) {
877 std::swap(bufferWidth, bufferHeight);
878 }
879 }
880
881 const Rect layerSize{getBounds()};
882 return layerSize.width() != bufferWidth || layerSize.height() != bufferHeight;
883}
Robert Carr7121caf2020-12-15 13:07:32 -0800884
Robert Carr7121caf2020-12-15 13:07:32 -0800885void BufferStateLayer::decrementPendingBufferCount() {
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800886 int32_t pendingBuffers = --mPendingBufferTransactions;
887 tracePendingBufferCount(pendingBuffers);
Robert Carr7121caf2020-12-15 13:07:32 -0800888}
889
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800890void BufferStateLayer::tracePendingBufferCount(int32_t pendingBuffers) {
891 ATRACE_INT(mBlastTransactionName.c_str(), pendingBuffers);
Robert Carr7121caf2020-12-15 13:07:32 -0800892}
893
Robert Carr7121caf2020-12-15 13:07:32 -0800894
chaviw39d01472021-04-08 14:26:24 -0500895/*
896 * We don't want to send the layer's transform to input, but rather the
897 * parent's transform. This is because BufferStateLayer's transform is
898 * information about how the buffer is placed on screen. The parent's
899 * transform makes more sense to send since it's information about how the
900 * layer is placed on screen. This transform is used by input to determine
901 * how to go from screen space back to window space.
902 */
903ui::Transform BufferStateLayer::getInputTransform() const {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000904 sp<Layer> parent = mDrawingParent.promote();
chaviw39d01472021-04-08 14:26:24 -0500905 if (parent == nullptr) {
906 return ui::Transform();
907 }
908
909 return parent->getTransform();
910}
911
912/**
913 * Similar to getInputTransform, we need to update the bounds to include the transform.
914 * This is because bounds for BSL doesn't include buffer transform, where the input assumes
915 * that's already included.
916 */
917Rect BufferStateLayer::getInputBounds() const {
918 Rect bufferBounds = getCroppedBufferSize(getDrawingState());
919 if (mDrawingState.transform.getType() == ui::Transform::IDENTITY || !bufferBounds.isValid()) {
920 return bufferBounds;
921 }
922 return mDrawingState.transform.transform(bufferBounds);
923}
924
Ady Abraham9dada822022-02-03 10:26:59 -0800925bool BufferStateLayer::simpleBufferUpdate(const layer_state_t& s) const {
926 const uint64_t requiredFlags = layer_state_t::eBufferChanged;
927
928 const uint64_t deniedFlags = layer_state_t::eProducerDisconnect | layer_state_t::eLayerChanged |
929 layer_state_t::eRelativeLayerChanged | layer_state_t::eTransparentRegionChanged |
930 layer_state_t::eFlagsChanged | layer_state_t::eBlurRegionsChanged |
931 layer_state_t::eLayerStackChanged | layer_state_t::eAutoRefreshChanged |
932 layer_state_t::eReparent;
933
934 const uint64_t allowedFlags = layer_state_t::eHasListenerCallbacksChanged |
935 layer_state_t::eFrameRateSelectionPriority | layer_state_t::eFrameRateChanged |
936 layer_state_t::eSurfaceDamageRegionChanged | layer_state_t::eApiChanged |
937 layer_state_t::eMetadataChanged | layer_state_t::eDropInputModeChanged |
938 layer_state_t::eInputInfoChanged;
939
940 if ((s.what & requiredFlags) != requiredFlags) {
941 ALOGV("%s: false [missing required flags 0x%" PRIx64 "]", __func__,
942 (s.what | requiredFlags) & ~s.what);
943 return false;
944 }
945
946 if (s.what & deniedFlags) {
947 ALOGV("%s: false [has denied flags 0x%" PRIx64 "]", __func__, s.what & deniedFlags);
948 return false;
949 }
950
951 if (s.what & allowedFlags) {
952 ALOGV("%s: [has allowed flags 0x%" PRIx64 "]", __func__, s.what & allowedFlags);
953 }
954
955 if (s.what & layer_state_t::ePositionChanged) {
956 if (mRequestedTransform.tx() != s.x || mRequestedTransform.ty() != s.y) {
957 ALOGV("%s: false [ePositionChanged changed]", __func__);
958 return false;
959 }
960 }
961
962 if (s.what & layer_state_t::eAlphaChanged) {
963 if (mDrawingState.color.a != s.alpha) {
964 ALOGV("%s: false [eAlphaChanged changed]", __func__);
965 return false;
966 }
967 }
968
969 if (s.what & layer_state_t::eColorTransformChanged) {
970 if (mDrawingState.colorTransform != s.colorTransform) {
971 ALOGV("%s: false [eColorTransformChanged changed]", __func__);
972 return false;
973 }
974 }
975
976 if (s.what & layer_state_t::eBackgroundColorChanged) {
977 if (mDrawingState.bgColorLayer || s.bgColorAlpha != 0) {
978 ALOGV("%s: false [eBackgroundColorChanged changed]", __func__);
979 return false;
980 }
981 }
982
983 if (s.what & layer_state_t::eMatrixChanged) {
984 if (mRequestedTransform.dsdx() != s.matrix.dsdx ||
985 mRequestedTransform.dtdy() != s.matrix.dtdy ||
986 mRequestedTransform.dtdx() != s.matrix.dtdx ||
987 mRequestedTransform.dsdy() != s.matrix.dsdy) {
988 ALOGV("%s: false [eMatrixChanged changed]", __func__);
989 return false;
990 }
991 }
992
993 if (s.what & layer_state_t::eCornerRadiusChanged) {
994 if (mDrawingState.cornerRadius != s.cornerRadius) {
995 ALOGV("%s: false [eCornerRadiusChanged changed]", __func__);
996 return false;
997 }
998 }
999
1000 if (s.what & layer_state_t::eBackgroundBlurRadiusChanged) {
1001 if (mDrawingState.backgroundBlurRadius != static_cast<int>(s.backgroundBlurRadius)) {
1002 ALOGV("%s: false [eBackgroundBlurRadiusChanged changed]", __func__);
1003 return false;
1004 }
1005 }
1006
1007 if (s.what & layer_state_t::eTransformChanged) {
1008 if (mDrawingState.bufferTransform != s.transform) {
1009 ALOGV("%s: false [eTransformChanged changed]", __func__);
1010 return false;
1011 }
1012 }
1013
1014 if (s.what & layer_state_t::eTransformToDisplayInverseChanged) {
1015 if (mDrawingState.transformToDisplayInverse != s.transformToDisplayInverse) {
1016 ALOGV("%s: false [eTransformToDisplayInverseChanged changed]", __func__);
1017 return false;
1018 }
1019 }
1020
1021 if (s.what & layer_state_t::eCropChanged) {
1022 if (mDrawingState.crop != s.crop) {
1023 ALOGV("%s: false [eCropChanged changed]", __func__);
1024 return false;
1025 }
1026 }
1027
1028 if (s.what & layer_state_t::eDataspaceChanged) {
1029 if (mDrawingState.dataspace != s.dataspace) {
1030 ALOGV("%s: false [eDataspaceChanged changed]", __func__);
1031 return false;
1032 }
1033 }
1034
1035 if (s.what & layer_state_t::eHdrMetadataChanged) {
1036 if (mDrawingState.hdrMetadata != s.hdrMetadata) {
1037 ALOGV("%s: false [eHdrMetadataChanged changed]", __func__);
1038 return false;
1039 }
1040 }
1041
1042 if (s.what & layer_state_t::eSidebandStreamChanged) {
1043 if (mDrawingState.sidebandStream != s.sidebandStream) {
1044 ALOGV("%s: false [eSidebandStreamChanged changed]", __func__);
1045 return false;
1046 }
1047 }
1048
1049 if (s.what & layer_state_t::eColorSpaceAgnosticChanged) {
1050 if (mDrawingState.colorSpaceAgnostic != s.colorSpaceAgnostic) {
1051 ALOGV("%s: false [eColorSpaceAgnosticChanged changed]", __func__);
1052 return false;
1053 }
1054 }
1055
1056 if (s.what & layer_state_t::eShadowRadiusChanged) {
1057 if (mDrawingState.shadowRadius != s.shadowRadius) {
1058 ALOGV("%s: false [eShadowRadiusChanged changed]", __func__);
1059 return false;
1060 }
1061 }
1062
1063 if (s.what & layer_state_t::eFixedTransformHintChanged) {
1064 if (mDrawingState.fixedTransformHint != s.fixedTransformHint) {
1065 ALOGV("%s: false [eFixedTransformHintChanged changed]", __func__);
1066 return false;
1067 }
1068 }
1069
1070 if (s.what & layer_state_t::eTrustedOverlayChanged) {
1071 if (mDrawingState.isTrustedOverlay != s.isTrustedOverlay) {
1072 ALOGV("%s: false [eTrustedOverlayChanged changed]", __func__);
1073 return false;
1074 }
1075 }
1076
1077 if (s.what & layer_state_t::eStretchChanged) {
1078 StretchEffect temp = s.stretchEffect;
1079 temp.sanitize();
1080 if (mDrawingState.stretchEffect != temp) {
1081 ALOGV("%s: false [eStretchChanged changed]", __func__);
1082 return false;
1083 }
1084 }
1085
1086 if (s.what & layer_state_t::eBufferCropChanged) {
1087 if (mDrawingState.bufferCrop != s.bufferCrop) {
1088 ALOGV("%s: false [eBufferCropChanged changed]", __func__);
1089 return false;
1090 }
1091 }
1092
1093 if (s.what & layer_state_t::eDestinationFrameChanged) {
1094 if (mDrawingState.destinationFrame != s.destinationFrame) {
1095 ALOGV("%s: false [eDestinationFrameChanged changed]", __func__);
1096 return false;
1097 }
1098 }
1099
Sally Qi81d95e62022-03-21 19:41:33 -07001100 if (s.what & layer_state_t::eDimmingEnabledChanged) {
1101 if (mDrawingState.dimmingEnabled != s.dimmingEnabled) {
1102 ALOGV("%s: false [eDimmingEnabledChanged changed]", __func__);
1103 return false;
1104 }
1105 }
1106
Ady Abraham9dada822022-02-03 10:26:59 -08001107 ALOGV("%s: true", __func__);
1108 return true;
1109}
1110
Marissa Wall61c58622018-07-18 10:12:20 -07001111} // namespace android