SurfaceFlinger.h revision 81bac09fa6b01dd1495644d9c825c3666762fced 
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 <stdint.h>
21#include <sys/types.h>
22
23#include <utils/SortedVector.h>
24#include <utils/KeyedVector.h>
25#include <utils/threads.h>
26#include <utils/Atomic.h>
27#include <utils/Errors.h>
28#include <utils/RefBase.h>
29
30#include <binder/IMemory.h>
31#include <binder/Permission.h>
32
33#include <ui/PixelFormat.h>
34#include <surfaceflinger/ISurfaceComposer.h>
35#include <surfaceflinger/ISurfaceComposerClient.h>
36
37#include "Barrier.h"
38#include "Layer.h"
39
40#include "MessageQueue.h"
41
42struct copybit_device_t;
43struct overlay_device_t;
44
45namespace android {
46
47// ---------------------------------------------------------------------------
48
49class Client;
50class DisplayHardware;
51class FreezeLock;
52class Layer;
53class LayerBlur;
54class LayerDim;
55class LayerBuffer;
56
57#define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
58#define UNLIKELY( exp )     (__builtin_expect( (exp) != 0, false ))
59
60// ---------------------------------------------------------------------------
61
62class Client : public BnSurfaceComposerClient
63{
64public:
65        Client(const sp<SurfaceFlinger>& flinger);
66        ~Client();
67
68    status_t initCheck() const;
69
70    // protected by SurfaceFlinger::mStateLock
71    ssize_t attachLayer(const sp<LayerBaseClient>& layer);
72    void detachLayer(const LayerBaseClient* layer);
73    sp<LayerBaseClient> getLayerUser(int32_t i) const;
74
75private:
76
77    // ISurfaceComposerClient interface
78    virtual sp<IMemoryHeap> getControlBlock() const;
79    virtual ssize_t getTokenForSurface(const sp<ISurface>& sur) const;
80    virtual sp<ISurface> createSurface(
81            surface_data_t* params, int pid, const String8& name,
82            DisplayID display, uint32_t w, uint32_t h,PixelFormat format,
83            uint32_t flags);
84    virtual status_t destroySurface(SurfaceID surfaceId);
85    virtual status_t setState(int32_t count, const layer_state_t* states);
86
87    DefaultKeyedVector< size_t, wp<LayerBaseClient> > mLayers;
88    sp<SurfaceFlinger> mFlinger;
89    int32_t mNameGenerator;
90};
91
92class UserClient : public BnSurfaceComposerClient
93{
94public:
95    // pointer to this client's control block
96    SharedClient* ctrlblk;
97
98public:
99        UserClient(const sp<SurfaceFlinger>& flinger);
100        ~UserClient();
101
102    status_t initCheck() const;
103
104    // protected by SurfaceFlinger::mStateLock
105    void detachLayer(const Layer* layer);
106
107private:
108
109    // ISurfaceComposerClient interface
110    virtual sp<IMemoryHeap> getControlBlock() const;
111    virtual ssize_t getTokenForSurface(const sp<ISurface>& sur) const;
112    virtual sp<ISurface> createSurface(
113            surface_data_t* params, int pid, const String8& name,
114            DisplayID display, uint32_t w, uint32_t h,PixelFormat format,
115            uint32_t flags);
116    virtual status_t destroySurface(SurfaceID surfaceId);
117    virtual status_t setState(int32_t count, const layer_state_t* states);
118
119    // atomic-ops
120    mutable volatile int32_t mBitmap;
121
122    sp<IMemoryHeap> mCblkHeap;
123    sp<SurfaceFlinger> mFlinger;
124};
125
126// ---------------------------------------------------------------------------
127
128class GraphicPlane
129{
130public:
131    static status_t orientationToTransfrom(int orientation, int w, int h,
132            Transform* tr);
133
134                                GraphicPlane();
135                                ~GraphicPlane();
136
137        bool                    initialized() const;
138
139        void                    setDisplayHardware(DisplayHardware *);
140        status_t                setOrientation(int orientation);
141        int                     getOrientation() const { return mOrientation; }
142        int                     getWidth() const;
143        int                     getHeight() const;
144
145        const DisplayHardware&  displayHardware() const;
146        const Transform&        transform() const;
147        EGLDisplay              getEGLDisplay() const;
148
149private:
150                                GraphicPlane(const GraphicPlane&);
151        GraphicPlane            operator = (const GraphicPlane&);
152
153        DisplayHardware*        mHw;
154        Transform               mGlobalTransform;
155        Transform               mDisplayTransform;
156        int                     mOrientation;
157        float                   mDisplayWidth;
158        float                   mDisplayHeight;
159        int                     mWidth;
160        int                     mHeight;
161};
162
163// ---------------------------------------------------------------------------
164
165enum {
166    eTransactionNeeded      = 0x01,
167    eTraversalNeeded        = 0x02
168};
169
170class SurfaceFlinger : public BnSurfaceComposer, protected Thread
171{
172public:
173    static void instantiate();
174    static void shutdown();
175
176                    SurfaceFlinger();
177    virtual         ~SurfaceFlinger();
178            void    init();
179
180    virtual status_t onTransact(
181        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
182
183    virtual status_t dump(int fd, const Vector<String16>& args);
184
185    // ISurfaceComposer interface
186    virtual sp<ISurfaceComposerClient>  createConnection();
187    virtual sp<ISurfaceComposerClient>  createClientConnection();
188    virtual sp<IMemoryHeap>             getCblk() const;
189    virtual void                        bootFinished();
190    virtual void                        openGlobalTransaction();
191    virtual void                        closeGlobalTransaction();
192    virtual status_t                    freezeDisplay(DisplayID dpy, uint32_t flags);
193    virtual status_t                    unfreezeDisplay(DisplayID dpy, uint32_t flags);
194    virtual int                         setOrientation(DisplayID dpy, int orientation, uint32_t flags);
195    virtual void                        signal() const;
196
197            void                        screenReleased(DisplayID dpy);
198            void                        screenAcquired(DisplayID dpy);
199
200            overlay_control_device_t* getOverlayEngine() const;
201
202    status_t removeLayer(const sp<LayerBase>& layer);
203    status_t addLayer(const sp<LayerBase>& layer);
204    status_t invalidateLayerVisibility(const sp<LayerBase>& layer);
205
206    sp<Layer> getLayer(const sp<ISurface>& sur) const;
207
208private:
209    friend class Client;
210    friend class LayerBase;
211    friend class LayerBuffer;
212    friend class LayerBaseClient;
213    friend class LayerBaseClient::Surface;
214    friend class Layer;
215    friend class LayerBlur;
216    friend class LayerDim;
217
218    sp<ISurface> createSurface(const sp<Client>& client,
219            int pid, const String8& name,
220            ISurfaceComposerClient::surface_data_t* params,
221            DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
222            uint32_t flags);
223
224    sp<Layer> createNormalSurface(
225            const sp<Client>& client, DisplayID display,
226            uint32_t w, uint32_t h, uint32_t flags,
227            PixelFormat& format);
228
229    sp<LayerBlur> createBlurSurface(
230            const sp<Client>& client, DisplayID display,
231            uint32_t w, uint32_t h, uint32_t flags);
232
233    sp<LayerDim> createDimSurface(
234            const sp<Client>& client, DisplayID display,
235            uint32_t w, uint32_t h, uint32_t flags);
236
237    sp<LayerBuffer> createPushBuffersSurface(
238            const sp<Client>& client, DisplayID display,
239            uint32_t w, uint32_t h, uint32_t flags);
240
241    status_t removeSurface(const sp<Client>& client, SurfaceID sid);
242    status_t destroySurface(const sp<LayerBaseClient>& layer);
243    status_t setClientState(const sp<Client>& client,
244            int32_t count, const layer_state_t* states);
245
246
247    class LayerVector {
248    public:
249        inline              LayerVector() { }
250                            LayerVector(const LayerVector&);
251        inline size_t       size() const { return layers.size(); }
252        inline sp<LayerBase> const* array() const { return layers.array(); }
253        ssize_t             add(const sp<LayerBase>&, Vector< sp<LayerBase> >::compar_t);
254        ssize_t             remove(const sp<LayerBase>&);
255        ssize_t             reorder(const sp<LayerBase>&, Vector< sp<LayerBase> >::compar_t);
256        ssize_t             indexOf(const sp<LayerBase>& key, size_t guess=0) const;
257        inline sp<LayerBase> operator [] (size_t i) const { return layers[i]; }
258    private:
259        KeyedVector< sp<LayerBase> , size_t> lookup;
260        Vector< sp<LayerBase> >              layers;
261    };
262
263    struct State {
264        State() {
265            orientation = ISurfaceComposer::eOrientationDefault;
266            freezeDisplay = 0;
267        }
268        LayerVector     layersSortedByZ;
269        uint8_t         orientation;
270        uint8_t         orientationType;
271        uint8_t         freezeDisplay;
272    };
273
274    virtual bool        threadLoop();
275    virtual status_t    readyToRun();
276    virtual void        onFirstRef();
277
278public:     // hack to work around gcc 4.0.3 bug
279    const GraphicPlane&     graphicPlane(int dpy) const;
280          GraphicPlane&     graphicPlane(int dpy);
281private:
282
283            void        waitForEvent();
284public:     // hack to work around gcc 4.0.3 bug
285            void        signalEvent();
286private:
287            void        handleConsoleEvents();
288            void        handleTransaction(uint32_t transactionFlags);
289            void        handleTransactionLocked(
290                            uint32_t transactionFlags,
291                            Vector< sp<LayerBase> >& ditchedLayers);
292
293            void        computeVisibleRegions(
294                            LayerVector& currentLayers,
295                            Region& dirtyRegion,
296                            Region& wormholeRegion);
297
298            void        handlePageFlip();
299            bool        lockPageFlip(const LayerVector& currentLayers);
300            void        unlockPageFlip(const LayerVector& currentLayers);
301            void        handleRepaint();
302            void        postFramebuffer();
303            void        composeSurfaces(const Region& dirty);
304            void        unlockClients();
305
306
307            ssize_t     addClientLayer(const sp<Client>& client,
308                    const sp<LayerBaseClient>& lbc);
309            status_t    addLayer_l(const sp<LayerBase>& layer);
310            status_t    removeLayer_l(const sp<LayerBase>& layer);
311            status_t    purgatorizeLayer_l(const sp<LayerBase>& layer);
312
313            uint32_t    getTransactionFlags(uint32_t flags);
314            uint32_t    setTransactionFlags(uint32_t flags);
315            void        commitTransaction();
316
317
318            friend class FreezeLock;
319            sp<FreezeLock> getFreezeLock() const;
320            inline void incFreezeCount() {
321                if (mFreezeCount == 0)
322                    mFreezeDisplayTime = 0;
323                mFreezeCount++;
324            }
325            inline void decFreezeCount() { if (mFreezeCount > 0) mFreezeCount--; }
326            inline bool hasFreezeRequest() const { return mFreezeDisplay; }
327            inline bool isFrozen() const {
328                return (mFreezeDisplay || mFreezeCount>0) && mBootFinished;
329            }
330
331
332            void        debugFlashRegions();
333            void        debugShowFPS() const;
334            void        drawWormhole() const;
335
336
337    mutable     MessageQueue    mEventQueue;
338
339    status_t postMessageAsync(const sp<MessageBase>& msg,
340            nsecs_t reltime=0, uint32_t flags = 0);
341
342    status_t postMessageSync(const sp<MessageBase>& msg,
343            nsecs_t reltime=0, uint32_t flags = 0);
344
345                // access must be protected by mStateLock
346    mutable     Mutex                   mStateLock;
347                State                   mCurrentState;
348                State                   mDrawingState;
349    volatile    int32_t                 mTransactionFlags;
350    volatile    int32_t                 mTransactionCount;
351                Condition               mTransactionCV;
352                bool                    mResizeTransationPending;
353
354                // protected by mStateLock (but we could use another lock)
355                GraphicPlane                mGraphicPlanes[1];
356                bool                        mLayersRemoved;
357                DefaultKeyedVector< wp<IBinder>, wp<Layer> > mLayerMap;
358
359                // constant members (no synchronization needed for access)
360                sp<IMemoryHeap>             mServerHeap;
361                surface_flinger_cblk_t*     mServerCblk;
362                GLuint                      mWormholeTexName;
363                nsecs_t                     mBootTime;
364                Permission                  mHardwareTest;
365                Permission                  mAccessSurfaceFlinger;
366                Permission                  mDump;
367
368                // Can only accessed from the main thread, these members
369                // don't need synchronization
370                Region                      mDirtyRegion;
371                Region                      mDirtyRegionRemovedLayer;
372                Region                      mInvalidRegion;
373                Region                      mWormholeRegion;
374                bool                        mVisibleRegionsDirty;
375                bool                        mDeferReleaseConsole;
376                bool                        mFreezeDisplay;
377                int32_t                     mFreezeCount;
378                nsecs_t                     mFreezeDisplayTime;
379
380                // don't use a lock for these, we don't care
381                int                         mDebugRegion;
382                int                         mDebugBackground;
383                volatile nsecs_t            mDebugInSwapBuffers;
384                nsecs_t                     mLastSwapBufferTime;
385                volatile nsecs_t            mDebugInTransaction;
386                nsecs_t                     mLastTransactionTime;
387                bool                        mBootFinished;
388
389                // these are thread safe
390    mutable     Barrier                     mReadyToRunBarrier;
391
392                // atomic variables
393                enum {
394                    eConsoleReleased = 1,
395                    eConsoleAcquired = 2
396                };
397   volatile     int32_t                     mConsoleSignals;
398
399   // only written in the main thread, only read in other threads
400   volatile     int32_t                     mSecureFrameBuffer;
401};
402
403// ---------------------------------------------------------------------------
404
405class FreezeLock : public LightRefBase<FreezeLock> {
406    SurfaceFlinger* mFlinger;
407public:
408    FreezeLock(SurfaceFlinger* flinger)
409        : mFlinger(flinger) {
410        mFlinger->incFreezeCount();
411    }
412    ~FreezeLock() {
413        mFlinger->decFreezeCount();
414    }
415};
416
417// ---------------------------------------------------------------------------
418}; // namespace android
419
420#endif // ANDROID_SURFACE_FLINGER_H
421