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_LAYER_BASE_H 18 #define ANDROID_LAYER_BASE_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 23 #include <EGL/egl.h> 24 #include <EGL/eglext.h> 25 #include <GLES/gl.h> 26 27 #include <utils/RefBase.h> 28 29 #include <ui/Region.h> 30 #include <ui/Overlay.h> 31 32 #include <surfaceflinger/ISurfaceComposerClient.h> 33 #include <private/surfaceflinger/SharedBufferStack.h> 34 #include <private/surfaceflinger/LayerState.h> 35 36 #include <pixelflinger/pixelflinger.h> 37 38 #include "Transform.h" 39 40 namespace android { 41 42 // --------------------------------------------------------------------------- 43 44 class DisplayHardware; 45 class Client; 46 class GraphicBuffer; 47 class GraphicPlane; 48 class LayerBaseClient; 49 class SurfaceFlinger; 50 class Texture; 51 52 // --------------------------------------------------------------------------- 53 54 class LayerBase : public RefBase 55 { 56 static int32_t sSequence; 57 58 public: 59 LayerBase(SurfaceFlinger* flinger, DisplayID display); 60 61 DisplayID dpy; 62 mutable bool contentDirty; 63 Region visibleRegionScreen; 64 Region transparentRegionScreen; 65 Region coveredRegionScreen; 66 int32_t sequence; 67 68 struct State { 69 uint32_t w; 70 uint32_t h; 71 uint32_t requested_w; 72 uint32_t requested_h; 73 uint32_t z; 74 uint8_t alpha; 75 uint8_t flags; 76 uint8_t reserved[2]; 77 int32_t sequence; // changes when visible regions can change 78 uint32_t tint; 79 Transform transform; 80 Region transparentRegion; 81 }; 82 83 void setName(const String8& name); 84 String8 getName() const; 85 86 // modify current state 87 bool setPosition(int32_t x, int32_t y); 88 bool setLayer(uint32_t z); 89 bool setSize(uint32_t w, uint32_t h); 90 bool setAlpha(uint8_t alpha); 91 bool setMatrix(const layer_state_t::matrix22_t& matrix); 92 bool setTransparentRegionHint(const Region& opaque); 93 bool setFlags(uint8_t flags, uint8_t mask); 94 95 void commitTransaction(); 96 bool requestTransaction(); 97 void forceVisibilityTransaction(); 98 99 uint32_t getTransactionFlags(uint32_t flags); 100 uint32_t setTransactionFlags(uint32_t flags); 101 102 Rect visibleBounds() const; 103 void drawRegion(const Region& reg) const; 104 105 void invalidate(); 106 107 virtual sp<LayerBaseClient> getLayerBaseClient() const { return 0; } 108 109 virtual const char* getTypeId() const { return "LayerBase"; } 110 111 /** 112 * draw - performs some global clipping optimizations 113 * and calls onDraw(). 114 * Typically this method is not overridden, instead implement onDraw() 115 * to perform the actual drawing. 116 */ 117 virtual void draw(const Region& clip) const; 118 virtual void drawForSreenShot() const; 119 120 /** 121 * onDraw - draws the surface. 122 */ 123 virtual void onDraw(const Region& clip) const = 0; 124 125 /** 126 * initStates - called just after construction 127 */ 128 virtual void initStates(uint32_t w, uint32_t h, uint32_t flags); 129 130 /** 131 * doTransaction - process the transaction. This is a good place to figure 132 * out which attributes of the surface have changed. 133 */ 134 virtual uint32_t doTransaction(uint32_t transactionFlags); 135 136 /** 137 * setVisibleRegion - called to set the new visible region. This gives 138 * a chance to update the new visible region or record the fact it changed. 139 */ 140 virtual void setVisibleRegion(const Region& visibleRegion); 141 142 /** 143 * setCoveredRegion - called when the covered region changes. The covered 144 * region corresponds to any area of the surface that is covered 145 * (transparently or not) by another surface. 146 */ 147 virtual void setCoveredRegion(const Region& coveredRegion); 148 149 /** 150 * validateVisibility - cache a bunch of things 151 */ 152 virtual void validateVisibility(const Transform& globalTransform); 153 154 /** 155 * lockPageFlip - called each time the screen is redrawn and returns whether 156 * the visible regions need to be recomputed (this is a fairly heavy 157 * operation, so this should be set only if needed). Typically this is used 158 * to figure out if the content or size of a surface has changed. 159 */ 160 virtual void lockPageFlip(bool& recomputeVisibleRegions); 161 162 /** 163 * unlockPageFlip - called each time the screen is redrawn. updates the 164 * final dirty region wrt the planeTransform. 165 * At this point, all visible regions, surface position and size, etc... are 166 * correct. 167 */ 168 virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion); 169 170 /** 171 * finishPageFlip - called after all surfaces have drawn. 172 */ 173 virtual void finishPageFlip(); 174 175 /** 176 * needsBlending - true if this surface needs blending 177 */ 178 virtual bool needsBlending() const { return false; } 179 180 /** 181 * needsDithering - true if this surface needs dithering 182 */ 183 virtual bool needsDithering() const { return false; } 184 185 /** 186 * needsLinearFiltering - true if this surface needs filtering 187 */ 188 virtual bool needsFiltering() const { return mNeedsFiltering; } 189 190 /** 191 * isSecure - true if this surface is secure, that is if it prevents 192 * screenshots or VNC servers. 193 */ 194 virtual bool isSecure() const { return false; } 195 196 /** Called from the main thread, when the surface is removed from the 197 * draw list */ 198 virtual status_t ditch() { return NO_ERROR; } 199 200 /** called with the state lock when the surface is removed from the 201 * current list */ 202 virtual void onRemoved() { }; 203 204 /** always call base class first */ 205 virtual void dump(String8& result, char* scratch, size_t size) const; 206 207 208 enum { // flags for doTransaction() 209 eVisibleRegion = 0x00000002, 210 }; 211 212 213 inline const State& drawingState() const { return mDrawingState; } 214 inline const State& currentState() const { return mCurrentState; } 215 inline State& currentState() { return mCurrentState; } 216 217 int32_t getOrientation() const { return mOrientation; } 218 int tx() const { return mLeft; } 219 int ty() const { return mTop; } 220 221 protected: 222 const GraphicPlane& graphicPlane(int dpy) const; 223 GraphicPlane& graphicPlane(int dpy); 224 225 void clearWithOpenGL(const Region& clip, GLclampf r, GLclampf g, 226 GLclampf b, GLclampf alpha) const; 227 void clearWithOpenGL(const Region& clip) const; 228 void drawWithOpenGL(const Region& clip, const Texture& texture) const; 229 230 // these must be called from the post/drawing thread 231 void setBufferCrop(const Rect& crop); 232 void setBufferTransform(uint32_t transform); 233 234 sp<SurfaceFlinger> mFlinger; 235 uint32_t mFlags; 236 237 // post/drawing thread 238 Rect mBufferCrop; 239 uint32_t mBufferTransform; 240 241 // cached during validateVisibility() 242 bool mNeedsFiltering; 243 int32_t mOrientation; 244 GLfloat mVertices[4][2]; 245 Rect mTransformedBounds; 246 int mLeft; 247 int mTop; 248 249 // these are protected by an external lock 250 State mCurrentState; 251 State mDrawingState; 252 volatile int32_t mTransactionFlags; 253 254 // don't change, don't need a lock 255 bool mPremultipliedAlpha; 256 String8 mName; 257 mutable bool mDebug; 258 259 260 // atomic 261 volatile int32_t mInvalidate; 262 263 264 protected: 265 virtual ~LayerBase(); 266 267 private: 268 LayerBase(const LayerBase& rhs); 269 }; 270 271 272 // --------------------------------------------------------------------------- 273 274 class LayerBaseClient : public LayerBase 275 { 276 public: 277 class Surface; 278 279 LayerBaseClient(SurfaceFlinger* flinger, DisplayID display, 280 const sp<Client>& client); 281 virtual ~LayerBaseClient(); 282 283 sp<Surface> getSurface(); 284 virtual sp<Surface> createSurface() const; 285 virtual sp<LayerBaseClient> getLayerBaseClient() const { 286 return const_cast<LayerBaseClient*>(this); } 287 virtual const char* getTypeId() const { return "LayerBaseClient"; } 288 289 uint32_t getIdentity() const { return mIdentity; } 290 291 class Surface : public BnSurface { 292 public: 293 int32_t getIdentity() const { return mIdentity; } 294 295 protected: 296 Surface(const sp<SurfaceFlinger>& flinger, int identity, 297 const sp<LayerBaseClient>& owner); 298 virtual ~Surface(); 299 virtual status_t onTransact(uint32_t code, const Parcel& data, 300 Parcel* reply, uint32_t flags); 301 sp<LayerBaseClient> getOwner() const; 302 303 private: 304 virtual sp<GraphicBuffer> requestBuffer(int bufferIdx, 305 uint32_t w, uint32_t h, uint32_t format, uint32_t usage); 306 virtual status_t setBufferCount(int bufferCount); 307 308 virtual status_t registerBuffers(const ISurface::BufferHeap& buffers); 309 virtual void postBuffer(ssize_t offset); 310 virtual void unregisterBuffers(); 311 virtual sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, 312 int32_t format, int32_t orientation); 313 314 protected: 315 friend class LayerBaseClient; 316 sp<SurfaceFlinger> mFlinger; 317 int32_t mIdentity; 318 wp<LayerBaseClient> mOwner; 319 }; 320 321 friend class Surface; 322 323 protected: 324 virtual void dump(String8& result, char* scratch, size_t size) const; 325 326 private: 327 mutable Mutex mLock; 328 mutable wp<Surface> mClientSurface; 329 const wp<Client> mClientRef; 330 // only read 331 const uint32_t mIdentity; 332 static int32_t sIdentity; 333 }; 334 335 // --------------------------------------------------------------------------- 336 337 }; // namespace android 338 339 #endif // ANDROID_LAYER_BASE_H 340
