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 "DisplayHardware/DisplayHardware.h" 39 #include "Transform.h" 40 41 namespace android { 42 43 // --------------------------------------------------------------------------- 44 45 class DisplayHardware; 46 class Client; 47 class GraphicBuffer; 48 class GraphicPlane; 49 class LayerBaseClient; 50 class SurfaceFlinger; 51 class Texture; 52 53 // --------------------------------------------------------------------------- 54 55 class LayerBase : public RefBase 56 { 57 static int32_t sSequence; 58 59 public: 60 LayerBase(SurfaceFlinger* flinger, DisplayID display); 61 62 DisplayID dpy; 63 mutable bool contentDirty; 64 Region visibleRegionScreen; 65 Region transparentRegionScreen; 66 Region coveredRegionScreen; 67 int32_t sequence; 68 69 struct State { 70 uint32_t w; 71 uint32_t h; 72 uint32_t requested_w; 73 uint32_t requested_h; 74 uint32_t z; 75 uint8_t alpha; 76 uint8_t flags; 77 uint8_t reserved[2]; 78 int32_t sequence; // changes when visible regions can change 79 uint32_t tint; 80 Transform transform; 81 Region transparentRegion; 82 }; 83 84 void setName(const String8& name); 85 String8 getName() const; 86 87 // modify current state 88 bool setPosition(int32_t x, int32_t y); 89 bool setLayer(uint32_t z); 90 bool setSize(uint32_t w, uint32_t h); 91 bool setAlpha(uint8_t alpha); 92 bool setMatrix(const layer_state_t::matrix22_t& matrix); 93 bool setTransparentRegionHint(const Region& opaque); 94 bool setFlags(uint8_t flags, uint8_t mask); 95 96 void commitTransaction(); 97 bool requestTransaction(); 98 void forceVisibilityTransaction(); 99 100 uint32_t getTransactionFlags(uint32_t flags); 101 uint32_t setTransactionFlags(uint32_t flags); 102 103 Rect visibleBounds() const; 104 void drawRegion(const Region& reg) const; 105 106 void invalidate(); 107 108 virtual sp<LayerBaseClient> getLayerBaseClient() const { return 0; } 109 110 virtual const char* getTypeId() const { return "LayerBase"; } 111 112 /** 113 * draw - performs some global clipping optimizations 114 * and calls onDraw(). 115 * Typically this method is not overridden, instead implement onDraw() 116 * to perform the actual drawing. 117 */ 118 virtual void draw(const Region& clip) const; 119 virtual void drawForSreenShot() const; 120 121 /** 122 * bypass mode 123 */ 124 virtual bool setBypass(bool enable) { return false; } 125 126 /** 127 * onDraw - draws the surface. 128 */ 129 virtual void onDraw(const Region& clip) const = 0; 130 131 /** 132 * initStates - called just after construction 133 */ 134 virtual void initStates(uint32_t w, uint32_t h, uint32_t flags); 135 136 /** 137 * doTransaction - process the transaction. This is a good place to figure 138 * out which attributes of the surface have changed. 139 */ 140 virtual uint32_t doTransaction(uint32_t transactionFlags); 141 142 /** 143 * setVisibleRegion - called to set the new visible region. This gives 144 * a chance to update the new visible region or record the fact it changed. 145 */ 146 virtual void setVisibleRegion(const Region& visibleRegion); 147 148 /** 149 * setCoveredRegion - called when the covered region changes. The covered 150 * region corresponds to any area of the surface that is covered 151 * (transparently or not) by another surface. 152 */ 153 virtual void setCoveredRegion(const Region& coveredRegion); 154 155 /** 156 * validateVisibility - cache a bunch of things 157 */ 158 virtual void validateVisibility(const Transform& globalTransform); 159 160 /** 161 * lockPageFlip - called each time the screen is redrawn and returns whether 162 * the visible regions need to be recomputed (this is a fairly heavy 163 * operation, so this should be set only if needed). Typically this is used 164 * to figure out if the content or size of a surface has changed. 165 */ 166 virtual void lockPageFlip(bool& recomputeVisibleRegions); 167 168 /** 169 * unlockPageFlip - called each time the screen is redrawn. updates the 170 * final dirty region wrt the planeTransform. 171 * At this point, all visible regions, surface position and size, etc... are 172 * correct. 173 */ 174 virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion); 175 176 /** 177 * needsBlending - true if this surface needs blending 178 */ 179 virtual bool needsBlending() const { return false; } 180 181 /** 182 * needsDithering - true if this surface needs dithering 183 */ 184 virtual bool needsDithering() const { return false; } 185 186 /** 187 * needsLinearFiltering - true if this surface needs filtering 188 */ 189 virtual bool needsFiltering() const { 190 return (!(mFlags & DisplayHardware::SLOW_CONFIG)) && mNeedsFiltering; 191 } 192 193 /** 194 * isSecure - true if this surface is secure, that is if it prevents 195 * screenshots or VNC servers. 196 */ 197 virtual bool isSecure() const { return false; } 198 199 /** called with the state lock when the surface is removed from the 200 * current list */ 201 virtual void onRemoved() { }; 202 203 /** always call base class first */ 204 virtual void dump(String8& result, char* scratch, size_t size) const; 205 206 207 enum { // flags for doTransaction() 208 eVisibleRegion = 0x00000002, 209 }; 210 211 212 inline const State& drawingState() const { return mDrawingState; } 213 inline const State& currentState() const { return mCurrentState; } 214 inline State& currentState() { return mCurrentState; } 215 216 int32_t getOrientation() const { return mOrientation; } 217 int tx() const { return mLeft; } 218 int ty() const { return mTop; } 219 220 protected: 221 const GraphicPlane& graphicPlane(int dpy) const; 222 GraphicPlane& graphicPlane(int dpy); 223 224 void clearWithOpenGL(const Region& clip, GLclampf r, GLclampf g, 225 GLclampf b, GLclampf alpha) const; 226 void clearWithOpenGL(const Region& clip) const; 227 void drawWithOpenGL(const Region& clip, const Texture& texture) const; 228 229 // these must be called from the post/drawing thread 230 void setBufferCrop(const Rect& crop); 231 void setBufferTransform(uint32_t transform); 232 233 sp<SurfaceFlinger> mFlinger; 234 uint32_t mFlags; 235 236 // post/drawing thread 237 Rect mBufferCrop; 238 uint32_t mBufferTransform; 239 240 // cached during validateVisibility() 241 bool mNeedsFiltering; 242 int32_t mOrientation; 243 GLfloat mVertices[4][2]; 244 Rect mTransformedBounds; 245 int mLeft; 246 int mTop; 247 248 // these are protected by an external lock 249 State mCurrentState; 250 State mDrawingState; 251 volatile int32_t mTransactionFlags; 252 253 // don't change, don't need a lock 254 bool mPremultipliedAlpha; 255 String8 mName; 256 mutable bool mDebug; 257 258 259 // atomic 260 volatile int32_t mInvalidate; 261 262 263 public: 264 // called from class SurfaceFlinger 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
