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 | |
| 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> |
Mathias Agopian | c5b2c0b | 2009-05-19 19:08:10 -0700 | [diff] [blame] | 28 | #include <binder/MemoryDealer.h> |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 29 | #include <utils/RefBase.h> |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 30 | |
| 31 | #include <ui/PixelFormat.h> |
| 32 | #include <ui/ISurfaceComposer.h> |
| 33 | #include <ui/ISurfaceFlingerClient.h> |
| 34 | |
| 35 | #include <private/ui/SharedState.h> |
| 36 | #include <private/ui/LayerState.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" |
| 40 | #include "Tokenizer.h" |
| 41 | |
Mathias Agopian | f1d8e87 | 2009-04-20 19:39:12 -0700 | [diff] [blame] | 42 | #include "MessageQueue.h" |
| 43 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 44 | struct copybit_device_t; |
| 45 | struct overlay_device_t; |
| 46 | |
| 47 | namespace android { |
| 48 | |
| 49 | // --------------------------------------------------------------------------- |
| 50 | |
| 51 | class Client; |
| 52 | class BClient; |
| 53 | class DisplayHardware; |
| 54 | class FreezeLock; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 55 | class Layer; |
| 56 | class LayerBuffer; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 57 | |
| 58 | typedef int32_t ClientID; |
| 59 | |
| 60 | #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) |
| 61 | #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) |
| 62 | |
| 63 | // --------------------------------------------------------------------------- |
| 64 | |
| 65 | class Client |
| 66 | { |
| 67 | public: |
| 68 | Client(ClientID cid, const sp<SurfaceFlinger>& flinger); |
| 69 | ~Client(); |
| 70 | |
| 71 | int32_t generateId(int pid); |
| 72 | void free(int32_t id); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 73 | status_t bindLayer(const sp<LayerBaseClient>& layer, int32_t id); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 74 | |
| 75 | inline bool isValid(int32_t i) const; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 76 | sp<LayerBaseClient> getLayerUser(int32_t i) const; |
| 77 | const Vector< wp<LayerBaseClient> >& getLayers() const { return mLayers; } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 78 | const sp<IMemory>& controlBlockMemory() const { return mCblkMemory; } |
| 79 | void dump(const char* what); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 80 | |
| 81 | // pointer to this client's control block |
| 82 | per_client_cblk_t* ctrlblk; |
| 83 | ClientID cid; |
| 84 | |
| 85 | |
| 86 | private: |
| 87 | int getClientPid() const { return mPid; } |
| 88 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 89 | int mPid; |
| 90 | uint32_t mBitmap; |
| 91 | SortedVector<uint8_t> mInUse; |
| 92 | Vector< wp<LayerBaseClient> > mLayers; |
| 93 | sp<MemoryDealer> mCblkHeap; |
| 94 | sp<SurfaceFlinger> mFlinger; |
| 95 | sp<IMemory> mCblkMemory; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 96 | }; |
| 97 | |
| 98 | // --------------------------------------------------------------------------- |
| 99 | |
| 100 | class GraphicPlane |
| 101 | { |
| 102 | public: |
| 103 | static status_t orientationToTransfrom(int orientation, int w, int h, |
| 104 | Transform* tr); |
| 105 | |
| 106 | GraphicPlane(); |
| 107 | ~GraphicPlane(); |
| 108 | |
| 109 | bool initialized() const; |
| 110 | |
| 111 | void setDisplayHardware(DisplayHardware *); |
| 112 | void setTransform(const Transform& tr); |
| 113 | status_t setOrientation(int orientation); |
Mathias Agopian | 0d1318b | 2009-03-27 17:58:20 -0700 | [diff] [blame] | 114 | int getOrientation() const { return mOrientation; } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 115 | |
| 116 | const DisplayHardware& displayHardware() const; |
| 117 | const Transform& transform() const; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 118 | EGLDisplay getEGLDisplay() const; |
| 119 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 120 | private: |
| 121 | GraphicPlane(const GraphicPlane&); |
| 122 | GraphicPlane operator = (const GraphicPlane&); |
| 123 | |
| 124 | DisplayHardware* mHw; |
| 125 | Transform mTransform; |
| 126 | Transform mOrientationTransform; |
| 127 | Transform mGlobalTransform; |
Mathias Agopian | 0d1318b | 2009-03-27 17:58:20 -0700 | [diff] [blame] | 128 | int mOrientation; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 129 | }; |
| 130 | |
| 131 | // --------------------------------------------------------------------------- |
| 132 | |
| 133 | enum { |
| 134 | eTransactionNeeded = 0x01, |
| 135 | eTraversalNeeded = 0x02 |
| 136 | }; |
| 137 | |
| 138 | class SurfaceFlinger : public BnSurfaceComposer, protected Thread |
| 139 | { |
| 140 | public: |
| 141 | static void instantiate(); |
| 142 | static void shutdown(); |
| 143 | |
| 144 | SurfaceFlinger(); |
| 145 | virtual ~SurfaceFlinger(); |
| 146 | void init(); |
| 147 | |
| 148 | virtual status_t onTransact( |
| 149 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); |
| 150 | |
| 151 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 152 | |
| 153 | // ISurfaceComposer interface |
| 154 | virtual sp<ISurfaceFlingerClient> createConnection(); |
| 155 | virtual sp<IMemory> getCblk() const; |
| 156 | virtual void bootFinished(); |
| 157 | virtual void openGlobalTransaction(); |
| 158 | virtual void closeGlobalTransaction(); |
| 159 | virtual status_t freezeDisplay(DisplayID dpy, uint32_t flags); |
| 160 | virtual status_t unfreezeDisplay(DisplayID dpy, uint32_t flags); |
Mathias Agopian | c08731e | 2009-03-27 18:11:38 -0700 | [diff] [blame] | 161 | virtual int setOrientation(DisplayID dpy, int orientation, uint32_t flags); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 162 | virtual void signal() const; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 163 | |
| 164 | void screenReleased(DisplayID dpy); |
| 165 | void screenAcquired(DisplayID dpy); |
| 166 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 167 | overlay_control_device_t* getOverlayEngine() const; |
| 168 | |
| 169 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 170 | status_t removeLayer(const sp<LayerBase>& layer); |
| 171 | status_t addLayer(const sp<LayerBase>& layer); |
| 172 | status_t invalidateLayerVisibility(const sp<LayerBase>& layer); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 173 | |
| 174 | private: |
| 175 | friend class BClient; |
| 176 | friend class LayerBase; |
| 177 | friend class LayerBuffer; |
| 178 | friend class LayerBaseClient; |
| 179 | friend class Layer; |
| 180 | friend class LayerBlur; |
| 181 | |
| 182 | sp<ISurface> createSurface(ClientID client, int pid, |
| 183 | ISurfaceFlingerClient::surface_data_t* params, |
| 184 | DisplayID display, uint32_t w, uint32_t h, PixelFormat format, |
| 185 | uint32_t flags); |
| 186 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 187 | sp<LayerBaseClient> createNormalSurfaceLocked( |
| 188 | Client* client, DisplayID display, |
| 189 | int32_t id, uint32_t w, uint32_t h, |
| 190 | PixelFormat format, uint32_t flags); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 191 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 192 | sp<LayerBaseClient> createBlurSurfaceLocked( |
| 193 | Client* client, DisplayID display, |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 194 | int32_t id, uint32_t w, uint32_t h, uint32_t flags); |
| 195 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 196 | sp<LayerBaseClient> createDimSurfaceLocked( |
| 197 | Client* client, DisplayID display, |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 198 | int32_t id, uint32_t w, uint32_t h, uint32_t flags); |
| 199 | |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 200 | sp<LayerBaseClient> createPushBuffersSurfaceLocked( |
| 201 | Client* client, DisplayID display, |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 202 | int32_t id, uint32_t w, uint32_t h, uint32_t flags); |
| 203 | |
Mathias Agopian | 9a11206 | 2009-04-17 19:36:26 -0700 | [diff] [blame] | 204 | status_t removeSurface(SurfaceID surface_id); |
| 205 | status_t destroySurface(const sp<LayerBaseClient>& layer); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 206 | status_t setClientState(ClientID cid, int32_t count, const layer_state_t* states); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 207 | |
| 208 | |
| 209 | class LayerVector { |
| 210 | public: |
| 211 | inline LayerVector() { } |
| 212 | LayerVector(const LayerVector&); |
| 213 | inline size_t size() const { return layers.size(); } |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 214 | inline sp<LayerBase> const* array() const { return layers.array(); } |
| 215 | ssize_t add(const sp<LayerBase>&, Vector< sp<LayerBase> >::compar_t); |
| 216 | ssize_t remove(const sp<LayerBase>&); |
| 217 | ssize_t reorder(const sp<LayerBase>&, Vector< sp<LayerBase> >::compar_t); |
| 218 | ssize_t indexOf(const sp<LayerBase>& key, size_t guess=0) const; |
| 219 | inline sp<LayerBase> operator [] (size_t i) const { return layers[i]; } |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 220 | private: |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 221 | KeyedVector< sp<LayerBase> , size_t> lookup; |
| 222 | Vector< sp<LayerBase> > layers; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 223 | }; |
| 224 | |
| 225 | struct State { |
| 226 | State() { |
| 227 | orientation = ISurfaceComposer::eOrientationDefault; |
| 228 | freezeDisplay = 0; |
| 229 | } |
| 230 | LayerVector layersSortedByZ; |
| 231 | uint8_t orientation; |
Mathias Agopian | c08731e | 2009-03-27 18:11:38 -0700 | [diff] [blame] | 232 | uint8_t orientationType; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 233 | uint8_t freezeDisplay; |
| 234 | }; |
| 235 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 236 | virtual bool threadLoop(); |
| 237 | virtual status_t readyToRun(); |
| 238 | virtual void onFirstRef(); |
| 239 | |
| 240 | const GraphicPlane& graphicPlane(int dpy) const; |
| 241 | GraphicPlane& graphicPlane(int dpy); |
| 242 | |
| 243 | void waitForEvent(); |
| 244 | void signalEvent(); |
| 245 | void signalDelayedEvent(nsecs_t delay); |
| 246 | |
| 247 | void handleConsoleEvents(); |
| 248 | void handleTransaction(uint32_t transactionFlags); |
| 249 | |
| 250 | void computeVisibleRegions( |
| 251 | LayerVector& currentLayers, |
| 252 | Region& dirtyRegion, |
| 253 | Region& wormholeRegion); |
| 254 | |
| 255 | void handlePageFlip(); |
| 256 | bool lockPageFlip(const LayerVector& currentLayers); |
| 257 | void unlockPageFlip(const LayerVector& currentLayers); |
| 258 | void handleRepaint(); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 259 | void scheduleBroadcast(Client* client); |
| 260 | void executeScheduledBroadcasts(); |
| 261 | void postFramebuffer(); |
| 262 | void composeSurfaces(const Region& dirty); |
| 263 | void unlockClients(); |
| 264 | |
| 265 | |
| 266 | void destroyConnection(ClientID cid); |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 267 | sp<LayerBaseClient> getLayerUser_l(SurfaceID index) const; |
| 268 | status_t addLayer_l(const sp<LayerBase>& layer); |
| 269 | status_t removeLayer_l(const sp<LayerBase>& layer); |
Mathias Agopian | 9a11206 | 2009-04-17 19:36:26 -0700 | [diff] [blame] | 270 | status_t purgatorizeLayer_l(const sp<LayerBase>& layer); |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 271 | void free_resources_l(); |
| 272 | |
| 273 | uint32_t getTransactionFlags(uint32_t flags); |
| 274 | uint32_t setTransactionFlags(uint32_t flags, nsecs_t delay = 0); |
| 275 | void commitTransaction(); |
| 276 | |
| 277 | |
| 278 | friend class FreezeLock; |
| 279 | sp<FreezeLock> getFreezeLock() const; |
| 280 | inline void incFreezeCount() { mFreezeCount++; } |
| 281 | inline void decFreezeCount() { if (mFreezeCount > 0) mFreezeCount--; } |
| 282 | inline bool hasFreezeRequest() const { return mFreezeDisplay; } |
| 283 | inline bool isFrozen() const { |
| 284 | return mFreezeDisplay || mFreezeCount>0; |
| 285 | } |
| 286 | |
| 287 | |
| 288 | void debugFlashRegions(); |
| 289 | void debugShowFPS() const; |
| 290 | void drawWormhole() const; |
| 291 | |
Mathias Agopian | f1d8e87 | 2009-04-20 19:39:12 -0700 | [diff] [blame] | 292 | |
| 293 | mutable MessageQueue mEventQueue; |
| 294 | |
| 295 | |
| 296 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 297 | // access must be protected by mStateLock |
| 298 | mutable Mutex mStateLock; |
| 299 | State mCurrentState; |
| 300 | State mDrawingState; |
| 301 | volatile int32_t mTransactionFlags; |
| 302 | volatile int32_t mTransactionCount; |
| 303 | Condition mTransactionCV; |
Mathias Agopian | 9a11206 | 2009-04-17 19:36:26 -0700 | [diff] [blame] | 304 | SortedVector< sp<LayerBase> > mLayerPurgatory; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 305 | |
Mathias Agopian | 9a11206 | 2009-04-17 19:36:26 -0700 | [diff] [blame] | 306 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 307 | // protected by mStateLock (but we could use another lock) |
| 308 | Tokenizer mTokens; |
| 309 | DefaultKeyedVector<ClientID, Client*> mClientsMap; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 310 | DefaultKeyedVector<SurfaceID, sp<LayerBaseClient> > mLayerMap; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 311 | GraphicPlane mGraphicPlanes[1]; |
Mathias Agopian | 076b1cc | 2009-04-10 14:24:30 -0700 | [diff] [blame] | 312 | bool mLayersRemoved; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 313 | Vector<Client*> mDisconnectedClients; |
| 314 | |
| 315 | // constant members (no synchronization needed for access) |
| 316 | sp<MemoryDealer> mServerHeap; |
| 317 | sp<IMemory> mServerCblkMemory; |
| 318 | surface_flinger_cblk_t* mServerCblk; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 319 | GLuint mWormholeTexName; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 320 | nsecs_t mBootTime; |
| 321 | |
| 322 | // Can only accessed from the main thread, these members |
| 323 | // don't need synchronization |
| 324 | Region mDirtyRegion; |
| 325 | Region mInvalidRegion; |
| 326 | Region mWormholeRegion; |
| 327 | Client* mLastScheduledBroadcast; |
| 328 | SortedVector<Client*> mScheduledBroadcasts; |
| 329 | bool mVisibleRegionsDirty; |
| 330 | bool mDeferReleaseConsole; |
| 331 | bool mFreezeDisplay; |
| 332 | int32_t mFreezeCount; |
| 333 | nsecs_t mFreezeDisplayTime; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 334 | |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 335 | // don't use a lock for these, we don't care |
| 336 | int mDebugRegion; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 337 | int mDebugBackground; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 338 | |
| 339 | // these are thread safe |
| 340 | mutable Barrier mReadyToRunBarrier; |
The Android Open Source Project | edbf3b6 | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 341 | |
| 342 | // atomic variables |
| 343 | enum { |
| 344 | eConsoleReleased = 1, |
| 345 | eConsoleAcquired = 2 |
| 346 | }; |
| 347 | volatile int32_t mConsoleSignals; |
| 348 | |
| 349 | // only written in the main thread, only read in other threads |
| 350 | volatile int32_t mSecureFrameBuffer; |
| 351 | }; |
| 352 | |
| 353 | // --------------------------------------------------------------------------- |
| 354 | |
| 355 | class FreezeLock : public LightRefBase<FreezeLock> { |
| 356 | SurfaceFlinger* mFlinger; |
| 357 | public: |
| 358 | FreezeLock(SurfaceFlinger* flinger) |
| 359 | : mFlinger(flinger) { |
| 360 | mFlinger->incFreezeCount(); |
| 361 | } |
| 362 | ~FreezeLock() { |
| 363 | mFlinger->decFreezeCount(); |
| 364 | } |
| 365 | }; |
| 366 | |
| 367 | // --------------------------------------------------------------------------- |
| 368 | |
| 369 | class BClient : public BnSurfaceFlingerClient |
| 370 | { |
| 371 | public: |
| 372 | BClient(SurfaceFlinger *flinger, ClientID cid, |
| 373 | const sp<IMemory>& cblk); |
| 374 | ~BClient(); |
| 375 | |
| 376 | // ISurfaceFlingerClient interface |
| 377 | virtual void getControlBlocks(sp<IMemory>* ctrl) const; |
| 378 | |
| 379 | virtual sp<ISurface> createSurface( |
| 380 | surface_data_t* params, int pid, |
| 381 | DisplayID display, uint32_t w, uint32_t h,PixelFormat format, |
| 382 | uint32_t flags); |
| 383 | |
| 384 | virtual status_t destroySurface(SurfaceID surfaceId); |
| 385 | virtual status_t setState(int32_t count, const layer_state_t* states); |
| 386 | |
| 387 | private: |
| 388 | ClientID mId; |
| 389 | SurfaceFlinger* mFlinger; |
| 390 | sp<IMemory> mCblk; |
| 391 | }; |
| 392 | |
| 393 | // --------------------------------------------------------------------------- |
| 394 | }; // namespace android |
| 395 | |
| 396 | #endif // ANDROID_SURFACE_FLINGER_H |