blob: b5bc5c5d0b2a007ce83fa656453b277d632087cc [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>
Mathias Agopian86303202012-07-24 22:46:10 -070036#include <hardware/hwcomposer_defs.h>
chaviw291d88a2019-02-14 10:33:58 -080037#include <input/ISetInputWindowsListener.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080038#include <layerproto/LayerProtoHeader.h>
39#include <math/mat4.h>
Vishnu Nair35798872017-10-06 16:00:36 -070040#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070041#include <system/graphics.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080042#include <ui/FenceTime.h>
43#include <ui/PixelFormat.h>
44#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"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080055#include "Effects/Daltonizer.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080056#include "FrameTracker.h"
Robert Carr2047fae2016-11-28 14:09:09 -080057#include "LayerVector.h"
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080058#include "Scheduler/RefreshRateConfigs.h"
Ana Krulecb43429d2019-01-09 14:28:51 -080059#include "Scheduler/RefreshRateStats.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070060#include "Scheduler/Scheduler.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070061#include "Scheduler/VSyncModulator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080062#include "SurfaceFlingerFactory.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080063#include "SurfaceTracing.h"
Ady Abraham50204dd2019-07-19 15:47:11 -070064#include "TracedOrdinal.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080065#include "TransactionCompletedThread.h"
Mathias Agopian86303202012-07-24 22:46:10 -070066
Dominik Laskowski83b88212018-12-11 13:34:06 -080067#include <atomic>
68#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080069#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -070070#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080071#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080072#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -070073#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080074#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070075#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070076#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070077#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -080078#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -070079#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -070080#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080081#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070082
chaviw1d044282017-09-27 12:19:28 -070083using namespace android::surfaceflinger;
84
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080085namespace android {
86
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080087class Client;
Lloyd Pique144e1162017-12-20 16:44:52 -080088class EventThread;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070089class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -080090class IGraphicBufferProducer;
Robert Carr720e5062018-07-30 17:45:14 -070091class IInputFlinger;
Lloyd Pique144e1162017-12-20 16:44:52 -080092class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070093class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -070094class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070095class RegionSamplingThread;
Yiwei Zhang7e666a52018-11-15 13:33:42 -080096class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -070097class FrameTracer;
Lloyd Pique144e1162017-12-20 16:44:52 -080098
Lloyd Pique542307f2018-10-19 13:24:08 -070099namespace compositionengine {
100class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800101class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800102
103struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700104} // namespace compositionengine
105
Peiyong Lin833074a2018-08-28 11:53:54 -0700106namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800107class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700108} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700109
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800110namespace dvr {
111class VrFlinger;
112} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800113
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800114enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700115 eTransactionNeeded = 0x01,
116 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700117 eDisplayTransactionNeeded = 0x04,
Lloyd Piqued432a7c2018-03-23 16:05:31 -0700118 eDisplayLayerStackChanged = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700119 eTransactionFlushNeeded = 0x10,
120 eTransactionMask = 0x1f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800121};
122
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800123using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800124
David Sodman105b7dc2017-11-04 20:28:14 -0700125class SurfaceFlingerBE
126{
127public:
128 SurfaceFlingerBE();
129
David Sodmanbc815282017-11-05 18:57:52 -0800130 const std::string mHwcServiceName; // "default" for real use, something else for testing.
131
David Sodman73beded2017-11-15 11:56:06 -0800132 FenceTimeline mGlCompositionDoneTimeline;
133 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800134
David Sodman99974d22017-11-28 12:04:33 -0800135 // protected by mCompositorTimingLock;
136 mutable std::mutex mCompositorTimingLock;
137 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800138
David Sodman99974d22017-11-28 12:04:33 -0800139 // Only accessed from the main thread.
140 struct CompositePresentTime {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700141 nsecs_t composite = -1;
142 std::shared_ptr<FenceTime> display = FenceTime::NO_FENCE;
David Sodman99974d22017-11-28 12:04:33 -0800143 };
144 std::queue<CompositePresentTime> mCompositePresentTimes;
145
David Sodman4a36e932017-11-07 14:29:47 -0800146 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700147 nsecs_t mFrameBuckets[NUM_BUCKETS] = {};
148 nsecs_t mTotalTime = 0;
149 std::atomic<nsecs_t> mLastSwapTime = 0;
David Sodman4a36e932017-11-07 14:29:47 -0800150
David Sodmancbaf0832017-11-07 14:21:36 -0800151 // Double- vs. triple-buffering stats
152 struct BufferingStats {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700153 size_t numSegments = 0;
154 nsecs_t totalTime = 0;
David Sodmancbaf0832017-11-07 14:21:36 -0800155
156 // "Two buffer" means that a third buffer was never used, whereas
157 // "double-buffered" means that on average the segment only used two
158 // buffers (though it may have used a third for some part of the
159 // segment)
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700160 nsecs_t twoBufferTime = 0;
161 nsecs_t doubleBufferedTime = 0;
162 nsecs_t tripleBufferedTime = 0;
David Sodmancbaf0832017-11-07 14:21:36 -0800163 };
164 mutable Mutex mBufferingStatsMutex;
165 std::unordered_map<std::string, BufferingStats> mBufferingStats;
166
David Sodman105b7dc2017-11-04 20:28:14 -0700167 // The composer sequence id is a monotonically increasing integer that we
168 // use to differentiate callbacks from different hardware composer
169 // instances. Each hardware composer instance gets a different sequence id.
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700170 int32_t mComposerSequenceId = 0;
chaviw291d88a2019-02-14 10:33:58 -0800171};
David Sodman105b7dc2017-11-04 20:28:14 -0700172
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700173class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700174 public PriorityDumper,
Alec Mouri4545a8a2019-08-08 20:05:32 -0700175 public ClientCache::ErasedRecipient,
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:
David Sodman105b7dc2017-11-04 20:28:14 -0700180 SurfaceFlingerBE& getBE() { return mBE; }
181 const SurfaceFlingerBE& getBE() const { return mBE; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800182
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800183 // This is the phase offset in nanoseconds of the software vsync event
184 // relative to the vsync event reported by HWComposer. The software vsync
185 // event is when SurfaceFlinger and Choreographer-based applications run each
186 // frame.
187 //
188 // This phase offset allows adjustment of the minimum latency from application
189 // wake-up time (by Choreographer) to the time at which the resulting window
190 // image is displayed. This value may be either positive (after the HW vsync)
191 // or negative (before the HW vsync). Setting it to 0 will result in a lower
192 // latency bound of two vsync periods because the app and SurfaceFlinger
193 // will run just after the HW vsync. Setting it to a positive number will
194 // result in the minimum latency being:
195 //
196 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
197 //
198 // Note that reducing this latency makes it more likely for the applications
199 // to not have their window content image ready in time. When this happens
200 // the latency will end up being an additional vsync period, and animations
201 // will hiccup. Therefore, this latency should be tuned somewhat
202 // conservatively (or at least with awareness of the trade-off being made).
203 static int64_t vsyncPhaseOffsetNs;
204 static int64_t sfVsyncPhaseOffsetNs;
205
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800206 // If fences from sync Framework are supported.
207 static bool hasSyncFramework;
208
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700209 // The offset in nanoseconds to use when DispSync timestamps present fence
210 // signaling time.
211 static int64_t dispSyncPresentTimeOffset;
212
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700213 // Some hardware can do RGB->YUV conversion more efficiently in hardware
214 // controlled by HWC than in hardware controlled by the video encoder.
215 // This instruct VirtualDisplaySurface to use HWC for such conversion on
216 // GL composition.
217 static bool useHwcForRgbToYuv;
218
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800219 // Maximum dimension supported by HWC for virtual display.
220 // Equal to min(max_height, max_width).
221 static uint64_t maxVirtualDisplaySize;
222
Fabien Sanglard1971b632017-03-10 14:50:03 -0800223 // Controls the number of buffers SurfaceFlinger will allocate for use in
224 // FramebufferSurface
225 static int64_t maxFrameBufferAcquiredBuffers;
226
Peiyong Lin13effd12018-07-24 17:01:47 -0700227 // Indicate if a device has wide color gamut display. This is typically
228 // found on devices with wide color gamut (e.g. Display-P3) display.
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600229 static bool hasWideColorDisplay;
230
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700231 static int primaryDisplayOrientation;
232
Peiyong Lin13effd12018-07-24 17:01:47 -0700233 // Indicate if device wants color management on its display.
234 static bool useColorManagement;
235
Peiyong Linb3839ad2018-09-05 15:37:19 -0700236 static bool useContextPriority;
237
Peiyong Lin0256f722018-08-31 15:45:10 -0700238 // The data space and pixel format that SurfaceFlinger expects hardware composer
239 // to composite efficiently. Meaning under most scenarios, hardware composer
240 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700241 static ui::Dataspace defaultCompositionDataspace;
242 static ui::PixelFormat defaultCompositionPixelFormat;
243
244 // The data space and pixel format that SurfaceFlinger expects hardware composer
245 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
246 // hardware composer will accept layers with the data space and pixel format.
247 static ui::Dataspace wideColorGamutCompositionDataspace;
248 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700249
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700250 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700251 return "SurfaceFlinger";
252 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800253
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800254 struct SkipInitializationTag {};
255 static constexpr SkipInitializationTag SkipInitialization;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700256 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
257 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800258
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700259 // must be called before clients can connect
260 void init() ANDROID_API;
261
262 // starts SurfaceFlinger main loop in the current thread
263 void run() ANDROID_API;
264
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700265 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700266 status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800267
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700268 // post a synchronous message to the main thread
Vishnu Nair8406fd72019-07-30 11:29:31 -0700269 status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0)
270 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800271
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700272 // force full composition on all displays
273 void repaintEverything();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800274
Lloyd Pique90c115d2018-09-18 21:39:42 -0700275 surfaceflinger::Factory& getFactory() { return mFactory; }
276
Lloyd Pique70d91362018-10-18 16:02:55 -0700277 // The CompositionEngine encapsulates all composition related interfaces and actions.
278 compositionengine::CompositionEngine& getCompositionEngine() const;
279
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700280 // returns the default Display
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800281 sp<const DisplayDevice> getDefaultDisplayDevice() {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700282 Mutex::Autolock _l(mStateLock);
283 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700284 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700285
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 Agopian86303202012-07-24 22:46:10 -0700293 // enable/disable h/w composer event
294 // TODO: this should be made accessible only to EventThread
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800295 void setPrimaryVsyncEnabled(bool enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700296
Ady Abraham9ba25122019-06-03 17:10:55 -0700297 // main thread function to enable/disable h/w composer event
298 void setPrimaryVsyncEnabledInternal(bool enabled);
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700299 void setVsyncEnabledInHWC(DisplayId displayId, HWC2::Vsync enabled);
Ady Abraham9ba25122019-06-03 17:10:55 -0700300
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700301 // called on the main thread by MessageQueue when an internal message
302 // is received
303 // TODO: this should be made accessible only to MessageQueue
304 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700305
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700306 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700307
Robert Carr0d480722017-01-10 16:42:54 -0800308 bool authenticateSurfaceTextureLocked(
309 const sp<IGraphicBufferProducer>& bufferProducer) const;
310
Dominik Laskowski75848362019-11-11 17:57:20 -0800311 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700312 void onLayerDestroyed(Layer*);
Robert Carr2e102c92018-10-23 12:11:15 -0700313
Marissa Walle2ffb422018-10-12 11:33:52 -0700314 TransactionCompletedThread& getTransactionCompletedThread() {
315 return mTransactionCompletedThread;
316 }
317
Robert Carrc0df3122019-04-11 13:18:21 -0700318 sp<Layer> fromHandle(const sp<IBinder>& handle) REQUIRES(mStateLock);
319
Alec Mouri4545a8a2019-08-08 20:05:32 -0700320 // Inherit from ClientCache::ErasedRecipient
321 void bufferErased(const client_cache_t& clientCacheId) override;
322
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700323private:
David Sodman0c69cad2017-08-21 12:12:51 -0700324 friend class BufferLayer;
Marissa Wallfd668622018-05-10 10:21:13 -0700325 friend class BufferQueueLayer;
Marissa Wall61c58622018-07-18 10:12:20 -0700326 friend class BufferStateLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700327 friend class Client;
328 friend class Layer;
Dan Stozab9b08832014-03-13 11:55:57 -0700329 friend class MonitoredProducer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700330 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800331 friend class RegionSamplingThread;
Nataniel Borges2b796da2019-02-15 13:32:18 -0800332 friend class SurfaceTracing;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800333
Lloyd Piquef58625d2017-12-19 13:22:33 -0800334 // For unit tests
335 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700336 friend class TransactionApplicationTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800337
Jamie Gennis6547ff42013-07-16 20:12:42 -0700338 // This value is specified in number of frames. Log frame stats at most
339 // every half hour.
340 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
341
Dan Stoza7d89d062015-04-30 13:29:25 -0700342 static const size_t MAX_LAYERS = 4096;
Nataniel Borges2b796da2019-02-15 13:32:18 -0800343 static const int MAX_TRACING_MEMORY = 100 * 1024 * 1024; // 100MB
Dan Stoza7d89d062015-04-30 13:29:25 -0700344
Lloyd Pique58e24a32019-08-01 15:50:14 -0700345protected:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700346 // We're reference counted, never destroy SurfaceFlinger directly
347 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800348
Lloyd Pique58e24a32019-08-01 15:50:14 -0700349private:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700350 /* ------------------------------------------------------------------------
351 * Internal data structures
352 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800353
Robert Carr2047fae2016-11-28 14:09:09 -0800354 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800355 public:
chaviwfd462612018-05-31 16:11:27 -0700356 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700357 State& operator=(const State& other) {
358 // We explicitly don't copy stateSet so that, e.g., mDrawingState
359 // always uses the Drawing StateSet.
360 layersSortedByZ = other.layersSortedByZ;
361 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700362 colorMatrixChanged = other.colorMatrixChanged;
363 if (colorMatrixChanged) {
364 colorMatrix = other.colorMatrix;
365 }
Dan Stoza412903f2017-04-27 13:42:17 -0700366 return *this;
367 }
368
369 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700370 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700371 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800372
Chia-I Wu28f320b2018-05-03 11:02:56 -0700373 bool colorMatrixChanged = true;
374 mat4 colorMatrix;
375
Dan Stoza412903f2017-04-27 13:42:17 -0700376 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
377 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800378 };
379
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700380 /* ------------------------------------------------------------------------
381 * IBinder interface
382 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800383 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
384 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Robert Carr14167e02019-02-13 13:50:55 -0800385 bool callingThreadHasUnscopedSurfaceFlingerAccess() EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800386
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700387 /* ------------------------------------------------------------------------
388 * ISurfaceComposer interface
389 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800390 sp<ISurfaceComposerClient> createConnection() override;
391 sp<IBinder> createDisplay(const String8& displayName, bool secure) override;
392 void destroyDisplay(const sp<IBinder>& displayToken) override;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800393 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override;
394 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800395 void setTransactionState(const Vector<ComposerState>& state,
396 const Vector<DisplayState>& displays, uint32_t flags,
397 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -0800398 const InputWindowCommands& inputWindowCommands,
Marissa Wall947d34e2019-03-29 14:03:53 -0700399 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
Valerie Hau9dab9732019-08-20 09:29:25 -0700400 bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700401 const std::vector<ListenerCallbacks>& listenerCallbacks) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800402 void bootFinished() override;
403 bool authenticateSurfaceTexture(
404 const sp<IGraphicBufferProducer>& bufferProducer) const override;
405 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override;
406 sp<IDisplayEventConnection> createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700407 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp,
408 ISurfaceComposer::ConfigChanged configChanged =
409 ISurfaceComposer::eConfigChangedSuppress) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800410 status_t captureScreen(const sp<IBinder>& displayToken, sp<GraphicBuffer>* outBuffer,
Robert Carr108b2c72019-04-02 16:32:58 -0700411 bool& outCapturedSecureLayers, const ui::Dataspace reqDataspace,
412 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
413 uint32_t reqWidth, uint32_t reqHeight,
414 bool useIdentityTransform, ISurfaceComposer::Rotation rotation, bool captureSecureLayers) override;
chaviw93df2ea2019-04-30 16:45:12 -0700415 status_t captureScreen(uint64_t displayOrLayerStack, ui::Dataspace* outDataspace,
416 sp<GraphicBuffer>* outBuffer) override;
Robert Carr866455f2019-04-02 16:28:26 -0700417 status_t captureLayers(
418 const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
419 const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat,
420 const Rect& sourceCrop,
421 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& exclude,
422 float frameScale, bool childrenOnly) override;
Robert Carr108b2c72019-04-02 16:32:58 -0700423
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800424 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
425 status_t getDisplayConfigs(const sp<IBinder>& displayToken,
Dominik Laskowski22488f62019-03-28 09:53:04 -0700426 Vector<DisplayInfo>* configs) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800427 int getActiveConfig(const sp<IBinder>& displayToken) override;
428 status_t getDisplayColorModes(const sp<IBinder>& displayToken,
429 Vector<ui::ColorMode>* configs) override;
Daniel Solomon42d04562019-01-20 21:03:19 -0800430 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken,
431 ui::DisplayPrimaries &primaries);
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800432 ui::ColorMode getActiveColorMode(const sp<IBinder>& displayToken) override;
433 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode) override;
434 void setPowerMode(const sp<IBinder>& displayToken, int mode) override;
435 status_t setActiveConfig(const sp<IBinder>& displayToken, int id) override;
436 status_t clearAnimationFrameStats() override;
437 status_t getAnimationFrameStats(FrameStats* outStats) const override;
438 status_t getHdrCapabilities(const sp<IBinder>& displayToken,
439 HdrCapabilities* outCapabilities) const override;
440 status_t enableVSyncInjections(bool enable) override;
441 status_t injectVSync(nsecs_t when) override;
442 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const override;
443 status_t getColorManagement(bool* outGetColorManagement) const override;
Peiyong Linc6780972018-10-28 15:24:08 -0700444 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
445 ui::Dataspace* outWideColorGamutDataspace,
446 ui::PixelFormat* outWideColorGamutPixelFormat) const override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800447 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
448 ui::PixelFormat* outFormat,
449 ui::Dataspace* outDataspace,
450 uint8_t* outComponentMask) const override;
451 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
452 uint8_t componentMask,
453 uint64_t maxFrames) const override;
454 status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
455 uint64_t timestamp,
456 DisplayedFrameStats* outStats) const override;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800457 status_t getProtectedContentSupport(bool* outSupported) const override;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800458 status_t isWideColorDisplay(const sp<IBinder>& displayToken,
459 bool* outIsWideColorDisplay) const override;
Dan Stoza84ab9372018-12-17 15:27:57 -0800460 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
461 const sp<IRegionSamplingListener>& listener) override;
462 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override;
Ady Abraham838de062019-02-04 10:24:03 -0800463 status_t setAllowedDisplayConfigs(const sp<IBinder>& displayToken,
464 const std::vector<int32_t>& allowedConfigs) override;
Ady Abrahamd9b3ea62019-02-26 14:08:03 -0800465 status_t getAllowedDisplayConfigs(const sp<IBinder>& displayToken,
466 std::vector<int32_t>* outAllowedConfigs) override;
Dan Gittik57e63c52019-01-18 16:37:54 +0000467 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
468 bool* outSupport) const override;
469 status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) const override;
Ady Abraham8532d012019-05-08 14:50:56 -0700470 status_t notifyPowerHint(int32_t hintId) override;
Vishnu Nairb13bb952019-11-15 10:24:08 -0800471 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
472 float lightPosY, float lightPosZ, float lightRadius) override;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700473 /* ------------------------------------------------------------------------
474 * DeathRecipient interface
475 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800476 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800477
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700478 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700479 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700480 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800481 void onFirstRef() override;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800482
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700483 /* ------------------------------------------------------------------------
Steven Thomasb02664d2017-07-26 18:48:28 -0700484 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700485 */
Ady Abraham7159f572019-10-11 11:10:18 -0700486 void onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, int64_t timestamp,
487 std::optional<hwc2_vsync_period_t> vsyncPeriod) override;
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700488 void onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -0800489 HWC2::Connection connection) override;
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700490 void onRefreshReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId) override;
Ady Abraham7159f572019-10-11 11:10:18 -0700491 void onVsyncPeriodTimingChangedReceived(
492 int32_t sequenceId, hwc2_display_t display,
493 const hwc_vsync_period_change_timeline_t& updatedTimeline) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700494
495 /* ------------------------------------------------------------------------
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800496 * ISchedulerCallback
Ady Abraham2139f732019-11-13 18:56:40 -0800497 */
498 void changeRefreshRate(const Scheduler::RefreshRate&, Scheduler::ConfigEvent) override;
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800499 // force full composition on all displays without resetting the scheduler idle timer.
500 void repaintEverythingForHWC() override;
Ady Abraham2139f732019-11-13 18:56:40 -0800501 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700502 * Message handling
503 */
504 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700505 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700506 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700507 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700508 void signalLayerUpdate();
509 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800510
Ady Abraham2139f732019-11-13 18:56:40 -0800511 using RefreshRate = scheduler::RefreshRateConfigs::RefreshRate;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700512
Ady Abraham03b02dd2019-03-21 15:40:11 -0700513 struct ActiveConfigInfo {
Ady Abraham2139f732019-11-13 18:56:40 -0800514 HwcConfigIndexType configId;
Josh Gaoa0520712019-11-14 15:38:04 -0800515 Scheduler::ConfigEvent event = Scheduler::ConfigEvent::None;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700516
517 bool operator!=(const ActiveConfigInfo& other) const {
Ady Abraham2139f732019-11-13 18:56:40 -0800518 return configId != other.configId || event != other.event;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700519 }
520 };
521
Andy McFadden13a082e2012-08-24 10:16:42 -0700522 // called on the main thread in response to initializeDisplays()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800523 void onInitializeDisplays() REQUIRES(mStateLock);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800524 // Sets the desired active config bit. It obtains the lock, and sets mDesiredActiveConfig.
Ady Abraham03b02dd2019-03-21 15:40:11 -0700525 void setDesiredActiveConfig(const ActiveConfigInfo& info) REQUIRES(mStateLock);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800526 // Once HWC has returned the present fence, this sets the active config and a new refresh
Ady Abraham53852a52019-05-28 18:07:44 -0700527 // rate in SF.
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800528 void setActiveConfigInternal() REQUIRES(mStateLock);
529 // Active config is updated on INVALIDATE call in a state machine-like manner. When the
Ady Abrahamb838aed2019-02-12 15:30:16 -0800530 // desired config was set, HWC needs to update the panel on the next refresh, and when
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800531 // we receive the fence back, we know that the process was complete. It returns whether
Ady Abrahamb838aed2019-02-12 15:30:16 -0800532 // we need to wait for the next invalidate
Dominik Laskowski22488f62019-03-28 09:53:04 -0700533 bool performSetActiveConfig() REQUIRES(mStateLock);
Ady Abraham53852a52019-05-28 18:07:44 -0700534 // Called when active config is no longer is progress
535 void desiredActiveConfigChangeDone() REQUIRES(mStateLock);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700536 // called on the main thread in response to setPowerMode()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800537 void setPowerModeInternal(const sp<DisplayDevice>& display, int mode) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800538
Ady Abraham838de062019-02-04 10:24:03 -0800539 // called on the main thread in response to setAllowedDisplayConfigs()
Dominik Laskowski22488f62019-03-28 09:53:04 -0700540 void setAllowedDisplayConfigsInternal(const sp<DisplayDevice>& display,
541 const std::vector<int32_t>& allowedConfigs)
542 REQUIRES(mStateLock);
Ady Abraham838de062019-02-04 10:24:03 -0800543
Dan Stoza6b9454d2014-11-07 16:00:59 -0800544 // Returns whether the transaction actually modified any state
545 bool handleMessageTransaction();
546
547 // Returns whether a new buffer has been latched (see handlePageFlip())
548 bool handleMessageInvalidate();
549
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700550 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700551
Mathias Agopian87baae12012-07-31 12:38:26 -0700552 void handleTransaction(uint32_t transactionFlags);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800553 void handleTransactionLocked(uint32_t transactionFlags) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800554
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800555 void updateInputFlinger();
556 void updateInputWindowInfo();
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800557 void commitInputWindowCommands() REQUIRES(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700558 void setInputWindowsFinished();
Riley Andrews03414a12014-07-01 14:22:59 -0700559 void updateCursorAsync();
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700560 void initScheduler(DisplayId primaryDisplayId);
Riley Andrews03414a12014-07-01 14:22:59 -0700561
Dan Stoza6b9454d2014-11-07 16:00:59 -0800562 /* handlePageFlip - latch a new buffer if available and compute the dirty
563 * region. Returns whether a new buffer has been latched, i.e., whether it
564 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700565 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800566 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800567
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700568 /* ------------------------------------------------------------------------
569 * Transactions
570 */
Marissa Wall713b63f2018-10-17 15:42:43 -0700571 void applyTransactionState(const Vector<ComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800572 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -0800573 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -0700574 const int64_t desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -0700575 const client_cache_t& uncacheBuffer, const int64_t postTime,
576 bool privileged, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700577 const std::vector<ListenerCallbacks>& listenerCallbacks,
Valerie Hau9dab9732019-08-20 09:29:25 -0700578 bool isMainThread = false) REQUIRES(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700579 // Returns true if at least one transaction was flushed
Marissa Wall713b63f2018-10-17 15:42:43 -0700580 bool flushTransactionQueues();
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700581 // Returns true if there is at least one transaction that needs to be flushed
582 bool transactionFlushNeeded();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700583 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800584 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700585 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700586 uint32_t setTransactionFlags(uint32_t flags);
Ana Krulec7ecce8c2018-10-12 13:44:41 -0700587 uint32_t setTransactionFlags(uint32_t flags, Scheduler::TransactionStart transactionStart);
Nataniel Borges2b796da2019-02-15 13:32:18 -0800588 void commitTransaction() REQUIRES(mStateLock);
chaviw74d90ad2019-04-26 14:45:26 -0700589 void commitOffscreenLayers();
Marissa Wall17b4e452018-12-26 16:32:34 -0800590 bool transactionIsReadyToBeApplied(int64_t desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700591 bool useCachedExpectedPresentTime,
Marissa Wall17b4e452018-12-26 16:32:34 -0800592 const Vector<ComposerState>& states);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800593 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800594 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
595 REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800596
Lloyd Pique58e24a32019-08-01 15:50:14 -0700597protected:
598 virtual uint32_t setClientStateLocked(
599 const ComposerState& composerState, int64_t desiredPresentTime, int64_t postTime,
600 bool privileged,
601 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks)
602 REQUIRES(mStateLock);
603 virtual void commitTransactionLocked();
604
605private:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700606 /* ------------------------------------------------------------------------
607 * Layer management
608 */
Marissa Wall2d814fb2019-04-09 18:52:57 +0000609 status_t createLayer(const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
610 PixelFormat format, uint32_t flags, LayerMetadata metadata,
Robert Carrc0df3122019-04-11 13:18:21 -0700611 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
Valerie Hau1acd6962019-10-28 16:35:48 -0700612 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer = nullptr,
613 uint32_t* outTransformHint = nullptr);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800614
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700615 status_t createBufferQueueLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800616 uint32_t h, uint32_t flags, LayerMetadata metadata,
617 PixelFormat& format, sp<IBinder>* outHandle,
618 sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800619
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700620 status_t createBufferStateLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800621 uint32_t h, uint32_t flags, LayerMetadata metadata,
Valerie Hau1acd6962019-10-28 16:35:48 -0700622 sp<IBinder>* outHandle, uint32_t* outTransformHint,
623 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700624
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700625 status_t createColorLayer(const sp<Client>& client, std::string name, uint32_t w, uint32_t h,
Evan Roskya1f1e152019-01-24 16:17:46 -0800626 uint32_t flags, LayerMetadata metadata, sp<IBinder>* outHandle,
627 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700628
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700629 status_t createContainerLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800630 uint32_t h, uint32_t flags, LayerMetadata metadata,
631 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Robert Carr6b3f6c52018-08-13 13:05:17 -0700632
chaviwfe94a222019-08-21 13:52:59 -0700633 status_t mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
634 sp<IBinder>* outHandle);
635
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700636 std::string getUniqueLayerName(const char* name);
Cody Northropbc755282017-03-31 12:00:08 -0600637
Rob Carr4bba3702018-10-08 21:53:30 +0000638 // called when all clients have released all their references to
639 // this layer meaning it is entirely safe to destroy all
640 // resources associated to this layer.
Robert Carr695d5282018-12-18 15:27:58 -0800641 void onHandleDestroyed(sp<Layer>& layer);
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800642 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700643
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700644 // add a layer to SurfaceFlinger
Robert Carrc0df3122019-04-11 13:18:21 -0700645 status_t addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
646 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
647 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
648 bool addToCurrentState);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700649
Vishnu Nair4351ad52019-02-11 14:13:02 -0800650 // Traverse through all the layers and compute and cache its bounds.
651 void computeLayerBounds();
652
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700653 /* ------------------------------------------------------------------------
654 * Boot animation, on/off animations and screen capture
655 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700656
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700657 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700658
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700659 using TraverseLayersFunction = std::function<void(const LayerVector::Visitor&)>;
660
chaviwa76b2712017-09-20 12:02:26 -0700661 void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000662 ANativeWindowBuffer* buffer, bool useIdentityTransform,
663 int* outSyncFd);
chaviwa76b2712017-09-20 12:02:26 -0700664 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700665 sp<GraphicBuffer>* outBuffer, const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -0700666 bool useIdentityTransform, bool& outCapturedSecureLayers);
Kevin DuBois7cbcc372019-02-25 14:53:28 -0800667 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Robert Carr108b2c72019-04-02 16:32:58 -0700668 const sp<GraphicBuffer>& buffer, bool useIdentityTransform,
669 bool& outCapturedSecureLayers);
chaviw93df2ea2019-04-30 16:45:12 -0700670 const sp<DisplayDevice> getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack);
chaviwa76b2712017-09-20 12:02:26 -0700671 status_t captureScreenImplLocked(const RenderArea& renderArea,
672 TraverseLayersFunction traverseLayers,
673 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Robert Carr108b2c72019-04-02 16:32:58 -0700674 bool forSystem, int* outSyncFd, bool& outCapturedSecureLayers);
chaviw0e3479f2018-09-10 16:49:30 -0700675 void traverseLayersInDisplay(const sp<const DisplayDevice>& display,
676 const LayerVector::Visitor& visitor);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700677
Lloyd Pique90c115d2018-09-18 21:39:42 -0700678 sp<StartPropertySetThread> mStartPropertySetThread;
Wei Wangb254fa32017-01-31 17:43:23 -0800679
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700680 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700681 * Properties
682 */
683 void readPersistentProperties();
684
685 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700686 * EGL
687 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700688 size_t getMaxTextureSize() const;
689 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700690
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700691 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700692 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700693 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700694 // called when starting, or restarting after system_server death
695 void initializeDisplays();
696
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700697 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) const {
698 Mutex::Autolock _l(mStateLock);
699 return getDisplayDeviceLocked(displayToken);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700700 }
701
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700702 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) {
703 Mutex::Autolock _l(mStateLock);
704 return getDisplayDeviceLocked(displayToken);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700705 }
706
707 // NOTE: can only be called from the main thread or with mStateLock held
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700708 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const {
709 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700710 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700711
712 // NOTE: can only be called from the main thread or with mStateLock held
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700713 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700714 const auto it = mDisplays.find(displayToken);
715 return it == mDisplays.end() ? nullptr : it->second;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700716 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700717
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700718 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700719 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700720 }
721
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700722 sp<DisplayDevice> getDefaultDisplayDeviceLocked() {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800723 if (const auto token = getInternalDisplayTokenLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700724 return getDisplayDeviceLocked(token);
725 }
726 return nullptr;
Michael Wright28f24d02016-07-12 13:30:53 -0700727 }
728
Mathias Agopian87baae12012-07-31 12:38:26 -0700729 // mark a region of a layer stack dirty. this updates the dirty
730 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700731 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700732
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700733 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700734 * H/W composer
735 */
736
Lloyd Pique441d5042018-10-18 16:49:51 -0700737 // The current hardware composer interface.
738 //
739 // The following thread safety rules apply when accessing mHwc, either
740 // directly or via getHwComposer():
741 //
742 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
743 // only when switching into and out of vr. Recreating mHwc must only be
744 // done on the main thread.
745 //
746 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
747 // mStateLock.
748 //
749 // 3. When accessing mHwc on a thread other than the main thread, we always
750 // need to acquire mStateLock. This is because the main thread could be
751 // in the process of destroying the current mHwc instance.
752 //
753 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
754 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
755 // destroy it, so it's always safe to access mHwc from any thread without
756 // acquiring mStateLock.
757 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700758
Mathias Agopian888c8222012-08-04 21:10:38 -0700759 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700760 * Compositing
761 */
762 void invalidateHwcGeometry();
Mathias Agopiancd60f992012-08-16 16:28:27 -0700763
David Sodman2b406362017-12-15 13:33:47 -0800764 void postComposition();
Dominik Laskowskif654d572018-12-20 11:03:06 -0800765 void getCompositorTiming(CompositorTiming* compositorTiming);
Ana Krulece588e312018-09-18 12:32:24 -0700766 void updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
767 std::shared_ptr<FenceTime>& presentFenceTime);
768 void setCompositorTimingSnapped(const DisplayStatInfo& stats,
769 nsecs_t compositeToPresentLatency);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600770
David Sodmanfa9b2af2017-12-24 13:28:59 -0800771 void postFrame();
Mathias Agopian4da75192010-08-10 17:19:56 -0700772
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700773 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700774 * Display management
775 */
Lloyd Pique542307f2018-10-19 13:24:08 -0700776 sp<DisplayDevice> setupNewDisplayDeviceInternal(
777 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
778 const DisplayDeviceState& state,
779 const sp<compositionengine::DisplaySurface>& dispSurface,
780 const sp<IGraphicBufferProducer>& producer);
Lloyd Pique347200f2017-12-14 17:00:15 -0800781 void processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -0800782 void processDisplayHotplugEventsLocked();
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700783
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800784 void dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800785
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700786 /* ------------------------------------------------------------------------
787 * VSync
788 */
Dominik Laskowski83b88212018-12-11 13:34:06 -0800789 nsecs_t getVsyncPeriod() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700790
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800791 // Sets the refresh rate by switching active configs, if they are available for
Ana Krulec7d1d6832018-12-27 11:10:09 -0800792 // the desired refresh rate.
Ady Abraham2139f732019-11-13 18:56:40 -0800793 void changeRefreshRateLocked(const RefreshRate&, Scheduler::ConfigEvent event)
794 REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700795
Ady Abraham2139f732019-11-13 18:56:40 -0800796 bool isDisplayConfigAllowed(HwcConfigIndexType configId) const REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700797
Ady Abraham11579302019-09-19 12:35:58 -0700798 bool previousFrameMissed(int graceTimeMs = 0);
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700799
800 // Populates the expected present time for this frame. For negative offsets, performs a
801 // correction using the predicted vsync for the next frame instead.
802 void populateExpectedPresentTime();
803
Dominik Laskowskic2867142019-01-21 11:33:38 -0800804 /*
805 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700806 */
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800807 sp<IBinder> getPhysicalDisplayTokenLocked(DisplayId displayId) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700808 const auto it = mPhysicalDisplayTokens.find(displayId);
809 return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
810 }
811
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800812 std::optional<DisplayId> getPhysicalDisplayIdLocked(const sp<IBinder>& displayToken) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700813 for (const auto& [id, token] : mPhysicalDisplayTokens) {
814 if (token == displayToken) {
815 return id;
816 }
817 }
818 return {};
819 }
820
821 // TODO(b/74619554): Remove special cases for primary display.
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800822 sp<IBinder> getInternalDisplayTokenLocked() const {
823 const auto displayId = getInternalDisplayIdLocked();
824 return displayId ? getPhysicalDisplayTokenLocked(*displayId) : nullptr;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700825 }
826
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800827 std::optional<DisplayId> getInternalDisplayIdLocked() const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700828 const auto hwcDisplayId = getHwComposer().getInternalHwcDisplayId();
829 return hwcDisplayId ? getHwComposer().toPhysicalDisplayId(*hwcDisplayId) : std::nullopt;
830 }
831
Dominik Laskowskic2867142019-01-21 11:33:38 -0800832 /*
833 * Debugging & dumpsys
834 */
Dominik Laskowskic2867142019-01-21 11:33:38 -0800835 using DumpArgs = Vector<String16>;
836 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
837
838 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
839 static Dumper dumper(F&& dump) {
840 using namespace std::placeholders;
841 return std::bind(std::forward<F>(dump), _3);
842 }
843
844 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
845 Dumper dumper(F dump) {
846 using namespace std::placeholders;
847 return std::bind(dump, this, _3);
848 }
849
850 template <typename F>
851 Dumper argsDumper(F dump) {
852 using namespace std::placeholders;
853 return std::bind(dump, this, _1, _3);
854 }
855
856 template <typename F>
857 Dumper protoDumper(F dump) {
858 using namespace std::placeholders;
859 return std::bind(dump, this, _1, _2, _3);
860 }
861
862 void dumpAllLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
863
864 void appendSfConfigString(std::string& result) const;
865 void listLayersLocked(std::string& result) const;
866 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
867 void clearStatsLocked(const DumpArgs& args, std::string& result);
868 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Jamie Gennis6547ff42013-07-16 20:12:42 -0700869 void logFrameStats();
870
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800871 void dumpVSync(std::string& result) const REQUIRES(mStateLock);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800872 void dumpStaticScreenStats(std::string& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700873 // Not const because each Layer needs to query Fences and cache timestamps.
Yiwei Zhang5434a782018-12-05 18:06:32 -0800874 void dumpFrameEventsLocked(std::string& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800875
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700876 void recordBufferingStats(const std::string& layerName,
877 std::vector<OccupancyTracker::Segment>&& history);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800878 void dumpBufferingStats(std::string& result) const;
879 void dumpDisplayIdentificationData(std::string& result) const;
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700880 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800881 void dumpWideColorInfo(std::string& result) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700882 LayersProto dumpDrawingStateProto(uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Vishnu Nair0f085c62019-08-30 08:49:12 -0700883 void dumpOffscreenLayersProto(LayersProto& layersProto,
884 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700885 LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)
886 EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -0700887 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Nataniel Borges2b796da2019-02-15 13:32:18 -0800888 void withTracingLock(std::function<void()> operation) REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -0700889
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800890 bool isLayerTripleBufferingDisabled() const {
891 return this->mLayerTripleBufferingDisabled;
892 }
Dominik Laskowskic2867142019-01-21 11:33:38 -0800893
894 status_t doDump(int fd, const DumpArgs& args, bool asProto);
895
Nataniel Borges8e7dc722019-02-28 15:10:28 -0800896 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -0800897
898 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
899 return doDump(fd, args, asProto);
900 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800901
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800902 /* ------------------------------------------------------------------------
903 * VrFlinger
904 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700905 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800906
Steven Thomas050b2c82017-03-06 11:45:16 -0800907 // Check to see if we should handoff to vr flinger.
908 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800909
Chia-I Wu28f320b2018-05-03 11:02:56 -0700910 void updateColorMatrixLocked();
911
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700912 /* ------------------------------------------------------------------------
913 * Attributes
914 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800915
Lloyd Pique90c115d2018-09-18 21:39:42 -0700916 surfaceflinger::Factory& mFactory;
917
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700918 // access must be protected by mStateLock
919 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700920 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700921 std::atomic<int32_t> mTransactionFlags = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700922 Condition mTransactionCV;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700923 bool mTransactionPending = false;
924 bool mAnimTransactionPending = false;
925 SortedVector<sp<Layer>> mLayersPendingRemoval;
926 bool mTraversalNeededMainThread = false;
Dan Stoza101d8dc2018-02-27 15:42:25 -0800927
Nataniel Borges2b796da2019-02-15 13:32:18 -0800928 // guards access to the mDrawing state if tracing is enabled.
929 mutable std::mutex mDrawingStateLock;
930
Chia-I Wu28f320b2018-05-03 11:02:56 -0700931 // global color transform states
932 Daltonizer mDaltonizer;
933 float mGlobalSaturationFactor = 1.0f;
934 mat4 mClientColorMatrix;
935
Dan Stoza101d8dc2018-02-27 15:42:25 -0800936 // Can't be unordered_set because wp<> isn't hashable
937 std::set<wp<IBinder>> mGraphicBufferProducerList;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700938 size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800939
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700940 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700941 bool mLayersRemoved = false;
942 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700943
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700944 std::atomic<bool> mRepaintEverything = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700945
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800946 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700947 const nsecs_t mBootTime = systemTime();
948 bool mGpuToCpuSupported = false;
Mathias Agopian3094df32012-06-18 18:06:45 -0700949
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700950 // Can only accessed from the main thread, these members
951 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700952 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700953 bool mVisibleRegionsDirty = false;
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800954 // Set during transaction commit stage to track if the input info for a layer has changed.
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700955 bool mInputInfoChanged = false;
956 bool mGeometryInvalid = false;
957 bool mAnimCompositionPending = false;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800958 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800959 // Tracks layers that need to update a display's dirty region.
960 std::vector<sp<Layer>> mLayersPendingRefresh;
Ady Abrahambe0f9482019-04-24 15:41:53 -0700961 std::array<sp<Fence>, 2> mPreviousPresentFences = {Fence::NO_FENCE, Fence::NO_FENCE};
Alec Mouricc0fc602019-02-26 21:45:19 -0800962 // True if in the previous frame at least one layer was composed via the GPU.
Dan Stoza05dacfb2016-07-01 13:33:38 -0700963 bool mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -0800964 // True if in the previous frame at least one layer was composed via HW Composer.
965 // Note that it is possible for a frame to be composed via both client and device
966 // composition, for example in the case of overlays.
967 bool mHadDeviceComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700968
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800969 enum class BootStage {
970 BOOTLOADER,
971 BOOTANIMATION,
972 FINISHED,
973 };
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700974 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800975
Lloyd Piqueba04e622017-12-14 17:11:26 -0800976 struct HotplugEvent {
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700977 hwc2_display_t hwcDisplayId;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800978 HWC2::Connection connection = HWC2::Connection::Invalid;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800979 };
980 // protected by mStateLock
981 std::vector<HotplugEvent> mPendingHotplugEvents;
982
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700983 // this may only be written from the main thread with mStateLock held
984 // it may be read from other threads with mStateLock held
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700985 std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800986 std::unordered_map<DisplayId, sp<IBinder>> mPhysicalDisplayTokens;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700987
Robert Carrc0df3122019-04-11 13:18:21 -0700988 // protected by mStateLock
989 std::unordered_map<BBinder*, wp<Layer>> mLayersByLocalBinderToken;
990
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700991 // don't use a lock for these, we don't care
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700992 int mDebugRegion = 0;
993 bool mDebugDisableHWC = false;
994 bool mDebugDisableTransformHint = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700995 volatile nsecs_t mDebugInTransaction = 0;
996 bool mForceFullDamage = false;
Dan Stozac5da2712016-07-20 15:38:12 -0700997 bool mPropagateBackpressure = true;
Ady Abrahamadb9a992019-09-19 21:21:55 +0000998 bool mPropagateBackpressureClientComposition = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700999 std::unique_ptr<SurfaceInterceptor> mInterceptor;
1000 SurfaceTracing mTracing{*this};
Nataniel Borges2b796da2019-02-15 13:32:18 -08001001 bool mTracingEnabled = false;
1002 bool mTracingEnabledChanged GUARDED_BY(mStateLock) = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001003 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001004 const std::unique_ptr<FrameTracer> mFrameTracer;
Fabien Sanglard642b23d2017-02-09 12:29:39 -08001005 bool mUseHwcVirtualDisplays = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001006 std::atomic<uint32_t> mFrameMissedCount = 0;
1007 std::atomic<uint32_t> mHwcFrameMissedCount = 0;
1008 std::atomic<uint32_t> mGpuFrameMissedCount = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001009
Marissa Walle2ffb422018-10-12 11:33:52 -07001010 TransactionCompletedThread mTransactionCompletedThread;
1011
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08001012 // Restrict layers to use two buffers in their bufferqueues.
1013 bool mLayerTripleBufferingDisabled = false;
1014
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001015 // these are thread safe
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001016 std::unique_ptr<MessageQueue> mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001017 FrameTracker mAnimFrameTracker;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001018
1019 // protected by mDestroyedLayerLock;
1020 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -08001021 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001022
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001023 nsecs_t mRefreshStartTime = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001024
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001025 std::atomic<bool> mRefreshPending = false;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001026
Dan Stoza436ccf32018-06-21 12:10:12 -07001027 // We maintain a pool of pre-generated texture names to hand out to avoid
1028 // layer creation needing to run on the main thread (which it would
1029 // otherwise need to do to access RenderEngine).
1030 std::mutex mTexturePoolMutex;
1031 uint32_t mTexturePoolSize = 0;
1032 std::vector<uint32_t> mTexturePool;
1033
Marissa Wall713b63f2018-10-17 15:42:43 -07001034 struct TransactionState {
1035 TransactionState(const Vector<ComposerState>& composerStates,
Marissa Wall17b4e452018-12-26 16:32:34 -08001036 const Vector<DisplayState>& displayStates, uint32_t transactionFlags,
Marissa Wall947d34e2019-03-29 14:03:53 -07001037 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
Valerie Hau9dab9732019-08-20 09:29:25 -07001038 int64_t postTime, bool privileged, bool hasListenerCallbacks,
1039 std::vector<ListenerCallbacks> listenerCallbacks)
Marissa Wall17b4e452018-12-26 16:32:34 -08001040 : states(composerStates),
1041 displays(displayStates),
1042 flags(transactionFlags),
Valerie Haubc6ddb12019-03-08 11:10:15 -08001043 desiredPresentTime(desiredPresentTime),
Marissa Wall78b72202019-03-15 14:58:34 -07001044 buffer(uncacheBuffer),
Valerie Haubc6ddb12019-03-08 11:10:15 -08001045 postTime(postTime),
Valerie Hau9dab9732019-08-20 09:29:25 -07001046 privileged(privileged),
1047 hasListenerCallbacks(hasListenerCallbacks),
1048 listenerCallbacks(listenerCallbacks) {}
Marissa Wall713b63f2018-10-17 15:42:43 -07001049
1050 Vector<ComposerState> states;
1051 Vector<DisplayState> displays;
1052 uint32_t flags;
Valerie Haubc6ddb12019-03-08 11:10:15 -08001053 const int64_t desiredPresentTime;
Marissa Wall947d34e2019-03-29 14:03:53 -07001054 client_cache_t buffer;
Valerie Haubc6ddb12019-03-08 11:10:15 -08001055 const int64_t postTime;
Robert Carr14167e02019-02-13 13:50:55 -08001056 bool privileged;
Valerie Hau9dab9732019-08-20 09:29:25 -07001057 bool hasListenerCallbacks;
1058 std::vector<ListenerCallbacks> listenerCallbacks;
Marissa Wall713b63f2018-10-17 15:42:43 -07001059 };
Valerie Hau5de3ad22019-08-20 07:47:43 -07001060 std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash> mTransactionQueues;
Marissa Wall713b63f2018-10-17 15:42:43 -07001061
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001062 /* ------------------------------------------------------------------------
1063 * Feature prototyping
1064 */
1065
Dan Stozab90cf072015-03-05 11:05:59 -08001066 // Static screen stats
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001067 bool mHasPoweredOff = false;
Dan Stozae77c7662016-05-13 11:37:28 -07001068
chaviweadf0d42019-08-12 13:28:29 -07001069 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001070
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07001071 // Verify that transaction is being called by an approved process:
1072 // either AID_GRAPHICS or AID_SYSTEM.
1073 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001074
Steven Morelanda904bb92019-07-02 17:37:23 -07001075 // to linkToDeath
1076 sp<IBinder> mWindowManager;
1077
Steven Thomasb02664d2017-07-26 18:48:28 -07001078 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001079 std::atomic<bool> mVrFlingerRequestsDisplay = false;
Steven Thomas050b2c82017-03-06 11:45:16 -08001080 static bool useVrFlinger;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001081 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001082
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001083 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001084
Peiyong Lina3ea5592019-02-10 14:45:00 -08001085 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1086 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1087 // 2. be one of the supported color modes returned by hardware composer, otherwise
1088 // it will not be respected.
1089 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1090 // is not set to 1.
1091 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1092 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1093
Peiyong Lin9d846a52018-11-05 13:18:20 -08001094 ui::Dataspace mDefaultCompositionDataspace;
1095 ui::Dataspace mWideColorGamutCompositionDataspace;
Yichi Chenda901bf2019-06-28 14:58:27 +08001096 ui::Dataspace mColorSpaceAgnosticDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001097
David Sodman105b7dc2017-11-04 20:28:14 -07001098 SurfaceFlingerBE mBE;
Lloyd Pique70d91362018-10-18 16:02:55 -07001099 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Ana Krulec98b5b242018-08-10 15:03:23 -07001100
Ana Krulecb43429d2019-01-09 14:28:51 -08001101 /* ------------------------------------------------------------------------
1102 * Scheduler
1103 */
Ana Krulec98b5b242018-08-10 15:03:23 -07001104 std::unique_ptr<Scheduler> mScheduler;
Dominik Laskowski98041832019-08-01 18:35:59 -07001105 scheduler::ConnectionHandle mAppConnectionHandle;
1106 scheduler::ConnectionHandle mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001107
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001108 // Stores phase offsets configured per refresh rate.
1109 const std::unique_ptr<scheduler::PhaseOffsets> mPhaseOffsets;
1110
1111 // Optional to defer construction until scheduler connections are created.
1112 std::optional<scheduler::VSyncModulator> mVSyncModulator;
1113
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001114 std::unique_ptr<scheduler::RefreshRateConfigs> mRefreshRateConfigs;
1115 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Ady Abraham1902d072019-03-01 17:18:59 -08001116
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001117 std::atomic<nsecs_t> mExpectedPresentTime = 0;
1118
Dominik Laskowski22488f62019-03-28 09:53:04 -07001119 // All configs are allowed if the set is empty.
Ady Abraham2139f732019-11-13 18:56:40 -08001120 using DisplayConfigs = std::set<HwcConfigIndexType>;
Dominik Laskowski22488f62019-03-28 09:53:04 -07001121 DisplayConfigs mAllowedDisplayConfigs GUARDED_BY(mStateLock);
Ady Abraham838de062019-02-04 10:24:03 -08001122
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001123 std::mutex mActiveConfigLock;
1124 // This bit is set once we start setting the config. We read from this bit during the
1125 // process. If at the end, this bit is different than mDesiredActiveConfig, we restart
1126 // the process.
1127 ActiveConfigInfo mUpcomingActiveConfig; // Always read and written on the main thread.
1128 // This bit can be set at any point in time when the system wants the new config.
1129 ActiveConfigInfo mDesiredActiveConfig GUARDED_BY(mActiveConfigLock);
1130
Ady Abrahamb838aed2019-02-12 15:30:16 -08001131 // below flags are set by main thread only
Ady Abraham50204dd2019-07-19 15:47:11 -07001132 TracedOrdinal<bool> mDesiredActiveConfigChanged
1133 GUARDED_BY(mActiveConfigLock) = {"DesiredActiveConfigChanged", false};
Ady Abrahamb838aed2019-02-12 15:30:16 -08001134 bool mCheckPendingFence = false;
1135
Kevin DuBois413287f2019-02-25 08:46:47 -08001136 bool mLumaSampling = true;
1137 sp<RegionSamplingThread> mRegionSamplingThread;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001138 ui::DisplayPrimaries mInternalDisplayPrimaries;
Kevin DuBois413287f2019-02-25 08:46:47 -08001139
Robert Carr720e5062018-07-30 17:45:14 -07001140 sp<IInputFlinger> mInputFlinger;
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001141 InputWindowCommands mPendingInputWindowCommands GUARDED_BY(mStateLock);
1142 // Should only be accessed by the main thread.
chaviw273171b2018-12-26 11:46:30 -08001143 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001144
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001145 struct SetInputWindowsListener : BnSetInputWindowsListener {
1146 explicit SetInputWindowsListener(sp<SurfaceFlinger> flinger)
1147 : mFlinger(std::move(flinger)) {}
1148
1149 void onSetInputWindowsFinished() override;
1150
1151 const sp<SurfaceFlinger> mFlinger;
1152 };
1153
1154 const sp<SetInputWindowsListener> mSetInputWindowsListener = new SetInputWindowsListener(this);
1155
chaviw95ef3c42019-02-14 10:55:09 -08001156 bool mPendingSyncInputWindows GUARDED_BY(mStateLock);
Peiyong Lin74ca2f42019-01-14 19:36:57 -08001157 Hwc2::impl::PowerAdvisor mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001158
Alec Mouri9519bf12019-11-15 16:54:44 -08001159 // This should only be accessed on the main thread.
1160 nsecs_t mFrameStartTime = 0;
1161
Ady Abraham03b02dd2019-03-21 15:40:11 -07001162 std::unique_ptr<RefreshRateOverlay> mRefreshRateOverlay;
Ady Abraham34392f72019-04-10 11:29:27 -07001163
1164 // Flag used to set override allowed display configs from backdoor
1165 bool mDebugDisplayConfigSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001166
1167 // A set of layers that have no parent so they are not drawn on screen.
1168 // Should only be accessed by the main thread.
1169 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1170 // be any issues with a raw pointer referencing an invalid object.
1171 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001172
Ady Abraham27c70212019-06-11 10:52:26 -07001173 // Flags to capture the state of Vsync in HWC
1174 HWC2::Vsync mHWCVsyncState = HWC2::Vsync::Disable;
1175 HWC2::Vsync mHWCVsyncPendingState = HWC2::Vsync::Disable;
Romain Guy0147a172017-06-01 13:53:56 -07001176};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001177
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001178} // namespace android