services/surfaceflinger/SurfaceFlinger.h

   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
  20 #include <memory>
  21 #include <stdint.h>
  22 #include <sys/types.h>
  23
  24 #include <EGL/egl.h>
  25
  26 /*
  27  * NOTE: Make sure this file doesn't include  anything from <gl/ > or <gl2/ >
  28  */
  29
  30 #include <cutils/compiler.h>
  31
  32 #include <utils/Atomic.h>
  33 #include <utils/Errors.h>
  34 #include <utils/KeyedVector.h>
  35 #include <utils/RefBase.h>
  36 #include <utils/SortedVector.h>
  37 #include <utils/threads.h>
  38
  39 #include <ui/FenceTime.h>
  40 #include <ui/PixelFormat.h>
  41 #include <math/mat4.h>
  42
  43 #include <gui/FrameTimestamps.h>
  44 #include <gui/ISurfaceComposer.h>
  45 #include <gui/ISurfaceComposerClient.h>
  46 #include <gui/OccupancyTracker.h>
  47
  48 #include <hardware/hwcomposer_defs.h>
  49
  50 #include <system/graphics.h>
  51
  52 #include <private/gui/LayerState.h>
  53
  54 #include "Barrier.h"
  55 #include "DisplayDevice.h"
  56 #include "DispSync.h"
  57 #include "FrameTracker.h"
  58 #include "LayerVector.h"
  59 #include "MessageQueue.h"
  60 #include "SurfaceInterceptor.h"
  61 #include "StartPropertySetThread.h"
  62
  63 #include "DisplayHardware/HWComposer.h"
  64 #include "Effects/Daltonizer.h"
  65
  66 #include <map>
  67 #include <mutex>
  68 #include <queue>
  69 #include <string>
  70 #include <utility>
  71
  72 namespace android {
  73
  74 // ---------------------------------------------------------------------------
  75
  76 class Client;
  77 class DisplayEventConnection;
  78 class EventThread;
  79 class Layer;
  80 class LayerDim;
  81 class Surface;
  82 class RenderEngine;
  83 class EventControlThread;
  84 class VSyncSource;
  85 class InjectVSyncSource;
  86
  87 namespace dvr {
  88 class VrFlinger;
  89 } // namespace dvr
  90
  91 // ---------------------------------------------------------------------------
  92
  93 enum {
  94     eTransactionNeeded        = 0x01,
  95     eTraversalNeeded          = 0x02,
  96     eDisplayTransactionNeeded = 0x04,
  97     eTransactionMask          = 0x07
  98 };
  99
 100 class SurfaceFlinger : public BnSurfaceComposer,
 101                        private IBinder::DeathRecipient,
 102                        private HWComposer::EventHandler
 103 {
 104 public:
 105
 106     // This is the phase offset in nanoseconds of the software vsync event
 107     // relative to the vsync event reported by HWComposer.  The software vsync
 108     // event is when SurfaceFlinger and Choreographer-based applications run each
 109     // frame.
 110     //
 111     // This phase offset allows adjustment of the minimum latency from application
 112     // wake-up time (by Choreographer) to the time at which the resulting window
 113     // image is displayed.  This value may be either positive (after the HW vsync)
 114     // or negative (before the HW vsync). Setting it to 0 will result in a lower
 115     // latency bound of two vsync periods because the app and SurfaceFlinger
 116     // will run just after the HW vsync.  Setting it to a positive number will
 117     // result in the minimum latency being:
 118     //
 119     //     (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
 120     //
 121     // Note that reducing this latency makes it more likely for the applications
 122     // to not have their window content image ready in time.  When this happens
 123     // the latency will end up being an additional vsync period, and animations
 124     // will hiccup.  Therefore, this latency should be tuned somewhat
 125     // conservatively (or at least with awareness of the trade-off being made).
 126     static int64_t vsyncPhaseOffsetNs;
 127     static int64_t sfVsyncPhaseOffsetNs;
 128
 129     // If fences from sync Framework are supported.
 130     static bool hasSyncFramework;
 131
 132     // Instruct the Render Engine to use EGL_IMG_context_priority is available.
 133     static bool useContextPriority;
 134
 135     // The offset in nanoseconds to use when DispSync timestamps present fence
 136     // signaling time.
 137     static int64_t dispSyncPresentTimeOffset;
 138
 139     // Some hardware can do RGB->YUV conversion more efficiently in hardware
 140     // controlled by HWC than in hardware controlled by the video encoder.
 141     // This instruct VirtualDisplaySurface to use HWC for such conversion on
 142     // GL composition.
 143     static bool useHwcForRgbToYuv;
 144
 145     // Maximum dimension supported by HWC for virtual display.
 146     // Equal to min(max_height, max_width).
 147     static uint64_t maxVirtualDisplaySize;
 148
 149     // Controls the number of buffers SurfaceFlinger will allocate for use in
 150     // FramebufferSurface
 151     static int64_t maxFrameBufferAcquiredBuffers;
 152
 153     // Indicate if platform supports color management on its
 154     // wide-color display. This is typically found on devices
 155     // with wide gamut (e.g. Display-P3) display.
 156     // This also allows devices with wide-color displays that don't
 157     // want to support color management to disable color management.
 158     static bool hasWideColorDisplay;
 159
 160     static char const* getServiceName() ANDROID_API {
 161         return "SurfaceFlinger";
 162     }
 163
 164     SurfaceFlinger() ANDROID_API;
 165
 166     // must be called before clients can connect
 167     void init() ANDROID_API;
 168
 169     // starts SurfaceFlinger main loop in the current thread
 170     void run() ANDROID_API;
 171
 172     enum {
 173         EVENT_VSYNC = HWC_EVENT_VSYNC
 174     };
 175
 176     // post an asynchronous message to the main thread
 177     status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);
 178
 179     // post a synchronous message to the main thread
 180     status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);
 181
 182     // force full composition on all displays
 183     void repaintEverything();
 184
 185     // returns the default Display
 186     sp<const DisplayDevice> getDefaultDisplayDevice() const {
 187         Mutex::Autolock _l(mStateLock);
 188         return getDefaultDisplayDeviceLocked();
 189     }
 190
 191     // utility function to delete a texture on the main thread
 192     void deleteTextureAsync(uint32_t texture);
 193
 194     // enable/disable h/w composer event
 195     // TODO: this should be made accessible only to EventThread
 196 #ifdef USE_HWC2
 197     void setVsyncEnabled(int disp, int enabled);
 198 #else
 199     void eventControl(int disp, int event, int enabled);
 200 #endif
 201
 202     // called on the main thread by MessageQueue when an internal message
 203     // is received
 204     // TODO: this should be made accessible only to MessageQueue
 205     void onMessageReceived(int32_t what);
 206
 207     // for debugging only
 208     // TODO: this should be made accessible only to HWComposer
 209     const Vector< sp<Layer> >& getLayerSortedByZForHwcDisplay(int id);
 210
 211     RenderEngine& getRenderEngine() const {
 212         return *mRenderEngine;
 213     }
 214
 215     bool authenticateSurfaceTextureLocked(
 216         const sp<IGraphicBufferProducer>& bufferProducer) const;
 217
 218 private:
 219     friend class Client;
 220     friend class DisplayEventConnection;
 221     friend class EventThread;
 222     friend class Layer;
 223     friend class MonitoredProducer;
 224
 225     // This value is specified in number of frames.  Log frame stats at most
 226     // every half hour.
 227     enum { LOG_FRAME_STATS_PERIOD =  30*60*60 };
 228
 229     static const size_t MAX_LAYERS = 4096;
 230
 231     // We're reference counted, never destroy SurfaceFlinger directly
 232     virtual ~SurfaceFlinger();
 233
 234     /* ------------------------------------------------------------------------
 235      * Internal data structures
 236      */
 237
 238     class State {
 239     public:
 240         explicit State(LayerVector::StateSet set) : stateSet(set) {}
 241         State& operator=(const State& other) {
 242             // We explicitly don't copy stateSet so that, e.g., mDrawingState
 243             // always uses the Drawing StateSet.
 244             layersSortedByZ = other.layersSortedByZ;
 245             displays = other.displays;
 246             return *this;
 247         }
 248
 249         const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
 250         LayerVector layersSortedByZ;
 251         DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
 252
 253         void traverseInZOrder(const LayerVector::Visitor& visitor) const;
 254         void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
 255     };
 256
 257     /* ------------------------------------------------------------------------
 258      * IBinder interface
 259      */
 260     virtual status_t onTransact(uint32_t code, const Parcel& data,
 261         Parcel* reply, uint32_t flags);
 262     virtual status_t dump(int fd, const Vector<String16>& args);
 263
 264     /* ------------------------------------------------------------------------
 265      * ISurfaceComposer interface
 266      */
 267     virtual sp<ISurfaceComposerClient> createConnection();
 268     virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
 269     virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
 270     virtual void destroyDisplay(const sp<IBinder>& display);
 271     virtual sp<IBinder> getBuiltInDisplay(int32_t id);
 272     virtual void setTransactionState(const Vector<ComposerState>& state,
 273             const Vector<DisplayState>& displays, uint32_t flags);
 274     virtual void bootFinished();
 275     virtual bool authenticateSurfaceTexture(
 276         const sp<IGraphicBufferProducer>& bufferProducer) const;
 277     virtual status_t getSupportedFrameTimestamps(
 278             std::vector<FrameEvent>* outSupported) const;
 279     virtual sp<IDisplayEventConnection> createDisplayEventConnection(
 280             ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp);
 281     virtual status_t captureScreen(const sp<IBinder>& display,
 282             const sp<IGraphicBufferProducer>& producer,
 283             Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
 284             int32_t minLayerZ, int32_t maxLayerZ,
 285             bool useIdentityTransform, ISurfaceComposer::Rotation rotation);
 286     virtual status_t getDisplayStats(const sp<IBinder>& display,
 287             DisplayStatInfo* stats);
 288     virtual status_t getDisplayConfigs(const sp<IBinder>& display,
 289             Vector<DisplayInfo>* configs);
 290     virtual int getActiveConfig(const sp<IBinder>& display);
 291     virtual status_t getDisplayColorModes(const sp<IBinder>& display,
 292             Vector<android_color_mode_t>* configs);
 293     virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
 294     virtual status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
 295     virtual void setPowerMode(const sp<IBinder>& display, int mode);
 296     virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
 297     virtual status_t clearAnimationFrameStats();
 298     virtual status_t getAnimationFrameStats(FrameStats* outStats) const;
 299     virtual status_t getHdrCapabilities(const sp<IBinder>& display,
 300             HdrCapabilities* outCapabilities) const;
 301     virtual status_t enableVSyncInjections(bool enable);
 302     virtual status_t injectVSync(nsecs_t when);
 303
 304
 305     /* ------------------------------------------------------------------------
 306      * DeathRecipient interface
 307      */
 308     virtual void binderDied(const wp<IBinder>& who);
 309
 310     /* ------------------------------------------------------------------------
 311      * RefBase interface
 312      */
 313     virtual void onFirstRef();
 314
 315     /* ------------------------------------------------------------------------
 316      * HWComposer::EventHandler interface
 317      */
 318     virtual void onVSyncReceived(HWComposer* composer, int type, nsecs_t timestamp);
 319     virtual void onHotplugReceived(HWComposer* composer, int disp, bool connected);
 320     virtual void onInvalidateReceived(HWComposer* composer);
 321
 322     /* ------------------------------------------------------------------------
 323      * Message handling
 324      */
 325     void waitForEvent();
 326     void signalTransaction();
 327     void signalLayerUpdate();
 328     void signalRefresh();
 329
 330     // called on the main thread in response to initializeDisplays()
 331     void onInitializeDisplays();
 332     // called on the main thread in response to setActiveConfig()
 333     void setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode);
 334     // called on the main thread in response to setPowerMode()
 335     void setPowerModeInternal(const sp<DisplayDevice>& hw, int mode);
 336
 337     // Called on the main thread in response to setActiveColorMode()
 338     void setActiveColorModeInternal(const sp<DisplayDevice>& hw, android_color_mode_t colorMode);
 339
 340     // Returns whether the transaction actually modified any state
 341     bool handleMessageTransaction();
 342
 343     // Returns whether a new buffer has been latched (see handlePageFlip())
 344     bool handleMessageInvalidate();
 345
 346     void handleMessageRefresh();
 347
 348     void handleTransaction(uint32_t transactionFlags);
 349     void handleTransactionLocked(uint32_t transactionFlags);
 350
 351     void updateCursorAsync();
 352
 353     /* handlePageFlip - latch a new buffer if available and compute the dirty
 354      * region. Returns whether a new buffer has been latched, i.e., whether it
 355      * is necessary to perform a refresh during this vsync.
 356      */
 357     bool handlePageFlip();
 358
 359     /* ------------------------------------------------------------------------
 360      * Transactions
 361      */
 362     uint32_t getTransactionFlags(uint32_t flags);
 363     uint32_t peekTransactionFlags();
 364     uint32_t setTransactionFlags(uint32_t flags);
 365     void commitTransaction();
 366     uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
 367     uint32_t setDisplayStateLocked(const DisplayState& s);
 368
 369     /* ------------------------------------------------------------------------
 370      * Layer management
 371      */
 372     status_t createLayer(const String8& name, const sp<Client>& client,
 373             uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
 374             uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
 375             sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
 376
 377     status_t createNormalLayer(const sp<Client>& client, const String8& name,
 378             uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
 379             sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
 380             sp<Layer>* outLayer);
 381
 382     status_t createDimLayer(const sp<Client>& client, const String8& name,
 383             uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
 384             sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
 385
 386     String8 getUniqueLayerName(const String8& name);
 387
 388     // called in response to the window-manager calling
 389     // ISurfaceComposerClient::destroySurface()
 390     status_t onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle);
 391
 392     // called when all clients have released all their references to
 393     // this layer meaning it is entirely safe to destroy all
 394     // resources associated to this layer.
 395     status_t onLayerDestroyed(const wp<Layer>& layer);
 396
 397     // remove a layer from SurfaceFlinger immediately
 398     status_t removeLayer(const sp<Layer>& layer, bool topLevelOnly = false);
 399
 400     // add a layer to SurfaceFlinger
 401     status_t addClientLayer(const sp<Client>& client,
 402             const sp<IBinder>& handle,
 403             const sp<IGraphicBufferProducer>& gbc,
 404             const sp<Layer>& lbc,
 405             const sp<Layer>& parent);
 406
 407     /* ------------------------------------------------------------------------
 408      * Boot animation, on/off animations and screen capture
 409      */
 410
 411     void startBootAnim();
 412
 413     void renderScreenImplLocked(
 414             const sp<const DisplayDevice>& hw,
 415             Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
 416             int32_t minLayerZ, int32_t maxLayerZ,
 417             bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation);
 418
 419 #ifdef USE_HWC2
 420     status_t captureScreenImplLocked(const sp<const DisplayDevice>& device,
 421                                      ANativeWindowBuffer* buffer, Rect sourceCrop,
 422                                      uint32_t reqWidth, uint32_t reqHeight, int32_t minLayerZ,
 423                                      int32_t maxLayerZ, bool useIdentityTransform,
 424                                      Transform::orientation_flags rotation, bool isLocalScreenshot,
 425                                      int* outSyncFd);
 426 #else
 427     status_t captureScreenImplLocked(
 428             const sp<const DisplayDevice>& hw,
 429             const sp<IGraphicBufferProducer>& producer,
 430             Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
 431             int32_t minLayerZ, int32_t maxLayerZ,
 432             bool useIdentityTransform, Transform::orientation_flags rotation,
 433             bool isLocalScreenshot);
 434 #endif
 435
 436     sp<StartPropertySetThread> mStartPropertySetThread = nullptr;
 437
 438     /* ------------------------------------------------------------------------
 439      * Properties
 440      */
 441     void readPersistentProperties();
 442
 443     /* ------------------------------------------------------------------------
 444      * EGL
 445      */
 446     size_t getMaxTextureSize() const;
 447     size_t getMaxViewportDims() const;
 448
 449     /* ------------------------------------------------------------------------
 450      * Display and layer stack management
 451      */
 452     // called when starting, or restarting after system_server death
 453     void initializeDisplays();
 454
 455     // Create an IBinder for a builtin display and add it to current state
 456     void createBuiltinDisplayLocked(DisplayDevice::DisplayType type);
 457
 458
 459     sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
 460       Mutex::Autolock _l(mStateLock);
 461       return getDisplayDeviceLocked(dpy);
 462     }
 463
 464     sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
 465       Mutex::Autolock _l(mStateLock);
 466       return getDisplayDeviceLocked(dpy);
 467     }
 468
 469     // NOTE: can only be called from the main thread or with mStateLock held
 470     sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) const {
 471         return mDisplays.valueFor(dpy);
 472     }
 473
 474     // NOTE: can only be called from the main thread or with mStateLock held
 475     sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) {
 476         return mDisplays.valueFor(dpy);
 477     }
 478
 479     sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
 480         return getDisplayDeviceLocked(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
 481     }
 482
 483     void createDefaultDisplayDevice();
 484
 485     int32_t getDisplayType(const sp<IBinder>& display) {
 486         if (!display.get()) return NAME_NOT_FOUND;
 487         for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
 488             if (display == mBuiltinDisplays[i]) {
 489                 return i;
 490             }
 491         }
 492         return NAME_NOT_FOUND;
 493     }
 494
 495     // mark a region of a layer stack dirty. this updates the dirty
 496     // region of all screens presenting this layer stack.
 497     void invalidateLayerStack(uint32_t layerStack, const Region& dirty);
 498
 499 #ifndef USE_HWC2
 500     int32_t allocateHwcDisplayId(DisplayDevice::DisplayType type);
 501 #endif
 502
 503     /* ------------------------------------------------------------------------
 504      * H/W composer
 505      */
 506
 507     HWComposer& getHwComposer() const { return *mHwc; }
 508
 509     /* ------------------------------------------------------------------------
 510      * Compositing
 511      */
 512     void invalidateHwcGeometry();
 513     void computeVisibleRegions(uint32_t layerStack,
 514             Region& dirtyRegion, Region& opaqueRegion);
 515
 516     void preComposition(nsecs_t refreshStartTime);
 517     void postComposition(nsecs_t refreshStartTime);
 518     void updateCompositorTiming(
 519             nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
 520             std::shared_ptr<FenceTime>& presentFenceTime);
 521     void setCompositorTimingSnapped(
 522             nsecs_t vsyncPhase, nsecs_t vsyncInterval,
 523             nsecs_t compositeToPresentLatency);
 524     void rebuildLayerStacks();
 525
 526     // Given a dataSpace, returns the appropriate color_mode to use
 527     // to display that dataSpace.
 528     android_color_mode pickColorMode(android_dataspace dataSpace) const;
 529     android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b) const;
 530
 531     mat4 computeSaturationMatrix() const;
 532
 533     void setUpHWComposer();
 534     void doComposition();
 535     void doDebugFlashRegions();
 536     void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
 537
 538     // compose surfaces for display hw. this fails if using GL and the surface
 539     // has been destroyed and is no longer valid.
 540     bool doComposeSurfaces(const sp<const DisplayDevice>& displayDevice, const Region& dirty);
 541
 542     void postFramebuffer();
 543     void drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const;
 544
 545     /* ------------------------------------------------------------------------
 546      * Display management
 547      */
 548
 549     /* ------------------------------------------------------------------------
 550      * VSync
 551      */
 552     void enableHardwareVsync();
 553     void resyncToHardwareVsync(bool makeAvailable);
 554     void disableHardwareVsync(bool makeUnavailable);
 555
 556 public:
 557     void resyncWithRateLimit();
 558     void getCompositorTiming(CompositorTiming* compositorTiming);
 559 private:
 560
 561     /* ------------------------------------------------------------------------
 562      * Debugging & dumpsys
 563      */
 564     void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
 565     void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
 566     void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
 567     void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
 568     bool startDdmConnection();
 569     void appendSfConfigString(String8& result) const;
 570     void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
 571             const sp<const DisplayDevice>& hw,
 572             int32_t minLayerZ, int32_t maxLayerZ);
 573
 574     void logFrameStats();
 575
 576     void dumpStaticScreenStats(String8& result) const;
 577     // Not const because each Layer needs to query Fences and cache timestamps.
 578     void dumpFrameEventsLocked(String8& result);
 579
 580     void recordBufferingStats(const char* layerName,
 581             std::vector<OccupancyTracker::Segment>&& history);
 582     void dumpBufferingStats(String8& result) const;
 583     void dumpWideColorInfo(String8& result) const;
 584
 585     bool isLayerTripleBufferingDisabled() const {
 586         return this->mLayerTripleBufferingDisabled;
 587     }
 588
 589 #ifdef USE_HWC2
 590     /* ------------------------------------------------------------------------
 591      * VrFlinger
 592      */
 593     template<typename T>
 594     void clearHwcLayers(const T& layers) {
 595         for (size_t i = 0; i < layers.size(); ++i) {
 596             layers[i]->clearHwcLayers();
 597         }
 598     }
 599     void resetHwcLocked();
 600
 601     // Check to see if we should handoff to vr flinger.
 602     void updateVrFlinger();
 603 #endif
 604
 605     /* ------------------------------------------------------------------------
 606      * Attributes
 607      */
 608
 609     // access must be protected by mStateLock
 610     mutable Mutex mStateLock;
 611     State mCurrentState{LayerVector::StateSet::Current};
 612     volatile int32_t mTransactionFlags;
 613     Condition mTransactionCV;
 614     bool mTransactionPending;
 615     bool mAnimTransactionPending;
 616     SortedVector< sp<Layer> > mLayersPendingRemoval;
 617     SortedVector< wp<IBinder> > mGraphicBufferProducerList;
 618
 619     // protected by mStateLock (but we could use another lock)
 620     bool mLayersRemoved;
 621     bool mLayersAdded;
 622
 623     // access must be protected by mInvalidateLock
 624     volatile int32_t mRepaintEverything;
 625
 626     // current, real and vr hardware composers.
 627     HWComposer* mHwc;
 628 #ifdef USE_HWC2
 629     HWComposer* mRealHwc;
 630     HWComposer* mVrHwc;
 631 #endif
 632     // constant members (no synchronization needed for access)
 633     RenderEngine* mRenderEngine;
 634     nsecs_t mBootTime;
 635     bool mGpuToCpuSupported;
 636     sp<EventThread> mEventThread;
 637     sp<EventThread> mSFEventThread;
 638     sp<EventThread> mInjectorEventThread;
 639     sp<InjectVSyncSource> mVSyncInjector;
 640     sp<EventControlThread> mEventControlThread;
 641     EGLContext mEGLContext;
 642     EGLDisplay mEGLDisplay;
 643     sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
 644
 645 #ifdef USE_HWC2
 646     std::unique_ptr<dvr::VrFlinger> mVrFlinger;
 647 #endif
 648
 649     // Can only accessed from the main thread, these members
 650     // don't need synchronization
 651     State mDrawingState{LayerVector::StateSet::Drawing};
 652     bool mVisibleRegionsDirty;
 653 #ifndef USE_HWC2
 654     bool mHwWorkListDirty;
 655 #else
 656     bool mGeometryInvalid;
 657 #endif
 658     bool mAnimCompositionPending;
 659 #ifdef USE_HWC2
 660     std::vector<sp<Layer>> mLayersWithQueuedFrames;
 661     sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
 662     bool mHadClientComposition = false;
 663 #endif
 664     FenceTimeline mGlCompositionDoneTimeline;
 665     FenceTimeline mDisplayTimeline;
 666
 667     // this may only be written from the main thread with mStateLock held
 668     // it may be read from other threads with mStateLock held
 669     DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
 670
 671     // don't use a lock for these, we don't care
 672     int mDebugRegion;
 673     int mDebugDDMS;
 674     int mDebugDisableHWC;
 675     int mDebugDisableTransformHint;
 676     volatile nsecs_t mDebugInSwapBuffers;
 677     nsecs_t mLastSwapBufferTime;
 678     volatile nsecs_t mDebugInTransaction;
 679     nsecs_t mLastTransactionTime;
 680     bool mBootFinished;
 681     bool mForceFullDamage;
 682 #ifdef USE_HWC2
 683     bool mPropagateBackpressure = true;
 684 #endif
 685     SurfaceInterceptor mInterceptor;
 686     bool mUseHwcVirtualDisplays = false;
 687
 688     // Restrict layers to use two buffers in their bufferqueues.
 689     bool mLayerTripleBufferingDisabled = false;
 690
 691     // these are thread safe
 692     mutable MessageQueue mEventQueue;
 693     FrameTracker mAnimFrameTracker;
 694     DispSync mPrimaryDispSync;
 695
 696     // protected by mDestroyedLayerLock;
 697     mutable Mutex mDestroyedLayerLock;
 698     Vector<Layer const *> mDestroyedLayers;
 699
 700     // protected by mHWVsyncLock
 701     Mutex mHWVsyncLock;
 702     bool mPrimaryHWVsyncEnabled;
 703     bool mHWVsyncAvailable;
 704
 705     // protected by mCompositorTimingLock;
 706     mutable std::mutex mCompositorTimingLock;
 707     CompositorTiming mCompositorTiming;
 708
 709     // Only accessed from the main thread.
 710     struct CompositePresentTime {
 711         nsecs_t composite { -1 };
 712         std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
 713     };
 714     std::queue<CompositePresentTime> mCompositePresentTimes;
 715
 716     std::atomic<bool> mRefreshPending{false};
 717
 718     /* ------------------------------------------------------------------------
 719      * Feature prototyping
 720      */
 721
 722     bool mInjectVSyncs;
 723
 724     Daltonizer mDaltonizer;
 725 #ifndef USE_HWC2
 726     bool mDaltonize;
 727 #endif
 728
 729     mat4 mPreviousColorMatrix;
 730     mat4 mColorMatrix;
 731     bool mHasColorMatrix;
 732
 733     // Static screen stats
 734     bool mHasPoweredOff;
 735     static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
 736     nsecs_t mFrameBuckets[NUM_BUCKETS];
 737     nsecs_t mTotalTime;
 738     std::atomic<nsecs_t> mLastSwapTime;
 739
 740     size_t mNumLayers;
 741
 742     // Double- vs. triple-buffering stats
 743     struct BufferingStats {
 744         BufferingStats()
 745           : numSegments(0),
 746             totalTime(0),
 747             twoBufferTime(0),
 748             doubleBufferedTime(0),
 749             tripleBufferedTime(0) {}
 750
 751         size_t numSegments;
 752         nsecs_t totalTime;
 753
 754         // "Two buffer" means that a third buffer was never used, whereas
 755         // "double-buffered" means that on average the segment only used two
 756         // buffers (though it may have used a third for some part of the
 757         // segment)
 758         nsecs_t twoBufferTime;
 759         nsecs_t doubleBufferedTime;
 760         nsecs_t tripleBufferedTime;
 761     };
 762     mutable Mutex mBufferingStatsMutex;
 763     std::unordered_map<std::string, BufferingStats> mBufferingStats;
 764
 765     // Verify that transaction is being called by an approved process:
 766     // either AID_GRAPHICS or AID_SYSTEM.
 767     status_t CheckTransactCodeCredentials(uint32_t code);
 768
 769 #ifdef USE_HWC2
 770     std::atomic<bool> mVrFlingerRequestsDisplay;
 771     static bool useVrFlinger;
 772 #endif
 773
 774     float mSaturation = 1.0f;
 775 };
 776 }; // namespace android
 777
 778 #endif // ANDROID_SURFACE_FLINGER_H