blob: abc03ec3f3f7b8f04be0c986204cdb63f50ce9b5 [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
17#ifndef ANDROID_SURFACE_FLINGER_H
18#define ANDROID_SURFACE_FLINGER_H
19
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080020#include <sys/types.h>
21
Mathias Agopian3f844832013-08-07 21:24:32 -070022/*
23 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
24 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070025
Dominik Laskowski83b88212018-12-11 13:34:06 -080026#include <android-base/thread_annotations.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>
Robert Carr4cdc58f2017-08-23 14:22:20 -070033#include <gui/LayerState.h>
Dan Stozae77c7662016-05-13 11:37:28 -070034#include <gui/OccupancyTracker.h>
Mathias Agopian86303202012-07-24 22:46:10 -070035#include <hardware/hwcomposer_defs.h>
chaviw291d88a2019-02-14 10:33:58 -080036#include <input/ISetInputWindowsListener.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080037#include <layerproto/LayerProtoHeader.h>
38#include <math/mat4.h>
Vishnu Nair35798872017-10-06 16:00:36 -070039#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070040#include <system/graphics.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080041#include <ui/FenceTime.h>
42#include <ui/PixelFormat.h>
43#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
Ady Abraham838de062019-02-04 10:24:03 -080050#include "AllowedDisplayConfigs.h"
Mathias Agopian921e6ac2012-07-23 23:11:29 -070051#include "Barrier.h"
Marissa Wallebc2c052019-01-16 19:16:55 -080052#include "BufferStateLayerCache.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070053#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080054#include "DisplayHardware/HWC2.h"
55#include "DisplayHardware/HWComposer.h"
56#include "Effects/Daltonizer.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080057#include "FrameTracker.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070058#include "LayerBE.h"
Yiwei Zhang7124ad32018-02-21 13:02:45 -080059#include "LayerStats.h"
Robert Carr2047fae2016-11-28 14:09:09 -080060#include "LayerVector.h"
Dan Stozaec460082018-12-17 15:35:09 -080061#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070062#include "Scheduler/DispSync.h"
63#include "Scheduler/EventThread.h"
64#include "Scheduler/MessageQueue.h"
Ana Krulec757f63a2019-01-25 10:46:18 -080065#include "Scheduler/PhaseOffsets.h"
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080066#include "Scheduler/RefreshRateConfigs.h"
Ana Krulecb43429d2019-01-09 14:28:51 -080067#include "Scheduler/RefreshRateStats.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070068#include "Scheduler/Scheduler.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070069#include "Scheduler/VSyncModulator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080070#include "SurfaceFlingerFactory.h"
71#include "SurfaceInterceptor.h"
72#include "SurfaceTracing.h"
73#include "TransactionCompletedThread.h"
Mathias Agopian86303202012-07-24 22:46:10 -070074
Dominik Laskowski83b88212018-12-11 13:34:06 -080075#include <atomic>
76#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080077#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -070078#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080079#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080080#include <mutex>
81#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070082#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070083#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070084#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -080085#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -070086#include <unordered_map>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080087#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070088
chaviw1d044282017-09-27 12:19:28 -070089using namespace android::surfaceflinger;
90
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091namespace android {
92
93// ---------------------------------------------------------------------------
94
95class Client;
chaviw13fdc492017-06-27 12:40:18 -070096class ColorLayer;
Lloyd Pique144e1162017-12-20 16:44:52 -080097class DisplayEventConnection;
Jamie Gennisd1700752013-10-14 12:22:52 -070098class EventControlThread;
Lloyd Pique144e1162017-12-20 16:44:52 -080099class EventThread;
Lloyd Pique12eb4232018-01-17 11:54:43 -0800100class IGraphicBufferConsumer;
101class IGraphicBufferProducer;
Robert Carr720e5062018-07-30 17:45:14 -0700102class IInputFlinger;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700103class InjectVSyncSource;
Lloyd Pique144e1162017-12-20 16:44:52 -0800104class Layer;
105class Surface;
David Sodman105b7dc2017-11-04 20:28:14 -0700106class SurfaceFlingerBE;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800107class TimeStats;
Lloyd Pique144e1162017-12-20 16:44:52 -0800108class VSyncSource;
David Sodmanba340492018-08-05 21:51:33 -0700109struct CompositionInfo;
Lloyd Pique144e1162017-12-20 16:44:52 -0800110
Lloyd Pique542307f2018-10-19 13:24:08 -0700111namespace compositionengine {
112class DisplaySurface;
113} // namespace compositionengine
114
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800115namespace impl {
116class EventThread;
117} // namespace impl
118
Peiyong Lin833074a2018-08-28 11:53:54 -0700119namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800120class RenderEngine;
121}
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800122
chaviwa76b2712017-09-20 12:02:26 -0700123typedef std::function<void(const LayerVector::Visitor&)> TraverseLayersFunction;
124
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800125namespace dvr {
126class VrFlinger;
127} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800128
Lloyd Pique22098362018-09-13 11:46:49 -0700129namespace surfaceflinger {
130class NativeWindowSurface;
131} // namespace surfaceflinger
132
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800133// ---------------------------------------------------------------------------
134
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800135enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700136 eTransactionNeeded = 0x01,
137 eTraversalNeeded = 0x02,
138 eDisplayTransactionNeeded = 0x04,
Lloyd Piqued432a7c2018-03-23 16:05:31 -0700139 eDisplayLayerStackChanged = 0x08,
140 eTransactionMask = 0x0f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800141};
142
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800143enum class DisplayColorSetting : int32_t {
144 MANAGED = 0,
145 UNMANAGED = 1,
146 ENHANCED = 2,
147};
148
David Sodman105b7dc2017-11-04 20:28:14 -0700149class SurfaceFlingerBE
150{
151public:
152 SurfaceFlingerBE();
153
David Sodmanbc815282017-11-05 18:57:52 -0800154 const std::string mHwcServiceName; // "default" for real use, something else for testing.
155
David Sodman73beded2017-11-15 11:56:06 -0800156 FenceTimeline mGlCompositionDoneTimeline;
157 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800158
David Sodman99974d22017-11-28 12:04:33 -0800159 // protected by mCompositorTimingLock;
160 mutable std::mutex mCompositorTimingLock;
161 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800162
David Sodman99974d22017-11-28 12:04:33 -0800163 // Only accessed from the main thread.
164 struct CompositePresentTime {
165 nsecs_t composite { -1 };
166 std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
167 };
168 std::queue<CompositePresentTime> mCompositePresentTimes;
169
David Sodman4a36e932017-11-07 14:29:47 -0800170 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
171 nsecs_t mFrameBuckets[NUM_BUCKETS];
172 nsecs_t mTotalTime;
173 std::atomic<nsecs_t> mLastSwapTime;
174
David Sodmancbaf0832017-11-07 14:21:36 -0800175 // Double- vs. triple-buffering stats
176 struct BufferingStats {
177 BufferingStats()
178 : numSegments(0),
179 totalTime(0),
180 twoBufferTime(0),
181 doubleBufferedTime(0),
182 tripleBufferedTime(0) {}
183
184 size_t numSegments;
185 nsecs_t totalTime;
186
187 // "Two buffer" means that a third buffer was never used, whereas
188 // "double-buffered" means that on average the segment only used two
189 // buffers (though it may have used a third for some part of the
190 // segment)
191 nsecs_t twoBufferTime;
192 nsecs_t doubleBufferedTime;
193 nsecs_t tripleBufferedTime;
194 };
195 mutable Mutex mBufferingStatsMutex;
196 std::unordered_map<std::string, BufferingStats> mBufferingStats;
197
David Sodman105b7dc2017-11-04 20:28:14 -0700198 // The composer sequence id is a monotonically increasing integer that we
199 // use to differentiate callbacks from different hardware composer
200 // instances. Each hardware composer instance gets a different sequence id.
201 int32_t mComposerSequenceId;
David Sodmanba340492018-08-05 21:51:33 -0700202
Dominik Laskowski05275f12018-11-01 15:03:24 -0700203 std::map<wp<IBinder>, std::vector<CompositionInfo>> mCompositionInfo;
204 std::map<wp<IBinder>, std::vector<CompositionInfo>> mEndOfFrameCompositionInfo;
David Sodman105b7dc2017-11-04 20:28:14 -0700205};
206
chaviw291d88a2019-02-14 10:33:58 -0800207class SetInputWindowsListener : public BnSetInputWindowsListener {
208public:
209 SetInputWindowsListener(const sp<SurfaceFlinger>& flinger) : mFlinger(flinger) {}
210 void onSetInputWindowsFinished() override;
211
212private:
213 const sp<SurfaceFlinger> mFlinger;
214};
David Sodman105b7dc2017-11-04 20:28:14 -0700215
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700216class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700217 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700218 private IBinder::DeathRecipient,
Steven Thomasb02664d2017-07-26 18:48:28 -0700219 private HWC2::ComposerCallback
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800220{
221public:
David Sodman105b7dc2017-11-04 20:28:14 -0700222 SurfaceFlingerBE& getBE() { return mBE; }
223 const SurfaceFlingerBE& getBE() const { return mBE; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800224
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800225 // This is the phase offset in nanoseconds of the software vsync event
226 // relative to the vsync event reported by HWComposer. The software vsync
227 // event is when SurfaceFlinger and Choreographer-based applications run each
228 // frame.
229 //
230 // This phase offset allows adjustment of the minimum latency from application
231 // wake-up time (by Choreographer) to the time at which the resulting window
232 // image is displayed. This value may be either positive (after the HW vsync)
233 // or negative (before the HW vsync). Setting it to 0 will result in a lower
234 // latency bound of two vsync periods because the app and SurfaceFlinger
235 // will run just after the HW vsync. Setting it to a positive number will
236 // result in the minimum latency being:
237 //
238 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
239 //
240 // Note that reducing this latency makes it more likely for the applications
241 // to not have their window content image ready in time. When this happens
242 // the latency will end up being an additional vsync period, and animations
243 // will hiccup. Therefore, this latency should be tuned somewhat
244 // conservatively (or at least with awareness of the trade-off being made).
245 static int64_t vsyncPhaseOffsetNs;
246 static int64_t sfVsyncPhaseOffsetNs;
247
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800248 // If fences from sync Framework are supported.
249 static bool hasSyncFramework;
250
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700251 // The offset in nanoseconds to use when DispSync timestamps present fence
252 // signaling time.
253 static int64_t dispSyncPresentTimeOffset;
254
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700255 // Some hardware can do RGB->YUV conversion more efficiently in hardware
256 // controlled by HWC than in hardware controlled by the video encoder.
257 // This instruct VirtualDisplaySurface to use HWC for such conversion on
258 // GL composition.
259 static bool useHwcForRgbToYuv;
260
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800261 // Maximum dimension supported by HWC for virtual display.
262 // Equal to min(max_height, max_width).
263 static uint64_t maxVirtualDisplaySize;
264
Fabien Sanglard1971b632017-03-10 14:50:03 -0800265 // Controls the number of buffers SurfaceFlinger will allocate for use in
266 // FramebufferSurface
267 static int64_t maxFrameBufferAcquiredBuffers;
268
Peiyong Lin13effd12018-07-24 17:01:47 -0700269 // Indicate if a device has wide color gamut display. This is typically
270 // found on devices with wide color gamut (e.g. Display-P3) display.
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600271 static bool hasWideColorDisplay;
272
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700273 static int primaryDisplayOrientation;
274
Peiyong Lin13effd12018-07-24 17:01:47 -0700275 // Indicate if device wants color management on its display.
276 static bool useColorManagement;
277
Peiyong Linb3839ad2018-09-05 15:37:19 -0700278 static bool useContextPriority;
279
Peiyong Lin0256f722018-08-31 15:45:10 -0700280 // The data space and pixel format that SurfaceFlinger expects hardware composer
281 // to composite efficiently. Meaning under most scenarios, hardware composer
282 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700283 static ui::Dataspace defaultCompositionDataspace;
284 static ui::PixelFormat defaultCompositionPixelFormat;
285
286 // The data space and pixel format that SurfaceFlinger expects hardware composer
287 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
288 // hardware composer will accept layers with the data space and pixel format.
289 static ui::Dataspace wideColorGamutCompositionDataspace;
290 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700291
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700292 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700293 return "SurfaceFlinger";
294 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800295
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800296 struct SkipInitializationTag {};
297 static constexpr SkipInitializationTag SkipInitialization;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700298 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
299 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800300
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700301 // must be called before clients can connect
302 void init() ANDROID_API;
303
304 // starts SurfaceFlinger main loop in the current thread
305 void run() ANDROID_API;
306
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700307 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700308 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 -0800309
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700310 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700311 status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800312
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700313 // force full composition on all displays
314 void repaintEverything();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800315
Ana Krulec7d1d6832018-12-27 11:10:09 -0800316 // force full composition on all displays without resetting the scheduler idle timer.
317 void repaintEverythingForHWC();
318
Lloyd Pique90c115d2018-09-18 21:39:42 -0700319 surfaceflinger::Factory& getFactory() { return mFactory; }
320
Lloyd Pique70d91362018-10-18 16:02:55 -0700321 // The CompositionEngine encapsulates all composition related interfaces and actions.
322 compositionengine::CompositionEngine& getCompositionEngine() const;
323
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700324 // returns the default Display
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800325 sp<const DisplayDevice> getDefaultDisplayDevice() {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700326 Mutex::Autolock _l(mStateLock);
327 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700328 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700329
Dan Stoza436ccf32018-06-21 12:10:12 -0700330 // Obtains a name from the texture pool, or, if the pool is empty, posts a
331 // synchronous message to the main thread to obtain one on the fly
332 uint32_t getNewTexture();
333
Mathias Agopian86303202012-07-24 22:46:10 -0700334 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700335 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700336
Mathias Agopian86303202012-07-24 22:46:10 -0700337 // enable/disable h/w composer event
338 // TODO: this should be made accessible only to EventThread
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800339 void setPrimaryVsyncEnabled(bool enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700340
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700341 // called on the main thread by MessageQueue when an internal message
342 // is received
343 // TODO: this should be made accessible only to MessageQueue
344 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700345
Mathias Agopiancb558572012-10-04 15:58:54 -0700346 // for debugging only
347 // TODO: this should be made accessible only to HWComposer
Dominik Laskowski075d3172018-05-24 15:50:06 -0700348 const Vector<sp<Layer>>& getLayerSortedByZForHwcDisplay(DisplayId displayId);
Mathias Agopiancb558572012-10-04 15:58:54 -0700349
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700350 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700351
Robert Carr0d480722017-01-10 16:42:54 -0800352 bool authenticateSurfaceTextureLocked(
353 const sp<IGraphicBufferProducer>& bufferProducer) const;
354
Robert Carr2e102c92018-10-23 12:11:15 -0700355 inline void onLayerCreated() { mNumLayers++; }
356 inline void onLayerDestroyed() { mNumLayers--; }
357
Marissa Walle2ffb422018-10-12 11:33:52 -0700358 TransactionCompletedThread& getTransactionCompletedThread() {
359 return mTransactionCompletedThread;
360 }
361
chaviw291d88a2019-02-14 10:33:58 -0800362 void setInputWindowsFinished();
363
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700364private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700365 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800366 friend class DisplayEventConnection;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800367 friend class impl::EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800368 friend class Layer;
David Sodman0c69cad2017-08-21 12:12:51 -0700369 friend class BufferLayer;
Marissa Wallfd668622018-05-10 10:21:13 -0700370 friend class BufferQueueLayer;
Marissa Wall61c58622018-07-18 10:12:20 -0700371 friend class BufferStateLayer;
Dan Stozab9b08832014-03-13 11:55:57 -0700372 friend class MonitoredProducer;
Dan Stozaec460082018-12-17 15:35:09 -0800373 friend class RegionSamplingThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800374
Lloyd Piquef58625d2017-12-19 13:22:33 -0800375 // For unit tests
376 friend class TestableSurfaceFlinger;
377
Jamie Gennis6547ff42013-07-16 20:12:42 -0700378 // This value is specified in number of frames. Log frame stats at most
379 // every half hour.
380 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
381
Dan Stoza7d89d062015-04-30 13:29:25 -0700382 static const size_t MAX_LAYERS = 4096;
383
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700384 // We're reference counted, never destroy SurfaceFlinger directly
385 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800386
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700387 /* ------------------------------------------------------------------------
388 * Internal data structures
389 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800390
Robert Carr2047fae2016-11-28 14:09:09 -0800391 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800392 public:
chaviwfd462612018-05-31 16:11:27 -0700393 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700394 State& operator=(const State& other) {
395 // We explicitly don't copy stateSet so that, e.g., mDrawingState
396 // always uses the Drawing StateSet.
397 layersSortedByZ = other.layersSortedByZ;
398 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700399 colorMatrixChanged = other.colorMatrixChanged;
400 if (colorMatrixChanged) {
401 colorMatrix = other.colorMatrix;
402 }
Dan Stoza412903f2017-04-27 13:42:17 -0700403 return *this;
404 }
405
406 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700407 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700408 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800409
Chia-I Wu28f320b2018-05-03 11:02:56 -0700410 bool colorMatrixChanged = true;
411 mat4 colorMatrix;
412
Dan Stoza412903f2017-04-27 13:42:17 -0700413 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
414 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800415 };
416
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700417 /* ------------------------------------------------------------------------
418 * IBinder interface
419 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800420 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
421 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Robert Carr14167e02019-02-13 13:50:55 -0800422 bool callingThreadHasUnscopedSurfaceFlingerAccess() EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800423
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700424 /* ------------------------------------------------------------------------
425 * ISurfaceComposer interface
426 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800427 sp<ISurfaceComposerClient> createConnection() override;
428 sp<IBinder> createDisplay(const String8& displayName, bool secure) override;
429 void destroyDisplay(const sp<IBinder>& displayToken) override;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800430 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override;
431 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800432 void setTransactionState(const Vector<ComposerState>& state,
433 const Vector<DisplayState>& displays, uint32_t flags,
434 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -0800435 const InputWindowCommands& inputWindowCommands,
436 int64_t desiredPresentTime) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800437 void bootFinished() override;
438 bool authenticateSurfaceTexture(
439 const sp<IGraphicBufferProducer>& bufferProducer) const override;
440 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override;
441 sp<IDisplayEventConnection> createDisplayEventConnection(
442 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp) override;
443 status_t captureScreen(const sp<IBinder>& displayToken, sp<GraphicBuffer>* outBuffer,
444 const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat,
445 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
446 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) override;
447 status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
448 const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat,
449 const Rect& sourceCrop, float frameScale, bool childrenOnly) override;
450 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
451 status_t getDisplayConfigs(const sp<IBinder>& displayToken,
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800452 Vector<DisplayInfo>* configs) override {
453 Mutex::Autolock _l(mStateLock);
454 return getDisplayConfigsLocked(displayToken, configs);
455 }
456 status_t getDisplayConfigsLocked(const sp<IBinder>& displayToken, Vector<DisplayInfo>* configs)
457 REQUIRES(mStateLock);
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800458 int getActiveConfig(const sp<IBinder>& displayToken) override;
459 status_t getDisplayColorModes(const sp<IBinder>& displayToken,
460 Vector<ui::ColorMode>* configs) override;
Daniel Solomon42d04562019-01-20 21:03:19 -0800461 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken,
462 ui::DisplayPrimaries &primaries);
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800463 ui::ColorMode getActiveColorMode(const sp<IBinder>& displayToken) override;
464 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode) override;
465 void setPowerMode(const sp<IBinder>& displayToken, int mode) override;
466 status_t setActiveConfig(const sp<IBinder>& displayToken, int id) override;
467 status_t clearAnimationFrameStats() override;
468 status_t getAnimationFrameStats(FrameStats* outStats) const override;
469 status_t getHdrCapabilities(const sp<IBinder>& displayToken,
470 HdrCapabilities* outCapabilities) const override;
471 status_t enableVSyncInjections(bool enable) override;
472 status_t injectVSync(nsecs_t when) override;
473 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const override;
474 status_t getColorManagement(bool* outGetColorManagement) const override;
Peiyong Linc6780972018-10-28 15:24:08 -0700475 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
476 ui::Dataspace* outWideColorGamutDataspace,
477 ui::PixelFormat* outWideColorGamutPixelFormat) const override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800478 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
479 ui::PixelFormat* outFormat,
480 ui::Dataspace* outDataspace,
481 uint8_t* outComponentMask) const override;
482 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
483 uint8_t componentMask,
484 uint64_t maxFrames) const override;
485 status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
486 uint64_t timestamp,
487 DisplayedFrameStats* outStats) const override;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800488 status_t getProtectedContentSupport(bool* outSupported) const override;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800489 status_t isWideColorDisplay(const sp<IBinder>& displayToken,
490 bool* outIsWideColorDisplay) const override;
Dan Stoza84ab9372018-12-17 15:27:57 -0800491 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
492 const sp<IRegionSamplingListener>& listener) override;
493 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override;
Ady Abraham838de062019-02-04 10:24:03 -0800494 status_t setAllowedDisplayConfigs(const sp<IBinder>& displayToken,
495 const std::vector<int32_t>& allowedConfigs) override;
Ady Abrahamd9b3ea62019-02-26 14:08:03 -0800496 status_t getAllowedDisplayConfigs(const sp<IBinder>& displayToken,
497 std::vector<int32_t>* outAllowedConfigs) override;
Ady Abraham838de062019-02-04 10:24:03 -0800498
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700499 /* ------------------------------------------------------------------------
500 * DeathRecipient interface
501 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800502 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800503
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700504 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700505 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700506 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800507 void onFirstRef() override;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800508
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700509 /* ------------------------------------------------------------------------
Steven Thomasb02664d2017-07-26 18:48:28 -0700510 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700511 */
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700512 void onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Steven Thomasb02664d2017-07-26 18:48:28 -0700513 int64_t timestamp) override;
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700514 void onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -0800515 HWC2::Connection connection) override;
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700516 void onRefreshReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700517
518 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700519 * Message handling
520 */
521 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700522 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700523 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700524 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700525 void signalLayerUpdate();
526 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800527
Ady Abraham447052e2019-02-13 16:07:27 -0800528 enum class ConfigEvent { None, Changed };
529
Andy McFadden13a082e2012-08-24 10:16:42 -0700530 // called on the main thread in response to initializeDisplays()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800531 void onInitializeDisplays() REQUIRES(mStateLock);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800532 // Sets the desired active config bit. It obtains the lock, and sets mDesiredActiveConfig.
Ady Abraham447052e2019-02-13 16:07:27 -0800533 void setDesiredActiveConfig(const sp<IBinder>& displayToken, int mode, ConfigEvent event)
534 REQUIRES(mStateLock);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800535 // Once HWC has returned the present fence, this sets the active config and a new refresh
536 // rate in SF. It also triggers HWC vsync.
537 void setActiveConfigInternal() REQUIRES(mStateLock);
538 // Active config is updated on INVALIDATE call in a state machine-like manner. When the
Ady Abrahamb838aed2019-02-12 15:30:16 -0800539 // desired config was set, HWC needs to update the panel on the next refresh, and when
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800540 // we receive the fence back, we know that the process was complete. It returns whether
Ady Abrahamb838aed2019-02-12 15:30:16 -0800541 // we need to wait for the next invalidate
542 bool performSetActiveConfig();
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700543 // called on the main thread in response to setPowerMode()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800544 void setPowerModeInternal(const sp<DisplayDevice>& display, int mode) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800545
Ady Abraham838de062019-02-04 10:24:03 -0800546 // called on the main thread in response to setAllowedDisplayConfigs()
547 void setAllowedDisplayConfigsInternal(
548 const sp<IBinder>& displayToken,
549 std::unique_ptr<const AllowedDisplayConfigs>&& allowedConfigs) REQUIRES(mStateLock);
550
Dan Stoza6b9454d2014-11-07 16:00:59 -0800551 // Returns whether the transaction actually modified any state
552 bool handleMessageTransaction();
553
554 // Returns whether a new buffer has been latched (see handlePageFlip())
555 bool handleMessageInvalidate();
556
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700557 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700558
Mathias Agopian87baae12012-07-31 12:38:26 -0700559 void handleTransaction(uint32_t transactionFlags);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800560 void handleTransactionLocked(uint32_t transactionFlags) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800561
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800562 void updateInputFlinger();
563 void updateInputWindowInfo();
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800564 void commitInputWindowCommands() REQUIRES(mStateLock);
chaviwfbe5d9c2018-12-26 12:23:37 -0800565 void executeInputWindowCommands();
Riley Andrews03414a12014-07-01 14:22:59 -0700566 void updateCursorAsync();
567
Dan Stoza6b9454d2014-11-07 16:00:59 -0800568 /* handlePageFlip - latch a new buffer if available and compute the dirty
569 * region. Returns whether a new buffer has been latched, i.e., whether it
570 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700571 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800572 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800573
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700574 /* ------------------------------------------------------------------------
575 * Transactions
576 */
Marissa Wall713b63f2018-10-17 15:42:43 -0700577 void applyTransactionState(const Vector<ComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800578 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -0800579 const InputWindowCommands& inputWindowCommands,
580 bool privileged) REQUIRES(mStateLock);
Marissa Wall713b63f2018-10-17 15:42:43 -0700581 bool flushTransactionQueues();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700582 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800583 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700584 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700585 uint32_t setTransactionFlags(uint32_t flags);
Ana Krulec7ecce8c2018-10-12 13:44:41 -0700586 uint32_t setTransactionFlags(uint32_t flags, Scheduler::TransactionStart transactionStart);
chaviw61626f22018-11-15 16:26:27 -0800587 void latchAndReleaseBuffer(const sp<Layer>& layer);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700588 void commitTransaction();
chaviwca27f252018-02-06 16:46:39 -0800589 bool containsAnyInvalidClientState(const Vector<ComposerState>& states);
Marissa Wall17b4e452018-12-26 16:32:34 -0800590 bool transactionIsReadyToBeApplied(int64_t desiredPresentTime,
591 const Vector<ComposerState>& states);
Robert Carr14167e02019-02-13 13:50:55 -0800592 uint32_t setClientStateLocked(const ComposerState& composerState, bool privileged);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700593 uint32_t setDisplayStateLocked(const DisplayState& s);
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
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700597 /* ------------------------------------------------------------------------
598 * Layer management
599 */
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800600 status_t createLayer(const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
601 PixelFormat format, uint32_t flags, LayerMetadata metadata,
602 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800603
Marissa Wallfd668622018-05-10 10:21:13 -0700604 status_t createBufferQueueLayer(const sp<Client>& client, const String8& name, uint32_t w,
605 uint32_t h, uint32_t flags, PixelFormat& format,
606 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
607 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800608
Marissa Wall61c58622018-07-18 10:12:20 -0700609 status_t createBufferStateLayer(const sp<Client>& client, const String8& name, uint32_t w,
610 uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
611 sp<Layer>* outLayer);
612
chaviw13fdc492017-06-27 12:40:18 -0700613 status_t createColorLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700614 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
David Sodman0c69cad2017-08-21 12:12:51 -0700615 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700616
Robert Carr6b3f6c52018-08-13 13:05:17 -0700617 status_t createContainerLayer(const sp<Client>& client, const String8& name,
618 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
619 sp<Layer>* outLayer);
620
Cody Northropbc755282017-03-31 12:00:08 -0600621 String8 getUniqueLayerName(const String8& name);
622
Rob Carr4bba3702018-10-08 21:53:30 +0000623 // called when all clients have released all their references to
624 // this layer meaning it is entirely safe to destroy all
625 // resources associated to this layer.
Robert Carr695d5282018-12-18 15:27:58 -0800626 void onHandleDestroyed(sp<Layer>& layer);
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800627 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700628
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700629 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700630 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700631 const sp<IBinder>& handle,
632 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -0700633 const sp<Layer>& lbc,
Robert Carrb89ea9d2018-12-10 13:01:14 -0800634 const sp<Layer>& parent,
635 bool addToCurrentState);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700636
Vishnu Nair4351ad52019-02-11 14:13:02 -0800637 // Traverse through all the layers and compute and cache its bounds.
638 void computeLayerBounds();
639
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700640 /* ------------------------------------------------------------------------
641 * Boot animation, on/off animations and screen capture
642 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700643
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700644 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700645
chaviwa76b2712017-09-20 12:02:26 -0700646 void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000647 ANativeWindowBuffer* buffer, bool useIdentityTransform,
648 int* outSyncFd);
chaviwa76b2712017-09-20 12:02:26 -0700649 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700650 sp<GraphicBuffer>* outBuffer, const ui::PixelFormat reqPixelFormat,
chaviwa76b2712017-09-20 12:02:26 -0700651 bool useIdentityTransform);
Dan Stozaec460082018-12-17 15:35:09 -0800652 status_t captureScreenCore(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
653 const sp<GraphicBuffer>& buffer, bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700654 status_t captureScreenImplLocked(const RenderArea& renderArea,
655 TraverseLayersFunction traverseLayers,
656 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Robert Carr03480e22018-01-04 16:02:06 -0800657 bool forSystem, int* outSyncFd);
chaviw0e3479f2018-09-10 16:49:30 -0700658 void traverseLayersInDisplay(const sp<const DisplayDevice>& display,
659 const LayerVector::Visitor& visitor);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700660
Lloyd Pique90c115d2018-09-18 21:39:42 -0700661 sp<StartPropertySetThread> mStartPropertySetThread;
Wei Wangb254fa32017-01-31 17:43:23 -0800662
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700663 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700664 * Properties
665 */
666 void readPersistentProperties();
667
668 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700669 * EGL
670 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700671 size_t getMaxTextureSize() const;
672 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700673
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700674 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700675 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700676 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700677 // called when starting, or restarting after system_server death
678 void initializeDisplays();
679
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700680 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) const {
681 Mutex::Autolock _l(mStateLock);
682 return getDisplayDeviceLocked(displayToken);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700683 }
684
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700685 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) {
686 Mutex::Autolock _l(mStateLock);
687 return getDisplayDeviceLocked(displayToken);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700688 }
689
690 // NOTE: can only be called from the main thread or with mStateLock held
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700691 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const {
692 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700693 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700694
695 // NOTE: can only be called from the main thread or with mStateLock held
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700696 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700697 const auto it = mDisplays.find(displayToken);
698 return it == mDisplays.end() ? nullptr : it->second;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700699 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700700
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700701 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700702 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700703 }
704
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700705 sp<DisplayDevice> getDefaultDisplayDeviceLocked() {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800706 if (const auto token = getInternalDisplayTokenLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700707 return getDisplayDeviceLocked(token);
708 }
709 return nullptr;
Michael Wright28f24d02016-07-12 13:30:53 -0700710 }
711
Mathias Agopian87baae12012-07-31 12:38:26 -0700712 // mark a region of a layer stack dirty. this updates the dirty
713 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700714 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700715
Daniel Solomon42d04562019-01-20 21:03:19 -0800716 // Initialize structures containing information about the internal
717 // display's native color coordinates using default data
718 void initDefaultDisplayNativePrimaries();
719
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700720 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700721 * H/W composer
722 */
723
Lloyd Pique441d5042018-10-18 16:49:51 -0700724 // The current hardware composer interface.
725 //
726 // The following thread safety rules apply when accessing mHwc, either
727 // directly or via getHwComposer():
728 //
729 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
730 // only when switching into and out of vr. Recreating mHwc must only be
731 // done on the main thread.
732 //
733 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
734 // mStateLock.
735 //
736 // 3. When accessing mHwc on a thread other than the main thread, we always
737 // need to acquire mStateLock. This is because the main thread could be
738 // in the process of destroying the current mHwc instance.
739 //
740 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
741 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
742 // destroy it, so it's always safe to access mHwc from any thread without
743 // acquiring mStateLock.
744 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700745
Mathias Agopian888c8222012-08-04 21:10:38 -0700746 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700747 * Compositing
748 */
749 void invalidateHwcGeometry();
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700750 void computeVisibleRegions(const sp<const DisplayDevice>& display, Region& dirtyRegion,
751 Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700752
David Sodman2b406362017-12-15 13:33:47 -0800753 void preComposition();
754 void postComposition();
Dominik Laskowskif654d572018-12-20 11:03:06 -0800755 void getCompositorTiming(CompositorTiming* compositorTiming);
Ana Krulece588e312018-09-18 12:32:24 -0700756 void updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
757 std::shared_ptr<FenceTime>& presentFenceTime);
758 void setCompositorTimingSnapped(const DisplayStatInfo& stats,
759 nsecs_t compositeToPresentLatency);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700760 void rebuildLayerStacks();
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600761
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700762 ui::Dataspace getBestDataspace(const sp<const DisplayDevice>& display,
Peiyong Lin136fbbc2018-04-17 15:09:44 -0700763 ui::Dataspace* outHdrDataSpace) const;
764
765 // Returns the appropriate ColorMode, Dataspace and RenderIntent for the
766 // DisplayDevice. The function only returns the supported ColorMode,
767 // Dataspace and RenderIntent.
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700768 void pickColorMode(const sp<DisplayDevice>& display, ui::ColorMode* outMode,
769 ui::Dataspace* outDataSpace, ui::RenderIntent* outRenderIntent) const;
Romain Guy0147a172017-06-01 13:53:56 -0700770
David Sodman79bba0e2018-08-05 18:07:49 -0700771 void calculateWorkingSet();
David Sodman2b406362017-12-15 13:33:47 -0800772 /*
773 * beginFrame - This function handles any pre-frame processing that needs to be
774 * prior to any CompositionInfo handling and is not dependent on data in
775 * CompositionInfo
776 */
David Sodmanfa9b2af2017-12-24 13:28:59 -0800777 void beginFrame(const sp<DisplayDevice>& display);
David Sodman2b406362017-12-15 13:33:47 -0800778 /* prepareFrame - This function will call into the DisplayDevice to prepare a
779 * frame after CompositionInfo has been programmed. This provides a mechanism
780 * to prepare the hardware composer
781 */
David Sodmanfa9b2af2017-12-24 13:28:59 -0800782 void prepareFrame(const sp<DisplayDevice>& display);
783 void doComposition(const sp<DisplayDevice>& display, bool repainEverything);
784 void doDebugFlashRegions(const sp<DisplayDevice>& display, bool repaintEverything);
Adrian Roos1e1a1282017-11-01 19:05:31 +0100785 void doTracing(const char* where);
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800786 void logLayerStats();
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800787 void doDisplayComposition(const sp<DisplayDevice>& display, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700788
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000789 // This fails if using GL and the surface has been destroyed. readyFence
790 // will be populated if using GL and native fence sync is supported, to
791 // signal when drawing has completed.
792 bool doComposeSurfaces(const sp<DisplayDevice>& display, const Region& debugRegionm,
793 base::unique_fd* readyFence);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700794
David Sodmanfa9b2af2017-12-24 13:28:59 -0800795 void postFramebuffer(const sp<DisplayDevice>& display);
796 void postFrame();
Chia-I Wu28e3a252018-09-07 12:05:02 -0700797 void drawWormhole(const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700798
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700799 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700800 * Display management
801 */
Lloyd Pique542307f2018-10-19 13:24:08 -0700802 sp<DisplayDevice> setupNewDisplayDeviceInternal(
803 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
804 const DisplayDeviceState& state,
805 const sp<compositionengine::DisplaySurface>& dispSurface,
806 const sp<IGraphicBufferProducer>& producer);
Lloyd Pique347200f2017-12-14 17:00:15 -0800807 void processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -0800808 void processDisplayHotplugEventsLocked();
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700809
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800810 void dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800811
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700812 /* ------------------------------------------------------------------------
813 * VSync
814 */
Dominik Laskowski83b88212018-12-11 13:34:06 -0800815 nsecs_t getVsyncPeriod() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700816
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800817 // Sets the refresh rate by switching active configs, if they are available for
Ana Krulec7d1d6832018-12-27 11:10:09 -0800818 // the desired refresh rate.
Ady Abraham447052e2019-02-13 16:07:27 -0800819 void setRefreshRateTo(scheduler::RefreshRateConfigs::RefreshRateType, ConfigEvent event)
820 REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700821
Ady Abraham838de062019-02-04 10:24:03 -0800822 bool isConfigAllowed(const DisplayId& displayId, int32_t config);
823
Dominik Laskowskic2867142019-01-21 11:33:38 -0800824 /*
825 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700826 */
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800827 sp<IBinder> getPhysicalDisplayTokenLocked(DisplayId displayId) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700828 const auto it = mPhysicalDisplayTokens.find(displayId);
829 return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
830 }
831
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800832 std::optional<DisplayId> getPhysicalDisplayIdLocked(const sp<IBinder>& displayToken) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700833 for (const auto& [id, token] : mPhysicalDisplayTokens) {
834 if (token == displayToken) {
835 return id;
836 }
837 }
838 return {};
839 }
840
841 // TODO(b/74619554): Remove special cases for primary display.
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800842 sp<IBinder> getInternalDisplayTokenLocked() const {
843 const auto displayId = getInternalDisplayIdLocked();
844 return displayId ? getPhysicalDisplayTokenLocked(*displayId) : nullptr;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700845 }
846
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800847 std::optional<DisplayId> getInternalDisplayIdLocked() const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700848 const auto hwcDisplayId = getHwComposer().getInternalHwcDisplayId();
849 return hwcDisplayId ? getHwComposer().toPhysicalDisplayId(*hwcDisplayId) : std::nullopt;
850 }
851
Dominik Laskowskic2867142019-01-21 11:33:38 -0800852 /*
853 * Debugging & dumpsys
854 */
Dominik Laskowskic2867142019-01-21 11:33:38 -0800855 using DumpArgs = Vector<String16>;
856 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
857
858 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
859 static Dumper dumper(F&& dump) {
860 using namespace std::placeholders;
861 return std::bind(std::forward<F>(dump), _3);
862 }
863
864 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
865 Dumper dumper(F dump) {
866 using namespace std::placeholders;
867 return std::bind(dump, this, _3);
868 }
869
870 template <typename F>
871 Dumper argsDumper(F dump) {
872 using namespace std::placeholders;
873 return std::bind(dump, this, _1, _3);
874 }
875
876 template <typename F>
877 Dumper protoDumper(F dump) {
878 using namespace std::placeholders;
879 return std::bind(dump, this, _1, _2, _3);
880 }
881
882 void dumpAllLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
883
884 void appendSfConfigString(std::string& result) const;
885 void listLayersLocked(std::string& result) const;
886 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
887 void clearStatsLocked(const DumpArgs& args, std::string& result);
888 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Jamie Gennis6547ff42013-07-16 20:12:42 -0700889 void logFrameStats();
890
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800891 void dumpVSync(std::string& result) const REQUIRES(mStateLock);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800892 void dumpStaticScreenStats(std::string& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700893 // Not const because each Layer needs to query Fences and cache timestamps.
Yiwei Zhang5434a782018-12-05 18:06:32 -0800894 void dumpFrameEventsLocked(std::string& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800895
Dan Stozae77c7662016-05-13 11:37:28 -0700896 void recordBufferingStats(const char* layerName,
897 std::vector<OccupancyTracker::Segment>&& history);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800898 void dumpBufferingStats(std::string& result) const;
899 void dumpDisplayIdentificationData(std::string& result) const;
900 void dumpWideColorInfo(std::string& result) const;
Jorim Jaggi8e0af362017-11-14 16:28:28 +0100901 LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const;
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800902 LayersProto dumpVisibleLayersProtoInfo(const sp<DisplayDevice>& display) const;
Dan Stozae77c7662016-05-13 11:37:28 -0700903
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800904 bool isLayerTripleBufferingDisabled() const {
905 return this->mLayerTripleBufferingDisabled;
906 }
Dominik Laskowskic2867142019-01-21 11:33:38 -0800907
908 status_t doDump(int fd, const DumpArgs& args, bool asProto);
909
910 status_t dumpCritical(int fd, const DumpArgs&, bool asProto) override {
911 return doDump(fd, DumpArgs(), asProto);
912 }
913
914 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
915 return doDump(fd, args, asProto);
916 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800917
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800918 /* ------------------------------------------------------------------------
919 * VrFlinger
920 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700921 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800922
Steven Thomas050b2c82017-03-06 11:45:16 -0800923 // Check to see if we should handoff to vr flinger.
924 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800925
Chia-I Wu28f320b2018-05-03 11:02:56 -0700926 void updateColorMatrixLocked();
927
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700928 /* ------------------------------------------------------------------------
929 * Attributes
930 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800931
Lloyd Pique90c115d2018-09-18 21:39:42 -0700932 surfaceflinger::Factory& mFactory;
933
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700934 // access must be protected by mStateLock
935 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700936 State mCurrentState{LayerVector::StateSet::Current};
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700937 std::atomic<int32_t> mTransactionFlags{0};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700938 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700939 bool mTransactionPending;
940 bool mAnimTransactionPending;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700941 SortedVector< sp<Layer> > mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -0800942
Chia-I Wu28f320b2018-05-03 11:02:56 -0700943 // global color transform states
944 Daltonizer mDaltonizer;
945 float mGlobalSaturationFactor = 1.0f;
946 mat4 mClientColorMatrix;
947
Dan Stoza101d8dc2018-02-27 15:42:25 -0800948 // Can't be unordered_set because wp<> isn't hashable
949 std::set<wp<IBinder>> mGraphicBufferProducerList;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700950 size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800951
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700952 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700953 bool mLayersRemoved;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700954 bool mLayersAdded;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700955
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700956 std::atomic<bool> mRepaintEverything{false};
Mathias Agopianca4d3602011-05-19 15:38:14 -0700957
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800958 // constant members (no synchronization needed for access)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700959 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700960 bool mGpuToCpuSupported;
Lloyd Piquee83f9312018-02-01 12:53:17 -0800961 std::unique_ptr<EventThread> mInjectorEventThread;
Lloyd Piquee83f9312018-02-01 12:53:17 -0800962 std::unique_ptr<InjectVSyncSource> mVSyncInjector;
Lloyd Pique755e3192018-01-31 16:46:15 -0800963 std::unique_ptr<EventControlThread> mEventControlThread;
Mathias Agopian3094df32012-06-18 18:06:45 -0700964
Ana Krulec757f63a2019-01-25 10:46:18 -0800965 // Calculates correct offsets.
Dan Stoza84d619e2018-03-28 17:07:36 -0700966 VSyncModulator mVsyncModulator;
Ana Krulec757f63a2019-01-25 10:46:18 -0800967 // Keeps track of all available phase offsets for different refresh types.
968 std::unique_ptr<scheduler::PhaseOffsets> mPhaseOffsets;
Dan Stoza84d619e2018-03-28 17:07:36 -0700969
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700970 // Can only accessed from the main thread, these members
971 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700972 State mDrawingState{LayerVector::StateSet::Drawing};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700973 bool mVisibleRegionsDirty;
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800974 // Set during transaction commit stage to track if the input info for a layer has changed.
975 bool mInputInfoChanged{false};
Dan Stoza9e56aa02015-11-02 13:00:03 -0800976 bool mGeometryInvalid;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800977 bool mAnimCompositionPending;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800978 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800979 // Tracks layers that need to update a display's dirty region.
980 std::vector<sp<Layer>> mLayersPendingRefresh;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700981 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
982 bool mHadClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700983
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800984 enum class BootStage {
985 BOOTLOADER,
986 BOOTANIMATION,
987 FINISHED,
988 };
989 BootStage mBootStage;
990
Lloyd Piqueba04e622017-12-14 17:11:26 -0800991 struct HotplugEvent {
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700992 hwc2_display_t hwcDisplayId;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800993 HWC2::Connection connection = HWC2::Connection::Invalid;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800994 };
995 // protected by mStateLock
996 std::vector<HotplugEvent> mPendingHotplugEvents;
997
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700998 // this may only be written from the main thread with mStateLock held
999 // it may be read from other threads with mStateLock held
Dominik Laskowski9fae1022018-05-29 13:17:40 -07001000 std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001001 std::unordered_map<DisplayId, sp<IBinder>> mPhysicalDisplayTokens;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001002
1003 // don't use a lock for these, we don't care
1004 int mDebugRegion;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001005 int mDebugDisableHWC;
1006 int mDebugDisableTransformHint;
1007 volatile nsecs_t mDebugInSwapBuffers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001008 volatile nsecs_t mDebugInTransaction;
1009 nsecs_t mLastTransactionTime;
David Sodmanfa9b2af2017-12-24 13:28:59 -08001010 nsecs_t mPostFramebufferTime;
Dan Stozaee44edd2015-03-23 15:50:23 -07001011 bool mForceFullDamage;
Dan Stozac5da2712016-07-20 15:38:12 -07001012 bool mPropagateBackpressure = true;
Lloyd Pique90c115d2018-09-18 21:39:42 -07001013 std::unique_ptr<SurfaceInterceptor> mInterceptor{mFactory.createSurfaceInterceptor(this)};
Adrian Roos1e1a1282017-11-01 19:05:31 +01001014 SurfaceTracing mTracing;
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001015 LayerStats mLayerStats;
Alec Mourifb571ea2019-01-24 18:42:10 -08001016 std::shared_ptr<TimeStats> mTimeStats;
Fabien Sanglard642b23d2017-02-09 12:29:39 -08001017 bool mUseHwcVirtualDisplays = false;
Marissa Wallcfcdaa52018-05-21 15:45:59 -07001018 std::atomic<uint32_t> mFrameMissedCount{0};
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001019
Marissa Walle2ffb422018-10-12 11:33:52 -07001020 TransactionCompletedThread mTransactionCompletedThread;
1021
Dan Stozaec460082018-12-17 15:35:09 -08001022 bool mLumaSampling = true;
1023 sp<RegionSamplingThread> mRegionSamplingThread = new RegionSamplingThread(*this);
1024
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08001025 // Restrict layers to use two buffers in their bufferqueues.
1026 bool mLayerTripleBufferingDisabled = false;
1027
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001028 // these are thread safe
Lloyd Pique90c115d2018-09-18 21:39:42 -07001029 mutable std::unique_ptr<MessageQueue> mEventQueue{mFactory.createMessageQueue()};
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001030 FrameTracker mAnimFrameTracker;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001031
1032 // protected by mDestroyedLayerLock;
1033 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -08001034 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001035
David Sodman2b406362017-12-15 13:33:47 -08001036 nsecs_t mRefreshStartTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001037
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001038 std::atomic<bool> mRefreshPending{false};
1039
Dan Stoza436ccf32018-06-21 12:10:12 -07001040 // We maintain a pool of pre-generated texture names to hand out to avoid
1041 // layer creation needing to run on the main thread (which it would
1042 // otherwise need to do to access RenderEngine).
1043 std::mutex mTexturePoolMutex;
1044 uint32_t mTexturePoolSize = 0;
1045 std::vector<uint32_t> mTexturePool;
1046
Marissa Wall713b63f2018-10-17 15:42:43 -07001047 struct IBinderHash {
1048 std::size_t operator()(const sp<IBinder>& strongPointer) const {
1049 return std::hash<IBinder*>{}(strongPointer.get());
1050 }
1051 };
1052 struct TransactionState {
1053 TransactionState(const Vector<ComposerState>& composerStates,
Marissa Wall17b4e452018-12-26 16:32:34 -08001054 const Vector<DisplayState>& displayStates, uint32_t transactionFlags,
Robert Carr14167e02019-02-13 13:50:55 -08001055 int64_t desiredPresentTime,
1056 bool privileged)
Marissa Wall17b4e452018-12-26 16:32:34 -08001057 : states(composerStates),
1058 displays(displayStates),
1059 flags(transactionFlags),
Robert Carr14167e02019-02-13 13:50:55 -08001060 time(desiredPresentTime),
1061 privileged(privileged) {}
Marissa Wall713b63f2018-10-17 15:42:43 -07001062
1063 Vector<ComposerState> states;
1064 Vector<DisplayState> displays;
1065 uint32_t flags;
Marissa Wall17b4e452018-12-26 16:32:34 -08001066 int64_t time;
Robert Carr14167e02019-02-13 13:50:55 -08001067 bool privileged;
Marissa Wall713b63f2018-10-17 15:42:43 -07001068 };
1069 std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IBinderHash> mTransactionQueues;
1070
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001071 /* ------------------------------------------------------------------------
1072 * Feature prototyping
1073 */
1074
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001075 bool mInjectVSyncs;
1076
Dan Stozab90cf072015-03-05 11:05:59 -08001077 // Static screen stats
1078 bool mHasPoweredOff;
Dan Stozae77c7662016-05-13 11:37:28 -07001079
Robert Carr1f0a16a2016-10-24 16:27:39 -07001080 size_t mNumLayers;
1081
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07001082 // Verify that transaction is being called by an approved process:
1083 // either AID_GRAPHICS or AID_SYSTEM.
1084 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001085
Steven Thomasb02664d2017-07-26 18:48:28 -07001086 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Steven Thomas050b2c82017-03-06 11:45:16 -08001087 std::atomic<bool> mVrFlingerRequestsDisplay;
1088 static bool useVrFlinger;
Steven Thomasb02664d2017-07-26 18:48:28 -07001089 std::thread::id mMainThreadId;
Romain Guy0147a172017-06-01 13:53:56 -07001090
Chia-I Wue0ec4312018-07-03 01:17:18 +08001091 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::ENHANCED;
David Sodman105b7dc2017-11-04 20:28:14 -07001092
Peiyong Lina3ea5592019-02-10 14:45:00 -08001093 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1094 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1095 // 2. be one of the supported color modes returned by hardware composer, otherwise
1096 // it will not be respected.
1097 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1098 // is not set to 1.
1099 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1100 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1101
Peiyong Lin9d846a52018-11-05 13:18:20 -08001102 ui::Dataspace mDefaultCompositionDataspace;
1103 ui::Dataspace mWideColorGamutCompositionDataspace;
1104
David Sodman105b7dc2017-11-04 20:28:14 -07001105 SurfaceFlingerBE mBE;
Lloyd Pique70d91362018-10-18 16:02:55 -07001106 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Ana Krulec98b5b242018-08-10 15:03:23 -07001107
Ana Krulecb43429d2019-01-09 14:28:51 -08001108 /* ------------------------------------------------------------------------
1109 * Scheduler
1110 */
Ana Krulecc2870422019-01-29 19:00:58 -08001111 bool mUse90Hz = false;
Ana Krulecba13ab32019-02-20 14:14:12 -08001112 bool mUseSmart90ForVideo = false;
Ana Krulec98b5b242018-08-10 15:03:23 -07001113 std::unique_ptr<Scheduler> mScheduler;
1114 sp<Scheduler::ConnectionHandle> mAppConnectionHandle;
1115 sp<Scheduler::ConnectionHandle> mSfConnectionHandle;
Ana Krulecb43429d2019-01-09 14:28:51 -08001116 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Robert Carr720e5062018-07-30 17:45:14 -07001117
Ady Abraham838de062019-02-04 10:24:03 -08001118 std::mutex mAllowedConfigsLock;
1119 std::unordered_map<DisplayId, std::unique_ptr<const AllowedDisplayConfigs>> mAllowedConfigs
1120 GUARDED_BY(mAllowedConfigsLock);
1121
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001122 struct ActiveConfigInfo {
1123 int configId;
1124 sp<IBinder> displayToken;
Ady Abraham447052e2019-02-13 16:07:27 -08001125 ConfigEvent event;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001126
1127 bool operator!=(const ActiveConfigInfo& other) const {
1128 if (configId != other.configId) {
1129 return true;
1130 }
1131 return (displayToken != other.displayToken);
1132 }
1133 };
1134 std::mutex mActiveConfigLock;
1135 // This bit is set once we start setting the config. We read from this bit during the
1136 // process. If at the end, this bit is different than mDesiredActiveConfig, we restart
1137 // the process.
1138 ActiveConfigInfo mUpcomingActiveConfig; // Always read and written on the main thread.
1139 // This bit can be set at any point in time when the system wants the new config.
1140 ActiveConfigInfo mDesiredActiveConfig GUARDED_BY(mActiveConfigLock);
1141
Ady Abrahamb838aed2019-02-12 15:30:16 -08001142 // below flags are set by main thread only
1143 bool mDesiredActiveConfigChanged GUARDED_BY(mActiveConfigLock) = false;
1144 bool mWaitForNextInvalidate = false;
1145 bool mCheckPendingFence = false;
1146
Ana Krulecb43429d2019-01-09 14:28:51 -08001147 /* ------------------------------------------------------------------------ */
Robert Carr720e5062018-07-30 17:45:14 -07001148 sp<IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001149
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001150 InputWindowCommands mPendingInputWindowCommands GUARDED_BY(mStateLock);
1151 // Should only be accessed by the main thread.
chaviw273171b2018-12-26 11:46:30 -08001152 InputWindowCommands mInputWindowCommands;
Marissa Wallebc2c052019-01-16 19:16:55 -08001153
Daniel Solomon42d04562019-01-20 21:03:19 -08001154 ui::DisplayPrimaries mInternalDisplayPrimaries;
chaviw291d88a2019-02-14 10:33:58 -08001155
1156 sp<SetInputWindowsListener> mSetInputWindowsListener;
chaviw95ef3c42019-02-14 10:55:09 -08001157 bool mPendingSyncInputWindows GUARDED_BY(mStateLock);
Romain Guy0147a172017-06-01 13:53:56 -07001158};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001159}; // namespace android
1160
1161#endif // ANDROID_SURFACE_FLINGER_H