The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 1 | /* |
| 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 Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 20 | #include <memory> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 21 | #include <stdint.h> |
| 22 | #include <sys/types.h> |
| 23 | |
Mathias Agopian | 3f84483 | 2013-08-07 21:24:32 -0700 | [diff] [blame] | 24 | /* |
| 25 | * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ > |
| 26 | */ |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 27 | |
Glenn Kasten | 99ed224 | 2011-12-15 09:51:17 -0800 | [diff] [blame] | 28 | #include <cutils/compiler.h> |
Steven Moreland | 2716e11 | 2018-02-23 14:57:20 -0800 | [diff] [blame] | 29 | #include <cutils/atomic.h> |
Glenn Kasten | 99ed224 | 2011-12-15 09:51:17 -0800 | [diff] [blame] | 30 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 31 | #include <utils/Errors.h> |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 32 | #include <utils/KeyedVector.h> |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 33 | #include <utils/RefBase.h> |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 34 | #include <utils/SortedVector.h> |
| 35 | #include <utils/threads.h> |
Dan Stoza | 84d619e | 2018-03-28 17:07:36 -0700 | [diff] [blame] | 36 | #include <utils/Trace.h> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 37 | |
Brian Anderson | 3d4039d | 2016-09-23 16:31:30 -0700 | [diff] [blame] | 38 | #include <ui/FenceTime.h> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 39 | #include <ui/PixelFormat.h> |
Mathias Agopian | 1d77b71 | 2017-02-17 15:46:13 -0800 | [diff] [blame] | 40 | #include <math/mat4.h> |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 41 | |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 42 | #include <gui/FrameTimestamps.h> |
Mathias Agopian | 90ac799 | 2012-02-25 18:48:35 -0800 | [diff] [blame] | 43 | #include <gui/ISurfaceComposer.h> |
| 44 | #include <gui/ISurfaceComposerClient.h> |
Robert Carr | 4cdc58f | 2017-08-23 14:22:20 -0700 | [diff] [blame] | 45 | #include <gui/LayerState.h> |
| 46 | |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 47 | #include <gui/OccupancyTracker.h> |
David Sodman | af8bab1 | 2017-12-14 15:30:55 -0800 | [diff] [blame] | 48 | #include <gui/BufferQueue.h> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 49 | |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 50 | #include <hardware/hwcomposer_defs.h> |
| 51 | |
Vishnu Nair | 3579887 | 2017-10-06 16:00:36 -0700 | [diff] [blame] | 52 | #include <serviceutils/PriorityDumper.h> |
| 53 | |
Michael Wright | 28f24d0 | 2016-07-12 13:30:53 -0700 | [diff] [blame] | 54 | #include <system/graphics.h> |
| 55 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 56 | #include "Barrier.h" |
Mathias Agopian | 92a979a | 2012-08-02 18:32:23 -0700 | [diff] [blame] | 57 | #include "DisplayDevice.h" |
Jamie Gennis | 4b0eba9 | 2013-02-05 13:30:24 -0800 | [diff] [blame] | 58 | #include "FrameTracker.h" |
Ana Krulec | fefcb58 | 2018-08-07 14:22:37 -0700 | [diff] [blame] | 59 | #include "LayerBE.h" |
Yiwei Zhang | 7124ad3 | 2018-02-21 13:02:45 -0800 | [diff] [blame] | 60 | #include "LayerStats.h" |
Robert Carr | 2047fae | 2016-11-28 14:09:09 -0800 | [diff] [blame] | 61 | #include "LayerVector.h" |
Ana Krulec | fefcb58 | 2018-08-07 14:22:37 -0700 | [diff] [blame] | 62 | #include "StartPropertySetThread.h" |
Irvel | 468051e | 2016-06-13 16:44:44 -0700 | [diff] [blame] | 63 | #include "SurfaceInterceptor.h" |
Adrian Roos | 1e1a128 | 2017-11-01 19:05:31 +0100 | [diff] [blame] | 64 | #include "SurfaceTracing.h" |
Mathias Agopian | f1d8e87 | 2009-04-20 19:39:12 -0700 | [diff] [blame] | 65 | |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 66 | #include "DisplayHardware/HWC2.h" |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 67 | #include "DisplayHardware/HWComposer.h" |
Mathias Agopian | ff2ed70 | 2013-09-01 21:36:12 -0700 | [diff] [blame] | 68 | #include "Effects/Daltonizer.h" |
Ana Krulec | fefcb58 | 2018-08-07 14:22:37 -0700 | [diff] [blame] | 69 | #include "Scheduler/DispSync.h" |
| 70 | #include "Scheduler/EventThread.h" |
| 71 | #include "Scheduler/MessageQueue.h" |
Ana Krulec | 98b5b24 | 2018-08-10 15:03:23 -0700 | [diff] [blame] | 72 | #include "Scheduler/Scheduler.h" |
Ana Krulec | fefcb58 | 2018-08-07 14:22:37 -0700 | [diff] [blame] | 73 | #include "Scheduler/VSyncModulator.h" |
| 74 | #include "TimeStats/TimeStats.h" |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 75 | |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 76 | #include <map> |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 77 | #include <mutex> |
| 78 | #include <queue> |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 79 | #include <string> |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 80 | #include <thread> |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 81 | #include <utility> |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 82 | #include "RenderArea.h" |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 83 | |
chaviw | 1d04428 | 2017-09-27 12:19:28 -0700 | [diff] [blame] | 84 | #include <layerproto/LayerProtoHeader.h> |
| 85 | |
| 86 | using namespace android::surfaceflinger; |
| 87 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 88 | namespace android { |
| 89 | |
| 90 | // --------------------------------------------------------------------------- |
| 91 | |
| 92 | class Client; |
chaviw | 13fdc49 | 2017-06-27 12:40:18 -0700 | [diff] [blame] | 93 | class ColorLayer; |
Lloyd Pique | 144e116 | 2017-12-20 16:44:52 -0800 | [diff] [blame] | 94 | class DisplayEventConnection; |
Jamie Gennis | d170075 | 2013-10-14 12:22:52 -0700 | [diff] [blame] | 95 | class EventControlThread; |
Lloyd Pique | 144e116 | 2017-12-20 16:44:52 -0800 | [diff] [blame] | 96 | class EventThread; |
Lloyd Pique | 12eb423 | 2018-01-17 11:54:43 -0800 | [diff] [blame] | 97 | class IGraphicBufferConsumer; |
| 98 | class IGraphicBufferProducer; |
Sahil Dhanju | c1ba5c4 | 2016-06-07 20:09:20 -0700 | [diff] [blame] | 99 | class InjectVSyncSource; |
Lloyd Pique | 144e116 | 2017-12-20 16:44:52 -0800 | [diff] [blame] | 100 | class Layer; |
| 101 | class Surface; |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 102 | class SurfaceFlingerBE; |
Lloyd Pique | 144e116 | 2017-12-20 16:44:52 -0800 | [diff] [blame] | 103 | class VSyncSource; |
David Sodman | ba34049 | 2018-08-05 21:51:33 -0700 | [diff] [blame] | 104 | struct CompositionInfo; |
Lloyd Pique | 144e116 | 2017-12-20 16:44:52 -0800 | [diff] [blame] | 105 | |
Lloyd Pique | 0fcde1b | 2017-12-20 16:50:21 -0800 | [diff] [blame] | 106 | namespace impl { |
| 107 | class EventThread; |
| 108 | } // namespace impl |
| 109 | |
Peiyong Lin | 833074a | 2018-08-28 11:53:54 -0700 | [diff] [blame] | 110 | namespace renderengine { |
Lloyd Pique | 144e116 | 2017-12-20 16:44:52 -0800 | [diff] [blame] | 111 | class RenderEngine; |
| 112 | } |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 113 | |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 114 | typedef std::function<void(const LayerVector::Visitor&)> TraverseLayersFunction; |
| 115 | |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 116 | namespace dvr { |
| 117 | class VrFlinger; |
| 118 | } // namespace dvr |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 119 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 120 | // --------------------------------------------------------------------------- |
| 121 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 122 | enum { |
Mathias Agopian | e57f292 | 2012-08-09 16:29:12 -0700 | [diff] [blame] | 123 | eTransactionNeeded = 0x01, |
| 124 | eTraversalNeeded = 0x02, |
| 125 | eDisplayTransactionNeeded = 0x04, |
Lloyd Pique | d432a7c | 2018-03-23 16:05:31 -0700 | [diff] [blame] | 126 | eDisplayLayerStackChanged = 0x08, |
| 127 | eTransactionMask = 0x0f, |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 128 | }; |
| 129 | |
Peiyong Lin | dd9b2ae | 2018-03-01 16:22:45 -0800 | [diff] [blame] | 130 | enum class DisplayColorSetting : int32_t { |
| 131 | MANAGED = 0, |
| 132 | UNMANAGED = 1, |
| 133 | ENHANCED = 2, |
| 134 | }; |
| 135 | |
Lloyd Pique | 99d3da5 | 2018-01-22 17:48:03 -0800 | [diff] [blame] | 136 | // A thin interface to abstract creating instances of Surface (gui/Surface.h) to |
| 137 | // use as a NativeWindow. |
| 138 | class NativeWindowSurface { |
| 139 | public: |
| 140 | virtual ~NativeWindowSurface(); |
| 141 | |
| 142 | // Gets the NativeWindow to use for the surface. |
| 143 | virtual sp<ANativeWindow> getNativeWindow() const = 0; |
| 144 | |
| 145 | // Indicates that the surface should allocate its buffers now. |
| 146 | virtual void preallocateBuffers() = 0; |
| 147 | }; |
| 148 | |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 149 | class SurfaceFlingerBE |
| 150 | { |
| 151 | public: |
| 152 | SurfaceFlingerBE(); |
| 153 | |
| 154 | // The current hardware composer interface. |
| 155 | // |
| 156 | // The following thread safety rules apply when accessing mHwc, either |
| 157 | // directly or via getHwComposer(): |
| 158 | // |
| 159 | // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc |
| 160 | // only when switching into and out of vr. Recreating mHwc must only be |
| 161 | // done on the main thread. |
| 162 | // |
| 163 | // 2. When accessing mHwc on the main thread, it's not necessary to acquire |
| 164 | // mStateLock. |
| 165 | // |
| 166 | // 3. When accessing mHwc on a thread other than the main thread, we always |
| 167 | // need to acquire mStateLock. This is because the main thread could be |
| 168 | // in the process of destroying the current mHwc instance. |
| 169 | // |
| 170 | // The above thread safety rules only apply to SurfaceFlinger.cpp. In |
| 171 | // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never |
| 172 | // destroy it, so it's always safe to access mHwc from any thread without |
| 173 | // acquiring mStateLock. |
| 174 | std::unique_ptr<HWComposer> mHwc; |
| 175 | |
David Sodman | bc81528 | 2017-11-05 18:57:52 -0800 | [diff] [blame] | 176 | const std::string mHwcServiceName; // "default" for real use, something else for testing. |
| 177 | |
| 178 | // constant members (no synchronization needed for access) |
Peiyong Lin | 833074a | 2018-08-28 11:53:54 -0700 | [diff] [blame] | 179 | std::unique_ptr<renderengine::RenderEngine> mRenderEngine; |
David Sodman | bc81528 | 2017-11-05 18:57:52 -0800 | [diff] [blame] | 180 | EGLContext mEGLContext; |
| 181 | EGLDisplay mEGLDisplay; |
Lloyd Pique | fcd8661 | 2017-12-14 17:15:36 -0800 | [diff] [blame] | 182 | |
David Sodman | 73beded | 2017-11-15 11:56:06 -0800 | [diff] [blame] | 183 | FenceTimeline mGlCompositionDoneTimeline; |
| 184 | FenceTimeline mDisplayTimeline; |
David Sodman | bc81528 | 2017-11-05 18:57:52 -0800 | [diff] [blame] | 185 | |
David Sodman | 99974d2 | 2017-11-28 12:04:33 -0800 | [diff] [blame] | 186 | // protected by mCompositorTimingLock; |
| 187 | mutable std::mutex mCompositorTimingLock; |
| 188 | CompositorTiming mCompositorTiming; |
Lloyd Pique | fcd8661 | 2017-12-14 17:15:36 -0800 | [diff] [blame] | 189 | |
David Sodman | 99974d2 | 2017-11-28 12:04:33 -0800 | [diff] [blame] | 190 | // Only accessed from the main thread. |
| 191 | struct CompositePresentTime { |
| 192 | nsecs_t composite { -1 }; |
| 193 | std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE }; |
| 194 | }; |
| 195 | std::queue<CompositePresentTime> mCompositePresentTimes; |
| 196 | |
David Sodman | 4a36e93 | 2017-11-07 14:29:47 -0800 | [diff] [blame] | 197 | static const size_t NUM_BUCKETS = 8; // < 1-7, 7+ |
| 198 | nsecs_t mFrameBuckets[NUM_BUCKETS]; |
| 199 | nsecs_t mTotalTime; |
| 200 | std::atomic<nsecs_t> mLastSwapTime; |
| 201 | |
David Sodman | cbaf083 | 2017-11-07 14:21:36 -0800 | [diff] [blame] | 202 | // Double- vs. triple-buffering stats |
| 203 | struct BufferingStats { |
| 204 | BufferingStats() |
| 205 | : numSegments(0), |
| 206 | totalTime(0), |
| 207 | twoBufferTime(0), |
| 208 | doubleBufferedTime(0), |
| 209 | tripleBufferedTime(0) {} |
| 210 | |
| 211 | size_t numSegments; |
| 212 | nsecs_t totalTime; |
| 213 | |
| 214 | // "Two buffer" means that a third buffer was never used, whereas |
| 215 | // "double-buffered" means that on average the segment only used two |
| 216 | // buffers (though it may have used a third for some part of the |
| 217 | // segment) |
| 218 | nsecs_t twoBufferTime; |
| 219 | nsecs_t doubleBufferedTime; |
| 220 | nsecs_t tripleBufferedTime; |
| 221 | }; |
| 222 | mutable Mutex mBufferingStatsMutex; |
| 223 | std::unordered_map<std::string, BufferingStats> mBufferingStats; |
| 224 | |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 225 | // The composer sequence id is a monotonically increasing integer that we |
| 226 | // use to differentiate callbacks from different hardware composer |
| 227 | // instances. Each hardware composer instance gets a different sequence id. |
| 228 | int32_t mComposerSequenceId; |
David Sodman | ba34049 | 2018-08-05 21:51:33 -0700 | [diff] [blame] | 229 | |
David Sodman | 15fb96e | 2018-01-07 10:23:24 -0800 | [diff] [blame] | 230 | std::unordered_map<int32_t, std::vector<CompositionInfo>> mCompositionInfo; |
David Sodman | 7e4ae11 | 2018-02-09 15:02:28 -0800 | [diff] [blame] | 231 | std::unordered_map<int32_t, std::vector<CompositionInfo>> mEndOfFrameCompositionInfo; |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 232 | }; |
| 233 | |
| 234 | |
Mathias Agopian | 4f4f094 | 2013-08-19 17:26:18 -0700 | [diff] [blame] | 235 | class SurfaceFlinger : public BnSurfaceComposer, |
Vishnu Nair | 3579887 | 2017-10-06 16:00:36 -0700 | [diff] [blame] | 236 | public PriorityDumper, |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 237 | private IBinder::DeathRecipient, |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 238 | private HWC2::ComposerCallback |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 239 | { |
| 240 | public: |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 241 | SurfaceFlingerBE& getBE() { return mBE; } |
| 242 | const SurfaceFlingerBE& getBE() const { return mBE; } |
Fabien Sanglard | 0cc1938 | 2017-03-06 11:54:40 -0800 | [diff] [blame] | 243 | |
Fabien Sanglard | 0cc1938 | 2017-03-06 11:54:40 -0800 | [diff] [blame] | 244 | // This is the phase offset in nanoseconds of the software vsync event |
| 245 | // relative to the vsync event reported by HWComposer. The software vsync |
| 246 | // event is when SurfaceFlinger and Choreographer-based applications run each |
| 247 | // frame. |
| 248 | // |
| 249 | // This phase offset allows adjustment of the minimum latency from application |
| 250 | // wake-up time (by Choreographer) to the time at which the resulting window |
| 251 | // image is displayed. This value may be either positive (after the HW vsync) |
| 252 | // or negative (before the HW vsync). Setting it to 0 will result in a lower |
| 253 | // latency bound of two vsync periods because the app and SurfaceFlinger |
| 254 | // will run just after the HW vsync. Setting it to a positive number will |
| 255 | // result in the minimum latency being: |
| 256 | // |
| 257 | // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD)) |
| 258 | // |
| 259 | // Note that reducing this latency makes it more likely for the applications |
| 260 | // to not have their window content image ready in time. When this happens |
| 261 | // the latency will end up being an additional vsync period, and animations |
| 262 | // will hiccup. Therefore, this latency should be tuned somewhat |
| 263 | // conservatively (or at least with awareness of the trade-off being made). |
| 264 | static int64_t vsyncPhaseOffsetNs; |
| 265 | static int64_t sfVsyncPhaseOffsetNs; |
| 266 | |
Fabien Sanglard | cbf153b | 2017-03-10 17:57:12 -0800 | [diff] [blame] | 267 | // If fences from sync Framework are supported. |
| 268 | static bool hasSyncFramework; |
| 269 | |
Fabien Sanglard | c45a7d9 | 2017-03-14 13:24:22 -0700 | [diff] [blame] | 270 | // The offset in nanoseconds to use when DispSync timestamps present fence |
| 271 | // signaling time. |
| 272 | static int64_t dispSyncPresentTimeOffset; |
| 273 | |
Fabien Sanglard | a34ed63 | 2017-03-14 11:43:52 -0700 | [diff] [blame] | 274 | // Some hardware can do RGB->YUV conversion more efficiently in hardware |
| 275 | // controlled by HWC than in hardware controlled by the video encoder. |
| 276 | // This instruct VirtualDisplaySurface to use HWC for such conversion on |
| 277 | // GL composition. |
| 278 | static bool useHwcForRgbToYuv; |
| 279 | |
Fabien Sanglard | c8e387e | 2017-03-10 10:30:28 -0800 | [diff] [blame] | 280 | // Maximum dimension supported by HWC for virtual display. |
| 281 | // Equal to min(max_height, max_width). |
| 282 | static uint64_t maxVirtualDisplaySize; |
| 283 | |
Fabien Sanglard | 1971b63 | 2017-03-10 14:50:03 -0800 | [diff] [blame] | 284 | // Controls the number of buffers SurfaceFlinger will allocate for use in |
| 285 | // FramebufferSurface |
| 286 | static int64_t maxFrameBufferAcquiredBuffers; |
| 287 | |
Peiyong Lin | 13effd1 | 2018-07-24 17:01:47 -0700 | [diff] [blame] | 288 | // Indicate if a device has wide color gamut display. This is typically |
| 289 | // found on devices with wide color gamut (e.g. Display-P3) display. |
Courtney Goeltzenleuchter | 5d94389 | 2017-03-22 13:46:46 -0600 | [diff] [blame] | 290 | static bool hasWideColorDisplay; |
| 291 | |
Chia-I Wu | 304d9cd | 2018-08-27 14:38:14 -0700 | [diff] [blame] | 292 | static int primaryDisplayOrientation; |
| 293 | |
Peiyong Lin | 13effd1 | 2018-07-24 17:01:47 -0700 | [diff] [blame] | 294 | // Indicate if device wants color management on its display. |
| 295 | static bool useColorManagement; |
| 296 | |
Mathias Agopian | b6df7d0 | 2013-05-09 14:53:35 -0700 | [diff] [blame] | 297 | static char const* getServiceName() ANDROID_API { |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 298 | return "SurfaceFlinger"; |
| 299 | } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 300 | |
Lloyd Pique | ac648ee | 2018-01-17 13:42:24 -0800 | [diff] [blame] | 301 | struct SkipInitializationTag {}; |
| 302 | static constexpr SkipInitializationTag SkipInitialization; |
| 303 | explicit SurfaceFlinger(SkipInitializationTag) ANDROID_API; |
Mathias Agopian | b6df7d0 | 2013-05-09 14:53:35 -0700 | [diff] [blame] | 304 | SurfaceFlinger() ANDROID_API; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 305 | |
Mathias Agopian | 4f4f094 | 2013-08-19 17:26:18 -0700 | [diff] [blame] | 306 | // must be called before clients can connect |
| 307 | void init() ANDROID_API; |
| 308 | |
| 309 | // starts SurfaceFlinger main loop in the current thread |
| 310 | void run() ANDROID_API; |
| 311 | |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 312 | enum { |
| 313 | EVENT_VSYNC = HWC_EVENT_VSYNC |
| 314 | }; |
| 315 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 316 | // post an asynchronous message to the main thread |
Mathias Agopian | 3f84483 | 2013-08-07 21:24:32 -0700 | [diff] [blame] | 317 | status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 318 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 319 | // post a synchronous message to the main thread |
Mathias Agopian | 3f84483 | 2013-08-07 21:24:32 -0700 | [diff] [blame] | 320 | status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 321 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 322 | // force full composition on all displays |
| 323 | void repaintEverything(); |
Mathias Agopian | bf2c6a6 | 2010-12-10 16:22:31 -0800 | [diff] [blame] | 324 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 325 | // returns the default Display |
Tomasz Wasilczyk | 8722a31 | 2017-04-13 19:14:30 +0000 | [diff] [blame] | 326 | sp<const DisplayDevice> getDefaultDisplayDevice() const { |
Stephen Kiazyk | 7d3dcb9 | 2017-04-05 16:46:49 -0700 | [diff] [blame] | 327 | Mutex::Autolock _l(mStateLock); |
| 328 | return getDefaultDisplayDeviceLocked(); |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 329 | } |
Mathias Agopian | b60314a | 2012-04-10 22:09:54 -0700 | [diff] [blame] | 330 | |
Dan Stoza | 436ccf3 | 2018-06-21 12:10:12 -0700 | [diff] [blame] | 331 | // Obtains a name from the texture pool, or, if the pool is empty, posts a |
| 332 | // synchronous message to the main thread to obtain one on the fly |
| 333 | uint32_t getNewTexture(); |
| 334 | |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 335 | // utility function to delete a texture on the main thread |
Mathias Agopian | 3f84483 | 2013-08-07 21:24:32 -0700 | [diff] [blame] | 336 | void deleteTextureAsync(uint32_t texture); |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 337 | |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 338 | // enable/disable h/w composer event |
| 339 | // TODO: this should be made accessible only to EventThread |
Dan Stoza | 9e56aa0 | 2015-11-02 13:00:03 -0800 | [diff] [blame] | 340 | void setVsyncEnabled(int disp, int enabled); |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 341 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 342 | // called on the main thread by MessageQueue when an internal message |
| 343 | // is received |
| 344 | // TODO: this should be made accessible only to MessageQueue |
| 345 | void onMessageReceived(int32_t what); |
Mathias Agopian | 3094df3 | 2012-06-18 18:06:45 -0700 | [diff] [blame] | 346 | |
Mathias Agopian | cb55857 | 2012-10-04 15:58:54 -0700 | [diff] [blame] | 347 | // for debugging only |
| 348 | // TODO: this should be made accessible only to HWComposer |
Jesse Hall | 48bc05b | 2013-03-21 14:06:52 -0700 | [diff] [blame] | 349 | const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id); |
Mathias Agopian | cb55857 | 2012-10-04 15:58:54 -0700 | [diff] [blame] | 350 | |
Peiyong Lin | 833074a | 2018-08-28 11:53:54 -0700 | [diff] [blame] | 351 | renderengine::RenderEngine& getRenderEngine() const { return *getBE().mRenderEngine; } |
Jesse Hall | 29c3f35 | 2013-05-21 15:36:55 -0700 | [diff] [blame] | 352 | |
Robert Carr | 0d48072 | 2017-01-10 16:42:54 -0800 | [diff] [blame] | 353 | bool authenticateSurfaceTextureLocked( |
| 354 | const sp<IGraphicBufferProducer>& bufferProducer) const; |
| 355 | |
Mathias Agopian | 1f339ff | 2011-07-01 17:08:43 -0700 | [diff] [blame] | 356 | private: |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 357 | friend class Client; |
Mathias Agopian | d0566bc | 2011-11-17 17:49:17 -0800 | [diff] [blame] | 358 | friend class DisplayEventConnection; |
Lloyd Pique | 0fcde1b | 2017-12-20 16:50:21 -0800 | [diff] [blame] | 359 | friend class impl::EventThread; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 360 | friend class Layer; |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 361 | friend class BufferLayer; |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 362 | friend class BufferQueueLayer; |
Marissa Wall | 61c5862 | 2018-07-18 10:12:20 -0700 | [diff] [blame] | 363 | friend class BufferStateLayer; |
Dan Stoza | b9b0883 | 2014-03-13 11:55:57 -0700 | [diff] [blame] | 364 | friend class MonitoredProducer; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 365 | |
Lloyd Pique | f58625d | 2017-12-19 13:22:33 -0800 | [diff] [blame] | 366 | // For unit tests |
| 367 | friend class TestableSurfaceFlinger; |
| 368 | |
Jamie Gennis | 6547ff4 | 2013-07-16 20:12:42 -0700 | [diff] [blame] | 369 | // This value is specified in number of frames. Log frame stats at most |
| 370 | // every half hour. |
| 371 | enum { LOG_FRAME_STATS_PERIOD = 30*60*60 }; |
| 372 | |
Dan Stoza | 7d89d06 | 2015-04-30 13:29:25 -0700 | [diff] [blame] | 373 | static const size_t MAX_LAYERS = 4096; |
| 374 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 375 | // We're reference counted, never destroy SurfaceFlinger directly |
| 376 | virtual ~SurfaceFlinger(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 377 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 378 | /* ------------------------------------------------------------------------ |
| 379 | * Internal data structures |
| 380 | */ |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 381 | |
Robert Carr | 2047fae | 2016-11-28 14:09:09 -0800 | [diff] [blame] | 382 | class State { |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 383 | public: |
chaviw | fd46261 | 2018-05-31 16:11:27 -0700 | [diff] [blame] | 384 | explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {} |
Dan Stoza | 412903f | 2017-04-27 13:42:17 -0700 | [diff] [blame] | 385 | State& operator=(const State& other) { |
| 386 | // We explicitly don't copy stateSet so that, e.g., mDrawingState |
| 387 | // always uses the Drawing StateSet. |
| 388 | layersSortedByZ = other.layersSortedByZ; |
| 389 | displays = other.displays; |
Chia-I Wu | 28f320b | 2018-05-03 11:02:56 -0700 | [diff] [blame] | 390 | colorMatrixChanged = other.colorMatrixChanged; |
| 391 | if (colorMatrixChanged) { |
| 392 | colorMatrix = other.colorMatrix; |
| 393 | } |
Dan Stoza | 412903f | 2017-04-27 13:42:17 -0700 | [diff] [blame] | 394 | return *this; |
| 395 | } |
| 396 | |
| 397 | const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid; |
Mathias Agopian | 92a979a | 2012-08-02 18:32:23 -0700 | [diff] [blame] | 398 | LayerVector layersSortedByZ; |
Mathias Agopian | e57f292 | 2012-08-09 16:29:12 -0700 | [diff] [blame] | 399 | DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays; |
Robert Carr | 2047fae | 2016-11-28 14:09:09 -0800 | [diff] [blame] | 400 | |
Chia-I Wu | 28f320b | 2018-05-03 11:02:56 -0700 | [diff] [blame] | 401 | bool colorMatrixChanged = true; |
| 402 | mat4 colorMatrix; |
| 403 | |
Dan Stoza | 412903f | 2017-04-27 13:42:17 -0700 | [diff] [blame] | 404 | void traverseInZOrder(const LayerVector::Visitor& visitor) const; |
| 405 | void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 406 | }; |
| 407 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 408 | /* ------------------------------------------------------------------------ |
| 409 | * IBinder interface |
| 410 | */ |
| 411 | virtual status_t onTransact(uint32_t code, const Parcel& data, |
| 412 | Parcel* reply, uint32_t flags); |
Vishnu Nair | 3579887 | 2017-10-06 16:00:36 -0700 | [diff] [blame] | 413 | virtual status_t dump(int fd, const Vector<String16>& args) { return priorityDump(fd, args); } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 414 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 415 | /* ------------------------------------------------------------------------ |
| 416 | * ISurfaceComposer interface |
| 417 | */ |
| 418 | virtual sp<ISurfaceComposerClient> createConnection(); |
Robert Carr | 1db73f6 | 2016-12-21 12:58:51 -0800 | [diff] [blame] | 419 | virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp); |
Jamie Gennis | dd3cb84 | 2012-10-19 18:19:11 -0700 | [diff] [blame] | 420 | virtual sp<IBinder> createDisplay(const String8& displayName, bool secure); |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 421 | virtual void destroyDisplay(const sp<IBinder>& displayToken); |
Mathias Agopian | e57f292 | 2012-08-09 16:29:12 -0700 | [diff] [blame] | 422 | virtual sp<IBinder> getBuiltInDisplay(int32_t id); |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 423 | virtual void setTransactionState(const Vector<ComposerState>& state, |
Mathias Agopian | 8b33f03 | 2012-07-24 20:43:54 -0700 | [diff] [blame] | 424 | const Vector<DisplayState>& displays, uint32_t flags); |
Mathias Agopian | 92a979a | 2012-08-02 18:32:23 -0700 | [diff] [blame] | 425 | virtual void bootFinished(); |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 426 | virtual bool authenticateSurfaceTexture( |
Andy McFadden | 2adaf04 | 2012-12-18 09:49:45 -0800 | [diff] [blame] | 427 | const sp<IGraphicBufferProducer>& bufferProducer) const; |
Brian Anderson | 6b37671 | 2017-04-04 10:51:39 -0700 | [diff] [blame] | 428 | virtual status_t getSupportedFrameTimestamps( |
| 429 | std::vector<FrameEvent>* outSupported) const; |
Jorim Jaggi | b1e2f8d | 2017-06-08 15:43:59 -0700 | [diff] [blame] | 430 | virtual sp<IDisplayEventConnection> createDisplayEventConnection( |
| 431 | ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp); |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 432 | virtual status_t captureScreen(const sp<IBinder>& displayToken, sp<GraphicBuffer>* outBuffer, |
Chavi Weingarten | 40482ff | 2017-11-30 01:51:40 +0000 | [diff] [blame] | 433 | Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, |
| 434 | int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform, |
| 435 | ISurfaceComposer::Rotation rotation); |
| 436 | virtual status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer, |
Robert Carr | 578038f | 2018-03-09 12:25:24 -0800 | [diff] [blame] | 437 | const Rect& sourceCrop, float frameScale, bool childrenOnly); |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 438 | virtual status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats); |
| 439 | virtual status_t getDisplayConfigs(const sp<IBinder>& displayToken, |
| 440 | Vector<DisplayInfo>* configs); |
| 441 | virtual int getActiveConfig(const sp<IBinder>& displayToken); |
| 442 | virtual status_t getDisplayColorModes(const sp<IBinder>& displayToken, |
| 443 | Vector<ui::ColorMode>* configs); |
| 444 | virtual ui::ColorMode getActiveColorMode(const sp<IBinder>& displayToken); |
| 445 | virtual status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode); |
| 446 | virtual void setPowerMode(const sp<IBinder>& displayToken, int mode); |
| 447 | virtual status_t setActiveConfig(const sp<IBinder>& displayToken, int id); |
Svetoslav | d85084b | 2014-03-20 10:28:31 -0700 | [diff] [blame] | 448 | virtual status_t clearAnimationFrameStats(); |
| 449 | virtual status_t getAnimationFrameStats(FrameStats* outStats) const; |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 450 | virtual status_t getHdrCapabilities(const sp<IBinder>& displayToken, |
| 451 | HdrCapabilities* outCapabilities) const; |
Sahil Dhanju | c1ba5c4 | 2016-06-07 20:09:20 -0700 | [diff] [blame] | 452 | virtual status_t enableVSyncInjections(bool enable); |
| 453 | virtual status_t injectVSync(nsecs_t when); |
Kalle Raita | a099a24 | 2017-01-11 11:17:29 -0800 | [diff] [blame] | 454 | virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const; |
Sahil Dhanju | c1ba5c4 | 2016-06-07 20:09:20 -0700 | [diff] [blame] | 455 | |
Mathias Agopian | 1b03149 | 2012-06-20 17:51:20 -0700 | [diff] [blame] | 456 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 457 | /* ------------------------------------------------------------------------ |
| 458 | * DeathRecipient interface |
| 459 | */ |
| 460 | virtual void binderDied(const wp<IBinder>& who); |
Mathias Agopian | 99ce5cd | 2012-01-31 18:24:27 -0800 | [diff] [blame] | 461 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 462 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 4f4f094 | 2013-08-19 17:26:18 -0700 | [diff] [blame] | 463 | * RefBase interface |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 464 | */ |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 465 | virtual void onFirstRef(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 466 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 467 | /* ------------------------------------------------------------------------ |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 468 | * HWC2::ComposerCallback / HWComposer::EventHandler interface |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 469 | */ |
Dominik Laskowski | a2edf61 | 2018-06-01 13:15:16 -0700 | [diff] [blame] | 470 | void onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 471 | int64_t timestamp) override; |
Dominik Laskowski | a2edf61 | 2018-06-01 13:15:16 -0700 | [diff] [blame] | 472 | void onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, |
Lloyd Pique | 715a2c1 | 2017-12-14 17:18:08 -0800 | [diff] [blame] | 473 | HWC2::Connection connection) override; |
Dominik Laskowski | a2edf61 | 2018-06-01 13:15:16 -0700 | [diff] [blame] | 474 | void onRefreshReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId) override; |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 475 | |
| 476 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 477 | * Message handling |
| 478 | */ |
| 479 | void waitForEvent(); |
Steven Thomas | 6d8110b | 2017-08-31 18:24:21 -0700 | [diff] [blame] | 480 | // Can only be called from the main thread or with mStateLock held |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 481 | void signalTransaction(); |
Steven Thomas | 6d8110b | 2017-08-31 18:24:21 -0700 | [diff] [blame] | 482 | // Can only be called from the main thread or with mStateLock held |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 483 | void signalLayerUpdate(); |
| 484 | void signalRefresh(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 485 | |
Andy McFadden | 13a082e | 2012-08-24 10:16:42 -0700 | [diff] [blame] | 486 | // called on the main thread in response to initializeDisplays() |
| 487 | void onInitializeDisplays(); |
Michael Lentine | 6c9e34a | 2014-07-14 13:48:55 -0700 | [diff] [blame] | 488 | // called on the main thread in response to setActiveConfig() |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 489 | void setActiveConfigInternal(const sp<DisplayDevice>& display, int mode); |
Prashant Malani | 2c9b11f | 2014-05-25 01:36:31 -0700 | [diff] [blame] | 490 | // called on the main thread in response to setPowerMode() |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 491 | void setPowerModeInternal(const sp<DisplayDevice>& display, int mode, bool stateLockHeld); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 492 | |
Michael Wright | 28f24d0 | 2016-07-12 13:30:53 -0700 | [diff] [blame] | 493 | // Called on the main thread in response to setActiveColorMode() |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 494 | void setActiveColorModeInternal(const sp<DisplayDevice>& display, ui::ColorMode colorMode, |
| 495 | ui::Dataspace dataSpace, ui::RenderIntent renderIntent); |
Michael Wright | 28f24d0 | 2016-07-12 13:30:53 -0700 | [diff] [blame] | 496 | |
Dan Stoza | 6b9454d | 2014-11-07 16:00:59 -0800 | [diff] [blame] | 497 | // Returns whether the transaction actually modified any state |
| 498 | bool handleMessageTransaction(); |
| 499 | |
| 500 | // Returns whether a new buffer has been latched (see handlePageFlip()) |
| 501 | bool handleMessageInvalidate(); |
| 502 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 503 | void handleMessageRefresh(); |
Mathias Agopian | 4fec873 | 2012-06-29 14:12:52 -0700 | [diff] [blame] | 504 | |
Mathias Agopian | 87baae1 | 2012-07-31 12:38:26 -0700 | [diff] [blame] | 505 | void handleTransaction(uint32_t transactionFlags); |
| 506 | void handleTransactionLocked(uint32_t transactionFlags); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 507 | |
Riley Andrews | 03414a1 | 2014-07-01 14:22:59 -0700 | [diff] [blame] | 508 | void updateCursorAsync(); |
| 509 | |
Dan Stoza | 6b9454d | 2014-11-07 16:00:59 -0800 | [diff] [blame] | 510 | /* handlePageFlip - latch a new buffer if available and compute the dirty |
| 511 | * region. Returns whether a new buffer has been latched, i.e., whether it |
| 512 | * is necessary to perform a refresh during this vsync. |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 513 | */ |
Dan Stoza | 6b9454d | 2014-11-07 16:00:59 -0800 | [diff] [blame] | 514 | bool handlePageFlip(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 515 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 516 | /* ------------------------------------------------------------------------ |
| 517 | * Transactions |
| 518 | */ |
| 519 | uint32_t getTransactionFlags(uint32_t flags); |
Fabien Sanglard | c8251eb | 2016-12-07 13:59:48 -0800 | [diff] [blame] | 520 | uint32_t peekTransactionFlags(); |
Steven Thomas | 6d8110b | 2017-08-31 18:24:21 -0700 | [diff] [blame] | 521 | // Can only be called from the main thread or with mStateLock held |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 522 | uint32_t setTransactionFlags(uint32_t flags); |
Dan Stoza | 84d619e | 2018-03-28 17:07:36 -0700 | [diff] [blame] | 523 | uint32_t setTransactionFlags(uint32_t flags, VSyncModulator::TransactionStart transactionStart); |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 524 | void commitTransaction(); |
chaviw | ca27f25 | 2018-02-06 16:46:39 -0800 | [diff] [blame] | 525 | bool containsAnyInvalidClientState(const Vector<ComposerState>& states); |
| 526 | uint32_t setClientStateLocked(const ComposerState& composerState); |
Mathias Agopian | e57f292 | 2012-08-09 16:29:12 -0700 | [diff] [blame] | 527 | uint32_t setDisplayStateLocked(const DisplayState& s); |
chaviw | ca27f25 | 2018-02-06 16:46:39 -0800 | [diff] [blame] | 528 | void setDestroyStateLocked(const ComposerState& composerState); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 529 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 530 | /* ------------------------------------------------------------------------ |
| 531 | * Layer management |
| 532 | */ |
Mathias Agopian | 4d9b822 | 2013-03-12 17:11:48 -0700 | [diff] [blame] | 533 | status_t createLayer(const String8& name, const sp<Client>& client, |
| 534 | uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, |
rongliu | cfb187b | 2018-03-14 12:26:23 -0700 | [diff] [blame] | 535 | int32_t windowType, int32_t ownerUid, sp<IBinder>* handle, |
Albert Chaulk | 479c60c | 2017-01-27 14:21:34 -0500 | [diff] [blame] | 536 | sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 537 | |
Marissa Wall | fd66862 | 2018-05-10 10:21:13 -0700 | [diff] [blame] | 538 | status_t createBufferQueueLayer(const sp<Client>& client, const String8& name, uint32_t w, |
| 539 | uint32_t h, uint32_t flags, PixelFormat& format, |
| 540 | sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp, |
| 541 | sp<Layer>* outLayer); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 542 | |
Marissa Wall | 61c5862 | 2018-07-18 10:12:20 -0700 | [diff] [blame] | 543 | status_t createBufferStateLayer(const sp<Client>& client, const String8& name, uint32_t w, |
| 544 | uint32_t h, uint32_t flags, sp<IBinder>* outHandle, |
| 545 | sp<Layer>* outLayer); |
| 546 | |
chaviw | 13fdc49 | 2017-06-27 12:40:18 -0700 | [diff] [blame] | 547 | status_t createColorLayer(const sp<Client>& client, const String8& name, |
Mathias Agopian | 4d9b822 | 2013-03-12 17:11:48 -0700 | [diff] [blame] | 548 | uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle, |
David Sodman | 0c69cad | 2017-08-21 12:12:51 -0700 | [diff] [blame] | 549 | sp<Layer>* outLayer); |
Mathias Agopian | 74c40c0 | 2010-09-29 13:02:36 -0700 | [diff] [blame] | 550 | |
Robert Carr | 6b3f6c5 | 2018-08-13 13:05:17 -0700 | [diff] [blame] | 551 | status_t createContainerLayer(const sp<Client>& client, const String8& name, |
| 552 | uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle, |
| 553 | sp<Layer>* outLayer); |
| 554 | |
Cody Northrop | bc75528 | 2017-03-31 12:00:08 -0600 | [diff] [blame] | 555 | String8 getUniqueLayerName(const String8& name); |
| 556 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 557 | // called in response to the window-manager calling |
| 558 | // ISurfaceComposerClient::destroySurface() |
Mathias Agopian | ac9fa42 | 2013-02-11 16:40:36 -0800 | [diff] [blame] | 559 | status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle); |
Mathias Agopian | b9494d5 | 2012-04-18 02:28:45 -0700 | [diff] [blame] | 560 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 561 | // called when all clients have released all their references to |
| 562 | // this layer meaning it is entirely safe to destroy all |
| 563 | // resources associated to this layer. |
Mathias Agopian | 13127d8 | 2013-03-05 17:47:11 -0800 | [diff] [blame] | 564 | status_t onLayerDestroyed(const wp<Layer>& layer); |
Mathias Agopian | a491260 | 2012-07-12 14:25:33 -0700 | [diff] [blame] | 565 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 566 | // remove a layer from SurfaceFlinger immediately |
Chia-I Wu | 515dc9c | 2017-06-15 12:53:59 -0700 | [diff] [blame] | 567 | status_t removeLayer(const sp<Layer>& layer, bool topLevelOnly = false); |
chaviw | ca27f25 | 2018-02-06 16:46:39 -0800 | [diff] [blame] | 568 | status_t removeLayerLocked(const Mutex&, const sp<Layer>& layer, bool topLevelOnly = false); |
Mathias Agopian | a491260 | 2012-07-12 14:25:33 -0700 | [diff] [blame] | 569 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 570 | // add a layer to SurfaceFlinger |
Dan Stoza | 7d89d06 | 2015-04-30 13:29:25 -0700 | [diff] [blame] | 571 | status_t addClientLayer(const sp<Client>& client, |
Mathias Agopian | 6710604 | 2013-03-14 19:18:13 -0700 | [diff] [blame] | 572 | const sp<IBinder>& handle, |
| 573 | const sp<IGraphicBufferProducer>& gbc, |
Robert Carr | 1f0a16a | 2016-10-24 16:27:39 -0700 | [diff] [blame] | 574 | const sp<Layer>& lbc, |
| 575 | const sp<Layer>& parent); |
Mathias Agopian | f1d8e87 | 2009-04-20 19:39:12 -0700 | [diff] [blame] | 576 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 577 | /* ------------------------------------------------------------------------ |
| 578 | * Boot animation, on/off animations and screen capture |
| 579 | */ |
Mathias Agopian | bb64124 | 2010-05-18 17:06:55 -0700 | [diff] [blame] | 580 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 581 | void startBootAnim(); |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 582 | |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 583 | void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers, |
Chia-I Wu | 1be50b5 | 2018-08-29 10:44:48 -0700 | [diff] [blame] | 584 | bool useIdentityTransform); |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 585 | status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers, |
Chavi Weingarten | 40482ff | 2017-11-30 01:51:40 +0000 | [diff] [blame] | 586 | sp<GraphicBuffer>* outBuffer, |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 587 | bool useIdentityTransform); |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 588 | status_t captureScreenImplLocked(const RenderArea& renderArea, |
| 589 | TraverseLayersFunction traverseLayers, |
| 590 | ANativeWindowBuffer* buffer, bool useIdentityTransform, |
Robert Carr | 03480e2 | 2018-01-04 16:02:06 -0800 | [diff] [blame] | 591 | bool forSystem, int* outSyncFd); |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 592 | void traverseLayersInDisplay(const sp<const DisplayDevice>& display, int32_t minLayerZ, |
| 593 | int32_t maxLayerZ, const LayerVector::Visitor& visitor); |
Mathias Agopian | abe815d | 2013-03-19 22:22:21 -0700 | [diff] [blame] | 594 | |
Wei Wang | f9b05ee | 2017-07-19 20:59:39 -0700 | [diff] [blame] | 595 | sp<StartPropertySetThread> mStartPropertySetThread = nullptr; |
Wei Wang | b254fa3 | 2017-01-31 17:43:23 -0800 | [diff] [blame] | 596 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 597 | /* ------------------------------------------------------------------------ |
Romain Guy | 11d63f4 | 2017-07-20 12:47:14 -0700 | [diff] [blame] | 598 | * Properties |
| 599 | */ |
| 600 | void readPersistentProperties(); |
| 601 | |
| 602 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 603 | * EGL |
| 604 | */ |
Mathias Agopian | 875d8e1 | 2013-06-07 15:35:48 -0700 | [diff] [blame] | 605 | size_t getMaxTextureSize() const; |
| 606 | size_t getMaxViewportDims() const; |
Mathias Agopian | a491260 | 2012-07-12 14:25:33 -0700 | [diff] [blame] | 607 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 608 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 87baae1 | 2012-07-31 12:38:26 -0700 | [diff] [blame] | 609 | * Display and layer stack management |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 610 | */ |
Andy McFadden | 13a082e | 2012-08-24 10:16:42 -0700 | [diff] [blame] | 611 | // called when starting, or restarting after system_server death |
| 612 | void initializeDisplays(); |
| 613 | |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 614 | sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) const { |
| 615 | Mutex::Autolock _l(mStateLock); |
| 616 | return getDisplayDeviceLocked(displayToken); |
Stephen Kiazyk | 7d3dcb9 | 2017-04-05 16:46:49 -0700 | [diff] [blame] | 617 | } |
| 618 | |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 619 | sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) { |
| 620 | Mutex::Autolock _l(mStateLock); |
| 621 | return getDisplayDeviceLocked(displayToken); |
Stephen Kiazyk | 7d3dcb9 | 2017-04-05 16:46:49 -0700 | [diff] [blame] | 622 | } |
| 623 | |
| 624 | // NOTE: can only be called from the main thread or with mStateLock held |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 625 | sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const { |
| 626 | return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken); |
Mathias Agopian | 92a979a | 2012-08-02 18:32:23 -0700 | [diff] [blame] | 627 | } |
Mathias Agopian | db9b41f | 2012-10-15 16:51:41 -0700 | [diff] [blame] | 628 | |
| 629 | // NOTE: can only be called from the main thread or with mStateLock held |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 630 | sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) { |
Dominik Laskowski | 9fae102 | 2018-05-29 13:17:40 -0700 | [diff] [blame] | 631 | const auto it = mDisplays.find(displayToken); |
| 632 | return it == mDisplays.end() ? nullptr : it->second; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 633 | } |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 634 | |
Stephen Kiazyk | 7d3dcb9 | 2017-04-05 16:46:49 -0700 | [diff] [blame] | 635 | sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const { |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 636 | return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked(); |
Stephen Kiazyk | 7d3dcb9 | 2017-04-05 16:46:49 -0700 | [diff] [blame] | 637 | } |
| 638 | |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 639 | sp<DisplayDevice> getDefaultDisplayDeviceLocked() { |
| 640 | return getDisplayDeviceLocked(mDisplayTokens[DisplayDevice::DISPLAY_PRIMARY]); |
Michael Wright | 28f24d0 | 2016-07-12 13:30:53 -0700 | [diff] [blame] | 641 | } |
| 642 | |
Mathias Agopian | 87baae1 | 2012-07-31 12:38:26 -0700 | [diff] [blame] | 643 | // mark a region of a layer stack dirty. this updates the dirty |
| 644 | // region of all screens presenting this layer stack. |
Chia-I Wu | ab0c319 | 2017-08-01 11:29:00 -0700 | [diff] [blame] | 645 | void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty); |
Mathias Agopian | 87baae1 | 2012-07-31 12:38:26 -0700 | [diff] [blame] | 646 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 647 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 648 | * H/W composer |
| 649 | */ |
| 650 | |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 651 | HWComposer& getHwComposer() const { return *getBE().mHwc; } |
Mathias Agopian | 8630320 | 2012-07-24 22:46:10 -0700 | [diff] [blame] | 652 | |
Mathias Agopian | 888c822 | 2012-08-04 21:10:38 -0700 | [diff] [blame] | 653 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 654 | * Compositing |
| 655 | */ |
| 656 | void invalidateHwcGeometry(); |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 657 | void computeVisibleRegions(const sp<const DisplayDevice>& display, Region& dirtyRegion, |
| 658 | Region& opaqueRegion); |
Mathias Agopian | cd60f99 | 2012-08-16 16:28:27 -0700 | [diff] [blame] | 659 | |
David Sodman | 2b40636 | 2017-12-15 13:33:47 -0800 | [diff] [blame] | 660 | void preComposition(); |
| 661 | void postComposition(); |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 662 | void updateCompositorTiming( |
| 663 | nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime, |
| 664 | std::shared_ptr<FenceTime>& presentFenceTime); |
Brian Anderson | d001058 | 2017-03-07 13:20:31 -0800 | [diff] [blame] | 665 | void setCompositorTimingSnapped( |
| 666 | nsecs_t vsyncPhase, nsecs_t vsyncInterval, |
| 667 | nsecs_t compositeToPresentLatency); |
Mathias Agopian | cd60f99 | 2012-08-16 16:28:27 -0700 | [diff] [blame] | 668 | void rebuildLayerStacks(); |
Courtney Goeltzenleuchter | 5d94389 | 2017-03-22 13:46:46 -0600 | [diff] [blame] | 669 | |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 670 | ui::Dataspace getBestDataspace(const sp<const DisplayDevice>& display, |
Peiyong Lin | 136fbbc | 2018-04-17 15:09:44 -0700 | [diff] [blame] | 671 | ui::Dataspace* outHdrDataSpace) const; |
| 672 | |
| 673 | // Returns the appropriate ColorMode, Dataspace and RenderIntent for the |
| 674 | // DisplayDevice. The function only returns the supported ColorMode, |
| 675 | // Dataspace and RenderIntent. |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 676 | void pickColorMode(const sp<DisplayDevice>& display, ui::ColorMode* outMode, |
| 677 | ui::Dataspace* outDataSpace, ui::RenderIntent* outRenderIntent) const; |
Romain Guy | 0147a17 | 2017-06-01 13:53:56 -0700 | [diff] [blame] | 678 | |
David Sodman | 79bba0e | 2018-08-05 18:07:49 -0700 | [diff] [blame] | 679 | void calculateWorkingSet(); |
David Sodman | 2b40636 | 2017-12-15 13:33:47 -0800 | [diff] [blame] | 680 | /* |
| 681 | * beginFrame - This function handles any pre-frame processing that needs to be |
| 682 | * prior to any CompositionInfo handling and is not dependent on data in |
| 683 | * CompositionInfo |
| 684 | */ |
David Sodman | fa9b2af | 2017-12-24 13:28:59 -0800 | [diff] [blame] | 685 | void beginFrame(const sp<DisplayDevice>& display); |
David Sodman | 2b40636 | 2017-12-15 13:33:47 -0800 | [diff] [blame] | 686 | /* prepareFrame - This function will call into the DisplayDevice to prepare a |
| 687 | * frame after CompositionInfo has been programmed. This provides a mechanism |
| 688 | * to prepare the hardware composer |
| 689 | */ |
David Sodman | fa9b2af | 2017-12-24 13:28:59 -0800 | [diff] [blame] | 690 | void prepareFrame(const sp<DisplayDevice>& display); |
David Sodman | 10a41ff | 2018-08-05 12:14:17 -0700 | [diff] [blame] | 691 | void setUpHWComposer(const CompositionInfo& compositionInfo); |
David Sodman | fa9b2af | 2017-12-24 13:28:59 -0800 | [diff] [blame] | 692 | void doComposition(const sp<DisplayDevice>& display, bool repainEverything); |
| 693 | void doDebugFlashRegions(const sp<DisplayDevice>& display, bool repaintEverything); |
Adrian Roos | 1e1a128 | 2017-11-01 19:05:31 +0100 | [diff] [blame] | 694 | void doTracing(const char* where); |
Yiwei Zhang | 7124ad3 | 2018-02-21 13:02:45 -0800 | [diff] [blame] | 695 | void logLayerStats(); |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 696 | void doDisplayComposition(const sp<const DisplayDevice>& display, const Region& dirtyRegion); |
Michael Lentine | 3f121fc | 2014-10-01 11:17:28 -0700 | [diff] [blame] | 697 | |
Dominik Laskowski | a2edf61 | 2018-06-01 13:15:16 -0700 | [diff] [blame] | 698 | // This fails if using GL and the surface has been destroyed. |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 699 | bool doComposeSurfaces(const sp<const DisplayDevice>& display); |
Mathias Agopian | cd60f99 | 2012-08-16 16:28:27 -0700 | [diff] [blame] | 700 | |
David Sodman | fa9b2af | 2017-12-24 13:28:59 -0800 | [diff] [blame] | 701 | void postFramebuffer(const sp<DisplayDevice>& display); |
| 702 | void postFrame(); |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 703 | void drawWormhole(const sp<const DisplayDevice>& display, const Region& region) const; |
Mathias Agopian | 4da7519 | 2010-08-10 17:19:56 -0700 | [diff] [blame] | 704 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 705 | /* ------------------------------------------------------------------------ |
Jamie Gennis | 0bceb84 | 2012-08-23 20:19:38 -0700 | [diff] [blame] | 706 | * Display management |
| 707 | */ |
Dominik Laskowski | a2edf61 | 2018-06-01 13:15:16 -0700 | [diff] [blame] | 708 | DisplayDevice::DisplayType determineDisplayType(hwc2_display_t hwcDisplayId, |
| 709 | HWC2::Connection connection) const; |
Dominik Laskowski | 7e04546 | 2018-05-30 13:02:02 -0700 | [diff] [blame] | 710 | sp<DisplayDevice> setupNewDisplayDeviceInternal(const wp<IBinder>& displayToken, |
| 711 | int32_t displayId, |
Lloyd Pique | 99d3da5 | 2018-01-22 17:48:03 -0800 | [diff] [blame] | 712 | const DisplayDeviceState& state, |
| 713 | const sp<DisplaySurface>& dispSurface, |
| 714 | const sp<IGraphicBufferProducer>& producer); |
Lloyd Pique | 347200f | 2017-12-14 17:00:15 -0800 | [diff] [blame] | 715 | void processDisplayChangesLocked(); |
Lloyd Pique | ba04e62 | 2017-12-14 17:11:26 -0800 | [diff] [blame] | 716 | void processDisplayHotplugEventsLocked(); |
Mathias Agopian | 3ee454a | 2012-08-27 16:28:24 -0700 | [diff] [blame] | 717 | |
Jamie Gennis | faf77cc | 2013-07-30 15:10:32 -0700 | [diff] [blame] | 718 | /* ------------------------------------------------------------------------ |
| 719 | * VSync |
| 720 | */ |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 721 | void enableHardwareVsync(); |
| 722 | void resyncToHardwareVsync(bool makeAvailable); |
| 723 | void disableHardwareVsync(bool makeUnavailable); |
Robert Carr | 1f0a16a | 2016-10-24 16:27:39 -0700 | [diff] [blame] | 724 | |
Tim Murray | 4a4e4a2 | 2016-04-19 16:29:23 +0000 | [diff] [blame] | 725 | public: |
Brian Anderson | 0a61b0c | 2016-12-07 14:55:56 -0800 | [diff] [blame] | 726 | void resyncWithRateLimit(); |
| 727 | void getCompositorTiming(CompositorTiming* compositorTiming); |
Tim Murray | 4a4e4a2 | 2016-04-19 16:29:23 +0000 | [diff] [blame] | 728 | private: |
Jamie Gennis | 0bceb84 | 2012-08-23 20:19:38 -0700 | [diff] [blame] | 729 | |
| 730 | /* ------------------------------------------------------------------------ |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 731 | * Debugging & dumpsys |
| 732 | */ |
Vishnu Nair | 3579887 | 2017-10-06 16:00:36 -0700 | [diff] [blame] | 733 | public: |
Vishnu Nair | 6a40853 | 2017-10-24 09:11:27 -0700 | [diff] [blame] | 734 | status_t dumpCritical(int fd, const Vector<String16>& /*args*/, bool asProto) { |
| 735 | return doDump(fd, Vector<String16>(), asProto); |
Vishnu Nair | 3579887 | 2017-10-06 16:00:36 -0700 | [diff] [blame] | 736 | } |
| 737 | |
Vishnu Nair | 6a40853 | 2017-10-24 09:11:27 -0700 | [diff] [blame] | 738 | status_t dumpAll(int fd, const Vector<String16>& args, bool asProto) { |
| 739 | return doDump(fd, args, asProto); |
| 740 | } |
| 741 | |
Vishnu Nair | 3579887 | 2017-10-06 16:00:36 -0700 | [diff] [blame] | 742 | private: |
Mathias Agopian | 3f84483 | 2013-08-07 21:24:32 -0700 | [diff] [blame] | 743 | void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const; |
| 744 | void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const; |
| 745 | void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result); |
| 746 | void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const; |
Keun young Park | 63f165f | 2012-08-31 10:53:36 -0700 | [diff] [blame] | 747 | bool startDdmConnection(); |
Fabien Sanglard | 63a5fcd | 2016-12-29 15:13:07 -0800 | [diff] [blame] | 748 | void appendSfConfigString(String8& result) const; |
Mathias Agopian | d555684 | 2013-09-19 17:08:37 -0700 | [diff] [blame] | 749 | void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr, |
chaviw | a76b271 | 2017-09-20 12:02:26 -0700 | [diff] [blame] | 750 | TraverseLayersFunction traverseLayers); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 751 | |
Jamie Gennis | 6547ff4 | 2013-07-16 20:12:42 -0700 | [diff] [blame] | 752 | void logFrameStats(); |
| 753 | |
Dan Stoza | b90cf07 | 2015-03-05 11:05:59 -0800 | [diff] [blame] | 754 | void dumpStaticScreenStats(String8& result) const; |
Brian Anderson | d6927fb | 2016-07-23 23:37:30 -0700 | [diff] [blame] | 755 | // Not const because each Layer needs to query Fences and cache timestamps. |
| 756 | void dumpFrameEventsLocked(String8& result); |
Dan Stoza | b90cf07 | 2015-03-05 11:05:59 -0800 | [diff] [blame] | 757 | |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 758 | void recordBufferingStats(const char* layerName, |
| 759 | std::vector<OccupancyTracker::Segment>&& history); |
| 760 | void dumpBufferingStats(String8& result) const; |
Dominik Laskowski | e9ef7c4 | 2018-03-12 19:34:30 -0700 | [diff] [blame] | 761 | void dumpDisplayIdentificationData(String8& result) const; |
Courtney Goeltzenleuchter | f3b2de1 | 2017-03-27 12:18:12 -0600 | [diff] [blame] | 762 | void dumpWideColorInfo(String8& result) const; |
David Sodman | 7e4ae11 | 2018-02-09 15:02:28 -0800 | [diff] [blame] | 763 | void dumpFrameCompositionInfo(String8& result) const; |
Jorim Jaggi | 8e0af36 | 2017-11-14 16:28:28 +0100 | [diff] [blame] | 764 | LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const; |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 765 | LayersProto dumpVisibleLayersProtoInfo(const DisplayDevice& display) const; |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 766 | |
Fabien Sanglard | 63a5fcd | 2016-12-29 15:13:07 -0800 | [diff] [blame] | 767 | bool isLayerTripleBufferingDisabled() const { |
| 768 | return this->mLayerTripleBufferingDisabled; |
| 769 | } |
Vishnu Nair | 6a40853 | 2017-10-24 09:11:27 -0700 | [diff] [blame] | 770 | status_t doDump(int fd, const Vector<String16>& args, bool asProto); |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 771 | |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 772 | /* ------------------------------------------------------------------------ |
| 773 | * VrFlinger |
| 774 | */ |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 775 | void resetDisplayState(); |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 776 | |
Steven Thomas | 050b2c8 | 2017-03-06 11:45:16 -0800 | [diff] [blame] | 777 | // Check to see if we should handoff to vr flinger. |
| 778 | void updateVrFlinger(); |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 779 | |
Chia-I Wu | 28f320b | 2018-05-03 11:02:56 -0700 | [diff] [blame] | 780 | void updateColorMatrixLocked(); |
| 781 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 782 | /* ------------------------------------------------------------------------ |
| 783 | * Attributes |
| 784 | */ |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 785 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 786 | // access must be protected by mStateLock |
| 787 | mutable Mutex mStateLock; |
Dan Stoza | 412903f | 2017-04-27 13:42:17 -0700 | [diff] [blame] | 788 | State mCurrentState{LayerVector::StateSet::Current}; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 789 | volatile int32_t mTransactionFlags; |
| 790 | Condition mTransactionCV; |
Jamie Gennis | 2d5e230 | 2012-10-15 18:24:43 -0700 | [diff] [blame] | 791 | bool mTransactionPending; |
| 792 | bool mAnimTransactionPending; |
Robert Carr | 1f0a16a | 2016-10-24 16:27:39 -0700 | [diff] [blame] | 793 | SortedVector< sp<Layer> > mLayersPendingRemoval; |
Dan Stoza | 101d8dc | 2018-02-27 15:42:25 -0800 | [diff] [blame] | 794 | |
Chia-I Wu | 28f320b | 2018-05-03 11:02:56 -0700 | [diff] [blame] | 795 | // global color transform states |
| 796 | Daltonizer mDaltonizer; |
| 797 | float mGlobalSaturationFactor = 1.0f; |
| 798 | mat4 mClientColorMatrix; |
| 799 | |
Dan Stoza | 101d8dc | 2018-02-27 15:42:25 -0800 | [diff] [blame] | 800 | // Can't be unordered_set because wp<> isn't hashable |
| 801 | std::set<wp<IBinder>> mGraphicBufferProducerList; |
Dan Stoza | 0a0158c | 2018-03-16 13:38:54 -0700 | [diff] [blame] | 802 | size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 803 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 804 | // protected by mStateLock (but we could use another lock) |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 805 | bool mLayersRemoved; |
Robert Carr | 1f0a16a | 2016-10-24 16:27:39 -0700 | [diff] [blame] | 806 | bool mLayersAdded; |
Mathias Agopian | ca4d360 | 2011-05-19 15:38:14 -0700 | [diff] [blame] | 807 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 808 | // access must be protected by mInvalidateLock |
Mathias Agopian | 87baae1 | 2012-07-31 12:38:26 -0700 | [diff] [blame] | 809 | volatile int32_t mRepaintEverything; |
Mathias Agopian | ca4d360 | 2011-05-19 15:38:14 -0700 | [diff] [blame] | 810 | |
David Sodman | 10a41ff | 2018-08-05 12:14:17 -0700 | [diff] [blame] | 811 | // helper methods |
| 812 | void configureHwcCommonData(const CompositionInfo& compositionInfo) const; |
| 813 | void configureDeviceComposition(const CompositionInfo& compositionInfo) const; |
| 814 | void configureSidebandComposition(const CompositionInfo& compositionInfo) const; |
| 815 | |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 816 | // constant members (no synchronization needed for access) |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 817 | nsecs_t mBootTime; |
Mathias Agopian | b4b1730 | 2013-03-20 18:36:41 -0700 | [diff] [blame] | 818 | bool mGpuToCpuSupported; |
Lloyd Pique | e83f931 | 2018-02-01 12:53:17 -0800 | [diff] [blame] | 819 | std::unique_ptr<EventThread> mEventThread; |
| 820 | std::unique_ptr<EventThread> mSFEventThread; |
| 821 | std::unique_ptr<EventThread> mInjectorEventThread; |
| 822 | std::unique_ptr<VSyncSource> mEventThreadSource; |
| 823 | std::unique_ptr<VSyncSource> mSfEventThreadSource; |
| 824 | std::unique_ptr<InjectVSyncSource> mVSyncInjector; |
Lloyd Pique | 755e319 | 2018-01-31 16:46:15 -0800 | [diff] [blame] | 825 | std::unique_ptr<EventControlThread> mEventControlThread; |
Dominik Laskowski | eecd659 | 2018-05-29 10:25:41 -0700 | [diff] [blame] | 826 | sp<IBinder> mDisplayTokens[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES]; |
Mathias Agopian | 3094df3 | 2012-06-18 18:06:45 -0700 | [diff] [blame] | 827 | |
Dan Stoza | 84d619e | 2018-03-28 17:07:36 -0700 | [diff] [blame] | 828 | VSyncModulator mVsyncModulator; |
| 829 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 830 | // Can only accessed from the main thread, these members |
| 831 | // don't need synchronization |
Dan Stoza | 412903f | 2017-04-27 13:42:17 -0700 | [diff] [blame] | 832 | State mDrawingState{LayerVector::StateSet::Drawing}; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 833 | bool mVisibleRegionsDirty; |
Dan Stoza | 9e56aa0 | 2015-11-02 13:00:03 -0800 | [diff] [blame] | 834 | bool mGeometryInvalid; |
Jamie Gennis | 4b0eba9 | 2013-02-05 13:30:24 -0800 | [diff] [blame] | 835 | bool mAnimCompositionPending; |
Dan Stoza | 9e56aa0 | 2015-11-02 13:00:03 -0800 | [diff] [blame] | 836 | std::vector<sp<Layer>> mLayersWithQueuedFrames; |
Dan Stoza | 05dacfb | 2016-07-01 13:33:38 -0700 | [diff] [blame] | 837 | sp<Fence> mPreviousPresentFence = Fence::NO_FENCE; |
| 838 | bool mHadClientComposition = false; |
Mathias Agopian | db9b41f | 2012-10-15 16:51:41 -0700 | [diff] [blame] | 839 | |
Chia-I Wu | 14c9c7b | 2018-06-26 10:18:18 +0800 | [diff] [blame] | 840 | enum class BootStage { |
| 841 | BOOTLOADER, |
| 842 | BOOTANIMATION, |
| 843 | FINISHED, |
| 844 | }; |
| 845 | BootStage mBootStage; |
| 846 | |
Lloyd Pique | ba04e62 | 2017-12-14 17:11:26 -0800 | [diff] [blame] | 847 | struct HotplugEvent { |
Dominik Laskowski | a2edf61 | 2018-06-01 13:15:16 -0700 | [diff] [blame] | 848 | hwc2_display_t hwcDisplayId; |
Lloyd Pique | ba04e62 | 2017-12-14 17:11:26 -0800 | [diff] [blame] | 849 | HWC2::Connection connection = HWC2::Connection::Invalid; |
Lloyd Pique | ba04e62 | 2017-12-14 17:11:26 -0800 | [diff] [blame] | 850 | }; |
| 851 | // protected by mStateLock |
| 852 | std::vector<HotplugEvent> mPendingHotplugEvents; |
| 853 | |
Mathias Agopian | db9b41f | 2012-10-15 16:51:41 -0700 | [diff] [blame] | 854 | // this may only be written from the main thread with mStateLock held |
| 855 | // it may be read from other threads with mStateLock held |
Dominik Laskowski | 9fae102 | 2018-05-29 13:17:40 -0700 | [diff] [blame] | 856 | std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 857 | |
| 858 | // don't use a lock for these, we don't care |
| 859 | int mDebugRegion; |
| 860 | int mDebugDDMS; |
| 861 | int mDebugDisableHWC; |
| 862 | int mDebugDisableTransformHint; |
| 863 | volatile nsecs_t mDebugInSwapBuffers; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 864 | volatile nsecs_t mDebugInTransaction; |
| 865 | nsecs_t mLastTransactionTime; |
David Sodman | fa9b2af | 2017-12-24 13:28:59 -0800 | [diff] [blame] | 866 | nsecs_t mPostFramebufferTime; |
Dan Stoza | ee44edd | 2015-03-23 15:50:23 -0700 | [diff] [blame] | 867 | bool mForceFullDamage; |
Dan Stoza | c5da271 | 2016-07-20 15:38:12 -0700 | [diff] [blame] | 868 | bool mPropagateBackpressure = true; |
Lloyd Pique | 4dccc41 | 2018-01-22 17:21:36 -0800 | [diff] [blame] | 869 | std::unique_ptr<SurfaceInterceptor> mInterceptor = |
| 870 | std::make_unique<impl::SurfaceInterceptor>(this); |
Adrian Roos | 1e1a128 | 2017-11-01 19:05:31 +0100 | [diff] [blame] | 871 | SurfaceTracing mTracing; |
Yiwei Zhang | 7124ad3 | 2018-02-21 13:02:45 -0800 | [diff] [blame] | 872 | LayerStats mLayerStats; |
Yiwei Zhang | faf3ded | 2018-05-02 17:37:17 -0700 | [diff] [blame] | 873 | TimeStats& mTimeStats = TimeStats::getInstance(); |
Fabien Sanglard | 642b23d | 2017-02-09 12:29:39 -0800 | [diff] [blame] | 874 | bool mUseHwcVirtualDisplays = false; |
Marissa Wall | cfcdaa5 | 2018-05-21 15:45:59 -0700 | [diff] [blame] | 875 | std::atomic<uint32_t> mFrameMissedCount{0}; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 876 | |
Fabien Sanglard | 63a5fcd | 2016-12-29 15:13:07 -0800 | [diff] [blame] | 877 | // Restrict layers to use two buffers in their bufferqueues. |
| 878 | bool mLayerTripleBufferingDisabled = false; |
| 879 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 880 | // these are thread safe |
Lloyd Pique | 3fcdef1 | 2018-01-22 17:14:00 -0800 | [diff] [blame] | 881 | mutable std::unique_ptr<MessageQueue> mEventQueue{std::make_unique<impl::MessageQueue>()}; |
Jamie Gennis | 4b0eba9 | 2013-02-05 13:30:24 -0800 | [diff] [blame] | 882 | FrameTracker mAnimFrameTracker; |
Lloyd Pique | 41be5d2 | 2018-06-21 13:11:48 -0700 | [diff] [blame] | 883 | std::unique_ptr<DispSync> mPrimaryDispSync; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 884 | |
| 885 | // protected by mDestroyedLayerLock; |
| 886 | mutable Mutex mDestroyedLayerLock; |
Mathias Agopian | 13127d8 | 2013-03-05 17:47:11 -0800 | [diff] [blame] | 887 | Vector<Layer const *> mDestroyedLayers; |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 888 | |
Jamie Gennis | faf77cc | 2013-07-30 15:10:32 -0700 | [diff] [blame] | 889 | // protected by mHWVsyncLock |
| 890 | Mutex mHWVsyncLock; |
| 891 | bool mPrimaryHWVsyncEnabled; |
Jesse Hall | 948fe0c | 2013-10-14 12:56:09 -0700 | [diff] [blame] | 892 | bool mHWVsyncAvailable; |
David Sodman | 2b40636 | 2017-12-15 13:33:47 -0800 | [diff] [blame] | 893 | nsecs_t mRefreshStartTime; |
Jamie Gennis | faf77cc | 2013-07-30 15:10:32 -0700 | [diff] [blame] | 894 | |
Dan Stoza | 2b6d38e | 2017-06-01 16:40:30 -0700 | [diff] [blame] | 895 | std::atomic<bool> mRefreshPending{false}; |
| 896 | |
Dan Stoza | 436ccf3 | 2018-06-21 12:10:12 -0700 | [diff] [blame] | 897 | // We maintain a pool of pre-generated texture names to hand out to avoid |
| 898 | // layer creation needing to run on the main thread (which it would |
| 899 | // otherwise need to do to access RenderEngine). |
| 900 | std::mutex mTexturePoolMutex; |
| 901 | uint32_t mTexturePoolSize = 0; |
| 902 | std::vector<uint32_t> mTexturePool; |
| 903 | |
Mathias Agopian | 921e6ac | 2012-07-23 23:11:29 -0700 | [diff] [blame] | 904 | /* ------------------------------------------------------------------------ |
| 905 | * Feature prototyping |
| 906 | */ |
| 907 | |
Sahil Dhanju | c1ba5c4 | 2016-06-07 20:09:20 -0700 | [diff] [blame] | 908 | bool mInjectVSyncs; |
| 909 | |
Dan Stoza | b90cf07 | 2015-03-05 11:05:59 -0800 | [diff] [blame] | 910 | // Static screen stats |
| 911 | bool mHasPoweredOff; |
Dan Stoza | e77c766 | 2016-05-13 11:37:28 -0700 | [diff] [blame] | 912 | |
Robert Carr | 1f0a16a | 2016-10-24 16:27:39 -0700 | [diff] [blame] | 913 | size_t mNumLayers; |
| 914 | |
Fabien Sanglard | 6e8e98a | 2016-10-27 20:04:11 -0700 | [diff] [blame] | 915 | // Verify that transaction is being called by an approved process: |
| 916 | // either AID_GRAPHICS or AID_SYSTEM. |
| 917 | status_t CheckTransactCodeCredentials(uint32_t code); |
Hendrik Wagenaar | 87670ff | 2017-02-01 12:10:46 -0800 | [diff] [blame] | 918 | |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 919 | std::unique_ptr<dvr::VrFlinger> mVrFlinger; |
Steven Thomas | 050b2c8 | 2017-03-06 11:45:16 -0800 | [diff] [blame] | 920 | std::atomic<bool> mVrFlingerRequestsDisplay; |
| 921 | static bool useVrFlinger; |
Steven Thomas | b02664d | 2017-07-26 18:48:28 -0700 | [diff] [blame] | 922 | std::thread::id mMainThreadId; |
Romain Guy | 0147a17 | 2017-06-01 13:53:56 -0700 | [diff] [blame] | 923 | |
Chia-I Wu | e0ec431 | 2018-07-03 01:17:18 +0800 | [diff] [blame] | 924 | DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::ENHANCED; |
Chia-I Wu | d49d669 | 2018-06-27 07:17:41 +0800 | [diff] [blame] | 925 | // Applied on Display P3 layers when the render intent is non-colorimetric. |
| 926 | mat4 mEnhancedSaturationMatrix; |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 927 | |
Lloyd Pique | 12eb423 | 2018-01-17 11:54:43 -0800 | [diff] [blame] | 928 | using CreateBufferQueueFunction = |
| 929 | std::function<void(sp<IGraphicBufferProducer>* /* outProducer */, |
| 930 | sp<IGraphicBufferConsumer>* /* outConsumer */, |
| 931 | bool /* consumerIsSurfaceFlinger */)>; |
| 932 | CreateBufferQueueFunction mCreateBufferQueue; |
| 933 | |
Lloyd Pique | 99d3da5 | 2018-01-22 17:48:03 -0800 | [diff] [blame] | 934 | using CreateNativeWindowSurfaceFunction = |
| 935 | std::function<std::unique_ptr<NativeWindowSurface>(const sp<IGraphicBufferProducer>&)>; |
| 936 | CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface; |
| 937 | |
David Sodman | 105b7dc | 2017-11-04 20:28:14 -0700 | [diff] [blame] | 938 | SurfaceFlingerBE mBE; |
Ana Krulec | 98b5b24 | 2018-08-10 15:03:23 -0700 | [diff] [blame] | 939 | |
| 940 | bool mUseScheduler = false; |
| 941 | std::unique_ptr<Scheduler> mScheduler; |
| 942 | sp<Scheduler::ConnectionHandle> mAppConnectionHandle; |
| 943 | sp<Scheduler::ConnectionHandle> mSfConnectionHandle; |
Romain Guy | 0147a17 | 2017-06-01 13:53:56 -0700 | [diff] [blame] | 944 | }; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 945 | }; // namespace android |
| 946 | |
| 947 | #endif // ANDROID_SURFACE_FLINGER_H |