frameworks/base/services/surfaceflinger/SurfaceFlinger.h

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