blob: 9c37223f8c5f269e8b219929484c700b113b5eb5 [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
20#include <stdint.h>
21#include <sys/types.h>
22
Mathias Agopian921e6ac2012-07-23 23:11:29 -070023#include <EGL/egl.h>
Mathias Agopian3f844832013-08-07 21:24:32 -070024
25/*
26 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
27 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070028
Glenn Kasten99ed2242011-12-15 09:51:17 -080029#include <cutils/compiler.h>
30
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080031#include <utils/Atomic.h>
32#include <utils/Errors.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070033#include <utils/KeyedVector.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070034#include <utils/RefBase.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070035#include <utils/SortedVector.h>
36#include <utils/threads.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080037
Mathias Agopian99b49842011-06-27 16:05:52 -070038#include <binder/IMemory.h>
Mathias Agopian375f5632009-06-15 18:24:59 -070039
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080040#include <ui/PixelFormat.h>
Alan Viverette9c5a3332013-09-12 20:04:35 -070041#include <ui/mat4.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070042
Mathias Agopian90ac7992012-02-25 18:48:35 -080043#include <gui/ISurfaceComposer.h>
44#include <gui/ISurfaceComposerClient.h>
Dan Stozae77c7662016-05-13 11:37:28 -070045#include <gui/OccupancyTracker.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080046
Mathias Agopian86303202012-07-24 22:46:10 -070047#include <hardware/hwcomposer_defs.h>
48
Michael Wright28f24d02016-07-12 13:30:53 -070049#include <system/graphics.h>
50
Mathias Agopian921e6ac2012-07-23 23:11:29 -070051#include <private/gui/LayerState.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080052
Mathias Agopian921e6ac2012-07-23 23:11:29 -070053#include "Barrier.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070054#include "DisplayDevice.h"
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070055#include "DispSync.h"
Pablo Ceballos40845df2016-01-25 17:41:15 -080056#include "FenceTracker.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080057#include "FrameTracker.h"
58#include "MessageQueue.h"
Irvel468051e2016-06-13 16:44:44 -070059#include "SurfaceInterceptor.h"
Mathias Agopianf1d8e872009-04-20 19:39:12 -070060
Mathias Agopian86303202012-07-24 22:46:10 -070061#include "DisplayHardware/HWComposer.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -070062#include "Effects/Daltonizer.h"
Mathias Agopian86303202012-07-24 22:46:10 -070063
Dan Stozae77c7662016-05-13 11:37:28 -070064#include <map>
65#include <string>
66
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080067namespace android {
68
69// ---------------------------------------------------------------------------
70
71class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080072class DisplayEventConnection;
73class EventThread;
Mathias Agopianf33e4b62012-09-20 16:54:14 -070074class IGraphicBufferAlloc;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080075class Layer;
Mathias Agopianb7e930d2010-06-01 15:12:58 -070076class LayerDim;
Mathias Agopiane3c697f2013-02-14 17:11:02 -080077class Surface;
Mathias Agopian875d8e12013-06-07 15:35:48 -070078class RenderEngine;
Jamie Gennisd1700752013-10-14 12:22:52 -070079class EventControlThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070080class VSyncSource;
81class InjectVSyncSource;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080082
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080083// ---------------------------------------------------------------------------
84
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080085enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -070086 eTransactionNeeded = 0x01,
87 eTraversalNeeded = 0x02,
88 eDisplayTransactionNeeded = 0x04,
89 eTransactionMask = 0x07
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080090};
91
Mathias Agopian4f4f0942013-08-19 17:26:18 -070092class SurfaceFlinger : public BnSurfaceComposer,
Mathias Agopian921e6ac2012-07-23 23:11:29 -070093 private IBinder::DeathRecipient,
Mathias Agopian86303202012-07-24 22:46:10 -070094 private HWComposer::EventHandler
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080095{
96public:
Mathias Agopianb6df7d02013-05-09 14:53:35 -070097 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -070098 return "SurfaceFlinger";
99 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800100
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700101 SurfaceFlinger() ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800102
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700103 // must be called before clients can connect
104 void init() ANDROID_API;
105
106 // starts SurfaceFlinger main loop in the current thread
107 void run() ANDROID_API;
108
Mathias Agopian86303202012-07-24 22:46:10 -0700109 enum {
110 EVENT_VSYNC = HWC_EVENT_VSYNC
111 };
112
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700113 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700114 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 -0800115
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700116 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700117 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 -0800118
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700119 // force full composition on all displays
120 void repaintEverything();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800121
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700122 // returns the default Display
Mathias Agopian42977342012-08-05 00:40:46 -0700123 sp<const DisplayDevice> getDefaultDisplayDevice() const {
Jesse Hall692c7232012-11-08 15:41:56 -0800124 return getDisplayDevice(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700125 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700126
Mathias Agopian86303202012-07-24 22:46:10 -0700127 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700128 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700129
Mathias Agopian86303202012-07-24 22:46:10 -0700130 // enable/disable h/w composer event
131 // TODO: this should be made accessible only to EventThread
Dan Stoza9e56aa02015-11-02 13:00:03 -0800132 void setVsyncEnabled(int disp, int enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700133
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700134 // called on the main thread by MessageQueue when an internal message
135 // is received
136 // TODO: this should be made accessible only to MessageQueue
137 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700138
Mathias Agopiancb558572012-10-04 15:58:54 -0700139 // for debugging only
140 // TODO: this should be made accessible only to HWComposer
Jesse Hall48bc05b2013-03-21 14:06:52 -0700141 const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id);
Mathias Agopiancb558572012-10-04 15:58:54 -0700142
Mathias Agopian875d8e12013-06-07 15:35:48 -0700143 RenderEngine& getRenderEngine() const {
144 return *mRenderEngine;
Jesse Hall29c3f352013-05-21 15:36:55 -0700145 }
146
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700147private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700148 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800149 friend class DisplayEventConnection;
Irvel468051e2016-06-13 16:44:44 -0700150 friend class EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800151 friend class Layer;
Dan Stozab9b08832014-03-13 11:55:57 -0700152 friend class MonitoredProducer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800153
Jamie Gennis6547ff42013-07-16 20:12:42 -0700154 // This value is specified in number of frames. Log frame stats at most
155 // every half hour.
156 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
157
Dan Stoza7d89d062015-04-30 13:29:25 -0700158 static const size_t MAX_LAYERS = 4096;
159
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700160 // We're reference counted, never destroy SurfaceFlinger directly
161 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800162
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700163 /* ------------------------------------------------------------------------
164 * Internal data structures
165 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800166
Mathias Agopian13127d82013-03-05 17:47:11 -0800167 class LayerVector : public SortedVector< sp<Layer> > {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800168 public:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700169 LayerVector();
170 LayerVector(const LayerVector& rhs);
171 virtual int do_compare(const void* lhs, const void* rhs) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800172 };
173
Mathias Agopian92a979a2012-08-02 18:32:23 -0700174 struct State {
175 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700176 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800177 };
178
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700179 /* ------------------------------------------------------------------------
180 * IBinder interface
181 */
182 virtual status_t onTransact(uint32_t code, const Parcel& data,
183 Parcel* reply, uint32_t flags);
184 virtual status_t dump(int fd, const Vector<String16>& args);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800185
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700186 /* ------------------------------------------------------------------------
187 * ISurfaceComposer interface
188 */
189 virtual sp<ISurfaceComposerClient> createConnection();
190 virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc();
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700191 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
Jesse Hall6c913be2013-08-08 12:15:49 -0700192 virtual void destroyDisplay(const sp<IBinder>& display);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700193 virtual sp<IBinder> getBuiltInDisplay(int32_t id);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700194 virtual void setTransactionState(const Vector<ComposerState>& state,
Mathias Agopian8b33f032012-07-24 20:43:54 -0700195 const Vector<DisplayState>& displays, uint32_t flags);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700196 virtual void bootFinished();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700197 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800198 const sp<IGraphicBufferProducer>& bufferProducer) const;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700199 virtual sp<IDisplayEventConnection> createDisplayEventConnection();
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800200 virtual status_t captureScreen(const sp<IBinder>& display,
201 const sp<IGraphicBufferProducer>& producer,
Dan Stozac1879002014-05-22 15:59:05 -0700202 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Dan Stozac7014012014-02-14 15:03:43 -0800203 uint32_t minLayerZ, uint32_t maxLayerZ,
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700204 bool useIdentityTransform, ISurfaceComposer::Rotation rotation);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700205 virtual status_t getDisplayStats(const sp<IBinder>& display,
206 DisplayStatInfo* stats);
Dan Stoza7f7da322014-05-02 15:26:25 -0700207 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
208 Vector<DisplayInfo>* configs);
209 virtual int getActiveConfig(const sp<IBinder>& display);
Michael Wright28f24d02016-07-12 13:30:53 -0700210 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
211 Vector<android_color_mode_t>* configs);
212 virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
213 virtual status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700214 virtual void setPowerMode(const sp<IBinder>& display, int mode);
Dan Stoza7f7da322014-05-02 15:26:25 -0700215 virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
Svetoslavd85084b2014-03-20 10:28:31 -0700216 virtual status_t clearAnimationFrameStats();
217 virtual status_t getAnimationFrameStats(FrameStats* outStats) const;
Dan Stozac4f471e2016-03-24 09:31:08 -0700218 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
219 HdrCapabilities* outCapabilities) const;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700220 virtual status_t enableVSyncInjections(bool enable);
221 virtual status_t injectVSync(nsecs_t when);
222
Mathias Agopian1b031492012-06-20 17:51:20 -0700223
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700224 /* ------------------------------------------------------------------------
225 * DeathRecipient interface
226 */
227 virtual void binderDied(const wp<IBinder>& who);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800228
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700229 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700230 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700231 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700232 virtual void onFirstRef();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800233
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700234 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700235 * HWComposer::EventHandler interface
236 */
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700237 virtual void onVSyncReceived(int type, nsecs_t timestamp);
Mathias Agopian148994e2012-09-19 17:31:36 -0700238 virtual void onHotplugReceived(int disp, bool connected);
Mathias Agopian86303202012-07-24 22:46:10 -0700239
240 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700241 * Message handling
242 */
243 void waitForEvent();
244 void signalTransaction();
245 void signalLayerUpdate();
246 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800247
Andy McFadden13a082e2012-08-24 10:16:42 -0700248 // called on the main thread in response to initializeDisplays()
249 void onInitializeDisplays();
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700250 // called on the main thread in response to setActiveConfig()
251 void setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700252 // called on the main thread in response to setPowerMode()
253 void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800254
Michael Wright28f24d02016-07-12 13:30:53 -0700255 // Called on the main thread in response to setActiveColorMode()
256 void setActiveColorModeInternal(const sp<DisplayDevice>& hw, android_color_mode_t colorMode);
257
Dan Stoza6b9454d2014-11-07 16:00:59 -0800258 // Returns whether the transaction actually modified any state
259 bool handleMessageTransaction();
260
261 // Returns whether a new buffer has been latched (see handlePageFlip())
262 bool handleMessageInvalidate();
263
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700264 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700265
Mathias Agopian87baae12012-07-31 12:38:26 -0700266 void handleTransaction(uint32_t transactionFlags);
267 void handleTransactionLocked(uint32_t transactionFlags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800268
Riley Andrews03414a12014-07-01 14:22:59 -0700269 void updateCursorAsync();
270
Dan Stoza6b9454d2014-11-07 16:00:59 -0800271 /* handlePageFlip - latch a new buffer if available and compute the dirty
272 * region. Returns whether a new buffer has been latched, i.e., whether it
273 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700274 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800275 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800276
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700277 /* ------------------------------------------------------------------------
278 * Transactions
279 */
280 uint32_t getTransactionFlags(uint32_t flags);
281 uint32_t peekTransactionFlags(uint32_t flags);
282 uint32_t setTransactionFlags(uint32_t flags);
283 void commitTransaction();
Mathias Agopian3f844832013-08-07 21:24:32 -0700284 uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700285 uint32_t setDisplayStateLocked(const DisplayState& s);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800286
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700287 /* ------------------------------------------------------------------------
288 * Layer management
289 */
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700290 status_t createLayer(const String8& name, const sp<Client>& client,
291 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
292 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800293
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700294 status_t createNormalLayer(const sp<Client>& client, const String8& name,
295 uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
296 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
297 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800298
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700299 status_t createDimLayer(const sp<Client>& client, const String8& name,
300 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
301 sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700302
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700303 // called in response to the window-manager calling
304 // ISurfaceComposerClient::destroySurface()
Mathias Agopianac9fa422013-02-11 16:40:36 -0800305 status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle);
Mathias Agopianb9494d52012-04-18 02:28:45 -0700306
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700307 // called when all clients have released all their references to
308 // this layer meaning it is entirely safe to destroy all
309 // resources associated to this layer.
Mathias Agopian13127d82013-03-05 17:47:11 -0800310 status_t onLayerDestroyed(const wp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700311
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700312 // remove a layer from SurfaceFlinger immediately
Dan Stoza22851c32016-08-09 13:21:03 -0700313 status_t removeLayer(const wp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700314
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700315 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700316 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700317 const sp<IBinder>& handle,
318 const sp<IGraphicBufferProducer>& gbc,
319 const sp<Layer>& lbc);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700320
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700321 /* ------------------------------------------------------------------------
322 * Boot animation, on/off animations and screen capture
323 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700324
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700325 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700326
Mathias Agopian180f10d2013-04-10 22:55:41 -0700327 void renderScreenImplLocked(
328 const sp<const DisplayDevice>& hw,
Dan Stozac1879002014-05-22 15:59:05 -0700329 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Mathias Agopian180f10d2013-04-10 22:55:41 -0700330 uint32_t minLayerZ, uint32_t maxLayerZ,
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700331 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation);
Mathias Agopian180f10d2013-04-10 22:55:41 -0700332
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800333 status_t captureScreenImplLocked(
334 const sp<const DisplayDevice>& hw,
Mathias Agopianabe815d2013-03-19 22:22:21 -0700335 const sp<IGraphicBufferProducer>& producer,
Dan Stozac1879002014-05-22 15:59:05 -0700336 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Dan Stozac7014012014-02-14 15:03:43 -0800337 uint32_t minLayerZ, uint32_t maxLayerZ,
Pablo Ceballosb5b35632016-02-23 11:18:51 -0800338 bool useIdentityTransform, Transform::orientation_flags rotation,
339 bool isLocalScreenshot);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700340
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700341 /* ------------------------------------------------------------------------
342 * EGL
343 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700344 size_t getMaxTextureSize() const;
345 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700346
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700347 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700348 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700349 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700350 // called when starting, or restarting after system_server death
351 void initializeDisplays();
352
Jesse Hall692c7232012-11-08 15:41:56 -0800353 // Create an IBinder for a builtin display and add it to current state
354 void createBuiltinDisplayLocked(DisplayDevice::DisplayType type);
355
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700356 // NOTE: can only be called from the main thread or with mStateLock held
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700357 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
Mathias Agopian92a979a2012-08-02 18:32:23 -0700358 return mDisplays.valueFor(dpy);
359 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700360
361 // NOTE: can only be called from the main thread or with mStateLock held
362 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
Mathias Agopian42977342012-08-05 00:40:46 -0700363 return mDisplays.valueFor(dpy);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700364 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700365
Michael Wright28f24d02016-07-12 13:30:53 -0700366 int32_t getDisplayType(const sp<IBinder>& display) {
367 if (!display.get()) return NAME_NOT_FOUND;
368 for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
369 if (display == mBuiltinDisplays[i]) {
370 return i;
371 }
372 }
373 return NAME_NOT_FOUND;
374 }
375
Mathias Agopian87baae12012-07-31 12:38:26 -0700376 // mark a region of a layer stack dirty. this updates the dirty
377 // region of all screens presenting this layer stack.
378 void invalidateLayerStack(uint32_t layerStack, const Region& dirty);
379
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700380 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700381 * H/W composer
382 */
383
384 HWComposer& getHwComposer() const { return *mHwc; }
385
Mathias Agopian888c8222012-08-04 21:10:38 -0700386 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700387 * Compositing
388 */
389 void invalidateHwcGeometry();
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700390 static void computeVisibleRegions(
391 const LayerVector& currentLayers, uint32_t layerStack,
Mathias Agopian87baae12012-07-31 12:38:26 -0700392 Region& dirtyRegion, Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700393
394 void preComposition();
Pablo Ceballos40845df2016-01-25 17:41:15 -0800395 void postComposition(nsecs_t refreshStartTime);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700396 void rebuildLayerStacks();
397 void setUpHWComposer();
398 void doComposition();
399 void doDebugFlashRegions();
Mathias Agopian3f844832013-08-07 21:24:32 -0700400 void doDisplayComposition(const sp<const DisplayDevice>& hw, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700401
402 // compose surfaces for display hw. this fails if using GL and the surface
403 // has been destroyed and is no longer valid.
404 bool doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700405
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700406 void postFramebuffer();
Mathias Agopian3f844832013-08-07 21:24:32 -0700407 void drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700408
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700409 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700410 * Display management
411 */
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700412
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700413 /* ------------------------------------------------------------------------
414 * VSync
415 */
416 void enableHardwareVsync();
Dan Stoza67264e92016-04-14 16:11:48 +0000417 void resyncToHardwareVsync(bool makeAvailable);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000418 void disableHardwareVsync(bool makeUnavailable);
419public:
420 void resyncWithRateLimit();
421private:
Jamie Gennis0bceb842012-08-23 20:19:38 -0700422
423 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700424 * Debugging & dumpsys
425 */
Mathias Agopian3f844832013-08-07 21:24:32 -0700426 void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
427 void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
428 void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
429 void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
Keun young Park63f165f2012-08-31 10:53:36 -0700430 bool startDdmConnection();
Andy McFadden4803b742012-09-24 19:07:20 -0700431 static void appendSfConfigString(String8& result);
Mathias Agopiand5556842013-09-19 17:08:37 -0700432 void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
Mathias Agopianfee2b462013-07-03 12:34:01 -0700433 const sp<const DisplayDevice>& hw,
434 uint32_t minLayerZ, uint32_t maxLayerZ);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800435
Jamie Gennis6547ff42013-07-16 20:12:42 -0700436 void logFrameStats();
437
Dan Stozab90cf072015-03-05 11:05:59 -0800438 void dumpStaticScreenStats(String8& result) const;
439
Dan Stozae77c7662016-05-13 11:37:28 -0700440 void recordBufferingStats(const char* layerName,
441 std::vector<OccupancyTracker::Segment>&& history);
442 void dumpBufferingStats(String8& result) const;
443
Pablo Ceballosce796e72016-02-04 19:10:51 -0800444 bool getFrameTimestamps(const Layer& layer, uint64_t frameNumber,
445 FrameTimestamps* outTimestamps);
446
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700447 /* ------------------------------------------------------------------------
448 * Attributes
449 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800450
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700451 // access must be protected by mStateLock
452 mutable Mutex mStateLock;
453 State mCurrentState;
454 volatile int32_t mTransactionFlags;
455 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700456 bool mTransactionPending;
457 bool mAnimTransactionPending;
Mathias Agopian13127d82013-03-05 17:47:11 -0800458 Vector< sp<Layer> > mLayersPendingRemoval;
Mathias Agopian67106042013-03-14 19:18:13 -0700459 SortedVector< wp<IBinder> > mGraphicBufferProducerList;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800460
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700461 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700462 bool mLayersRemoved;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700463
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700464 // access must be protected by mInvalidateLock
Mathias Agopian87baae12012-07-31 12:38:26 -0700465 volatile int32_t mRepaintEverything;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700466
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700467 // constant members (no synchronization needed for access)
Mathias Agopian86303202012-07-24 22:46:10 -0700468 HWComposer* mHwc;
Mathias Agopian875d8e12013-06-07 15:35:48 -0700469 RenderEngine* mRenderEngine;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700470 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700471 bool mGpuToCpuSupported;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700472 sp<EventThread> mEventThread;
Jamie Gennis0a645cc2013-10-14 20:52:46 -0700473 sp<EventThread> mSFEventThread;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700474 sp<EventThread> mInjectorEventThread;
475 sp<InjectVSyncSource> mVSyncInjector;
Jamie Gennisd1700752013-10-14 12:22:52 -0700476 sp<EventControlThread> mEventControlThread;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700477 EGLContext mEGLContext;
Jesse Hall34a09ba2012-07-29 22:35:34 -0700478 EGLDisplay mEGLDisplay;
Jesse Hall9e663de2013-08-16 14:28:37 -0700479 sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
Mathias Agopian3094df32012-06-18 18:06:45 -0700480
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700481 // Can only accessed from the main thread, these members
482 // don't need synchronization
483 State mDrawingState;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700484 bool mVisibleRegionsDirty;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800485 bool mGeometryInvalid;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800486 bool mAnimCompositionPending;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800487 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700488 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
489 bool mHadClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700490
491 // this may only be written from the main thread with mStateLock held
492 // it may be read from other threads with mStateLock held
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700493 DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700494
495 // don't use a lock for these, we don't care
496 int mDebugRegion;
497 int mDebugDDMS;
498 int mDebugDisableHWC;
499 int mDebugDisableTransformHint;
500 volatile nsecs_t mDebugInSwapBuffers;
501 nsecs_t mLastSwapBufferTime;
502 volatile nsecs_t mDebugInTransaction;
503 nsecs_t mLastTransactionTime;
504 bool mBootFinished;
Dan Stozaee44edd2015-03-23 15:50:23 -0700505 bool mForceFullDamage;
Pablo Ceballos40845df2016-01-25 17:41:15 -0800506 FenceTracker mFenceTracker;
Dan Stozac5da2712016-07-20 15:38:12 -0700507 bool mPropagateBackpressure = true;
Irvel468051e2016-06-13 16:44:44 -0700508 SurfaceInterceptor mInterceptor;
Dan Stoza8cf150a2016-08-02 10:27:31 -0700509 bool mUseHwcVirtualDisplays = true;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700510
511 // these are thread safe
512 mutable MessageQueue mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800513 FrameTracker mAnimFrameTracker;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700514 DispSync mPrimaryDispSync;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700515
516 // protected by mDestroyedLayerLock;
517 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -0800518 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700519
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700520 // protected by mHWVsyncLock
521 Mutex mHWVsyncLock;
522 bool mPrimaryHWVsyncEnabled;
Jesse Hall948fe0c2013-10-14 12:56:09 -0700523 bool mHWVsyncAvailable;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700524
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700525 /* ------------------------------------------------------------------------
526 * Feature prototyping
527 */
528
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700529 bool mInjectVSyncs;
530
Mathias Agopianff2ed702013-09-01 21:36:12 -0700531 Daltonizer mDaltonizer;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700532
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700533 mat4 mPreviousColorMatrix;
Alan Viverette9c5a3332013-09-12 20:04:35 -0700534 mat4 mColorMatrix;
535 bool mHasColorMatrix;
Dan Stozab90cf072015-03-05 11:05:59 -0800536
537 // Static screen stats
538 bool mHasPoweredOff;
539 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
540 nsecs_t mFrameBuckets[NUM_BUCKETS];
541 nsecs_t mTotalTime;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000542 std::atomic<nsecs_t> mLastSwapTime;
Dan Stozae77c7662016-05-13 11:37:28 -0700543
544 // Double- vs. triple-buffering stats
545 struct BufferingStats {
546 BufferingStats()
547 : numSegments(0),
548 totalTime(0),
549 twoBufferTime(0),
550 doubleBufferedTime(0),
551 tripleBufferedTime(0) {}
552
553 size_t numSegments;
554 nsecs_t totalTime;
555
556 // "Two buffer" means that a third buffer was never used, whereas
557 // "double-buffered" means that on average the segment only used two
558 // buffers (though it may have used a third for some part of the
559 // segment)
560 nsecs_t twoBufferTime;
561 nsecs_t doubleBufferedTime;
562 nsecs_t tripleBufferedTime;
563 };
564 mutable Mutex mBufferingStatsMutex;
565 std::unordered_map<std::string, BufferingStats> mBufferingStats;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800566};
567
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800568}; // namespace android
569
570#endif // ANDROID_SURFACE_FLINGER_H