1 /*
2 * Copyright (C) 2007 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 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18
19 #pragma clang diagnostic push
20 #pragma clang diagnostic ignored "-Wconversion"
21
22 //#define LOG_NDEBUG 0
23 #undef LOG_TAG
24 #define LOG_TAG "Layer"
25 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
26
27 #include <android-base/properties.h>
28 #include <android-base/stringprintf.h>
29 #include <binder/IPCThreadState.h>
30 #include <common/trace.h>
31 #include <compositionengine/CompositionEngine.h>
32 #include <compositionengine/Display.h>
33 #include <compositionengine/LayerFECompositionState.h>
34 #include <compositionengine/OutputLayer.h>
35 #include <compositionengine/impl/OutputLayerCompositionState.h>
36 #include <cutils/compiler.h>
37 #include <cutils/native_handle.h>
38 #include <cutils/properties.h>
39 #include <ftl/enum.h>
40 #include <ftl/fake_guard.h>
41 #include <gui/BufferItem.h>
42 #include <gui/Surface.h>
43 #include <math.h>
44 #include <private/android_filesystem_config.h>
45 #include <renderengine/RenderEngine.h>
46 #include <stdint.h>
47 #include <stdlib.h>
48 #include <sys/types.h>
49 #include <system/graphics-base-v1.0.h>
50 #include <ui/DebugUtils.h>
51 #include <ui/FloatRect.h>
52 #include <ui/GraphicBuffer.h>
53 #include <ui/HdrRenderTypeUtils.h>
54 #include <ui/PixelFormat.h>
55 #include <ui/Rect.h>
56 #include <ui/Transform.h>
57 #include <utils/Errors.h>
58 #include <utils/Log.h>
59 #include <utils/NativeHandle.h>
60 #include <utils/StopWatch.h>
61
62 #include <algorithm>
63 #include <optional>
64
65 #include "DisplayDevice.h"
66 #include "DisplayHardware/HWComposer.h"
67 #include "FrameTimeline/FrameTimeline.h"
68 #include "FrameTracer/FrameTracer.h"
69 #include "FrontEnd/LayerCreationArgs.h"
70 #include "FrontEnd/LayerHandle.h"
71 #include "Layer.h"
72 #include "LayerProtoHelper.h"
73 #include "SurfaceFlinger.h"
74 #include "TimeStats/TimeStats.h"
75 #include "TransactionCallbackInvoker.h"
76 #include "TunnelModeEnabledReporter.h"
77 #include "Utils/FenceUtils.h"
78
79 #define DEBUG_RESIZE 0
80 #define EARLY_RELEASE_ENABLED false
81
82 namespace android {
83 using namespace std::chrono_literals;
84 namespace {
85 constexpr int kDumpTableRowLength = 159;
86
87 const ui::Transform kIdentityTransform;
88
frameRateToSetFrameRateVotePayload(Layer::FrameRate frameRate)89 TimeStats::SetFrameRateVote frameRateToSetFrameRateVotePayload(Layer::FrameRate frameRate) {
90 using FrameRateCompatibility = TimeStats::SetFrameRateVote::FrameRateCompatibility;
91 using Seamlessness = TimeStats::SetFrameRateVote::Seamlessness;
92 const auto frameRateCompatibility = [frameRate] {
93 switch (frameRate.vote.type) {
94 case Layer::FrameRateCompatibility::Default:
95 return FrameRateCompatibility::Default;
96 case Layer::FrameRateCompatibility::ExactOrMultiple:
97 return FrameRateCompatibility::ExactOrMultiple;
98 default:
99 return FrameRateCompatibility::Undefined;
100 }
101 }();
102
103 const auto seamlessness = [frameRate] {
104 switch (frameRate.vote.seamlessness) {
105 case scheduler::Seamlessness::OnlySeamless:
106 return Seamlessness::ShouldBeSeamless;
107 case scheduler::Seamlessness::SeamedAndSeamless:
108 return Seamlessness::NotRequired;
109 default:
110 return Seamlessness::Undefined;
111 }
112 }();
113
114 return TimeStats::SetFrameRateVote{.frameRate = frameRate.vote.rate.getValue(),
115 .frameRateCompatibility = frameRateCompatibility,
116 .seamlessness = seamlessness};
117 }
118
119 } // namespace
120
121 using namespace ftl::flag_operators;
122
123 using base::StringAppendF;
124 using frontend::LayerSnapshot;
125 using frontend::RoundedCornerState;
126 using gui::GameMode;
127 using gui::LayerMetadata;
128 using gui::WindowInfo;
129 using ui::Size;
130
131 using PresentState = frametimeline::SurfaceFrame::PresentState;
132
Layer(const surfaceflinger::LayerCreationArgs & args)133 Layer::Layer(const surfaceflinger::LayerCreationArgs& args)
134 : sequence(args.sequence),
135 mFlinger(sp<SurfaceFlinger>::fromExisting(args.flinger)),
136 mName(base::StringPrintf("%s#%d", args.name.c_str(), sequence)),
137 mWindowType(static_cast<WindowInfo::Type>(
138 args.metadata.getInt32(gui::METADATA_WINDOW_TYPE, 0))) {
139 ALOGV("Creating Layer %s", getDebugName());
140
141 mDrawingState.crop = {0, 0, -1, -1};
142 mDrawingState.sequence = 0;
143 mDrawingState.transform.set(0, 0);
144 mDrawingState.frameNumber = 0;
145 mDrawingState.previousFrameNumber = 0;
146 mDrawingState.barrierFrameNumber = 0;
147 mDrawingState.producerId = 0;
148 mDrawingState.barrierProducerId = 0;
149 mDrawingState.bufferTransform = 0;
150 mDrawingState.transformToDisplayInverse = false;
151 mDrawingState.acquireFence = sp<Fence>::make(-1);
152 mDrawingState.acquireFenceTime = std::make_shared<FenceTime>(mDrawingState.acquireFence);
153 mDrawingState.dataspace = ui::Dataspace::V0_SRGB;
154 mDrawingState.metadata = args.metadata;
155 mDrawingState.frameTimelineInfo = {};
156 mDrawingState.postTime = -1;
157 mDeprecatedFrameTracker.setDisplayRefreshPeriod(
158 args.flinger->mScheduler->getPacesetterVsyncPeriod().ns());
159
160 mOwnerUid = args.ownerUid;
161 mOwnerPid = args.ownerPid;
162 mOwnerAppId = mOwnerUid % PER_USER_RANGE;
163
164 mPotentialCursor = args.flags & ISurfaceComposerClient::eCursorWindow;
165 mLayerFEs.emplace_back(frontend::LayerHierarchy::TraversalPath{static_cast<uint32_t>(sequence)},
166 args.flinger->getFactory().createLayerFE(mName, this));
167 }
168
onFirstRef()169 void Layer::onFirstRef() {
170 mFlinger->onLayerFirstRef(this);
171 }
172
~Layer()173 Layer::~Layer() {
174 LOG_ALWAYS_FATAL_IF(std::this_thread::get_id() != mFlinger->mMainThreadId,
175 "Layer destructor called off the main thread.");
176
177 if (mBufferInfo.mBuffer != nullptr) {
178 callReleaseBufferCallback(mDrawingState.releaseBufferListener,
179 mBufferInfo.mBuffer->getBuffer(), mBufferInfo.mFrameNumber,
180 mBufferInfo.mFence);
181 }
182 const int32_t layerId = getSequence();
183 mFlinger->mTimeStats->onDestroy(layerId);
184 mFlinger->mFrameTracer->onDestroy(layerId);
185
186 mFlinger->onLayerDestroyed(this);
187
188 const auto currentTime = std::chrono::steady_clock::now();
189 if (mBufferInfo.mTimeSinceDataspaceUpdate > std::chrono::steady_clock::time_point::min()) {
190 mFlinger->mLayerEvents.emplace_back(mOwnerUid, getSequence(), mBufferInfo.mDataspace,
191 std::chrono::duration_cast<std::chrono::milliseconds>(
192 currentTime -
193 mBufferInfo.mTimeSinceDataspaceUpdate));
194 }
195
196 if (mDrawingState.sidebandStream != nullptr) {
197 mFlinger->mTunnelModeEnabledReporter->decrementTunnelModeCount();
198 }
199 if (hasTrustedPresentationListener()) {
200 mFlinger->mNumTrustedPresentationListeners--;
201 updateTrustedPresentationState(nullptr, nullptr, -1 /* time_in_ms */, true /* leaveState*/);
202 }
203 }
204
205 // ---------------------------------------------------------------------------
206 // set-up
207 // ---------------------------------------------------------------------------
getHandle()208 sp<IBinder> Layer::getHandle() {
209 Mutex::Autolock _l(mLock);
210 if (mGetHandleCalled) {
211 ALOGE("Get handle called twice" );
212 return nullptr;
213 }
214 mGetHandleCalled = true;
215 mHandleAlive = true;
216 return sp<LayerHandle>::make(mFlinger, sp<Layer>::fromExisting(this));
217 }
218
219 // ---------------------------------------------------------------------------
220 // h/w composer set-up
221 // ---------------------------------------------------------------------------
222
223 // No early returns.
updateTrustedPresentationState(const DisplayDevice * display,const frontend::LayerSnapshot * snapshot,int64_t time_in_ms,bool leaveState)224 void Layer::updateTrustedPresentationState(const DisplayDevice* display,
225 const frontend::LayerSnapshot* snapshot,
226 int64_t time_in_ms, bool leaveState) {
227 if (!hasTrustedPresentationListener()) {
228 return;
229 }
230 const bool lastState = mLastComputedTrustedPresentationState;
231 mLastComputedTrustedPresentationState = false;
232
233 if (!leaveState) {
234 const auto outputLayer = findOutputLayerForDisplay(display, snapshot->path);
235 if (outputLayer != nullptr) {
236 if (outputLayer->getState().coveredRegionExcludingDisplayOverlays) {
237 Region coveredRegion =
238 *outputLayer->getState().coveredRegionExcludingDisplayOverlays;
239 mLastComputedTrustedPresentationState =
240 computeTrustedPresentationState(snapshot->geomLayerBounds,
241 snapshot->sourceBounds(), coveredRegion,
242 snapshot->transformedBounds,
243 snapshot->alpha,
244 snapshot->geomLayerTransform,
245 mTrustedPresentationThresholds);
246 } else {
247 ALOGE("CoveredRegionExcludingDisplayOverlays was not set for %s. Don't compute "
248 "TrustedPresentationState",
249 getDebugName());
250 }
251 }
252 }
253 const bool newState = mLastComputedTrustedPresentationState;
254 if (lastState && !newState) {
255 // We were in the trusted presentation state, but now we left it,
256 // emit the callback if needed
257 if (mLastReportedTrustedPresentationState) {
258 mLastReportedTrustedPresentationState = false;
259 mTrustedPresentationListener.invoke(false);
260 }
261 // Reset the timer
262 mEnteredTrustedPresentationStateTime = -1;
263 } else if (!lastState && newState) {
264 // We were not in the trusted presentation state, but we entered it, begin the timer
265 // and make sure this gets called at least once more!
266 mEnteredTrustedPresentationStateTime = time_in_ms;
267 mFlinger->forceFutureUpdate(mTrustedPresentationThresholds.stabilityRequirementMs * 1.5);
268 }
269
270 // Has the timer elapsed, but we are still in the state? Emit a callback if needed
271 if (!mLastReportedTrustedPresentationState && newState &&
272 (time_in_ms - mEnteredTrustedPresentationStateTime >
273 mTrustedPresentationThresholds.stabilityRequirementMs)) {
274 mLastReportedTrustedPresentationState = true;
275 mTrustedPresentationListener.invoke(true);
276 }
277 }
278
279 /**
280 * See SurfaceComposerClient.h: setTrustedPresentationCallback for discussion
281 * of how the parameters and thresholds are interpreted. The general spirit is
282 * to produce an upper bound on the amount of the buffer which was presented.
283 */
computeTrustedPresentationState(const FloatRect & bounds,const FloatRect & sourceBounds,const Region & coveredRegion,const FloatRect & screenBounds,float alpha,const ui::Transform & effectiveTransform,const TrustedPresentationThresholds & thresholds)284 bool Layer::computeTrustedPresentationState(const FloatRect& bounds, const FloatRect& sourceBounds,
285 const Region& coveredRegion,
286 const FloatRect& screenBounds, float alpha,
287 const ui::Transform& effectiveTransform,
288 const TrustedPresentationThresholds& thresholds) {
289 if (alpha < thresholds.minAlpha) {
290 return false;
291 }
292 if (sourceBounds.getWidth() == 0 || sourceBounds.getHeight() == 0) {
293 return false;
294 }
295 if (screenBounds.getWidth() == 0 || screenBounds.getHeight() == 0) {
296 return false;
297 }
298
299 const float sx = effectiveTransform.dsdx();
300 const float sy = effectiveTransform.dsdy();
301 float fractionRendered = std::min(sx * sy, 1.0f);
302
303 float boundsOverSourceW = bounds.getWidth() / (float)sourceBounds.getWidth();
304 float boundsOverSourceH = bounds.getHeight() / (float)sourceBounds.getHeight();
305 fractionRendered *= boundsOverSourceW * boundsOverSourceH;
306
307 Region tJunctionFreeRegion = Region::createTJunctionFreeRegion(coveredRegion);
308 // Compute the size of all the rects since they may be disconnected.
309 float coveredSize = 0;
310 for (auto rect = tJunctionFreeRegion.begin(); rect < tJunctionFreeRegion.end(); rect++) {
311 float size = rect->width() * rect->height();
312 coveredSize += size;
313 }
314
315 fractionRendered *= (1 - (coveredSize / (screenBounds.getWidth() * screenBounds.getHeight())));
316
317 if (fractionRendered < thresholds.minFractionRendered) {
318 return false;
319 }
320
321 return true;
322 }
323
getCroppedBufferSize(const State & s) const324 Rect Layer::getCroppedBufferSize(const State& s) const {
325 Rect size = getBufferSize(s);
326 Rect crop = Rect(getCrop(s));
327 if (!crop.isEmpty() && size.isValid()) {
328 size.intersect(crop, &size);
329 } else if (!crop.isEmpty()) {
330 size = crop;
331 }
332 return size;
333 }
334
getDebugName() const335 const char* Layer::getDebugName() const {
336 return mName.c_str();
337 }
338
339 // ---------------------------------------------------------------------------
340 // drawing...
341 // ---------------------------------------------------------------------------
342
getCompositionType(const DisplayDevice & display) const343 aidl::android::hardware::graphics::composer3::Composition Layer::getCompositionType(
344 const DisplayDevice& display) const {
345 const auto outputLayer = findOutputLayerForDisplay(&display);
346 return getCompositionType(outputLayer);
347 }
348
getCompositionType(const compositionengine::OutputLayer * outputLayer) const349 aidl::android::hardware::graphics::composer3::Composition Layer::getCompositionType(
350 const compositionengine::OutputLayer* outputLayer) const {
351 if (outputLayer == nullptr) {
352 return aidl::android::hardware::graphics::composer3::Composition::INVALID;
353 }
354 if (outputLayer->getState().hwc) {
355 return (*outputLayer->getState().hwc).hwcCompositionType;
356 } else {
357 return aidl::android::hardware::graphics::composer3::Composition::CLIENT;
358 }
359 }
360
361 // ----------------------------------------------------------------------------
362 // transaction
363 // ----------------------------------------------------------------------------
364
commitTransaction()365 void Layer::commitTransaction() REQUIRES(mFlinger->mStateLock) {
366 // Set the present state for all bufferlessSurfaceFramesTX to Presented. The
367 // bufferSurfaceFrameTX will be presented in latchBuffer.
368 for (auto& [token, surfaceFrame] : mDrawingState.bufferlessSurfaceFramesTX) {
369 if (surfaceFrame->getPresentState() != PresentState::Presented) {
370 // With applyPendingStates, we could end up having presented surfaceframes from previous
371 // states
372 surfaceFrame->setPresentState(PresentState::Presented, mLastLatchTime);
373 mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
374 }
375 }
376 mDrawingState.bufferlessSurfaceFramesTX.clear();
377 }
378
setTransactionFlags(uint32_t mask)379 void Layer::setTransactionFlags(uint32_t mask) {
380 mTransactionFlags |= mask;
381 }
382
setCrop(const FloatRect & crop)383 bool Layer::setCrop(const FloatRect& crop) {
384 if (mDrawingState.crop == crop) return false;
385 mDrawingState.sequence++;
386 mDrawingState.crop = crop;
387
388 setTransactionFlags(eTransactionNeeded);
389 return true;
390 }
391
isLayerFocusedBasedOnPriority(int32_t priority)392 bool Layer::isLayerFocusedBasedOnPriority(int32_t priority) {
393 return priority == PRIORITY_FOCUSED_WITH_MODE || priority == PRIORITY_FOCUSED_WITHOUT_MODE;
394 };
395
setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo & info,nsecs_t postTime,gui::GameMode gameMode)396 void Layer::setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info,
397 nsecs_t postTime, gui::GameMode gameMode)
398 REQUIRES(mFlinger->mStateLock) {
399 mDrawingState.postTime = postTime;
400
401 // Check if one of the bufferlessSurfaceFramesTX contains the same vsyncId. This can happen if
402 // there are two transactions with the same token, the first one without a buffer and the
403 // second one with a buffer. We promote the bufferlessSurfaceFrame to a bufferSurfaceFrameTX
404 // in that case.
405 auto it = mDrawingState.bufferlessSurfaceFramesTX.find(info.vsyncId);
406 if (it != mDrawingState.bufferlessSurfaceFramesTX.end()) {
407 // Promote the bufferlessSurfaceFrame to a bufferSurfaceFrameTX
408 mDrawingState.bufferSurfaceFrameTX = it->second;
409 mDrawingState.bufferlessSurfaceFramesTX.erase(it);
410 mDrawingState.bufferSurfaceFrameTX->promoteToBuffer();
411 mDrawingState.bufferSurfaceFrameTX->setActualQueueTime(postTime);
412 } else {
413 mDrawingState.bufferSurfaceFrameTX =
414 createSurfaceFrameForBuffer(info, postTime, mTransactionName, gameMode);
415 }
416
417 setFrameTimelineVsyncForSkippedFrames(info, postTime, mTransactionName, gameMode);
418 }
419
setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo & info,nsecs_t postTime,gui::GameMode gameMode)420 void Layer::setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo& info,
421 nsecs_t postTime,
422 gui::GameMode gameMode) {
423 mDrawingState.frameTimelineInfo = info;
424 mDrawingState.postTime = postTime;
425 setTransactionFlags(eTransactionNeeded);
426
427 if (const auto& bufferSurfaceFrameTX = mDrawingState.bufferSurfaceFrameTX;
428 bufferSurfaceFrameTX != nullptr) {
429 if (bufferSurfaceFrameTX->getToken() == info.vsyncId) {
430 // BufferSurfaceFrame takes precedence over BufferlessSurfaceFrame. If the same token is
431 // being used for BufferSurfaceFrame, don't create a new one.
432 return;
433 }
434 }
435 // For Transactions without a buffer, we create only one SurfaceFrame per vsyncId. If multiple
436 // transactions use the same vsyncId, we just treat them as one SurfaceFrame (unless they are
437 // targeting different vsyncs).
438 auto it = mDrawingState.bufferlessSurfaceFramesTX.find(info.vsyncId);
439 if (it == mDrawingState.bufferlessSurfaceFramesTX.end()) {
440 auto surfaceFrame = createSurfaceFrameForTransaction(info, postTime, gameMode);
441 mDrawingState.bufferlessSurfaceFramesTX[info.vsyncId] = surfaceFrame;
442 } else {
443 if (it->second->getPresentState() == PresentState::Presented) {
444 // If the SurfaceFrame was already presented, its safe to overwrite it since it must
445 // have been from previous vsync.
446 it->second = createSurfaceFrameForTransaction(info, postTime, gameMode);
447 }
448 }
449
450 setFrameTimelineVsyncForSkippedFrames(info, postTime, mTransactionName, gameMode);
451 }
452
addSurfaceFrameDroppedForBuffer(std::shared_ptr<frametimeline::SurfaceFrame> & surfaceFrame,nsecs_t dropTime)453 void Layer::addSurfaceFrameDroppedForBuffer(
454 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t dropTime) {
455 surfaceFrame->setDropTime(dropTime);
456 surfaceFrame->setPresentState(PresentState::Dropped);
457 mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
458 }
459
addSurfaceFramePresentedForBuffer(std::shared_ptr<frametimeline::SurfaceFrame> & surfaceFrame,nsecs_t acquireFenceTime,nsecs_t currentLatchTime)460 void Layer::addSurfaceFramePresentedForBuffer(
461 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t acquireFenceTime,
462 nsecs_t currentLatchTime) REQUIRES(mFlinger->mStateLock) {
463 surfaceFrame->setAcquireFenceTime(acquireFenceTime);
464 surfaceFrame->setPresentState(PresentState::Presented, mLastLatchTime);
465 mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
466 updateLastLatchTime(currentLatchTime);
467 }
468
createSurfaceFrameForTransaction(const FrameTimelineInfo & info,nsecs_t postTime,gui::GameMode gameMode)469 std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForTransaction(
470 const FrameTimelineInfo& info, nsecs_t postTime, gui::GameMode gameMode)
471 REQUIRES(mFlinger->mStateLock) {
472 auto surfaceFrame =
473 mFlinger->mFrameTimeline->createSurfaceFrameForToken(info, mOwnerPid, mOwnerUid,
474 getSequence(), mName,
475 mTransactionName,
476 /*isBuffer*/ false, gameMode);
477 // Buffer hasn't yet been latched, so use mDrawingState
478 surfaceFrame->setDesiredPresentTime(mDrawingState.desiredPresentTime);
479
480 surfaceFrame->setActualStartTime(info.startTimeNanos);
481 // For Transactions, the post time is considered to be both queue and acquire fence time.
482 surfaceFrame->setActualQueueTime(postTime);
483 surfaceFrame->setAcquireFenceTime(postTime);
484 const auto fps = mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());
485 if (fps) {
486 surfaceFrame->setRenderRate(*fps);
487 }
488 return surfaceFrame;
489 }
490
createSurfaceFrameForBuffer(const FrameTimelineInfo & info,nsecs_t queueTime,std::string debugName,gui::GameMode gameMode)491 std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForBuffer(
492 const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName,
493 gui::GameMode gameMode) REQUIRES(mFlinger->mStateLock) {
494 auto surfaceFrame =
495 mFlinger->mFrameTimeline->createSurfaceFrameForToken(info, mOwnerPid, mOwnerUid,
496 getSequence(), mName, debugName,
497 /*isBuffer*/ true, gameMode);
498 // Buffer hasn't yet been latched, so use mDrawingState
499 surfaceFrame->setDesiredPresentTime(mDrawingState.desiredPresentTime);
500 surfaceFrame->setActualStartTime(info.startTimeNanos);
501 // For buffers, acquire fence time will set during latch.
502 surfaceFrame->setActualQueueTime(queueTime);
503 const auto fps = mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());
504 if (fps) {
505 surfaceFrame->setRenderRate(*fps);
506 }
507 return surfaceFrame;
508 }
509
setFrameTimelineVsyncForSkippedFrames(const FrameTimelineInfo & info,nsecs_t postTime,std::string debugName,gui::GameMode gameMode)510 void Layer::setFrameTimelineVsyncForSkippedFrames(const FrameTimelineInfo& info, nsecs_t postTime,
511 std::string debugName, gui::GameMode gameMode)
512 REQUIRES(mFlinger->mStateLock) {
513 if (info.skippedFrameVsyncId == FrameTimelineInfo::INVALID_VSYNC_ID) {
514 return;
515 }
516
517 FrameTimelineInfo skippedFrameTimelineInfo = info;
518 skippedFrameTimelineInfo.vsyncId = info.skippedFrameVsyncId;
519
520 auto surfaceFrame =
521 mFlinger->mFrameTimeline->createSurfaceFrameForToken(skippedFrameTimelineInfo,
522 mOwnerPid, mOwnerUid,
523 getSequence(), mName, debugName,
524 /*isBuffer*/ false, gameMode);
525 // Buffer hasn't yet been latched, so use mDrawingState
526 surfaceFrame->setDesiredPresentTime(mDrawingState.desiredPresentTime);
527 surfaceFrame->setActualStartTime(skippedFrameTimelineInfo.skippedFrameStartTimeNanos);
528 // For Transactions, the post time is considered to be both queue and acquire fence time.
529 surfaceFrame->setActualQueueTime(postTime);
530 surfaceFrame->setAcquireFenceTime(postTime);
531 const auto fps = mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());
532 if (fps) {
533 surfaceFrame->setRenderRate(*fps);
534 }
535 addSurfaceFrameDroppedForBuffer(surfaceFrame, postTime);
536 }
537
setFrameRateForLayerTree(FrameRate frameRate,const scheduler::LayerProps & layerProps,nsecs_t now)538 bool Layer::setFrameRateForLayerTree(FrameRate frameRate, const scheduler::LayerProps& layerProps,
539 nsecs_t now) {
540 if (mDrawingState.frameRateForLayerTree == frameRate) {
541 return false;
542 }
543
544 mDrawingState.frameRateForLayerTree = frameRate;
545 mFlinger->mScheduler
546 ->recordLayerHistory(sequence, layerProps, now, now,
547 scheduler::LayerHistory::LayerUpdateType::SetFrameRate);
548 return true;
549 }
550
getFrameRateForLayerTree() const551 Layer::FrameRate Layer::getFrameRateForLayerTree() const {
552 return getDrawingState().frameRateForLayerTree;
553 }
554
555 // ----------------------------------------------------------------------------
556 // debugging
557 // ----------------------------------------------------------------------------
558
miniDumpHeader(std::string & result)559 void Layer::miniDumpHeader(std::string& result) {
560 result.append(kDumpTableRowLength, '-');
561 result.append("\n");
562 result.append(" Layer name\n");
563 result.append(" Z | ");
564 result.append(" Window Type | ");
565 result.append(" Comp Type | ");
566 result.append(" Transform | ");
567 result.append(" Disp Frame (LTRB) | ");
568 result.append(" Source Crop (LTRB) | ");
569 result.append(" Frame Rate (Explicit) (Seamlessness) [Focused]\n");
570 result.append(kDumpTableRowLength, '-');
571 result.append("\n");
572 }
573
miniDump(std::string & result,const frontend::LayerSnapshot & snapshot,const DisplayDevice & display) const574 void Layer::miniDump(std::string& result, const frontend::LayerSnapshot& snapshot,
575 const DisplayDevice& display) const {
576 const auto outputLayer = findOutputLayerForDisplay(&display, snapshot.path);
577 if (!outputLayer) {
578 return;
579 }
580
581 StringAppendF(&result, " %s\n", snapshot.debugName.c_str());
582 StringAppendF(&result, " %10zu | ", snapshot.globalZ);
583 StringAppendF(&result, " %10d | ",
584 snapshot.layerMetadata.getInt32(gui::METADATA_WINDOW_TYPE, 0));
585 StringAppendF(&result, "%10s | ", toString(getCompositionType(outputLayer)).c_str());
586 const auto& outputLayerState = outputLayer->getState();
587 StringAppendF(&result, "%10s | ", toString(outputLayerState.bufferTransform).c_str());
588 const Rect& frame = outputLayerState.displayFrame;
589 StringAppendF(&result, "%4d %4d %4d %4d | ", frame.left, frame.top, frame.right, frame.bottom);
590 const FloatRect& crop = outputLayerState.sourceCrop;
591 StringAppendF(&result, "%6.1f %6.1f %6.1f %6.1f | ", crop.left, crop.top, crop.right,
592 crop.bottom);
593 const auto frameRate = snapshot.frameRate;
594 std::string frameRateStr;
595 if (frameRate.vote.rate.isValid()) {
596 StringAppendF(&frameRateStr, "%.2f", frameRate.vote.rate.getValue());
597 }
598 if (frameRate.vote.rate.isValid() || frameRate.vote.type != FrameRateCompatibility::Default) {
599 StringAppendF(&result, "%6s %15s %17s", frameRateStr.c_str(),
600 ftl::enum_string(frameRate.vote.type).c_str(),
601 ftl::enum_string(frameRate.vote.seamlessness).c_str());
602 } else if (frameRate.category != FrameRateCategory::Default) {
603 StringAppendF(&result, "%6s %15s %17s", frameRateStr.c_str(),
604 (std::string("Cat::") + ftl::enum_string(frameRate.category)).c_str(),
605 ftl::enum_string(frameRate.vote.seamlessness).c_str());
606 } else {
607 result.append(41, ' ');
608 }
609
610 const auto focused = isLayerFocusedBasedOnPriority(snapshot.frameRateSelectionPriority);
611 StringAppendF(&result, " [%s]\n", focused ? "*" : " ");
612
613 result.append(kDumpTableRowLength, '-');
614 result.append("\n");
615 }
616
dumpFrameStats(std::string & result) const617 void Layer::dumpFrameStats(std::string& result) const {
618 if (FlagManager::getInstance().deprecate_frame_tracker()) {
619 FrameStats fs = FrameStats();
620 getFrameStats(&fs);
621 for (auto desired = fs.desiredPresentTimesNano.begin(),
622 actual = fs.actualPresentTimesNano.begin(),
623 ready = fs.frameReadyTimesNano.begin();
624 desired != fs.desiredPresentTimesNano.end() &&
625 actual != fs.actualPresentTimesNano.end() && ready != fs.frameReadyTimesNano.end();
626 ++desired, ++actual, ++ready) {
627 result.append(std::format("{}\t{}\t{}\n", *desired, *actual, *ready));
628 }
629
630 result.push_back('\n');
631 } else {
632 mDeprecatedFrameTracker.dumpStats(result);
633 }
634 }
635
clearFrameStats()636 void Layer::clearFrameStats() {
637 if (FlagManager::getInstance().deprecate_frame_tracker()) {
638 mFrameStatsHistorySize = 0;
639 } else {
640 mDeprecatedFrameTracker.clearStats();
641 }
642 }
643
getFrameStats(FrameStats * outStats) const644 void Layer::getFrameStats(FrameStats* outStats) const {
645 if (FlagManager::getInstance().deprecate_frame_tracker()) {
646 if (auto ftl = getTimeline()) {
647 float fps = ftl->get().computeFps({getSequence()});
648 ftl->get().generateFrameStats(getSequence(), mFrameStatsHistorySize, outStats);
649 outStats->refreshPeriodNano = Fps::fromValue(fps).getPeriodNsecs();
650 }
651 } else {
652 mDeprecatedFrameTracker.getStats(outStats);
653 }
654 }
655
onDisconnect()656 void Layer::onDisconnect() {
657 const int32_t layerId = getSequence();
658 mFlinger->mTimeStats->onDestroy(layerId);
659 mFlinger->mFrameTracer->onDestroy(layerId);
660 }
661
writeCompositionStateToProto(perfetto::protos::LayerProto * layerProto,ui::LayerStack layerStack)662 void Layer::writeCompositionStateToProto(perfetto::protos::LayerProto* layerProto,
663 ui::LayerStack layerStack) {
664 ftl::FakeGuard guard(mFlinger->mStateLock); // Called from the main thread.
665 ftl::FakeGuard mainThreadGuard(kMainThreadContext);
666
667 // Only populate for the primary display.
668 if (const auto display = mFlinger->getDisplayFromLayerStack(layerStack)) {
669 const auto compositionType = getCompositionType(*display);
670 layerProto->set_hwc_composition_type(
671 static_cast<perfetto::protos::HwcCompositionType>(compositionType));
672 LayerProtoHelper::writeToProto(getVisibleRegion(display),
673 [&]() { return layerProto->mutable_visible_region(); });
674 }
675 }
676
findOutputLayerForDisplay(const DisplayDevice * display) const677 compositionengine::OutputLayer* Layer::findOutputLayerForDisplay(
678 const DisplayDevice* display) const {
679 if (!display) return nullptr;
680 sp<LayerFE> layerFE;
681 frontend::LayerHierarchy::TraversalPath path{.id = static_cast<uint32_t>(sequence)};
682 for (auto& [p, layer] : mLayerFEs) {
683 if (p == path) {
684 layerFE = layer;
685 }
686 }
687
688 if (!layerFE) return nullptr;
689 return display->getCompositionDisplay()->getOutputLayerForLayer(layerFE);
690 }
691
findOutputLayerForDisplay(const DisplayDevice * display,const frontend::LayerHierarchy::TraversalPath & path) const692 compositionengine::OutputLayer* Layer::findOutputLayerForDisplay(
693 const DisplayDevice* display, const frontend::LayerHierarchy::TraversalPath& path) const {
694 if (!display) return nullptr;
695 sp<LayerFE> layerFE;
696 for (auto& [p, layer] : mLayerFEs) {
697 if (p == path) {
698 layerFE = layer;
699 }
700 }
701
702 if (!layerFE) return nullptr;
703 return display->getCompositionDisplay()->getOutputLayerForLayer(layerFE);
704 }
705
getVisibleRegion(const DisplayDevice * display) const706 Region Layer::getVisibleRegion(const DisplayDevice* display) const {
707 const auto outputLayer = findOutputLayerForDisplay(display);
708 return outputLayer ? outputLayer->getState().visibleRegion : Region();
709 }
710
callReleaseBufferCallback(const sp<ITransactionCompletedListener> & listener,const sp<GraphicBuffer> & buffer,uint64_t framenumber,const sp<Fence> & releaseFence)711 void Layer::callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
712 const sp<GraphicBuffer>& buffer, uint64_t framenumber,
713 const sp<Fence>& releaseFence) {
714 if (!listener && !mBufferReleaseChannel) {
715 return;
716 }
717
718 SFTRACE_FORMAT_INSTANT("callReleaseBufferCallback %s - %" PRIu64, getDebugName(), framenumber);
719
720 ReleaseCallbackId callbackId{buffer->getId(), framenumber};
721 const sp<Fence>& fence = releaseFence ? releaseFence : Fence::NO_FENCE;
722 uint32_t currentMaxAcquiredBufferCount =
723 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(mOwnerUid);
724
725 if (FlagManager::getInstance().monitor_buffer_fences()) {
726 buffer->getDependencyMonitor().addEgress(FenceTime::makeValid(fence), "Layer release");
727 }
728
729 if (listener) {
730 listener->onReleaseBuffer(callbackId, fence, currentMaxAcquiredBufferCount);
731 }
732
733 if (!mBufferReleaseChannel) {
734 return;
735 }
736
737 status_t status = mBufferReleaseChannel->writeReleaseFence(callbackId, fence,
738 currentMaxAcquiredBufferCount);
739 if (status != OK) {
740 int error = -status;
741 // callReleaseBufferCallback is called during Layer's destructor. In this case, it's
742 // expected to receive connection errors.
743 if (error != EPIPE && error != ECONNRESET) {
744 ALOGD("[%s] writeReleaseFence failed. error %d (%s)", getDebugName(), error,
745 strerror(error));
746 }
747 }
748 }
749
findCallbackHandle()750 sp<CallbackHandle> Layer::findCallbackHandle() {
751 // If we are displayed on multiple displays in a single composition cycle then we would
752 // need to do careful tracking to enable the use of the mLastClientCompositionFence.
753 // For example we can only use it if all the displays are client comp, and we need
754 // to merge all the client comp fences. We could do this, but for now we just
755 // disable the optimization when a layer is composed on multiple displays.
756 if (mClearClientCompositionFenceOnLayerDisplayed) {
757 mLastClientCompositionFence = nullptr;
758 } else {
759 mClearClientCompositionFenceOnLayerDisplayed = true;
760 }
761
762 // The previous release fence notifies the client that SurfaceFlinger is done with the previous
763 // buffer that was presented on this layer. The first transaction that came in this frame that
764 // replaced the previous buffer on this layer needs this release fence, because the fence will
765 // let the client know when that previous buffer is removed from the screen.
766 //
767 // Every other transaction on this layer does not need a release fence because no other
768 // Transactions that were set on this layer this frame are going to have their preceding buffer
769 // removed from the display this frame.
770 //
771 // For example, if we have 3 transactions this frame. The first transaction doesn't contain a
772 // buffer so it doesn't need a previous release fence because the layer still needs the previous
773 // buffer. The second transaction contains a buffer so it needs a previous release fence because
774 // the previous buffer will be released this frame. The third transaction also contains a
775 // buffer. It replaces the buffer in the second transaction. The buffer in the second
776 // transaction will now no longer be presented so it is released immediately and the third
777 // transaction doesn't need a previous release fence.
778 sp<CallbackHandle> ch;
779 for (auto& handle : mDrawingState.callbackHandles) {
780 if (handle->releasePreviousBuffer && mPreviousReleaseBufferEndpoint == handle->listener) {
781 ch = handle;
782 break;
783 }
784 }
785 return ch;
786 }
787
prepareReleaseCallbacks(ftl::Future<FenceResult> futureFenceResult,ui::LayerStack layerStack)788 void Layer::prepareReleaseCallbacks(ftl::Future<FenceResult> futureFenceResult,
789 ui::LayerStack layerStack) {
790 sp<CallbackHandle> ch = findCallbackHandle();
791
792 if (ch != nullptr) {
793 ch->previousReleaseCallbackId = mPreviousReleaseCallbackId;
794 ch->previousReleaseFences.emplace_back(std::move(futureFenceResult));
795 ch->name = mName;
796 } else {
797 // If we didn't get a release callback yet (e.g. some scenarios when capturing
798 // screenshots asynchronously) then make sure we don't drop the fence.
799 // Older fences for the same layer stack can be dropped when a new fence arrives.
800 // An assumption here is that RenderEngine performs work sequentially, so an
801 // incoming fence will not fire before an existing fence.
802 mAdditionalPreviousReleaseFences.emplace_or_replace(layerStack,
803 std::move(futureFenceResult));
804 }
805
806 if (mBufferInfo.mBuffer) {
807 mPreviouslyPresentedLayerStacks.push_back(layerStack);
808 }
809
810 if (mDrawingState.frameNumber > 0) {
811 mDrawingState.previousFrameNumber = mDrawingState.frameNumber;
812 }
813 }
814
releasePendingBuffer(nsecs_t dequeueReadyTime)815 void Layer::releasePendingBuffer(nsecs_t dequeueReadyTime) {
816 for (const auto& handle : mDrawingState.callbackHandles) {
817 handle->bufferReleaseChannel = mBufferReleaseChannel;
818 handle->transformHint = mTransformHint;
819 handle->dequeueReadyTime = dequeueReadyTime;
820 handle->currentMaxAcquiredBufferCount =
821 mFlinger->getMaxAcquiredBufferCountForCurrentRefreshRate(mOwnerUid);
822 SFTRACE_FORMAT_INSTANT("releasePendingBuffer %s - %" PRIu64, getDebugName(),
823 handle->previousReleaseCallbackId.framenumber);
824 }
825
826 for (auto& handle : mDrawingState.callbackHandles) {
827 if (handle->releasePreviousBuffer && mPreviousReleaseBufferEndpoint == handle->listener) {
828 handle->previousReleaseCallbackId = mPreviousReleaseCallbackId;
829 break;
830 }
831 }
832
833 mFlinger->getTransactionCallbackInvoker().addCallbackHandles(mDrawingState.callbackHandles);
834 mDrawingState.callbackHandles = {};
835 }
836
setTransform(uint32_t transform)837 bool Layer::setTransform(uint32_t transform) {
838 if (mDrawingState.bufferTransform == transform) return false;
839 mDrawingState.bufferTransform = transform;
840 setTransactionFlags(eTransactionNeeded);
841 return true;
842 }
843
setTransformToDisplayInverse(bool transformToDisplayInverse)844 bool Layer::setTransformToDisplayInverse(bool transformToDisplayInverse) {
845 if (mDrawingState.transformToDisplayInverse == transformToDisplayInverse) return false;
846 mDrawingState.sequence++;
847 mDrawingState.transformToDisplayInverse = transformToDisplayInverse;
848 setTransactionFlags(eTransactionNeeded);
849 return true;
850 }
851
releasePreviousBuffer()852 void Layer::releasePreviousBuffer() REQUIRES(mFlinger->mStateLock) {
853 mReleasePreviousBuffer = true;
854 if (!mBufferInfo.mBuffer ||
855 (!mDrawingState.buffer->hasSameBuffer(*mBufferInfo.mBuffer) ||
856 mDrawingState.frameNumber != mBufferInfo.mFrameNumber)) {
857 // If mDrawingState has a buffer, and we are about to update again
858 // before swapping to drawing state, then the first buffer will be
859 // dropped and we should decrement the pending buffer count and
860 // call any release buffer callbacks if set.
861 callReleaseBufferCallback(mDrawingState.releaseBufferListener,
862 mDrawingState.buffer->getBuffer(), mDrawingState.frameNumber,
863 mDrawingState.acquireFence);
864 const int32_t layerId = getSequence();
865 mFlinger->mTimeStats->removeTimeRecord(layerId, mDrawingState.frameNumber);
866 decrementPendingBufferCount();
867 if (mDrawingState.bufferSurfaceFrameTX != nullptr &&
868 mDrawingState.bufferSurfaceFrameTX->getPresentState() != PresentState::Presented) {
869 addSurfaceFrameDroppedForBuffer(mDrawingState.bufferSurfaceFrameTX, systemTime());
870 mDrawingState.bufferSurfaceFrameTX.reset();
871 }
872 } else if (EARLY_RELEASE_ENABLED && mLastClientCompositionFence != nullptr) {
873 callReleaseBufferCallback(mDrawingState.releaseBufferListener,
874 mDrawingState.buffer->getBuffer(), mDrawingState.frameNumber,
875 mLastClientCompositionFence);
876 mLastClientCompositionFence = nullptr;
877 }
878 }
879
resetDrawingStateBufferInfo()880 void Layer::resetDrawingStateBufferInfo() {
881 mDrawingState.producerId = 0;
882 mDrawingState.frameNumber = 0;
883 mDrawingState.previousFrameNumber = 0;
884 mDrawingState.releaseBufferListener = nullptr;
885 mDrawingState.buffer = nullptr;
886 mDrawingState.acquireFence = sp<Fence>::make(-1);
887 mDrawingState.acquireFenceTime = std::make_unique<FenceTime>(mDrawingState.acquireFence);
888 mCallbackHandleAcquireTimeOrFence = mDrawingState.acquireFenceTime->getSignalTime();
889 mDrawingState.releaseBufferEndpoint = nullptr;
890 }
891
setBuffer(std::shared_ptr<renderengine::ExternalTexture> & buffer,const BufferData & bufferData,nsecs_t postTime,nsecs_t desiredPresentTime,bool isAutoTimestamp,const FrameTimelineInfo & info,gui::GameMode gameMode)892 bool Layer::setBuffer(std::shared_ptr<renderengine::ExternalTexture>& buffer,
893 const BufferData& bufferData, nsecs_t postTime, nsecs_t desiredPresentTime,
894 bool isAutoTimestamp, const FrameTimelineInfo& info, gui::GameMode gameMode)
895 REQUIRES(mFlinger->mStateLock) {
896 SFTRACE_FORMAT("setBuffer %s - hasBuffer=%s", getDebugName(), (buffer ? "true" : "false"));
897
898 const bool frameNumberChanged =
899 bufferData.flags.test(BufferData::BufferDataChange::frameNumberChanged);
900 const uint64_t frameNumber =
901 frameNumberChanged ? bufferData.frameNumber : mDrawingState.frameNumber + 1;
902 SFTRACE_FORMAT_INSTANT("setBuffer %s - %" PRIu64, getDebugName(), frameNumber);
903
904 if (mDrawingState.buffer) {
905 releasePreviousBuffer();
906 } else if (buffer) {
907 // if we are latching a buffer for the first time then clear the mLastLatchTime since
908 // we don't want to incorrectly classify a frame if we miss the desired present time.
909 updateLastLatchTime(0);
910 }
911
912 mDrawingState.desiredPresentTime = desiredPresentTime;
913 mDrawingState.isAutoTimestamp = isAutoTimestamp;
914 mDrawingState.latchedVsyncId = info.vsyncId;
915 mDrawingState.useVsyncIdForRefreshRateSelection = info.useForRefreshRateSelection;
916 if (!buffer) {
917 resetDrawingStateBufferInfo();
918 setTransactionFlags(eTransactionNeeded);
919 mDrawingState.bufferSurfaceFrameTX = nullptr;
920 setFrameTimelineVsyncForBufferlessTransaction(info, postTime, gameMode);
921 return true;
922 } else {
923 // release sideband stream if it exists and a non null buffer is being set
924 if (mDrawingState.sidebandStream != nullptr) {
925 setSidebandStream(nullptr, info, postTime, gameMode);
926 }
927 }
928
929 if ((mDrawingState.producerId > bufferData.producerId) ||
930 ((mDrawingState.producerId == bufferData.producerId) &&
931 (mDrawingState.frameNumber > frameNumber))) {
932 ALOGE("Out of order buffers detected for %s producedId=%d frameNumber=%" PRIu64
933 " -> producedId=%d frameNumber=%" PRIu64,
934 getDebugName(), mDrawingState.producerId, mDrawingState.frameNumber,
935 bufferData.producerId, frameNumber);
936 TransactionTraceWriter::getInstance().invoke("out_of_order_buffers_", /*overwrite=*/false);
937 }
938
939 mDrawingState.producerId = bufferData.producerId;
940 mDrawingState.barrierProducerId =
941 std::max(mDrawingState.producerId, mDrawingState.barrierProducerId);
942 mDrawingState.frameNumber = frameNumber;
943 mDrawingState.barrierFrameNumber =
944 std::max(mDrawingState.frameNumber, mDrawingState.barrierFrameNumber);
945
946 mDrawingState.releaseBufferListener = bufferData.releaseBufferListener;
947 mDrawingState.previousBuffer = std::move(mDrawingState.buffer);
948 mDrawingState.buffer = std::move(buffer);
949 mDrawingState.acquireFence = bufferData.flags.test(BufferData::BufferDataChange::fenceChanged)
950 ? bufferData.acquireFence
951 : Fence::NO_FENCE;
952 mDrawingState.acquireFenceTime = std::make_unique<FenceTime>(mDrawingState.acquireFence);
953 if (mDrawingState.acquireFenceTime->getSignalTime() == Fence::SIGNAL_TIME_PENDING) {
954 // We latched this buffer unsiganled, so we need to pass the acquire fence
955 // on the callback instead of just the acquire time, since it's unknown at
956 // this point.
957 mCallbackHandleAcquireTimeOrFence = mDrawingState.acquireFence;
958 } else {
959 mCallbackHandleAcquireTimeOrFence = mDrawingState.acquireFenceTime->getSignalTime();
960 }
961 setTransactionFlags(eTransactionNeeded);
962
963 const int32_t layerId = getSequence();
964 mFlinger->mTimeStats->setPostTime(layerId, mDrawingState.frameNumber, getName().c_str(),
965 mOwnerUid, postTime, gameMode);
966
967 setFrameTimelineVsyncForBufferTransaction(info, postTime, gameMode);
968
969 if (bufferData.dequeueTime > 0) {
970 const uint64_t bufferId = mDrawingState.buffer->getId();
971 mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
972 mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, frameNumber,
973 bufferData.dequeueTime,
974 FrameTracer::FrameEvent::DEQUEUE);
975 mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, frameNumber, postTime,
976 FrameTracer::FrameEvent::QUEUE);
977 }
978
979 mDrawingState.releaseBufferEndpoint = bufferData.releaseBufferEndpoint;
980
981 // If the layer had been updated a TextureView, this would make sure the present time could be
982 // same to TextureView update when it's a small dirty, and get the correct heuristic rate.
983 if (mFlinger->mScheduler->supportSmallDirtyDetection(mOwnerAppId)) {
984 if (mDrawingState.useVsyncIdForRefreshRateSelection) {
985 mUsedVsyncIdForRefreshRateSelection = true;
986 }
987 }
988 return true;
989 }
990
setDesiredPresentTime(nsecs_t desiredPresentTime,bool isAutoTimestamp)991 void Layer::setDesiredPresentTime(nsecs_t desiredPresentTime, bool isAutoTimestamp) {
992 mDrawingState.desiredPresentTime = desiredPresentTime;
993 mDrawingState.isAutoTimestamp = isAutoTimestamp;
994 }
995
recordLayerHistoryBufferUpdate(const scheduler::LayerProps & layerProps,nsecs_t now)996 void Layer::recordLayerHistoryBufferUpdate(const scheduler::LayerProps& layerProps, nsecs_t now) {
997 SFTRACE_CALL();
998 const nsecs_t presentTime = [&] {
999 if (!mDrawingState.isAutoTimestamp) {
1000 SFTRACE_FORMAT_INSTANT("desiredPresentTime");
1001 return mDrawingState.desiredPresentTime;
1002 }
1003
1004 if (mDrawingState.useVsyncIdForRefreshRateSelection) {
1005 const auto prediction =
1006 mFlinger->mFrameTimeline->getTokenManager()->getPredictionsForToken(
1007 mDrawingState.latchedVsyncId);
1008 if (prediction.has_value()) {
1009 SFTRACE_FORMAT_INSTANT("predictedPresentTime");
1010 mMaxTimeForUseVsyncId = prediction->presentTime +
1011 scheduler::LayerHistory::kMaxPeriodForHistory.count();
1012 return prediction->presentTime;
1013 }
1014 }
1015
1016 if (!mFlinger->mScheduler->supportSmallDirtyDetection(mOwnerAppId)) {
1017 return static_cast<nsecs_t>(0);
1018 }
1019
1020 // If the layer is not an application and didn't set an explicit rate or desiredPresentTime,
1021 // return "0" to tell the layer history that it will use the max refresh rate without
1022 // calculating the adaptive rate.
1023 if (mWindowType != WindowInfo::Type::APPLICATION &&
1024 mWindowType != WindowInfo::Type::BASE_APPLICATION) {
1025 return static_cast<nsecs_t>(0);
1026 }
1027
1028 // Return the valid present time only when the layer potentially updated a TextureView so
1029 // LayerHistory could heuristically calculate the rate if the UI is continually updating.
1030 if (mUsedVsyncIdForRefreshRateSelection) {
1031 const auto prediction =
1032 mFlinger->mFrameTimeline->getTokenManager()->getPredictionsForToken(
1033 mDrawingState.latchedVsyncId);
1034 if (prediction.has_value()) {
1035 if (mMaxTimeForUseVsyncId >= prediction->presentTime) {
1036 return prediction->presentTime;
1037 }
1038 mUsedVsyncIdForRefreshRateSelection = false;
1039 }
1040 }
1041
1042 return static_cast<nsecs_t>(0);
1043 }();
1044
1045 if (SFTRACE_ENABLED() && presentTime > 0) {
1046 const auto presentIn = TimePoint::fromNs(presentTime) - TimePoint::now();
1047 SFTRACE_FORMAT_INSTANT("presentIn %s", to_string(presentIn).c_str());
1048 }
1049
1050 mFlinger->mScheduler->recordLayerHistory(sequence, layerProps, presentTime, now,
1051 scheduler::LayerHistory::LayerUpdateType::Buffer);
1052 }
1053
recordLayerHistoryAnimationTx(const scheduler::LayerProps & layerProps,nsecs_t now)1054 void Layer::recordLayerHistoryAnimationTx(const scheduler::LayerProps& layerProps, nsecs_t now) {
1055 const nsecs_t presentTime =
1056 mDrawingState.isAutoTimestamp ? 0 : mDrawingState.desiredPresentTime;
1057 mFlinger->mScheduler->recordLayerHistory(sequence, layerProps, presentTime, now,
1058 scheduler::LayerHistory::LayerUpdateType::AnimationTX);
1059 }
1060
setDataspace(ui::Dataspace dataspace)1061 bool Layer::setDataspace(ui::Dataspace dataspace) {
1062 if (mDrawingState.dataspace == dataspace) return false;
1063 mDrawingState.dataspace = dataspace;
1064 setTransactionFlags(eTransactionNeeded);
1065 return true;
1066 }
1067
setExtendedRangeBrightness(float currentBufferRatio,float desiredRatio)1068 bool Layer::setExtendedRangeBrightness(float currentBufferRatio, float desiredRatio) {
1069 if (mDrawingState.currentHdrSdrRatio == currentBufferRatio &&
1070 mDrawingState.desiredHdrSdrRatio == desiredRatio)
1071 return false;
1072 mDrawingState.currentHdrSdrRatio = currentBufferRatio;
1073 mDrawingState.desiredHdrSdrRatio = desiredRatio;
1074 setTransactionFlags(eTransactionNeeded);
1075 return true;
1076 }
1077
setDesiredHdrHeadroom(float desiredRatio)1078 bool Layer::setDesiredHdrHeadroom(float desiredRatio) {
1079 if (mDrawingState.desiredHdrSdrRatio == desiredRatio) return false;
1080 mDrawingState.desiredHdrSdrRatio = desiredRatio;
1081 setTransactionFlags(eTransactionNeeded);
1082 return true;
1083 }
1084
setSidebandStream(const sp<NativeHandle> & sidebandStream,const FrameTimelineInfo & info,nsecs_t postTime,gui::GameMode gameMode)1085 bool Layer::setSidebandStream(const sp<NativeHandle>& sidebandStream, const FrameTimelineInfo& info,
1086 nsecs_t postTime, gui::GameMode gameMode)
1087 REQUIRES(mFlinger->mStateLock) {
1088 if (mDrawingState.sidebandStream == sidebandStream) return false;
1089
1090 if (mDrawingState.sidebandStream != nullptr && sidebandStream == nullptr) {
1091 mFlinger->mTunnelModeEnabledReporter->decrementTunnelModeCount();
1092 } else if (sidebandStream != nullptr) {
1093 mFlinger->mTunnelModeEnabledReporter->incrementTunnelModeCount();
1094 }
1095
1096 mDrawingState.sidebandStream = sidebandStream;
1097 if (sidebandStream != nullptr && mDrawingState.buffer != nullptr) {
1098 releasePreviousBuffer();
1099 resetDrawingStateBufferInfo();
1100 mDrawingState.bufferSurfaceFrameTX = nullptr;
1101 setFrameTimelineVsyncForBufferlessTransaction(info, postTime, gameMode);
1102 }
1103 setTransactionFlags(eTransactionNeeded);
1104 if (!mSidebandStreamChanged.exchange(true)) {
1105 // mSidebandStreamChanged was false
1106 mFlinger->onLayerUpdate();
1107 }
1108 return true;
1109 }
1110
setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>> & handles,bool willPresent)1111 bool Layer::setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles,
1112 bool willPresent) {
1113 // If there is no handle, we will not send a callback so reset mReleasePreviousBuffer and return
1114 if (handles.empty()) {
1115 mReleasePreviousBuffer = false;
1116 return false;
1117 }
1118
1119 std::deque<sp<CallbackHandle>> remainingHandles;
1120 for (const auto& handle : handles) {
1121 // If this transaction set a buffer on this layer, release its previous buffer
1122 handle->releasePreviousBuffer = mReleasePreviousBuffer;
1123
1124 // If this layer will be presented in this frame
1125 if (willPresent) {
1126 // If this transaction set an acquire fence on this layer, set its acquire time
1127 handle->acquireTimeOrFence = mCallbackHandleAcquireTimeOrFence;
1128 handle->frameNumber = mDrawingState.frameNumber;
1129 handle->previousFrameNumber = mDrawingState.previousFrameNumber;
1130 handle->previousBuffer = mDrawingState.previousBuffer;
1131 if (mPreviousReleaseBufferEndpoint == handle->listener) {
1132 // Add fence from previous screenshot now so that it can be dispatched to the
1133 // client.
1134 for (auto& [_, future] : mAdditionalPreviousReleaseFences) {
1135 handle->previousReleaseFences.emplace_back(std::move(future));
1136 }
1137 mAdditionalPreviousReleaseFences.clear();
1138 }
1139 // Store so latched time and release fence can be set
1140 mDrawingState.callbackHandles.push_back(handle);
1141
1142 } else { // If this layer will NOT need to be relatched and presented this frame
1143 // Queue this handle to be notified below.
1144 remainingHandles.push_back(handle);
1145 }
1146 }
1147
1148 if (!remainingHandles.empty()) {
1149 // Notify the transaction completed threads these handles are done. These are only the
1150 // handles that were not added to the mDrawingState, which will be notified later.
1151 mFlinger->getTransactionCallbackInvoker().addCallbackHandles(remainingHandles);
1152 }
1153
1154 mReleasePreviousBuffer = false;
1155 mCallbackHandleAcquireTimeOrFence = -1;
1156
1157 return willPresent;
1158 }
1159
getBufferSize(const State &) const1160 Rect Layer::getBufferSize(const State& /*s*/) const {
1161 // for buffer state layers we use the display frame size as the buffer size.
1162
1163 if (mBufferInfo.mBuffer == nullptr) {
1164 return Rect::INVALID_RECT;
1165 }
1166
1167 uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
1168 uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();
1169
1170 // Undo any transformations on the buffer and return the result.
1171 if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
1172 std::swap(bufWidth, bufHeight);
1173 }
1174
1175 if (getTransformToDisplayInverse()) {
1176 uint32_t invTransform = SurfaceFlinger::getActiveDisplayRotationFlags();
1177 if (invTransform & ui::Transform::ROT_90) {
1178 std::swap(bufWidth, bufHeight);
1179 }
1180 }
1181
1182 return Rect(0, 0, static_cast<int32_t>(bufWidth), static_cast<int32_t>(bufHeight));
1183 }
1184
fenceHasSignaled() const1185 bool Layer::fenceHasSignaled() const {
1186 if (SurfaceFlinger::enableLatchUnsignaledConfig != LatchUnsignaledConfig::Disabled) {
1187 return true;
1188 }
1189
1190 const bool fenceSignaled =
1191 getDrawingState().acquireFence->getStatus() == Fence::Status::Signaled;
1192 if (!fenceSignaled) {
1193 mFlinger->mTimeStats->incrementLatchSkipped(getSequence(),
1194 TimeStats::LatchSkipReason::LateAcquire);
1195 }
1196
1197 return fenceSignaled;
1198 }
1199
onPreComposition(nsecs_t refreshStartTime)1200 void Layer::onPreComposition(nsecs_t refreshStartTime) {
1201 for (const auto& handle : mDrawingState.callbackHandles) {
1202 handle->refreshStartTime = refreshStartTime;
1203 }
1204 }
1205
latchSidebandStream(bool & recomputeVisibleRegions)1206 bool Layer::latchSidebandStream(bool& recomputeVisibleRegions) {
1207 if (mSidebandStreamChanged.exchange(false)) {
1208 const State& s(getDrawingState());
1209 // mSidebandStreamChanged was true
1210 mSidebandStream = s.sidebandStream;
1211 if (mSidebandStream != nullptr) {
1212 setTransactionFlags(eTransactionNeeded);
1213 mFlinger->setTransactionFlags(eTraversalNeeded);
1214 }
1215 recomputeVisibleRegions = true;
1216 return true;
1217 }
1218 return false;
1219 }
1220
updateTexImage(nsecs_t latchTime,bool bgColorOnly)1221 void Layer::updateTexImage(nsecs_t latchTime, bool bgColorOnly) REQUIRES(mFlinger->mStateLock) {
1222 const State& s(getDrawingState());
1223
1224 if (!s.buffer) {
1225 if (bgColorOnly || mBufferInfo.mBuffer) {
1226 for (auto& handle : mDrawingState.callbackHandles) {
1227 handle->latchTime = latchTime;
1228 }
1229 }
1230 return;
1231 }
1232
1233 for (auto& handle : mDrawingState.callbackHandles) {
1234 if (handle->frameNumber == mDrawingState.frameNumber) {
1235 handle->latchTime = latchTime;
1236 }
1237 }
1238
1239 const int32_t layerId = getSequence();
1240 const uint64_t bufferId = mDrawingState.buffer->getId();
1241 const uint64_t frameNumber = mDrawingState.frameNumber;
1242 const auto acquireFence = std::make_shared<FenceTime>(mDrawingState.acquireFence);
1243 mFlinger->mTimeStats->setAcquireFence(layerId, frameNumber, acquireFence);
1244 mFlinger->mTimeStats->setLatchTime(layerId, frameNumber, latchTime);
1245
1246 mFlinger->mFrameTracer->traceFence(layerId, bufferId, frameNumber, acquireFence,
1247 FrameTracer::FrameEvent::ACQUIRE_FENCE);
1248 mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, frameNumber, latchTime,
1249 FrameTracer::FrameEvent::LATCH);
1250
1251 auto& bufferSurfaceFrame = mDrawingState.bufferSurfaceFrameTX;
1252 if (bufferSurfaceFrame != nullptr &&
1253 bufferSurfaceFrame->getPresentState() != PresentState::Presented) {
1254 // Update only if the bufferSurfaceFrame wasn't already presented. A Presented
1255 // bufferSurfaceFrame could be seen here if a pending state was applied successfully and we
1256 // are processing the next state.
1257 addSurfaceFramePresentedForBuffer(bufferSurfaceFrame,
1258 mDrawingState.acquireFenceTime->getSignalTime(),
1259 latchTime);
1260 mDrawingState.bufferSurfaceFrameTX.reset();
1261 }
1262
1263 std::deque<sp<CallbackHandle>> remainingHandles;
1264 mFlinger->getTransactionCallbackInvoker()
1265 .addOnCommitCallbackHandles(mDrawingState.callbackHandles, remainingHandles);
1266 mDrawingState.callbackHandles = remainingHandles;
1267 }
1268
gatherBufferInfo()1269 void Layer::gatherBufferInfo() {
1270 mPreviousReleaseCallbackId = {getCurrentBufferId(), mBufferInfo.mFrameNumber};
1271 mPreviousReleaseBufferEndpoint = mBufferInfo.mReleaseBufferEndpoint;
1272 if (!mDrawingState.buffer) {
1273 mBufferInfo = {};
1274 return;
1275 }
1276
1277 if ((!mBufferInfo.mBuffer || !mDrawingState.buffer->hasSameBuffer(*mBufferInfo.mBuffer))) {
1278 decrementPendingBufferCount();
1279 }
1280
1281 mBufferInfo.mBuffer = mDrawingState.buffer;
1282 mBufferInfo.mReleaseBufferEndpoint = mDrawingState.releaseBufferEndpoint;
1283 mBufferInfo.mFence = mDrawingState.acquireFence;
1284 mBufferInfo.mFrameNumber = mDrawingState.frameNumber;
1285 mBufferInfo.mPixelFormat =
1286 !mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->getPixelFormat();
1287 mBufferInfo.mFrameLatencyNeeded = true;
1288 mBufferInfo.mDesiredPresentTime = mDrawingState.desiredPresentTime;
1289 mBufferInfo.mFenceTime = std::make_shared<FenceTime>(mDrawingState.acquireFence);
1290 mBufferInfo.mTransform = mDrawingState.bufferTransform;
1291 auto lastDataspace = mBufferInfo.mDataspace;
1292 mBufferInfo.mDataspace = translateDataspace(mDrawingState.dataspace);
1293 if (mBufferInfo.mBuffer != nullptr) {
1294 auto& mapper = GraphicBufferMapper::get();
1295 // TODO: We should measure if it's faster to do a blind write if we're on newer api levels
1296 // and don't need to possibly remaps buffers.
1297 ui::Dataspace dataspace = ui::Dataspace::UNKNOWN;
1298 status_t err = OK;
1299 {
1300 SFTRACE_NAME("getDataspace");
1301 err = mapper.getDataspace(mBufferInfo.mBuffer->getBuffer()->handle, &dataspace);
1302 }
1303 if (err != OK || dataspace != mBufferInfo.mDataspace) {
1304 {
1305 SFTRACE_NAME("setDataspace");
1306 err = mapper.setDataspace(mBufferInfo.mBuffer->getBuffer()->handle,
1307 static_cast<ui::Dataspace>(mBufferInfo.mDataspace));
1308 }
1309
1310 // Some GPU drivers may cache gralloc metadata which means before we composite we need
1311 // to upsert RenderEngine's caches. Put in a special workaround to be backwards
1312 // compatible with old vendors, with a ticking clock.
1313 static const int32_t kVendorVersion =
1314 base::GetIntProperty("ro.board.api_level", __ANDROID_API_FUTURE__);
1315 if (const auto format =
1316 static_cast<aidl::android::hardware::graphics::common::PixelFormat>(
1317 mBufferInfo.mBuffer->getPixelFormat());
1318 err == OK && kVendorVersion < __ANDROID_API_U__ &&
1319 (format ==
1320 aidl::android::hardware::graphics::common::PixelFormat::
1321 IMPLEMENTATION_DEFINED ||
1322 format == aidl::android::hardware::graphics::common::PixelFormat::YCBCR_420_888 ||
1323 format == aidl::android::hardware::graphics::common::PixelFormat::YV12 ||
1324 format == aidl::android::hardware::graphics::common::PixelFormat::YCBCR_P010)) {
1325 mBufferInfo.mBuffer->remapBuffer();
1326 }
1327 }
1328 }
1329 if (lastDataspace != mBufferInfo.mDataspace ||
1330 mBufferInfo.mTimeSinceDataspaceUpdate == std::chrono::steady_clock::time_point::min()) {
1331 mFlinger->mHdrLayerInfoChanged = true;
1332 const auto currentTime = std::chrono::steady_clock::now();
1333 if (mBufferInfo.mTimeSinceDataspaceUpdate > std::chrono::steady_clock::time_point::min()) {
1334 mFlinger->mLayerEvents
1335 .emplace_back(mOwnerUid, getSequence(), lastDataspace,
1336 std::chrono::duration_cast<std::chrono::milliseconds>(
1337 currentTime - mBufferInfo.mTimeSinceDataspaceUpdate));
1338 }
1339 mBufferInfo.mTimeSinceDataspaceUpdate = currentTime;
1340 }
1341 if (mBufferInfo.mDesiredHdrSdrRatio != mDrawingState.desiredHdrSdrRatio) {
1342 mBufferInfo.mDesiredHdrSdrRatio = mDrawingState.desiredHdrSdrRatio;
1343 mFlinger->mHdrLayerInfoChanged = true;
1344 }
1345 mBufferInfo.mCrop = computeBufferCrop(mDrawingState);
1346 mBufferInfo.mTransformToDisplayInverse = mDrawingState.transformToDisplayInverse;
1347 }
1348
computeBufferCrop(const State & s)1349 Rect Layer::computeBufferCrop(const State& s) {
1350 if (s.buffer && !s.bufferCrop.isEmpty()) {
1351 Rect bufferCrop;
1352 s.buffer->getBounds().intersect(s.bufferCrop, &bufferCrop);
1353 return bufferCrop;
1354 } else if (s.buffer) {
1355 return s.buffer->getBounds();
1356 } else {
1357 return s.bufferCrop;
1358 }
1359 }
1360
decrementPendingBufferCount()1361 void Layer::decrementPendingBufferCount() {
1362 int32_t pendingBuffers = --mPendingBuffers;
1363 tracePendingBufferCount(pendingBuffers);
1364 }
1365
tracePendingBufferCount(int32_t pendingBuffers)1366 void Layer::tracePendingBufferCount(int32_t pendingBuffers) {
1367 SFTRACE_INT(mBlastTransactionName.c_str(), pendingBuffers);
1368 }
1369
getCompositionEngineLayerFE(const frontend::LayerHierarchy::TraversalPath & path)1370 sp<LayerFE> Layer::getCompositionEngineLayerFE(
1371 const frontend::LayerHierarchy::TraversalPath& path) {
1372 for (auto& [p, layerFE] : mLayerFEs) {
1373 if (p == path) {
1374 return layerFE;
1375 }
1376 }
1377 auto layerFE = mFlinger->getFactory().createLayerFE(mName, this);
1378 mLayerFEs.emplace_back(path, layerFE);
1379 return layerFE;
1380 }
1381
onCompositionPresented(const DisplayDevice * display,const std::shared_ptr<FenceTime> & glDoneFence,const std::shared_ptr<FenceTime> & presentFence,const CompositorTiming & compositorTiming,gui::GameMode gameMode)1382 void Layer::onCompositionPresented(const DisplayDevice* display,
1383 const std::shared_ptr<FenceTime>& glDoneFence,
1384 const std::shared_ptr<FenceTime>& presentFence,
1385 const CompositorTiming& compositorTiming,
1386 gui::GameMode gameMode) {
1387 // mFrameLatencyNeeded is true when a new frame was latched for the
1388 // composition.
1389 if (!mBufferInfo.mFrameLatencyNeeded) return;
1390
1391 for (const auto& handle : mDrawingState.callbackHandles) {
1392 handle->gpuCompositionDoneFence = glDoneFence;
1393 handle->compositorTiming = compositorTiming;
1394 }
1395
1396 // Update mDeprecatedFrameTracker.
1397 nsecs_t desiredPresentTime = mBufferInfo.mDesiredPresentTime;
1398 mDeprecatedFrameTracker.setDesiredPresentTime(desiredPresentTime);
1399
1400 const int32_t layerId = getSequence();
1401 mFlinger->mTimeStats->setDesiredTime(layerId, mCurrentFrameNumber, desiredPresentTime);
1402
1403 const auto outputLayer = findOutputLayerForDisplay(display);
1404 if (outputLayer && outputLayer->requiresClientComposition()) {
1405 nsecs_t clientCompositionTimestamp = outputLayer->getState().clientCompositionTimestamp;
1406 mFlinger->mFrameTracer->traceTimestamp(layerId, getCurrentBufferId(), mCurrentFrameNumber,
1407 clientCompositionTimestamp,
1408 FrameTracer::FrameEvent::FALLBACK_COMPOSITION);
1409 // Update the SurfaceFrames in the drawing state
1410 if (mDrawingState.bufferSurfaceFrameTX) {
1411 mDrawingState.bufferSurfaceFrameTX->setGpuComposition();
1412 }
1413 for (auto& [token, surfaceFrame] : mDrawingState.bufferlessSurfaceFramesTX) {
1414 surfaceFrame->setGpuComposition();
1415 }
1416 }
1417
1418 // The SurfaceFrame's AcquireFence is the same as this.
1419 std::shared_ptr<FenceTime> frameReadyFence = mBufferInfo.mFenceTime;
1420 if (frameReadyFence->isValid()) {
1421 mDeprecatedFrameTracker.setFrameReadyFence(std::move(frameReadyFence));
1422 } else {
1423 // There was no fence for this frame, so assume that it was ready
1424 // to be presented at the desired present time.
1425 mDeprecatedFrameTracker.setFrameReadyTime(desiredPresentTime);
1426 }
1427 if (display) {
1428 const auto activeMode = display->refreshRateSelector().getActiveMode();
1429 const Fps refreshRate = activeMode.fps;
1430 const std::optional<Fps> renderRate =
1431 mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());
1432
1433 const auto vote = frameRateToSetFrameRateVotePayload(getFrameRateForLayerTree());
1434
1435 if (presentFence->isValid()) {
1436 mFlinger->mTimeStats->setPresentFence(layerId, mCurrentFrameNumber, presentFence,
1437 refreshRate, renderRate, vote, gameMode);
1438 mFlinger->mFrameTracer->traceFence(layerId, getCurrentBufferId(), mCurrentFrameNumber,
1439 presentFence,
1440 FrameTracer::FrameEvent::PRESENT_FENCE);
1441 mDeprecatedFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence));
1442 } else if (const auto displayId = asPhysicalDisplayId(display->getDisplayIdVariant());
1443 displayId.has_value() && mFlinger->getHwComposer().isConnected(*displayId)) {
1444 // The HWC doesn't support present fences, so use the present timestamp instead.
1445 const nsecs_t presentTimestamp =
1446 mFlinger->getHwComposer().getPresentTimestamp(*displayId);
1447
1448 const nsecs_t now = systemTime(CLOCK_MONOTONIC);
1449 const nsecs_t vsyncPeriod =
1450 mFlinger->getHwComposer()
1451 .getDisplayVsyncPeriod(*displayId)
1452 .value_opt()
1453 .value_or(activeMode.modePtr->getVsyncRate().getPeriodNsecs());
1454
1455 const nsecs_t actualPresentTime = now - ((now - presentTimestamp) % vsyncPeriod);
1456
1457 mFlinger->mTimeStats->setPresentTime(layerId, mCurrentFrameNumber, actualPresentTime,
1458 refreshRate, renderRate, vote, gameMode);
1459 mFlinger->mFrameTracer->traceTimestamp(layerId, getCurrentBufferId(),
1460 mCurrentFrameNumber, actualPresentTime,
1461 FrameTracer::FrameEvent::PRESENT_FENCE);
1462 mDeprecatedFrameTracker.setActualPresentTime(actualPresentTime);
1463 }
1464 }
1465
1466 mFrameStatsHistorySize++;
1467 mDeprecatedFrameTracker.advanceFrame();
1468 mBufferInfo.mFrameLatencyNeeded = false;
1469 }
1470
latchBufferImpl(bool & recomputeVisibleRegions,nsecs_t latchTime,bool bgColorOnly)1471 bool Layer::latchBufferImpl(bool& recomputeVisibleRegions, nsecs_t latchTime, bool bgColorOnly)
1472 REQUIRES(mFlinger->mStateLock) {
1473 SFTRACE_FORMAT_INSTANT("latchBuffer %s - %" PRIu64, getDebugName(),
1474 getDrawingState().frameNumber);
1475
1476 bool refreshRequired = latchSidebandStream(recomputeVisibleRegions);
1477
1478 if (refreshRequired) {
1479 return refreshRequired;
1480 }
1481
1482 // If the head buffer's acquire fence hasn't signaled yet, return and
1483 // try again later
1484 if (!fenceHasSignaled()) {
1485 SFTRACE_NAME("!fenceHasSignaled()");
1486 mFlinger->onLayerUpdate();
1487 return false;
1488 }
1489 updateTexImage(latchTime, bgColorOnly);
1490
1491 // Capture the old state of the layer for comparisons later
1492 BufferInfo oldBufferInfo = mBufferInfo;
1493 mPreviousFrameNumber = mCurrentFrameNumber;
1494 mCurrentFrameNumber = mDrawingState.frameNumber;
1495 gatherBufferInfo();
1496
1497 if (mBufferInfo.mBuffer) {
1498 // We latched a buffer that will be presented soon. Clear the previously presented layer
1499 // stack list.
1500 mPreviouslyPresentedLayerStacks.clear();
1501 }
1502
1503 if (mDrawingState.buffer == nullptr) {
1504 const bool bufferReleased = oldBufferInfo.mBuffer != nullptr;
1505 recomputeVisibleRegions = bufferReleased;
1506 return bufferReleased;
1507 }
1508
1509 if (oldBufferInfo.mBuffer == nullptr) {
1510 // the first time we receive a buffer, we need to trigger a
1511 // geometry invalidation.
1512 recomputeVisibleRegions = true;
1513 }
1514
1515 if ((mBufferInfo.mCrop != oldBufferInfo.mCrop) ||
1516 (mBufferInfo.mTransform != oldBufferInfo.mTransform) ||
1517 (mBufferInfo.mTransformToDisplayInverse != oldBufferInfo.mTransformToDisplayInverse)) {
1518 recomputeVisibleRegions = true;
1519 }
1520
1521 if (oldBufferInfo.mBuffer != nullptr) {
1522 uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
1523 uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();
1524 if (bufWidth != oldBufferInfo.mBuffer->getWidth() ||
1525 bufHeight != oldBufferInfo.mBuffer->getHeight()) {
1526 recomputeVisibleRegions = true;
1527 }
1528 }
1529 return true;
1530 }
1531
getTransformToDisplayInverse() const1532 bool Layer::getTransformToDisplayInverse() const {
1533 return mBufferInfo.mTransformToDisplayInverse;
1534 }
1535
translateDataspace(ui::Dataspace dataspace)1536 ui::Dataspace Layer::translateDataspace(ui::Dataspace dataspace) {
1537 ui::Dataspace updatedDataspace = dataspace;
1538 // translate legacy dataspaces to modern dataspaces
1539 switch (dataspace) {
1540 // Treat unknown dataspaces as V0_sRGB
1541 case ui::Dataspace::UNKNOWN:
1542 case ui::Dataspace::SRGB:
1543 updatedDataspace = ui::Dataspace::V0_SRGB;
1544 break;
1545 case ui::Dataspace::SRGB_LINEAR:
1546 updatedDataspace = ui::Dataspace::V0_SRGB_LINEAR;
1547 break;
1548 case ui::Dataspace::JFIF:
1549 updatedDataspace = ui::Dataspace::V0_JFIF;
1550 break;
1551 case ui::Dataspace::BT601_625:
1552 updatedDataspace = ui::Dataspace::V0_BT601_625;
1553 break;
1554 case ui::Dataspace::BT601_525:
1555 updatedDataspace = ui::Dataspace::V0_BT601_525;
1556 break;
1557 case ui::Dataspace::BT709:
1558 updatedDataspace = ui::Dataspace::V0_BT709;
1559 break;
1560 default:
1561 break;
1562 }
1563
1564 return updatedDataspace;
1565 }
1566
getBuffer() const1567 sp<GraphicBuffer> Layer::getBuffer() const {
1568 return mBufferInfo.mBuffer ? mBufferInfo.mBuffer->getBuffer() : nullptr;
1569 }
1570
setTrustedPresentationInfo(TrustedPresentationThresholds const & thresholds,TrustedPresentationListener const & listener)1571 bool Layer::setTrustedPresentationInfo(TrustedPresentationThresholds const& thresholds,
1572 TrustedPresentationListener const& listener) {
1573 bool hadTrustedPresentationListener = hasTrustedPresentationListener();
1574 mTrustedPresentationListener = listener;
1575 mTrustedPresentationThresholds = thresholds;
1576 bool haveTrustedPresentationListener = hasTrustedPresentationListener();
1577 if (!hadTrustedPresentationListener && haveTrustedPresentationListener) {
1578 mFlinger->mNumTrustedPresentationListeners++;
1579 } else if (hadTrustedPresentationListener && !haveTrustedPresentationListener) {
1580 mFlinger->mNumTrustedPresentationListeners--;
1581 }
1582
1583 // Reset trusted presentation states to ensure we start the time again.
1584 mEnteredTrustedPresentationStateTime = -1;
1585 mLastReportedTrustedPresentationState = false;
1586 mLastComputedTrustedPresentationState = false;
1587
1588 // If there's a new trusted presentation listener, the code needs to go through the composite
1589 // path to ensure it recomutes the current state and invokes the TrustedPresentationListener if
1590 // we're already in the requested state.
1591 return haveTrustedPresentationListener;
1592 }
1593
setBufferReleaseChannel(const std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint> & channel)1594 void Layer::setBufferReleaseChannel(
1595 const std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint>& channel) {
1596 mBufferReleaseChannel = channel;
1597 }
1598
updateLastLatchTime(nsecs_t latchTime)1599 void Layer::updateLastLatchTime(nsecs_t latchTime) {
1600 mLastLatchTime = latchTime;
1601 }
1602
setIsSmallDirty(frontend::LayerSnapshot * snapshot)1603 void Layer::setIsSmallDirty(frontend::LayerSnapshot* snapshot) {
1604 if (!mFlinger->mScheduler->supportSmallDirtyDetection(mOwnerAppId)) {
1605 snapshot->isSmallDirty = false;
1606 return;
1607 }
1608
1609 if (mWindowType != WindowInfo::Type::APPLICATION &&
1610 mWindowType != WindowInfo::Type::BASE_APPLICATION) {
1611 snapshot->isSmallDirty = false;
1612 return;
1613 }
1614
1615 Rect bounds = snapshot->surfaceDamage.getBounds();
1616 if (!bounds.isValid()) {
1617 snapshot->isSmallDirty = false;
1618 return;
1619 }
1620
1621 // Transform to screen space.
1622 bounds = snapshot->localTransform.transform(bounds);
1623
1624 // If the damage region is a small dirty, this could give the hint for the layer history that
1625 // it could suppress the heuristic rate when calculating.
1626 snapshot->isSmallDirty =
1627 mFlinger->mScheduler->isSmallDirtyArea(mOwnerAppId,
1628 bounds.getWidth() * bounds.getHeight());
1629 }
1630
1631 } // namespace android
1632
1633 #if defined(__gl_h_)
1634 #error "don't include gl/gl.h in this file"
1635 #endif
1636
1637 #if defined(__gl2_h_)
1638 #error "don't include gl2/gl2.h in this file"
1639 #endif
1640
1641 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1642 #pragma clang diagnostic pop // ignored "-Wconversion"
1643