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