The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 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 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 23 | #include <utils/Atomic.h> |
| 24 | #include <utils/Errors.h> |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 25 | #include <utils/KeyedVector.h> |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 26 | #include <utils/RefBase.h> |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 27 | #include <utils/SortedVector.h> |
| 28 | #include <utils/threads.h> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 29 | |
Mathias Agopian | a1e6bc8 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 30 | #include <binder/BinderService.h> |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 31 | #include <binder/IMemory.h> |
Mathias Agopian | 375f563 | 2009-06-15 18:24:59 -0700 | [diff] [blame] | 32 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 33 | #include <ui/PixelFormat.h> |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 34 | #include <surfaceflinger/IGraphicBufferAlloc.h> |
Mathias Agopian | 9cce325 | 2010-02-09 17:46:37 -0800 | [diff] [blame] | 35 | #include <surfaceflinger/ISurfaceComposer.h> |
Mathias Agopian | 7e27f05 | 2010-05-28 14:22:23 -0700 | [diff] [blame] | 36 | #include <surfaceflinger/ISurfaceComposerClient.h> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 37 | |
| 38 | #include "Barrier.h" |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 39 | #include "Layer.h" |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 40 | |
Mathias Agopian | f1d8e87 | 2009-04-20 19:39:12 -0700 | [diff] [blame] | 41 | #include "MessageQueue.h" |
| 42 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 43 | namespace android { |
| 44 | |
| 45 | // --------------------------------------------------------------------------- |
| 46 | |
| 47 | class Client; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 48 | class DisplayHardware; |
| 49 | class FreezeLock; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 50 | class Layer; |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 51 | class LayerDim; |
Mathias Agopian | a67932f | 2011-04-20 14:20:59 -0700 | [diff] [blame] | 52 | struct surface_flinger_cblk_t; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 53 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 54 | #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) |
| 55 | #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) |
| 56 | |
| 57 | // --------------------------------------------------------------------------- |
| 58 | |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 59 | class Client : public BnSurfaceComposerClient |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 60 | { |
| 61 | public: |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 62 | Client(const sp<SurfaceFlinger>& flinger); |
| 63 | ~Client(); |
| 64 | |
| 65 | status_t initCheck() const; |
| 66 | |
| 67 | // protected by SurfaceFlinger::mStateLock |
Mathias Agopian | 4f11374 | 2011-05-03 16:21:41 -0700 | [diff] [blame] | 68 | size_t attachLayer(const sp<LayerBaseClient>& layer); |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 69 | void detachLayer(const LayerBaseClient* layer); |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 70 | sp<LayerBaseClient> getLayerUser(int32_t i) const; |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 71 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 72 | private: |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 73 | // ISurfaceComposerClient interface |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 74 | virtual sp<ISurface> createSurface( |
Mathias Agopian | 0ef4e15 | 2011-04-20 14:19:32 -0700 | [diff] [blame] | 75 | surface_data_t* params, const String8& name, |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 76 | DisplayID display, uint32_t w, uint32_t h,PixelFormat format, |
| 77 | uint32_t flags); |
| 78 | virtual status_t destroySurface(SurfaceID surfaceId); |
Mathias Agopian | a67932f | 2011-04-20 14:20:59 -0700 | [diff] [blame] | 79 | virtual status_t onTransact( |
| 80 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 81 | |
Mathias Agopian | 4f11374 | 2011-05-03 16:21:41 -0700 | [diff] [blame] | 82 | // constant |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 83 | sp<SurfaceFlinger> mFlinger; |
Mathias Agopian | 4f11374 | 2011-05-03 16:21:41 -0700 | [diff] [blame] | 84 | |
| 85 | // protected by mLock |
| 86 | DefaultKeyedVector< size_t, wp<LayerBaseClient> > mLayers; |
| 87 | size_t mNameGenerator; |
| 88 | |
| 89 | // thread-safe |
| 90 | mutable Mutex mLock; |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 91 | }; |
| 92 | |
Jamie Gennis | 9a78c90 | 2011-01-12 18:30:40 -0800 | [diff] [blame] | 93 | class GraphicBufferAlloc : public BnGraphicBufferAlloc |
| 94 | { |
| 95 | public: |
| 96 | GraphicBufferAlloc(); |
| 97 | virtual ~GraphicBufferAlloc(); |
Jamie Gennis | 9a78c90 | 2011-01-12 18:30:40 -0800 | [diff] [blame] | 98 | virtual sp<GraphicBuffer> createGraphicBuffer(uint32_t w, uint32_t h, |
Mathias Agopian | d9e8c64 | 2011-07-01 14:53:49 -0700 | [diff] [blame] | 99 | PixelFormat format, uint32_t usage, status_t* error); |
Jamie Gennis | 9a78c90 | 2011-01-12 18:30:40 -0800 | [diff] [blame] | 100 | }; |
| 101 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 102 | // --------------------------------------------------------------------------- |
| 103 | |
| 104 | class GraphicPlane |
| 105 | { |
| 106 | public: |
| 107 | static status_t orientationToTransfrom(int orientation, int w, int h, |
| 108 | Transform* tr); |
| 109 | |
| 110 | GraphicPlane(); |
| 111 | ~GraphicPlane(); |
| 112 | |
| 113 | bool initialized() const; |
| 114 | |
| 115 | void setDisplayHardware(DisplayHardware *); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 116 | status_t setOrientation(int orientation); |
Mathias Agopian | 0d1318b | 2009-03-27 17:58:20 -0700 | [diff] [blame] | 117 | int getOrientation() const { return mOrientation; } |
Mathias Agopian | 2b92d89 | 2010-02-08 15:49:35 -0800 | [diff] [blame] | 118 | int getWidth() const; |
| 119 | int getHeight() const; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 120 | |
| 121 | const DisplayHardware& displayHardware() const; |
Mathias Agopian | 59119e6 | 2010-10-11 12:37:43 -0700 | [diff] [blame] | 122 | DisplayHardware& editDisplayHardware(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 123 | const Transform& transform() const; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 124 | EGLDisplay getEGLDisplay() const; |
| 125 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 126 | private: |
| 127 | GraphicPlane(const GraphicPlane&); |
| 128 | GraphicPlane operator = (const GraphicPlane&); |
| 129 | |
| 130 | DisplayHardware* mHw; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 131 | Transform mGlobalTransform; |
Mathias Agopian | 2b92d89 | 2010-02-08 15:49:35 -0800 | [diff] [blame] | 132 | Transform mDisplayTransform; |
Mathias Agopian | 0d1318b | 2009-03-27 17:58:20 -0700 | [diff] [blame] | 133 | int mOrientation; |
Mathias Agopian | 2b92d89 | 2010-02-08 15:49:35 -0800 | [diff] [blame] | 134 | float mDisplayWidth; |
| 135 | float mDisplayHeight; |
| 136 | int mWidth; |
| 137 | int mHeight; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 138 | }; |
| 139 | |
| 140 | // --------------------------------------------------------------------------- |
| 141 | |
| 142 | enum { |
| 143 | eTransactionNeeded = 0x01, |
| 144 | eTraversalNeeded = 0x02 |
| 145 | }; |
| 146 | |
Mathias Agopian | a1e6bc8 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 147 | class SurfaceFlinger : |
| 148 | public BinderService<SurfaceFlinger>, |
| 149 | public BnSurfaceComposer, |
Mathias Agopian | 1f339ff | 2011-07-01 17:08:43 -0700 | [diff] [blame] | 150 | public IBinder::DeathRecipient, |
Mathias Agopian | a1e6bc8 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 151 | protected Thread |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 152 | { |
| 153 | public: |
Mathias Agopian | a1e6bc8 | 2010-07-14 18:41:18 -0700 | [diff] [blame] | 154 | static char const* getServiceName() { return "SurfaceFlinger"; } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 155 | |
| 156 | SurfaceFlinger(); |
| 157 | virtual ~SurfaceFlinger(); |
| 158 | void init(); |
| 159 | |
| 160 | virtual status_t onTransact( |
| 161 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
| 162 | |
| 163 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 164 | |
| 165 | // ISurfaceComposer interface |
Mathias Agopian | 7e27f05 | 2010-05-28 14:22:23 -0700 | [diff] [blame] | 166 | virtual sp<ISurfaceComposerClient> createConnection(); |
Jamie Gennis | 9a78c90 | 2011-01-12 18:30:40 -0800 | [diff] [blame] | 167 | virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc(); |
Mathias Agopian | 7303c6b | 2009-07-02 18:11:53 -0700 | [diff] [blame] | 168 | virtual sp<IMemoryHeap> getCblk() const; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 169 | virtual void bootFinished(); |
Jamie Gennis | b8d69a5 | 2011-10-10 15:48:06 -0700 | [diff] [blame^] | 170 | virtual void setTransactionState(const Vector<ComposerState>& state, |
| 171 | int orientation); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 172 | virtual status_t freezeDisplay(DisplayID dpy, uint32_t flags); |
| 173 | virtual status_t unfreezeDisplay(DisplayID dpy, uint32_t flags); |
Mathias Agopian | c08731e | 2009-03-27 18:11:38 -0700 | [diff] [blame] | 174 | virtual int setOrientation(DisplayID dpy, int orientation, uint32_t flags); |
Jamie Gennis | 582270d | 2011-08-17 18:19:00 -0700 | [diff] [blame] | 175 | virtual bool authenticateSurfaceTexture(const sp<ISurfaceTexture>& surface) const; |
Mathias Agopian | bf2c6a6 | 2010-12-10 16:22:31 -0800 | [diff] [blame] | 176 | |
| 177 | virtual status_t captureScreen(DisplayID dpy, |
| 178 | sp<IMemoryHeap>* heap, |
| 179 | uint32_t* width, uint32_t* height, |
| 180 | PixelFormat* format, uint32_t reqWidth, uint32_t reqHeight, |
| 181 | uint32_t minLayerZ, uint32_t maxLayerZ); |
| 182 | |
Mathias Agopian | 59119e6 | 2010-10-11 12:37:43 -0700 | [diff] [blame] | 183 | virtual status_t turnElectronBeamOff(int32_t mode); |
Mathias Agopian | 9daa5c9 | 2010-10-12 16:05:48 -0700 | [diff] [blame] | 184 | virtual status_t turnElectronBeamOn(int32_t mode); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 185 | |
| 186 | void screenReleased(DisplayID dpy); |
| 187 | void screenAcquired(DisplayID dpy); |
| 188 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 189 | status_t removeLayer(const sp<LayerBase>& layer); |
| 190 | status_t addLayer(const sp<LayerBase>& layer); |
| 191 | status_t invalidateLayerVisibility(const sp<LayerBase>& layer); |
Mathias Agopian | ad456f9 | 2011-01-13 17:53:01 -0800 | [diff] [blame] | 192 | void invalidateHwcGeometry(); |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 193 | |
| 194 | sp<Layer> getLayer(const sp<ISurface>& sur) const; |
| 195 | |
Jamie Gennis | 9575f60 | 2011-10-07 14:51:16 -0700 | [diff] [blame] | 196 | GLuint getProtectedTexName() const { return mProtectedTexName; } |
| 197 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 198 | private: |
Mathias Agopian | 1f339ff | 2011-07-01 17:08:43 -0700 | [diff] [blame] | 199 | // DeathRecipient interface |
| 200 | virtual void binderDied(const wp<IBinder>& who); |
| 201 | |
| 202 | private: |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 203 | friend class Client; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 204 | friend class LayerBase; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 205 | friend class LayerBaseClient; |
| 206 | friend class Layer; |
Mathias Agopian | 945ebbf | 2009-06-18 18:48:39 -0700 | [diff] [blame] | 207 | friend class LayerDim; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 208 | |
Mathias Agopian | 0ef4e15 | 2011-04-20 14:19:32 -0700 | [diff] [blame] | 209 | sp<ISurface> createSurface( |
Mathias Agopian | 7e27f05 | 2010-05-28 14:22:23 -0700 | [diff] [blame] | 210 | ISurfaceComposerClient::surface_data_t* params, |
Mathias Agopian | 0ef4e15 | 2011-04-20 14:19:32 -0700 | [diff] [blame] | 211 | const String8& name, |
| 212 | const sp<Client>& client, |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 213 | DisplayID display, uint32_t w, uint32_t h, PixelFormat format, |
| 214 | uint32_t flags); |
| 215 | |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 216 | sp<Layer> createNormalSurface( |
Mathias Agopian | f9d9327 | 2009-06-19 17:00:27 -0700 | [diff] [blame] | 217 | const sp<Client>& client, DisplayID display, |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 218 | uint32_t w, uint32_t h, uint32_t flags, |
Mathias Agopian | 1c97d2e | 2009-08-19 17:46:26 -0700 | [diff] [blame] | 219 | PixelFormat& format); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 220 | |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 221 | sp<LayerDim> createDimSurface( |
Mathias Agopian | f9d9327 | 2009-06-19 17:00:27 -0700 | [diff] [blame] | 222 | const sp<Client>& client, DisplayID display, |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 223 | uint32_t w, uint32_t h, uint32_t flags); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 224 | |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 225 | status_t removeSurface(const sp<Client>& client, SurfaceID sid); |
Mathias Agopian | ca4d360 | 2011-05-19 15:38:14 -0700 | [diff] [blame] | 226 | status_t destroySurface(const wp<LayerBaseClient>& layer); |
Mathias Agopian | 698c087 | 2011-06-28 19:09:31 -0700 | [diff] [blame] | 227 | uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 228 | |
Mathias Agopian | f6679fc | 2010-08-10 18:09:09 -0700 | [diff] [blame] | 229 | class LayerVector : public SortedVector< sp<LayerBase> > { |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 230 | public: |
Mathias Agopian | f6679fc | 2010-08-10 18:09:09 -0700 | [diff] [blame] | 231 | LayerVector() { } |
| 232 | LayerVector(const LayerVector& rhs) : SortedVector< sp<LayerBase> >(rhs) { } |
| 233 | virtual int do_compare(const void* lhs, const void* rhs) const { |
| 234 | const sp<LayerBase>& l(*reinterpret_cast<const sp<LayerBase>*>(lhs)); |
| 235 | const sp<LayerBase>& r(*reinterpret_cast<const sp<LayerBase>*>(rhs)); |
| 236 | // sort layers by Z order |
| 237 | uint32_t lz = l->currentState().z; |
| 238 | uint32_t rz = r->currentState().z; |
| 239 | // then by sequence, so we get a stable ordering |
| 240 | return (lz != rz) ? (lz - rz) : (l->sequence - r->sequence); |
| 241 | } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 242 | }; |
| 243 | |
| 244 | struct State { |
| 245 | State() { |
| 246 | orientation = ISurfaceComposer::eOrientationDefault; |
| 247 | freezeDisplay = 0; |
| 248 | } |
| 249 | LayerVector layersSortedByZ; |
| 250 | uint8_t orientation; |
Jeff Brown | 21230c6 | 2011-09-20 15:08:29 -0700 | [diff] [blame] | 251 | uint8_t orientationFlags; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 252 | uint8_t freezeDisplay; |
| 253 | }; |
| 254 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 255 | virtual bool threadLoop(); |
| 256 | virtual status_t readyToRun(); |
| 257 | virtual void onFirstRef(); |
| 258 | |
Andy McFadden | 550a114 | 2009-10-29 10:19:34 -0700 | [diff] [blame] | 259 | public: // hack to work around gcc 4.0.3 bug |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 260 | const GraphicPlane& graphicPlane(int dpy) const; |
| 261 | GraphicPlane& graphicPlane(int dpy); |
Mathias Agopian | e2c2f92 | 2011-10-05 15:00:22 -0700 | [diff] [blame] | 262 | void signalEvent(); |
| 263 | void repaintEverything(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 264 | |
Andy McFadden | 2944a2b | 2009-09-21 14:33:20 -0700 | [diff] [blame] | 265 | private: |
Mathias Agopian | e2c2f92 | 2011-10-05 15:00:22 -0700 | [diff] [blame] | 266 | void waitForEvent(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 267 | void handleConsoleEvents(); |
| 268 | void handleTransaction(uint32_t transactionFlags); |
Mathias Agopian | ca4d360 | 2011-05-19 15:38:14 -0700 | [diff] [blame] | 269 | void handleTransactionLocked(uint32_t transactionFlags); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 270 | |
| 271 | void computeVisibleRegions( |
Mathias Agopian | 1bbafb9 | 2011-03-11 16:54:47 -0800 | [diff] [blame] | 272 | const LayerVector& currentLayers, |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 273 | Region& dirtyRegion, |
| 274 | Region& wormholeRegion); |
| 275 | |
| 276 | void handlePageFlip(); |
| 277 | bool lockPageFlip(const LayerVector& currentLayers); |
| 278 | void unlockPageFlip(const LayerVector& currentLayers); |
Mathias Agopian | a350ff9 | 2010-08-10 17:14:02 -0700 | [diff] [blame] | 279 | void handleWorkList(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 280 | void handleRepaint(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 281 | void postFramebuffer(); |
Mathias Agopian | 9c6e297 | 2011-09-20 17:21:56 -0700 | [diff] [blame] | 282 | void setupHardwareComposer(Region& dirtyInOut); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 283 | void composeSurfaces(const Region& dirty); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 284 | |
| 285 | |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 286 | ssize_t addClientLayer(const sp<Client>& client, |
| 287 | const sp<LayerBaseClient>& lbc); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 288 | status_t addLayer_l(const sp<LayerBase>& layer); |
| 289 | status_t removeLayer_l(const sp<LayerBase>& layer); |
Mathias Agopian | 9a11206 | 2009-04-17 19:36:26 -0700 | [diff] [blame] | 290 | status_t purgatorizeLayer_l(const sp<LayerBase>& layer); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 291 | |
| 292 | uint32_t getTransactionFlags(uint32_t flags); |
Mathias Agopian | dea20b1 | 2011-05-03 17:04:02 -0700 | [diff] [blame] | 293 | uint32_t peekTransactionFlags(uint32_t flags); |
Mathias Agopian | bb64124 | 2010-05-18 17:06:55 -0700 | [diff] [blame] | 294 | uint32_t setTransactionFlags(uint32_t flags); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 295 | void commitTransaction(); |
| 296 | |
| 297 | |
Mathias Agopian | 74c40c0 | 2010-09-29 13:02:36 -0700 | [diff] [blame] | 298 | status_t captureScreenImplLocked(DisplayID dpy, |
| 299 | sp<IMemoryHeap>* heap, |
| 300 | uint32_t* width, uint32_t* height, PixelFormat* format, |
Mathias Agopian | bf2c6a6 | 2010-12-10 16:22:31 -0800 | [diff] [blame] | 301 | uint32_t reqWidth, uint32_t reqHeight, |
| 302 | uint32_t minLayerZ, uint32_t maxLayerZ); |
Mathias Agopian | 74c40c0 | 2010-09-29 13:02:36 -0700 | [diff] [blame] | 303 | |
Mathias Agopian | abd671a | 2010-10-14 14:54:06 -0700 | [diff] [blame] | 304 | status_t turnElectronBeamOffImplLocked(int32_t mode); |
| 305 | status_t turnElectronBeamOnImplLocked(int32_t mode); |
Mathias Agopian | 9daa5c9 | 2010-10-12 16:05:48 -0700 | [diff] [blame] | 306 | status_t electronBeamOffAnimationImplLocked(); |
| 307 | status_t electronBeamOnAnimationImplLocked(); |
| 308 | status_t renderScreenToTextureLocked(DisplayID dpy, |
| 309 | GLuint* textureName, GLfloat* uOut, GLfloat* vOut); |
Mathias Agopian | 59119e6 | 2010-10-11 12:37:43 -0700 | [diff] [blame] | 310 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 311 | friend class FreezeLock; |
| 312 | sp<FreezeLock> getFreezeLock() const; |
Mathias Agopian | 0408772 | 2009-12-01 17:23:28 -0800 | [diff] [blame] | 313 | inline void incFreezeCount() { |
| 314 | if (mFreezeCount == 0) |
| 315 | mFreezeDisplayTime = 0; |
| 316 | mFreezeCount++; |
| 317 | } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 318 | inline void decFreezeCount() { if (mFreezeCount > 0) mFreezeCount--; } |
| 319 | inline bool hasFreezeRequest() const { return mFreezeDisplay; } |
| 320 | inline bool isFrozen() const { |
Mathias Agopian | 3330b20 | 2009-10-05 17:07:12 -0700 | [diff] [blame] | 321 | return (mFreezeDisplay || mFreezeCount>0) && mBootFinished; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | |
| 325 | void debugFlashRegions(); |
| 326 | void debugShowFPS() const; |
| 327 | void drawWormhole() const; |
| 328 | |
Mathias Agopian | f1d8e87 | 2009-04-20 19:39:12 -0700 | [diff] [blame] | 329 | |
| 330 | mutable MessageQueue mEventQueue; |
Mathias Agopian | bb64124 | 2010-05-18 17:06:55 -0700 | [diff] [blame] | 331 | |
| 332 | status_t postMessageAsync(const sp<MessageBase>& msg, |
| 333 | nsecs_t reltime=0, uint32_t flags = 0); |
| 334 | |
| 335 | status_t postMessageSync(const sp<MessageBase>& msg, |
| 336 | nsecs_t reltime=0, uint32_t flags = 0); |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 337 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 338 | // access must be protected by mStateLock |
| 339 | mutable Mutex mStateLock; |
| 340 | State mCurrentState; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 341 | volatile int32_t mTransactionFlags; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 342 | Condition mTransactionCV; |
Mathias Agopian | 76cd4dd | 2011-01-14 17:37:42 -0800 | [diff] [blame] | 343 | SortedVector< sp<LayerBase> > mLayerPurgatory; |
Mathias Agopian | cbb288b | 2009-09-07 16:32:45 -0700 | [diff] [blame] | 344 | bool mResizeTransationPending; |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 345 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 346 | // protected by mStateLock (but we could use another lock) |
Mathias Agopian | 96f0819 | 2010-06-02 23:28:45 -0700 | [diff] [blame] | 347 | GraphicPlane mGraphicPlanes[1]; |
| 348 | bool mLayersRemoved; |
Mathias Agopian | b7e930d | 2010-06-01 15:12:58 -0700 | [diff] [blame] | 349 | DefaultKeyedVector< wp<IBinder>, wp<Layer> > mLayerMap; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 350 | |
| 351 | // constant members (no synchronization needed for access) |
Mathias Agopian | 7303c6b | 2009-07-02 18:11:53 -0700 | [diff] [blame] | 352 | sp<IMemoryHeap> mServerHeap; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 353 | surface_flinger_cblk_t* mServerCblk; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 354 | GLuint mWormholeTexName; |
Jamie Gennis | 9575f60 | 2011-10-07 14:51:16 -0700 | [diff] [blame] | 355 | GLuint mProtectedTexName; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 356 | nsecs_t mBootTime; |
Mathias Agopian | 99b4984 | 2011-06-27 16:05:52 -0700 | [diff] [blame] | 357 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 358 | // Can only accessed from the main thread, these members |
| 359 | // don't need synchronization |
Mathias Agopian | 1bbafb9 | 2011-03-11 16:54:47 -0800 | [diff] [blame] | 360 | State mDrawingState; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 361 | Region mDirtyRegion; |
Mathias Agopian | 9701122 | 2009-07-28 10:57:27 -0700 | [diff] [blame] | 362 | Region mDirtyRegionRemovedLayer; |
Mathias Agopian | 0656a68 | 2011-09-20 17:22:44 -0700 | [diff] [blame] | 363 | Region mSwapRegion; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 364 | Region mWormholeRegion; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 365 | bool mVisibleRegionsDirty; |
Mathias Agopian | a350ff9 | 2010-08-10 17:14:02 -0700 | [diff] [blame] | 366 | bool mHwWorkListDirty; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 367 | bool mFreezeDisplay; |
Mathias Agopian | abd671a | 2010-10-14 14:54:06 -0700 | [diff] [blame] | 368 | int32_t mElectronBeamAnimationMode; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 369 | int32_t mFreezeCount; |
| 370 | nsecs_t mFreezeDisplayTime; |
Mathias Agopian | 4da7519 | 2010-08-10 17:19:56 -0700 | [diff] [blame] | 371 | Vector< sp<LayerBase> > mVisibleLayersSortedByZ; |
| 372 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 373 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 374 | // don't use a lock for these, we don't care |
| 375 | int mDebugRegion; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 376 | int mDebugBackground; |
Mathias Agopian | 8afb7e3 | 2011-08-15 20:44:40 -0700 | [diff] [blame] | 377 | int mDebugDDMS; |
Mathias Agopian | 73d3ba9 | 2010-09-22 18:58:01 -0700 | [diff] [blame] | 378 | int mDebugDisableHWC; |
Mathias Agopian | a458364 | 2011-08-23 18:03:18 -0700 | [diff] [blame] | 379 | int mDebugDisableTransformHint; |
Mathias Agopian | 9795c42 | 2009-08-26 16:36:26 -0700 | [diff] [blame] | 380 | volatile nsecs_t mDebugInSwapBuffers; |
| 381 | nsecs_t mLastSwapBufferTime; |
| 382 | volatile nsecs_t mDebugInTransaction; |
| 383 | nsecs_t mLastTransactionTime; |
Mathias Agopian | 3330b20 | 2009-10-05 17:07:12 -0700 | [diff] [blame] | 384 | bool mBootFinished; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 385 | |
| 386 | // these are thread safe |
| 387 | mutable Barrier mReadyToRunBarrier; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 388 | |
Mathias Agopian | ca4d360 | 2011-05-19 15:38:14 -0700 | [diff] [blame] | 389 | |
| 390 | // protected by mDestroyedLayerLock; |
| 391 | mutable Mutex mDestroyedLayerLock; |
| 392 | Vector<LayerBase const *> mDestroyedLayers; |
| 393 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 394 | // atomic variables |
| 395 | enum { |
| 396 | eConsoleReleased = 1, |
| 397 | eConsoleAcquired = 2 |
| 398 | }; |
| 399 | volatile int32_t mConsoleSignals; |
| 400 | |
| 401 | // only written in the main thread, only read in other threads |
| 402 | volatile int32_t mSecureFrameBuffer; |
| 403 | }; |
| 404 | |
| 405 | // --------------------------------------------------------------------------- |
| 406 | |
| 407 | class FreezeLock : public LightRefBase<FreezeLock> { |
| 408 | SurfaceFlinger* mFlinger; |
| 409 | public: |
| 410 | FreezeLock(SurfaceFlinger* flinger) |
| 411 | : mFlinger(flinger) { |
| 412 | mFlinger->incFreezeCount(); |
| 413 | } |
| 414 | ~FreezeLock() { |
| 415 | mFlinger->decFreezeCount(); |
| 416 | } |
| 417 | }; |
| 418 | |
| 419 | // --------------------------------------------------------------------------- |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 420 | }; // namespace android |
| 421 | |
| 422 | #endif // ANDROID_SURFACE_FLINGER_H |