blob: 4da0803f67bc8db95281bbc3b651d0feb1d6f4a2 [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;
David Sodman105b7dc2017-11-04 20:28:14 -070095class SurfaceFlingerBE;
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080096
chaviwa76b2712017-09-20 12:02:26 -070097typedef std::function<void(const LayerVector::Visitor&)> TraverseLayersFunction;
98
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080099namespace dvr {
100class VrFlinger;
101} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800102
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800103// ---------------------------------------------------------------------------
104
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800105enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700106 eTransactionNeeded = 0x01,
107 eTraversalNeeded = 0x02,
108 eDisplayTransactionNeeded = 0x04,
109 eTransactionMask = 0x07
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800110};
111
David Sodman105b7dc2017-11-04 20:28:14 -0700112class SurfaceFlingerBE
113{
114public:
115 SurfaceFlingerBE();
116
117 // The current hardware composer interface.
118 //
119 // The following thread safety rules apply when accessing mHwc, either
120 // directly or via getHwComposer():
121 //
122 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
123 // only when switching into and out of vr. Recreating mHwc must only be
124 // done on the main thread.
125 //
126 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
127 // mStateLock.
128 //
129 // 3. When accessing mHwc on a thread other than the main thread, we always
130 // need to acquire mStateLock. This is because the main thread could be
131 // in the process of destroying the current mHwc instance.
132 //
133 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
134 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
135 // destroy it, so it's always safe to access mHwc from any thread without
136 // acquiring mStateLock.
137 std::unique_ptr<HWComposer> mHwc;
138
David Sodmanbc815282017-11-05 18:57:52 -0800139 const std::string mHwcServiceName; // "default" for real use, something else for testing.
140
141 // constant members (no synchronization needed for access)
142 std::unique_ptr<RenderEngine> mRenderEngine;
143 EGLContext mEGLContext;
144 EGLDisplay mEGLDisplay;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800145
David Sodman73beded2017-11-15 11:56:06 -0800146 FenceTimeline mGlCompositionDoneTimeline;
147 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800148
David Sodman99974d22017-11-28 12:04:33 -0800149 // protected by mCompositorTimingLock;
150 mutable std::mutex mCompositorTimingLock;
151 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800152
David Sodman99974d22017-11-28 12:04:33 -0800153 // Only accessed from the main thread.
154 struct CompositePresentTime {
155 nsecs_t composite { -1 };
156 std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
157 };
158 std::queue<CompositePresentTime> mCompositePresentTimes;
159
David Sodman4a36e932017-11-07 14:29:47 -0800160 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
161 nsecs_t mFrameBuckets[NUM_BUCKETS];
162 nsecs_t mTotalTime;
163 std::atomic<nsecs_t> mLastSwapTime;
164
David Sodmancbaf0832017-11-07 14:21:36 -0800165 // Double- vs. triple-buffering stats
166 struct BufferingStats {
167 BufferingStats()
168 : numSegments(0),
169 totalTime(0),
170 twoBufferTime(0),
171 doubleBufferedTime(0),
172 tripleBufferedTime(0) {}
173
174 size_t numSegments;
175 nsecs_t totalTime;
176
177 // "Two buffer" means that a third buffer was never used, whereas
178 // "double-buffered" means that on average the segment only used two
179 // buffers (though it may have used a third for some part of the
180 // segment)
181 nsecs_t twoBufferTime;
182 nsecs_t doubleBufferedTime;
183 nsecs_t tripleBufferedTime;
184 };
185 mutable Mutex mBufferingStatsMutex;
186 std::unordered_map<std::string, BufferingStats> mBufferingStats;
187
David Sodman105b7dc2017-11-04 20:28:14 -0700188 // The composer sequence id is a monotonically increasing integer that we
189 // use to differentiate callbacks from different hardware composer
190 // instances. Each hardware composer instance gets a different sequence id.
191 int32_t mComposerSequenceId;
192};
193
194
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700195class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700196 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700197 private IBinder::DeathRecipient,
Steven Thomasb02664d2017-07-26 18:48:28 -0700198 private HWC2::ComposerCallback
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800199{
200public:
David Sodman105b7dc2017-11-04 20:28:14 -0700201 SurfaceFlingerBE& getBE() { return mBE; }
202 const SurfaceFlingerBE& getBE() const { return mBE; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800203
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800204 // This is the phase offset in nanoseconds of the software vsync event
205 // relative to the vsync event reported by HWComposer. The software vsync
206 // event is when SurfaceFlinger and Choreographer-based applications run each
207 // frame.
208 //
209 // This phase offset allows adjustment of the minimum latency from application
210 // wake-up time (by Choreographer) to the time at which the resulting window
211 // image is displayed. This value may be either positive (after the HW vsync)
212 // or negative (before the HW vsync). Setting it to 0 will result in a lower
213 // latency bound of two vsync periods because the app and SurfaceFlinger
214 // will run just after the HW vsync. Setting it to a positive number will
215 // result in the minimum latency being:
216 //
217 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
218 //
219 // Note that reducing this latency makes it more likely for the applications
220 // to not have their window content image ready in time. When this happens
221 // the latency will end up being an additional vsync period, and animations
222 // will hiccup. Therefore, this latency should be tuned somewhat
223 // conservatively (or at least with awareness of the trade-off being made).
224 static int64_t vsyncPhaseOffsetNs;
225 static int64_t sfVsyncPhaseOffsetNs;
226
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800227 // If fences from sync Framework are supported.
228 static bool hasSyncFramework;
229
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700230 // The offset in nanoseconds to use when DispSync timestamps present fence
231 // signaling time.
232 static int64_t dispSyncPresentTimeOffset;
233
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700234 // Some hardware can do RGB->YUV conversion more efficiently in hardware
235 // controlled by HWC than in hardware controlled by the video encoder.
236 // This instruct VirtualDisplaySurface to use HWC for such conversion on
237 // GL composition.
238 static bool useHwcForRgbToYuv;
239
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800240 // Maximum dimension supported by HWC for virtual display.
241 // Equal to min(max_height, max_width).
242 static uint64_t maxVirtualDisplaySize;
243
Fabien Sanglard1971b632017-03-10 14:50:03 -0800244 // Controls the number of buffers SurfaceFlinger will allocate for use in
245 // FramebufferSurface
246 static int64_t maxFrameBufferAcquiredBuffers;
247
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600248 // Indicate if platform supports color management on its
249 // wide-color display. This is typically found on devices
250 // with wide gamut (e.g. Display-P3) display.
251 // This also allows devices with wide-color displays that don't
252 // want to support color management to disable color management.
253 static bool hasWideColorDisplay;
254
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700255 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700256 return "SurfaceFlinger";
257 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800258
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700259 SurfaceFlinger() ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800260
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700261 // must be called before clients can connect
262 void init() ANDROID_API;
263
264 // starts SurfaceFlinger main loop in the current thread
265 void run() ANDROID_API;
266
Mathias Agopian86303202012-07-24 22:46:10 -0700267 enum {
268 EVENT_VSYNC = HWC_EVENT_VSYNC
269 };
270
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700271 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700272 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 -0800273
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700274 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700275 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 -0800276
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700277 // force full composition on all displays
278 void repaintEverything();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700279 // Can only be called from the main thread or with mStateLock held
280 void repaintEverythingLocked();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800281
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700282 // returns the default Display
Tomasz Wasilczyk8722a312017-04-13 19:14:30 +0000283 sp<const DisplayDevice> getDefaultDisplayDevice() const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700284 Mutex::Autolock _l(mStateLock);
285 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700286 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700287
Mathias Agopian86303202012-07-24 22:46:10 -0700288 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700289 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700290
Mathias Agopian86303202012-07-24 22:46:10 -0700291 // enable/disable h/w composer event
292 // TODO: this should be made accessible only to EventThread
Dan Stoza9e56aa02015-11-02 13:00:03 -0800293 void setVsyncEnabled(int disp, int enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700294
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700295 // called on the main thread by MessageQueue when an internal message
296 // is received
297 // TODO: this should be made accessible only to MessageQueue
298 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700299
Mathias Agopiancb558572012-10-04 15:58:54 -0700300 // for debugging only
301 // TODO: this should be made accessible only to HWComposer
Jesse Hall48bc05b2013-03-21 14:06:52 -0700302 const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id);
Mathias Agopiancb558572012-10-04 15:58:54 -0700303
Mathias Agopian875d8e12013-06-07 15:35:48 -0700304 RenderEngine& getRenderEngine() const {
David Sodmanbc815282017-11-05 18:57:52 -0800305 return *getBE().mRenderEngine;
Jesse Hall29c3f352013-05-21 15:36:55 -0700306 }
307
Robert Carr0d480722017-01-10 16:42:54 -0800308 bool authenticateSurfaceTextureLocked(
309 const sp<IGraphicBufferProducer>& bufferProducer) const;
310
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700311private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700312 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800313 friend class DisplayEventConnection;
Irvel468051e2016-06-13 16:44:44 -0700314 friend class EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800315 friend class Layer;
David Sodman0c69cad2017-08-21 12:12:51 -0700316 friend class BufferLayer;
Dan Stozab9b08832014-03-13 11:55:57 -0700317 friend class MonitoredProducer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800318
Jamie Gennis6547ff42013-07-16 20:12:42 -0700319 // This value is specified in number of frames. Log frame stats at most
320 // every half hour.
321 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
322
Dan Stoza7d89d062015-04-30 13:29:25 -0700323 static const size_t MAX_LAYERS = 4096;
324
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700325 // We're reference counted, never destroy SurfaceFlinger directly
326 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800327
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700328 /* ------------------------------------------------------------------------
329 * Internal data structures
330 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800331
Robert Carr2047fae2016-11-28 14:09:09 -0800332 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800333 public:
Dan Stoza412903f2017-04-27 13:42:17 -0700334 explicit State(LayerVector::StateSet set) : stateSet(set) {}
335 State& operator=(const State& other) {
336 // We explicitly don't copy stateSet so that, e.g., mDrawingState
337 // always uses the Drawing StateSet.
338 layersSortedByZ = other.layersSortedByZ;
339 displays = other.displays;
340 return *this;
341 }
342
343 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700344 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700345 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800346
Dan Stoza412903f2017-04-27 13:42:17 -0700347 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
348 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800349 };
350
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700351 /* ------------------------------------------------------------------------
352 * IBinder interface
353 */
354 virtual status_t onTransact(uint32_t code, const Parcel& data,
355 Parcel* reply, uint32_t flags);
Vishnu Nair35798872017-10-06 16:00:36 -0700356 virtual status_t dump(int fd, const Vector<String16>& args) { return priorityDump(fd, args); }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800357
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700358 /* ------------------------------------------------------------------------
359 * ISurfaceComposer interface
360 */
361 virtual sp<ISurfaceComposerClient> createConnection();
Robert Carr1db73f62016-12-21 12:58:51 -0800362 virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700363 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
Jesse Hall6c913be2013-08-08 12:15:49 -0700364 virtual void destroyDisplay(const sp<IBinder>& display);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700365 virtual sp<IBinder> getBuiltInDisplay(int32_t id);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700366 virtual void setTransactionState(const Vector<ComposerState>& state,
Mathias Agopian8b33f032012-07-24 20:43:54 -0700367 const Vector<DisplayState>& displays, uint32_t flags);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700368 virtual void bootFinished();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700369 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800370 const sp<IGraphicBufferProducer>& bufferProducer) const;
Brian Anderson6b376712017-04-04 10:51:39 -0700371 virtual status_t getSupportedFrameTimestamps(
372 std::vector<FrameEvent>* outSupported) const;
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700373 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
374 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp);
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000375 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
376 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
377 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
378 ISurfaceComposer::Rotation rotation);
379 virtual status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
chaviw7206d492017-11-10 16:16:12 -0800380 const Rect& sourceCrop, float frameScale);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700381 virtual status_t getDisplayStats(const sp<IBinder>& display,
382 DisplayStatInfo* stats);
Dan Stoza7f7da322014-05-02 15:26:25 -0700383 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
384 Vector<DisplayInfo>* configs);
385 virtual int getActiveConfig(const sp<IBinder>& display);
Michael Wright28f24d02016-07-12 13:30:53 -0700386 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
387 Vector<android_color_mode_t>* configs);
388 virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
389 virtual status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700390 virtual void setPowerMode(const sp<IBinder>& display, int mode);
Dan Stoza7f7da322014-05-02 15:26:25 -0700391 virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
Svetoslavd85084b2014-03-20 10:28:31 -0700392 virtual status_t clearAnimationFrameStats();
393 virtual status_t getAnimationFrameStats(FrameStats* outStats) const;
Dan Stozac4f471e2016-03-24 09:31:08 -0700394 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
395 HdrCapabilities* outCapabilities) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700396 virtual status_t enableVSyncInjections(bool enable);
397 virtual status_t injectVSync(nsecs_t when);
Kalle Raitaa099a242017-01-11 11:17:29 -0800398 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700399
Mathias Agopian1b031492012-06-20 17:51:20 -0700400
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700401 /* ------------------------------------------------------------------------
402 * DeathRecipient interface
403 */
404 virtual void binderDied(const wp<IBinder>& who);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800405
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700406 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700407 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700408 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700409 virtual void onFirstRef();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800410
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700411 /* ------------------------------------------------------------------------
Steven Thomasb02664d2017-07-26 18:48:28 -0700412 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700413 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700414 void onVsyncReceived(int32_t sequenceId, hwc2_display_t display,
415 int64_t timestamp) override;
416 void onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
Lloyd Pique715a2c12017-12-14 17:18:08 -0800417 HWC2::Connection connection) override;
Steven Thomasb02664d2017-07-26 18:48:28 -0700418 void onRefreshReceived(int32_t sequenceId, hwc2_display_t display) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700419
420 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700421 * Message handling
422 */
423 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700424 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700425 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700426 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700427 void signalLayerUpdate();
428 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800429
Andy McFadden13a082e2012-08-24 10:16:42 -0700430 // called on the main thread in response to initializeDisplays()
431 void onInitializeDisplays();
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700432 // called on the main thread in response to setActiveConfig()
433 void setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700434 // called on the main thread in response to setPowerMode()
Steven Thomasb02664d2017-07-26 18:48:28 -0700435 void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode,
436 bool stateLockHeld);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800437
Michael Wright28f24d02016-07-12 13:30:53 -0700438 // Called on the main thread in response to setActiveColorMode()
439 void setActiveColorModeInternal(const sp<DisplayDevice>& hw, android_color_mode_t colorMode);
440
Dan Stoza6b9454d2014-11-07 16:00:59 -0800441 // Returns whether the transaction actually modified any state
442 bool handleMessageTransaction();
443
444 // Returns whether a new buffer has been latched (see handlePageFlip())
445 bool handleMessageInvalidate();
446
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700447 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700448
Mathias Agopian87baae12012-07-31 12:38:26 -0700449 void handleTransaction(uint32_t transactionFlags);
450 void handleTransactionLocked(uint32_t transactionFlags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800451
Riley Andrews03414a12014-07-01 14:22:59 -0700452 void updateCursorAsync();
453
Dan Stoza6b9454d2014-11-07 16:00:59 -0800454 /* handlePageFlip - latch a new buffer if available and compute the dirty
455 * region. Returns whether a new buffer has been latched, i.e., whether it
456 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700457 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800458 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800459
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700460 /* ------------------------------------------------------------------------
461 * Transactions
462 */
463 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800464 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700465 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700466 uint32_t setTransactionFlags(uint32_t flags);
467 void commitTransaction();
Mathias Agopian3f844832013-08-07 21:24:32 -0700468 uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700469 uint32_t setDisplayStateLocked(const DisplayState& s);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800470
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700471 /* ------------------------------------------------------------------------
472 * Layer management
473 */
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700474 status_t createLayer(const String8& name, const sp<Client>& client,
475 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -0500476 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
477 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800478
David Sodman0c69cad2017-08-21 12:12:51 -0700479 status_t createBufferLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700480 uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
481 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
482 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800483
chaviw13fdc492017-06-27 12:40:18 -0700484 status_t createColorLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700485 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
David Sodman0c69cad2017-08-21 12:12:51 -0700486 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700487
Cody Northropbc755282017-03-31 12:00:08 -0600488 String8 getUniqueLayerName(const String8& name);
489
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700490 // called in response to the window-manager calling
491 // ISurfaceComposerClient::destroySurface()
Mathias Agopianac9fa422013-02-11 16:40:36 -0800492 status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle);
Mathias Agopianb9494d52012-04-18 02:28:45 -0700493
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700494 // called when all clients have released all their references to
495 // this layer meaning it is entirely safe to destroy all
496 // resources associated to this layer.
Mathias Agopian13127d82013-03-05 17:47:11 -0800497 status_t onLayerDestroyed(const wp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700498
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700499 // remove a layer from SurfaceFlinger immediately
Chia-I Wu515dc9c2017-06-15 12:53:59 -0700500 status_t removeLayer(const sp<Layer>& layer, bool topLevelOnly = false);
Mathias Agopiana4912602012-07-12 14:25:33 -0700501
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700502 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700503 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700504 const sp<IBinder>& handle,
505 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -0700506 const sp<Layer>& lbc,
507 const sp<Layer>& parent);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700508
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700509 /* ------------------------------------------------------------------------
510 * Boot animation, on/off animations and screen capture
511 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700512
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700513 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700514
chaviwa76b2712017-09-20 12:02:26 -0700515 void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
516 bool yswap, bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700517 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000518 sp<GraphicBuffer>* outBuffer,
chaviwa76b2712017-09-20 12:02:26 -0700519 bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700520 status_t captureScreenImplLocked(const RenderArea& renderArea,
521 TraverseLayersFunction traverseLayers,
522 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Robert Carr03480e22018-01-04 16:02:06 -0800523 bool forSystem, int* outSyncFd);
chaviwa76b2712017-09-20 12:02:26 -0700524 void traverseLayersInDisplay(const sp<const DisplayDevice>& display, int32_t minLayerZ,
525 int32_t maxLayerZ, const LayerVector::Visitor& visitor);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700526
Wei Wangf9b05ee2017-07-19 20:59:39 -0700527 sp<StartPropertySetThread> mStartPropertySetThread = nullptr;
Wei Wangb254fa32017-01-31 17:43:23 -0800528
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700529 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700530 * Properties
531 */
532 void readPersistentProperties();
533
534 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700535 * EGL
536 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700537 size_t getMaxTextureSize() const;
538 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700539
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700540 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700541 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700542 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700543 // called when starting, or restarting after system_server death
544 void initializeDisplays();
545
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700546 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700547 Mutex::Autolock _l(mStateLock);
548 return getDisplayDeviceLocked(dpy);
549 }
550
551 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
552 Mutex::Autolock _l(mStateLock);
553 return getDisplayDeviceLocked(dpy);
554 }
555
556 // NOTE: can only be called from the main thread or with mStateLock held
557 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) const {
Mathias Agopian92a979a2012-08-02 18:32:23 -0700558 return mDisplays.valueFor(dpy);
559 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700560
561 // NOTE: can only be called from the main thread or with mStateLock held
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700562 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) {
Mathias Agopian42977342012-08-05 00:40:46 -0700563 return mDisplays.valueFor(dpy);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700564 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700565
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700566 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
567 return getDisplayDeviceLocked(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
568 }
569
Michael Wright28f24d02016-07-12 13:30:53 -0700570 int32_t getDisplayType(const sp<IBinder>& display) {
571 if (!display.get()) return NAME_NOT_FOUND;
572 for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
573 if (display == mBuiltinDisplays[i]) {
574 return i;
575 }
576 }
577 return NAME_NOT_FOUND;
578 }
579
Mathias Agopian87baae12012-07-31 12:38:26 -0700580 // mark a region of a layer stack dirty. this updates the dirty
581 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700582 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700583
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700584 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700585 * H/W composer
586 */
587
David Sodman105b7dc2017-11-04 20:28:14 -0700588 HWComposer& getHwComposer() const { return *getBE().mHwc; }
Mathias Agopian86303202012-07-24 22:46:10 -0700589
Mathias Agopian888c8222012-08-04 21:10:38 -0700590 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700591 * Compositing
592 */
593 void invalidateHwcGeometry();
Chia-I Wuab0c3192017-08-01 11:29:00 -0700594 void computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Mathias Agopian87baae12012-07-31 12:38:26 -0700595 Region& dirtyRegion, Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700596
Brian Andersond6927fb2016-07-23 23:37:30 -0700597 void preComposition(nsecs_t refreshStartTime);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800598 void postComposition(nsecs_t refreshStartTime);
599 void updateCompositorTiming(
600 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
601 std::shared_ptr<FenceTime>& presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -0800602 void setCompositorTimingSnapped(
603 nsecs_t vsyncPhase, nsecs_t vsyncInterval,
604 nsecs_t compositeToPresentLatency);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700605 void rebuildLayerStacks();
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600606
607 // Given a dataSpace, returns the appropriate color_mode to use
608 // to display that dataSpace.
Romain Guy0147a172017-06-01 13:53:56 -0700609 android_color_mode pickColorMode(android_dataspace dataSpace) const;
610 android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b) const;
611
612 mat4 computeSaturationMatrix() const;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600613
Mathias Agopiancd60f992012-08-16 16:28:27 -0700614 void setUpHWComposer();
615 void doComposition();
616 void doDebugFlashRegions();
Adrian Roos1e1a1282017-11-01 19:05:31 +0100617 void doTracing(const char* where);
Fabien Sanglard830b8472016-11-30 16:35:58 -0800618 void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700619
620 // compose surfaces for display hw. this fails if using GL and the surface
621 // has been destroyed and is no longer valid.
Chia-I Wub02087d2017-11-09 10:19:54 -0800622 bool doComposeSurfaces(const sp<const DisplayDevice>& displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700623
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700624 void postFramebuffer();
Fabien Sanglard830b8472016-11-30 16:35:58 -0800625 void drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700626
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700627 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700628 * Display management
629 */
Lloyd Pique715a2c12017-12-14 17:18:08 -0800630 DisplayDevice::DisplayType determineDisplayType(hwc2_display_t display,
631 HWC2::Connection connection) const;
Lloyd Pique347200f2017-12-14 17:00:15 -0800632 void processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -0800633 void processDisplayHotplugEventsLocked();
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700634
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700635 /* ------------------------------------------------------------------------
636 * VSync
637 */
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800638 void enableHardwareVsync();
639 void resyncToHardwareVsync(bool makeAvailable);
640 void disableHardwareVsync(bool makeUnavailable);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700641
Tim Murray4a4e4a22016-04-19 16:29:23 +0000642public:
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800643 void resyncWithRateLimit();
644 void getCompositorTiming(CompositorTiming* compositorTiming);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000645private:
Jamie Gennis0bceb842012-08-23 20:19:38 -0700646
647 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700648 * Debugging & dumpsys
649 */
Vishnu Nair35798872017-10-06 16:00:36 -0700650public:
Vishnu Nair6a408532017-10-24 09:11:27 -0700651 status_t dumpCritical(int fd, const Vector<String16>& /*args*/, bool asProto) {
652 return doDump(fd, Vector<String16>(), asProto);
Vishnu Nair35798872017-10-06 16:00:36 -0700653 }
654
Vishnu Nair6a408532017-10-24 09:11:27 -0700655 status_t dumpAll(int fd, const Vector<String16>& args, bool asProto) {
656 return doDump(fd, args, asProto);
657 }
658
Vishnu Nair35798872017-10-06 16:00:36 -0700659private:
Mathias Agopian3f844832013-08-07 21:24:32 -0700660 void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
661 void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
662 void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
663 void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
Keun young Park63f165f2012-08-31 10:53:36 -0700664 bool startDdmConnection();
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800665 void appendSfConfigString(String8& result) const;
Mathias Agopiand5556842013-09-19 17:08:37 -0700666 void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
chaviwa76b2712017-09-20 12:02:26 -0700667 TraverseLayersFunction traverseLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800668
Jamie Gennis6547ff42013-07-16 20:12:42 -0700669 void logFrameStats();
670
Dan Stozab90cf072015-03-05 11:05:59 -0800671 void dumpStaticScreenStats(String8& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700672 // Not const because each Layer needs to query Fences and cache timestamps.
673 void dumpFrameEventsLocked(String8& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800674
Dan Stozae77c7662016-05-13 11:37:28 -0700675 void recordBufferingStats(const char* layerName,
676 std::vector<OccupancyTracker::Segment>&& history);
677 void dumpBufferingStats(String8& result) const;
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -0600678 void dumpWideColorInfo(String8& result) const;
Jorim Jaggi8e0af362017-11-14 16:28:28 +0100679 LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const;
Dan Stozae77c7662016-05-13 11:37:28 -0700680
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800681 bool isLayerTripleBufferingDisabled() const {
682 return this->mLayerTripleBufferingDisabled;
683 }
Vishnu Nair6a408532017-10-24 09:11:27 -0700684 status_t doDump(int fd, const Vector<String16>& args, bool asProto);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800685
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800686 /* ------------------------------------------------------------------------
687 * VrFlinger
688 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700689 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800690
Steven Thomas050b2c82017-03-06 11:45:16 -0800691 // Check to see if we should handoff to vr flinger.
692 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800693
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700694 /* ------------------------------------------------------------------------
695 * Attributes
696 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800697
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700698 // access must be protected by mStateLock
699 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700700 State mCurrentState{LayerVector::StateSet::Current};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700701 volatile int32_t mTransactionFlags;
702 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700703 bool mTransactionPending;
704 bool mAnimTransactionPending;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700705 SortedVector< sp<Layer> > mLayersPendingRemoval;
Mathias Agopian67106042013-03-14 19:18:13 -0700706 SortedVector< wp<IBinder> > mGraphicBufferProducerList;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800707
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700708 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700709 bool mLayersRemoved;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700710 bool mLayersAdded;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700711
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700712 // access must be protected by mInvalidateLock
Mathias Agopian87baae12012-07-31 12:38:26 -0700713 volatile int32_t mRepaintEverything;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700714
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800715 // constant members (no synchronization needed for access)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700716 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700717 bool mGpuToCpuSupported;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700718 sp<EventThread> mEventThread;
Jamie Gennis0a645cc2013-10-14 20:52:46 -0700719 sp<EventThread> mSFEventThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700720 sp<EventThread> mInjectorEventThread;
721 sp<InjectVSyncSource> mVSyncInjector;
Jamie Gennisd1700752013-10-14 12:22:52 -0700722 sp<EventControlThread> mEventControlThread;
Jesse Hall9e663de2013-08-16 14:28:37 -0700723 sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
Mathias Agopian3094df32012-06-18 18:06:45 -0700724
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700725 // Can only accessed from the main thread, these members
726 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700727 State mDrawingState{LayerVector::StateSet::Drawing};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700728 bool mVisibleRegionsDirty;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800729 bool mGeometryInvalid;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800730 bool mAnimCompositionPending;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800731 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700732 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
733 bool mHadClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700734
Lloyd Piqueba04e622017-12-14 17:11:26 -0800735 struct HotplugEvent {
736 hwc2_display_t display;
737 HWC2::Connection connection = HWC2::Connection::Invalid;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800738 };
739 // protected by mStateLock
740 std::vector<HotplugEvent> mPendingHotplugEvents;
741
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700742 // this may only be written from the main thread with mStateLock held
743 // it may be read from other threads with mStateLock held
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700744 DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700745
746 // don't use a lock for these, we don't care
747 int mDebugRegion;
748 int mDebugDDMS;
749 int mDebugDisableHWC;
750 int mDebugDisableTransformHint;
751 volatile nsecs_t mDebugInSwapBuffers;
752 nsecs_t mLastSwapBufferTime;
753 volatile nsecs_t mDebugInTransaction;
754 nsecs_t mLastTransactionTime;
755 bool mBootFinished;
Dan Stozaee44edd2015-03-23 15:50:23 -0700756 bool mForceFullDamage;
Dan Stozac5da2712016-07-20 15:38:12 -0700757 bool mPropagateBackpressure = true;
Irvel468051e2016-06-13 16:44:44 -0700758 SurfaceInterceptor mInterceptor;
Adrian Roos1e1a1282017-11-01 19:05:31 +0100759 SurfaceTracing mTracing;
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800760 bool mUseHwcVirtualDisplays = false;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700761
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800762 // Restrict layers to use two buffers in their bufferqueues.
763 bool mLayerTripleBufferingDisabled = false;
764
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700765 // these are thread safe
766 mutable MessageQueue mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800767 FrameTracker mAnimFrameTracker;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700768 DispSync mPrimaryDispSync;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700769
770 // protected by mDestroyedLayerLock;
771 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -0800772 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700773
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700774 // protected by mHWVsyncLock
775 Mutex mHWVsyncLock;
776 bool mPrimaryHWVsyncEnabled;
Jesse Hall948fe0c2013-10-14 12:56:09 -0700777 bool mHWVsyncAvailable;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700778
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700779 std::atomic<bool> mRefreshPending{false};
780
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700781 /* ------------------------------------------------------------------------
782 * Feature prototyping
783 */
784
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700785 bool mInjectVSyncs;
786
Mathias Agopianff2ed702013-09-01 21:36:12 -0700787 Daltonizer mDaltonizer;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700788
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700789 mat4 mPreviousColorMatrix;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700790 mat4 mColorMatrix;
Romain Guya9638732017-06-01 12:05:21 -0700791 bool mHasColorMatrix;
Dan Stozab90cf072015-03-05 11:05:59 -0800792
793 // Static screen stats
794 bool mHasPoweredOff;
Dan Stozae77c7662016-05-13 11:37:28 -0700795
Robert Carr1f0a16a2016-10-24 16:27:39 -0700796 size_t mNumLayers;
797
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -0700798
799 // Verify that transaction is being called by an approved process:
800 // either AID_GRAPHICS or AID_SYSTEM.
801 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800802
Steven Thomasb02664d2017-07-26 18:48:28 -0700803 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Steven Thomas050b2c82017-03-06 11:45:16 -0800804 std::atomic<bool> mVrFlingerRequestsDisplay;
805 static bool useVrFlinger;
Steven Thomasb02664d2017-07-26 18:48:28 -0700806 std::thread::id mMainThreadId;
Romain Guy0147a172017-06-01 13:53:56 -0700807
808 float mSaturation = 1.0f;
Romain Guy54f154a2017-10-24 21:40:32 +0100809 bool mForceNativeColorMode = false;
David Sodman105b7dc2017-11-04 20:28:14 -0700810
811 SurfaceFlingerBE mBE;
Romain Guy0147a172017-06-01 13:53:56 -0700812};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800813}; // namespace android
814
815#endif // ANDROID_SURFACE_FLINGER_H