frameworks/base/services/surfaceflinger/LayerBase.h

   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 from the main thread, when the surface is removed from the
 200      * draw list */
 201     virtual status_t ditch() { return NO_ERROR; }
 202
 203     /** called with the state lock when the surface is removed from the
 204      *  current list */
 205     virtual void onRemoved() { };
 206
 207     /** always call base class first */
 208     virtual void dump(String8& result, char* scratch, size_t size) const;
 209     virtual void shortDump(String8& result, char* scratch, size_t size) const;
 210
 211
 212     enum { // flags for doTransaction()
 213         eVisibleRegion      = 0x00000002,
 214     };
 215
 216
 217     inline  const State&    drawingState() const    { return mDrawingState; }
 218     inline  const State&    currentState() const    { return mCurrentState; }
 219     inline  State&          currentState()          { return mCurrentState; }
 220
 221     int32_t  getOrientation() const { return mOrientation; }
 222     int  tx() const             { return mLeft; }
 223     int  ty() const             { return mTop; }
 224
 225 protected:
 226     const GraphicPlane& graphicPlane(int dpy) const;
 227           GraphicPlane& graphicPlane(int dpy);
 228
 229           void clearWithOpenGL(const Region& clip, GLclampf r, GLclampf g,
 230                                GLclampf b, GLclampf alpha) const;
 231           void clearWithOpenGL(const Region& clip) const;
 232           void drawWithOpenGL(const Region& clip, const Texture& texture) const;
 233
 234           // these must be called from the post/drawing thread
 235           void setBufferCrop(const Rect& crop);
 236           void setBufferTransform(uint32_t transform);
 237
 238                 sp<SurfaceFlinger> mFlinger;
 239                 uint32_t        mFlags;
 240
 241                 // post/drawing thread
 242                 Rect mBufferCrop;
 243                 uint32_t mBufferTransform;
 244
 245                 // cached during validateVisibility()
 246                 bool            mNeedsFiltering;
 247                 int32_t         mOrientation;
 248                 GLfloat         mVertices[4][2];
 249                 Rect            mTransformedBounds;
 250                 int             mLeft;
 251                 int             mTop;
 252
 253                 // these are protected by an external lock
 254                 State           mCurrentState;
 255                 State           mDrawingState;
 256     volatile    int32_t         mTransactionFlags;
 257
 258                 // don't change, don't need a lock
 259                 bool            mPremultipliedAlpha;
 260                 String8         mName;
 261     mutable     bool            mDebug;
 262
 263
 264                 // atomic
 265     volatile    int32_t         mInvalidate;
 266
 267
 268 protected:
 269     virtual ~LayerBase();
 270
 271 private:
 272     LayerBase(const LayerBase& rhs);
 273 };
 274
 275
 276 // ---------------------------------------------------------------------------
 277
 278 class LayerBaseClient : public LayerBase
 279 {
 280 public:
 281     class Surface;
 282
 283             LayerBaseClient(SurfaceFlinger* flinger, DisplayID display,
 284                         const sp<Client>& client);
 285     virtual ~LayerBaseClient();
 286
 287             sp<Surface> getSurface();
 288     virtual sp<Surface> createSurface() const;
 289     virtual sp<LayerBaseClient> getLayerBaseClient() const {
 290         return const_cast<LayerBaseClient*>(this); }
 291     virtual const char* getTypeId() const { return "LayerBaseClient"; }
 292
 293     uint32_t getIdentity() const { return mIdentity; }
 294
 295     class Surface : public BnSurface  {
 296     public:
 297         int32_t getIdentity() const { return mIdentity; }
 298
 299     protected:
 300         Surface(const sp<SurfaceFlinger>& flinger, int identity,
 301                 const sp<LayerBaseClient>& owner);
 302         virtual ~Surface();
 303         virtual status_t onTransact(uint32_t code, const Parcel& data,
 304                 Parcel* reply, uint32_t flags);
 305         sp<LayerBaseClient> getOwner() const;
 306
 307     private:
 308         virtual sp<GraphicBuffer> requestBuffer(int bufferIdx,
 309                 uint32_t w, uint32_t h, uint32_t format, uint32_t usage);
 310         virtual status_t setBufferCount(int bufferCount);
 311
 312         virtual status_t registerBuffers(const ISurface::BufferHeap& buffers);
 313         virtual void postBuffer(ssize_t offset);
 314         virtual void unregisterBuffers();
 315         virtual sp<OverlayRef> createOverlay(uint32_t w, uint32_t h,
 316                 int32_t format, int32_t orientation);
 317
 318     protected:
 319         friend class LayerBaseClient;
 320         sp<SurfaceFlinger>  mFlinger;
 321         int32_t             mIdentity;
 322         wp<LayerBaseClient> mOwner;
 323     };
 324
 325     friend class Surface;
 326
 327 protected:
 328     virtual void dump(String8& result, char* scratch, size_t size) const;
 329     virtual void shortDump(String8& result, char* scratch, size_t size) const;
 330
 331 private:
 332     mutable Mutex mLock;
 333     mutable wp<Surface> mClientSurface;
 334     const wp<Client> mClientRef;
 335     // only read
 336     const uint32_t mIdentity;
 337     static int32_t sIdentity;
 338 };
 339
 340 // ---------------------------------------------------------------------------
 341
 342 }; // namespace android
 343
 344 #endif // ANDROID_LAYER_BASE_H