blob: f85a6c6d445b25327d5db558d76d473debe7a4e8 [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 Laskowski9dab3432019-03-27 13:21:10 -070017#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080019#include <sys/types.h>
20
Mathias Agopian3f844832013-08-07 21:24:32 -070021/*
22 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
23 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070024
Dominik Laskowski83b88212018-12-11 13:34:06 -080025#include <android-base/thread_annotations.h>
Lloyd Pique6a3b4462019-03-07 20:58:12 -080026#include <compositionengine/OutputColorSetting.h>
Steven Moreland2716e112018-02-23 14:57:20 -080027#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080028#include <cutils/compiler.h>
29#include <gui/BufferQueue.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080030#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080031#include <gui/ISurfaceComposer.h>
32#include <gui/ISurfaceComposerClient.h>
Valerie Hau5de3ad22019-08-20 07:47:43 -070033#include <gui/ITransactionCompletedListener.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070034#include <gui/LayerState.h>
Dan Stozae77c7662016-05-13 11:37:28 -070035#include <gui/OccupancyTracker.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080036#include <layerproto/LayerProtoHeader.h>
37#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080038#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070039#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070040#include <system/graphics.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080041#include <ui/FenceTime.h>
42#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010043#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080044#include <utils/Errors.h>
45#include <utils/KeyedVector.h>
46#include <utils/RefBase.h>
47#include <utils/SortedVector.h>
48#include <utils/Trace.h>
49#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070050
Marissa Wall947d34e2019-03-29 14:03:53 -070051#include "ClientCache.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070052#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080053#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080054#include "DisplayHardware/PowerAdvisor.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020055#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080056#include "Effects/Daltonizer.h"
Marin Shalamanov5801c942020-12-17 17:00:13 +010057#include "Fps.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080058#include "FrameTracker.h"
Robert Carr2047fae2016-11-28 14:09:09 -080059#include "LayerVector.h"
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080060#include "Scheduler/RefreshRateConfigs.h"
Ana Krulecb43429d2019-01-09 14:28:51 -080061#include "Scheduler/RefreshRateStats.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070062#include "Scheduler/Scheduler.h"
Dominik Laskowskia93a5312020-07-23 15:10:03 -070063#include "Scheduler/VsyncModulator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080064#include "SurfaceFlingerFactory.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080065#include "SurfaceTracing.h"
Ady Abraham50204dd2019-07-19 15:47:11 -070066#include "TracedOrdinal.h"
Robert Carr9a803c32021-01-14 16:57:58 -080067#include "TransactionCallbackInvoker.h"
Mathias Agopian86303202012-07-24 22:46:10 -070068
Dominik Laskowski83b88212018-12-11 13:34:06 -080069#include <atomic>
70#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080071#include <functional>
Dominik Laskowskidd4ef272020-04-23 14:02:12 -070072#include <future>
Dan Stozae77c7662016-05-13 11:37:28 -070073#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080074#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080075#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -070076#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080077#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070078#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070079#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070080#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -080081#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -070082#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -070083#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080084#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070085
chaviw1d044282017-09-27 12:19:28 -070086using namespace android::surfaceflinger;
87
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080088namespace android {
89
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080090class Client;
Lloyd Pique144e1162017-12-20 16:44:52 -080091class EventThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -080092class FpsReporter;
John Reck88270902021-03-18 11:27:35 -040093class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070094class HWComposer;
Chris Ye0783e992020-06-02 21:34:49 -070095struct SetInputWindowsListener;
Lloyd Pique12eb4232018-01-17 11:54:43 -080096class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -080097class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070098class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -070099class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700100class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200101class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800102class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700103class FrameTracer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800104
chaviw0ef7caa2021-01-05 11:04:50 -0800105using gui::ScreenCaptureResults;
106
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700107namespace frametimeline {
108class FrameTimeline;
109}
110
Chris Ye0783e992020-06-02 21:34:49 -0700111namespace os {
112 class IInputFlinger;
113}
114
Lloyd Pique542307f2018-10-19 13:24:08 -0700115namespace compositionengine {
116class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800117class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800118
119struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700120} // namespace compositionengine
121
Peiyong Lin833074a2018-08-28 11:53:54 -0700122namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800123class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700124} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700125
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800126enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700127 eTransactionNeeded = 0x01,
128 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700129 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700130 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700131 eTransactionFlushNeeded = 0x10,
132 eTransactionMask = 0x1f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800133};
134
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800135using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800136
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700137struct SurfaceFlingerBE {
David Sodman73beded2017-11-15 11:56:06 -0800138 FenceTimeline mGlCompositionDoneTimeline;
139 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800140
David Sodman99974d22017-11-28 12:04:33 -0800141 // protected by mCompositorTimingLock;
142 mutable std::mutex mCompositorTimingLock;
143 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800144
David Sodman99974d22017-11-28 12:04:33 -0800145 // Only accessed from the main thread.
146 struct CompositePresentTime {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700147 nsecs_t composite = -1;
148 std::shared_ptr<FenceTime> display = FenceTime::NO_FENCE;
David Sodman99974d22017-11-28 12:04:33 -0800149 };
150 std::queue<CompositePresentTime> mCompositePresentTimes;
151
David Sodman4a36e932017-11-07 14:29:47 -0800152 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700153 nsecs_t mFrameBuckets[NUM_BUCKETS] = {};
154 nsecs_t mTotalTime = 0;
155 std::atomic<nsecs_t> mLastSwapTime = 0;
David Sodman4a36e932017-11-07 14:29:47 -0800156
David Sodmancbaf0832017-11-07 14:21:36 -0800157 // Double- vs. triple-buffering stats
158 struct BufferingStats {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700159 size_t numSegments = 0;
160 nsecs_t totalTime = 0;
David Sodmancbaf0832017-11-07 14:21:36 -0800161
162 // "Two buffer" means that a third buffer was never used, whereas
163 // "double-buffered" means that on average the segment only used two
164 // buffers (though it may have used a third for some part of the
165 // segment)
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700166 nsecs_t twoBufferTime = 0;
167 nsecs_t doubleBufferedTime = 0;
168 nsecs_t tripleBufferedTime = 0;
David Sodmancbaf0832017-11-07 14:21:36 -0800169 };
170 mutable Mutex mBufferingStatsMutex;
171 std::unordered_map<std::string, BufferingStats> mBufferingStats;
chaviw291d88a2019-02-14 10:33:58 -0800172};
David Sodman105b7dc2017-11-04 20:28:14 -0700173
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700174class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700175 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700176 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800177 private HWC2::ComposerCallback,
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800178 private ISchedulerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800179public:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700180 struct SkipInitializationTag {};
181
182 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
183 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
184
185 // set main thread scheduling policy
186 static status_t setSchedFifo(bool enabled) ANDROID_API;
187
188 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800189
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800190 // This is the phase offset in nanoseconds of the software vsync event
191 // relative to the vsync event reported by HWComposer. The software vsync
192 // event is when SurfaceFlinger and Choreographer-based applications run each
193 // frame.
194 //
195 // This phase offset allows adjustment of the minimum latency from application
196 // wake-up time (by Choreographer) to the time at which the resulting window
197 // image is displayed. This value may be either positive (after the HW vsync)
198 // or negative (before the HW vsync). Setting it to 0 will result in a lower
199 // latency bound of two vsync periods because the app and SurfaceFlinger
200 // will run just after the HW vsync. Setting it to a positive number will
201 // result in the minimum latency being:
202 //
203 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
204 //
205 // Note that reducing this latency makes it more likely for the applications
206 // to not have their window content image ready in time. When this happens
207 // the latency will end up being an additional vsync period, and animations
208 // will hiccup. Therefore, this latency should be tuned somewhat
209 // conservatively (or at least with awareness of the trade-off being made).
210 static int64_t vsyncPhaseOffsetNs;
211 static int64_t sfVsyncPhaseOffsetNs;
212
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800213 // If fences from sync Framework are supported.
214 static bool hasSyncFramework;
215
Ady Abraham8cb21882020-08-26 18:22:05 -0700216 // The offset in nanoseconds to use when VsyncController timestamps present fence
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700217 // signaling time.
218 static int64_t dispSyncPresentTimeOffset;
219
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700220 // Some hardware can do RGB->YUV conversion more efficiently in hardware
221 // controlled by HWC than in hardware controlled by the video encoder.
222 // This instruct VirtualDisplaySurface to use HWC for such conversion on
223 // GL composition.
224 static bool useHwcForRgbToYuv;
225
Fabien Sanglard1971b632017-03-10 14:50:03 -0800226 // Controls the number of buffers SurfaceFlinger will allocate for use in
227 // FramebufferSurface
228 static int64_t maxFrameBufferAcquiredBuffers;
229
Brian Lindahla13f2d52020-03-05 11:54:17 +0100230 // Controls the maximum width and height in pixels that the graphics pipeline can support for
231 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
232 static uint32_t maxGraphicsWidth;
233 static uint32_t maxGraphicsHeight;
234
Peiyong Lin13effd12018-07-24 17:01:47 -0700235 // Indicate if a device has wide color gamut display. This is typically
236 // found on devices with wide color gamut (e.g. Display-P3) display.
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600237 static bool hasWideColorDisplay;
238
Dominik Laskowski718f9602019-11-09 20:01:35 -0800239 static ui::Rotation internalDisplayOrientation;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700240
Peiyong Lin13effd12018-07-24 17:01:47 -0700241 // Indicate if device wants color management on its display.
242 static bool useColorManagement;
243
Peiyong Linb3839ad2018-09-05 15:37:19 -0700244 static bool useContextPriority;
245
Peiyong Lin0256f722018-08-31 15:45:10 -0700246 // The data space and pixel format that SurfaceFlinger expects hardware composer
247 // to composite efficiently. Meaning under most scenarios, hardware composer
248 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700249 static ui::Dataspace defaultCompositionDataspace;
250 static ui::PixelFormat defaultCompositionPixelFormat;
251
252 // The data space and pixel format that SurfaceFlinger expects hardware composer
253 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
254 // hardware composer will accept layers with the data space and pixel format.
255 static ui::Dataspace wideColorGamutCompositionDataspace;
256 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700257
Ana Krulec3803b8d2020-02-03 16:35:46 -0800258 // Whether to use frame rate API when deciding about the refresh rate of the display. This
259 // variable is caches in SF, so that we can check it with each layer creation, and a void the
260 // overhead that is caused by reading from sysprop.
261 static bool useFrameRateApi;
262
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800263 static constexpr SkipInitializationTag SkipInitialization;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800264
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700265 // must be called before clients can connect
266 void init() ANDROID_API;
267
268 // starts SurfaceFlinger main loop in the current thread
269 void run() ANDROID_API;
270
Peiyong Linf243e5e2020-08-22 17:40:59 -0700271 SurfaceFlingerBE& getBE() { return mBE; }
272 const SurfaceFlingerBE& getBE() const { return mBE; }
273
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700274 // Schedule an asynchronous or synchronous task on the main thread.
275 template <typename F, typename T = std::invoke_result_t<F>>
276 [[nodiscard]] std::future<T> schedule(F&&);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800277
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700278 // force full composition on all displays
279 void repaintEverything();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800280
Lloyd Pique90c115d2018-09-18 21:39:42 -0700281 surfaceflinger::Factory& getFactory() { return mFactory; }
282
Lloyd Pique70d91362018-10-18 16:02:55 -0700283 // The CompositionEngine encapsulates all composition related interfaces and actions.
284 compositionengine::CompositionEngine& getCompositionEngine() const;
285
Dan Stoza436ccf32018-06-21 12:10:12 -0700286 // Obtains a name from the texture pool, or, if the pool is empty, posts a
287 // synchronous message to the main thread to obtain one on the fly
288 uint32_t getNewTexture();
289
Mathias Agopian86303202012-07-24 22:46:10 -0700290 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700291 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700292
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700293 // called on the main thread by MessageQueue when an internal message
294 // is received
295 // TODO: this should be made accessible only to MessageQueue
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700296 void onMessageReceived(int32_t what, int64_t vsyncId, nsecs_t expectedVSyncTime);
Mathias Agopian3094df32012-06-18 18:06:45 -0700297
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700298 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700299
Robert Carr0d480722017-01-10 16:42:54 -0800300 bool authenticateSurfaceTextureLocked(
301 const sp<IGraphicBufferProducer>& bufferProducer) const;
302
Dominik Laskowski75848362019-11-11 17:57:20 -0800303 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700304 void onLayerDestroyed(Layer*);
Robert Carr2e102c92018-10-23 12:11:15 -0700305
Valerie Hauc5686802019-11-22 14:18:09 -0800306 void removeFromOffscreenLayers(Layer* layer);
307
Robert Carr9a803c32021-01-14 16:57:58 -0800308 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
309 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700310 }
311
Alec Mouri9a02eda2020-04-21 17:39:34 -0700312 // Converts from a binder handle to a Layer
313 // Returns nullptr if the handle does not point to an existing layer.
314 // Otherwise, returns a weak reference so that callers off the main-thread
315 // won't accidentally hold onto the last strong reference.
316 wp<Layer> fromHandle(const sp<IBinder>& handle);
Vishnu Nair83df0342021-03-30 11:50:44 -0700317 wp<Layer> fromHandleLocked(const sp<IBinder>& handle) const REQUIRES(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -0700318
Vishnu Nair9b079a22020-01-21 14:36:08 -0800319 // If set, disables reusing client composition buffers. This can be set by
320 // debug.sf.disable_client_composition_cache
321 bool mDisableClientCompositionCache = false;
Chris Ye0783e992020-06-02 21:34:49 -0700322 void setInputWindowsFinished();
Vishnu Nair9b079a22020-01-21 14:36:08 -0800323
Peiyong Linf243e5e2020-08-22 17:40:59 -0700324protected:
325 // We're reference counted, never destroy SurfaceFlinger directly
326 virtual ~SurfaceFlinger();
327
328 virtual uint32_t setClientStateLocked(
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000329 const FrameTimelineInfo& info, const ComposerState& composerState,
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800330 int64_t desiredPresentTime, bool isAutoTimestamp, int64_t postTime,
331 uint32_t permissions,
Galia Peychevae11d5752021-01-22 13:50:16 +0000332 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks)
333 REQUIRES(mStateLock);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700334 virtual void commitTransactionLocked();
335
336 // Used internally by computeLayerBounds() to gets the clip rectangle to use for the
337 // root layers on a particular display in layer-coordinate space. The
338 // layers (and effectively their children) will be clipped against this
339 // rectangle. The base behavior is to clip to the visible region of the
340 // display.
341 virtual FloatRect getLayerClipBoundsForDisplay(const DisplayDevice&) const;
342
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700343private:
David Sodman0c69cad2017-08-21 12:12:51 -0700344 friend class BufferLayer;
Marissa Wallfd668622018-05-10 10:21:13 -0700345 friend class BufferQueueLayer;
Marissa Wall61c58622018-07-18 10:12:20 -0700346 friend class BufferStateLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700347 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800348 friend class FpsReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700349 friend class Layer;
Dan Stozab9b08832014-03-13 11:55:57 -0700350 friend class MonitoredProducer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700351 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800352 friend class RegionSamplingThread;
Nataniel Borges2b796da2019-02-15 13:32:18 -0800353 friend class SurfaceTracing;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800354
Lloyd Piquef58625d2017-12-19 13:22:33 -0800355 // For unit tests
356 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700357 friend class TransactionApplicationTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800358
Peiyong Linf243e5e2020-08-22 17:40:59 -0700359 using RefreshRate = scheduler::RefreshRateConfigs::RefreshRate;
360 using VsyncModulator = scheduler::VsyncModulator;
361 using TransactionSchedule = scheduler::TransactionSchedule;
362 using TraverseLayersFunction = std::function<void(const LayerVector::Visitor&)>;
363 using RenderAreaFuture = std::future<std::unique_ptr<RenderArea>>;
364 using DumpArgs = Vector<String16>;
365 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
366
Jamie Gennis6547ff42013-07-16 20:12:42 -0700367 // This value is specified in number of frames. Log frame stats at most
368 // every half hour.
369 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
370
Robert Carr2047fae2016-11-28 14:09:09 -0800371 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800372 public:
chaviwfd462612018-05-31 16:11:27 -0700373 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700374 State& operator=(const State& other) {
375 // We explicitly don't copy stateSet so that, e.g., mDrawingState
376 // always uses the Drawing StateSet.
377 layersSortedByZ = other.layersSortedByZ;
378 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700379 colorMatrixChanged = other.colorMatrixChanged;
380 if (colorMatrixChanged) {
381 colorMatrix = other.colorMatrix;
382 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800383 globalShadowSettings = other.globalShadowSettings;
384
Dan Stoza412903f2017-04-27 13:42:17 -0700385 return *this;
386 }
387
388 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700389 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700390 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800391
Chia-I Wu28f320b2018-05-03 11:02:56 -0700392 bool colorMatrixChanged = true;
393 mat4 colorMatrix;
394
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800395 renderengine::ShadowSettings globalShadowSettings;
396
Edgar Arriaga844fa672020-01-16 14:21:42 -0800397 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700398 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
399 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800400 };
401
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800402 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
403 // state before the buffers are latched. The layer owns the atomic counters and decrements the
404 // count in the main thread when dropping or latching a buffer.
405 //
406 // The binder threads increment the same counter when a new transaction containing a buffer is
407 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
408 // This is done to avoid lock contention with the main thread.
409 class BufferCountTracker {
410 public:
411 void increment(BBinder* layerHandle) {
412 std::lock_guard<std::mutex> lock(mLock);
413 auto it = mCounterByLayerHandle.find(layerHandle);
414 if (it != mCounterByLayerHandle.end()) {
415 auto [name, pendingBuffers] = it->second;
416 int32_t count = ++(*pendingBuffers);
417 ATRACE_INT(name.c_str(), count);
418 } else {
419 ALOGW("Handle not found! %p", layerHandle);
420 }
421 }
422
423 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
424 std::lock_guard<std::mutex> lock(mLock);
425 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
426 }
427
428 void remove(BBinder* layerHandle) {
429 std::lock_guard<std::mutex> lock(mLock);
430 mCounterByLayerHandle.erase(layerHandle);
431 }
432
433 private:
434 std::mutex mLock;
435 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
436 mCounterByLayerHandle GUARDED_BY(mLock);
437 };
438
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100439 struct ActiveModeInfo {
440 DisplayModeId modeId;
441 Scheduler::ModeEvent event = Scheduler::ModeEvent::None;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700442
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100443 bool operator!=(const ActiveModeInfo& other) const {
444 return modeId != other.modeId || event != other.event;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700445 }
446 };
447
448 enum class BootStage {
449 BOOTLOADER,
450 BOOTANIMATION,
451 FINISHED,
452 };
453
454 struct HotplugEvent {
455 hal::HWDisplayId hwcDisplayId;
456 hal::Connection connection = hal::Connection::INVALID;
457 };
458
arthurhungf1b7c7b2021-03-03 17:42:23 +0800459 class CountDownLatch {
460 public:
Arthur Hung2274a312021-04-28 15:13:06 +0000461 enum {
462 eSyncTransaction = 1 << 0,
463 eSyncInputWindows = 1 << 1,
464 };
465 explicit CountDownLatch(uint32_t flags) : mFlags(flags) {}
arthurhungf1b7c7b2021-03-03 17:42:23 +0800466
Arthur Hung2274a312021-04-28 15:13:06 +0000467 // True if there is no waiting condition after count down.
468 bool countDown(uint32_t flag) {
arthurhungf1b7c7b2021-03-03 17:42:23 +0800469 std::unique_lock<std::mutex> lock(mMutex);
Arthur Hung2274a312021-04-28 15:13:06 +0000470 if (mFlags == 0) {
471 return true;
arthurhungf1b7c7b2021-03-03 17:42:23 +0800472 }
Arthur Hung2274a312021-04-28 15:13:06 +0000473 mFlags &= ~flag;
474 if (mFlags == 0) {
arthurhungf1b7c7b2021-03-03 17:42:23 +0800475 mCountDownComplete.notify_all();
Arthur Hung2274a312021-04-28 15:13:06 +0000476 return true;
arthurhungf1b7c7b2021-03-03 17:42:23 +0800477 }
Arthur Hung2274a312021-04-28 15:13:06 +0000478 return false;
arthurhungf1b7c7b2021-03-03 17:42:23 +0800479 }
480
481 // Return true if triggered.
482 bool wait_until(const std::chrono::seconds& timeout) const {
483 std::unique_lock<std::mutex> lock(mMutex);
484 const auto untilTime = std::chrono::system_clock::now() + timeout;
Arthur Hung2274a312021-04-28 15:13:06 +0000485 while (mFlags != 0) {
arthurhungf1b7c7b2021-03-03 17:42:23 +0800486 // Conditional variables can be woken up sporadically, so we check count
487 // to verify the wakeup was triggered by |countDown|.
488 if (std::cv_status::timeout == mCountDownComplete.wait_until(lock, untilTime)) {
489 return false;
490 }
491 }
492 return true;
493 }
494
495 private:
Arthur Hung2274a312021-04-28 15:13:06 +0000496 uint32_t mFlags;
arthurhungf1b7c7b2021-03-03 17:42:23 +0800497 mutable std::condition_variable mCountDownComplete;
498 mutable std::mutex mMutex;
499 };
500
Peiyong Linf243e5e2020-08-22 17:40:59 -0700501 struct TransactionState {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000502 TransactionState(const FrameTimelineInfo& frameTimelineInfo,
503 const Vector<ComposerState>& composerStates,
Peiyong Linf243e5e2020-08-22 17:40:59 -0700504 const Vector<DisplayState>& displayStates, uint32_t transactionFlags,
Arthur Hung58144272021-01-16 03:43:53 +0000505 const sp<IBinder>& applyToken,
506 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
507 bool isAutoTimestamp, const client_cache_t& uncacheBuffer,
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800508 int64_t postTime, uint32_t permissions, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000509 std::vector<ListenerCallbacks> listenerCallbacks, int originPid,
510 int originUid, uint64_t transactionId)
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000511 : frameTimelineInfo(frameTimelineInfo),
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700512 states(composerStates),
Peiyong Linf243e5e2020-08-22 17:40:59 -0700513 displays(displayStates),
514 flags(transactionFlags),
Arthur Hung58144272021-01-16 03:43:53 +0000515 applyToken(applyToken),
516 inputWindowCommands(inputWindowCommands),
Peiyong Linf243e5e2020-08-22 17:40:59 -0700517 desiredPresentTime(desiredPresentTime),
Ady Abrahamf0c56492020-12-17 18:04:15 -0800518 isAutoTimestamp(isAutoTimestamp),
Peiyong Linf243e5e2020-08-22 17:40:59 -0700519 buffer(uncacheBuffer),
520 postTime(postTime),
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800521 permissions(permissions),
Peiyong Linf243e5e2020-08-22 17:40:59 -0700522 hasListenerCallbacks(hasListenerCallbacks),
523 listenerCallbacks(listenerCallbacks),
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000524 originPid(originPid),
525 originUid(originUid),
526 id(transactionId) {}
Peiyong Linf243e5e2020-08-22 17:40:59 -0700527
Vishnu Nair83df0342021-03-30 11:50:44 -0700528 void traverseStatesWithBuffers(std::function<void(const layer_state_t&)> visitor);
529
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000530 FrameTimelineInfo frameTimelineInfo;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700531 Vector<ComposerState> states;
532 Vector<DisplayState> displays;
533 uint32_t flags;
Arthur Hung58144272021-01-16 03:43:53 +0000534 sp<IBinder> applyToken;
535 InputWindowCommands inputWindowCommands;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700536 const int64_t desiredPresentTime;
Ady Abrahamf0c56492020-12-17 18:04:15 -0800537 const bool isAutoTimestamp;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700538 client_cache_t buffer;
539 const int64_t postTime;
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800540 uint32_t permissions;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700541 bool hasListenerCallbacks;
542 std::vector<ListenerCallbacks> listenerCallbacks;
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000543 int originPid;
544 int originUid;
545 uint64_t id;
arthurhungf1b7c7b2021-03-03 17:42:23 +0800546 std::shared_ptr<CountDownLatch> transactionCommittedSignal;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700547 };
548
549 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
550 static Dumper dumper(F&& dump) {
551 using namespace std::placeholders;
552 return std::bind(std::forward<F>(dump), _3);
553 }
554
555 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
556 Dumper dumper(F dump) {
557 using namespace std::placeholders;
558 return std::bind(dump, this, _3);
559 }
560
561 template <typename F>
562 Dumper argsDumper(F dump) {
563 using namespace std::placeholders;
564 return std::bind(dump, this, _1, _3);
565 }
566
567 template <typename F>
568 Dumper protoDumper(F dump) {
569 using namespace std::placeholders;
570 return std::bind(dump, this, _1, _2, _3);
571 }
572
573 template <typename... Args,
574 typename Handler = VsyncModulator::VsyncConfigOpt (VsyncModulator::*)(Args...)>
575 void modulateVsync(Handler handler, Args... args) {
576 if (const auto config = (*mVsyncModulator.*handler)(args...)) {
Ady Abraham55fa7272020-09-30 19:19:27 -0700577 const auto vsyncPeriod = mRefreshRateConfigs->getCurrentRefreshRate().getVsyncPeriod();
578 setVsyncConfig(*config, vsyncPeriod);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700579 }
580 }
581
582 static const int MAX_TRACING_MEMORY = 100 * 1024 * 1024; // 100MB
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700583 // Maximum allowed number of display frames that can be set through backdoor
584 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700585
586 // Implements IBinder.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800587 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
588 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Steven Thomasd4071902020-03-24 16:02:53 -0700589 bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
590 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800591
Peiyong Linf243e5e2020-08-22 17:40:59 -0700592 // Implements ISurfaceComposer
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800593 sp<ISurfaceComposerClient> createConnection() override;
594 sp<IBinder> createDisplay(const String8& displayName, bool secure) override;
595 void destroyDisplay(const sp<IBinder>& displayToken) override;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800596 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override;
597 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000598 status_t setTransactionState(const FrameTimelineInfo& frameTimelineInfo,
599 const Vector<ComposerState>& state,
chaviw308ddba2020-08-11 16:23:51 -0700600 const Vector<DisplayState>& displays, uint32_t flags,
601 const sp<IBinder>& applyToken,
602 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800603 int64_t desiredPresentTime, bool isAutoTimestamp,
604 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000605 const std::vector<ListenerCallbacks>& listenerCallbacks,
606 uint64_t transactionId) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800607 void bootFinished() override;
608 bool authenticateSurfaceTexture(
609 const sp<IGraphicBufferProducer>& bufferProducer) const override;
610 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override;
611 sp<IDisplayEventConnection> createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700612 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp,
Ady Abraham62f216c2020-10-13 19:07:23 -0700613 ISurfaceComposer::EventRegistrationFlags eventRegistration = {}) override;
Dominik Laskowskif1833852021-03-23 15:06:50 -0700614
615 status_t captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&) override;
616 status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&) override;
617 status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&) override;
Robert Carr108b2c72019-04-02 16:32:58 -0700618
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800619 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100620 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
621 EXCLUDES(mStateLock) override;
622 status_t getStaticDisplayInfo(const sp<IBinder>& displayToken, ui::StaticDisplayInfo*)
623 EXCLUDES(mStateLock) override;
624 status_t getDynamicDisplayInfo(const sp<IBinder>& displayToken, ui::DynamicDisplayInfo*)
625 EXCLUDES(mStateLock) override;
Daniel Solomon42d04562019-01-20 21:03:19 -0800626 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800627 ui::DisplayPrimaries&) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800628 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode) override;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100629 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) override;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100630 void setGameContentType(const sp<IBinder>& displayToken, bool on) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800631 void setPowerMode(const sp<IBinder>& displayToken, int mode) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800632 status_t clearAnimationFrameStats() override;
633 status_t getAnimationFrameStats(FrameStats* outStats) const override;
Kriti Dang49ad4132021-01-08 11:49:56 +0100634 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
635 const std::vector<ui::Hdr>& hdrTypes) override;
Tej Singhe2751772021-04-06 22:05:29 -0700636 status_t onPullAtom(const int32_t atomId, std::string* pulledData, bool* success) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800637 status_t enableVSyncInjections(bool enable) override;
638 status_t injectVSync(nsecs_t when) override;
Vishnu Nair43bccf82020-06-05 10:53:37 -0700639 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800640 status_t getColorManagement(bool* outGetColorManagement) const override;
Peiyong Linc6780972018-10-28 15:24:08 -0700641 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
642 ui::Dataspace* outWideColorGamutDataspace,
643 ui::PixelFormat* outWideColorGamutPixelFormat) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700644 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800645 ui::PixelFormat* outFormat,
646 ui::Dataspace* outDataspace,
647 uint8_t* outComponentMask) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700648 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
649 uint8_t componentMask, uint64_t maxFrames) override;
650 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800651 uint64_t timestamp,
652 DisplayedFrameStats* outStats) const override;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800653 status_t getProtectedContentSupport(bool* outSupported) const override;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800654 status_t isWideColorDisplay(const sp<IBinder>& displayToken,
655 bool* outIsWideColorDisplay) const override;
Dan Stoza84ab9372018-12-17 15:27:57 -0800656 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
657 const sp<IRegionSamplingListener>& listener) override;
658 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override;
Alec Mouria9a68a62021-03-04 19:14:50 -0800659 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800660 status_t removeFpsListener(const sp<gui::IFpsListener>& listener) override;
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100661 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
662 ui::DisplayModeId displayModeId, bool allowGroupSwitching,
663 float primaryRefreshRateMin, float primaryRefreshRateMax,
664 float appRequestRefreshRateMin,
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100665 float appRequestRefreshRateMax) override;
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100666 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
667 ui::DisplayModeId* outDefaultMode,
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100668 bool* outAllowGroupSwitching,
669 float* outPrimaryRefreshRateMin,
670 float* outPrimaryRefreshRateMax,
671 float* outAppRequestRefreshRateMin,
672 float* outAppRequestRefreshRateMax) override;
Dan Gittik57e63c52019-01-18 16:37:54 +0000673 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
674 bool* outSupport) const override;
John Reck22be6962021-03-10 12:59:54 -0500675 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
676 const gui::DisplayBrightness& brightness) override;
John Reck88270902021-03-18 11:27:35 -0400677 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
678 const sp<gui::IHdrLayerInfoListener>& listener) override;
679 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
680 const sp<gui::IHdrLayerInfoListener>& listener) override;
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100681 status_t notifyPowerBoost(int32_t boostId) override;
Vishnu Nairb13bb952019-11-15 10:24:08 -0800682 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
683 float lightPosY, float lightPosZ, float lightRadius) override;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800684 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Marin Shalamanovc5986772021-03-16 16:09:49 +0100685 int8_t compatibility, int8_t changeFrameRateStrategy) override;
Steven Thomasd4071902020-03-24 16:02:53 -0700686 status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) override;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700687
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000688 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
689 const FrameTimelineInfo& frameTimelineInfo) override;
Ady Abraham74e17562020-08-24 18:18:19 -0700690
Pablo Gamito6ee484d2020-07-30 14:26:28 +0000691 status_t addTransactionTraceListener(
692 const sp<gui::ITransactionTraceListener>& listener) override;
693
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800694 int getGPUContextPriority() override;
695
Ady Abraham564f9de2021-02-03 18:34:33 -0800696 status_t getExtraBufferCount(int* extraBuffers) const override;
697
Peiyong Linf243e5e2020-08-22 17:40:59 -0700698 // Implements IBinder::DeathRecipient.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800699 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800700
Peiyong Linf243e5e2020-08-22 17:40:59 -0700701 // Implements RefBase.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800702 void onFirstRef() override;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800703
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700704 // HWC2::ComposerCallback overrides:
705 void onComposerHalVsync(hal::HWDisplayId, int64_t timestamp,
706 std::optional<hal::VsyncPeriodNanos>) override;
707 void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) override;
708 void onComposerHalRefresh(hal::HWDisplayId) override;
709 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
710 const hal::VsyncPeriodChangeTimeline&) override;
711 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700712
Peiyong Linf243e5e2020-08-22 17:40:59 -0700713 /*
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800714 * ISchedulerCallback
Ady Abraham2139f732019-11-13 18:56:40 -0800715 */
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700716
717 // Toggles hardware VSYNC by calling into HWC.
718 void setVsyncEnabled(bool) override;
719 // Initiates a refresh rate change to be applied on invalidate.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100720 void changeRefreshRate(const Scheduler::RefreshRate&, Scheduler::ModeEvent) override;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700721 // Forces full composition on all displays without resetting the scheduler idle timer.
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800722 void repaintEverythingForHWC() override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800723 // Called when kernel idle timer has expired. Used to update the refresh rate overlay.
724 void kernelTimerChanged(bool expired) override;
Ady Abraham62a0be22020-12-08 16:54:10 -0800725 // Called when the frame rate override list changed to trigger an event.
726 void triggerOnFrameRateOverridesChanged() override;
Ana Krulecb9afd792020-06-11 13:16:15 -0700727 // Toggles the kernel idle timer on or off depending the policy decisions around refresh rates.
728 void toggleKernelIdleTimer();
729 // Keeps track of whether the kernel idle timer is currently enabled, so we don't have to
730 // make calls to sys prop each time.
731 bool mKernelIdleTimerEnabled = false;
732 // Keeps track of whether the kernel timer is supported on the SF side.
733 bool mSupportKernelIdleTimer = false;
Ady Abraham29d0da32020-07-16 18:39:33 -0700734 // Show spinner with refresh rate overlay
735 bool mRefreshRateOverlaySpinner = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700736
Peiyong Linf243e5e2020-08-22 17:40:59 -0700737 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700738 * Message handling
739 */
Steven Thomas6d8110b2017-08-31 18:24:21 -0700740 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700741 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700742 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700743 void signalLayerUpdate();
744 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800745
Marin Shalamanov5801c942020-12-17 17:00:13 +0100746 // Called on the main thread in response to initializeDisplays()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800747 void onInitializeDisplays() REQUIRES(mStateLock);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100748 // Sets the desired active mode bit. It obtains the lock, and sets mDesiredActiveMode.
749 void setDesiredActiveMode(const ActiveModeInfo& info) REQUIRES(mStateLock);
750 status_t setActiveMode(const sp<IBinder>& displayToken, int id);
751 // Once HWC has returned the present fence, this sets the active mode and a new refresh
Ady Abraham53852a52019-05-28 18:07:44 -0700752 // rate in SF.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100753 void setActiveModeInternal() REQUIRES(mStateLock);
754 // Calls to setActiveMode on the main thread if there is a pending mode change
Ady Abraham27cbed72020-04-10 12:56:59 -0700755 // that needs to be applied.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100756 void performSetActiveMode() REQUIRES(mStateLock);
757 void clearDesiredActiveModeState() REQUIRES(mStateLock) EXCLUDES(mActiveModeLock);
758 // Called when active mode is no longer is progress
759 void desiredActiveModeChangeDone() REQUIRES(mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100760 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700761 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
762 REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800763
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100764 // Sets the desired display mode specs.
765 status_t setDesiredDisplayModeSpecsInternal(
Steven Thomasd4071902020-03-24 16:02:53 -0700766 const sp<DisplayDevice>& display,
767 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy)
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100768 EXCLUDES(mStateLock);
Ady Abraham838de062019-02-04 10:24:03 -0800769
Dan Stoza28d46a52020-04-28 09:54:54 -0700770 // Handle the INVALIDATE message queue event, latching new buffers and applying
771 // incoming transactions
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700772 void onMessageInvalidate(int64_t vsyncId, nsecs_t expectedVSyncTime);
Dan Stoza28d46a52020-04-28 09:54:54 -0700773
Dan Stoza6b9454d2014-11-07 16:00:59 -0800774 // Returns whether the transaction actually modified any state
775 bool handleMessageTransaction();
776
Dan Stoza28d46a52020-04-28 09:54:54 -0700777 // Handle the REFRESH message queue event, sending the current frame down to RenderEngine and
778 // the Composer HAL for presentation
779 void onMessageRefresh();
780
Dan Stoza6b9454d2014-11-07 16:00:59 -0800781 // Returns whether a new buffer has been latched (see handlePageFlip())
782 bool handleMessageInvalidate();
783
Mathias Agopian87baae12012-07-31 12:38:26 -0700784 void handleTransaction(uint32_t transactionFlags);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800785 void handleTransactionLocked(uint32_t transactionFlags) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800786
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800787 void updateInputFlinger();
788 void updateInputWindowInfo();
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800789 void commitInputWindowCommands() REQUIRES(mStateLock);
Riley Andrews03414a12014-07-01 14:22:59 -0700790 void updateCursorAsync();
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700791
Marin Shalamanova903d032020-12-29 20:35:13 +0100792 void initScheduler(const DisplayDeviceState&) REQUIRES(mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100793 void updatePhaseConfiguration(const Fps&) REQUIRES(mStateLock);
Ady Abraham55fa7272020-09-30 19:19:27 -0700794 void setVsyncConfig(const VsyncModulator::VsyncConfig&, nsecs_t vsyncPeriod);
Riley Andrews03414a12014-07-01 14:22:59 -0700795
Dan Stoza6b9454d2014-11-07 16:00:59 -0800796 /* handlePageFlip - latch a new buffer if available and compute the dirty
797 * region. Returns whether a new buffer has been latched, i.e., whether it
798 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700799 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800800 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800801
Peiyong Linf243e5e2020-08-22 17:40:59 -0700802 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700803 * Transactions
804 */
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000805 void applyTransactionState(const FrameTimelineInfo& info, const Vector<ComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800806 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -0800807 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800808 const int64_t desiredPresentTime, bool isAutoTimestamp,
Valerie Hau9dab9732019-08-20 09:29:25 -0700809 const client_cache_t& uncacheBuffer, const int64_t postTime,
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800810 uint32_t permissions, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700811 const std::vector<ListenerCallbacks>& listenerCallbacks,
Arthur Hung58144272021-01-16 03:43:53 +0000812 int originPid, int originUid, uint64_t transactionId)
813 REQUIRES(mStateLock);
814 // flush pending transaction that was presented after desiredPresentTime.
815 void flushTransactionQueues();
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700816 // Returns true if there is at least one transaction that needs to be flushed
817 bool transactionFlushNeeded();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700818 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800819 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700820 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700821 uint32_t setTransactionFlags(uint32_t flags);
Valerie Haud50e7412020-06-16 17:58:14 -0700822 // Indicate SF should call doTraversal on layers, but don't trigger a wakeup! We use this cases
823 // where there are still pending transactions but we know they won't be ready until a frame
Robert Carr4b874132020-05-29 12:02:51 -0700824 // arrives from a different layer. So we need to ensure we performTransaction from invalidate
825 // but there is no need to try and wake up immediately to do it. Rather we rely on
Valerie Haud50e7412020-06-16 17:58:14 -0700826 // onFrameAvailable or another layer update to wake us up.
827 void setTraversalNeeded();
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700828 uint32_t setTransactionFlags(uint32_t flags, TransactionSchedule);
Nataniel Borges2b796da2019-02-15 13:32:18 -0800829 void commitTransaction() REQUIRES(mStateLock);
chaviw74d90ad2019-04-26 14:45:26 -0700830 void commitOffscreenLayers();
Vishnu Nair12f62a02021-02-03 16:23:16 -0800831 bool transactionIsReadyToBeApplied(
Ady Abraham43752eb2021-03-04 16:24:25 -0800832 const FrameTimelineInfo& info, bool isAutoTimestamp, int64_t desiredPresentTime,
Ady Abraham5690bda2021-03-12 15:01:18 -0800833 uid_t originUid, const Vector<ComposerState>& states,
Vishnu Nair83df0342021-03-30 11:50:44 -0700834 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>&
835 bufferLayersReadyToPresent) const REQUIRES(mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800836 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800837 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
838 REQUIRES(mStateLock);
Ady Abraham8db10102021-03-15 17:19:23 -0700839 bool frameIsEarly(nsecs_t expectedPresentTime, int64_t vsyncId) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700840 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700841 * Layer management
842 */
Marissa Wall2d814fb2019-04-09 18:52:57 +0000843 status_t createLayer(const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
844 PixelFormat format, uint32_t flags, LayerMetadata metadata,
Robert Carrc0df3122019-04-11 13:18:21 -0700845 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
Ady Abraham9f0a4002020-10-05 15:47:26 -0700846 const sp<IBinder>& parentHandle, int32_t* outLayerId,
847 const sp<Layer>& parentLayer = nullptr,
848 uint32_t* outTransformHint = nullptr);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800849
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700850 status_t createBufferQueueLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800851 uint32_t h, uint32_t flags, LayerMetadata metadata,
852 PixelFormat& format, sp<IBinder>* outHandle,
853 sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800854
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700855 status_t createBufferStateLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800856 uint32_t h, uint32_t flags, LayerMetadata metadata,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700857 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700858
Vishnu Nairfa247b12020-02-11 08:58:26 -0800859 status_t createEffectLayer(const sp<Client>& client, std::string name, uint32_t w, uint32_t h,
860 uint32_t flags, LayerMetadata metadata, sp<IBinder>* outHandle,
861 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700862
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700863 status_t createContainerLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800864 uint32_t h, uint32_t flags, LayerMetadata metadata,
865 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Robert Carr6b3f6c52018-08-13 13:05:17 -0700866
chaviwfe94a222019-08-21 13:52:59 -0700867 status_t mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
Ady Abraham9f0a4002020-10-05 15:47:26 -0700868 sp<IBinder>* outHandle, int32_t* outLayerId);
chaviwfe94a222019-08-21 13:52:59 -0700869
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700870 std::string getUniqueLayerName(const char* name);
Cody Northropbc755282017-03-31 12:00:08 -0600871
Rob Carr4bba3702018-10-08 21:53:30 +0000872 // called when all clients have released all their references to
873 // this layer meaning it is entirely safe to destroy all
874 // resources associated to this layer.
Robert Carr695d5282018-12-18 15:27:58 -0800875 void onHandleDestroyed(sp<Layer>& layer);
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800876 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700877
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700878 // add a layer to SurfaceFlinger
Robert Carrc0df3122019-04-11 13:18:21 -0700879 status_t addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
880 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
881 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700882 bool addToCurrentState, uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700883
Vishnu Nair4351ad52019-02-11 14:13:02 -0800884 // Traverse through all the layers and compute and cache its bounds.
885 void computeLayerBounds();
886
Peiyong Linf243e5e2020-08-22 17:40:59 -0700887 // Boot animation, on/off animations and screen capture
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700888 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700889
Peiyong Lin05cc0112020-10-14 16:16:37 -0700890 status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, ui::Size bufferSize,
chaviw17ac24b2021-01-28 18:50:05 -0800891 ui::PixelFormat, bool allowProtected, bool grayscale,
Peiyong Lin05cc0112020-10-14 16:16:37 -0700892 const sp<IScreenCaptureListener>&);
Alec Mouria90a5702021-04-16 16:36:21 +0000893 status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction,
894 const std::shared_ptr<renderengine::ExternalTexture>&,
chaviw17ac24b2021-01-28 18:50:05 -0800895 bool regionSampling, bool grayscale,
896 const sp<IScreenCaptureListener>&);
chaviw03900772020-08-18 12:34:51 -0700897 status_t renderScreenImplLocked(const RenderArea&, TraverseLayersFunction,
Alec Mouria90a5702021-04-16 16:36:21 +0000898 const std::shared_ptr<renderengine::ExternalTexture>&,
chaviwf5bb97b2021-04-28 15:35:37 -0500899 bool canCaptureBlackoutContent, bool regionSampling,
900 bool grayscale, ScreenCaptureResults&);
chaviw03900772020-08-18 12:34:51 -0700901
chaviw4b9d5e12020-08-04 18:30:35 -0700902 // If the uid provided is not UNSET_UID, the traverse will skip any layers that don't have a
903 // matching ownerUid
904 void traverseLayersInLayerStack(ui::LayerStack, const int32_t uid, const LayerVector::Visitor&);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700905
Romain Guy11d63f42017-07-20 12:47:14 -0700906 void readPersistentProperties();
907
Mathias Agopian875d8e12013-06-07 15:35:48 -0700908 size_t getMaxTextureSize() const;
909 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700910
Peiyong Linf243e5e2020-08-22 17:40:59 -0700911 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700912 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700913 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700914 // called when starting, or restarting after system_server death
915 void initializeDisplays();
916
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700917 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
918 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700919 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700920 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700921
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700922 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700923 const auto it = mDisplays.find(displayToken);
924 return it == mDisplays.end() ? nullptr : it->second;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700925 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700926
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700927 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700928 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700929 }
930
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700931 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800932 if (const auto token = getInternalDisplayTokenLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700933 return getDisplayDeviceLocked(token);
934 }
935 return nullptr;
Michael Wright28f24d02016-07-12 13:30:53 -0700936 }
937
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700938 sp<const DisplayDevice> getDefaultDisplayDevice() EXCLUDES(mStateLock) {
939 Mutex::Autolock lock(mStateLock);
940 return getDefaultDisplayDeviceLocked();
941 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200942
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700943 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
944 template <typename Predicate>
945 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
946 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
947 [&](const auto& pair) { return p(*pair.second); });
948
949 return it == mDisplays.end() ? nullptr : it->second;
950 }
951
952 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
953 // TODO(b/182939859): Replace tokens with IDs for display lookup.
954 return findDisplay([id](const auto& display) { return display.getId() == id; });
955 }
956
Mathias Agopian87baae12012-07-31 12:38:26 -0700957 // mark a region of a layer stack dirty. this updates the dirty
958 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700959 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700960
Peiyong Linf243e5e2020-08-22 17:40:59 -0700961 /*
Mathias Agopian86303202012-07-24 22:46:10 -0700962 * H/W composer
963 */
Marin Shalamanov6e840172020-12-14 22:13:28 +0100964 // The following thread safety rules apply when accessing HWComposer:
965 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
966 // acquire mStateLock.
967 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -0700968 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +0100969 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -0700970 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700971
Peiyong Linf243e5e2020-08-22 17:40:59 -0700972 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700973 * Compositing
974 */
975 void invalidateHwcGeometry();
Mathias Agopiancd60f992012-08-16 16:28:27 -0700976
David Sodman2b406362017-12-15 13:33:47 -0800977 void postComposition();
Dominik Laskowskif654d572018-12-20 11:03:06 -0800978 void getCompositorTiming(CompositorTiming* compositorTiming);
Ana Krulece588e312018-09-18 12:32:24 -0700979 void updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
980 std::shared_ptr<FenceTime>& presentFenceTime);
981 void setCompositorTimingSnapped(const DisplayStatInfo& stats,
982 nsecs_t compositeToPresentLatency);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600983
David Sodmanfa9b2af2017-12-24 13:28:59 -0800984 void postFrame();
Mathias Agopian4da75192010-08-10 17:19:56 -0700985
Peiyong Linf243e5e2020-08-22 17:40:59 -0700986 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -0700987 * Display management
988 */
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +0100989 void loadDisplayModes(PhysicalDisplayId displayId, DisplayModes& outModes,
990 DisplayModePtr& outActiveMode) const REQUIRES(mStateLock);
Lloyd Pique542307f2018-10-19 13:24:08 -0700991 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -0700992 const wp<IBinder>& displayToken,
993 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -0700994 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +0100995 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700996 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowski20134642020-04-20 22:36:44 -0700997 void processDisplayChangesLocked() REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700998 void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
999 REQUIRES(mStateLock);
1000 void processDisplayRemoved(const wp<IBinder>& displayToken) REQUIRES(mStateLock);
Marin Shalamanovae685592020-02-12 17:12:22 +01001001 void processDisplayChanged(const wp<IBinder>& displayToken,
1002 const DisplayDeviceState& currentState,
Dominik Laskowski20134642020-04-20 22:36:44 -07001003 const DisplayDeviceState& drawingState) REQUIRES(mStateLock);
1004 void processDisplayHotplugEventsLocked() REQUIRES(mStateLock);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001005
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001006 void dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08001007
Peiyong Linf243e5e2020-08-22 17:40:59 -07001008 /*
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001009 * VSYNC
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001010 */
Ady Abraham2492a022020-07-24 11:09:55 -07001011 nsecs_t getVsyncPeriodFromHWC() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001012
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001013 // Sets the refresh rate by switching active configs, if they are available for
Ana Krulec7d1d6832018-12-27 11:10:09 -08001014 // the desired refresh rate.
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001015 void changeRefreshRateLocked(const RefreshRate&, Scheduler::ModeEvent) REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -07001016
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001017 bool isDisplayModeAllowed(DisplayModeId) const REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -07001018
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001019 struct FenceWithFenceTime {
1020 sp<Fence> fence = Fence::NO_FENCE;
1021 std::shared_ptr<FenceTime> fenceTime = FenceTime::NO_FENCE;
1022 };
1023
Alec Mouri6d414b52020-03-17 11:18:05 -07001024 // Gets the fence for the previous frame.
1025 // Must be called on the main thread.
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001026 FenceWithFenceTime previousFrameFence();
Alec Mouri6d414b52020-03-17 11:18:05 -07001027
1028 // Whether the previous frame has not yet been presented to the display.
1029 // If graceTimeMs is positive, this method waits for at most the provided
1030 // grace period before reporting if the frame missed.
1031 // Must be called on the main thread.
1032 bool previousFramePending(int graceTimeMs = 0);
1033
1034 // Returns the previous time that the frame was presented. If the frame has
1035 // not been presented yet, then returns Fence::SIGNAL_TIME_PENDING. If there
1036 // is no pending frame, then returns Fence::SIGNAL_TIME_INVALID.
1037 // Must be called on the main thread.
1038 nsecs_t previousFramePresentTime();
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001039
Ady Abraham5facfb12020-04-22 15:18:31 -07001040 // Calculates the expected present time for this frame. For negative offsets, performs a
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001041 // correction using the predicted vsync for the next frame instead.
Ady Abraham56b42a42020-12-28 16:48:48 -08001042 nsecs_t calculateExpectedPresentTime(DisplayStatInfo) const;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001043
Dominik Laskowskic2867142019-01-21 11:33:38 -08001044 /*
1045 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001046 */
Marin Shalamanova524a092020-07-27 21:39:55 +02001047 sp<IBinder> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
1048 REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001049 const auto it = mPhysicalDisplayTokens.find(displayId);
1050 return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
1051 }
1052
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001053 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
1054 const sp<IBinder>& displayToken) const REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001055 for (const auto& [id, token] : mPhysicalDisplayTokens) {
1056 if (token == displayToken) {
1057 return id;
1058 }
1059 }
1060 return {};
1061 }
1062
1063 // TODO(b/74619554): Remove special cases for primary display.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001064 sp<IBinder> getInternalDisplayTokenLocked() const REQUIRES(mStateLock) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001065 const auto displayId = getInternalDisplayIdLocked();
1066 return displayId ? getPhysicalDisplayTokenLocked(*displayId) : nullptr;
Dominik Laskowski075d3172018-05-24 15:50:06 -07001067 }
1068
Marin Shalamanova524a092020-07-27 21:39:55 +02001069 std::optional<PhysicalDisplayId> getInternalDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001070 const auto hwcDisplayId = getHwComposer().getInternalHwcDisplayId();
1071 return hwcDisplayId ? getHwComposer().toPhysicalDisplayId(*hwcDisplayId) : std::nullopt;
1072 }
1073
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001074 // Toggles use of HAL/GPU virtual displays.
1075 void enableHalVirtualDisplays(bool);
1076
1077 // Virtual display lifecycle for ID generation and HAL allocation.
1078 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat, ui::LayerStack)
1079 REQUIRES(mStateLock);
1080 void releaseVirtualDisplay(VirtualDisplayId);
1081
Dominik Laskowskic2867142019-01-21 11:33:38 -08001082 /*
1083 * Debugging & dumpsys
1084 */
Dominik Laskowskic2867142019-01-21 11:33:38 -08001085 void dumpAllLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
1086
1087 void appendSfConfigString(std::string& result) const;
1088 void listLayersLocked(std::string& result) const;
1089 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
1090 void clearStatsLocked(const DumpArgs& args, std::string& result);
1091 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001092 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Jamie Gennis6547ff42013-07-16 20:12:42 -07001093 void logFrameStats();
1094
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08001095 void dumpVSync(std::string& result) const REQUIRES(mStateLock);
Yiwei Zhang5434a782018-12-05 18:06:32 -08001096 void dumpStaticScreenStats(std::string& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -07001097 // Not const because each Layer needs to query Fences and cache timestamps.
Yiwei Zhang5434a782018-12-05 18:06:32 -08001098 void dumpFrameEventsLocked(std::string& result);
Dan Stozab90cf072015-03-05 11:05:59 -08001099
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001100 void recordBufferingStats(const std::string& layerName,
1101 std::vector<OccupancyTracker::Segment>&& history);
Yiwei Zhang5434a782018-12-05 18:06:32 -08001102 void dumpBufferingStats(std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001103 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001104 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001105 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001106 LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;
Vishnu Nair0f085c62019-08-30 08:49:12 -07001107 void dumpOffscreenLayersProto(LayersProto& layersProto,
1108 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Alec Mouri6b9e9912020-01-21 10:50:24 -08001109 // Dumps state from HW Composer
1110 void dumpHwc(std::string& result) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -07001111 LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)
1112 EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -07001113 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001114 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001115
Dominik Laskowskic2867142019-01-21 11:33:38 -08001116 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1117
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001118 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001119
1120 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1121 return doDump(fd, args, asProto);
1122 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001123
Steven Thomasd4071902020-03-24 16:02:53 -07001124 void onFrameRateFlexibilityTokenReleased();
1125
chaviw17ac24b2021-01-28 18:50:05 -08001126 static mat4 calculateColorMatrix(float saturation);
1127
Chia-I Wu28f320b2018-05-03 11:02:56 -07001128 void updateColorMatrixLocked();
1129
Peiyong Linf243e5e2020-08-22 17:40:59 -07001130 // Verify that transaction is being called by an approved process:
1131 // either AID_GRAPHICS or AID_SYSTEM.
1132 status_t CheckTransactCodeCredentials(uint32_t code);
1133
Ady Abrahame46243a2021-02-23 19:33:49 -08001134 // Add transaction to the Transaction Queue
arthurhungf1b7c7b2021-03-03 17:42:23 +08001135 void queueTransaction(TransactionState& state) EXCLUDES(mQueueLock);
1136 void waitForSynchronousTransaction(const CountDownLatch& transactionCommittedSignal);
Arthur Hung2274a312021-04-28 15:13:06 +00001137 void signalSynchronousTransactions(const uint32_t flag);
Ady Abrahame46243a2021-02-23 19:33:49 -08001138
Peiyong Linf243e5e2020-08-22 17:40:59 -07001139 /*
1140 * Generic Layer Metadata
1141 */
1142 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1143
1144 /*
1145 * Misc
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001146 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001147
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001148 std::optional<ActiveModeInfo> getDesiredActiveMode() EXCLUDES(mActiveModeLock) {
1149 std::lock_guard<std::mutex> lock(mActiveModeLock);
1150 if (mDesiredActiveModeChanged) return mDesiredActiveMode;
Peiyong Linf243e5e2020-08-22 17:40:59 -07001151 return std::nullopt;
1152 }
1153
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001154 std::vector<ui::ColorMode> getDisplayColorModes(PhysicalDisplayId displayId)
1155 REQUIRES(mStateLock);
1156
Ady Abraham564f9de2021-02-03 18:34:33 -08001157 static int calculateExtraBufferCount(Fps maxSupportedRefreshRate,
1158 std::chrono::nanoseconds presentLatency);
1159
Peiyong Linf243e5e2020-08-22 17:40:59 -07001160 sp<StartPropertySetThread> mStartPropertySetThread;
Lloyd Pique90c115d2018-09-18 21:39:42 -07001161 surfaceflinger::Factory& mFactory;
1162
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001163 // access must be protected by mStateLock
1164 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001165 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001166 std::atomic<int32_t> mTransactionFlags = 0;
arthurhungf1b7c7b2021-03-03 17:42:23 +08001167 std::vector<std::shared_ptr<CountDownLatch>> mTransactionCommittedSignals;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001168 bool mAnimTransactionPending = false;
1169 SortedVector<sp<Layer>> mLayersPendingRemoval;
Valerie Haud50e7412020-06-16 17:58:14 -07001170 bool mForceTraversal = false;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001171
Chia-I Wu28f320b2018-05-03 11:02:56 -07001172 // global color transform states
1173 Daltonizer mDaltonizer;
1174 float mGlobalSaturationFactor = 1.0f;
1175 mat4 mClientColorMatrix;
1176
Dan Stoza101d8dc2018-02-27 15:42:25 -08001177 // Can't be unordered_set because wp<> isn't hashable
1178 std::set<wp<IBinder>> mGraphicBufferProducerList;
Ady Abrahamb89ca7d2020-03-04 11:19:37 -08001179 size_t mMaxGraphicBufferProducerListSize = ISurfaceComposer::MAX_LAYERS;
Alec Mouri601393f2020-02-21 13:26:52 -08001180 // If there are more GraphicBufferProducers tracked by SurfaceFlinger than
1181 // this threshold, then begin logging.
1182 size_t mGraphicBufferProducerListSizeLogThreshold =
1183 static_cast<size_t>(0.95 * static_cast<double>(MAX_LAYERS));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001184
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001185 void removeGraphicBufferProducerAsync(const wp<IBinder>&);
1186
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001187 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001188 bool mLayersRemoved = false;
1189 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001190
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001191 std::atomic<bool> mRepaintEverything = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001192
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001193 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001194 const nsecs_t mBootTime = systemTime();
1195 bool mGpuToCpuSupported = false;
Alec Mouri5f487d42020-02-06 09:26:19 -08001196 bool mIsUserBuild = true;
Mathias Agopian3094df32012-06-18 18:06:45 -07001197
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001198 // Can only accessed from the main thread, these members
1199 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001200 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001201 bool mVisibleRegionsDirty = false;
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001202 // Set during transaction commit stage to track if the input info for a layer has changed.
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001203 bool mInputInfoChanged = false;
1204 bool mGeometryInvalid = false;
1205 bool mAnimCompositionPending = false;
Alec Mouri5c9c9602020-09-01 15:10:40 -07001206
1207 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001208 // latched.
1209 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> mLayersWithQueuedFrames;
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001210 // Tracks layers that need to update a display's dirty region.
1211 std::vector<sp<Layer>> mLayersPendingRefresh;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001212 std::array<FenceWithFenceTime, 2> mPreviousPresentFences;
Alec Mouricc0fc602019-02-26 21:45:19 -08001213 // True if in the previous frame at least one layer was composed via the GPU.
Dan Stoza05dacfb2016-07-01 13:33:38 -07001214 bool mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001215 // True if in the previous frame at least one layer was composed via HW Composer.
1216 // Note that it is possible for a frame to be composed via both client and device
1217 // composition, for example in the case of overlays.
1218 bool mHadDeviceComposition = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001219 // True if in the previous frame, the client composition was skipped by reusing the buffer
1220 // used in a previous composition. This can happed if the client composition requests
1221 // did not change.
1222 bool mReusedClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001223
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001224 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001225
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001226 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mStateLock);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001227
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001228 // this may only be written from the main thread with mStateLock held
1229 // it may be read from other threads with mStateLock held
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001230 std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Marin Shalamanova524a092020-07-27 21:39:55 +02001231 std::unordered_map<PhysicalDisplayId, sp<IBinder>> mPhysicalDisplayTokens
1232 GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001233
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001234 struct {
1235 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1236 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1237 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001238
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001239 std::unordered_map<BBinder*, wp<Layer>> mLayersByLocalBinderToken GUARDED_BY(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07001240
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001241 // don't use a lock for these, we don't care
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001242 int mDebugRegion = 0;
1243 bool mDebugDisableHWC = false;
1244 bool mDebugDisableTransformHint = false;
Alec Mouridd8bf2d2021-05-08 16:36:33 -07001245 bool mLayerCachingEnabled = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001246 volatile nsecs_t mDebugInTransaction = 0;
1247 bool mForceFullDamage = false;
Ady Abrahamadb9a992019-09-19 21:21:55 +00001248 bool mPropagateBackpressureClientComposition = false;
Pablo Gamito5cfc6e52020-09-10 11:18:03 +00001249 sp<SurfaceInterceptor> mInterceptor;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001250
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001251 SurfaceTracing mTracing{*this};
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001252 std::mutex mTracingLock;
Nataniel Borges2b796da2019-02-15 13:32:18 -08001253 bool mTracingEnabled = false;
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07001254 bool mTracePostComposition = false;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001255 std::atomic<bool> mTracingEnabledChanged = false;
1256
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001257 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001258 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001259 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001260
Lucas Dupin00f16422020-03-11 11:33:04 -07001261 // If blurs should be enabled on this device.
1262 bool mSupportsBlur = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001263 // Disable blurs, for debugging
Lucas Dupin00f16422020-03-11 11:33:04 -07001264 std::atomic<bool> mDisableBlurs = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001265 // If blurs are considered expensive and should require high GPU frequency.
1266 bool mBlursAreExpensive = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001267 std::atomic<uint32_t> mFrameMissedCount = 0;
1268 std::atomic<uint32_t> mHwcFrameMissedCount = 0;
1269 std::atomic<uint32_t> mGpuFrameMissedCount = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001270
Robert Carr9a803c32021-01-14 16:57:58 -08001271 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001272
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001273 // these are thread safe
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001274 std::unique_ptr<MessageQueue> mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001275 FrameTracker mAnimFrameTracker;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001276
1277 // protected by mDestroyedLayerLock;
1278 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -08001279 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001280
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001281 nsecs_t mRefreshStartTime = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001282
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001283 std::atomic<bool> mRefreshPending = false;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001284
Dan Stoza436ccf32018-06-21 12:10:12 -07001285 // We maintain a pool of pre-generated texture names to hand out to avoid
1286 // layer creation needing to run on the main thread (which it would
1287 // otherwise need to do to access RenderEngine).
1288 std::mutex mTexturePoolMutex;
1289 uint32_t mTexturePoolSize = 0;
1290 std::vector<uint32_t> mTexturePool;
1291
Arthur Hung58144272021-01-16 03:43:53 +00001292 mutable Mutex mQueueLock;
1293 Condition mTransactionQueueCV;
1294 std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash>
1295 mPendingTransactionQueues GUARDED_BY(mQueueLock);
1296 std::queue<TransactionState> mTransactionQueue GUARDED_BY(mQueueLock);
Peiyong Linf243e5e2020-08-22 17:40:59 -07001297 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001298 * Feature prototyping
1299 */
1300
Dan Stozab90cf072015-03-05 11:05:59 -08001301 // Static screen stats
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001302 bool mHasPoweredOff = false;
Dan Stozae77c7662016-05-13 11:37:28 -07001303
chaviweadf0d42019-08-12 13:28:29 -07001304 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001305
Steven Morelanda904bb92019-07-02 17:37:23 -07001306 // to linkToDeath
1307 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001308 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1309 // different threads without a lock and could trigger unsynchronized writes to
1310 // to mWindowManager or mInputFlinger
1311 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001312
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001313 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001314
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001315 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001316
Peiyong Lina3ea5592019-02-10 14:45:00 -08001317 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1318 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1319 // 2. be one of the supported color modes returned by hardware composer, otherwise
1320 // it will not be respected.
1321 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1322 // is not set to 1.
1323 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1324 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1325
Peiyong Lin9d846a52018-11-05 13:18:20 -08001326 ui::Dataspace mDefaultCompositionDataspace;
1327 ui::Dataspace mWideColorGamutCompositionDataspace;
Yichi Chenda901bf2019-06-28 14:58:27 +08001328 ui::Dataspace mColorSpaceAgnosticDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001329
David Sodman105b7dc2017-11-04 20:28:14 -07001330 SurfaceFlingerBE mBE;
Lloyd Pique70d91362018-10-18 16:02:55 -07001331 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Ana Krulec98b5b242018-08-10 15:03:23 -07001332
Dominik Laskowskif06d68e2021-03-24 19:40:03 -07001333 const std::string mHwcServiceName;
1334
1335 bool hasMockHwc() const { return mHwcServiceName == "mock"; }
1336
Peiyong Linf243e5e2020-08-22 17:40:59 -07001337 /*
Ana Krulecb43429d2019-01-09 14:28:51 -08001338 * Scheduler
1339 */
Ana Krulec98b5b242018-08-10 15:03:23 -07001340 std::unique_ptr<Scheduler> mScheduler;
Dominik Laskowski98041832019-08-01 18:35:59 -07001341 scheduler::ConnectionHandle mAppConnectionHandle;
1342 scheduler::ConnectionHandle mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001343
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001344 // Stores phase offsets configured per refresh rate.
Ady Abraham8287e852020-08-12 14:44:58 -07001345 std::unique_ptr<scheduler::VsyncConfiguration> mVsyncConfiguration;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001346
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001347 // Optional to defer construction until PhaseConfiguration is created.
1348 std::optional<scheduler::VsyncModulator> mVsyncModulator;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001349
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001350 std::unique_ptr<scheduler::RefreshRateConfigs> mRefreshRateConfigs;
1351 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Ady Abraham1902d072019-03-01 17:18:59 -08001352
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001353 std::atomic<nsecs_t> mExpectedPresentTime = 0;
Snild Dolkow819636c2021-01-22 14:42:08 +01001354 nsecs_t mScheduledPresentTime = 0;
Marin Shalamanovc75b0772020-06-12 22:29:11 +02001355 hal::Vsync mHWCVsyncPendingState = hal::Vsync::DISABLE;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001356
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001357 std::mutex mActiveModeLock;
1358 // This bit is set once we start setting the mode. We read from this bit during the
1359 // process. If at the end, this bit is different than mDesiredActiveMode, we restart
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001360 // the process.
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001361 ActiveModeInfo mUpcomingActiveMode; // Always read and written on the main thread.
1362 // This bit can be set at any point in time when the system wants the new mode.
1363 ActiveModeInfo mDesiredActiveMode GUARDED_BY(mActiveModeLock);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001364
Ady Abrahamb838aed2019-02-12 15:30:16 -08001365 // below flags are set by main thread only
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001366 TracedOrdinal<bool> mDesiredActiveModeChanged
1367 GUARDED_BY(mActiveModeLock) = {"DesiredActiveModeChanged", false};
1368 bool mSetActiveModePending = false;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001369
Kevin DuBois413287f2019-02-25 08:46:47 -08001370 bool mLumaSampling = true;
1371 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001372 sp<FpsReporter> mFpsReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001373 ui::DisplayPrimaries mInternalDisplayPrimaries;
Kevin DuBois413287f2019-02-25 08:46:47 -08001374
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001375 const float mInternalDisplayDensity;
1376 const float mEmulatedDisplayDensity;
1377
Chris Ye0783e992020-06-02 21:34:49 -07001378 sp<os::IInputFlinger> mInputFlinger;
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001379 // Should only be accessed by the main thread.
chaviw273171b2018-12-26 11:46:30 -08001380 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001381
Chris Ye0783e992020-06-02 21:34:49 -07001382 sp<SetInputWindowsListener> mSetInputWindowsListener;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001383
Peiyong Lin74ca2f42019-01-14 19:36:57 -08001384 Hwc2::impl::PowerAdvisor mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001385
Alec Mouri9519bf12019-11-15 16:54:44 -08001386 // This should only be accessed on the main thread.
1387 nsecs_t mFrameStartTime = 0;
1388
Dominik Laskowski20134642020-04-20 22:36:44 -07001389 void enableRefreshRateOverlay(bool enable);
1390 std::unique_ptr<RefreshRateOverlay> mRefreshRateOverlay GUARDED_BY(mStateLock);
Ady Abraham34392f72019-04-10 11:29:27 -07001391
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001392 // Flag used to set override desired display mode from backdoor
1393 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001394
1395 // A set of layers that have no parent so they are not drawn on screen.
1396 // Should only be accessed by the main thread.
1397 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1398 // be any issues with a raw pointer referencing an invalid object.
1399 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001400
Steven Thomasd4071902020-03-24 16:02:53 -07001401 int mFrameRateFlexibilityTokenCount = 0;
Ady Abraham07e54702020-04-16 15:05:37 -07001402
1403 sp<IBinder> mDebugFrameRateFlexibilityToken;
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001404
1405 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001406
1407 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1408 GUARDED_BY(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001409 mutable Mutex mCreatedLayersLock;
1410 struct LayerCreatedState {
1411 LayerCreatedState(const wp<Layer>& layer, const wp<IBinder>& parent,
1412 const wp<Layer> parentLayer, const wp<IBinder>& producer)
1413 : layer(layer),
1414 initialParent(parent),
1415 initialParentLayer(parentLayer),
1416 initialProducer(producer) {}
1417 wp<Layer> layer;
1418 // Indicates the initial parent of the created layer, only used for creating layer in
1419 // SurfaceFlinger. If nullptr, it may add the created layer into the current root layers.
1420 wp<IBinder> initialParent;
1421 wp<Layer> initialParentLayer;
1422 // Indicates the initial graphic buffer producer of the created layer, only used for
1423 // creating layer in SurfaceFlinger.
1424 wp<IBinder> initialProducer;
1425 };
1426
1427 // A temporay pool that store the created layers and will be added to current state in main
1428 // thread.
1429 std::unordered_map<BBinder*, std::unique_ptr<LayerCreatedState>> mCreatedLayers;
1430 void setLayerCreatedState(const sp<IBinder>& handle, const wp<Layer>& layer,
1431 const wp<IBinder>& parent, const wp<Layer> parentLayer,
1432 const wp<IBinder>& producer);
1433 auto getLayerCreatedState(const sp<IBinder>& handle);
1434 sp<Layer> handleLayerCreatedLocked(const sp<IBinder>& handle, bool privileged)
1435 REQUIRES(mStateLock);
1436
1437 std::atomic<ui::Transform::RotationFlags> mDefaultDisplayTransformHint;
Romain Guy0147a172017-06-01 13:53:56 -07001438};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001439
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001440} // namespace android