blob: 13a057f2b67b7c7915633c6eb27f9763712008e6 [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
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080020#include <memory>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021#include <stdint.h>
22#include <sys/types.h>
23
Mathias Agopian921e6ac2012-07-23 23:11:29 -070024#include <EGL/egl.h>
Mathias Agopian3f844832013-08-07 21:24:32 -070025
26/*
27 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
28 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070029
Glenn Kasten99ed2242011-12-15 09:51:17 -080030#include <cutils/compiler.h>
31
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080032#include <utils/Atomic.h>
33#include <utils/Errors.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070034#include <utils/KeyedVector.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070035#include <utils/RefBase.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070036#include <utils/SortedVector.h>
37#include <utils/threads.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080038
Brian Anderson3d4039d2016-09-23 16:31:30 -070039#include <ui/FenceTime.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080040#include <ui/PixelFormat.h>
Mathias Agopian1d77b712017-02-17 15:46:13 -080041#include <math/mat4.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070042
Brian Anderson0a61b0c2016-12-07 14:55:56 -080043#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080044#include <gui/ISurfaceComposer.h>
45#include <gui/ISurfaceComposerClient.h>
Dan Stozae77c7662016-05-13 11:37:28 -070046#include <gui/OccupancyTracker.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080047
Mathias Agopian86303202012-07-24 22:46:10 -070048#include <hardware/hwcomposer_defs.h>
49
Michael Wright28f24d02016-07-12 13:30:53 -070050#include <system/graphics.h>
51
Mathias Agopian921e6ac2012-07-23 23:11:29 -070052#include <private/gui/LayerState.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080053
Mathias Agopian921e6ac2012-07-23 23:11:29 -070054#include "Barrier.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070055#include "DisplayDevice.h"
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070056#include "DispSync.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080057#include "FrameTracker.h"
Robert Carr2047fae2016-11-28 14:09:09 -080058#include "LayerVector.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080059#include "MessageQueue.h"
Irvel468051e2016-06-13 16:44:44 -070060#include "SurfaceInterceptor.h"
Wei Wangf9b05ee2017-07-19 20:59:39 -070061#include "StartPropertySetThread.h"
Mathias Agopianf1d8e872009-04-20 19:39:12 -070062
Steven Thomasd7f49c52017-07-26 18:48:28 -070063#ifdef USE_HWC2
64#include "DisplayHardware/HWC2.h"
Mathias Agopian86303202012-07-24 22:46:10 -070065#include "DisplayHardware/HWComposer.h"
Steven Thomasd7f49c52017-07-26 18:48:28 -070066#else
67#include "DisplayHardware/HWComposer_hwc1.h"
68#endif
69
Mathias Agopianff2ed702013-09-01 21:36:12 -070070#include "Effects/Daltonizer.h"
Mathias Agopian86303202012-07-24 22:46:10 -070071
Dan Stozae77c7662016-05-13 11:37:28 -070072#include <map>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080073#include <mutex>
74#include <queue>
Dan Stozae77c7662016-05-13 11:37:28 -070075#include <string>
Steven Thomasd7f49c52017-07-26 18:48:28 -070076#include <thread>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080077#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070078
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080079namespace android {
80
81// ---------------------------------------------------------------------------
82
83class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080084class DisplayEventConnection;
85class EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080086class Layer;
Mathias Agopianb7e930d2010-06-01 15:12:58 -070087class LayerDim;
Mathias Agopiane3c697f2013-02-14 17:11:02 -080088class Surface;
Mathias Agopian875d8e12013-06-07 15:35:48 -070089class RenderEngine;
Jamie Gennisd1700752013-10-14 12:22:52 -070090class EventControlThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070091class VSyncSource;
92class InjectVSyncSource;
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080093
94namespace dvr {
95class VrFlinger;
96} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080097
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080098// ---------------------------------------------------------------------------
99
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800100enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700101 eTransactionNeeded = 0x01,
102 eTraversalNeeded = 0x02,
103 eDisplayTransactionNeeded = 0x04,
104 eTransactionMask = 0x07
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800105};
106
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700107class SurfaceFlinger : public BnSurfaceComposer,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700108 private IBinder::DeathRecipient,
Steven Thomasd7f49c52017-07-26 18:48:28 -0700109#ifdef USE_HWC2
110 private HWC2::ComposerCallback
111#else
Mathias Agopian86303202012-07-24 22:46:10 -0700112 private HWComposer::EventHandler
Steven Thomasd7f49c52017-07-26 18:48:28 -0700113#endif
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800114{
115public:
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800116
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800117 // This is the phase offset in nanoseconds of the software vsync event
118 // relative to the vsync event reported by HWComposer. The software vsync
119 // event is when SurfaceFlinger and Choreographer-based applications run each
120 // frame.
121 //
122 // This phase offset allows adjustment of the minimum latency from application
123 // wake-up time (by Choreographer) to the time at which the resulting window
124 // image is displayed. This value may be either positive (after the HW vsync)
125 // or negative (before the HW vsync). Setting it to 0 will result in a lower
126 // latency bound of two vsync periods because the app and SurfaceFlinger
127 // will run just after the HW vsync. Setting it to a positive number will
128 // result in the minimum latency being:
129 //
130 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
131 //
132 // Note that reducing this latency makes it more likely for the applications
133 // to not have their window content image ready in time. When this happens
134 // the latency will end up being an additional vsync period, and animations
135 // will hiccup. Therefore, this latency should be tuned somewhat
136 // conservatively (or at least with awareness of the trade-off being made).
137 static int64_t vsyncPhaseOffsetNs;
138 static int64_t sfVsyncPhaseOffsetNs;
139
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800140 // If fences from sync Framework are supported.
141 static bool hasSyncFramework;
142
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700143 // Instruct the Render Engine to use EGL_IMG_context_priority is available.
144 static bool useContextPriority;
145
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700146 // The offset in nanoseconds to use when DispSync timestamps present fence
147 // signaling time.
148 static int64_t dispSyncPresentTimeOffset;
149
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700150 // Some hardware can do RGB->YUV conversion more efficiently in hardware
151 // controlled by HWC than in hardware controlled by the video encoder.
152 // This instruct VirtualDisplaySurface to use HWC for such conversion on
153 // GL composition.
154 static bool useHwcForRgbToYuv;
155
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800156 // Maximum dimension supported by HWC for virtual display.
157 // Equal to min(max_height, max_width).
158 static uint64_t maxVirtualDisplaySize;
159
Fabien Sanglard1971b632017-03-10 14:50:03 -0800160 // Controls the number of buffers SurfaceFlinger will allocate for use in
161 // FramebufferSurface
162 static int64_t maxFrameBufferAcquiredBuffers;
163
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600164 // Indicate if platform supports color management on its
165 // wide-color display. This is typically found on devices
166 // with wide gamut (e.g. Display-P3) display.
167 // This also allows devices with wide-color displays that don't
168 // want to support color management to disable color management.
169 static bool hasWideColorDisplay;
170
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700171 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700172 return "SurfaceFlinger";
173 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800174
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700175 SurfaceFlinger() ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800176
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700177 // must be called before clients can connect
178 void init() ANDROID_API;
179
180 // starts SurfaceFlinger main loop in the current thread
181 void run() ANDROID_API;
182
Mathias Agopian86303202012-07-24 22:46:10 -0700183 enum {
184 EVENT_VSYNC = HWC_EVENT_VSYNC
185 };
186
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700187 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700188 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 -0800189
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700190 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700191 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 -0800192
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700193 // force full composition on all displays
194 void repaintEverything();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700195 // Can only be called from the main thread or with mStateLock held
196 void repaintEverythingLocked();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800197
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700198 // returns the default Display
Tomasz Wasilczyk8722a312017-04-13 19:14:30 +0000199 sp<const DisplayDevice> getDefaultDisplayDevice() const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700200 Mutex::Autolock _l(mStateLock);
201 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700202 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700203
Mathias Agopian86303202012-07-24 22:46:10 -0700204 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700205 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700206
Mathias Agopian86303202012-07-24 22:46:10 -0700207 // enable/disable h/w composer event
208 // TODO: this should be made accessible only to EventThread
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000209#ifdef USE_HWC2
Dan Stoza9e56aa02015-11-02 13:00:03 -0800210 void setVsyncEnabled(int disp, int enabled);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000211#else
212 void eventControl(int disp, int event, int enabled);
213#endif
Mathias Agopian86303202012-07-24 22:46:10 -0700214
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700215 // called on the main thread by MessageQueue when an internal message
216 // is received
217 // TODO: this should be made accessible only to MessageQueue
218 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700219
Mathias Agopiancb558572012-10-04 15:58:54 -0700220 // for debugging only
221 // TODO: this should be made accessible only to HWComposer
Jesse Hall48bc05b2013-03-21 14:06:52 -0700222 const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id);
Mathias Agopiancb558572012-10-04 15:58:54 -0700223
Mathias Agopian875d8e12013-06-07 15:35:48 -0700224 RenderEngine& getRenderEngine() const {
225 return *mRenderEngine;
Jesse Hall29c3f352013-05-21 15:36:55 -0700226 }
227
Robert Carr0d480722017-01-10 16:42:54 -0800228 bool authenticateSurfaceTextureLocked(
229 const sp<IGraphicBufferProducer>& bufferProducer) const;
230
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700231private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700232 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800233 friend class DisplayEventConnection;
Irvel468051e2016-06-13 16:44:44 -0700234 friend class EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800235 friend class Layer;
Dan Stozab9b08832014-03-13 11:55:57 -0700236 friend class MonitoredProducer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800237
Jamie Gennis6547ff42013-07-16 20:12:42 -0700238 // This value is specified in number of frames. Log frame stats at most
239 // every half hour.
240 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
241
Dan Stoza7d89d062015-04-30 13:29:25 -0700242 static const size_t MAX_LAYERS = 4096;
243
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700244 // We're reference counted, never destroy SurfaceFlinger directly
245 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800246
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700247 /* ------------------------------------------------------------------------
248 * Internal data structures
249 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800250
Robert Carr2047fae2016-11-28 14:09:09 -0800251 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800252 public:
Dan Stoza412903f2017-04-27 13:42:17 -0700253 explicit State(LayerVector::StateSet set) : stateSet(set) {}
254 State& operator=(const State& other) {
255 // We explicitly don't copy stateSet so that, e.g., mDrawingState
256 // always uses the Drawing StateSet.
257 layersSortedByZ = other.layersSortedByZ;
258 displays = other.displays;
259 return *this;
260 }
261
262 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700263 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700264 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800265
Dan Stoza412903f2017-04-27 13:42:17 -0700266 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
267 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800268 };
269
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700270 /* ------------------------------------------------------------------------
271 * IBinder interface
272 */
273 virtual status_t onTransact(uint32_t code, const Parcel& data,
274 Parcel* reply, uint32_t flags);
275 virtual status_t dump(int fd, const Vector<String16>& args);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800276
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700277 /* ------------------------------------------------------------------------
278 * ISurfaceComposer interface
279 */
280 virtual sp<ISurfaceComposerClient> createConnection();
Robert Carr1db73f62016-12-21 12:58:51 -0800281 virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700282 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
Jesse Hall6c913be2013-08-08 12:15:49 -0700283 virtual void destroyDisplay(const sp<IBinder>& display);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700284 virtual sp<IBinder> getBuiltInDisplay(int32_t id);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700285 virtual void setTransactionState(const Vector<ComposerState>& state,
Mathias Agopian8b33f032012-07-24 20:43:54 -0700286 const Vector<DisplayState>& displays, uint32_t flags);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700287 virtual void bootFinished();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700288 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800289 const sp<IGraphicBufferProducer>& bufferProducer) const;
Brian Anderson6b376712017-04-04 10:51:39 -0700290 virtual status_t getSupportedFrameTimestamps(
291 std::vector<FrameEvent>* outSupported) const;
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700292 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
293 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp);
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800294 virtual status_t captureScreen(const sp<IBinder>& display,
295 const sp<IGraphicBufferProducer>& producer,
Dan Stozac1879002014-05-22 15:59:05 -0700296 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -0800297 int32_t minLayerZ, int32_t maxLayerZ,
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700298 bool useIdentityTransform, ISurfaceComposer::Rotation rotation);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700299 virtual status_t getDisplayStats(const sp<IBinder>& display,
300 DisplayStatInfo* stats);
Dan Stoza7f7da322014-05-02 15:26:25 -0700301 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
302 Vector<DisplayInfo>* configs);
303 virtual int getActiveConfig(const sp<IBinder>& display);
Michael Wright28f24d02016-07-12 13:30:53 -0700304 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
305 Vector<android_color_mode_t>* configs);
306 virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
307 virtual status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700308 virtual void setPowerMode(const sp<IBinder>& display, int mode);
Dan Stoza7f7da322014-05-02 15:26:25 -0700309 virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
Svetoslavd85084b2014-03-20 10:28:31 -0700310 virtual status_t clearAnimationFrameStats();
311 virtual status_t getAnimationFrameStats(FrameStats* outStats) const;
Dan Stozac4f471e2016-03-24 09:31:08 -0700312 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
313 HdrCapabilities* outCapabilities) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700314 virtual status_t enableVSyncInjections(bool enable);
315 virtual status_t injectVSync(nsecs_t when);
316
Mathias Agopian1b031492012-06-20 17:51:20 -0700317
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700318 /* ------------------------------------------------------------------------
319 * DeathRecipient interface
320 */
321 virtual void binderDied(const wp<IBinder>& who);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800322
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700323 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700324 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700325 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700326 virtual void onFirstRef();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800327
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700328 /* ------------------------------------------------------------------------
Steven Thomasd7f49c52017-07-26 18:48:28 -0700329 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700330 */
Steven Thomasd7f49c52017-07-26 18:48:28 -0700331#ifdef USE_HWC2
332 void onVsyncReceived(int32_t sequenceId, hwc2_display_t display,
333 int64_t timestamp) override;
334 void onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
335 HWC2::Connection connection,
336 bool primaryDisplay) override;
337 void onRefreshReceived(int32_t sequenceId, hwc2_display_t display) override;
338#else
339 void onVSyncReceived(HWComposer* composer, int type, nsecs_t timestamp) override;
340 void onHotplugReceived(HWComposer* composer, int disp, bool connected) override;
341 void onInvalidateReceived(HWComposer* composer) override;
342#endif
Mathias Agopian86303202012-07-24 22:46:10 -0700343
344 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700345 * Message handling
346 */
347 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700348 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700349 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700350 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700351 void signalLayerUpdate();
352 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800353
Andy McFadden13a082e2012-08-24 10:16:42 -0700354 // called on the main thread in response to initializeDisplays()
355 void onInitializeDisplays();
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700356 // called on the main thread in response to setActiveConfig()
357 void setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700358 // called on the main thread in response to setPowerMode()
Steven Thomasd7f49c52017-07-26 18:48:28 -0700359#ifdef USE_HWC2
360 void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode,
361 bool stateLockHeld);
362#else
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700363 void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode);
Steven Thomasd7f49c52017-07-26 18:48:28 -0700364#endif
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800365
Michael Wright28f24d02016-07-12 13:30:53 -0700366 // Called on the main thread in response to setActiveColorMode()
367 void setActiveColorModeInternal(const sp<DisplayDevice>& hw, android_color_mode_t colorMode);
368
Dan Stoza6b9454d2014-11-07 16:00:59 -0800369 // Returns whether the transaction actually modified any state
370 bool handleMessageTransaction();
371
372 // Returns whether a new buffer has been latched (see handlePageFlip())
373 bool handleMessageInvalidate();
374
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700375 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700376
Mathias Agopian87baae12012-07-31 12:38:26 -0700377 void handleTransaction(uint32_t transactionFlags);
378 void handleTransactionLocked(uint32_t transactionFlags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800379
Riley Andrews03414a12014-07-01 14:22:59 -0700380 void updateCursorAsync();
381
Dan Stoza6b9454d2014-11-07 16:00:59 -0800382 /* handlePageFlip - latch a new buffer if available and compute the dirty
383 * region. Returns whether a new buffer has been latched, i.e., whether it
384 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700385 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800386 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800387
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700388 /* ------------------------------------------------------------------------
389 * Transactions
390 */
391 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800392 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700393 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700394 uint32_t setTransactionFlags(uint32_t flags);
395 void commitTransaction();
Mathias Agopian3f844832013-08-07 21:24:32 -0700396 uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700397 uint32_t setDisplayStateLocked(const DisplayState& s);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800398
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700399 /* ------------------------------------------------------------------------
400 * Layer management
401 */
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700402 status_t createLayer(const String8& name, const sp<Client>& client,
403 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -0500404 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
405 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800406
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700407 status_t createNormalLayer(const sp<Client>& client, const String8& name,
408 uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
409 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
410 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800411
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700412 status_t createDimLayer(const sp<Client>& client, const String8& name,
413 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
414 sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700415
Cody Northropbc755282017-03-31 12:00:08 -0600416 String8 getUniqueLayerName(const String8& name);
417
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700418 // called in response to the window-manager calling
419 // ISurfaceComposerClient::destroySurface()
Mathias Agopianac9fa422013-02-11 16:40:36 -0800420 status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle);
Mathias Agopianb9494d52012-04-18 02:28:45 -0700421
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700422 // called when all clients have released all their references to
423 // this layer meaning it is entirely safe to destroy all
424 // resources associated to this layer.
Mathias Agopian13127d82013-03-05 17:47:11 -0800425 status_t onLayerDestroyed(const wp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700426
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700427 // remove a layer from SurfaceFlinger immediately
Chia-I Wu515dc9c2017-06-15 12:53:59 -0700428 status_t removeLayer(const sp<Layer>& layer, bool topLevelOnly = false);
Mathias Agopiana4912602012-07-12 14:25:33 -0700429
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700430 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700431 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700432 const sp<IBinder>& handle,
433 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -0700434 const sp<Layer>& lbc,
435 const sp<Layer>& parent);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700436
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700437 /* ------------------------------------------------------------------------
438 * Boot animation, on/off animations and screen capture
439 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700440
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700441 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700442
Mathias Agopian180f10d2013-04-10 22:55:41 -0700443 void renderScreenImplLocked(
444 const sp<const DisplayDevice>& hw,
Dan Stozac1879002014-05-22 15:59:05 -0700445 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -0800446 int32_t minLayerZ, int32_t maxLayerZ,
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700447 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation);
Mathias Agopian180f10d2013-04-10 22:55:41 -0700448
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700449#ifdef USE_HWC2
450 status_t captureScreenImplLocked(const sp<const DisplayDevice>& device,
451 ANativeWindowBuffer* buffer, Rect sourceCrop,
452 uint32_t reqWidth, uint32_t reqHeight, int32_t minLayerZ,
453 int32_t maxLayerZ, bool useIdentityTransform,
454 Transform::orientation_flags rotation, bool isLocalScreenshot,
455 int* outSyncFd);
456#else
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800457 status_t captureScreenImplLocked(
458 const sp<const DisplayDevice>& hw,
Mathias Agopianabe815d2013-03-19 22:22:21 -0700459 const sp<IGraphicBufferProducer>& producer,
Dan Stozac1879002014-05-22 15:59:05 -0700460 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -0800461 int32_t minLayerZ, int32_t maxLayerZ,
Pablo Ceballosb5b35632016-02-23 11:18:51 -0800462 bool useIdentityTransform, Transform::orientation_flags rotation,
463 bool isLocalScreenshot);
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700464#endif
Mathias Agopianabe815d2013-03-19 22:22:21 -0700465
Wei Wangf9b05ee2017-07-19 20:59:39 -0700466 sp<StartPropertySetThread> mStartPropertySetThread = nullptr;
Wei Wangb254fa32017-01-31 17:43:23 -0800467
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700468 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700469 * Properties
470 */
471 void readPersistentProperties();
472
473 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700474 * EGL
475 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700476 size_t getMaxTextureSize() const;
477 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700478
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700479 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700480 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700481 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700482 // called when starting, or restarting after system_server death
483 void initializeDisplays();
484
Jesse Hall692c7232012-11-08 15:41:56 -0800485 // Create an IBinder for a builtin display and add it to current state
486 void createBuiltinDisplayLocked(DisplayDevice::DisplayType type);
487
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700488
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700489 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700490 Mutex::Autolock _l(mStateLock);
491 return getDisplayDeviceLocked(dpy);
492 }
493
494 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
495 Mutex::Autolock _l(mStateLock);
496 return getDisplayDeviceLocked(dpy);
497 }
498
499 // NOTE: can only be called from the main thread or with mStateLock held
500 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) const {
Mathias Agopian92a979a2012-08-02 18:32:23 -0700501 return mDisplays.valueFor(dpy);
502 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700503
504 // NOTE: can only be called from the main thread or with mStateLock held
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700505 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) {
Mathias Agopian42977342012-08-05 00:40:46 -0700506 return mDisplays.valueFor(dpy);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700507 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700508
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700509 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
510 return getDisplayDeviceLocked(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
511 }
512
513 void createDefaultDisplayDevice();
514
Michael Wright28f24d02016-07-12 13:30:53 -0700515 int32_t getDisplayType(const sp<IBinder>& display) {
516 if (!display.get()) return NAME_NOT_FOUND;
517 for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
518 if (display == mBuiltinDisplays[i]) {
519 return i;
520 }
521 }
522 return NAME_NOT_FOUND;
523 }
524
Mathias Agopian87baae12012-07-31 12:38:26 -0700525 // mark a region of a layer stack dirty. this updates the dirty
526 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700527 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700528
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000529#ifndef USE_HWC2
530 int32_t allocateHwcDisplayId(DisplayDevice::DisplayType type);
531#endif
532
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700533 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700534 * H/W composer
535 */
536
537 HWComposer& getHwComposer() const { return *mHwc; }
538
Mathias Agopian888c8222012-08-04 21:10:38 -0700539 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700540 * Compositing
541 */
542 void invalidateHwcGeometry();
Chia-I Wuab0c3192017-08-01 11:29:00 -0700543 void computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Mathias Agopian87baae12012-07-31 12:38:26 -0700544 Region& dirtyRegion, Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700545
Brian Andersond6927fb2016-07-23 23:37:30 -0700546 void preComposition(nsecs_t refreshStartTime);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800547 void postComposition(nsecs_t refreshStartTime);
548 void updateCompositorTiming(
549 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
550 std::shared_ptr<FenceTime>& presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -0800551 void setCompositorTimingSnapped(
552 nsecs_t vsyncPhase, nsecs_t vsyncInterval,
553 nsecs_t compositeToPresentLatency);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700554 void rebuildLayerStacks();
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600555
556 // Given a dataSpace, returns the appropriate color_mode to use
557 // to display that dataSpace.
Romain Guy0147a172017-06-01 13:53:56 -0700558 android_color_mode pickColorMode(android_dataspace dataSpace) const;
559 android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b) const;
560
561 mat4 computeSaturationMatrix() const;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600562
Mathias Agopiancd60f992012-08-16 16:28:27 -0700563 void setUpHWComposer();
564 void doComposition();
565 void doDebugFlashRegions();
Fabien Sanglard830b8472016-11-30 16:35:58 -0800566 void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700567
568 // compose surfaces for display hw. this fails if using GL and the surface
569 // has been destroyed and is no longer valid.
Fabien Sanglard830b8472016-11-30 16:35:58 -0800570 bool doComposeSurfaces(const sp<const DisplayDevice>& displayDevice, const Region& dirty);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700571
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700572 void postFramebuffer();
Fabien Sanglard830b8472016-11-30 16:35:58 -0800573 void drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700574
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700575 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700576 * Display management
577 */
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700578
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700579 /* ------------------------------------------------------------------------
580 * VSync
581 */
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800582 void enableHardwareVsync();
583 void resyncToHardwareVsync(bool makeAvailable);
584 void disableHardwareVsync(bool makeUnavailable);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700585
Tim Murray4a4e4a22016-04-19 16:29:23 +0000586public:
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800587 void resyncWithRateLimit();
588 void getCompositorTiming(CompositorTiming* compositorTiming);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000589private:
Jamie Gennis0bceb842012-08-23 20:19:38 -0700590
591 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700592 * Debugging & dumpsys
593 */
Mathias Agopian3f844832013-08-07 21:24:32 -0700594 void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
595 void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
596 void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
597 void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
Keun young Park63f165f2012-08-31 10:53:36 -0700598 bool startDdmConnection();
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800599 void appendSfConfigString(String8& result) const;
Mathias Agopiand5556842013-09-19 17:08:37 -0700600 void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
Mathias Agopianfee2b462013-07-03 12:34:01 -0700601 const sp<const DisplayDevice>& hw,
Robert Carrae060832016-11-28 10:51:00 -0800602 int32_t minLayerZ, int32_t maxLayerZ);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800603
Jamie Gennis6547ff42013-07-16 20:12:42 -0700604 void logFrameStats();
605
Dan Stozab90cf072015-03-05 11:05:59 -0800606 void dumpStaticScreenStats(String8& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700607 // Not const because each Layer needs to query Fences and cache timestamps.
608 void dumpFrameEventsLocked(String8& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800609
Dan Stozae77c7662016-05-13 11:37:28 -0700610 void recordBufferingStats(const char* layerName,
611 std::vector<OccupancyTracker::Segment>&& history);
612 void dumpBufferingStats(String8& result) const;
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -0600613 void dumpWideColorInfo(String8& result) const;
Dan Stozae77c7662016-05-13 11:37:28 -0700614
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800615 bool isLayerTripleBufferingDisabled() const {
616 return this->mLayerTripleBufferingDisabled;
617 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800618
619#ifdef USE_HWC2
620 /* ------------------------------------------------------------------------
621 * VrFlinger
622 */
Steven Thomasd7f49c52017-07-26 18:48:28 -0700623 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800624
Steven Thomas050b2c82017-03-06 11:45:16 -0800625 // Check to see if we should handoff to vr flinger.
626 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800627#endif
628
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700629 /* ------------------------------------------------------------------------
630 * Attributes
631 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800632
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700633 // access must be protected by mStateLock
634 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700635 State mCurrentState{LayerVector::StateSet::Current};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700636 volatile int32_t mTransactionFlags;
637 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700638 bool mTransactionPending;
639 bool mAnimTransactionPending;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700640 SortedVector< sp<Layer> > mLayersPendingRemoval;
Mathias Agopian67106042013-03-14 19:18:13 -0700641 SortedVector< wp<IBinder> > mGraphicBufferProducerList;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800642
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700643 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700644 bool mLayersRemoved;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700645 bool mLayersAdded;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700646
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700647 // access must be protected by mInvalidateLock
Mathias Agopian87baae12012-07-31 12:38:26 -0700648 volatile int32_t mRepaintEverything;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700649
Steven Thomas6d8110b2017-08-31 18:24:21 -0700650 // The current hardware composer interface.
651 //
652 // The following thread safety rules apply when accessing mHwc, either
653 // directly or via getHwComposer():
654 //
655 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
656 // only when switching into and out of vr. Recreating mHwc must only be
657 // done on the main thread.
658 //
659 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
660 // mStateLock.
661 //
662 // 3. When accessing mHwc on a thread other than the main thread, we always
663 // need to acquire mStateLock. This is because the main thread could be
664 // in the process of destroying the current mHwc instance.
665 //
666 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
667 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
668 // destroy it, so it's always safe to access mHwc from any thread without
669 // acquiring mStateLock.
Steven Thomasd7f49c52017-07-26 18:48:28 -0700670 std::unique_ptr<HWComposer> mHwc;
671
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800672 // constant members (no synchronization needed for access)
Mathias Agopian875d8e12013-06-07 15:35:48 -0700673 RenderEngine* mRenderEngine;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700674 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700675 bool mGpuToCpuSupported;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700676 sp<EventThread> mEventThread;
Jamie Gennis0a645cc2013-10-14 20:52:46 -0700677 sp<EventThread> mSFEventThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700678 sp<EventThread> mInjectorEventThread;
679 sp<InjectVSyncSource> mVSyncInjector;
Jamie Gennisd1700752013-10-14 12:22:52 -0700680 sp<EventControlThread> mEventControlThread;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700681 EGLContext mEGLContext;
Jesse Hall34a09ba2012-07-29 22:35:34 -0700682 EGLDisplay mEGLDisplay;
Jesse Hall9e663de2013-08-16 14:28:37 -0700683 sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
Mathias Agopian3094df32012-06-18 18:06:45 -0700684
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700685 // Can only accessed from the main thread, these members
686 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700687 State mDrawingState{LayerVector::StateSet::Drawing};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700688 bool mVisibleRegionsDirty;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000689#ifndef USE_HWC2
690 bool mHwWorkListDirty;
691#else
Dan Stoza9e56aa02015-11-02 13:00:03 -0800692 bool mGeometryInvalid;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000693#endif
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800694 bool mAnimCompositionPending;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000695#ifdef USE_HWC2
Dan Stoza9e56aa02015-11-02 13:00:03 -0800696 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700697 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
698 bool mHadClientComposition = false;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000699#endif
Brian Anderson3d4039d2016-09-23 16:31:30 -0700700 FenceTimeline mGlCompositionDoneTimeline;
701 FenceTimeline mDisplayTimeline;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700702
703 // this may only be written from the main thread with mStateLock held
704 // it may be read from other threads with mStateLock held
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700705 DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700706
707 // don't use a lock for these, we don't care
708 int mDebugRegion;
709 int mDebugDDMS;
710 int mDebugDisableHWC;
711 int mDebugDisableTransformHint;
712 volatile nsecs_t mDebugInSwapBuffers;
713 nsecs_t mLastSwapBufferTime;
714 volatile nsecs_t mDebugInTransaction;
715 nsecs_t mLastTransactionTime;
716 bool mBootFinished;
Dan Stozaee44edd2015-03-23 15:50:23 -0700717 bool mForceFullDamage;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000718#ifdef USE_HWC2
Dan Stozac5da2712016-07-20 15:38:12 -0700719 bool mPropagateBackpressure = true;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000720#endif
Irvel468051e2016-06-13 16:44:44 -0700721 SurfaceInterceptor mInterceptor;
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800722 bool mUseHwcVirtualDisplays = false;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700723
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800724 // Restrict layers to use two buffers in their bufferqueues.
725 bool mLayerTripleBufferingDisabled = false;
726
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700727 // these are thread safe
728 mutable MessageQueue mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800729 FrameTracker mAnimFrameTracker;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700730 DispSync mPrimaryDispSync;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700731
732 // protected by mDestroyedLayerLock;
733 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -0800734 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700735
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700736 // protected by mHWVsyncLock
737 Mutex mHWVsyncLock;
738 bool mPrimaryHWVsyncEnabled;
Jesse Hall948fe0c2013-10-14 12:56:09 -0700739 bool mHWVsyncAvailable;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700740
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800741 // protected by mCompositorTimingLock;
Brian Andersond0010582017-03-07 13:20:31 -0800742 mutable std::mutex mCompositorTimingLock;
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800743 CompositorTiming mCompositorTiming;
744
745 // Only accessed from the main thread.
746 struct CompositePresentTime {
747 nsecs_t composite { -1 };
748 std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
749 };
750 std::queue<CompositePresentTime> mCompositePresentTimes;
751
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700752 std::atomic<bool> mRefreshPending{false};
753
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700754 /* ------------------------------------------------------------------------
755 * Feature prototyping
756 */
757
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700758 bool mInjectVSyncs;
759
Mathias Agopianff2ed702013-09-01 21:36:12 -0700760 Daltonizer mDaltonizer;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000761#ifndef USE_HWC2
762 bool mDaltonize;
763#endif
Alan Viverette9c5a3332013-09-12 20:04:35 -0700764
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700765 mat4 mPreviousColorMatrix;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700766 mat4 mColorMatrix;
Romain Guya9638732017-06-01 12:05:21 -0700767 bool mHasColorMatrix;
Dan Stozab90cf072015-03-05 11:05:59 -0800768
769 // Static screen stats
770 bool mHasPoweredOff;
771 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
772 nsecs_t mFrameBuckets[NUM_BUCKETS];
773 nsecs_t mTotalTime;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000774 std::atomic<nsecs_t> mLastSwapTime;
Dan Stozae77c7662016-05-13 11:37:28 -0700775
Robert Carr1f0a16a2016-10-24 16:27:39 -0700776 size_t mNumLayers;
777
Dan Stozae77c7662016-05-13 11:37:28 -0700778 // Double- vs. triple-buffering stats
779 struct BufferingStats {
780 BufferingStats()
781 : numSegments(0),
782 totalTime(0),
783 twoBufferTime(0),
784 doubleBufferedTime(0),
785 tripleBufferedTime(0) {}
786
787 size_t numSegments;
788 nsecs_t totalTime;
789
790 // "Two buffer" means that a third buffer was never used, whereas
791 // "double-buffered" means that on average the segment only used two
792 // buffers (though it may have used a third for some part of the
793 // segment)
794 nsecs_t twoBufferTime;
795 nsecs_t doubleBufferedTime;
796 nsecs_t tripleBufferedTime;
797 };
798 mutable Mutex mBufferingStatsMutex;
799 std::unordered_map<std::string, BufferingStats> mBufferingStats;
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -0700800
801 // Verify that transaction is being called by an approved process:
802 // either AID_GRAPHICS or AID_SYSTEM.
803 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800804
805#ifdef USE_HWC2
Steven Thomasd7f49c52017-07-26 18:48:28 -0700806 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Steven Thomas050b2c82017-03-06 11:45:16 -0800807 std::atomic<bool> mVrFlingerRequestsDisplay;
808 static bool useVrFlinger;
Steven Thomasd7f49c52017-07-26 18:48:28 -0700809 std::thread::id mMainThreadId;
810 // The composer sequence id is a monotonically increasing integer that we
811 // use to differentiate callbacks from different hardware composer
812 // instances. Each hardware composer instance gets a different sequence id.
813 int32_t mComposerSequenceId;
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800814#endif
Romain Guy0147a172017-06-01 13:53:56 -0700815
816 float mSaturation = 1.0f;
817};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800818}; // namespace android
819
820#endif // ANDROID_SURFACE_FLINGER_H