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