blob: c0dcdc9062c75d2c4b14cd2a0dc5ae12472c2103 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
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
Dominik Laskowskib7251f42020-04-20 17:42:59 -070017#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -070019#include <android/gui/DropInputMode.h>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080020#include <android/gui/ISurfaceComposerClient.h>
Melody Hsue4ef87f2024-03-26 23:54:45 +000021#include <ftl/small_map.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070022#include <gui/BufferQueue.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070023#include <gui/LayerState.h>
chaviw98318de2021-05-19 16:45:23 -050024#include <gui/WindowInfo.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070025#include <layerproto/LayerProtoHeader.h>
26#include <math/vec4.h>
Alec Mouri1c8d7202019-06-01 18:51:35 -070027#include <sys/types.h>
Lucas Dupinc3800b82020-10-02 16:24:48 -070028#include <ui/BlurRegion.h>
Melody Hsue4ef87f2024-03-26 23:54:45 +000029#include <ui/DisplayMap.h>
Dan Stoza80d61162017-12-20 15:57:52 -080030#include <ui/FloatRect.h>
Svetoslavd85084b2014-03-20 10:28:31 -070031#include <ui/FrameStats.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080032#include <ui/GraphicBuffer.h>
Melody Hsue4ef87f2024-03-26 23:54:45 +000033#include <ui/LayerStack.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080034#include <ui/PixelFormat.h>
35#include <ui/Region.h>
John Reckcdb4ed72021-02-04 13:39:33 -050036#include <ui/StretchEffect.h>
Peiyong Linefefaac2018-08-17 12:27:51 -070037#include <ui/Transform.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070038#include <utils/RefBase.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070039#include <utils/Timers.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080040
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080041#include <compositionengine/LayerFE.h>
Vishnu Nairbedb44b2022-08-02 21:47:40 +000042#include <compositionengine/LayerFECompositionState.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080043#include <scheduler/Fps.h>
44#include <scheduler/Seamlessness.h>
45
Robert Carrcdf83202018-03-07 12:48:34 -080046#include <cstdint>
Dominik Laskowski075d3172018-05-24 15:50:06 -070047#include <optional>
Peiyong Lincbc184f2018-08-22 13:24:10 -070048#include <vector>
Dan Stoza7dde5992015-05-22 09:51:44 -070049
Mathias Agopian13127d82013-03-05 17:47:11 -080050#include "Client.h"
Alec Mouri1c8d7202019-06-01 18:51:35 -070051#include "DisplayHardware/HWComposer.h"
David Sodman41fdfc92017-11-06 16:09:56 -080052#include "FrameTracker.h"
Vishnu Naire14c6b32022-08-06 04:20:15 +000053#include "LayerFE.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070054#include "LayerVector.h"
Ady Abrahambdda8f02021-04-01 16:06:11 -070055#include "Scheduler/LayerInfo.h"
Mathias Agopian13127d82013-03-05 17:47:11 -080056#include "SurfaceFlinger.h"
Robert Carr9a803c32021-01-14 16:57:58 -080057#include "TransactionCallbackInvoker.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080058
chaviw1d044282017-09-27 12:19:28 -070059using namespace android::surfaceflinger;
60
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080061namespace android {
62
Mathias Agopian1f7bec62010-06-25 18:02:21 -070063class Client;
Mathias Agopian3e25fd82013-04-22 17:52:16 +020064class Colorizer;
Mathias Agopian13127d82013-03-05 17:47:11 -080065class DisplayDevice;
66class GraphicBuffer;
67class SurfaceFlinger;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080068
Lloyd Piquefeb73d72018-12-04 17:23:44 -080069namespace compositionengine {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080070class OutputLayer;
Lloyd Piquea83776c2019-01-29 18:42:32 -080071struct LayerFECompositionState;
Lloyd Piquefeb73d72018-12-04 17:23:44 -080072}
73
Ady Abraham22c7b5c2020-09-22 19:33:40 -070074namespace frametimeline {
75class SurfaceFrame;
76} // namespace frametimeline
77
Vishnu Naire14c6b32022-08-06 04:20:15 +000078class Layer : public virtual RefBase {
Vishnu Nairdc4d31b2022-11-17 03:20:58 +000079public:
Ady Abrahamaae5ed52020-06-26 09:32:43 -070080 // The following constants represent priority of the window. SF uses this information when
81 // deciding which window has a priority when deciding about the refresh rate of the screen.
82 // Priority 0 is considered the highest priority. -1 means that the priority is unset.
Ana Krulecc84d09b2019-11-02 23:10:29 +010083 static constexpr int32_t PRIORITY_UNSET = -1;
Ady Abrahamaae5ed52020-06-26 09:32:43 -070084 // Windows that are in focus and voted for the preferred mode ID
85 static constexpr int32_t PRIORITY_FOCUSED_WITH_MODE = 0;
86 // // Windows that are in focus, but have not requested a specific mode ID.
87 static constexpr int32_t PRIORITY_FOCUSED_WITHOUT_MODE = 1;
88 // Windows that are not in focus, but voted for a specific mode ID.
89 static constexpr int32_t PRIORITY_NOT_FOCUSED_WITH_MODE = 2;
Mathias Agopian13127d82013-03-05 17:47:11 -080090
Ady Abrahambdda8f02021-04-01 16:06:11 -070091 using FrameRate = scheduler::LayerInfo::FrameRate;
Vishnu Nair3fbe3262023-09-29 17:07:00 -070092 using FrameRateCompatibility = scheduler::FrameRateCompatibility;
Rachel Lee58cc90d2023-09-05 18:50:20 -070093 using FrameRateSelectionStrategy = scheduler::LayerInfo::FrameRateSelectionStrategy;
Ady Abraham71c437d2020-01-31 15:56:57 -080094
Mathias Agopian13127d82013-03-05 17:47:11 -080095 struct State {
Mathias Agopian13127d82013-03-05 17:47:11 -080096 int32_t sequence; // changes when visible regions can change
Fabien Sanglard4ed383c2016-12-13 14:02:41 -080097 // Crop is expressed in layer space coordinate.
chaviw25714502021-02-11 10:01:08 -080098 Rect crop;
Evan Rosky1f6d6d52018-12-06 10:47:26 -080099 LayerMetadata metadata;
Robert Carr720e5062018-07-30 17:45:14 -0700100
Valerie Haub153bab2019-03-05 10:47:28 -0800101 ui::Dataspace dataspace;
102
Valerie Hau134651a2020-01-28 16:21:22 -0800103 uint64_t frameNumber;
Alec Mouri21d94322023-10-17 19:51:39 +0000104 uint64_t previousFrameNumber;
Vishnu Nair63221212023-04-06 15:17:37 -0700105 // high watermark framenumber to use to check for barriers to protect ourselves
106 // from out of order transactions
107 uint64_t barrierFrameNumber;
chaviw766c9c52021-02-10 17:36:47 -0800108 ui::Transform transform;
liulijuneb489f62022-10-17 22:02:14 +0800109
110 uint32_t producerId = 0;
Vishnu Nair63221212023-04-06 15:17:37 -0700111 // high watermark producerId to use to check for barriers to protect ourselves
112 // from out of order transactions
113 uint32_t barrierProducerId = 0;
114
chaviw766c9c52021-02-10 17:36:47 -0800115 uint32_t bufferTransform;
Marissa Wall61c58622018-07-18 10:12:20 -0700116 bool transformToDisplayInverse;
Marissa Wall61c58622018-07-18 10:12:20 -0700117 Region transparentRegionHint;
Alec Mouria90a5702021-04-16 16:36:21 +0000118 std::shared_ptr<renderengine::ExternalTexture> buffer;
Marissa Wall61c58622018-07-18 10:12:20 -0700119 sp<Fence> acquireFence;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700120 std::shared_ptr<FenceTime> acquireFenceTime;
Marissa Wall61c58622018-07-18 10:12:20 -0700121 sp<NativeHandle> sidebandStream;
Peiyong Lind3788632018-09-18 16:01:31 -0700122 mat4 colorTransform;
Valerie Haued54efa2019-01-11 20:03:14 -0800123
Marissa Walle2ffb422018-10-12 11:33:52 -0700124 // The deque of callback handles for this frame. The back of the deque contains the most
125 // recent callback handle.
126 std::deque<sp<CallbackHandle>> callbackHandles;
Ady Abrahamf0c56492020-12-17 18:04:15 -0800127 nsecs_t desiredPresentTime = 0;
128 bool isAutoTimestamp = true;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800129
Ady Abraham59fd8ff2021-04-15 20:13:30 -0700130 // The combined frame rate of parents / children of this layer
131 FrameRate frameRateForLayerTree;
Vishnu Nair6213bd92020-05-08 17:42:25 -0700132
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000133 // The vsync info that was used to start the transaction
134 FrameTimelineInfo frameTimelineInfo;
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700135
136 // When the transaction was posted
137 nsecs_t postTime;
Vishnu Nair1506b182021-02-22 14:35:15 -0800138 sp<ITransactionCompletedListener> releaseBufferListener;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000139 // SurfaceFrame that tracks the timeline of Transactions that contain a Buffer. Only one
140 // such SurfaceFrame exists because only one buffer can be presented on the layer per vsync.
141 // If multiple buffers are queued, the prior ones will be dropped, along with the
142 // SurfaceFrame that's tracking them.
143 std::shared_ptr<frametimeline::SurfaceFrame> bufferSurfaceFrameTX;
144 // A map of token(frametimelineVsyncId) to the SurfaceFrame that's tracking a transaction
145 // that contains the token. Only one SurfaceFrame exisits for transactions that share the
146 // same token, unless they are presented in different vsyncs.
147 std::unordered_map<int64_t, std::shared_ptr<frametimeline::SurfaceFrame>>
148 bufferlessSurfaceFramesTX;
149 // An arbitrary threshold for the number of BufferlessSurfaceFrames in the state. Used to
150 // trigger a warning if the number of SurfaceFrames crosses the threshold.
151 static constexpr uint32_t kStateSurfaceFramesThreshold = 25;
chaviwf3f40fe2021-04-27 15:54:02 -0500152 Rect bufferCrop;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700153 Rect destinationFrame;
chaviw0b06a8d2021-08-06 11:49:08 -0500154 sp<IBinder> releaseBufferEndpoint;
Vishnu Nair86653e92021-11-03 17:19:36 -0700155 bool autoRefresh = false;
Sally Qi963049b2023-03-23 14:06:21 -0700156 float currentHdrSdrRatio = 1.f;
Alec Mouri1b0d4e12024-02-12 22:27:19 +0000157 float desiredHdrSdrRatio = -1.f;
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000158 int64_t latchedVsyncId = 0;
Ady Abraham55269162023-05-09 11:26:06 -0700159 bool useVsyncIdForRefreshRateSelection = false;
Mathias Agopian13127d82013-03-05 17:47:11 -0800160 };
161
Kean Mariotti4ba343c2023-04-19 13:31:02 +0000162 explicit Layer(const surfaceflinger::LayerCreationArgs& args);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700163 virtual ~Layer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800164
Peiyong Linf243e5e2020-08-22 17:40:59 -0700165 static bool isLayerFocusedBasedOnPriority(int32_t priority);
166 static void miniDumpHeader(std::string& result);
Dominik Laskowski75848362019-11-11 17:57:20 -0800167
Peiyong Linf243e5e2020-08-22 17:40:59 -0700168 // Provide unique string for each class type in the Layer hierarchy
Vishnu Nairdc83d4b2024-08-15 16:29:20 +0000169 const char* getType() const { return "Layer"; }
Robert Carr7bf247e2017-05-18 14:02:49 -0700170
171 // This second set of geometry attributes are controlled by
172 // setGeometryAppliesWithResize, and their default mode is to be
173 // immediate. If setGeometryAppliesWithResize is specified
174 // while a resize is pending, then update of these attributes will
175 // be delayed until the resize completes.
176
Robert Carr7bf247e2017-05-18 14:02:49 -0700177 // Buffer space
Vishnu Nairbc4ee5c2022-08-16 03:19:37 +0000178 bool setCrop(const Rect& crop);
Robert Carr8d5227b2017-03-16 15:41:03 -0700179
Patrick Williamsbb25f802022-08-30 23:02:34 +0000180 bool setTransform(uint32_t /*transform*/);
181 bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/);
182 bool setBuffer(std::shared_ptr<renderengine::ExternalTexture>& /* buffer */,
183 const BufferData& /* bufferData */, nsecs_t /* postTime */,
184 nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
Vishnu Nair39a74a92024-07-29 19:01:50 +0000185 const FrameTimelineInfo& /*info*/, gui::GameMode gameMode);
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000186 void setDesiredPresentTime(nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000187 bool setDataspace(ui::Dataspace /*dataspace*/);
John Reck68796592023-01-25 13:47:12 -0500188 bool setExtendedRangeBrightness(float currentBufferRatio, float desiredRatio);
Alec Mouri1b0d4e12024-02-12 22:27:19 +0000189 bool setDesiredHdrHeadroom(float desiredRatio);
Dorin Drimuse5374e52023-08-02 17:52:43 +0000190 bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/,
Vishnu Nair39a74a92024-07-29 19:01:50 +0000191 const FrameTimelineInfo& /* info*/, nsecs_t /* postTime */,
192 gui::GameMode gameMode);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000193 bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& /*handles*/,
194 bool willPresent);
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -0700195
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000196 sp<LayerFE> getCompositionEngineLayerFE(const frontend::LayerHierarchy::TraversalPath&);
Vishnu Nair3cc15a42023-06-30 06:20:22 +0000197 sp<LayerFE> getOrCreateCompositionEngineLayerFE(const frontend::LayerHierarchy::TraversalPath&);
Vishnu Naire14c6b32022-08-06 04:20:15 +0000198
Dan Stozaee44edd2015-03-23 15:50:23 -0700199 // If we have received a new buffer this frame, we will pass its surface
200 // damage down to hardware composer. Otherwise, we must send a region with
201 // one empty rect.
Alec Mouriadebf5c2021-01-05 12:57:36 -0800202 Region getVisibleRegion(const DisplayDevice*) const;
Vishnu Naira156f482023-02-22 00:23:38 +0000203 void updateLastLatchTime(nsecs_t latchtime);
Dan Stozaee44edd2015-03-23 15:50:23 -0700204
Peiyong Linf243e5e2020-08-22 17:40:59 -0700205 /*
Peiyong Lin05cc0112020-10-14 16:16:37 -0700206 * isProtected - true if the layer may contain protected contents in the
Peiyong Linf243e5e2020-08-22 17:40:59 -0700207 * GRALLOC_USAGE_PROTECTED sense.
208 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000209 bool isProtected() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700210
Vishnu Nairbc4ee5c2022-08-16 03:19:37 +0000211 Rect getCrop(const Layer::State& s) const { return s.crop; }
Patrick Williamsbb25f802022-08-30 23:02:34 +0000212 bool needsFiltering(const DisplayDevice*) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700213
Patrick Williamsbb25f802022-08-30 23:02:34 +0000214 // from graphics API
Vishnu Nair3996ee32023-08-14 04:32:31 +0000215 static ui::Dataspace translateDataspace(ui::Dataspace dataspace);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000216 uint64_t mPreviousFrameNumber = 0;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700217
Leon Scroggins III5b581492023-10-31 14:29:41 -0400218 void onCompositionPresented(const DisplayDevice*,
219 const std::shared_ptr<FenceTime>& /*glDoneFence*/,
220 const std::shared_ptr<FenceTime>& /*presentFence*/,
Vishnu Nair39a74a92024-07-29 19:01:50 +0000221 const CompositorTiming&, gui::GameMode gameMode);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700222
223 // If a buffer was replaced this frame, release the former buffer
Patrick Williamsbb25f802022-08-30 23:02:34 +0000224 void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700225
Peiyong Linf243e5e2020-08-22 17:40:59 -0700226 /*
227 * latchBuffer - called each time the screen is redrawn and returns whether
228 * the visible regions need to be recomputed (this is a fairly heavy
229 * operation, so this should be set only if needed). Typically this is used
230 * to figure out if the content or size of a surface has changed.
231 */
Vishnu Naird47bcee2023-02-24 18:08:51 +0000232 bool latchBufferImpl(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
233 bool bgColorOnly);
234
Patrick Williamsbb25f802022-08-30 23:02:34 +0000235 /*
Vishnu Nair7ee4f462023-04-19 09:54:09 -0700236 * Returns true if the currently presented buffer will be released when this layer state
237 * is latched. This will return false if there is no buffer currently presented.
238 */
239 bool willReleaseBufferOnLatch() const;
240
Patrick Williamsbb25f802022-08-30 23:02:34 +0000241 sp<GraphicBuffer> getBuffer() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700242 /**
243 * Returns active buffer size in the correct orientation. Buffer size is determined by undoing
Patrick Williamsbb25f802022-08-30 23:02:34 +0000244 * any buffer transformations. Returns Rect::INVALID_RECT if the layer has no buffer or the
245 * layer does not have a display frame and its parent is not bounded.
Peiyong Linf243e5e2020-08-22 17:40:59 -0700246 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000247 Rect getBufferSize(const Layer::State&) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700248
Vishnu Nairdc83d4b2024-08-15 16:29:20 +0000249 FrameRate getFrameRateForLayerTree() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700250
Patrick Williamsbb25f802022-08-30 23:02:34 +0000251 bool getTransformToDisplayInverse() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700252
Peiyong Linf243e5e2020-08-22 17:40:59 -0700253 // Implements RefBase.
254 void onFirstRef() override;
255
Patrick Williamsbb25f802022-08-30 23:02:34 +0000256 struct BufferInfo {
257 nsecs_t mDesiredPresentTime;
258 std::shared_ptr<FenceTime> mFenceTime;
259 sp<Fence> mFence;
260 uint32_t mTransform{0};
261 ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};
262 Rect mCrop;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000263 PixelFormat mPixelFormat{PIXEL_FORMAT_NONE};
264 bool mTransformToDisplayInverse{false};
Patrick Williamsbb25f802022-08-30 23:02:34 +0000265 std::shared_ptr<renderengine::ExternalTexture> mBuffer;
266 uint64_t mFrameNumber;
Vishnu Nair7ee4f462023-04-19 09:54:09 -0700267 sp<IBinder> mReleaseBufferEndpoint;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000268 bool mFrameLatencyNeeded{false};
Alec Mouri1b0d4e12024-02-12 22:27:19 +0000269 float mDesiredHdrSdrRatio = -1.f;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000270 };
271
272 BufferInfo mBufferInfo;
Patrick Williams7c9fa272024-08-30 12:38:43 +0000273 std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint> mBufferReleaseChannel;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000274
Patrick Williamsbb25f802022-08-30 23:02:34 +0000275 bool fenceHasSignaled() const;
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000276 void onPreComposition(nsecs_t refreshStartTime);
Alec Mouri9892aac2023-12-11 21:16:59 +0000277 void onLayerDisplayed(ftl::SharedFuture<FenceResult>, ui::LayerStack layerStack,
278 std::function<FenceResult(FenceResult)>&& continuation = nullptr);
Robert Carrccab4242021-09-28 16:53:03 -0700279
Melody Hsu793f8362024-01-08 20:00:35 +0000280 // Tracks mLastClientCompositionFence and gets the callback handle for this layer.
281 sp<CallbackHandle> findCallbackHandle();
282
283 // Adds the future release fence to a list of fences that are used to release the
284 // last presented buffer. Also keeps track of the layerstack in a list of previous
285 // layerstacks that have been presented.
286 void prepareReleaseCallbacks(ftl::Future<FenceResult>, ui::LayerStack layerStack);
287
Vishnu Naire14c6b32022-08-06 04:20:15 +0000288 void setWasClientComposed(const sp<Fence>& fence) {
Robert Carrccab4242021-09-28 16:53:03 -0700289 mLastClientCompositionFence = fence;
Robert Carr05da0082022-05-25 23:29:34 -0700290 mClearClientCompositionFenceOnLayerDisplayed = false;
Robert Carrccab4242021-09-28 16:53:03 -0700291 }
292
Vishnu Naire14c6b32022-08-06 04:20:15 +0000293 const char* getDebugName() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700294
Chavi Weingarten076acac2023-01-19 17:20:43 +0000295 static bool computeTrustedPresentationState(const FloatRect& bounds,
296 const FloatRect& sourceBounds,
297 const Region& coveredRegion,
298 const FloatRect& screenBounds, float,
299 const ui::Transform&,
300 const TrustedPresentationThresholds&);
Vishnu Nair781d7252023-01-30 18:16:01 +0000301 void updateTrustedPresentationState(const DisplayDevice* display,
302 const frontend::LayerSnapshot* snapshot, int64_t time_in_ms,
Chavi Weingarten076acac2023-01-19 17:20:43 +0000303 bool leaveState);
304
305 inline bool hasTrustedPresentationListener() {
306 return mTrustedPresentationListener.callbackInterface != nullptr;
307 }
308
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700309 // Sets the masked bits.
310 void setTransactionFlags(uint32_t mask);
311
Vishnu Naire14c6b32022-08-06 04:20:15 +0000312 int32_t getSequence() const { return sequence; }
Pablo Ceballos40845df2016-01-25 17:41:15 -0800313
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700314 // For tracing.
315 // TODO: Replace with raw buffer id from buffer metadata when that becomes available.
316 // GraphicBuffer::getId() does not provide a reliable global identifier. Since the traces
317 // creates its tracks by buffer id and has no way of associating a buffer back to the process
318 // that created it, the current implementation is only sufficient for cases where a buffer is
319 // only used within a single layer.
chaviwd62d3062019-09-04 14:48:02 -0700320 uint64_t getCurrentBufferId() const { return getBuffer() ? getBuffer()->getId() : 0; }
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700321
Kean Mariotti4ba343c2023-04-19 13:31:02 +0000322 void writeCompositionStateToProto(perfetto::protos::LayerProto* layerProto,
323 ui::LayerStack layerStack);
chaviw08f3cb22020-01-13 13:17:21 -0800324
chaviw98318de2021-05-19 16:45:23 -0500325 gui::WindowInfo::Type getWindowType() const { return mWindowType; }
Peiyong Lin97067b02019-03-29 17:34:45 +0000326
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800327 inline const State& getDrawingState() const { return mDrawingState; }
Robert Carr6a160312021-05-17 12:08:20 -0700328 inline State& getDrawingState() { return mDrawingState; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800329
Vishnu Nair3cc15a42023-06-30 06:20:22 +0000330 void miniDump(std::string& result, const frontend::LayerSnapshot&, const DisplayDevice&) const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800331 void dumpFrameStats(std::string& result) const;
Svetoslavd85084b2014-03-20 10:28:31 -0700332 void clearFrameStats();
Jamie Gennis6547ff42013-07-16 20:12:42 -0700333 void logFrameStats();
Svetoslavd85084b2014-03-20 10:28:31 -0700334 void getFrameStats(FrameStats* outStats) const;
Brian Anderson5ea5e592016-12-01 16:54:33 -0800335 void onDisconnect();
Pablo Ceballosce796e72016-02-04 19:10:51 -0800336
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800337 half4 getColor() const;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800338 int32_t getBackgroundBlurRadius() const;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800339 bool drawShadows() const { return mEffectiveShadowRadius > 0.f; };
Robert Carr6452f122017-03-21 10:41:29 -0700340
Vishnu Nair787aa782023-03-17 13:46:46 -0700341 bool isHandleAlive() const { return mHandleAlive; }
342 bool onHandleDestroyed() { return mHandleAlive = false; }
Vishnu Nair4351ad52019-02-11 14:13:02 -0800343
Vishnu Nairefc42e22019-12-03 17:36:12 -0800344 /**
345 * Returns the cropped buffer size or the layer crop if the layer has no buffer. Return
346 * INVALID_RECT if the layer has no buffer and no crop.
347 * A layer with an invalid buffer size and no crop is considered to be boundless. The layer
348 * bounds are constrained by its parent bounds.
349 */
350 Rect getCroppedBufferSize(const Layer::State& s) const;
351
Vishnu Nairdc83d4b2024-08-15 16:29:20 +0000352 void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& /*info*/) {}
Vishnu Nair39a74a92024-07-29 19:01:50 +0000353 void setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info, nsecs_t postTime,
354 gui::GameMode gameMode);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000355 void setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo& info,
Vishnu Nair39a74a92024-07-29 19:01:50 +0000356 nsecs_t postTime, gui::GameMode gameMode);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000357
Ady Abraham88930f92023-06-07 10:32:08 -0700358 void addSurfaceFrameDroppedForBuffer(std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame,
359 nsecs_t dropTime);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000360 void addSurfaceFramePresentedForBuffer(
361 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t acquireFenceTime,
362 nsecs_t currentLatchTime);
363
364 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForTransaction(
Vishnu Nair39a74a92024-07-29 19:01:50 +0000365 const FrameTimelineInfo& info, nsecs_t postTime, gui::GameMode gameMode);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000366 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForBuffer(
Vishnu Nair39a74a92024-07-29 19:01:50 +0000367 const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName,
368 gui::GameMode gameMode);
Ady Abraham88930f92023-06-07 10:32:08 -0700369 void setFrameTimelineVsyncForSkippedFrames(const FrameTimelineInfo& info, nsecs_t postTime,
Vishnu Nair39a74a92024-07-29 19:01:50 +0000370 std::string debugName, gui::GameMode gameMode);
Ady Abraham74e17562020-08-24 18:18:19 -0700371
Chavi Weingarten328a8312023-01-26 21:17:52 +0000372 bool setTrustedPresentationInfo(TrustedPresentationThresholds const& thresholds,
Chavi Weingarten076acac2023-01-19 17:20:43 +0000373 TrustedPresentationListener const& listener);
Patrick Williams7c9fa272024-08-30 12:38:43 +0000374 void setBufferReleaseChannel(
375 const std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint>& channel);
Chavi Weingarten076acac2023-01-19 17:20:43 +0000376
Peiyong Linf243e5e2020-08-22 17:40:59 -0700377 // Creates a new handle each time, so we only expect
378 // this to be called once.
379 sp<IBinder> getHandle();
380 const std::string& getName() const { return mName; }
chaviw98318de2021-05-19 16:45:23 -0500381 void setInputInfo(const gui::WindowInfo& info);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700382
Ady Abraham62a0be22020-12-08 16:54:10 -0800383 virtual uid_t getOwnerUid() const { return mOwnerUid; }
Peiyong Linf243e5e2020-08-22 17:40:59 -0700384
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700385 pid_t getOwnerPid() { return mOwnerPid; }
386
Tony Huangf3621102023-09-04 17:14:22 +0800387 int32_t getOwnerAppId() { return mOwnerAppId; }
388
Arthur Hungc70bee22023-06-02 01:35:52 +0000389 // Used to check if mUsedVsyncIdForRefreshRateSelection should be expired when it stop updating.
390 nsecs_t mMaxTimeForUseVsyncId = 0;
391 // True when DrawState.useVsyncIdForRefreshRateSelection previously set to true during updating
392 // buffer.
393 bool mUsedVsyncIdForRefreshRateSelection{false};
394
Peiyong Linf243e5e2020-08-22 17:40:59 -0700395 // Layer serial number. This gives layers an explicit ordering, so we
396 // have a stable sort order when their layer stack and Z-order are
397 // the same.
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800398 const int32_t sequence;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700399
400 bool mPendingHWCDestroy{false};
Steven Thomas3172e202020-01-06 19:25:30 -0800401
Patrick Williamsbb25f802022-08-30 23:02:34 +0000402 // See mPendingBufferTransactions
403 void decrementPendingBufferCount();
404 std::atomic<int32_t>* getPendingBufferCounter() { return &mPendingBufferTransactions; }
405 std::string getPendingBufferCounterName() { return mBlastTransactionName; }
liulijuneb489f62022-10-17 22:02:14 +0800406 void callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
407 const sp<GraphicBuffer>& buffer, uint64_t framenumber,
408 const sp<Fence>& releaseFence);
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700409 bool setFrameRateForLayerTree(FrameRate, const scheduler::LayerProps&, nsecs_t now);
410 void recordLayerHistoryBufferUpdate(const scheduler::LayerProps&, nsecs_t now);
411 void recordLayerHistoryAnimationTx(const scheduler::LayerProps&, nsecs_t now);
Vishnu Nairc09c0232023-03-02 03:22:35 +0000412 bool hasBuffer() const { return mBufferInfo.mBuffer != nullptr; }
Vishnu Nairb76d99a2023-03-19 18:22:31 -0700413 void setTransformHint(std::optional<ui::Transform::RotationFlags> transformHint) {
414 mTransformHint = transformHint;
415 }
Vishnu Nairc1d19d72023-08-10 12:35:11 -0700416 void commitTransaction();
Vishnu Nair7ee4f462023-04-19 09:54:09 -0700417 // Keeps track of the previously presented layer stacks. This is used to get
418 // the release fences from the correct displays when we release the last buffer
419 // from the layer.
420 std::vector<ui::LayerStack> mPreviouslyPresentedLayerStacks;
Melody Hsu793f8362024-01-08 20:00:35 +0000421
Alec Mouri9892aac2023-12-11 21:16:59 +0000422 struct FenceAndContinuation {
423 ftl::SharedFuture<FenceResult> future;
424 std::function<FenceResult(FenceResult)> continuation;
425
426 ftl::SharedFuture<FenceResult> chain() const {
427 if (continuation) {
428 return ftl::Future(future).then(continuation).share();
429 } else {
430 return future;
431 }
432 }
433 };
Melody Hsu793f8362024-01-08 20:00:35 +0000434 std::vector<FenceAndContinuation> mPreviousReleaseFenceAndContinuations;
435
436 // Release fences for buffers that have not yet received a release
437 // callback. A release callback may not be given when capturing
438 // screenshots asynchronously. There may be no buffer update for the
439 // layer, but the layer will still be composited on the screen in every
440 // frame. Kepping track of these fences ensures that they are not dropped
Melody Hsue4ef87f2024-03-26 23:54:45 +0000441 // and can be dispatched to the client at a later time. Older fences are
442 // dropped when a layer stack receives a new fence.
443 // TODO(b/300533018): Track fence per multi-instance RenderEngine
444 ftl::SmallMap<ui::LayerStack, ftl::Future<FenceResult>, ui::kDisplayCapacity>
445 mAdditionalPreviousReleaseFences;
Melody Hsu793f8362024-01-08 20:00:35 +0000446
Josh Gao194ff392022-09-08 16:19:29 -0700447 // Exposed so SurfaceFlinger can assert that it's held
448 const sp<SurfaceFlinger> mFlinger;
449
Arthur Hungc70bee22023-06-02 01:35:52 +0000450 // Check if the damage region is a small dirty.
Arthur Hung69f95222023-10-04 07:39:02 +0000451 void setIsSmallDirty(frontend::LayerSnapshot* snapshot);
Arthur Hungc70bee22023-06-02 01:35:52 +0000452
Mathias Agopian13127d82013-03-05 17:47:11 -0800453protected:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700454 // For unit tests
455 friend class TestableSurfaceFlinger;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800456 friend class FpsReporterTest;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700457 friend class RefreshRateSelectionTest;
458 friend class SetFrameRateTest;
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000459 friend class TransactionFrameTracerTest;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000460 friend class TransactionSurfaceFrameTest;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700461
Patrick Williamsbb25f802022-08-30 23:02:34 +0000462 void gatherBufferInfo();
Peiyong Linf243e5e2020-08-22 17:40:59 -0700463
Peiyong Linf243e5e2020-08-22 17:40:59 -0700464 compositionengine::OutputLayer* findOutputLayerForDisplay(const DisplayDevice*) const;
Vishnu Nair3cc15a42023-06-30 06:20:22 +0000465 compositionengine::OutputLayer* findOutputLayerForDisplay(
466 const DisplayDevice*, const frontend::LayerHierarchy::TraversalPath& path) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700467
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700468 const std::string mName;
469 const std::string mTransactionName{"TX - " + mName};
Mathias Agopian13127d82013-03-05 17:47:11 -0800470
Vishnu Nairdc83d4b2024-08-15 16:29:20 +0000471 // These are only accessed by the main thread.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800472 State mDrawingState;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800473
Chavi Weingarten076acac2023-01-19 17:20:43 +0000474 TrustedPresentationThresholds mTrustedPresentationThresholds;
475 TrustedPresentationListener mTrustedPresentationListener;
476 bool mLastComputedTrustedPresentationState = false;
477 bool mLastReportedTrustedPresentationState = false;
478 int64_t mEnteredTrustedPresentationStateTime = -1;
479
Robert Carr38d25002021-06-11 14:30:09 -0700480 uint32_t mTransactionFlags{0};
Dan Stoza7dde5992015-05-22 09:51:44 -0700481
Brian Andersond6927fb2016-07-23 23:37:30 -0700482 // Timestamp history for UIAutomation. Thread safe.
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800483 FrameTracker mFrameTracker;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700484
485 // main thread
Lloyd Pique0b785d82018-12-04 17:25:27 -0800486 sp<NativeHandle> mSidebandStream;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000487
Robert Carrc3574f72016-03-24 12:19:32 -0700488 // We encode unset as -1.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700489 std::atomic<uint64_t> mCurrentFrameNumber{0};
Mathias Agopian13127d82013-03-05 17:47:11 -0800490
491 // protected by mLock
492 mutable Mutex mLock;
David Sodman0c69cad2017-08-21 12:12:51 -0700493
Riley Andrews03414a12014-07-01 14:22:59 -0700494 // This layer can be a cursor on some displays.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700495 bool mPotentialCursor{false};
Dan Stoza6b9454d2014-11-07 16:00:59 -0800496
Ady Abraham8f1ee7f2019-04-05 10:32:50 -0700497 // Window types from WindowManager.LayoutParams
chaviw98318de2021-05-19 16:45:23 -0500498 const gui::WindowInfo::Type mWindowType;
Ady Abraham8f1ee7f2019-04-05 10:32:50 -0700499
Alec Mouri9a29e672020-09-14 12:39:14 -0700500 // The owner of the layer. If created from a non system process, it will be the calling uid.
501 // If created from a system process, the value can be passed in.
502 uid_t mOwnerUid;
503
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700504 // The owner pid of the layer. If created from a non system process, it will be the calling pid.
505 // If created from a system process, the value can be passed in.
506 pid_t mOwnerPid;
507
Tony Huangf3621102023-09-04 17:14:22 +0800508 int32_t mOwnerAppId;
509
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000510 // Keeps track of the time SF latched the last buffer from this layer.
511 // Used in buffer stuffing analysis in FrameTimeline.
512 nsecs_t mLastLatchTime = 0;
513
Robert Carrccab4242021-09-28 16:53:03 -0700514 sp<Fence> mLastClientCompositionFence;
Robert Carr05da0082022-05-25 23:29:34 -0700515 bool mClearClientCompositionFenceOnLayerDisplayed = false;
chaviw4b129c22018-04-09 16:19:43 -0700516private:
Tony Huangf3621102023-09-04 17:14:22 +0800517 // Range of uids allocated for a user.
518 // This value is taken from android.os.UserHandle#PER_USER_RANGE.
519 static constexpr int32_t PER_USER_RANGE = 100000;
520
Patrick Williamsbb25f802022-08-30 23:02:34 +0000521 friend class SlotGenerationTest;
522 friend class TransactionFrameTracerTest;
523 friend class TransactionSurfaceFrameTest;
524
Patrick Williamsbb25f802022-08-30 23:02:34 +0000525 bool getSidebandStreamChanged() const { return mSidebandStreamChanged; }
526
527 std::atomic<bool> mSidebandStreamChanged{false};
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700528
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500529 aidl::android::hardware::graphics::composer3::Composition getCompositionType(
530 const DisplayDevice&) const;
Vishnu Nair3cc15a42023-06-30 06:20:22 +0000531 aidl::android::hardware::graphics::composer3::Composition getCompositionType(
532 const compositionengine::OutputLayer*) const;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800533
Patrick Williamsbb25f802022-08-30 23:02:34 +0000534 inline void tracePendingBufferCount(int32_t pendingBuffers);
535
536 // Latch sideband stream and returns true if the dirty region should be updated.
537 bool latchSidebandStream(bool& recomputeVisibleRegions);
538
Vishnu Naird47bcee2023-02-24 18:08:51 +0000539 void updateTexImage(nsecs_t latchTime, bool bgColorOnly = false);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000540
541 // Crop that applies to the buffer
542 Rect computeBufferCrop(const State& s);
543
Patrick Williamsbb25f802022-08-30 23:02:34 +0000544 void callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
545 const sp<GraphicBuffer>& buffer, uint64_t framenumber,
546 const sp<Fence>& releaseFence,
547 uint32_t currentMaxAcquiredBufferCount);
548
Patrick Williamsbb25f802022-08-30 23:02:34 +0000549 bool hasBufferOrSidebandStream() const {
550 return ((mSidebandStream != nullptr) || (mBufferInfo.mBuffer != nullptr));
551 }
552
Vishnu Nair22491b82022-10-18 14:59:14 -0700553 bool hasBufferOrSidebandStreamInDrawing() const {
554 return ((mDrawingState.sidebandStream != nullptr) || (mDrawingState.buffer != nullptr));
555 }
556
Robert Carrc0df3122019-04-11 13:18:21 -0700557 bool mGetHandleCalled = false;
chaviw43cb3cb2019-05-31 15:23:41 -0700558
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700559 // The inherited shadow radius after taking into account the layer hierarchy. This is the
560 // final shadow radius for this layer. If a shadow is specified for a layer, then effective
561 // shadow radius is the set shadow radius, otherwise its the parent's shadow radius.
Vishnu Nairf37dcfb2019-11-16 07:37:09 -0800562 float mEffectiveShadowRadius = 0.f;
Lucas Dupinc3800b82020-10-02 16:24:48 -0700563
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700564 // Game mode for the layer. Set by WindowManagerShell and recorded by SurfaceFlingerStats.
Vishnu Nair8fc721b2022-12-22 20:06:32 +0000565 gui::GameMode mGameMode = gui::GameMode::Unsupported;
Adithya Srinivasanac977e62021-05-21 22:50:56 +0000566
Vishnu Nair14d218b2021-07-13 13:57:39 -0700567 bool mIsAtRoot = false;
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800568
569 uint32_t mLayerCreationFlags;
Tianhao Yao67dd7122022-02-22 17:48:33 +0000570
Dorin Drimuse5374e52023-08-02 17:52:43 +0000571 void releasePreviousBuffer();
Vishnu Nair7ee4f462023-04-19 09:54:09 -0700572 void resetDrawingStateBufferInfo();
Patrick Williamsbb25f802022-08-30 23:02:34 +0000573
Patrick Williamsbb25f802022-08-30 23:02:34 +0000574 // Transform hint provided to the producer. This must be accessed holding
575 // the mStateLock.
Vishnu Nairb76d99a2023-03-19 18:22:31 -0700576 std::optional<ui::Transform::RotationFlags> mTransformHint = std::nullopt;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000577
Patrick Williamsbb25f802022-08-30 23:02:34 +0000578 ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;
Vishnu Nair7ee4f462023-04-19 09:54:09 -0700579 sp<IBinder> mPreviousReleaseBufferEndpoint;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000580
581 bool mReleasePreviousBuffer = false;
582
583 // Stores the last set acquire fence signal time used to populate the callback handle's acquire
584 // time.
585 std::variant<nsecs_t, sp<Fence>> mCallbackHandleAcquireTimeOrFence = -1;
586
Patrick Williamsbb25f802022-08-30 23:02:34 +0000587 const std::string mBlastTransactionName{"BufferTX - " + mName};
588 // This integer is incremented everytime a buffer arrives at the server for this layer,
589 // and decremented when a buffer is dropped or latched. When changed the integer is exported
Vishnu Nair2665ca92024-07-09 22:08:15 +0000590 // to systrace with SFTRACE_INT and mBlastTransactionName. This way when debugging perf it is
Patrick Williamsbb25f802022-08-30 23:02:34 +0000591 // possible to see when a buffer arrived at the server, and in which frame it latched.
592 //
593 // You can understand the trace this way:
594 // - If the integer increases, a buffer arrived at the server.
595 // - If the integer decreases in latchBuffer, that buffer was latched
Melody Hsu29f7d5c2024-09-23 07:36:19 +0000596 // - If the integer decreases in setBuffer, a buffer was dropped
Patrick Williamsbb25f802022-08-30 23:02:34 +0000597 std::atomic<int32_t> mPendingBufferTransactions{0};
598
599 // Contains requested position and matrix updates. This will be applied if the client does
600 // not specify a destination frame.
601 ui::Transform mRequestedTransform;
602
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000603 std::vector<std::pair<frontend::LayerHierarchy::TraversalPath, sp<LayerFE>>> mLayerFEs;
Vishnu Nair787aa782023-03-17 13:46:46 -0700604 bool mHandleAlive = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800605};
606
Marin Shalamanov46084422020-10-13 12:33:42 +0200607std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate);
608
Dominik Laskowski34157762018-10-31 13:07:19 -0700609} // namespace android