SurfaceFlinger.h revision 412903fce3a93f411c85c54375a1851bfb370400 
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 "StartBootAnimThread.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
72namespace android {
73
74// ---------------------------------------------------------------------------
75
76class Client;
77class DisplayEventConnection;
78class EventThread;
79class Layer;
80class LayerDim;
81class Surface;
82class RenderEngine;
83class EventControlThread;
84class VSyncSource;
85class InjectVSyncSource;
86
87namespace dvr {
88class VrFlinger;
89} // namespace dvr
90
91// ---------------------------------------------------------------------------
92
93enum {
94    eTransactionNeeded        = 0x01,
95    eTraversalNeeded          = 0x02,
96    eDisplayTransactionNeeded = 0x04,
97    eTransactionMask          = 0x07
98};
99
100class SurfaceFlinger : public BnSurfaceComposer,
101                       private IBinder::DeathRecipient,
102                       private HWComposer::EventHandler
103{
104public:
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
218private:
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    static constexpr const char* kTimestampProperty = "service.sf.present_timestamp";
231
232    // We're reference counted, never destroy SurfaceFlinger directly
233    virtual ~SurfaceFlinger();
234
235    /* ------------------------------------------------------------------------
236     * Internal data structures
237     */
238
239    class State {
240    public:
241        explicit State(LayerVector::StateSet set) : stateSet(set) {}
242        State& operator=(const State& other) {
243            // We explicitly don't copy stateSet so that, e.g., mDrawingState
244            // always uses the Drawing StateSet.
245            layersSortedByZ = other.layersSortedByZ;
246            displays = other.displays;
247            return *this;
248        }
249
250        const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
251        LayerVector layersSortedByZ;
252        DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
253
254        void traverseInZOrder(const LayerVector::Visitor& visitor) const;
255        void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
256    };
257
258    /* ------------------------------------------------------------------------
259     * IBinder interface
260     */
261    virtual status_t onTransact(uint32_t code, const Parcel& data,
262        Parcel* reply, uint32_t flags);
263    virtual status_t dump(int fd, const Vector<String16>& args);
264
265    /* ------------------------------------------------------------------------
266     * ISurfaceComposer interface
267     */
268    virtual sp<ISurfaceComposerClient> createConnection();
269    virtual sp<ISurfaceComposerClient> createScopedConnection(const sp<IGraphicBufferProducer>& gbp);
270    virtual sp<IBinder> createDisplay(const String8& displayName, bool secure);
271    virtual void destroyDisplay(const sp<IBinder>& display);
272    virtual sp<IBinder> getBuiltInDisplay(int32_t id);
273    virtual void setTransactionState(const Vector<ComposerState>& state,
274            const Vector<DisplayState>& displays, uint32_t flags);
275    virtual void bootFinished();
276    virtual bool authenticateSurfaceTexture(
277        const sp<IGraphicBufferProducer>& bufferProducer) const;
278    virtual status_t getSupportedFrameTimestamps(
279            std::vector<FrameEvent>* outSupported) const;
280    virtual sp<IDisplayEventConnection> createDisplayEventConnection();
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);
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    status_t captureScreenImplLocked(
420            const sp<const DisplayDevice>& hw,
421            const sp<IGraphicBufferProducer>& producer,
422            Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
423            int32_t minLayerZ, int32_t maxLayerZ,
424            bool useIdentityTransform, Transform::orientation_flags rotation,
425            bool isLocalScreenshot);
426
427    sp<StartBootAnimThread> mStartBootAnimThread = nullptr;
428
429    /* ------------------------------------------------------------------------
430     * EGL
431     */
432    size_t getMaxTextureSize() const;
433    size_t getMaxViewportDims() const;
434
435    /* ------------------------------------------------------------------------
436     * Display and layer stack management
437     */
438    // called when starting, or restarting after system_server death
439    void initializeDisplays();
440
441    // Create an IBinder for a builtin display and add it to current state
442    void createBuiltinDisplayLocked(DisplayDevice::DisplayType type);
443
444
445    sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) const {
446      Mutex::Autolock _l(mStateLock);
447      return getDisplayDeviceLocked(dpy);
448    }
449
450    sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& dpy) {
451      Mutex::Autolock _l(mStateLock);
452      return getDisplayDeviceLocked(dpy);
453    }
454
455    // NOTE: can only be called from the main thread or with mStateLock held
456    sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) const {
457        return mDisplays.valueFor(dpy);
458    }
459
460    // NOTE: can only be called from the main thread or with mStateLock held
461    sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& dpy) {
462        return mDisplays.valueFor(dpy);
463    }
464
465    sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
466        return getDisplayDeviceLocked(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
467    }
468
469    void createDefaultDisplayDevice();
470
471    int32_t getDisplayType(const sp<IBinder>& display) {
472        if (!display.get()) return NAME_NOT_FOUND;
473        for (int i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; ++i) {
474            if (display == mBuiltinDisplays[i]) {
475                return i;
476            }
477        }
478        return NAME_NOT_FOUND;
479    }
480
481    // mark a region of a layer stack dirty. this updates the dirty
482    // region of all screens presenting this layer stack.
483    void invalidateLayerStack(uint32_t layerStack, const Region& dirty);
484
485#ifndef USE_HWC2
486    int32_t allocateHwcDisplayId(DisplayDevice::DisplayType type);
487#endif
488
489    /* ------------------------------------------------------------------------
490     * H/W composer
491     */
492
493    HWComposer& getHwComposer() const { return *mHwc; }
494
495    /* ------------------------------------------------------------------------
496     * Compositing
497     */
498    void invalidateHwcGeometry();
499    void computeVisibleRegions(uint32_t layerStack,
500            Region& dirtyRegion, Region& opaqueRegion);
501
502    void preComposition(nsecs_t refreshStartTime);
503    void postComposition(nsecs_t refreshStartTime);
504    void updateCompositorTiming(
505            nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
506            std::shared_ptr<FenceTime>& presentFenceTime);
507    void setCompositorTimingSnapped(
508            nsecs_t vsyncPhase, nsecs_t vsyncInterval,
509            nsecs_t compositeToPresentLatency);
510    void rebuildLayerStacks();
511
512    // Given a dataSpace, returns the appropriate color_mode to use
513    // to display that dataSpace.
514    android_color_mode pickColorMode(android_dataspace dataSpace);
515    android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b);
516
517    void setUpHWComposer();
518    void doComposition();
519    void doDebugFlashRegions();
520    void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
521
522    // compose surfaces for display hw. this fails if using GL and the surface
523    // has been destroyed and is no longer valid.
524    bool doComposeSurfaces(const sp<const DisplayDevice>& displayDevice, const Region& dirty);
525
526    void postFramebuffer();
527    void drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const;
528
529    /* ------------------------------------------------------------------------
530     * Display management
531     */
532
533    /* ------------------------------------------------------------------------
534     * VSync
535     */
536    void enableHardwareVsync();
537    void resyncToHardwareVsync(bool makeAvailable);
538    void disableHardwareVsync(bool makeUnavailable);
539
540public:
541    void resyncWithRateLimit();
542    void getCompositorTiming(CompositorTiming* compositorTiming);
543private:
544
545    /* ------------------------------------------------------------------------
546     * Debugging & dumpsys
547     */
548    void listLayersLocked(const Vector<String16>& args, size_t& index, String8& result) const;
549    void dumpStatsLocked(const Vector<String16>& args, size_t& index, String8& result) const;
550    void clearStatsLocked(const Vector<String16>& args, size_t& index, String8& result);
551    void dumpAllLocked(const Vector<String16>& args, size_t& index, String8& result) const;
552    bool startDdmConnection();
553    void appendSfConfigString(String8& result) const;
554    void checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
555            const sp<const DisplayDevice>& hw,
556            int32_t minLayerZ, int32_t maxLayerZ);
557
558    void logFrameStats();
559
560    void dumpStaticScreenStats(String8& result) const;
561    // Not const because each Layer needs to query Fences and cache timestamps.
562    void dumpFrameEventsLocked(String8& result);
563
564    void recordBufferingStats(const char* layerName,
565            std::vector<OccupancyTracker::Segment>&& history);
566    void dumpBufferingStats(String8& result) const;
567    void dumpWideColorInfo(String8& result) const;
568
569    bool isLayerTripleBufferingDisabled() const {
570        return this->mLayerTripleBufferingDisabled;
571    }
572
573#ifdef USE_HWC2
574    /* ------------------------------------------------------------------------
575     * VrFlinger
576     */
577    void clearHwcLayers(const LayerVector& layers);
578    void resetHwcLocked();
579
580    // Check to see if we should handoff to vr flinger.
581    void updateVrFlinger();
582#endif
583
584    /* ------------------------------------------------------------------------
585     * Attributes
586     */
587
588    // access must be protected by mStateLock
589    mutable Mutex mStateLock;
590    State mCurrentState{LayerVector::StateSet::Current};
591    volatile int32_t mTransactionFlags;
592    Condition mTransactionCV;
593    bool mTransactionPending;
594    bool mAnimTransactionPending;
595    SortedVector< sp<Layer> > mLayersPendingRemoval;
596    SortedVector< wp<IBinder> > mGraphicBufferProducerList;
597
598    // protected by mStateLock (but we could use another lock)
599    bool mLayersRemoved;
600    bool mLayersAdded;
601
602    // access must be protected by mInvalidateLock
603    volatile int32_t mRepaintEverything;
604
605    // current, real and vr hardware composers.
606    HWComposer* mHwc;
607#ifdef USE_HWC2
608    HWComposer* mRealHwc;
609    HWComposer* mVrHwc;
610#endif
611    // constant members (no synchronization needed for access)
612    RenderEngine* mRenderEngine;
613    nsecs_t mBootTime;
614    bool mGpuToCpuSupported;
615    sp<EventThread> mEventThread;
616    sp<EventThread> mSFEventThread;
617    sp<EventThread> mInjectorEventThread;
618    sp<InjectVSyncSource> mVSyncInjector;
619    sp<EventControlThread> mEventControlThread;
620    EGLContext mEGLContext;
621    EGLDisplay mEGLDisplay;
622    sp<IBinder> mBuiltinDisplays[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
623
624#ifdef USE_HWC2
625    std::unique_ptr<dvr::VrFlinger> mVrFlinger;
626#endif
627
628    // Can only accessed from the main thread, these members
629    // don't need synchronization
630    State mDrawingState{LayerVector::StateSet::Drawing};
631    bool mVisibleRegionsDirty;
632#ifndef USE_HWC2
633    bool mHwWorkListDirty;
634#else
635    bool mGeometryInvalid;
636#endif
637    bool mAnimCompositionPending;
638#ifdef USE_HWC2
639    std::vector<sp<Layer>> mLayersWithQueuedFrames;
640    sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
641    bool mHadClientComposition = false;
642#endif
643    FenceTimeline mGlCompositionDoneTimeline;
644    FenceTimeline mDisplayTimeline;
645
646    // this may only be written from the main thread with mStateLock held
647    // it may be read from other threads with mStateLock held
648    DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> > mDisplays;
649
650    // don't use a lock for these, we don't care
651    int mDebugRegion;
652    int mDebugDDMS;
653    int mDebugDisableHWC;
654    int mDebugDisableTransformHint;
655    volatile nsecs_t mDebugInSwapBuffers;
656    nsecs_t mLastSwapBufferTime;
657    volatile nsecs_t mDebugInTransaction;
658    nsecs_t mLastTransactionTime;
659    bool mBootFinished;
660    bool mForceFullDamage;
661#ifdef USE_HWC2
662    bool mPropagateBackpressure = true;
663#endif
664    SurfaceInterceptor mInterceptor;
665    bool mUseHwcVirtualDisplays = false;
666
667    // Restrict layers to use two buffers in their bufferqueues.
668    bool mLayerTripleBufferingDisabled = false;
669
670    // these are thread safe
671    mutable MessageQueue mEventQueue;
672    FrameTracker mAnimFrameTracker;
673    DispSync mPrimaryDispSync;
674
675    // protected by mDestroyedLayerLock;
676    mutable Mutex mDestroyedLayerLock;
677    Vector<Layer const *> mDestroyedLayers;
678
679    // protected by mHWVsyncLock
680    Mutex mHWVsyncLock;
681    bool mPrimaryHWVsyncEnabled;
682    bool mHWVsyncAvailable;
683
684    // protected by mCompositorTimingLock;
685    mutable std::mutex mCompositorTimingLock;
686    CompositorTiming mCompositorTiming;
687
688    // Only accessed from the main thread.
689    struct CompositePresentTime {
690        nsecs_t composite { -1 };
691        std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
692    };
693    std::queue<CompositePresentTime> mCompositePresentTimes;
694
695    /* ------------------------------------------------------------------------
696     * Feature prototyping
697     */
698
699    bool mInjectVSyncs;
700
701    Daltonizer mDaltonizer;
702#ifndef USE_HWC2
703    bool mDaltonize;
704#endif
705
706    mat4 mPreviousColorMatrix;
707    mat4 mColorMatrix;
708    bool mHasColorMatrix;
709
710    // Static screen stats
711    bool mHasPoweredOff;
712    static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
713    nsecs_t mFrameBuckets[NUM_BUCKETS];
714    nsecs_t mTotalTime;
715    std::atomic<nsecs_t> mLastSwapTime;
716
717    size_t mNumLayers;
718
719    // Double- vs. triple-buffering stats
720    struct BufferingStats {
721        BufferingStats()
722          : numSegments(0),
723            totalTime(0),
724            twoBufferTime(0),
725            doubleBufferedTime(0),
726            tripleBufferedTime(0) {}
727
728        size_t numSegments;
729        nsecs_t totalTime;
730
731        // "Two buffer" means that a third buffer was never used, whereas
732        // "double-buffered" means that on average the segment only used two
733        // buffers (though it may have used a third for some part of the
734        // segment)
735        nsecs_t twoBufferTime;
736        nsecs_t doubleBufferedTime;
737        nsecs_t tripleBufferedTime;
738    };
739    mutable Mutex mBufferingStatsMutex;
740    std::unordered_map<std::string, BufferingStats> mBufferingStats;
741
742    // Verify that transaction is being called by an approved process:
743    // either AID_GRAPHICS or AID_SYSTEM.
744    status_t CheckTransactCodeCredentials(uint32_t code);
745
746#ifdef USE_HWC2
747    std::atomic<bool> mVrFlingerRequestsDisplay;
748    static bool useVrFlinger;
749#endif
750    };
751}; // namespace android
752
753#endif // ANDROID_SURFACE_FLINGER_H
754