blob: 01f1ac34bcefe67d0fd8ad0b91dbed2d7694b27e [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>
Steven Moreland2716e112018-02-23 14:57:20 -080029#include <cutils/atomic.h>
Glenn Kasten99ed2242011-12-15 09:51:17 -080030
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080031#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>
Dan Stoza84d619e2018-03-28 17:07:36 -070036#include <utils/Trace.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080037
Brian Anderson3d4039d2016-09-23 16:31:30 -070038#include <ui/FenceTime.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080039#include <ui/PixelFormat.h>
Mathias Agopian1d77b712017-02-17 15:46:13 -080040#include <math/mat4.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070041
Brian Anderson0a61b0c2016-12-07 14:55:56 -080042#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080043#include <gui/ISurfaceComposer.h>
44#include <gui/ISurfaceComposerClient.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070045#include <gui/LayerState.h>
46
Dan Stozae77c7662016-05-13 11:37:28 -070047#include <gui/OccupancyTracker.h>
David Sodmanaf8bab12017-12-14 15:30:55 -080048#include <gui/BufferQueue.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080049
Mathias Agopian86303202012-07-24 22:46:10 -070050#include <hardware/hwcomposer_defs.h>
51
Vishnu Nair35798872017-10-06 16:00:36 -070052#include <serviceutils/PriorityDumper.h>
53
Michael Wright28f24d02016-07-12 13:30:53 -070054#include <system/graphics.h>
55
Mathias Agopian921e6ac2012-07-23 23:11:29 -070056#include "Barrier.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070057#include "DisplayDevice.h"
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070058#include "DispSync.h"
Dan Stoza84d619e2018-03-28 17:07:36 -070059#include "EventThread.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080060#include "FrameTracker.h"
Yiwei Zhang7124ad32018-02-21 13:02:45 -080061#include "LayerStats.h"
Robert Carr2047fae2016-11-28 14:09:09 -080062#include "LayerVector.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080063#include "MessageQueue.h"
Irvel468051e2016-06-13 16:44:44 -070064#include "SurfaceInterceptor.h"
Adrian Roos1e1a1282017-11-01 19:05:31 +010065#include "SurfaceTracing.h"
Wei Wangf9b05ee2017-07-19 20:59:39 -070066#include "StartPropertySetThread.h"
David Sodmanaf8bab12017-12-14 15:30:55 -080067#include "LayerBE.h"
Dan Stoza84d619e2018-03-28 17:07:36 -070068#include "VSyncModulator.h"
Mathias Agopianf1d8e872009-04-20 19:39:12 -070069
Steven Thomasb02664d2017-07-26 18:48:28 -070070#include "DisplayHardware/HWC2.h"
Mathias Agopian86303202012-07-24 22:46:10 -070071#include "DisplayHardware/HWComposer.h"
Steven Thomasb02664d2017-07-26 18:48:28 -070072
Mathias Agopianff2ed702013-09-01 21:36:12 -070073#include "Effects/Daltonizer.h"
Mathias Agopian86303202012-07-24 22:46:10 -070074
Dan Stozae77c7662016-05-13 11:37:28 -070075#include <map>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080076#include <mutex>
77#include <queue>
Dan Stozae77c7662016-05-13 11:37:28 -070078#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070079#include <thread>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080080#include <utility>
chaviwa76b2712017-09-20 12:02:26 -070081#include "RenderArea.h"
Dan Stozae77c7662016-05-13 11:37:28 -070082
chaviw1d044282017-09-27 12:19:28 -070083#include <layerproto/LayerProtoHeader.h>
84
85using namespace android::surfaceflinger;
86
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080087namespace android {
88
89// ---------------------------------------------------------------------------
90
91class Client;
chaviw13fdc492017-06-27 12:40:18 -070092class ColorLayer;
Lloyd Pique144e1162017-12-20 16:44:52 -080093class DisplayEventConnection;
Jamie Gennisd1700752013-10-14 12:22:52 -070094class EventControlThread;
Lloyd Pique144e1162017-12-20 16:44:52 -080095class EventThread;
Lloyd Pique12eb4232018-01-17 11:54:43 -080096class IGraphicBufferConsumer;
97class IGraphicBufferProducer;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070098class InjectVSyncSource;
Lloyd Pique144e1162017-12-20 16:44:52 -080099class Layer;
100class Surface;
David Sodman105b7dc2017-11-04 20:28:14 -0700101class SurfaceFlingerBE;
Lloyd Pique144e1162017-12-20 16:44:52 -0800102class VSyncSource;
103
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800104namespace impl {
105class EventThread;
106} // namespace impl
107
Lloyd Pique144e1162017-12-20 16:44:52 -0800108namespace RE {
109class RenderEngine;
110}
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800111
chaviwa76b2712017-09-20 12:02:26 -0700112typedef std::function<void(const LayerVector::Visitor&)> TraverseLayersFunction;
113
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800114namespace dvr {
115class VrFlinger;
116} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800117
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800118// ---------------------------------------------------------------------------
119
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800120enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700121 eTransactionNeeded = 0x01,
122 eTraversalNeeded = 0x02,
123 eDisplayTransactionNeeded = 0x04,
Lloyd Piqued432a7c2018-03-23 16:05:31 -0700124 eDisplayLayerStackChanged = 0x08,
125 eTransactionMask = 0x0f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800126};
127
Lloyd Pique99d3da52018-01-22 17:48:03 -0800128// A thin interface to abstract creating instances of Surface (gui/Surface.h) to
129// use as a NativeWindow.
130class NativeWindowSurface {
131public:
132 virtual ~NativeWindowSurface();
133
134 // Gets the NativeWindow to use for the surface.
135 virtual sp<ANativeWindow> getNativeWindow() const = 0;
136
137 // Indicates that the surface should allocate its buffers now.
138 virtual void preallocateBuffers() = 0;
139};
140
David Sodman105b7dc2017-11-04 20:28:14 -0700141class SurfaceFlingerBE
142{
143public:
144 SurfaceFlingerBE();
145
146 // The current hardware composer interface.
147 //
148 // The following thread safety rules apply when accessing mHwc, either
149 // directly or via getHwComposer():
150 //
151 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
152 // only when switching into and out of vr. Recreating mHwc must only be
153 // done on the main thread.
154 //
155 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
156 // mStateLock.
157 //
158 // 3. When accessing mHwc on a thread other than the main thread, we always
159 // need to acquire mStateLock. This is because the main thread could be
160 // in the process of destroying the current mHwc instance.
161 //
162 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
163 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
164 // destroy it, so it's always safe to access mHwc from any thread without
165 // acquiring mStateLock.
166 std::unique_ptr<HWComposer> mHwc;
167
David Sodmanbc815282017-11-05 18:57:52 -0800168 const std::string mHwcServiceName; // "default" for real use, something else for testing.
169
170 // constant members (no synchronization needed for access)
Lloyd Pique144e1162017-12-20 16:44:52 -0800171 std::unique_ptr<RE::RenderEngine> mRenderEngine;
David Sodmanbc815282017-11-05 18:57:52 -0800172 EGLContext mEGLContext;
173 EGLDisplay mEGLDisplay;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800174
David Sodman73beded2017-11-15 11:56:06 -0800175 FenceTimeline mGlCompositionDoneTimeline;
176 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800177
David Sodman99974d22017-11-28 12:04:33 -0800178 // protected by mCompositorTimingLock;
179 mutable std::mutex mCompositorTimingLock;
180 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800181
David Sodman99974d22017-11-28 12:04:33 -0800182 // Only accessed from the main thread.
183 struct CompositePresentTime {
184 nsecs_t composite { -1 };
185 std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
186 };
187 std::queue<CompositePresentTime> mCompositePresentTimes;
188
David Sodman4a36e932017-11-07 14:29:47 -0800189 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
190 nsecs_t mFrameBuckets[NUM_BUCKETS];
191 nsecs_t mTotalTime;
192 std::atomic<nsecs_t> mLastSwapTime;
193
David Sodmancbaf0832017-11-07 14:21:36 -0800194 // Double- vs. triple-buffering stats
195 struct BufferingStats {
196 BufferingStats()
197 : numSegments(0),
198 totalTime(0),
199 twoBufferTime(0),
200 doubleBufferedTime(0),
201 tripleBufferedTime(0) {}
202
203 size_t numSegments;
204 nsecs_t totalTime;
205
206 // "Two buffer" means that a third buffer was never used, whereas
207 // "double-buffered" means that on average the segment only used two
208 // buffers (though it may have used a third for some part of the
209 // segment)
210 nsecs_t twoBufferTime;
211 nsecs_t doubleBufferedTime;
212 nsecs_t tripleBufferedTime;
213 };
214 mutable Mutex mBufferingStatsMutex;
215 std::unordered_map<std::string, BufferingStats> mBufferingStats;
216
David Sodman105b7dc2017-11-04 20:28:14 -0700217 // The composer sequence id is a monotonically increasing integer that we
218 // use to differentiate callbacks from different hardware composer
219 // instances. Each hardware composer instance gets a different sequence id.
220 int32_t mComposerSequenceId;
221};
222
223
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700224class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700225 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700226 private IBinder::DeathRecipient,
Steven Thomasb02664d2017-07-26 18:48:28 -0700227 private HWC2::ComposerCallback
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800228{
229public:
David Sodman105b7dc2017-11-04 20:28:14 -0700230 SurfaceFlingerBE& getBE() { return mBE; }
231 const SurfaceFlingerBE& getBE() const { return mBE; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800232
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800233 // This is the phase offset in nanoseconds of the software vsync event
234 // relative to the vsync event reported by HWComposer. The software vsync
235 // event is when SurfaceFlinger and Choreographer-based applications run each
236 // frame.
237 //
238 // This phase offset allows adjustment of the minimum latency from application
239 // wake-up time (by Choreographer) to the time at which the resulting window
240 // image is displayed. This value may be either positive (after the HW vsync)
241 // or negative (before the HW vsync). Setting it to 0 will result in a lower
242 // latency bound of two vsync periods because the app and SurfaceFlinger
243 // will run just after the HW vsync. Setting it to a positive number will
244 // result in the minimum latency being:
245 //
246 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
247 //
248 // Note that reducing this latency makes it more likely for the applications
249 // to not have their window content image ready in time. When this happens
250 // the latency will end up being an additional vsync period, and animations
251 // will hiccup. Therefore, this latency should be tuned somewhat
252 // conservatively (or at least with awareness of the trade-off being made).
253 static int64_t vsyncPhaseOffsetNs;
254 static int64_t sfVsyncPhaseOffsetNs;
255
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800256 // If fences from sync Framework are supported.
257 static bool hasSyncFramework;
258
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700259 // The offset in nanoseconds to use when DispSync timestamps present fence
260 // signaling time.
261 static int64_t dispSyncPresentTimeOffset;
262
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700263 // Some hardware can do RGB->YUV conversion more efficiently in hardware
264 // controlled by HWC than in hardware controlled by the video encoder.
265 // This instruct VirtualDisplaySurface to use HWC for such conversion on
266 // GL composition.
267 static bool useHwcForRgbToYuv;
268
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800269 // Maximum dimension supported by HWC for virtual display.
270 // Equal to min(max_height, max_width).
271 static uint64_t maxVirtualDisplaySize;
272
Fabien Sanglard1971b632017-03-10 14:50:03 -0800273 // Controls the number of buffers SurfaceFlinger will allocate for use in
274 // FramebufferSurface
275 static int64_t maxFrameBufferAcquiredBuffers;
276
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600277 // Indicate if platform supports color management on its
278 // wide-color display. This is typically found on devices
279 // with wide gamut (e.g. Display-P3) display.
280 // This also allows devices with wide-color displays that don't
281 // want to support color management to disable color management.
282 static bool hasWideColorDisplay;
283
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700284 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700285 return "SurfaceFlinger";
286 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800287
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800288 struct SkipInitializationTag {};
289 static constexpr SkipInitializationTag SkipInitialization;
290 explicit SurfaceFlinger(SkipInitializationTag) ANDROID_API;
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700291 SurfaceFlinger() ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800292
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700293 // must be called before clients can connect
294 void init() ANDROID_API;
295
296 // starts SurfaceFlinger main loop in the current thread
297 void run() ANDROID_API;
298
Mathias Agopian86303202012-07-24 22:46:10 -0700299 enum {
300 EVENT_VSYNC = HWC_EVENT_VSYNC
301 };
302
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700303 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700304 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 -0800305
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700306 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700307 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 -0800308
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700309 // force full composition on all displays
310 void repaintEverything();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700311 // Can only be called from the main thread or with mStateLock held
312 void repaintEverythingLocked();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800313
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700314 // returns the default Display
Tomasz Wasilczyk8722a312017-04-13 19:14:30 +0000315 sp<const DisplayDevice> getDefaultDisplayDevice() const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700316 Mutex::Autolock _l(mStateLock);
317 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700318 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700319
Mathias Agopian86303202012-07-24 22:46:10 -0700320 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700321 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700322
Mathias Agopian86303202012-07-24 22:46:10 -0700323 // enable/disable h/w composer event
324 // TODO: this should be made accessible only to EventThread
Dan Stoza9e56aa02015-11-02 13:00:03 -0800325 void setVsyncEnabled(int disp, int enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700326
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700327 // called on the main thread by MessageQueue when an internal message
328 // is received
329 // TODO: this should be made accessible only to MessageQueue
330 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700331
Mathias Agopiancb558572012-10-04 15:58:54 -0700332 // for debugging only
333 // TODO: this should be made accessible only to HWComposer
Jesse Hall48bc05b2013-03-21 14:06:52 -0700334 const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id);
Mathias Agopiancb558572012-10-04 15:58:54 -0700335
Lloyd Pique144e1162017-12-20 16:44:52 -0800336 RE::RenderEngine& getRenderEngine() const { return *getBE().mRenderEngine; }
Jesse Hall29c3f352013-05-21 15:36:55 -0700337
Robert Carr0d480722017-01-10 16:42:54 -0800338 bool authenticateSurfaceTextureLocked(
339 const sp<IGraphicBufferProducer>& bufferProducer) const;
340
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700341private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700342 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800343 friend class DisplayEventConnection;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800344 friend class impl::EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800345 friend class Layer;
David Sodman0c69cad2017-08-21 12:12:51 -0700346 friend class BufferLayer;
Dan Stozab9b08832014-03-13 11:55:57 -0700347 friend class MonitoredProducer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800348
Lloyd Piquef58625d2017-12-19 13:22:33 -0800349 // For unit tests
350 friend class TestableSurfaceFlinger;
351
Jamie Gennis6547ff42013-07-16 20:12:42 -0700352 // This value is specified in number of frames. Log frame stats at most
353 // every half hour.
354 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
355
Dan Stoza7d89d062015-04-30 13:29:25 -0700356 static const size_t MAX_LAYERS = 4096;
357
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700358 // We're reference counted, never destroy SurfaceFlinger directly
359 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800360
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700361 /* ------------------------------------------------------------------------
362 * Internal data structures
363 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800364
Robert Carr2047fae2016-11-28 14:09:09 -0800365 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800366 public:
Dan Stoza412903f2017-04-27 13:42:17 -0700367 explicit State(LayerVector::StateSet set) : stateSet(set) {}
368 State& operator=(const State& other) {
369 // We explicitly don't copy stateSet so that, e.g., mDrawingState
370 // always uses the Drawing StateSet.
371 layersSortedByZ = other.layersSortedByZ;
372 displays = other.displays;
373 return *this;
374 }
375
376 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700377 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700378 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800379
Dan Stoza412903f2017-04-27 13:42:17 -0700380 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
381 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800382 };
383
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700384 /* ------------------------------------------------------------------------
385 * IBinder interface
386 */
387 virtual status_t onTransact(uint32_t code, const Parcel& data,
388 Parcel* reply, uint32_t flags);
Vishnu Nair35798872017-10-06 16:00:36 -0700389 virtual status_t dump(int fd, const Vector<String16>& args) { return priorityDump(fd, args); }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800390
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700391 /* ------------------------------------------------------------------------
392 * ISurfaceComposer interface
393 */
394 virtual sp<ISurfaceComposerClient> createConnection();
Robert Carr1db73f62016-12-21 12:58:51 -0800395 virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700396 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
Jesse Hall6c913be2013-08-08 12:15:49 -0700397 virtual void destroyDisplay(const sp<IBinder>& display);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700398 virtual sp<IBinder> getBuiltInDisplay(int32_t id);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700399 virtual void setTransactionState(const Vector<ComposerState>& state,
Mathias Agopian8b33f032012-07-24 20:43:54 -0700400 const Vector<DisplayState>& displays, uint32_t flags);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700401 virtual void bootFinished();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700402 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800403 const sp<IGraphicBufferProducer>& bufferProducer) const;
Brian Anderson6b376712017-04-04 10:51:39 -0700404 virtual status_t getSupportedFrameTimestamps(
405 std::vector<FrameEvent>* outSupported) const;
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700406 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
407 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp);
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000408 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
409 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
410 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
411 ISurfaceComposer::Rotation rotation);
412 virtual status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
Robert Carr578038f2018-03-09 12:25:24 -0800413 const Rect& sourceCrop, float frameScale, bool childrenOnly);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700414 virtual status_t getDisplayStats(const sp<IBinder>& display,
415 DisplayStatInfo* stats);
Dan Stoza7f7da322014-05-02 15:26:25 -0700416 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
417 Vector<DisplayInfo>* configs);
418 virtual int getActiveConfig(const sp<IBinder>& display);
Michael Wright28f24d02016-07-12 13:30:53 -0700419 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700420 Vector<ui::ColorMode>* configs);
421 virtual ui::ColorMode getActiveColorMode(const sp<IBinder>& display);
422 virtual status_t setActiveColorMode(const sp<IBinder>& display, ui::ColorMode colorMode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700423 virtual void setPowerMode(const sp<IBinder>& display, int mode);
Dan Stoza7f7da322014-05-02 15:26:25 -0700424 virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
Svetoslavd85084b2014-03-20 10:28:31 -0700425 virtual status_t clearAnimationFrameStats();
426 virtual status_t getAnimationFrameStats(FrameStats* outStats) const;
Dan Stozac4f471e2016-03-24 09:31:08 -0700427 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
428 HdrCapabilities* outCapabilities) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700429 virtual status_t enableVSyncInjections(bool enable);
430 virtual status_t injectVSync(nsecs_t when);
Kalle Raitaa099a242017-01-11 11:17:29 -0800431 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700432
Mathias Agopian1b031492012-06-20 17:51:20 -0700433
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700434 /* ------------------------------------------------------------------------
435 * DeathRecipient interface
436 */
437 virtual void binderDied(const wp<IBinder>& who);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800438
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700439 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700440 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700441 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700442 virtual void onFirstRef();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800443
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700444 /* ------------------------------------------------------------------------
Steven Thomasb02664d2017-07-26 18:48:28 -0700445 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700446 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700447 void onVsyncReceived(int32_t sequenceId, hwc2_display_t display,
448 int64_t timestamp) override;
449 void onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
Lloyd Pique715a2c12017-12-14 17:18:08 -0800450 HWC2::Connection connection) override;
Steven Thomasb02664d2017-07-26 18:48:28 -0700451 void onRefreshReceived(int32_t sequenceId, hwc2_display_t display) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700452
453 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700454 * Message handling
455 */
456 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700457 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700458 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700459 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700460 void signalLayerUpdate();
461 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800462
Andy McFadden13a082e2012-08-24 10:16:42 -0700463 // called on the main thread in response to initializeDisplays()
464 void onInitializeDisplays();
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700465 // called on the main thread in response to setActiveConfig()
466 void setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700467 // called on the main thread in response to setPowerMode()
Steven Thomasb02664d2017-07-26 18:48:28 -0700468 void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode,
469 bool stateLockHeld);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800470
Michael Wright28f24d02016-07-12 13:30:53 -0700471 // Called on the main thread in response to setActiveColorMode()
Peiyong Lin9f034472018-03-28 15:29:00 -0700472 void setActiveColorModeInternal(const sp<DisplayDevice>& hw, ui::ColorMode colorMode);
Michael Wright28f24d02016-07-12 13:30:53 -0700473
Dan Stoza6b9454d2014-11-07 16:00:59 -0800474 // Returns whether the transaction actually modified any state
475 bool handleMessageTransaction();
476
477 // Returns whether a new buffer has been latched (see handlePageFlip())
478 bool handleMessageInvalidate();
479
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700480 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700481
Mathias Agopian87baae12012-07-31 12:38:26 -0700482 void handleTransaction(uint32_t transactionFlags);
483 void handleTransactionLocked(uint32_t transactionFlags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800484
Riley Andrews03414a12014-07-01 14:22:59 -0700485 void updateCursorAsync();
486
Dan Stoza6b9454d2014-11-07 16:00:59 -0800487 /* handlePageFlip - latch a new buffer if available and compute the dirty
488 * region. Returns whether a new buffer has been latched, i.e., whether it
489 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700490 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800491 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800492
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700493 /* ------------------------------------------------------------------------
494 * Transactions
495 */
496 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800497 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700498 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700499 uint32_t setTransactionFlags(uint32_t flags);
Dan Stoza84d619e2018-03-28 17:07:36 -0700500 uint32_t setTransactionFlags(uint32_t flags, VSyncModulator::TransactionStart transactionStart);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700501 void commitTransaction();
chaviwca27f252018-02-06 16:46:39 -0800502 bool containsAnyInvalidClientState(const Vector<ComposerState>& states);
503 uint32_t setClientStateLocked(const ComposerState& composerState);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700504 uint32_t setDisplayStateLocked(const DisplayState& s);
chaviwca27f252018-02-06 16:46:39 -0800505 void setDestroyStateLocked(const ComposerState& composerState);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800506
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700507 /* ------------------------------------------------------------------------
508 * Layer management
509 */
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700510 status_t createLayer(const String8& name, const sp<Client>& client,
511 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
rongliucfb187b2018-03-14 12:26:23 -0700512 int32_t windowType, int32_t ownerUid, sp<IBinder>* handle,
Albert Chaulk479c60c2017-01-27 14:21:34 -0500513 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800514
David Sodman0c69cad2017-08-21 12:12:51 -0700515 status_t createBufferLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700516 uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
517 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
518 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800519
chaviw13fdc492017-06-27 12:40:18 -0700520 status_t createColorLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700521 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
David Sodman0c69cad2017-08-21 12:12:51 -0700522 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700523
Cody Northropbc755282017-03-31 12:00:08 -0600524 String8 getUniqueLayerName(const String8& name);
525
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700526 // called in response to the window-manager calling
527 // ISurfaceComposerClient::destroySurface()
Mathias Agopianac9fa422013-02-11 16:40:36 -0800528 status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle);
Mathias Agopianb9494d52012-04-18 02:28:45 -0700529
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700530 // called when all clients have released all their references to
531 // this layer meaning it is entirely safe to destroy all
532 // resources associated to this layer.
Mathias Agopian13127d82013-03-05 17:47:11 -0800533 status_t onLayerDestroyed(const wp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700534
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700535 // remove a layer from SurfaceFlinger immediately
Chia-I Wu515dc9c2017-06-15 12:53:59 -0700536 status_t removeLayer(const sp<Layer>& layer, bool topLevelOnly = false);
chaviwca27f252018-02-06 16:46:39 -0800537 status_t removeLayerLocked(const Mutex&, const sp<Layer>& layer, bool topLevelOnly = false);
Mathias Agopiana4912602012-07-12 14:25:33 -0700538
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700539 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700540 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700541 const sp<IBinder>& handle,
542 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -0700543 const sp<Layer>& lbc,
544 const sp<Layer>& parent);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700545
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700546 /* ------------------------------------------------------------------------
547 * Boot animation, on/off animations and screen capture
548 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700549
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700550 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700551
chaviwa76b2712017-09-20 12:02:26 -0700552 void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
553 bool yswap, bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700554 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000555 sp<GraphicBuffer>* outBuffer,
chaviwa76b2712017-09-20 12:02:26 -0700556 bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700557 status_t captureScreenImplLocked(const RenderArea& renderArea,
558 TraverseLayersFunction traverseLayers,
559 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Robert Carr03480e22018-01-04 16:02:06 -0800560 bool forSystem, int* outSyncFd);
chaviwa76b2712017-09-20 12:02:26 -0700561 void traverseLayersInDisplay(const sp<const DisplayDevice>& display, int32_t minLayerZ,
562 int32_t maxLayerZ, const LayerVector::Visitor& visitor);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700563
Wei Wangf9b05ee2017-07-19 20:59:39 -0700564 sp<StartPropertySetThread> mStartPropertySetThread = nullptr;
Wei Wangb254fa32017-01-31 17:43:23 -0800565
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700566 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700567 * Properties
568 */
569 void readPersistentProperties();
570
571 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700572 * EGL
573 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700574 size_t getMaxTextureSize() const;
575 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700576
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700577 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700578 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700579 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700580 // called when starting, or restarting after system_server death
581 void initializeDisplays();
582
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700583 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700584 Mutex::Autolock _l(mStateLock);
585 return getDisplayDeviceLocked(dpy);
586 }
587
588 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
589 Mutex::Autolock _l(mStateLock);
590 return getDisplayDeviceLocked(dpy);
591 }
592
593 // NOTE: can only be called from the main thread or with mStateLock held
594 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) const {
Mathias Agopian92a979a2012-08-02 18:32:23 -0700595 return mDisplays.valueFor(dpy);
596 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700597
598 // NOTE: can only be called from the main thread or with mStateLock held
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700599 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) {
Mathias Agopian42977342012-08-05 00:40:46 -0700600 return mDisplays.valueFor(dpy);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700601 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700602
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700603 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
604 return getDisplayDeviceLocked(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
605 }
606
Michael Wright28f24d02016-07-12 13:30:53 -0700607 int32_t getDisplayType(const sp<IBinder>& display) {
608 if (!display.get()) return NAME_NOT_FOUND;
609 for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
610 if (display == mBuiltinDisplays[i]) {
611 return i;
612 }
613 }
614 return NAME_NOT_FOUND;
615 }
616
Mathias Agopian87baae12012-07-31 12:38:26 -0700617 // mark a region of a layer stack dirty. this updates the dirty
618 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700619 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700620
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700621 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700622 * H/W composer
623 */
624
David Sodman105b7dc2017-11-04 20:28:14 -0700625 HWComposer& getHwComposer() const { return *getBE().mHwc; }
Mathias Agopian86303202012-07-24 22:46:10 -0700626
Mathias Agopian888c8222012-08-04 21:10:38 -0700627 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700628 * Compositing
629 */
630 void invalidateHwcGeometry();
Chia-I Wuab0c3192017-08-01 11:29:00 -0700631 void computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Mathias Agopian87baae12012-07-31 12:38:26 -0700632 Region& dirtyRegion, Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700633
Chia-I Wu30505fb2018-03-26 16:20:31 -0700634 void preComposition(nsecs_t refreshStartTime);
635 void postComposition(nsecs_t refreshStartTime);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800636 void updateCompositorTiming(
637 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
638 std::shared_ptr<FenceTime>& presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -0800639 void setCompositorTimingSnapped(
640 nsecs_t vsyncPhase, nsecs_t vsyncInterval,
641 nsecs_t compositeToPresentLatency);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700642 void rebuildLayerStacks();
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600643
644 // Given a dataSpace, returns the appropriate color_mode to use
645 // to display that dataSpace.
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700646 ui::ColorMode pickColorMode(ui::Dataspace dataSpace) const;
647 ui::Dataspace bestTargetDataSpace(ui::Dataspace a, ui::Dataspace b,
Chia-I Wu5c6e4632018-01-11 08:54:38 -0800648 bool hasHdr) const;
Romain Guy0147a172017-06-01 13:53:56 -0700649
650 mat4 computeSaturationMatrix() const;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600651
Chia-I Wu30505fb2018-03-26 16:20:31 -0700652 void setUpHWComposer();
Mathias Agopiancd60f992012-08-16 16:28:27 -0700653 void doComposition();
654 void doDebugFlashRegions();
Adrian Roos1e1a1282017-11-01 19:05:31 +0100655 void doTracing(const char* where);
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800656 void logLayerStats();
Fabien Sanglard830b8472016-11-30 16:35:58 -0800657 void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700658
659 // compose surfaces for display hw. this fails if using GL and the surface
660 // has been destroyed and is no longer valid.
Chia-I Wub02087d2017-11-09 10:19:54 -0800661 bool doComposeSurfaces(const sp<const DisplayDevice>& displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700662
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700663 void postFramebuffer();
Fabien Sanglard830b8472016-11-30 16:35:58 -0800664 void drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700665
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700666 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700667 * Display management
668 */
Lloyd Pique715a2c12017-12-14 17:18:08 -0800669 DisplayDevice::DisplayType determineDisplayType(hwc2_display_t display,
670 HWC2::Connection connection) const;
Lloyd Pique99d3da52018-01-22 17:48:03 -0800671 sp<DisplayDevice> setupNewDisplayDeviceInternal(const wp<IBinder>& display, int hwcId,
672 const DisplayDeviceState& state,
673 const sp<DisplaySurface>& dispSurface,
674 const sp<IGraphicBufferProducer>& producer);
Lloyd Pique347200f2017-12-14 17:00:15 -0800675 void processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -0800676 void processDisplayHotplugEventsLocked();
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700677
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700678 /* ------------------------------------------------------------------------
679 * VSync
680 */
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800681 void enableHardwareVsync();
682 void resyncToHardwareVsync(bool makeAvailable);
683 void disableHardwareVsync(bool makeUnavailable);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700684
Tim Murray4a4e4a22016-04-19 16:29:23 +0000685public:
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800686 void resyncWithRateLimit();
687 void getCompositorTiming(CompositorTiming* compositorTiming);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000688private:
Jamie Gennis0bceb842012-08-23 20:19:38 -0700689
690 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700691 * Debugging & dumpsys
692 */
Vishnu Nair35798872017-10-06 16:00:36 -0700693public:
Vishnu Nair6a408532017-10-24 09:11:27 -0700694 status_t dumpCritical(int fd, const Vector<String16>& /*args*/, bool asProto) {
695 return doDump(fd, Vector<String16>(), asProto);
Vishnu Nair35798872017-10-06 16:00:36 -0700696 }
697
Vishnu Nair6a408532017-10-24 09:11:27 -0700698 status_t dumpAll(int fd, const Vector<String16>& args, bool asProto) {
699 return doDump(fd, args, asProto);
700 }
701
Vishnu Nair35798872017-10-06 16:00:36 -0700702private:
Mathias Agopian3f844832013-08-07 21:24:32 -0700703 void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
704 void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
705 void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
706 void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
Keun young Park63f165f2012-08-31 10:53:36 -0700707 bool startDdmConnection();
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800708 void appendSfConfigString(String8& result) const;
Mathias Agopiand5556842013-09-19 17:08:37 -0700709 void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
chaviwa76b2712017-09-20 12:02:26 -0700710 TraverseLayersFunction traverseLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800711
Jamie Gennis6547ff42013-07-16 20:12:42 -0700712 void logFrameStats();
713
Dan Stozab90cf072015-03-05 11:05:59 -0800714 void dumpStaticScreenStats(String8& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700715 // Not const because each Layer needs to query Fences and cache timestamps.
716 void dumpFrameEventsLocked(String8& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800717
Dan Stozae77c7662016-05-13 11:37:28 -0700718 void recordBufferingStats(const char* layerName,
719 std::vector<OccupancyTracker::Segment>&& history);
720 void dumpBufferingStats(String8& result) const;
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -0600721 void dumpWideColorInfo(String8& result) const;
Jorim Jaggi8e0af362017-11-14 16:28:28 +0100722 LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const;
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800723 LayersProto dumpVisibleLayersProtoInfo(int32_t hwcId) const;
Dan Stozae77c7662016-05-13 11:37:28 -0700724
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800725 bool isLayerTripleBufferingDisabled() const {
726 return this->mLayerTripleBufferingDisabled;
727 }
Vishnu Nair6a408532017-10-24 09:11:27 -0700728 status_t doDump(int fd, const Vector<String16>& args, bool asProto);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800729
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800730 /* ------------------------------------------------------------------------
731 * VrFlinger
732 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700733 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800734
Steven Thomas050b2c82017-03-06 11:45:16 -0800735 // Check to see if we should handoff to vr flinger.
736 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800737
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700738 /* ------------------------------------------------------------------------
739 * Attributes
740 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800741
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700742 // access must be protected by mStateLock
743 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700744 State mCurrentState{LayerVector::StateSet::Current};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700745 volatile int32_t mTransactionFlags;
746 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700747 bool mTransactionPending;
748 bool mAnimTransactionPending;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700749 SortedVector< sp<Layer> > mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -0800750
751 // Can't be unordered_set because wp<> isn't hashable
752 std::set<wp<IBinder>> mGraphicBufferProducerList;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700753 size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800754
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700755 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700756 bool mLayersRemoved;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700757 bool mLayersAdded;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700758
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700759 // access must be protected by mInvalidateLock
Mathias Agopian87baae12012-07-31 12:38:26 -0700760 volatile int32_t mRepaintEverything;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700761
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800762 // constant members (no synchronization needed for access)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700763 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700764 bool mGpuToCpuSupported;
Lloyd Piquee83f9312018-02-01 12:53:17 -0800765 std::unique_ptr<EventThread> mEventThread;
766 std::unique_ptr<EventThread> mSFEventThread;
767 std::unique_ptr<EventThread> mInjectorEventThread;
768 std::unique_ptr<VSyncSource> mEventThreadSource;
769 std::unique_ptr<VSyncSource> mSfEventThreadSource;
770 std::unique_ptr<InjectVSyncSource> mVSyncInjector;
Lloyd Pique755e3192018-01-31 16:46:15 -0800771 std::unique_ptr<EventControlThread> mEventControlThread;
Jesse Hall9e663de2013-08-16 14:28:37 -0700772 sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
Mathias Agopian3094df32012-06-18 18:06:45 -0700773
Dan Stoza84d619e2018-03-28 17:07:36 -0700774 VSyncModulator mVsyncModulator;
775
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700776 // Can only accessed from the main thread, these members
777 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700778 State mDrawingState{LayerVector::StateSet::Drawing};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700779 bool mVisibleRegionsDirty;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800780 bool mGeometryInvalid;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800781 bool mAnimCompositionPending;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800782 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700783 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
784 bool mHadClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700785
Lloyd Piqueba04e622017-12-14 17:11:26 -0800786 struct HotplugEvent {
787 hwc2_display_t display;
788 HWC2::Connection connection = HWC2::Connection::Invalid;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800789 };
790 // protected by mStateLock
791 std::vector<HotplugEvent> mPendingHotplugEvents;
792
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700793 // this may only be written from the main thread with mStateLock held
794 // it may be read from other threads with mStateLock held
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700795 DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700796
797 // don't use a lock for these, we don't care
798 int mDebugRegion;
799 int mDebugDDMS;
800 int mDebugDisableHWC;
801 int mDebugDisableTransformHint;
802 volatile nsecs_t mDebugInSwapBuffers;
803 nsecs_t mLastSwapBufferTime;
804 volatile nsecs_t mDebugInTransaction;
805 nsecs_t mLastTransactionTime;
806 bool mBootFinished;
Dan Stozaee44edd2015-03-23 15:50:23 -0700807 bool mForceFullDamage;
Dan Stozac5da2712016-07-20 15:38:12 -0700808 bool mPropagateBackpressure = true;
Lloyd Pique4dccc412018-01-22 17:21:36 -0800809 std::unique_ptr<SurfaceInterceptor> mInterceptor =
810 std::make_unique<impl::SurfaceInterceptor>(this);
Adrian Roos1e1a1282017-11-01 19:05:31 +0100811 SurfaceTracing mTracing;
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800812 LayerStats mLayerStats;
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800813 bool mUseHwcVirtualDisplays = false;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700814
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800815 // Restrict layers to use two buffers in their bufferqueues.
816 bool mLayerTripleBufferingDisabled = false;
817
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700818 // these are thread safe
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800819 mutable std::unique_ptr<MessageQueue> mEventQueue{std::make_unique<impl::MessageQueue>()};
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800820 FrameTracker mAnimFrameTracker;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700821 DispSync mPrimaryDispSync;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700822
823 // protected by mDestroyedLayerLock;
824 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -0800825 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700826
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700827 // protected by mHWVsyncLock
828 Mutex mHWVsyncLock;
829 bool mPrimaryHWVsyncEnabled;
Jesse Hall948fe0c2013-10-14 12:56:09 -0700830 bool mHWVsyncAvailable;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700831
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700832 std::atomic<bool> mRefreshPending{false};
833
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700834 /* ------------------------------------------------------------------------
835 * Feature prototyping
836 */
837
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700838 bool mInjectVSyncs;
839
Mathias Agopianff2ed702013-09-01 21:36:12 -0700840 Daltonizer mDaltonizer;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700841
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700842 mat4 mPreviousColorMatrix;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700843 mat4 mColorMatrix;
Romain Guya9638732017-06-01 12:05:21 -0700844 bool mHasColorMatrix;
Dan Stozab90cf072015-03-05 11:05:59 -0800845
846 // Static screen stats
847 bool mHasPoweredOff;
Dan Stozae77c7662016-05-13 11:37:28 -0700848
Robert Carr1f0a16a2016-10-24 16:27:39 -0700849 size_t mNumLayers;
850
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -0700851
852 // Verify that transaction is being called by an approved process:
853 // either AID_GRAPHICS or AID_SYSTEM.
854 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800855
Steven Thomasb02664d2017-07-26 18:48:28 -0700856 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Steven Thomas050b2c82017-03-06 11:45:16 -0800857 std::atomic<bool> mVrFlingerRequestsDisplay;
858 static bool useVrFlinger;
Steven Thomasb02664d2017-07-26 18:48:28 -0700859 std::thread::id mMainThreadId;
Romain Guy0147a172017-06-01 13:53:56 -0700860
861 float mSaturation = 1.0f;
Romain Guy54f154a2017-10-24 21:40:32 +0100862 bool mForceNativeColorMode = false;
David Sodman105b7dc2017-11-04 20:28:14 -0700863
Lloyd Pique12eb4232018-01-17 11:54:43 -0800864 using CreateBufferQueueFunction =
865 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
866 sp<IGraphicBufferConsumer>* /* outConsumer */,
867 bool /* consumerIsSurfaceFlinger */)>;
868 CreateBufferQueueFunction mCreateBufferQueue;
869
Lloyd Pique99d3da52018-01-22 17:48:03 -0800870 using CreateNativeWindowSurfaceFunction =
871 std::function<std::unique_ptr<NativeWindowSurface>(const sp<IGraphicBufferProducer>&)>;
872 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
873
David Sodman105b7dc2017-11-04 20:28:14 -0700874 SurfaceFlingerBE mBE;
Romain Guy0147a172017-06-01 13:53:56 -0700875};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800876}; // namespace android
877
878#endif // ANDROID_SURFACE_FLINGER_H