Layer.h revision 9e56aa0fdb5f7121b9b975c6c16db103ea4d2fe9 
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_LAYER_H
18#define ANDROID_LAYER_H
19
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <EGL/egl.h>
24#include <EGL/eglext.h>
25
26#include <utils/RefBase.h>
27#include <utils/String8.h>
28#include <utils/Timers.h>
29
30#include <ui/FrameStats.h>
31#include <ui/GraphicBuffer.h>
32#include <ui/PixelFormat.h>
33#include <ui/Region.h>
34
35#include <gui/ISurfaceComposerClient.h>
36
37#include <private/gui/LayerState.h>
38
39#include <list>
40
41#include "FrameTracker.h"
42#include "Client.h"
43#include "MonitoredProducer.h"
44#include "SurfaceFlinger.h"
45#include "SurfaceFlingerConsumer.h"
46#include "Transform.h"
47
48#include "DisplayHardware/HWComposer.h"
49#include "DisplayHardware/FloatRect.h"
50#include "RenderEngine/Mesh.h"
51#include "RenderEngine/Texture.h"
52
53namespace android {
54
55// ---------------------------------------------------------------------------
56
57class Client;
58class Colorizer;
59class DisplayDevice;
60class GraphicBuffer;
61class SurfaceFlinger;
62
63// ---------------------------------------------------------------------------
64
65/*
66 * A new BufferQueue and a new SurfaceFlingerConsumer are created when the
67 * Layer is first referenced.
68 *
69 * This also implements onFrameAvailable(), which notifies SurfaceFlinger
70 * that new data has arrived.
71 */
72class Layer : public SurfaceFlingerConsumer::ContentsChangedListener {
73    static int32_t sSequence;
74
75public:
76    mutable bool contentDirty;
77    // regions below are in window-manager space
78    Region visibleRegion;
79    Region coveredRegion;
80    Region visibleNonTransparentRegion;
81    Region surfaceDamageRegion;
82
83    // Layer serial number.  This gives layers an explicit ordering, so we
84    // have a stable sort order when their layer stack and Z-order are
85    // the same.
86    int32_t sequence;
87
88    enum { // flags for doTransaction()
89        eDontUpdateGeometryState = 0x00000001,
90        eVisibleRegion = 0x00000002,
91    };
92
93    struct Geometry {
94        uint32_t w;
95        uint32_t h;
96        Rect crop;
97        inline bool operator ==(const Geometry& rhs) const {
98            return (w == rhs.w && h == rhs.h && crop == rhs.crop);
99        }
100        inline bool operator !=(const Geometry& rhs) const {
101            return !operator ==(rhs);
102        }
103    };
104
105    struct State {
106        Geometry active;
107        Geometry requested;
108        uint32_t z;
109        uint32_t layerStack;
110#ifdef USE_HWC2
111        float alpha;
112#else
113        uint8_t alpha;
114#endif
115        uint8_t flags;
116        uint8_t mask;
117        uint8_t reserved[2];
118        int32_t sequence; // changes when visible regions can change
119        Transform transform;
120        bool modified;
121
122        // If set, defers this state update until the Layer identified by handle
123        // receives a frame with the given frameNumber
124        sp<IBinder> handle;
125        uint64_t frameNumber;
126
127        // the transparentRegion hint is a bit special, it's latched only
128        // when we receive a buffer -- this is because it's "content"
129        // dependent.
130        Region activeTransparentRegion;
131        Region requestedTransparentRegion;
132    };
133
134    // -----------------------------------------------------------------------
135
136    Layer(SurfaceFlinger* flinger, const sp<Client>& client,
137            const String8& name, uint32_t w, uint32_t h, uint32_t flags);
138
139    virtual ~Layer();
140
141    // the this layer's size and format
142    status_t setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
143
144    // modify current state
145    bool setPosition(float x, float y);
146    bool setLayer(uint32_t z);
147    bool setSize(uint32_t w, uint32_t h);
148#ifdef USE_HWC2
149    bool setAlpha(float alpha);
150#else
151    bool setAlpha(uint8_t alpha);
152#endif
153    bool setMatrix(const layer_state_t::matrix22_t& matrix);
154    bool setTransparentRegionHint(const Region& transparent);
155    bool setFlags(uint8_t flags, uint8_t mask);
156    bool setCrop(const Rect& crop);
157    bool setLayerStack(uint32_t layerStack);
158    void deferTransactionUntil(const sp<IBinder>& handle, uint64_t frameNumber);
159
160    // If we have received a new buffer this frame, we will pass its surface
161    // damage down to hardware composer. Otherwise, we must send a region with
162    // one empty rect.
163    void useSurfaceDamage();
164    void useEmptyDamage();
165
166    uint32_t getTransactionFlags(uint32_t flags);
167    uint32_t setTransactionFlags(uint32_t flags);
168
169    void computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh,
170            bool useIdentityTransform) const;
171    Rect computeBounds(const Region& activeTransparentRegion) const;
172    Rect computeBounds() const;
173
174    class Handle;
175    sp<IBinder> getHandle();
176    sp<IGraphicBufferProducer> getProducer() const;
177    const String8& getName() const;
178
179    // -----------------------------------------------------------------------
180    // Virtuals
181
182    virtual const char* getTypeId() const { return "Layer"; }
183
184    /*
185     * isOpaque - true if this surface is opaque
186     *
187     * This takes into account the buffer format (i.e. whether or not the
188     * pixel format includes an alpha channel) and the "opaque" flag set
189     * on the layer.  It does not examine the current plane alpha value.
190     */
191    virtual bool isOpaque(const Layer::State& s) const;
192
193    /*
194     * isSecure - true if this surface is secure, that is if it prevents
195     * screenshots or VNC servers.
196     */
197    virtual bool isSecure() const;
198
199    /*
200     * isProtected - true if the layer may contain protected content in the
201     * GRALLOC_USAGE_PROTECTED sense.
202     */
203    virtual bool isProtected() const;
204
205    /*
206     * isVisible - true if this layer is visible, false otherwise
207     */
208    virtual bool isVisible() const;
209
210    /*
211     * isFixedSize - true if content has a fixed size
212     */
213    virtual bool isFixedSize() const;
214
215protected:
216    /*
217     * onDraw - draws the surface.
218     */
219    virtual void onDraw(const sp<const DisplayDevice>& hw, const Region& clip,
220            bool useIdentityTransform) const;
221
222public:
223    // -----------------------------------------------------------------------
224
225#ifdef USE_HWC2
226    void setGeometry(const sp<const DisplayDevice>& displayDevice);
227    void forceClientComposition(int32_t hwcId);
228    void setPerFrameData(const sp<const DisplayDevice>& displayDevice);
229
230    // callIntoHwc exists so we can update our local state and call
231    // acceptDisplayChanges without unnecessarily updating the device's state
232    void setCompositionType(int32_t hwcId, HWC2::Composition type,
233            bool callIntoHwc = true);
234    HWC2::Composition getCompositionType(int32_t hwcId) const;
235
236    void setClearClientTarget(int32_t hwcId, bool clear);
237    bool getClearClientTarget(int32_t hwcId) const;
238
239    void updateCursorPosition(const sp<const DisplayDevice>& hw);
240#else
241    void setGeometry(const sp<const DisplayDevice>& hw,
242            HWComposer::HWCLayerInterface& layer);
243    void setPerFrameData(const sp<const DisplayDevice>& hw,
244            HWComposer::HWCLayerInterface& layer);
245    void setAcquireFence(const sp<const DisplayDevice>& hw,
246            HWComposer::HWCLayerInterface& layer);
247
248    Rect getPosition(const sp<const DisplayDevice>& hw);
249#endif
250
251    /*
252     * called after page-flip
253     */
254#ifdef USE_HWC2
255    void onLayerDisplayed(const sp<Fence>& releaseFence);
256#else
257    void onLayerDisplayed(const sp<const DisplayDevice>& hw,
258            HWComposer::HWCLayerInterface* layer);
259#endif
260
261    bool shouldPresentNow(const DispSync& dispSync) const;
262
263    /*
264     * called before composition.
265     * returns true if the layer has pending updates.
266     */
267    bool onPreComposition();
268
269    /*
270     *  called after composition.
271     */
272    void onPostComposition();
273
274#ifdef USE_HWC2
275    // If a buffer was replaced this frame, release the former buffer
276    void releasePendingBuffer();
277#endif
278
279    /*
280     * draw - performs some global clipping optimizations
281     * and calls onDraw().
282     */
283    void draw(const sp<const DisplayDevice>& hw, const Region& clip) const;
284    void draw(const sp<const DisplayDevice>& hw, bool useIdentityTransform) const;
285    void draw(const sp<const DisplayDevice>& hw) const;
286
287    /*
288     * doTransaction - process the transaction. This is a good place to figure
289     * out which attributes of the surface have changed.
290     */
291    uint32_t doTransaction(uint32_t transactionFlags);
292
293    /*
294     * setVisibleRegion - called to set the new visible region. This gives
295     * a chance to update the new visible region or record the fact it changed.
296     */
297    void setVisibleRegion(const Region& visibleRegion);
298
299    /*
300     * setCoveredRegion - called when the covered region changes. The covered
301     * region corresponds to any area of the surface that is covered
302     * (transparently or not) by another surface.
303     */
304    void setCoveredRegion(const Region& coveredRegion);
305
306    /*
307     * setVisibleNonTransparentRegion - called when the visible and
308     * non-transparent region changes.
309     */
310    void setVisibleNonTransparentRegion(const Region&
311            visibleNonTransparentRegion);
312
313    /*
314     * latchBuffer - called each time the screen is redrawn and returns whether
315     * the visible regions need to be recomputed (this is a fairly heavy
316     * operation, so this should be set only if needed). Typically this is used
317     * to figure out if the content or size of a surface has changed.
318     */
319    Region latchBuffer(bool& recomputeVisibleRegions);
320
321    bool isPotentialCursor() const { return mPotentialCursor;}
322
323    /*
324     * called with the state lock when the surface is removed from the
325     * current list
326     */
327    void onRemoved();
328
329
330    // Updates the transform hint in our SurfaceFlingerConsumer to match
331    // the current orientation of the display device.
332    void updateTransformHint(const sp<const DisplayDevice>& hw) const;
333
334    /*
335     * returns the rectangle that crops the content of the layer and scales it
336     * to the layer's size.
337     */
338    Rect getContentCrop() const;
339
340    /*
341     * Returns if a frame is queued.
342     */
343    bool hasQueuedFrame() const { return mQueuedFrames > 0 ||
344            mSidebandStreamChanged || mAutoRefresh; }
345
346#ifdef USE_HWC2
347    // -----------------------------------------------------------------------
348
349    bool hasHwcLayer(int32_t hwcId) {
350        if (mHwcLayers.count(hwcId) == 0) {
351            return false;
352        }
353        if (mHwcLayers[hwcId].layer->isAbandoned()) {
354            ALOGI("Erasing abandoned layer %s on %d", mName.string(), hwcId);
355            mHwcLayers.erase(hwcId);
356            return false;
357        }
358        return true;
359    }
360
361    std::shared_ptr<HWC2::Layer> getHwcLayer(int32_t hwcId) {
362        if (mHwcLayers.count(hwcId) == 0) {
363            return nullptr;
364        }
365        return mHwcLayers[hwcId].layer;
366    }
367
368    void setHwcLayer(int32_t hwcId, std::shared_ptr<HWC2::Layer>&& layer) {
369        if (layer) {
370            mHwcLayers[hwcId].layer = layer;
371        } else {
372            mHwcLayers.erase(hwcId);
373        }
374    }
375
376#endif
377    // -----------------------------------------------------------------------
378
379    void clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip) const;
380    void setFiltering(bool filtering);
381    bool getFiltering() const;
382
383    // only for debugging
384    inline const sp<GraphicBuffer>& getActiveBuffer() const { return mActiveBuffer; }
385
386    inline  const State&    getDrawingState() const { return mDrawingState; }
387    inline  const State&    getCurrentState() const { return mCurrentState; }
388    inline  State&          getCurrentState()       { return mCurrentState; }
389
390
391    /* always call base class first */
392    void dump(String8& result, Colorizer& colorizer) const;
393    void dumpFrameStats(String8& result) const;
394    void clearFrameStats();
395    void logFrameStats();
396    void getFrameStats(FrameStats* outStats) const;
397
398protected:
399    // constant
400    sp<SurfaceFlinger> mFlinger;
401
402    virtual void onFirstRef();
403
404    /*
405     * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer)
406     * is called.
407     */
408    class LayerCleaner {
409        sp<SurfaceFlinger> mFlinger;
410        wp<Layer> mLayer;
411    protected:
412        ~LayerCleaner();
413    public:
414        LayerCleaner(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer);
415    };
416
417
418private:
419    // Interface implementation for SurfaceFlingerConsumer::ContentsChangedListener
420    virtual void onFrameAvailable(const BufferItem& item) override;
421    virtual void onFrameReplaced(const BufferItem& item) override;
422    virtual void onSidebandStreamChanged() override;
423
424    void commitTransaction();
425
426    // needsLinearFiltering - true if this surface's state requires filtering
427    bool needsFiltering(const sp<const DisplayDevice>& hw) const;
428
429    uint32_t getEffectiveUsage(uint32_t usage) const;
430    FloatRect computeCrop(const sp<const DisplayDevice>& hw) const;
431    bool isCropped() const;
432    static bool getOpacityForFormat(uint32_t format);
433
434    // drawing
435    void clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
436            float r, float g, float b, float alpha) const;
437    void drawWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
438            bool useIdentityTransform) const;
439
440    // Temporary - Used only for LEGACY camera mode.
441    uint32_t getProducerStickyTransform() const;
442
443    // -----------------------------------------------------------------------
444
445    class SyncPoint
446    {
447    public:
448        SyncPoint(uint64_t frameNumber) : mFrameNumber(frameNumber),
449                mFrameIsAvailable(false), mTransactionIsApplied(false) {}
450
451        uint64_t getFrameNumber() const {
452            return mFrameNumber;
453        }
454
455        bool frameIsAvailable() const {
456            return mFrameIsAvailable;
457        }
458
459        void setFrameAvailable() {
460            mFrameIsAvailable = true;
461        }
462
463        bool transactionIsApplied() const {
464            return mTransactionIsApplied;
465        }
466
467        void setTransactionApplied() {
468            mTransactionIsApplied = true;
469        }
470
471    private:
472        const uint64_t mFrameNumber;
473        std::atomic<bool> mFrameIsAvailable;
474        std::atomic<bool> mTransactionIsApplied;
475    };
476
477    // SyncPoints which will be signaled when the correct frame is at the head
478    // of the queue and dropped after the frame has been latched. Protected by
479    // mLocalSyncPointMutex.
480    Mutex mLocalSyncPointMutex;
481    std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
482
483    // SyncPoints which will be signaled and then dropped when the transaction
484    // is applied
485    std::list<std::shared_ptr<SyncPoint>> mRemoteSyncPoints;
486
487    uint64_t getHeadFrameNumber() const;
488
489    // Returns false if the relevant frame has already been latched
490    bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
491
492    void pushPendingState();
493    void popPendingState();
494    bool applyPendingStates();
495public:
496    void notifyAvailableFrames();
497private:
498
499    // -----------------------------------------------------------------------
500
501    // constants
502    sp<SurfaceFlingerConsumer> mSurfaceFlingerConsumer;
503    sp<IGraphicBufferProducer> mProducer;
504    uint32_t mTextureName;      // from GLES
505    bool mPremultipliedAlpha;
506    String8 mName;
507    PixelFormat mFormat;
508
509    // these are protected by an external lock
510    State mCurrentState;
511    State mDrawingState;
512    volatile int32_t mTransactionFlags;
513
514    // Accessed from main thread and binder threads
515    Mutex mPendingStateMutex;
516    Vector<State> mPendingStates;
517
518    // thread-safe
519    volatile int32_t mQueuedFrames;
520    volatile int32_t mSidebandStreamChanged; // used like an atomic boolean
521    FrameTracker mFrameTracker;
522
523    // main thread
524    sp<GraphicBuffer> mActiveBuffer;
525    sp<NativeHandle> mSidebandStream;
526    Rect mCurrentCrop;
527    uint32_t mCurrentTransform;
528    uint32_t mCurrentScalingMode;
529    bool mCurrentOpacity;
530    std::atomic<uint64_t> mCurrentFrameNumber;
531    bool mRefreshPending;
532    bool mFrameLatencyNeeded;
533    // Whether filtering is forced on or not
534    bool mFiltering;
535    // Whether filtering is needed b/c of the drawingstate
536    bool mNeedsFiltering;
537    // The mesh used to draw the layer in GLES composition mode
538    mutable Mesh mMesh;
539    // The texture used to draw the layer in GLES composition mode
540    mutable Texture mTexture;
541
542#ifdef USE_HWC2
543    // HWC items, accessed from the main thread
544    struct HWCInfo {
545        HWCInfo()
546          : layer(),
547            forceClientComposition(false),
548            compositionType(HWC2::Composition::Invalid),
549            clearClientTarget(false) {}
550
551        std::shared_ptr<HWC2::Layer> layer;
552        bool forceClientComposition;
553        HWC2::Composition compositionType;
554        bool clearClientTarget;
555    };
556    std::unordered_map<int32_t, HWCInfo> mHwcLayers;
557#endif
558
559    // page-flip thread (currently main thread)
560    bool mProtectedByApp; // application requires protected path to external sink
561
562    // protected by mLock
563    mutable Mutex mLock;
564    // Set to true once we've returned this surface's handle
565    mutable bool mHasSurface;
566    const wp<Client> mClientRef;
567
568    // This layer can be a cursor on some displays.
569    bool mPotentialCursor;
570
571    // Local copy of the queued contents of the incoming BufferQueue
572    mutable Mutex mQueueItemLock;
573    Condition mQueueItemCondition;
574    Vector<BufferItem> mQueueItems;
575    std::atomic<uint64_t> mLastFrameNumberReceived;
576    bool mUpdateTexImageFailed; // This is only modified from the main thread
577
578    bool mAutoRefresh;
579};
580
581// ---------------------------------------------------------------------------
582
583}; // namespace android
584
585#endif // ANDROID_LAYER_H
586