blob: 974de9493053ec494ae57ecbd449cb9476fba24f [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 Agopian3f844832013-08-07 21:24:32 -070024/*
25 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
26 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070027
Glenn Kasten99ed2242011-12-15 09:51:17 -080028#include <cutils/compiler.h>
29
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080030#include <utils/Atomic.h>
31#include <utils/Errors.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070032#include <utils/KeyedVector.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070033#include <utils/RefBase.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070034#include <utils/SortedVector.h>
35#include <utils/threads.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080036
Brian Anderson3d4039d2016-09-23 16:31:30 -070037#include <ui/FenceTime.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080038#include <ui/PixelFormat.h>
Mathias Agopian1d77b712017-02-17 15:46:13 -080039#include <math/mat4.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070040
Brian Anderson0a61b0c2016-12-07 14:55:56 -080041#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080042#include <gui/ISurfaceComposer.h>
43#include <gui/ISurfaceComposerClient.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070044#include <gui/LayerState.h>
45
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
Vishnu Nair35798872017-10-06 16:00:36 -070050#include <serviceutils/PriorityDumper.h>
51
Michael Wright28f24d02016-07-12 13:30:53 -070052#include <system/graphics.h>
53
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"
Adrian Roos1e1a1282017-11-01 19:05:31 +010061#include "SurfaceTracing.h"
Wei Wangf9b05ee2017-07-19 20:59:39 -070062#include "StartPropertySetThread.h"
Mathias Agopianf1d8e872009-04-20 19:39:12 -070063
Steven Thomasb02664d2017-07-26 18:48:28 -070064#include "DisplayHardware/HWC2.h"
Mathias Agopian86303202012-07-24 22:46:10 -070065#include "DisplayHardware/HWComposer.h"
Steven Thomasb02664d2017-07-26 18:48:28 -070066
Mathias Agopianff2ed702013-09-01 21:36:12 -070067#include "Effects/Daltonizer.h"
Mathias Agopian86303202012-07-24 22:46:10 -070068
Dan Stozae77c7662016-05-13 11:37:28 -070069#include <map>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080070#include <mutex>
71#include <queue>
Dan Stozae77c7662016-05-13 11:37:28 -070072#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070073#include <thread>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080074#include <utility>
chaviwa76b2712017-09-20 12:02:26 -070075#include "RenderArea.h"
Dan Stozae77c7662016-05-13 11:37:28 -070076
chaviw1d044282017-09-27 12:19:28 -070077#include <layerproto/LayerProtoHeader.h>
78
79using namespace android::surfaceflinger;
80
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080081namespace android {
82
83// ---------------------------------------------------------------------------
84
85class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080086class DisplayEventConnection;
87class EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080088class Layer;
chaviw13fdc492017-06-27 12:40:18 -070089class ColorLayer;
Mathias Agopiane3c697f2013-02-14 17:11:02 -080090class Surface;
Mathias Agopian875d8e12013-06-07 15:35:48 -070091class RenderEngine;
Jamie Gennisd1700752013-10-14 12:22:52 -070092class EventControlThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070093class VSyncSource;
94class InjectVSyncSource;
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080095
chaviwa76b2712017-09-20 12:02:26 -070096typedef std::function<void(const LayerVector::Visitor&)> TraverseLayersFunction;
97
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080098namespace dvr {
99class VrFlinger;
100} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800101
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800102// ---------------------------------------------------------------------------
103
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800104enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700105 eTransactionNeeded = 0x01,
106 eTraversalNeeded = 0x02,
107 eDisplayTransactionNeeded = 0x04,
108 eTransactionMask = 0x07
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800109};
110
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700111class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700112 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700113 private IBinder::DeathRecipient,
Steven Thomasb02664d2017-07-26 18:48:28 -0700114 private HWC2::ComposerCallback
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800115{
116public:
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800117
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800118 // This is the phase offset in nanoseconds of the software vsync event
119 // relative to the vsync event reported by HWComposer. The software vsync
120 // event is when SurfaceFlinger and Choreographer-based applications run each
121 // frame.
122 //
123 // This phase offset allows adjustment of the minimum latency from application
124 // wake-up time (by Choreographer) to the time at which the resulting window
125 // image is displayed. This value may be either positive (after the HW vsync)
126 // or negative (before the HW vsync). Setting it to 0 will result in a lower
127 // latency bound of two vsync periods because the app and SurfaceFlinger
128 // will run just after the HW vsync. Setting it to a positive number will
129 // result in the minimum latency being:
130 //
131 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
132 //
133 // Note that reducing this latency makes it more likely for the applications
134 // to not have their window content image ready in time. When this happens
135 // the latency will end up being an additional vsync period, and animations
136 // will hiccup. Therefore, this latency should be tuned somewhat
137 // conservatively (or at least with awareness of the trade-off being made).
138 static int64_t vsyncPhaseOffsetNs;
139 static int64_t sfVsyncPhaseOffsetNs;
140
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800141 // If fences from sync Framework are supported.
142 static bool hasSyncFramework;
143
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700144 // Instruct the Render Engine to use EGL_IMG_context_priority is available.
145 static bool useContextPriority;
146
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700147 // The offset in nanoseconds to use when DispSync timestamps present fence
148 // signaling time.
149 static int64_t dispSyncPresentTimeOffset;
150
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700151 // Some hardware can do RGB->YUV conversion more efficiently in hardware
152 // controlled by HWC than in hardware controlled by the video encoder.
153 // This instruct VirtualDisplaySurface to use HWC for such conversion on
154 // GL composition.
155 static bool useHwcForRgbToYuv;
156
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800157 // Maximum dimension supported by HWC for virtual display.
158 // Equal to min(max_height, max_width).
159 static uint64_t maxVirtualDisplaySize;
160
Fabien Sanglard1971b632017-03-10 14:50:03 -0800161 // Controls the number of buffers SurfaceFlinger will allocate for use in
162 // FramebufferSurface
163 static int64_t maxFrameBufferAcquiredBuffers;
164
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600165 // Indicate if platform supports color management on its
166 // wide-color display. This is typically found on devices
167 // with wide gamut (e.g. Display-P3) display.
168 // This also allows devices with wide-color displays that don't
169 // want to support color management to disable color management.
170 static bool hasWideColorDisplay;
171
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700172 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700173 return "SurfaceFlinger";
174 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800175
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700176 SurfaceFlinger() ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800177
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700178 // must be called before clients can connect
179 void init() ANDROID_API;
180
181 // starts SurfaceFlinger main loop in the current thread
182 void run() ANDROID_API;
183
Mathias Agopian86303202012-07-24 22:46:10 -0700184 enum {
185 EVENT_VSYNC = HWC_EVENT_VSYNC
186 };
187
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700188 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700189 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 -0800190
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700191 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700192 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 -0800193
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700194 // force full composition on all displays
195 void repaintEverything();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700196 // Can only be called from the main thread or with mStateLock held
197 void repaintEverythingLocked();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800198
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700199 // returns the default Display
Tomasz Wasilczyk8722a312017-04-13 19:14:30 +0000200 sp<const DisplayDevice> getDefaultDisplayDevice() const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700201 Mutex::Autolock _l(mStateLock);
202 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700203 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700204
Mathias Agopian86303202012-07-24 22:46:10 -0700205 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700206 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700207
Mathias Agopian86303202012-07-24 22:46:10 -0700208 // enable/disable h/w composer event
209 // TODO: this should be made accessible only to EventThread
Dan Stoza9e56aa02015-11-02 13:00:03 -0800210 void setVsyncEnabled(int disp, int enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700211
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700212 // called on the main thread by MessageQueue when an internal message
213 // is received
214 // TODO: this should be made accessible only to MessageQueue
215 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700216
Mathias Agopiancb558572012-10-04 15:58:54 -0700217 // for debugging only
218 // TODO: this should be made accessible only to HWComposer
Jesse Hall48bc05b2013-03-21 14:06:52 -0700219 const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id);
Mathias Agopiancb558572012-10-04 15:58:54 -0700220
Mathias Agopian875d8e12013-06-07 15:35:48 -0700221 RenderEngine& getRenderEngine() const {
222 return *mRenderEngine;
Jesse Hall29c3f352013-05-21 15:36:55 -0700223 }
224
Robert Carr0d480722017-01-10 16:42:54 -0800225 bool authenticateSurfaceTextureLocked(
226 const sp<IGraphicBufferProducer>& bufferProducer) const;
227
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700228private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700229 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800230 friend class DisplayEventConnection;
Irvel468051e2016-06-13 16:44:44 -0700231 friend class EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800232 friend class Layer;
David Sodman0c69cad2017-08-21 12:12:51 -0700233 friend class BufferLayer;
Dan Stozab9b08832014-03-13 11:55:57 -0700234 friend class MonitoredProducer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800235
Jamie Gennis6547ff42013-07-16 20:12:42 -0700236 // This value is specified in number of frames. Log frame stats at most
237 // every half hour.
238 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
239
Dan Stoza7d89d062015-04-30 13:29:25 -0700240 static const size_t MAX_LAYERS = 4096;
241
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700242 // We're reference counted, never destroy SurfaceFlinger directly
243 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800244
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700245 /* ------------------------------------------------------------------------
246 * Internal data structures
247 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800248
Robert Carr2047fae2016-11-28 14:09:09 -0800249 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800250 public:
Dan Stoza412903f2017-04-27 13:42:17 -0700251 explicit State(LayerVector::StateSet set) : stateSet(set) {}
252 State& operator=(const State& other) {
253 // We explicitly don't copy stateSet so that, e.g., mDrawingState
254 // always uses the Drawing StateSet.
255 layersSortedByZ = other.layersSortedByZ;
256 displays = other.displays;
257 return *this;
258 }
259
260 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700261 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700262 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800263
Dan Stoza412903f2017-04-27 13:42:17 -0700264 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
265 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800266 };
267
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700268 /* ------------------------------------------------------------------------
269 * IBinder interface
270 */
271 virtual status_t onTransact(uint32_t code, const Parcel& data,
272 Parcel* reply, uint32_t flags);
Vishnu Nair35798872017-10-06 16:00:36 -0700273 virtual status_t dump(int fd, const Vector<String16>& args) { return priorityDump(fd, args); }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800274
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700275 /* ------------------------------------------------------------------------
276 * ISurfaceComposer interface
277 */
278 virtual sp<ISurfaceComposerClient> createConnection();
Robert Carr1db73f62016-12-21 12:58:51 -0800279 virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700280 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
Jesse Hall6c913be2013-08-08 12:15:49 -0700281 virtual void destroyDisplay(const sp<IBinder>& display);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700282 virtual sp<IBinder> getBuiltInDisplay(int32_t id);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700283 virtual void setTransactionState(const Vector<ComposerState>& state,
Mathias Agopian8b33f032012-07-24 20:43:54 -0700284 const Vector<DisplayState>& displays, uint32_t flags);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700285 virtual void bootFinished();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700286 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800287 const sp<IGraphicBufferProducer>& bufferProducer) const;
Brian Anderson6b376712017-04-04 10:51:39 -0700288 virtual status_t getSupportedFrameTimestamps(
289 std::vector<FrameEvent>* outSupported) const;
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700290 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
291 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp);
chaviwa252d892017-11-20 17:54:25 -0800292 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
293 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
294 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
295 ISurfaceComposer::Rotation rotation);
296 virtual status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
chaviw7206d492017-11-10 16:16:12 -0800297 const Rect& sourceCrop, float frameScale);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700298 virtual status_t getDisplayStats(const sp<IBinder>& display,
299 DisplayStatInfo* stats);
Dan Stoza7f7da322014-05-02 15:26:25 -0700300 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
301 Vector<DisplayInfo>* configs);
302 virtual int getActiveConfig(const sp<IBinder>& display);
Michael Wright28f24d02016-07-12 13:30:53 -0700303 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
304 Vector<android_color_mode_t>* configs);
305 virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
306 virtual status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700307 virtual void setPowerMode(const sp<IBinder>& display, int mode);
Dan Stoza7f7da322014-05-02 15:26:25 -0700308 virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
Svetoslavd85084b2014-03-20 10:28:31 -0700309 virtual status_t clearAnimationFrameStats();
310 virtual status_t getAnimationFrameStats(FrameStats* outStats) const;
Dan Stozac4f471e2016-03-24 09:31:08 -0700311 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
312 HdrCapabilities* outCapabilities) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700313 virtual status_t enableVSyncInjections(bool enable);
314 virtual status_t injectVSync(nsecs_t when);
Kalle Raitaa099a242017-01-11 11:17:29 -0800315 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700316
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 Thomasb02664d2017-07-26 18:48:28 -0700329 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700330 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700331 void onVsyncReceived(int32_t sequenceId, hwc2_display_t display,
332 int64_t timestamp) override;
333 void onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
334 HWC2::Connection connection,
335 bool primaryDisplay) override;
336 void onRefreshReceived(int32_t sequenceId, hwc2_display_t display) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700337
338 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700339 * Message handling
340 */
341 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700342 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700343 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700344 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700345 void signalLayerUpdate();
346 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800347
Andy McFadden13a082e2012-08-24 10:16:42 -0700348 // called on the main thread in response to initializeDisplays()
349 void onInitializeDisplays();
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700350 // called on the main thread in response to setActiveConfig()
351 void setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700352 // called on the main thread in response to setPowerMode()
Steven Thomasb02664d2017-07-26 18:48:28 -0700353 void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode,
354 bool stateLockHeld);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800355
Michael Wright28f24d02016-07-12 13:30:53 -0700356 // Called on the main thread in response to setActiveColorMode()
357 void setActiveColorModeInternal(const sp<DisplayDevice>& hw, android_color_mode_t colorMode);
358
Dan Stoza6b9454d2014-11-07 16:00:59 -0800359 // Returns whether the transaction actually modified any state
360 bool handleMessageTransaction();
361
362 // Returns whether a new buffer has been latched (see handlePageFlip())
363 bool handleMessageInvalidate();
364
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700365 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700366
Mathias Agopian87baae12012-07-31 12:38:26 -0700367 void handleTransaction(uint32_t transactionFlags);
368 void handleTransactionLocked(uint32_t transactionFlags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800369
Riley Andrews03414a12014-07-01 14:22:59 -0700370 void updateCursorAsync();
371
Dan Stoza6b9454d2014-11-07 16:00:59 -0800372 /* handlePageFlip - latch a new buffer if available and compute the dirty
373 * region. Returns whether a new buffer has been latched, i.e., whether it
374 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700375 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800376 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800377
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700378 /* ------------------------------------------------------------------------
379 * Transactions
380 */
381 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800382 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700383 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700384 uint32_t setTransactionFlags(uint32_t flags);
385 void commitTransaction();
Mathias Agopian3f844832013-08-07 21:24:32 -0700386 uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700387 uint32_t setDisplayStateLocked(const DisplayState& s);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800388
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700389 /* ------------------------------------------------------------------------
390 * Layer management
391 */
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700392 status_t createLayer(const String8& name, const sp<Client>& client,
393 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -0500394 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
395 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800396
David Sodman0c69cad2017-08-21 12:12:51 -0700397 status_t createBufferLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700398 uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
399 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
400 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800401
chaviw13fdc492017-06-27 12:40:18 -0700402 status_t createColorLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700403 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
David Sodman0c69cad2017-08-21 12:12:51 -0700404 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700405
Cody Northropbc755282017-03-31 12:00:08 -0600406 String8 getUniqueLayerName(const String8& name);
407
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700408 // called in response to the window-manager calling
409 // ISurfaceComposerClient::destroySurface()
Mathias Agopianac9fa422013-02-11 16:40:36 -0800410 status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle);
Mathias Agopianb9494d52012-04-18 02:28:45 -0700411
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700412 // called when all clients have released all their references to
413 // this layer meaning it is entirely safe to destroy all
414 // resources associated to this layer.
Mathias Agopian13127d82013-03-05 17:47:11 -0800415 status_t onLayerDestroyed(const wp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700416
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700417 // remove a layer from SurfaceFlinger immediately
Chia-I Wu515dc9c2017-06-15 12:53:59 -0700418 status_t removeLayer(const sp<Layer>& layer, bool topLevelOnly = false);
Mathias Agopiana4912602012-07-12 14:25:33 -0700419
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700420 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700421 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700422 const sp<IBinder>& handle,
423 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -0700424 const sp<Layer>& lbc,
425 const sp<Layer>& parent);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700426
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700427 /* ------------------------------------------------------------------------
428 * Boot animation, on/off animations and screen capture
429 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700430
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700431 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700432
chaviwa76b2712017-09-20 12:02:26 -0700433 void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
434 bool yswap, bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700435 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
chaviwa252d892017-11-20 17:54:25 -0800436 sp<GraphicBuffer>* outBuffer,
chaviwa76b2712017-09-20 12:02:26 -0700437 bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700438 status_t captureScreenImplLocked(const RenderArea& renderArea,
439 TraverseLayersFunction traverseLayers,
440 ANativeWindowBuffer* buffer, bool useIdentityTransform,
chaviwa252d892017-11-20 17:54:25 -0800441 int* outSyncFd);
chaviwa76b2712017-09-20 12:02:26 -0700442 void traverseLayersInDisplay(const sp<const DisplayDevice>& display, int32_t minLayerZ,
443 int32_t maxLayerZ, const LayerVector::Visitor& visitor);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700444
Wei Wangf9b05ee2017-07-19 20:59:39 -0700445 sp<StartPropertySetThread> mStartPropertySetThread = nullptr;
Wei Wangb254fa32017-01-31 17:43:23 -0800446
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700447 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700448 * Properties
449 */
450 void readPersistentProperties();
451
452 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700453 * EGL
454 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700455 size_t getMaxTextureSize() const;
456 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700457
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700458 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700459 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700460 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700461 // called when starting, or restarting after system_server death
462 void initializeDisplays();
463
Jesse Hall692c7232012-11-08 15:41:56 -0800464 // Create an IBinder for a builtin display and add it to current state
465 void createBuiltinDisplayLocked(DisplayDevice::DisplayType type);
466
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700467
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700468 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700469 Mutex::Autolock _l(mStateLock);
470 return getDisplayDeviceLocked(dpy);
471 }
472
473 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
474 Mutex::Autolock _l(mStateLock);
475 return getDisplayDeviceLocked(dpy);
476 }
477
478 // NOTE: can only be called from the main thread or with mStateLock held
479 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) const {
Mathias Agopian92a979a2012-08-02 18:32:23 -0700480 return mDisplays.valueFor(dpy);
481 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700482
483 // NOTE: can only be called from the main thread or with mStateLock held
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700484 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) {
Mathias Agopian42977342012-08-05 00:40:46 -0700485 return mDisplays.valueFor(dpy);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700486 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700487
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700488 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
489 return getDisplayDeviceLocked(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
490 }
491
492 void createDefaultDisplayDevice();
493
Michael Wright28f24d02016-07-12 13:30:53 -0700494 int32_t getDisplayType(const sp<IBinder>& display) {
495 if (!display.get()) return NAME_NOT_FOUND;
496 for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
497 if (display == mBuiltinDisplays[i]) {
498 return i;
499 }
500 }
501 return NAME_NOT_FOUND;
502 }
503
Mathias Agopian87baae12012-07-31 12:38:26 -0700504 // mark a region of a layer stack dirty. this updates the dirty
505 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700506 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700507
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700508 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700509 * H/W composer
510 */
511
512 HWComposer& getHwComposer() const { return *mHwc; }
513
Mathias Agopian888c8222012-08-04 21:10:38 -0700514 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700515 * Compositing
516 */
517 void invalidateHwcGeometry();
Chia-I Wuab0c3192017-08-01 11:29:00 -0700518 void computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Mathias Agopian87baae12012-07-31 12:38:26 -0700519 Region& dirtyRegion, Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700520
Brian Andersond6927fb2016-07-23 23:37:30 -0700521 void preComposition(nsecs_t refreshStartTime);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800522 void postComposition(nsecs_t refreshStartTime);
523 void updateCompositorTiming(
524 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
525 std::shared_ptr<FenceTime>& presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -0800526 void setCompositorTimingSnapped(
527 nsecs_t vsyncPhase, nsecs_t vsyncInterval,
528 nsecs_t compositeToPresentLatency);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700529 void rebuildLayerStacks();
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600530
531 // Given a dataSpace, returns the appropriate color_mode to use
532 // to display that dataSpace.
Romain Guy0147a172017-06-01 13:53:56 -0700533 android_color_mode pickColorMode(android_dataspace dataSpace) const;
534 android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b) const;
535
536 mat4 computeSaturationMatrix() const;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600537
Mathias Agopiancd60f992012-08-16 16:28:27 -0700538 void setUpHWComposer();
539 void doComposition();
540 void doDebugFlashRegions();
Adrian Roos1e1a1282017-11-01 19:05:31 +0100541 void doTracing(const char* where);
Fabien Sanglard830b8472016-11-30 16:35:58 -0800542 void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700543
544 // compose surfaces for display hw. this fails if using GL and the surface
545 // has been destroyed and is no longer valid.
Chia-I Wub02087d2017-11-09 10:19:54 -0800546 bool doComposeSurfaces(const sp<const DisplayDevice>& displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700547
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700548 void postFramebuffer();
Fabien Sanglard830b8472016-11-30 16:35:58 -0800549 void drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700550
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700551 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700552 * Display management
553 */
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700554
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700555 /* ------------------------------------------------------------------------
556 * VSync
557 */
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800558 void enableHardwareVsync();
559 void resyncToHardwareVsync(bool makeAvailable);
560 void disableHardwareVsync(bool makeUnavailable);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700561
Tim Murray4a4e4a22016-04-19 16:29:23 +0000562public:
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800563 void resyncWithRateLimit();
564 void getCompositorTiming(CompositorTiming* compositorTiming);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000565private:
Jamie Gennis0bceb842012-08-23 20:19:38 -0700566
567 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700568 * Debugging & dumpsys
569 */
Vishnu Nair35798872017-10-06 16:00:36 -0700570public:
Vishnu Nair6a408532017-10-24 09:11:27 -0700571 status_t dumpCritical(int fd, const Vector<String16>& /*args*/, bool asProto) {
572 return doDump(fd, Vector<String16>(), asProto);
Vishnu Nair35798872017-10-06 16:00:36 -0700573 }
574
Vishnu Nair6a408532017-10-24 09:11:27 -0700575 status_t dumpAll(int fd, const Vector<String16>& args, bool asProto) {
576 return doDump(fd, args, asProto);
577 }
578
Vishnu Nair35798872017-10-06 16:00:36 -0700579private:
Mathias Agopian3f844832013-08-07 21:24:32 -0700580 void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
581 void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
582 void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
583 void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
Keun young Park63f165f2012-08-31 10:53:36 -0700584 bool startDdmConnection();
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800585 void appendSfConfigString(String8& result) const;
Mathias Agopiand5556842013-09-19 17:08:37 -0700586 void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
chaviwa76b2712017-09-20 12:02:26 -0700587 TraverseLayersFunction traverseLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800588
Jamie Gennis6547ff42013-07-16 20:12:42 -0700589 void logFrameStats();
590
Dan Stozab90cf072015-03-05 11:05:59 -0800591 void dumpStaticScreenStats(String8& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700592 // Not const because each Layer needs to query Fences and cache timestamps.
593 void dumpFrameEventsLocked(String8& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800594
Dan Stozae77c7662016-05-13 11:37:28 -0700595 void recordBufferingStats(const char* layerName,
596 std::vector<OccupancyTracker::Segment>&& history);
597 void dumpBufferingStats(String8& result) const;
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -0600598 void dumpWideColorInfo(String8& result) const;
Jorim Jaggi8e0af362017-11-14 16:28:28 +0100599 LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const;
Dan Stozae77c7662016-05-13 11:37:28 -0700600
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800601 bool isLayerTripleBufferingDisabled() const {
602 return this->mLayerTripleBufferingDisabled;
603 }
Vishnu Nair6a408532017-10-24 09:11:27 -0700604 status_t doDump(int fd, const Vector<String16>& args, bool asProto);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800605
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800606 /* ------------------------------------------------------------------------
607 * VrFlinger
608 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700609 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800610
Steven Thomas050b2c82017-03-06 11:45:16 -0800611 // Check to see if we should handoff to vr flinger.
612 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800613
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700614 /* ------------------------------------------------------------------------
615 * Attributes
616 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800617
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700618 // access must be protected by mStateLock
619 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700620 State mCurrentState{LayerVector::StateSet::Current};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700621 volatile int32_t mTransactionFlags;
622 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700623 bool mTransactionPending;
624 bool mAnimTransactionPending;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700625 SortedVector< sp<Layer> > mLayersPendingRemoval;
Mathias Agopian67106042013-03-14 19:18:13 -0700626 SortedVector< wp<IBinder> > mGraphicBufferProducerList;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800627
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700628 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700629 bool mLayersRemoved;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700630 bool mLayersAdded;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700631
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700632 // access must be protected by mInvalidateLock
Mathias Agopian87baae12012-07-31 12:38:26 -0700633 volatile int32_t mRepaintEverything;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700634
Steven Thomas6d8110b2017-08-31 18:24:21 -0700635 // The current hardware composer interface.
636 //
637 // The following thread safety rules apply when accessing mHwc, either
638 // directly or via getHwComposer():
639 //
640 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
641 // only when switching into and out of vr. Recreating mHwc must only be
642 // done on the main thread.
643 //
644 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
645 // mStateLock.
646 //
647 // 3. When accessing mHwc on a thread other than the main thread, we always
648 // need to acquire mStateLock. This is because the main thread could be
649 // in the process of destroying the current mHwc instance.
650 //
651 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
652 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
653 // destroy it, so it's always safe to access mHwc from any thread without
654 // acquiring mStateLock.
Steven Thomasb02664d2017-07-26 18:48:28 -0700655 std::unique_ptr<HWComposer> mHwc;
656
Kalle Raitaa099a242017-01-11 11:17:29 -0800657 const std::string mHwcServiceName; // "default" for real use, something else for testing.
Steven Thomasb02664d2017-07-26 18:48:28 -0700658
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800659 // constant members (no synchronization needed for access)
Chia-I Wub2c76242017-11-09 17:17:07 -0800660 std::unique_ptr<RenderEngine> mRenderEngine;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700661 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700662 bool mGpuToCpuSupported;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700663 sp<EventThread> mEventThread;
Jamie Gennis0a645cc2013-10-14 20:52:46 -0700664 sp<EventThread> mSFEventThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700665 sp<EventThread> mInjectorEventThread;
666 sp<InjectVSyncSource> mVSyncInjector;
Jamie Gennisd1700752013-10-14 12:22:52 -0700667 sp<EventControlThread> mEventControlThread;
Jesse Hall9e663de2013-08-16 14:28:37 -0700668 sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
Mathias Agopian3094df32012-06-18 18:06:45 -0700669
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700670 // Can only accessed from the main thread, these members
671 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700672 State mDrawingState{LayerVector::StateSet::Drawing};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700673 bool mVisibleRegionsDirty;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800674 bool mGeometryInvalid;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800675 bool mAnimCompositionPending;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800676 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700677 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
678 bool mHadClientComposition = false;
Brian Anderson3d4039d2016-09-23 16:31:30 -0700679 FenceTimeline mGlCompositionDoneTimeline;
680 FenceTimeline mDisplayTimeline;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700681
682 // this may only be written from the main thread with mStateLock held
683 // it may be read from other threads with mStateLock held
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700684 DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700685
686 // don't use a lock for these, we don't care
687 int mDebugRegion;
688 int mDebugDDMS;
689 int mDebugDisableHWC;
690 int mDebugDisableTransformHint;
691 volatile nsecs_t mDebugInSwapBuffers;
692 nsecs_t mLastSwapBufferTime;
693 volatile nsecs_t mDebugInTransaction;
694 nsecs_t mLastTransactionTime;
695 bool mBootFinished;
Dan Stozaee44edd2015-03-23 15:50:23 -0700696 bool mForceFullDamage;
Dan Stozac5da2712016-07-20 15:38:12 -0700697 bool mPropagateBackpressure = true;
Irvel468051e2016-06-13 16:44:44 -0700698 SurfaceInterceptor mInterceptor;
Adrian Roos1e1a1282017-11-01 19:05:31 +0100699 SurfaceTracing mTracing;
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800700 bool mUseHwcVirtualDisplays = false;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700701
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800702 // Restrict layers to use two buffers in their bufferqueues.
703 bool mLayerTripleBufferingDisabled = false;
704
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700705 // these are thread safe
706 mutable MessageQueue mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800707 FrameTracker mAnimFrameTracker;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700708 DispSync mPrimaryDispSync;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700709
710 // protected by mDestroyedLayerLock;
711 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -0800712 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700713
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700714 // protected by mHWVsyncLock
715 Mutex mHWVsyncLock;
716 bool mPrimaryHWVsyncEnabled;
Jesse Hall948fe0c2013-10-14 12:56:09 -0700717 bool mHWVsyncAvailable;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700718
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800719 // protected by mCompositorTimingLock;
Brian Andersond0010582017-03-07 13:20:31 -0800720 mutable std::mutex mCompositorTimingLock;
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800721 CompositorTiming mCompositorTiming;
722
723 // Only accessed from the main thread.
724 struct CompositePresentTime {
725 nsecs_t composite { -1 };
726 std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
727 };
728 std::queue<CompositePresentTime> mCompositePresentTimes;
729
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700730 std::atomic<bool> mRefreshPending{false};
731
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700732 /* ------------------------------------------------------------------------
733 * Feature prototyping
734 */
735
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700736 bool mInjectVSyncs;
737
Mathias Agopianff2ed702013-09-01 21:36:12 -0700738 Daltonizer mDaltonizer;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700739
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700740 mat4 mPreviousColorMatrix;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700741 mat4 mColorMatrix;
Romain Guya9638732017-06-01 12:05:21 -0700742 bool mHasColorMatrix;
Dan Stozab90cf072015-03-05 11:05:59 -0800743
744 // Static screen stats
745 bool mHasPoweredOff;
746 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
747 nsecs_t mFrameBuckets[NUM_BUCKETS];
748 nsecs_t mTotalTime;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000749 std::atomic<nsecs_t> mLastSwapTime;
Dan Stozae77c7662016-05-13 11:37:28 -0700750
Robert Carr1f0a16a2016-10-24 16:27:39 -0700751 size_t mNumLayers;
752
Dan Stozae77c7662016-05-13 11:37:28 -0700753 // Double- vs. triple-buffering stats
754 struct BufferingStats {
755 BufferingStats()
756 : numSegments(0),
757 totalTime(0),
758 twoBufferTime(0),
759 doubleBufferedTime(0),
760 tripleBufferedTime(0) {}
761
762 size_t numSegments;
763 nsecs_t totalTime;
764
765 // "Two buffer" means that a third buffer was never used, whereas
766 // "double-buffered" means that on average the segment only used two
767 // buffers (though it may have used a third for some part of the
768 // segment)
769 nsecs_t twoBufferTime;
770 nsecs_t doubleBufferedTime;
771 nsecs_t tripleBufferedTime;
772 };
773 mutable Mutex mBufferingStatsMutex;
774 std::unordered_map<std::string, BufferingStats> mBufferingStats;
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -0700775
776 // Verify that transaction is being called by an approved process:
777 // either AID_GRAPHICS or AID_SYSTEM.
778 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800779
Steven Thomasb02664d2017-07-26 18:48:28 -0700780 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Steven Thomas050b2c82017-03-06 11:45:16 -0800781 std::atomic<bool> mVrFlingerRequestsDisplay;
782 static bool useVrFlinger;
Steven Thomasb02664d2017-07-26 18:48:28 -0700783 std::thread::id mMainThreadId;
784 // The composer sequence id is a monotonically increasing integer that we
785 // use to differentiate callbacks from different hardware composer
786 // instances. Each hardware composer instance gets a different sequence id.
787 int32_t mComposerSequenceId;
Romain Guy0147a172017-06-01 13:53:56 -0700788
789 float mSaturation = 1.0f;
Romain Guy54f154a2017-10-24 21:40:32 +0100790 bool mForceNativeColorMode = false;
Romain Guy0147a172017-06-01 13:53:56 -0700791};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800792}; // namespace android
793
794#endif // ANDROID_SURFACE_FLINGER_H