blob: c712061983b4f42c19df6061e9c841b565cdff9c [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>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080035#include <layerproto/LayerProtoHeader.h>
36#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080037#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070038#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070039#include <system/graphics.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080040#include <ui/FenceTime.h>
41#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010042#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080043#include <utils/Errors.h>
44#include <utils/KeyedVector.h>
45#include <utils/RefBase.h>
46#include <utils/SortedVector.h>
47#include <utils/Trace.h>
48#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070049
Marissa Wall947d34e2019-03-29 14:03:53 -070050#include "ClientCache.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070051#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080052#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080053#include "DisplayHardware/PowerAdvisor.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020054#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080055#include "Effects/Daltonizer.h"
Marin Shalamanov5801c942020-12-17 17:00:13 +010056#include "Fps.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080057#include "FrameTracker.h"
Robert Carr2047fae2016-11-28 14:09:09 -080058#include "LayerVector.h"
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -070059#include "Scheduler/MessageQueue.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"
Vishnu Nair6b591152021-10-08 11:45:14 -070068#include "TransactionState.h"
Mathias Agopian86303202012-07-24 22:46:10 -070069
Dominik Laskowski83b88212018-12-11 13:34:06 -080070#include <atomic>
71#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080072#include <functional>
Dominik Laskowskidd4ef272020-04-23 14:02:12 -070073#include <future>
Dan Stozae77c7662016-05-13 11:37:28 -070074#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080075#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080076#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -070077#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080078#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070079#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070080#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070081#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -080082#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -070083#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -070084#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080085#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070086
chaviw1d044282017-09-27 12:19:28 -070087using namespace android::surfaceflinger;
88
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080089namespace android {
90
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091class Client;
Lloyd Pique144e1162017-12-20 16:44:52 -080092class EventThread;
rnleea2ecd832021-07-29 13:58:30 -070093class FlagManager;
Alec Mouriadebf5c2021-01-05 12:57:36 -080094class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +020095class TunnelModeEnabledReporter;
John Reck88270902021-03-18 11:27:35 -040096class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070097class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -080098class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -080099class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700100class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700101class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700102class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200103class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800104class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700105class FrameTracer;
chaviw60c9d3e2021-06-04 12:52:17 -0500106class WindowInfosListenerInvoker;
Lloyd Pique144e1162017-12-20 16:44:52 -0800107
chaviw0ef7caa2021-01-05 11:04:50 -0800108using gui::ScreenCaptureResults;
109
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700110namespace frametimeline {
111class FrameTimeline;
112}
113
Chris Ye0783e992020-06-02 21:34:49 -0700114namespace os {
115 class IInputFlinger;
116}
117
Lloyd Pique542307f2018-10-19 13:24:08 -0700118namespace compositionengine {
119class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800120class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800121
122struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700123} // namespace compositionengine
124
Peiyong Lin833074a2018-08-28 11:53:54 -0700125namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800126class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700127} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700128
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800129enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700130 eTransactionNeeded = 0x01,
131 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700132 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700133 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700134 eTransactionFlushNeeded = 0x10,
135 eTransactionMask = 0x1f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800136};
137
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800138using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800139
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700140struct SurfaceFlingerBE {
David Sodman73beded2017-11-15 11:56:06 -0800141 FenceTimeline mGlCompositionDoneTimeline;
142 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800143
David Sodman99974d22017-11-28 12:04:33 -0800144 // protected by mCompositorTimingLock;
145 mutable std::mutex mCompositorTimingLock;
146 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800147
David Sodman99974d22017-11-28 12:04:33 -0800148 // Only accessed from the main thread.
149 struct CompositePresentTime {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700150 nsecs_t composite = -1;
151 std::shared_ptr<FenceTime> display = FenceTime::NO_FENCE;
David Sodman99974d22017-11-28 12:04:33 -0800152 };
153 std::queue<CompositePresentTime> mCompositePresentTimes;
154
David Sodman4a36e932017-11-07 14:29:47 -0800155 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700156 nsecs_t mFrameBuckets[NUM_BUCKETS] = {};
157 nsecs_t mTotalTime = 0;
158 std::atomic<nsecs_t> mLastSwapTime = 0;
chaviw291d88a2019-02-14 10:33:58 -0800159};
David Sodman105b7dc2017-11-04 20:28:14 -0700160
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700161class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700162 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700163 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800164 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700165 private ICompositor,
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800166 private ISchedulerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800167public:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700168 struct SkipInitializationTag {};
169
170 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
171 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
172
173 // set main thread scheduling policy
174 static status_t setSchedFifo(bool enabled) ANDROID_API;
175
Wei Wang23aa5a62021-06-04 15:56:57 -0700176 // set main thread scheduling attributes
177 static status_t setSchedAttr(bool enabled);
178
Peiyong Linf243e5e2020-08-22 17:40:59 -0700179 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800180
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800181 // This is the phase offset in nanoseconds of the software vsync event
182 // relative to the vsync event reported by HWComposer. The software vsync
183 // event is when SurfaceFlinger and Choreographer-based applications run each
184 // frame.
185 //
186 // This phase offset allows adjustment of the minimum latency from application
187 // wake-up time (by Choreographer) to the time at which the resulting window
188 // image is displayed. This value may be either positive (after the HW vsync)
189 // or negative (before the HW vsync). Setting it to 0 will result in a lower
190 // latency bound of two vsync periods because the app and SurfaceFlinger
191 // will run just after the HW vsync. Setting it to a positive number will
192 // result in the minimum latency being:
193 //
194 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
195 //
196 // Note that reducing this latency makes it more likely for the applications
197 // to not have their window content image ready in time. When this happens
198 // the latency will end up being an additional vsync period, and animations
199 // will hiccup. Therefore, this latency should be tuned somewhat
200 // conservatively (or at least with awareness of the trade-off being made).
201 static int64_t vsyncPhaseOffsetNs;
202 static int64_t sfVsyncPhaseOffsetNs;
203
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800204 // If fences from sync Framework are supported.
205 static bool hasSyncFramework;
206
Ady Abraham8cb21882020-08-26 18:22:05 -0700207 // The offset in nanoseconds to use when VsyncController timestamps present fence
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700208 // signaling time.
209 static int64_t dispSyncPresentTimeOffset;
210
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700211 // Some hardware can do RGB->YUV conversion more efficiently in hardware
212 // controlled by HWC than in hardware controlled by the video encoder.
213 // This instruct VirtualDisplaySurface to use HWC for such conversion on
214 // GL composition.
215 static bool useHwcForRgbToYuv;
216
Fabien Sanglard1971b632017-03-10 14:50:03 -0800217 // Controls the number of buffers SurfaceFlinger will allocate for use in
218 // FramebufferSurface
219 static int64_t maxFrameBufferAcquiredBuffers;
220
Brian Lindahla13f2d52020-03-05 11:54:17 +0100221 // Controls the maximum width and height in pixels that the graphics pipeline can support for
222 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
223 static uint32_t maxGraphicsWidth;
224 static uint32_t maxGraphicsHeight;
225
Peiyong Lin13effd12018-07-24 17:01:47 -0700226 // Indicate if a device has wide color gamut display. This is typically
227 // found on devices with wide color gamut (e.g. Display-P3) display.
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600228 static bool hasWideColorDisplay;
229
Dominik Laskowski718f9602019-11-09 20:01:35 -0800230 static ui::Rotation internalDisplayOrientation;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700231
Peiyong Lin13effd12018-07-24 17:01:47 -0700232 // Indicate if device wants color management on its display.
Alec Mouri5f62a602021-09-29 10:52:41 -0700233 static const constexpr bool useColorManagement = true;
Peiyong Lin13effd12018-07-24 17:01:47 -0700234
Peiyong Linb3839ad2018-09-05 15:37:19 -0700235 static bool useContextPriority;
236
Peiyong Lin0256f722018-08-31 15:45:10 -0700237 // The data space and pixel format that SurfaceFlinger expects hardware composer
238 // to composite efficiently. Meaning under most scenarios, hardware composer
239 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700240 static ui::Dataspace defaultCompositionDataspace;
241 static ui::PixelFormat defaultCompositionPixelFormat;
242
243 // The data space and pixel format that SurfaceFlinger expects hardware composer
244 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
245 // hardware composer will accept layers with the data space and pixel format.
246 static ui::Dataspace wideColorGamutCompositionDataspace;
247 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700248
Ana Krulec3803b8d2020-02-03 16:35:46 -0800249 // Whether to use frame rate API when deciding about the refresh rate of the display. This
250 // variable is caches in SF, so that we can check it with each layer creation, and a void the
251 // overhead that is caused by reading from sysprop.
252 static bool useFrameRateApi;
253
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800254 static constexpr SkipInitializationTag SkipInitialization;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800255
John Reckac09e452021-04-07 16:35:37 -0400256 // Whether or not SDR layers should be dimmed to the desired SDR white point instead of
257 // being treated as native display brightness
258 static bool enableSdrDimming;
259
Huihong Luof3441822021-06-16 15:41:07 -0700260 static bool enableLatchUnsignaled;
261
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700262 // must be called before clients can connect
263 void init() ANDROID_API;
264
265 // starts SurfaceFlinger main loop in the current thread
266 void run() ANDROID_API;
267
Peiyong Linf243e5e2020-08-22 17:40:59 -0700268 SurfaceFlingerBE& getBE() { return mBE; }
269 const SurfaceFlingerBE& getBE() const { return mBE; }
270
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700271 // Schedule an asynchronous or synchronous task on the main thread.
272 template <typename F, typename T = std::invoke_result_t<F>>
273 [[nodiscard]] std::future<T> schedule(F&&);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800274
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700275 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700276 void scheduleCommit(FrameHint);
277 // As above, but also force composite regardless if transactions were committed.
278 void scheduleComposite(FrameHint) override;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700279 // As above, but also force dirty geometry to repaint.
280 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700281 // Schedule sampling independently from commit or composite.
282 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800283
Lloyd Pique90c115d2018-09-18 21:39:42 -0700284 surfaceflinger::Factory& getFactory() { return mFactory; }
285
Lloyd Pique70d91362018-10-18 16:02:55 -0700286 // The CompositionEngine encapsulates all composition related interfaces and actions.
287 compositionengine::CompositionEngine& getCompositionEngine() const;
288
Dan Stoza436ccf32018-06-21 12:10:12 -0700289 // Obtains a name from the texture pool, or, if the pool is empty, posts a
290 // synchronous message to the main thread to obtain one on the fly
291 uint32_t getNewTexture();
292
Mathias Agopian86303202012-07-24 22:46:10 -0700293 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700294 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700295
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700296 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700297
Robert Carr0d480722017-01-10 16:42:54 -0800298 bool authenticateSurfaceTextureLocked(
299 const sp<IGraphicBufferProducer>& bufferProducer) const;
300
Dominik Laskowski75848362019-11-11 17:57:20 -0800301 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700302 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700303 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700304
Robert Carr867be372021-06-29 17:36:02 -0700305 void removeHierarchyFromOffscreenLayers(Layer* layer);
Valerie Hauc5686802019-11-22 14:18:09 -0800306 void removeFromOffscreenLayers(Layer* layer);
307
Robert Carr6a0382d2021-07-01 15:57:17 -0700308 // TODO: Remove atomic if move dtor to main thread CL lands
309 std::atomic<uint32_t> mNumClones;
310
Robert Carr9a803c32021-01-14 16:57:58 -0800311 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
312 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700313 }
314
Alec Mouri9a02eda2020-04-21 17:39:34 -0700315 // Converts from a binder handle to a Layer
316 // Returns nullptr if the handle does not point to an existing layer.
317 // Otherwise, returns a weak reference so that callers off the main-thread
318 // won't accidentally hold onto the last strong reference.
Vishnu Nairf9096652021-07-20 18:49:42 -0700319 wp<Layer> fromHandle(const sp<IBinder>& handle) const;
Robert Carrc0df3122019-04-11 13:18:21 -0700320
Vishnu Nair9b079a22020-01-21 14:36:08 -0800321 // If set, disables reusing client composition buffers. This can be set by
322 // debug.sf.disable_client_composition_cache
323 bool mDisableClientCompositionCache = false;
chaviwbf023a62021-06-07 16:00:06 -0500324 void windowInfosReported();
Vishnu Nair9b079a22020-01-21 14:36:08 -0800325
Alec Mouridea1ac52021-06-23 18:12:18 -0700326 // Disables expensive rendering for all displays
327 // This is scheduled on the main thread
328 void disableExpensiveRendering();
329
Peiyong Linf243e5e2020-08-22 17:40:59 -0700330protected:
331 // We're reference counted, never destroy SurfaceFlinger directly
332 virtual ~SurfaceFlinger();
333
Dominik Laskowski263eec42021-07-21 23:13:24 -0700334 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
335 REQUIRES(mStateLock);
336
337 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
338 template <typename Predicate>
339 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
340 return static_cast<bool>(findDisplay(p));
341 }
342
chaviwba4320c2021-09-15 15:20:53 -0500343 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
344 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
345 }
346
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700347private:
David Sodman0c69cad2017-08-21 12:12:51 -0700348 friend class BufferLayer;
Marissa Wallfd668622018-05-10 10:21:13 -0700349 friend class BufferQueueLayer;
Marissa Wall61c58622018-07-18 10:12:20 -0700350 friend class BufferStateLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700351 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800352 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200353 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700354 friend class Layer;
Dan Stozab9b08832014-03-13 11:55:57 -0700355 friend class MonitoredProducer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700356 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800357 friend class RegionSamplingThread;
Nataniel Borges2b796da2019-02-15 13:32:18 -0800358 friend class SurfaceTracing;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800359
Lloyd Piquef58625d2017-12-19 13:22:33 -0800360 // For unit tests
361 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700362 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700363 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800364
Peiyong Linf243e5e2020-08-22 17:40:59 -0700365 using RefreshRate = scheduler::RefreshRateConfigs::RefreshRate;
366 using VsyncModulator = scheduler::VsyncModulator;
367 using TransactionSchedule = scheduler::TransactionSchedule;
368 using TraverseLayersFunction = std::function<void(const LayerVector::Visitor&)>;
369 using RenderAreaFuture = std::future<std::unique_ptr<RenderArea>>;
370 using DumpArgs = Vector<String16>;
371 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
372
Jamie Gennis6547ff42013-07-16 20:12:42 -0700373 // This value is specified in number of frames. Log frame stats at most
374 // every half hour.
375 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
376
Robert Carr2047fae2016-11-28 14:09:09 -0800377 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800378 public:
chaviwfd462612018-05-31 16:11:27 -0700379 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700380 State& operator=(const State& other) {
381 // We explicitly don't copy stateSet so that, e.g., mDrawingState
382 // always uses the Drawing StateSet.
383 layersSortedByZ = other.layersSortedByZ;
384 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700385 colorMatrixChanged = other.colorMatrixChanged;
386 if (colorMatrixChanged) {
387 colorMatrix = other.colorMatrix;
388 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800389 globalShadowSettings = other.globalShadowSettings;
390
Dan Stoza412903f2017-04-27 13:42:17 -0700391 return *this;
392 }
393
394 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700395 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700396 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800397
Chia-I Wu28f320b2018-05-03 11:02:56 -0700398 bool colorMatrixChanged = true;
399 mat4 colorMatrix;
400
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800401 renderengine::ShadowSettings globalShadowSettings;
402
Edgar Arriaga844fa672020-01-16 14:21:42 -0800403 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700404 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
405 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800406 };
407
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800408 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
409 // state before the buffers are latched. The layer owns the atomic counters and decrements the
410 // count in the main thread when dropping or latching a buffer.
411 //
412 // The binder threads increment the same counter when a new transaction containing a buffer is
413 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
414 // This is done to avoid lock contention with the main thread.
415 class BufferCountTracker {
416 public:
417 void increment(BBinder* layerHandle) {
418 std::lock_guard<std::mutex> lock(mLock);
419 auto it = mCounterByLayerHandle.find(layerHandle);
420 if (it != mCounterByLayerHandle.end()) {
421 auto [name, pendingBuffers] = it->second;
422 int32_t count = ++(*pendingBuffers);
423 ATRACE_INT(name.c_str(), count);
424 } else {
425 ALOGW("Handle not found! %p", layerHandle);
426 }
427 }
428
429 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
430 std::lock_guard<std::mutex> lock(mLock);
431 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
432 }
433
434 void remove(BBinder* layerHandle) {
435 std::lock_guard<std::mutex> lock(mLock);
436 mCounterByLayerHandle.erase(layerHandle);
437 }
438
439 private:
440 std::mutex mLock;
441 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
442 mCounterByLayerHandle GUARDED_BY(mLock);
443 };
444
Ady Abraham690f4612021-07-01 23:24:03 -0700445 using ActiveModeInfo = DisplayDevice::ActiveModeInfo;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700446
447 enum class BootStage {
448 BOOTLOADER,
449 BOOTANIMATION,
450 FINISHED,
451 };
452
453 struct HotplugEvent {
454 hal::HWDisplayId hwcDisplayId;
455 hal::Connection connection = hal::Connection::INVALID;
456 };
457
Peiyong Linf243e5e2020-08-22 17:40:59 -0700458 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
459 static Dumper dumper(F&& dump) {
460 using namespace std::placeholders;
461 return std::bind(std::forward<F>(dump), _3);
462 }
463
464 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
465 Dumper dumper(F dump) {
466 using namespace std::placeholders;
467 return std::bind(dump, this, _3);
468 }
469
470 template <typename F>
471 Dumper argsDumper(F dump) {
472 using namespace std::placeholders;
473 return std::bind(dump, this, _1, _3);
474 }
475
476 template <typename F>
477 Dumper protoDumper(F dump) {
478 using namespace std::placeholders;
479 return std::bind(dump, this, _1, _2, _3);
480 }
481
482 template <typename... Args,
483 typename Handler = VsyncModulator::VsyncConfigOpt (VsyncModulator::*)(Args...)>
484 void modulateVsync(Handler handler, Args... args) {
485 if (const auto config = (*mVsyncModulator.*handler)(args...)) {
Ady Abraham3efa3942021-06-24 19:01:25 -0700486 const auto vsyncPeriod = mScheduler->getVsyncPeriodFromRefreshRateConfigs();
Ady Abraham55fa7272020-09-30 19:19:27 -0700487 setVsyncConfig(*config, vsyncPeriod);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700488 }
489 }
490
491 static const int MAX_TRACING_MEMORY = 100 * 1024 * 1024; // 100MB
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700492 // Maximum allowed number of display frames that can be set through backdoor
493 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700494
495 // Implements IBinder.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800496 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
497 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Steven Thomasd4071902020-03-24 16:02:53 -0700498 bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
499 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800500
Peiyong Linf243e5e2020-08-22 17:40:59 -0700501 // Implements ISurfaceComposer
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800502 sp<ISurfaceComposerClient> createConnection() override;
503 sp<IBinder> createDisplay(const String8& displayName, bool secure) override;
504 void destroyDisplay(const sp<IBinder>& displayToken) override;
Ady Abrahamed3290f2021-05-17 15:12:14 -0700505 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override EXCLUDES(mStateLock) {
506 Mutex::Autolock lock(mStateLock);
507 return getPhysicalDisplayIdsLocked();
508 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700509 status_t getPrimaryPhysicalDisplayId(PhysicalDisplayId*) const override EXCLUDES(mStateLock);
510
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800511 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000512 status_t setTransactionState(const FrameTimelineInfo& frameTimelineInfo,
513 const Vector<ComposerState>& state,
chaviw308ddba2020-08-11 16:23:51 -0700514 const Vector<DisplayState>& displays, uint32_t flags,
515 const sp<IBinder>& applyToken,
516 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800517 int64_t desiredPresentTime, bool isAutoTimestamp,
518 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000519 const std::vector<ListenerCallbacks>& listenerCallbacks,
520 uint64_t transactionId) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800521 void bootFinished() override;
522 bool authenticateSurfaceTexture(
523 const sp<IGraphicBufferProducer>& bufferProducer) const override;
524 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override;
525 sp<IDisplayEventConnection> createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700526 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp,
Ady Abraham62f216c2020-10-13 19:07:23 -0700527 ISurfaceComposer::EventRegistrationFlags eventRegistration = {}) override;
Dominik Laskowskif1833852021-03-23 15:06:50 -0700528
529 status_t captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&) override;
530 status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&) override;
531 status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&) override;
Robert Carr108b2c72019-04-02 16:32:58 -0700532
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800533 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100534 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
535 EXCLUDES(mStateLock) override;
536 status_t getStaticDisplayInfo(const sp<IBinder>& displayToken, ui::StaticDisplayInfo*)
537 EXCLUDES(mStateLock) override;
538 status_t getDynamicDisplayInfo(const sp<IBinder>& displayToken, ui::DynamicDisplayInfo*)
539 EXCLUDES(mStateLock) override;
Daniel Solomon42d04562019-01-20 21:03:19 -0800540 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800541 ui::DisplayPrimaries&) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800542 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode) override;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100543 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) override;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100544 void setGameContentType(const sp<IBinder>& displayToken, bool on) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800545 void setPowerMode(const sp<IBinder>& displayToken, int mode) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800546 status_t clearAnimationFrameStats() override;
547 status_t getAnimationFrameStats(FrameStats* outStats) const override;
Kriti Dang49ad4132021-01-08 11:49:56 +0100548 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
549 const std::vector<ui::Hdr>& hdrTypes) override;
Tej Singhe2751772021-04-06 22:05:29 -0700550 status_t onPullAtom(const int32_t atomId, std::string* pulledData, bool* success) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800551 status_t enableVSyncInjections(bool enable) override;
552 status_t injectVSync(nsecs_t when) override;
Vishnu Nair43bccf82020-06-05 10:53:37 -0700553 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800554 status_t getColorManagement(bool* outGetColorManagement) const override;
Peiyong Linc6780972018-10-28 15:24:08 -0700555 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
556 ui::Dataspace* outWideColorGamutDataspace,
557 ui::PixelFormat* outWideColorGamutPixelFormat) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700558 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800559 ui::PixelFormat* outFormat,
560 ui::Dataspace* outDataspace,
561 uint8_t* outComponentMask) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700562 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
563 uint8_t componentMask, uint64_t maxFrames) override;
564 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800565 uint64_t timestamp,
566 DisplayedFrameStats* outStats) const override;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800567 status_t getProtectedContentSupport(bool* outSupported) const override;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800568 status_t isWideColorDisplay(const sp<IBinder>& displayToken,
569 bool* outIsWideColorDisplay) const override;
Dan Stoza84ab9372018-12-17 15:27:57 -0800570 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
571 const sp<IRegionSamplingListener>& listener) override;
572 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override;
Alec Mouria9a68a62021-03-04 19:14:50 -0800573 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800574 status_t removeFpsListener(const sp<gui::IFpsListener>& listener) override;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200575 status_t addTunnelModeEnabledListener(
576 const sp<gui::ITunnelModeEnabledListener>& listener) override;
577 status_t removeTunnelModeEnabledListener(
578 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100579 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
580 ui::DisplayModeId displayModeId, bool allowGroupSwitching,
581 float primaryRefreshRateMin, float primaryRefreshRateMax,
582 float appRequestRefreshRateMin,
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100583 float appRequestRefreshRateMax) override;
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100584 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
585 ui::DisplayModeId* outDefaultMode,
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100586 bool* outAllowGroupSwitching,
587 float* outPrimaryRefreshRateMin,
588 float* outPrimaryRefreshRateMax,
589 float* outAppRequestRefreshRateMin,
590 float* outAppRequestRefreshRateMax) override;
Dan Gittik57e63c52019-01-18 16:37:54 +0000591 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
592 bool* outSupport) const override;
John Reck22be6962021-03-10 12:59:54 -0500593 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
594 const gui::DisplayBrightness& brightness) override;
John Reck88270902021-03-18 11:27:35 -0400595 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
596 const sp<gui::IHdrLayerInfoListener>& listener) override;
597 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
598 const sp<gui::IHdrLayerInfoListener>& listener) override;
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100599 status_t notifyPowerBoost(int32_t boostId) override;
Vishnu Nairb13bb952019-11-15 10:24:08 -0800600 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
601 float lightPosY, float lightPosZ, float lightRadius) override;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800602 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Marin Shalamanovc5986772021-03-16 16:09:49 +0100603 int8_t compatibility, int8_t changeFrameRateStrategy) override;
Steven Thomasd4071902020-03-24 16:02:53 -0700604 status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) override;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700605
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000606 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
607 const FrameTimelineInfo& frameTimelineInfo) override;
Ady Abraham74e17562020-08-24 18:18:19 -0700608
Pablo Gamito6ee484d2020-07-30 14:26:28 +0000609 status_t addTransactionTraceListener(
610 const sp<gui::ITransactionTraceListener>& listener) override;
611
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800612 int getGPUContextPriority() override;
613
Ady Abraham899dcdb2021-06-15 16:56:21 -0700614 status_t getMaxAcquiredBufferCount(int* buffers) const override;
Ady Abraham564f9de2021-02-03 18:34:33 -0800615
chaviw60c9d3e2021-06-04 12:52:17 -0500616 status_t addWindowInfosListener(
617 const sp<gui::IWindowInfosListener>& windowInfosListener) const override;
618 status_t removeWindowInfosListener(
619 const sp<gui::IWindowInfosListener>& windowInfosListener) const override;
620
Peiyong Linf243e5e2020-08-22 17:40:59 -0700621 // Implements IBinder::DeathRecipient.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800622 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800623
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700624 // HWC2::ComposerCallback overrides:
625 void onComposerHalVsync(hal::HWDisplayId, int64_t timestamp,
626 std::optional<hal::VsyncPeriodNanos>) override;
627 void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) override;
628 void onComposerHalRefresh(hal::HWDisplayId) override;
629 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
630 const hal::VsyncPeriodChangeTimeline&) override;
631 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700632
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700633 // ICompositor overrides:
634
635 // Commits transactions for layers and displays. Returns whether any state has been invalidated,
636 // i.e. whether a frame should be composited for each display.
637 bool commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expectedVsyncTime) override;
638
639 // Composites a frame for each display. CompositionEngine performs GPU and/or HAL composition
640 // via RenderEngine and the Composer HAL, respectively.
641 void composite(nsecs_t frameTime) override;
642
643 // Samples the composited frame via RegionSamplingThread.
644 void sample() override;
645
Peiyong Linf243e5e2020-08-22 17:40:59 -0700646 /*
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800647 * ISchedulerCallback
Ady Abraham2139f732019-11-13 18:56:40 -0800648 */
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700649
650 // Toggles hardware VSYNC by calling into HWC.
651 void setVsyncEnabled(bool) override;
652 // Initiates a refresh rate change to be applied on invalidate.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100653 void changeRefreshRate(const Scheduler::RefreshRate&, Scheduler::ModeEvent) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800654 // Called when kernel idle timer has expired. Used to update the refresh rate overlay.
655 void kernelTimerChanged(bool expired) override;
Ady Abraham62a0be22020-12-08 16:54:10 -0800656 // Called when the frame rate override list changed to trigger an event.
657 void triggerOnFrameRateOverridesChanged() override;
Ana Krulecb9afd792020-06-11 13:16:15 -0700658 // Toggles the kernel idle timer on or off depending the policy decisions around refresh rates.
Ady Abraham3efa3942021-06-24 19:01:25 -0700659 void toggleKernelIdleTimer() REQUIRES(mStateLock);
Ana Krulecb9afd792020-06-11 13:16:15 -0700660 // Keeps track of whether the kernel idle timer is currently enabled, so we don't have to
661 // make calls to sys prop each time.
662 bool mKernelIdleTimerEnabled = false;
Ady Abraham29d0da32020-07-16 18:39:33 -0700663 // Show spinner with refresh rate overlay
664 bool mRefreshRateOverlaySpinner = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700665
Marin Shalamanov5801c942020-12-17 17:00:13 +0100666 // Called on the main thread in response to initializeDisplays()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800667 void onInitializeDisplays() REQUIRES(mStateLock);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100668 // Sets the desired active mode bit. It obtains the lock, and sets mDesiredActiveMode.
669 void setDesiredActiveMode(const ActiveModeInfo& info) REQUIRES(mStateLock);
670 status_t setActiveMode(const sp<IBinder>& displayToken, int id);
671 // Once HWC has returned the present fence, this sets the active mode and a new refresh
Ady Abraham53852a52019-05-28 18:07:44 -0700672 // rate in SF.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100673 void setActiveModeInternal() REQUIRES(mStateLock);
674 // Calls to setActiveMode on the main thread if there is a pending mode change
Ady Abraham27cbed72020-04-10 12:56:59 -0700675 // that needs to be applied.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100676 void performSetActiveMode() REQUIRES(mStateLock);
Ady Abraham690f4612021-07-01 23:24:03 -0700677 void clearDesiredActiveModeState(const sp<DisplayDevice>&) REQUIRES(mStateLock);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100678 // Called when active mode is no longer is progress
Ady Abraham690f4612021-07-01 23:24:03 -0700679 void desiredActiveModeChangeDone(const sp<DisplayDevice>&) REQUIRES(mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100680 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700681 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
682 REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800683
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100684 // Sets the desired display mode specs.
685 status_t setDesiredDisplayModeSpecsInternal(
Steven Thomasd4071902020-03-24 16:02:53 -0700686 const sp<DisplayDevice>& display,
687 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy)
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100688 EXCLUDES(mStateLock);
Ady Abraham838de062019-02-04 10:24:03 -0800689
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700690 // Returns whether transactions were committed.
691 bool flushAndCommitTransactions() EXCLUDES(mStateLock);
692
693 void commitTransactions() EXCLUDES(mStateLock);
694 void commitTransactionsLocked(uint32_t transactionFlags) REQUIRES(mStateLock);
695 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800696
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700697 // Returns whether a new buffer has been latched.
698 bool latchBuffers();
Dan Stoza28d46a52020-04-28 09:54:54 -0700699
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700700 void updateLayerGeometry();
Dan Stoza6b9454d2014-11-07 16:00:59 -0800701
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800702 void updateInputFlinger();
chaviwbf023a62021-06-07 16:00:06 -0500703 void notifyWindowInfos();
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800704 void commitInputWindowCommands() REQUIRES(mStateLock);
Riley Andrews03414a12014-07-01 14:22:59 -0700705 void updateCursorAsync();
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700706
Ady Abraham3efa3942021-06-24 19:01:25 -0700707 void initScheduler(const sp<DisplayDevice>& display) REQUIRES(mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100708 void updatePhaseConfiguration(const Fps&) REQUIRES(mStateLock);
Ady Abraham55fa7272020-09-30 19:19:27 -0700709 void setVsyncConfig(const VsyncModulator::VsyncConfig&, nsecs_t vsyncPeriod);
Riley Andrews03414a12014-07-01 14:22:59 -0700710
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800711
Peiyong Linf243e5e2020-08-22 17:40:59 -0700712 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700713 * Transactions
714 */
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700715 bool applyTransactionState(const FrameTimelineInfo& info, const Vector<ComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800716 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -0800717 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800718 const int64_t desiredPresentTime, bool isAutoTimestamp,
Valerie Hau9dab9732019-08-20 09:29:25 -0700719 const client_cache_t& uncacheBuffer, const int64_t postTime,
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800720 uint32_t permissions, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700721 const std::vector<ListenerCallbacks>& listenerCallbacks,
Arthur Hung58144272021-01-16 03:43:53 +0000722 int originPid, int originUid, uint64_t transactionId)
723 REQUIRES(mStateLock);
724 // flush pending transaction that was presented after desiredPresentTime.
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700725 bool flushTransactionQueues();
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700726 // Returns true if there is at least one transaction that needs to be flushed
727 bool transactionFlushNeeded();
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700728
Dominik Laskowski48e09ef2021-08-04 14:05:30 -0700729 uint32_t setClientStateLocked(const FrameTimelineInfo&, const ComposerState&,
730 int64_t desiredPresentTime, bool isAutoTimestamp,
Vishnu Naircd52e2d2021-10-18 08:42:46 -0700731 int64_t postTime, uint32_t permissions) REQUIRES(mStateLock);
Dominik Laskowski48e09ef2021-08-04 14:05:30 -0700732
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700733 uint32_t getTransactionFlags() const;
734
735 // Sets the masked bits, and returns the old flags.
736 uint32_t setTransactionFlags(uint32_t mask);
737
738 // Clears and returns the masked bits.
739 uint32_t clearTransactionFlags(uint32_t mask);
740
Valerie Haud50e7412020-06-16 17:58:14 -0700741 // Indicate SF should call doTraversal on layers, but don't trigger a wakeup! We use this cases
742 // where there are still pending transactions but we know they won't be ready until a frame
Robert Carr4b874132020-05-29 12:02:51 -0700743 // arrives from a different layer. So we need to ensure we performTransaction from invalidate
744 // 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 -0700745 // onFrameAvailable or another layer update to wake us up.
746 void setTraversalNeeded();
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700747 uint32_t setTransactionFlags(uint32_t mask, TransactionSchedule,
748 const sp<IBinder>& applyToken = {});
chaviw74d90ad2019-04-26 14:45:26 -0700749 void commitOffscreenLayers();
Vishnu Nair12f62a02021-02-03 16:23:16 -0800750 bool transactionIsReadyToBeApplied(
Ady Abraham43752eb2021-03-04 16:24:25 -0800751 const FrameTimelineInfo& info, bool isAutoTimestamp, int64_t desiredPresentTime,
Ady Abraham5690bda2021-03-12 15:01:18 -0800752 uid_t originUid, const Vector<ComposerState>& states,
Vishnu Nair83df0342021-03-30 11:50:44 -0700753 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>&
754 bufferLayersReadyToPresent) const REQUIRES(mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800755 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800756 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
757 REQUIRES(mStateLock);
Ady Abraham8db10102021-03-15 17:19:23 -0700758 bool frameIsEarly(nsecs_t expectedPresentTime, int64_t vsyncId) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700759 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700760 * Layer management
761 */
Marissa Wall2d814fb2019-04-09 18:52:57 +0000762 status_t createLayer(const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
763 PixelFormat format, uint32_t flags, LayerMetadata metadata,
Robert Carrc0df3122019-04-11 13:18:21 -0700764 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
Ady Abraham9f0a4002020-10-05 15:47:26 -0700765 const sp<IBinder>& parentHandle, int32_t* outLayerId,
766 const sp<Layer>& parentLayer = nullptr,
767 uint32_t* outTransformHint = nullptr);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800768
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700769 status_t createBufferQueueLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800770 uint32_t h, uint32_t flags, LayerMetadata metadata,
771 PixelFormat& format, sp<IBinder>* outHandle,
772 sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800773
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700774 status_t createBufferStateLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800775 uint32_t h, uint32_t flags, LayerMetadata metadata,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700776 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700777
Vishnu Nairfa247b12020-02-11 08:58:26 -0800778 status_t createEffectLayer(const sp<Client>& client, std::string name, uint32_t w, uint32_t h,
779 uint32_t flags, LayerMetadata metadata, sp<IBinder>* outHandle,
780 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700781
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700782 status_t createContainerLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800783 uint32_t h, uint32_t flags, LayerMetadata metadata,
784 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Robert Carr6b3f6c52018-08-13 13:05:17 -0700785
chaviwfe94a222019-08-21 13:52:59 -0700786 status_t mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
Ady Abraham9f0a4002020-10-05 15:47:26 -0700787 sp<IBinder>* outHandle, int32_t* outLayerId);
chaviwfe94a222019-08-21 13:52:59 -0700788
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700789 std::string getUniqueLayerName(const char* name);
Cody Northropbc755282017-03-31 12:00:08 -0600790
Rob Carr4bba3702018-10-08 21:53:30 +0000791 // called when all clients have released all their references to
792 // this layer meaning it is entirely safe to destroy all
793 // resources associated to this layer.
Vishnu Nairf9096652021-07-20 18:49:42 -0700794 void onHandleDestroyed(BBinder* handle, sp<Layer>& layer);
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800795 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700796
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700797 // add a layer to SurfaceFlinger
Robert Carrc0df3122019-04-11 13:18:21 -0700798 status_t addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
799 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
800 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
chaviwe0c7b822021-07-20 10:16:05 -0500801 bool addToRoot, uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700802
Vishnu Nair4351ad52019-02-11 14:13:02 -0800803 // Traverse through all the layers and compute and cache its bounds.
804 void computeLayerBounds();
805
Peiyong Linf243e5e2020-08-22 17:40:59 -0700806 // Boot animation, on/off animations and screen capture
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700807 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700808
Sally Qi59a9f502021-10-12 18:53:23 +0000809 std::shared_future<renderengine::RenderEngineResult> captureScreenCommon(
810 RenderAreaFuture, TraverseLayersFunction, ui::Size bufferSize, ui::PixelFormat,
811 bool allowProtected, bool grayscale, const sp<IScreenCaptureListener>&);
812 std::shared_future<renderengine::RenderEngineResult> captureScreenCommon(
813 RenderAreaFuture, TraverseLayersFunction,
814 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
815 bool grayscale, const sp<IScreenCaptureListener>&);
816 std::shared_future<renderengine::RenderEngineResult> renderScreenImplLocked(
817 const RenderArea&, TraverseLayersFunction,
818 const std::shared_ptr<renderengine::ExternalTexture>&, bool canCaptureBlackoutContent,
819 bool regionSampling, bool grayscale, ScreenCaptureResults&);
chaviw03900772020-08-18 12:34:51 -0700820
chaviw4b9d5e12020-08-04 18:30:35 -0700821 // If the uid provided is not UNSET_UID, the traverse will skip any layers that don't have a
822 // matching ownerUid
823 void traverseLayersInLayerStack(ui::LayerStack, const int32_t uid, const LayerVector::Visitor&);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700824
Romain Guy11d63f42017-07-20 12:47:14 -0700825 void readPersistentProperties();
826
rnleeed20fa42021-08-10 18:00:03 -0700827 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700828
Peiyong Linf243e5e2020-08-22 17:40:59 -0700829 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700830 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700831 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700832 // called when starting, or restarting after system_server death
833 void initializeDisplays();
834
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700835 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
836 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700837 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700838 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700839
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700840 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700841 const auto it = mDisplays.find(displayToken);
842 return it == mDisplays.end() ? nullptr : it->second;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700843 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700844
Ady Abraham690f4612021-07-01 23:24:03 -0700845 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
846 REQUIRES(mStateLock) {
847 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
848 }
849
850 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
851 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
852 return getDisplayDeviceLocked(token);
853 }
854 return nullptr;
855 }
856
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700857 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700858 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700859 }
860
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700861 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700862 if (const auto display = getDisplayDeviceLocked(mActiveDisplayToken)) {
863 return display;
864 }
865 // The active display is outdated, fall back to the internal display
866 mActiveDisplayToken.clear();
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800867 if (const auto token = getInternalDisplayTokenLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700868 return getDisplayDeviceLocked(token);
869 }
870 return nullptr;
Michael Wright28f24d02016-07-12 13:30:53 -0700871 }
872
Ady Abraham3efa3942021-06-24 19:01:25 -0700873 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700874 Mutex::Autolock lock(mStateLock);
875 return getDefaultDisplayDeviceLocked();
876 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200877
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700878 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
879 template <typename Predicate>
880 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
881 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
882 [&](const auto& pair) { return p(*pair.second); });
883
884 return it == mDisplays.end() ? nullptr : it->second;
885 }
886
887 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
888 // TODO(b/182939859): Replace tokens with IDs for display lookup.
889 return findDisplay([id](const auto& display) { return display.getId() == id; });
890 }
891
Ady Abrahamed3290f2021-05-17 15:12:14 -0700892 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
893
Mathias Agopian87baae12012-07-31 12:38:26 -0700894 // mark a region of a layer stack dirty. this updates the dirty
895 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700896 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700897
Evan Rosky2239b372021-05-20 13:43:47 -0700898 sp<DisplayDevice> getDisplayWithInputByLayer(Layer* layer) const REQUIRES(mStateLock);
899
Siddharth Kapoorecc45ae2021-09-06 19:03:06 +0800900 bool isDisplayActiveLocked(const sp<const DisplayDevice>& display) const REQUIRES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700901 return display->getDisplayToken() == mActiveDisplayToken;
902 }
903
Peiyong Linf243e5e2020-08-22 17:40:59 -0700904 /*
Mathias Agopian86303202012-07-24 22:46:10 -0700905 * H/W composer
906 */
Marin Shalamanov6e840172020-12-14 22:13:28 +0100907 // The following thread safety rules apply when accessing HWComposer:
908 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
909 // acquire mStateLock.
910 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -0700911 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +0100912 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -0700913 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700914
Peiyong Linf243e5e2020-08-22 17:40:59 -0700915 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700916 * Compositing
917 */
David Sodman2b406362017-12-15 13:33:47 -0800918 void postComposition();
Dominik Laskowskif654d572018-12-20 11:03:06 -0800919 void getCompositorTiming(CompositorTiming* compositorTiming);
Ana Krulece588e312018-09-18 12:32:24 -0700920 void updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
921 std::shared_ptr<FenceTime>& presentFenceTime);
922 void setCompositorTimingSnapped(const DisplayStatInfo& stats,
923 nsecs_t compositeToPresentLatency);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600924
David Sodmanfa9b2af2017-12-24 13:28:59 -0800925 void postFrame();
Mathias Agopian4da75192010-08-10 17:19:56 -0700926
Peiyong Linf243e5e2020-08-22 17:40:59 -0700927 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -0700928 * Display management
929 */
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +0100930 void loadDisplayModes(PhysicalDisplayId displayId, DisplayModes& outModes,
931 DisplayModePtr& outActiveMode) const REQUIRES(mStateLock);
Lloyd Pique542307f2018-10-19 13:24:08 -0700932 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -0700933 const wp<IBinder>& displayToken,
934 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -0700935 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +0100936 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700937 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowski20134642020-04-20 22:36:44 -0700938 void processDisplayChangesLocked() REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700939 void processDisplayRemoved(const wp<IBinder>& displayToken) REQUIRES(mStateLock);
Marin Shalamanovae685592020-02-12 17:12:22 +0100940 void processDisplayChanged(const wp<IBinder>& displayToken,
941 const DisplayDeviceState& currentState,
Dominik Laskowski20134642020-04-20 22:36:44 -0700942 const DisplayDeviceState& drawingState) REQUIRES(mStateLock);
943 void processDisplayHotplugEventsLocked() REQUIRES(mStateLock);
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700944
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800945 void dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800946
Peiyong Linf243e5e2020-08-22 17:40:59 -0700947 /*
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700948 * VSYNC
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700949 */
Ady Abraham2492a022020-07-24 11:09:55 -0700950 nsecs_t getVsyncPeriodFromHWC() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700951
Ady Abraham4f960d12021-10-13 16:59:49 -0700952 void setHWCVsyncEnabled(PhysicalDisplayId id, hal::Vsync enabled) {
953 mLastHWCVsyncState = enabled;
954 getHwComposer().setVsyncEnabled(id, enabled);
955 }
956
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800957 // Sets the refresh rate by switching active configs, if they are available for
Ana Krulec7d1d6832018-12-27 11:10:09 -0800958 // the desired refresh rate.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100959 void changeRefreshRateLocked(const RefreshRate&, Scheduler::ModeEvent) REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700960
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700961 struct FenceWithFenceTime {
962 sp<Fence> fence = Fence::NO_FENCE;
963 std::shared_ptr<FenceTime> fenceTime = FenceTime::NO_FENCE;
964 };
965
Alec Mouri6d414b52020-03-17 11:18:05 -0700966 // Gets the fence for the previous frame.
967 // Must be called on the main thread.
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700968 FenceWithFenceTime previousFrameFence();
Alec Mouri6d414b52020-03-17 11:18:05 -0700969
970 // Whether the previous frame has not yet been presented to the display.
971 // If graceTimeMs is positive, this method waits for at most the provided
972 // grace period before reporting if the frame missed.
973 // Must be called on the main thread.
974 bool previousFramePending(int graceTimeMs = 0);
975
976 // Returns the previous time that the frame was presented. If the frame has
977 // not been presented yet, then returns Fence::SIGNAL_TIME_PENDING. If there
978 // is no pending frame, then returns Fence::SIGNAL_TIME_INVALID.
979 // Must be called on the main thread.
980 nsecs_t previousFramePresentTime();
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700981
Ady Abraham5facfb12020-04-22 15:18:31 -0700982 // Calculates the expected present time for this frame. For negative offsets, performs a
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700983 // correction using the predicted vsync for the next frame instead.
Ady Abraham899dcdb2021-06-15 16:56:21 -0700984
Ady Abraham56b42a42020-12-28 16:48:48 -0800985 nsecs_t calculateExpectedPresentTime(DisplayStatInfo) const;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700986
Dominik Laskowskic2867142019-01-21 11:33:38 -0800987 /*
988 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700989 */
Marin Shalamanova524a092020-07-27 21:39:55 +0200990 sp<IBinder> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
991 REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700992 const auto it = mPhysicalDisplayTokens.find(displayId);
993 return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
994 }
995
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200996 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
997 const sp<IBinder>& displayToken) const REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700998 for (const auto& [id, token] : mPhysicalDisplayTokens) {
999 if (token == displayToken) {
1000 return id;
1001 }
1002 }
1003 return {};
1004 }
1005
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001006 // TODO(b/182939859): SF conflates the primary (a.k.a. default) display with the first display
1007 // connected at boot, which is typically internal. (Theoretically, it must be internal because
1008 // SF does not support disconnecting it, though in practice HWC may circumvent this limitation.)
1009 //
1010 // SF inherits getInternalDisplayToken and getInternalDisplayId from ISurfaceComposer, so these
1011 // locked counterparts are named consistently. Once SF supports headless mode and can designate
1012 // any display as primary, the "internal" misnomer will be phased out.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001013 sp<IBinder> getInternalDisplayTokenLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001014 return getPhysicalDisplayTokenLocked(getInternalDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001015 }
1016
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001017 PhysicalDisplayId getInternalDisplayIdLocked() const REQUIRES(mStateLock) {
1018 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001019 }
1020
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001021 // Toggles use of HAL/GPU virtual displays.
1022 void enableHalVirtualDisplays(bool);
1023
1024 // Virtual display lifecycle for ID generation and HAL allocation.
Dominik Laskowski263eec42021-07-21 23:13:24 -07001025 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat) REQUIRES(mStateLock);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001026 void releaseVirtualDisplay(VirtualDisplayId);
1027
Ady Abrahamed3290f2021-05-17 15:12:14 -07001028 void onActiveDisplayChangedLocked(const sp<DisplayDevice>& activeDisplay) REQUIRES(mStateLock);
1029
1030 void onActiveDisplaySizeChanged(const sp<DisplayDevice>& activeDisplay);
1031
Dominik Laskowskic2867142019-01-21 11:33:38 -08001032 /*
1033 * Debugging & dumpsys
1034 */
Dominik Laskowskic2867142019-01-21 11:33:38 -08001035 void dumpAllLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
1036
1037 void appendSfConfigString(std::string& result) const;
1038 void listLayersLocked(std::string& result) const;
1039 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
1040 void clearStatsLocked(const DumpArgs& args, std::string& result);
1041 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001042 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Jamie Gennis6547ff42013-07-16 20:12:42 -07001043 void logFrameStats();
1044
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08001045 void dumpVSync(std::string& result) const REQUIRES(mStateLock);
Yiwei Zhang5434a782018-12-05 18:06:32 -08001046 void dumpStaticScreenStats(std::string& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -07001047 // Not const because each Layer needs to query Fences and cache timestamps.
Yiwei Zhang5434a782018-12-05 18:06:32 -08001048 void dumpFrameEventsLocked(std::string& result);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001049 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001050 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001051 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001052 LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;
Vishnu Nair0f085c62019-08-30 08:49:12 -07001053 void dumpOffscreenLayersProto(LayersProto& layersProto,
1054 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
chaviw0a398992021-08-13 10:13:01 -05001055 void dumpDisplayProto(LayersTraceProto& layersTraceProto) const;
1056
Alec Mouri6b9e9912020-01-21 10:50:24 -08001057 // Dumps state from HW Composer
1058 void dumpHwc(std::string& result) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -07001059 LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)
1060 EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -07001061 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001062 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001063
Dominik Laskowskic2867142019-01-21 11:33:38 -08001064 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1065
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001066 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001067
1068 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1069 return doDump(fd, args, asProto);
1070 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001071
Steven Thomasd4071902020-03-24 16:02:53 -07001072 void onFrameRateFlexibilityTokenReleased();
1073
chaviw17ac24b2021-01-28 18:50:05 -08001074 static mat4 calculateColorMatrix(float saturation);
1075
Chia-I Wu28f320b2018-05-03 11:02:56 -07001076 void updateColorMatrixLocked();
1077
Peiyong Linf243e5e2020-08-22 17:40:59 -07001078 // Verify that transaction is being called by an approved process:
1079 // either AID_GRAPHICS or AID_SYSTEM.
1080 status_t CheckTransactCodeCredentials(uint32_t code);
1081
Ady Abrahame46243a2021-02-23 19:33:49 -08001082 // Add transaction to the Transaction Queue
arthurhungf1b7c7b2021-03-03 17:42:23 +08001083 void queueTransaction(TransactionState& state) EXCLUDES(mQueueLock);
1084 void waitForSynchronousTransaction(const CountDownLatch& transactionCommittedSignal);
Arthur Hung2274a312021-04-28 15:13:06 +00001085 void signalSynchronousTransactions(const uint32_t flag);
Ady Abrahame46243a2021-02-23 19:33:49 -08001086
Peiyong Linf243e5e2020-08-22 17:40:59 -07001087 /*
1088 * Generic Layer Metadata
1089 */
1090 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1091
1092 /*
1093 * Misc
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001094 */
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001095 std::vector<ui::ColorMode> getDisplayColorModes(const DisplayDevice&) REQUIRES(mStateLock);
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001096
Ady Abraham899dcdb2021-06-15 16:56:21 -07001097 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1098 std::chrono::nanoseconds presentLatency);
1099 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001100
Ady Abraham3efa3942021-06-24 19:01:25 -07001101 void updateInternalDisplayVsyncLocked(const sp<DisplayDevice>& activeDisplay)
Ady Abrahamed3290f2021-05-17 15:12:14 -07001102 REQUIRES(mStateLock);
1103
Peiyong Linf243e5e2020-08-22 17:40:59 -07001104 sp<StartPropertySetThread> mStartPropertySetThread;
Lloyd Pique90c115d2018-09-18 21:39:42 -07001105 surfaceflinger::Factory& mFactory;
1106
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001107 std::future<void> mRenderEnginePrimeCacheFuture;
1108
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001109 // access must be protected by mStateLock
1110 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001111 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001112 std::atomic<int32_t> mTransactionFlags = 0;
arthurhungf1b7c7b2021-03-03 17:42:23 +08001113 std::vector<std::shared_ptr<CountDownLatch>> mTransactionCommittedSignals;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001114 bool mAnimTransactionPending = false;
1115 SortedVector<sp<Layer>> mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001116
Chia-I Wu28f320b2018-05-03 11:02:56 -07001117 // global color transform states
1118 Daltonizer mDaltonizer;
1119 float mGlobalSaturationFactor = 1.0f;
1120 mat4 mClientColorMatrix;
1121
Dan Stoza101d8dc2018-02-27 15:42:25 -08001122 // Can't be unordered_set because wp<> isn't hashable
1123 std::set<wp<IBinder>> mGraphicBufferProducerList;
Ady Abrahamb89ca7d2020-03-04 11:19:37 -08001124 size_t mMaxGraphicBufferProducerListSize = ISurfaceComposer::MAX_LAYERS;
Alec Mouri601393f2020-02-21 13:26:52 -08001125 // If there are more GraphicBufferProducers tracked by SurfaceFlinger than
1126 // this threshold, then begin logging.
1127 size_t mGraphicBufferProducerListSizeLogThreshold =
1128 static_cast<size_t>(0.95 * static_cast<double>(MAX_LAYERS));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001129
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001130 void removeGraphicBufferProducerAsync(const wp<IBinder>&);
1131
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001132 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001133 bool mLayersRemoved = false;
1134 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001135
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001136 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001137 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001138
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001139 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001140 const nsecs_t mBootTime = systemTime();
1141 bool mGpuToCpuSupported = false;
Alec Mouri5f487d42020-02-06 09:26:19 -08001142 bool mIsUserBuild = true;
Mathias Agopian3094df32012-06-18 18:06:45 -07001143
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001144 // Can only accessed from the main thread, these members
1145 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001146 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001147 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001148
Robert Carr167bdde2021-07-28 11:26:51 -07001149 // VisibleRegions dirty is already cleared by postComp, but we need to track it to prevent
1150 // extra work in the HDR layer info listener.
1151 bool mVisibleRegionsWereDirtyThisFrame = false;
1152 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1153 // scene hasn't changed
1154 bool mAddingHDRLayerInfoListener = false;
1155
Robert Carre450fb52021-06-11 13:21:09 -07001156 // Set during transaction application stage to track if the input info or children
1157 // for a layer has changed.
1158 // TODO: Also move visibleRegions over to a boolean system.
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001159 bool mInputInfoChanged = false;
Robert Carre450fb52021-06-11 13:21:09 -07001160 bool mSomeChildrenChanged;
Robert Carr167bdde2021-07-28 11:26:51 -07001161 bool mSomeDataspaceChanged = false;
Robert Carrb552ff52021-06-11 13:35:54 -07001162 bool mForceTransactionDisplayChange = false;
Robert Carre450fb52021-06-11 13:21:09 -07001163
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001164 bool mAnimCompositionPending = false;
Alec Mouri5c9c9602020-09-01 15:10:40 -07001165
1166 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001167 // latched.
1168 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> mLayersWithQueuedFrames;
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001169 // Tracks layers that need to update a display's dirty region.
1170 std::vector<sp<Layer>> mLayersPendingRefresh;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001171 std::array<FenceWithFenceTime, 2> mPreviousPresentFences;
Alec Mouricc0fc602019-02-26 21:45:19 -08001172 // True if in the previous frame at least one layer was composed via the GPU.
Dan Stoza05dacfb2016-07-01 13:33:38 -07001173 bool mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001174 // True if in the previous frame at least one layer was composed via HW Composer.
1175 // Note that it is possible for a frame to be composed via both client and device
1176 // composition, for example in the case of overlays.
1177 bool mHadDeviceComposition = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001178 // True if in the previous frame, the client composition was skipped by reusing the buffer
1179 // used in a previous composition. This can happed if the client composition requests
1180 // did not change.
1181 bool mReusedClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001182
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001183 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001184
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001185 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mStateLock);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001186
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001187 // this may only be written from the main thread with mStateLock held
1188 // it may be read from other threads with mStateLock held
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001189 std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Marin Shalamanova524a092020-07-27 21:39:55 +02001190 std::unordered_map<PhysicalDisplayId, sp<IBinder>> mPhysicalDisplayTokens
1191 GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001192
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001193 struct {
1194 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1195 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1196 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001197
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001198 std::atomic_uint mDebugFlashDelay = 0;
1199 std::atomic_bool mDebugDisableHWC = false;
1200 std::atomic_bool mDebugDisableTransformHint = false;
1201 std::atomic<nsecs_t> mDebugInTransaction = 0;
1202 std::atomic_bool mForceFullDamage = false;
1203
Alec Mouridd8bf2d2021-05-08 16:36:33 -07001204 bool mLayerCachingEnabled = false;
Ady Abrahamadb9a992019-09-19 21:21:55 +00001205 bool mPropagateBackpressureClientComposition = false;
Pablo Gamito5cfc6e52020-09-10 11:18:03 +00001206 sp<SurfaceInterceptor> mInterceptor;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001207
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001208 SurfaceTracing mTracing{*this};
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001209 std::mutex mTracingLock;
Nataniel Borges2b796da2019-02-15 13:32:18 -08001210 bool mTracingEnabled = false;
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07001211 bool mTracePostComposition = false;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001212 std::atomic<bool> mTracingEnabledChanged = false;
1213
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001214 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001215 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001216 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001217
Lucas Dupin00f16422020-03-11 11:33:04 -07001218 // If blurs should be enabled on this device.
1219 bool mSupportsBlur = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001220 // If blurs are considered expensive and should require high GPU frequency.
1221 bool mBlursAreExpensive = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001222 std::atomic<uint32_t> mFrameMissedCount = 0;
1223 std::atomic<uint32_t> mHwcFrameMissedCount = 0;
1224 std::atomic<uint32_t> mGpuFrameMissedCount = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001225
Robert Carr9a803c32021-01-14 16:57:58 -08001226 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001227
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001228 // these are thread safe
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001229 std::unique_ptr<MessageQueue> mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001230 FrameTracker mAnimFrameTracker;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001231
1232 // protected by mDestroyedLayerLock;
1233 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -08001234 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001235
Dan Stoza436ccf32018-06-21 12:10:12 -07001236 // We maintain a pool of pre-generated texture names to hand out to avoid
1237 // layer creation needing to run on the main thread (which it would
1238 // otherwise need to do to access RenderEngine).
1239 std::mutex mTexturePoolMutex;
1240 uint32_t mTexturePoolSize = 0;
1241 std::vector<uint32_t> mTexturePool;
1242
Arthur Hung58144272021-01-16 03:43:53 +00001243 mutable Mutex mQueueLock;
1244 Condition mTransactionQueueCV;
1245 std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash>
1246 mPendingTransactionQueues GUARDED_BY(mQueueLock);
1247 std::queue<TransactionState> mTransactionQueue GUARDED_BY(mQueueLock);
Peiyong Linf243e5e2020-08-22 17:40:59 -07001248 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001249 * Feature prototyping
1250 */
1251
Dan Stozab90cf072015-03-05 11:05:59 -08001252 // Static screen stats
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001253 bool mHasPoweredOff = false;
Dan Stozae77c7662016-05-13 11:37:28 -07001254
chaviweadf0d42019-08-12 13:28:29 -07001255 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001256
Steven Morelanda904bb92019-07-02 17:37:23 -07001257 // to linkToDeath
1258 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001259 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1260 // different threads without a lock and could trigger unsynchronized writes to
1261 // to mWindowManager or mInputFlinger
1262 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001263
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001264 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001265
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001266 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001267
Peiyong Lina3ea5592019-02-10 14:45:00 -08001268 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1269 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1270 // 2. be one of the supported color modes returned by hardware composer, otherwise
1271 // it will not be respected.
1272 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1273 // is not set to 1.
1274 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1275 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1276
Peiyong Lin9d846a52018-11-05 13:18:20 -08001277 ui::Dataspace mDefaultCompositionDataspace;
1278 ui::Dataspace mWideColorGamutCompositionDataspace;
Yichi Chenda901bf2019-06-28 14:58:27 +08001279 ui::Dataspace mColorSpaceAgnosticDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001280
David Sodman105b7dc2017-11-04 20:28:14 -07001281 SurfaceFlingerBE mBE;
Lloyd Pique70d91362018-10-18 16:02:55 -07001282 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Garfield Tan9c9c1912021-07-19 12:02:16 -07001283 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1284 // any mutex.
1285 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001286
Dominik Laskowskif06d68e2021-03-24 19:40:03 -07001287 const std::string mHwcServiceName;
1288
1289 bool hasMockHwc() const { return mHwcServiceName == "mock"; }
1290
Peiyong Linf243e5e2020-08-22 17:40:59 -07001291 /*
Ana Krulecb43429d2019-01-09 14:28:51 -08001292 * Scheduler
1293 */
Ana Krulec98b5b242018-08-10 15:03:23 -07001294 std::unique_ptr<Scheduler> mScheduler;
Dominik Laskowski98041832019-08-01 18:35:59 -07001295 scheduler::ConnectionHandle mAppConnectionHandle;
1296 scheduler::ConnectionHandle mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001297
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001298 // Stores phase offsets configured per refresh rate.
Ady Abraham8287e852020-08-12 14:44:58 -07001299 std::unique_ptr<scheduler::VsyncConfiguration> mVsyncConfiguration;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001300
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001301 // Optional to defer construction until PhaseConfiguration is created.
Ady Abraham23ea9da2021-07-14 16:32:56 -07001302 sp<VsyncModulator> mVsyncModulator;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001303
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001304 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Ady Abraham1902d072019-03-01 17:18:59 -08001305
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001306 std::atomic<nsecs_t> mExpectedPresentTime = 0;
Snild Dolkow819636c2021-01-22 14:42:08 +01001307 nsecs_t mScheduledPresentTime = 0;
Marin Shalamanovc75b0772020-06-12 22:29:11 +02001308 hal::Vsync mHWCVsyncPendingState = hal::Vsync::DISABLE;
Ady Abraham4f960d12021-10-13 16:59:49 -07001309 hal::Vsync mLastHWCVsyncState = hal::Vsync::DISABLE;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001310
Ady Abrahamb838aed2019-02-12 15:30:16 -08001311 // below flags are set by main thread only
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001312 bool mSetActiveModePending = false;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001313
Kevin DuBois413287f2019-02-25 08:46:47 -08001314 bool mLumaSampling = true;
1315 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001316 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001317 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001318 ui::DisplayPrimaries mInternalDisplayPrimaries;
Kevin DuBois413287f2019-02-25 08:46:47 -08001319
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001320 const float mInternalDisplayDensity;
1321 const float mEmulatedDisplayDensity;
1322
Chris Ye0783e992020-06-02 21:34:49 -07001323 sp<os::IInputFlinger> mInputFlinger;
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001324 // Should only be accessed by the main thread.
chaviw273171b2018-12-26 11:46:30 -08001325 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001326
Peiyong Lin74ca2f42019-01-14 19:36:57 -08001327 Hwc2::impl::PowerAdvisor mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001328
Ady Abraham1b11bc62021-06-03 19:51:19 -07001329 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock);
Ady Abraham34392f72019-04-10 11:29:27 -07001330
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001331 // Flag used to set override desired display mode from backdoor
1332 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001333
1334 // A set of layers that have no parent so they are not drawn on screen.
1335 // Should only be accessed by the main thread.
1336 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1337 // be any issues with a raw pointer referencing an invalid object.
1338 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001339
Steven Thomasd4071902020-03-24 16:02:53 -07001340 int mFrameRateFlexibilityTokenCount = 0;
Ady Abraham07e54702020-04-16 15:05:37 -07001341
1342 sp<IBinder> mDebugFrameRateFlexibilityToken;
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001343
1344 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001345
1346 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1347 GUARDED_BY(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001348 mutable Mutex mCreatedLayersLock;
1349 struct LayerCreatedState {
1350 LayerCreatedState(const wp<Layer>& layer, const wp<IBinder>& parent,
chaviwe0c7b822021-07-20 10:16:05 -05001351 const wp<Layer> parentLayer, const wp<IBinder>& producer, bool addToRoot)
arthurhungdba591c2021-02-08 17:28:49 +08001352 : layer(layer),
1353 initialParent(parent),
1354 initialParentLayer(parentLayer),
chaviwe0c7b822021-07-20 10:16:05 -05001355 initialProducer(producer),
1356 addToRoot(addToRoot) {}
arthurhungdba591c2021-02-08 17:28:49 +08001357 wp<Layer> layer;
1358 // Indicates the initial parent of the created layer, only used for creating layer in
1359 // SurfaceFlinger. If nullptr, it may add the created layer into the current root layers.
1360 wp<IBinder> initialParent;
1361 wp<Layer> initialParentLayer;
1362 // Indicates the initial graphic buffer producer of the created layer, only used for
1363 // creating layer in SurfaceFlinger.
1364 wp<IBinder> initialProducer;
chaviwe0c7b822021-07-20 10:16:05 -05001365 // Indicates whether the layer getting created should be added at root if there's no parent
1366 // and has permission ACCESS_SURFACE_FLINGER. If set to false and no parent, the layer will
1367 // be added offscreen.
1368 bool addToRoot;
arthurhungdba591c2021-02-08 17:28:49 +08001369 };
1370
1371 // A temporay pool that store the created layers and will be added to current state in main
1372 // thread.
1373 std::unordered_map<BBinder*, std::unique_ptr<LayerCreatedState>> mCreatedLayers;
1374 void setLayerCreatedState(const sp<IBinder>& handle, const wp<Layer>& layer,
1375 const wp<IBinder>& parent, const wp<Layer> parentLayer,
chaviwe0c7b822021-07-20 10:16:05 -05001376 const wp<IBinder>& producer, bool addToRoot);
arthurhungdba591c2021-02-08 17:28:49 +08001377 auto getLayerCreatedState(const sp<IBinder>& handle);
chaviwe0c7b822021-07-20 10:16:05 -05001378 sp<Layer> handleLayerCreatedLocked(const sp<IBinder>& handle) REQUIRES(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001379
Ady Abraham1273ac12021-08-26 17:31:53 -07001380 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001381
Ady Abraham1b11bc62021-06-03 19:51:19 -07001382 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
1383 return std::any_of(mDisplays.begin(), mDisplays.end(),
1384 [](std::pair<wp<IBinder>, sp<DisplayDevice>> display) {
1385 return display.second->isRefreshRateOverlayEnabled();
1386 });
1387 }
1388
Ady Abrahamed3290f2021-05-17 15:12:14 -07001389 wp<IBinder> mActiveDisplayToken GUARDED_BY(mStateLock);
chaviw60c9d3e2021-06-04 12:52:17 -05001390
1391 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001392
1393 std::unique_ptr<FlagManager> mFlagManager;
Romain Guy0147a172017-06-01 13:53:56 -07001394};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001395
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001396} // namespace android