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#include <ui/Overlay.h>
31
32#include <surfaceflinger/ISurfaceComposerClient.h>
33#include <private/surfaceflinger/SharedBufferStack.h>
34#include <private/surfaceflinger/LayerState.h>
35
36#include <pixelflinger/pixelflinger.h>
37
38#include "DisplayHardware/DisplayHardware.h"
39#include "Transform.h"
40
41namespace android {
42
43// ---------------------------------------------------------------------------
44
45class DisplayHardware;
46class Client;
47class GraphicBuffer;
48class GraphicPlane;
49class LayerBaseClient;
50class SurfaceFlinger;
51class Texture;
52
53// ---------------------------------------------------------------------------
54
55class LayerBase : public RefBase
56{
57    static int32_t sSequence;
58
59public:
60            LayerBase(SurfaceFlinger* flinger, DisplayID display);
61
62    DisplayID           dpy;
63    mutable bool        contentDirty;
64            Region      visibleRegionScreen;
65            Region      transparentRegionScreen;
66            Region      coveredRegionScreen;
67            int32_t     sequence;
68
69            struct State {
70                uint32_t        w;
71                uint32_t        h;
72                uint32_t        requested_w;
73                uint32_t        requested_h;
74                uint32_t        z;
75                uint8_t         alpha;
76                uint8_t         flags;
77                uint8_t         reserved[2];
78                int32_t         sequence;   // changes when visible regions can change
79                uint32_t        tint;
80                Transform       transform;
81                Region          transparentRegion;
82            };
83
84            void setName(const String8& name);
85            String8 getName() const;
86
87            // modify current state
88            bool setPosition(int32_t x, int32_t y);
89            bool setLayer(uint32_t z);
90            bool setSize(uint32_t w, uint32_t h);
91            bool setAlpha(uint8_t alpha);
92            bool setMatrix(const layer_state_t::matrix22_t& matrix);
93            bool setTransparentRegionHint(const Region& opaque);
94            bool setFlags(uint8_t flags, uint8_t mask);
95
96            void commitTransaction();
97            bool requestTransaction();
98            void forceVisibilityTransaction();
99
100            uint32_t getTransactionFlags(uint32_t flags);
101            uint32_t setTransactionFlags(uint32_t flags);
102
103            Rect visibleBounds() const;
104            void drawRegion(const Region& reg) const;
105
106            void invalidate();
107
108    virtual sp<LayerBaseClient> getLayerBaseClient() const { return 0; }
109
110    virtual const char* getTypeId() const { return "LayerBase"; }
111
112    /**
113     * draw - performs some global clipping optimizations
114     * and calls onDraw().
115     * Typically this method is not overridden, instead implement onDraw()
116     * to perform the actual drawing.
117     */
118    virtual void draw(const Region& clip) const;
119    virtual void drawForSreenShot() const;
120
121    /**
122     * bypass mode
123     */
124    virtual bool setBypass(bool enable) { return false; }
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 with the state lock when the surface is removed from the
200     *  current list */
201    virtual void onRemoved() { };
202
203    /** always call base class first */
204    virtual void dump(String8& result, char* scratch, size_t size) const;
205
206
207    enum { // flags for doTransaction()
208        eVisibleRegion      = 0x00000002,
209    };
210
211
212    inline  const State&    drawingState() const    { return mDrawingState; }
213    inline  const State&    currentState() const    { return mCurrentState; }
214    inline  State&          currentState()          { return mCurrentState; }
215
216    int32_t  getOrientation() const { return mOrientation; }
217    int  tx() const             { return mLeft; }
218    int  ty() const             { return mTop; }
219
220protected:
221    const GraphicPlane& graphicPlane(int dpy) const;
222          GraphicPlane& graphicPlane(int dpy);
223
224          void clearWithOpenGL(const Region& clip, GLclampf r, GLclampf g,
225                               GLclampf b, GLclampf alpha) const;
226          void clearWithOpenGL(const Region& clip) const;
227          void drawWithOpenGL(const Region& clip, const Texture& texture) const;
228
229          // these must be called from the post/drawing thread
230          void setBufferCrop(const Rect& crop);
231          void setBufferTransform(uint32_t transform);
232
233                sp<SurfaceFlinger> mFlinger;
234                uint32_t        mFlags;
235
236                // post/drawing thread
237                Rect mBufferCrop;
238                uint32_t mBufferTransform;
239
240                // cached during validateVisibility()
241                bool            mNeedsFiltering;
242                int32_t         mOrientation;
243                GLfloat         mVertices[4][2];
244                Rect            mTransformedBounds;
245                int             mLeft;
246                int             mTop;
247
248                // these are protected by an external lock
249                State           mCurrentState;
250                State           mDrawingState;
251    volatile    int32_t         mTransactionFlags;
252
253                // don't change, don't need a lock
254                bool            mPremultipliedAlpha;
255                String8         mName;
256    mutable     bool            mDebug;
257
258
259                // atomic
260    volatile    int32_t         mInvalidate;
261
262
263public:
264    // called from class SurfaceFlinger
265    virtual ~LayerBase();
266
267private:
268    LayerBase(const LayerBase& rhs);
269};
270
271
272// ---------------------------------------------------------------------------
273
274class LayerBaseClient : public LayerBase
275{
276public:
277    class Surface;
278
279            LayerBaseClient(SurfaceFlinger* flinger, DisplayID display,
280                        const sp<Client>& client);
281    virtual ~LayerBaseClient();
282
283            sp<Surface> getSurface();
284    virtual sp<Surface> createSurface() const;
285    virtual sp<LayerBaseClient> getLayerBaseClient() const {
286        return const_cast<LayerBaseClient*>(this); }
287    virtual const char* getTypeId() const { return "LayerBaseClient"; }
288
289    uint32_t getIdentity() const { return mIdentity; }
290
291    class Surface : public BnSurface  {
292    public:
293        int32_t getIdentity() const { return mIdentity; }
294
295    protected:
296        Surface(const sp<SurfaceFlinger>& flinger, int identity,
297                const sp<LayerBaseClient>& owner);
298        virtual ~Surface();
299        virtual status_t onTransact(uint32_t code, const Parcel& data,
300                Parcel* reply, uint32_t flags);
301        sp<LayerBaseClient> getOwner() const;
302
303    private:
304        virtual sp<GraphicBuffer> requestBuffer(int bufferIdx,
305                uint32_t w, uint32_t h, uint32_t format, uint32_t usage);
306        virtual status_t setBufferCount(int bufferCount);
307
308        virtual status_t registerBuffers(const ISurface::BufferHeap& buffers);
309        virtual void postBuffer(ssize_t offset);
310        virtual void unregisterBuffers();
311        virtual sp<OverlayRef> createOverlay(uint32_t w, uint32_t h,
312                int32_t format, int32_t orientation);
313
314    protected:
315        friend class LayerBaseClient;
316        sp<SurfaceFlinger>  mFlinger;
317        int32_t             mIdentity;
318        wp<LayerBaseClient> mOwner;
319    };
320
321    friend class Surface;
322
323protected:
324    virtual void dump(String8& result, char* scratch, size_t size) const;
325
326private:
327    mutable Mutex mLock;
328    mutable wp<Surface> mClientSurface;
329    const wp<Client> mClientRef;
330    // only read
331    const uint32_t mIdentity;
332    static int32_t sIdentity;
333};
334
335// ---------------------------------------------------------------------------
336
337}; // namespace android
338
339#endif // ANDROID_LAYER_BASE_H
340