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/ISurfaceFlingerClient.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 SurfaceFlinger; 49 50 // --------------------------------------------------------------------------- 51 52 class LayerBase : public RefBase 53 { 54 // poor man's dynamic_cast below 55 template<typename T> 56 struct getTypeInfoOfAnyType { 57 static uint32_t get() { return T::typeInfo; } 58 }; 59 60 template<typename T> 61 struct getTypeInfoOfAnyType<T*> { 62 static uint32_t get() { return getTypeInfoOfAnyType<T>::get(); } 63 }; 64 65 public: 66 static const uint32_t typeInfo; 67 static const char* const typeID; 68 virtual char const* getTypeID() const { return typeID; } 69 virtual uint32_t getTypeInfo() const { return typeInfo; } 70 71 template<typename T> 72 static T dynamicCast(LayerBase* base) { 73 uint32_t mostDerivedInfo = base->getTypeInfo(); 74 uint32_t castToInfo = getTypeInfoOfAnyType<T>::get(); 75 if ((mostDerivedInfo & castToInfo) == castToInfo) 76 return static_cast<T>(base); 77 return 0; 78 } 79 80 81 LayerBase(SurfaceFlinger* flinger, DisplayID display); 82 83 DisplayID dpy; 84 mutable bool contentDirty; 85 Region visibleRegionScreen; 86 Region transparentRegionScreen; 87 Region coveredRegionScreen; 88 89 struct State { 90 uint32_t w; 91 uint32_t h; 92 uint32_t requested_w; 93 uint32_t requested_h; 94 uint32_t z; 95 uint8_t alpha; 96 uint8_t flags; 97 uint8_t reserved[2]; 98 int32_t sequence; // changes when visible regions can change 99 uint32_t tint; 100 Transform transform; 101 Region transparentRegion; 102 }; 103 104 void setName(const String8& name); 105 String8 getName() const; 106 107 // modify current state 108 bool setPosition(int32_t x, int32_t y); 109 bool setLayer(uint32_t z); 110 bool setSize(uint32_t w, uint32_t h); 111 bool setAlpha(uint8_t alpha); 112 bool setMatrix(const layer_state_t::matrix22_t& matrix); 113 bool setTransparentRegionHint(const Region& opaque); 114 bool setFlags(uint8_t flags, uint8_t mask); 115 116 void commitTransaction(); 117 bool requestTransaction(); 118 void forceVisibilityTransaction(); 119 120 uint32_t getTransactionFlags(uint32_t flags); 121 uint32_t setTransactionFlags(uint32_t flags); 122 123 Rect visibleBounds() const; 124 void drawRegion(const Region& reg) const; 125 126 void invalidate(); 127 128 /** 129 * draw - performs some global clipping optimizations 130 * and calls onDraw(). 131 * Typically this method is not overridden, instead implement onDraw() 132 * to perform the actual drawing. 133 */ 134 virtual void draw(const Region& clip) const; 135 136 /** 137 * onDraw - draws the surface. 138 */ 139 virtual void onDraw(const Region& clip) const = 0; 140 141 /** 142 * initStates - called just after construction 143 */ 144 virtual void initStates(uint32_t w, uint32_t h, uint32_t flags); 145 146 /** 147 * doTransaction - process the transaction. This is a good place to figure 148 * out which attributes of the surface have changed. 149 */ 150 virtual uint32_t doTransaction(uint32_t transactionFlags); 151 152 /** 153 * setVisibleRegion - called to set the new visible region. This gives 154 * a chance to update the new visible region or record the fact it changed. 155 */ 156 virtual void setVisibleRegion(const Region& visibleRegion); 157 158 /** 159 * setCoveredRegion - called when the covered region changes. The covered 160 * region corresponds to any area of the surface that is covered 161 * (transparently or not) by another surface. 162 */ 163 virtual void setCoveredRegion(const Region& coveredRegion); 164 165 /** 166 * validateVisibility - cache a bunch of things 167 */ 168 virtual void validateVisibility(const Transform& globalTransform); 169 170 /** 171 * lockPageFlip - called each time the screen is redrawn and returns whether 172 * the visible regions need to be recomputed (this is a fairly heavy 173 * operation, so this should be set only if needed). Typically this is used 174 * to figure out if the content or size of a surface has changed. 175 */ 176 virtual void lockPageFlip(bool& recomputeVisibleRegions); 177 178 /** 179 * unlockPageFlip - called each time the screen is redrawn. updates the 180 * final dirty region wrt the planeTransform. 181 * At this point, all visible regions, surface position and size, etc... are 182 * correct. 183 */ 184 virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion); 185 186 /** 187 * finishPageFlip - called after all surfaces have drawn. 188 */ 189 virtual void finishPageFlip(); 190 191 /** 192 * needsBlending - true if this surface needs blending 193 */ 194 virtual bool needsBlending() const { return false; } 195 196 /** 197 * needsDithering - true if this surface needs dithering 198 */ 199 virtual bool needsDithering() const { return false; } 200 201 /** 202 * transformed -- true is this surface needs a to be transformed 203 */ 204 virtual bool transformed() const { return mTransformed; } 205 206 /** 207 * isSecure - true if this surface is secure, that is if it prevents 208 * screenshots or VNC servers. 209 */ 210 virtual bool isSecure() const { return false; } 211 212 /** Called from the main thread, when the surface is removed from the 213 * draw list */ 214 virtual status_t ditch() { return NO_ERROR; } 215 216 /** called with the state lock when the surface is removed from the 217 * current list */ 218 virtual void onRemoved() { }; 219 220 221 enum { // flags for doTransaction() 222 eVisibleRegion = 0x00000002, 223 }; 224 225 226 inline const State& drawingState() const { return mDrawingState; } 227 inline const State& currentState() const { return mCurrentState; } 228 inline State& currentState() { return mCurrentState; } 229 230 static int compareCurrentStateZ( 231 sp<LayerBase> const * layerA, 232 sp<LayerBase> const * layerB) { 233 return layerA[0]->currentState().z - layerB[0]->currentState().z; 234 } 235 236 int32_t getOrientation() const { return mOrientation; } 237 int tx() const { return mLeft; } 238 int ty() const { return mTop; } 239 240 protected: 241 const GraphicPlane& graphicPlane(int dpy) const; 242 GraphicPlane& graphicPlane(int dpy); 243 244 GLuint createTexture() const; 245 246 struct Texture { 247 Texture() : name(-1U), width(0), height(0), 248 image(EGL_NO_IMAGE_KHR), transform(0), 249 NPOTAdjust(false), dirty(true) { } 250 GLuint name; 251 GLuint width; 252 GLuint height; 253 GLuint potWidth; 254 GLuint potHeight; 255 GLfloat wScale; 256 GLfloat hScale; 257 EGLImageKHR image; 258 uint32_t transform; 259 bool NPOTAdjust; 260 bool dirty; 261 }; 262 263 void clearWithOpenGL(const Region& clip, GLclampx r, GLclampx g, 264 GLclampx b, GLclampx alpha) const; 265 void clearWithOpenGL(const Region& clip) const; 266 void drawWithOpenGL(const Region& clip, const Texture& texture) const; 267 void loadTexture(Texture* texture, 268 const Region& dirty, const GGLSurface& t) const; 269 status_t initializeEglImage( 270 const sp<GraphicBuffer>& buffer, Texture* texture); 271 272 bool isSupportedYuvFormat(int format) const; 273 274 sp<SurfaceFlinger> mFlinger; 275 uint32_t mFlags; 276 277 // cached during validateVisibility() 278 bool mTransformed; 279 bool mUseLinearFiltering; 280 int32_t mOrientation; 281 GLfixed mVertices[4][2]; 282 Rect mTransformedBounds; 283 int mLeft; 284 int mTop; 285 286 // these are protected by an external lock 287 State mCurrentState; 288 State mDrawingState; 289 volatile int32_t mTransactionFlags; 290 291 // don't change, don't need a lock 292 bool mPremultipliedAlpha; 293 String8 mName; 294 mutable bool mDebug; 295 296 297 // atomic 298 volatile int32_t mInvalidate; 299 300 301 protected: 302 virtual ~LayerBase(); 303 304 private: 305 LayerBase(const LayerBase& rhs); 306 void validateTexture(GLint textureName) const; 307 }; 308 309 310 // --------------------------------------------------------------------------- 311 312 class LayerBaseClient : public LayerBase 313 { 314 public: 315 class Surface; 316 static const uint32_t typeInfo; 317 static const char* const typeID; 318 virtual char const* getTypeID() const { return typeID; } 319 virtual uint32_t getTypeInfo() const { return typeInfo; } 320 321 // lcblk is (almost) only accessed from the main SF thread, in the places 322 // where it's not, a reference to Client must be held 323 SharedBufferServer* lcblk; 324 325 LayerBaseClient(SurfaceFlinger* flinger, DisplayID display, 326 const sp<Client>& client, int32_t i); 327 virtual ~LayerBaseClient(); 328 virtual void onFirstRef(); 329 330 const wp<Client> client; 331 332 inline uint32_t getIdentity() const { return mIdentity; } 333 inline int32_t clientIndex() const { return mIndex; } 334 int32_t serverIndex() const; 335 336 337 sp<Surface> getSurface(); 338 virtual sp<Surface> createSurface() const; 339 340 virtual void onRemoved(); 341 342 343 class Surface : public BnSurface 344 { 345 public: 346 int32_t getToken() const { return mToken; } 347 int32_t getIdentity() const { return mIdentity; } 348 349 protected: 350 Surface(const sp<SurfaceFlinger>& flinger, 351 SurfaceID id, int identity, 352 const sp<LayerBaseClient>& owner); 353 virtual ~Surface(); 354 virtual status_t onTransact(uint32_t code, const Parcel& data, 355 Parcel* reply, uint32_t flags); 356 sp<LayerBaseClient> getOwner() const; 357 358 private: 359 virtual sp<GraphicBuffer> requestBuffer(int index, int usage); 360 virtual status_t registerBuffers(const ISurface::BufferHeap& buffers); 361 virtual void postBuffer(ssize_t offset); 362 virtual void unregisterBuffers(); 363 virtual sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, 364 int32_t format, int32_t orientation); 365 366 protected: 367 friend class LayerBaseClient; 368 sp<SurfaceFlinger> mFlinger; 369 int32_t mToken; 370 int32_t mIdentity; 371 wp<LayerBaseClient> mOwner; 372 }; 373 374 friend class Surface; 375 376 private: 377 int32_t mIndex; 378 mutable Mutex mLock; 379 mutable wp<Surface> mClientSurface; 380 // only read 381 const uint32_t mIdentity; 382 static int32_t sIdentity; 383 }; 384 385 // --------------------------------------------------------------------------- 386 387 }; // namespace android 388 389 #endif // ANDROID_LAYER_BASE_H 390
