LayerBase.h revision 2bd1d95efecffad447afd682ffe605bbf8c79d62 
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_BASE_H
18#define ANDROID_LAYER_BASE_H
19
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <EGL/egl.h>
24#include <EGL/eglext.h>
25#include <GLES/gl.h>
26
27#include <utils/RefBase.h>
28
29#include <ui/Region.h>
30
31#include <surfaceflinger/ISurfaceComposerClient.h>
32#include <private/surfaceflinger/SharedBufferStack.h>
33#include <private/surfaceflinger/LayerState.h>
34
35#include <pixelflinger/pixelflinger.h>
36
37#include <hardware/hwcomposer.h>
38
39#include "DisplayHardware/DisplayHardware.h"
40#include "Transform.h"
41
42namespace android {
43
44// ---------------------------------------------------------------------------
45
46class DisplayHardware;
47class Client;
48class GraphicBuffer;
49class GraphicPlane;
50class LayerBaseClient;
51class SurfaceFlinger;
52class Texture;
53
54// ---------------------------------------------------------------------------
55
56class LayerBase : public RefBase
57{
58    static int32_t sSequence;
59
60public:
61            LayerBase(SurfaceFlinger* flinger, DisplayID display);
62
63    DisplayID           dpy;
64    mutable bool        contentDirty;
65            Region      visibleRegionScreen;
66            Region      transparentRegionScreen;
67            Region      coveredRegionScreen;
68            int32_t     sequence;
69
70            struct State {
71                uint32_t        w;
72                uint32_t        h;
73                uint32_t        requested_w;
74                uint32_t        requested_h;
75                uint32_t        z;
76                uint8_t         alpha;
77                uint8_t         flags;
78                uint8_t         reserved[2];
79                int32_t         sequence;   // changes when visible regions can change
80                uint32_t        tint;
81                Transform       transform;
82                Region          transparentRegion;
83            };
84
85            void setName(const String8& name);
86            String8 getName() const;
87
88            // modify current state
89            bool setPosition(int32_t x, int32_t y);
90            bool setLayer(uint32_t z);
91            bool setSize(uint32_t w, uint32_t h);
92            bool setAlpha(uint8_t alpha);
93            bool setMatrix(const layer_state_t::matrix22_t& matrix);
94            bool setTransparentRegionHint(const Region& opaque);
95            bool setFlags(uint8_t flags, uint8_t mask);
96
97            void commitTransaction();
98            bool requestTransaction();
99            void forceVisibilityTransaction();
100
101            uint32_t getTransactionFlags(uint32_t flags);
102            uint32_t setTransactionFlags(uint32_t flags);
103
104            Rect visibleBounds() const;
105            void drawRegion(const Region& reg) const;
106
107            void invalidate();
108
109    virtual sp<LayerBaseClient> getLayerBaseClient() const { return 0; }
110
111    virtual const char* getTypeId() const { return "LayerBase"; }
112
113    virtual void setGeometry(hwc_layer_t* hwcl);
114
115    virtual void setPerFrameData(hwc_layer_t* hwcl);
116
117    /**
118     * draw - performs some global clipping optimizations
119     * and calls onDraw().
120     * Typically this method is not overridden, instead implement onDraw()
121     * to perform the actual drawing.
122     */
123    virtual void draw(const Region& clip) const;
124    virtual void drawForSreenShot() const;
125
126    /**
127     * onDraw - draws the surface.
128     */
129    virtual void onDraw(const Region& clip) const = 0;
130
131    /**
132     * initStates - called just after construction
133     */
134    virtual void initStates(uint32_t w, uint32_t h, uint32_t flags);
135
136    /**
137     * doTransaction - process the transaction. This is a good place to figure
138     * out which attributes of the surface have changed.
139     */
140    virtual uint32_t doTransaction(uint32_t transactionFlags);
141
142    /**
143     * setVisibleRegion - called to set the new visible region. This gives
144     * a chance to update the new visible region or record the fact it changed.
145     */
146    virtual void setVisibleRegion(const Region& visibleRegion);
147
148    /**
149     * setCoveredRegion - called when the covered region changes. The covered
150     * region corresponds to any area of the surface that is covered
151     * (transparently or not) by another surface.
152     */
153    virtual void setCoveredRegion(const Region& coveredRegion);
154
155    /**
156     * validateVisibility - cache a bunch of things
157     */
158    virtual void validateVisibility(const Transform& globalTransform);
159
160    /**
161     * lockPageFlip - called each time the screen is redrawn and returns whether
162     * the visible regions need to be recomputed (this is a fairly heavy
163     * operation, so this should be set only if needed). Typically this is used
164     * to figure out if the content or size of a surface has changed.
165     */
166    virtual void lockPageFlip(bool& recomputeVisibleRegions);
167
168    /**
169     * unlockPageFlip - called each time the screen is redrawn. updates the
170     * final dirty region wrt the planeTransform.
171     * At this point, all visible regions, surface position and size, etc... are
172     * correct.
173     */
174    virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
175
176    /**
177     * needsBlending - true if this surface needs blending
178     */
179    virtual bool needsBlending() const  { return false; }
180
181    /**
182     * needsDithering - true if this surface needs dithering
183     */
184    virtual bool needsDithering() const { return false; }
185
186    /**
187     * needsLinearFiltering - true if this surface needs filtering
188     */
189    virtual bool needsFiltering() const {
190        return (!(mFlags & DisplayHardware::SLOW_CONFIG)) && mNeedsFiltering;
191    }
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       { return false; }
198
199    /** Called from the main thread, when the surface is removed from the
200     * draw list */
201    virtual status_t ditch() { return NO_ERROR; }
202
203    /** called with the state lock when the surface is removed from the
204     *  current list */
205    virtual void onRemoved() { };
206
207    /** always call base class first */
208    virtual void dump(String8& result, char* scratch, size_t size) const;
209    virtual void shortDump(String8& result, char* scratch, size_t size) const;
210
211
212    enum { // flags for doTransaction()
213        eVisibleRegion      = 0x00000002,
214    };
215
216
217    inline  const State&    drawingState() const    { return mDrawingState; }
218    inline  const State&    currentState() const    { return mCurrentState; }
219    inline  State&          currentState()          { return mCurrentState; }
220
221    int32_t  getOrientation() const { return mOrientation; }
222    int  tx() const             { return mLeft; }
223    int  ty() const             { return mTop; }
224
225protected:
226    const GraphicPlane& graphicPlane(int dpy) const;
227          GraphicPlane& graphicPlane(int dpy);
228
229          void clearWithOpenGL(const Region& clip, GLclampf r, GLclampf g,
230                               GLclampf b, GLclampf alpha) const;
231          void clearWithOpenGL(const Region& clip) const;
232          void drawWithOpenGL(const Region& clip, const Texture& texture) const;
233
234          // these must be called from the post/drawing thread
235          void setBufferCrop(const Rect& crop);
236          void setBufferTransform(uint32_t transform);
237
238                sp<SurfaceFlinger> mFlinger;
239                uint32_t        mFlags;
240
241                // post/drawing thread
242                Rect mBufferCrop;
243                uint32_t mBufferTransform;
244
245                // cached during validateVisibility()
246                bool            mNeedsFiltering;
247                int32_t         mOrientation;
248                GLfloat         mVertices[4][2];
249                Rect            mTransformedBounds;
250                int             mLeft;
251                int             mTop;
252
253                // these are protected by an external lock
254                State           mCurrentState;
255                State           mDrawingState;
256    volatile    int32_t         mTransactionFlags;
257
258                // don't change, don't need a lock
259                bool            mPremultipliedAlpha;
260                String8         mName;
261    mutable     bool            mDebug;
262
263
264                // atomic
265    volatile    int32_t         mInvalidate;
266
267
268protected:
269    virtual ~LayerBase();
270
271private:
272    LayerBase(const LayerBase& rhs);
273};
274
275
276// ---------------------------------------------------------------------------
277
278class LayerBaseClient : public LayerBase
279{
280public:
281    class Surface;
282
283            LayerBaseClient(SurfaceFlinger* flinger, DisplayID display,
284                        const sp<Client>& client);
285    virtual ~LayerBaseClient();
286
287            sp<Surface> getSurface();
288    virtual sp<Surface> createSurface() const;
289    virtual sp<LayerBaseClient> getLayerBaseClient() const {
290        return const_cast<LayerBaseClient*>(this); }
291    virtual const char* getTypeId() const { return "LayerBaseClient"; }
292
293    uint32_t getIdentity() const { return mIdentity; }
294
295    class Surface : public BnSurface  {
296    public:
297        int32_t getIdentity() const { return mIdentity; }
298
299    protected:
300        Surface(const sp<SurfaceFlinger>& flinger, int identity,
301                const sp<LayerBaseClient>& owner);
302        virtual ~Surface();
303        virtual status_t onTransact(uint32_t code, const Parcel& data,
304                Parcel* reply, uint32_t flags);
305        sp<LayerBaseClient> getOwner() const;
306
307    private:
308        virtual sp<GraphicBuffer> requestBuffer(int bufferIdx,
309                uint32_t w, uint32_t h, uint32_t format, uint32_t usage);
310        virtual status_t setBufferCount(int bufferCount);
311
312    protected:
313        friend class LayerBaseClient;
314        sp<SurfaceFlinger>  mFlinger;
315        int32_t             mIdentity;
316        wp<LayerBaseClient> mOwner;
317    };
318
319    friend class Surface;
320
321protected:
322    virtual void dump(String8& result, char* scratch, size_t size) const;
323    virtual void shortDump(String8& result, char* scratch, size_t size) const;
324
325private:
326    mutable Mutex mLock;
327    mutable wp<Surface> mClientSurface;
328    const wp<Client> mClientRef;
329    // only read
330    const uint32_t mIdentity;
331    static int32_t sIdentity;
332};
333
334// ---------------------------------------------------------------------------
335
336}; // namespace android
337
338#endif // ANDROID_LAYER_BASE_H
339