services/surfaceflinger/DisplayDevice.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_DISPLAY_DEVICE_H
  18 #define ANDROID_DISPLAY_DEVICE_H
  19
  20 #include <stdlib.h>
  21
  22 #include <ui/PixelFormat.h>
  23 #include <ui/Region.h>
  24
  25 #include <EGL/egl.h>
  26 #include <EGL/eglext.h>
  27
  28 #include <utils/Mutex.h>
  29 #include <utils/Timers.h>
  30
  31 #include <hardware/hwcomposer_defs.h>
  32
  33 #include "Transform.h"
  34
  35 struct ANativeWindow;
  36
  37 namespace android {
  38
  39 class DisplayInfo;
  40 class FramebufferSurface;
  41 class LayerBase;
  42 class SurfaceFlinger;
  43 class HWComposer;
  44
  45 class DisplayDevice : public LightRefBase<DisplayDevice>
  46 {
  47 public:
  48     // region in layer-stack space
  49     mutable Region dirtyRegion;
  50     // region in screen space
  51     mutable Region swapRegion;
  52     // region in screen space
  53     Region undefinedRegion;
  54
  55     enum DisplayType {
  56         DISPLAY_ID_INVALID = -1,
  57         DISPLAY_PRIMARY     = HWC_DISPLAY_PRIMARY,
  58         DISPLAY_EXTERNAL    = HWC_DISPLAY_EXTERNAL,
  59         NUM_DISPLAY_TYPES   = HWC_NUM_DISPLAY_TYPES,
  60         DISPLAY_VIRTUAL     = HWC_NUM_DISPLAY_TYPES
  61     };
  62
  63     enum {
  64         PARTIAL_UPDATES = 0x00020000, // video driver feature
  65         SWAP_RECTANGLE  = 0x00080000,
  66     };
  67
  68     DisplayDevice(
  69             const sp<SurfaceFlinger>& flinger,
  70             DisplayType type, const wp<IBinder>& displayToken,
  71             const sp<ANativeWindow>& nativeWindow,
  72             const sp<FramebufferSurface>& framebufferSurface,
  73             EGLConfig config);
  74
  75     ~DisplayDevice();
  76
  77     // whether this is a valid object. An invalid DisplayDevice is returned
  78     // when an non existing id is requested
  79     bool isValid() const;
  80
  81     // Flip the front and back buffers if the back buffer is "dirty".  Might
  82     // be instantaneous, might involve copying the frame buffer around.
  83     void flip(const Region& dirty) const;
  84
  85     int         getWidth() const;
  86     int         getHeight() const;
  87     PixelFormat getFormat() const;
  88     uint32_t    getFlags() const;
  89
  90     EGLSurface  getEGLSurface() const;
  91
  92     void                    setVisibleLayersSortedByZ(const Vector< sp<LayerBase> >& layers);
  93     const Vector< sp<LayerBase> >& getVisibleLayersSortedByZ() const;
  94     bool                    getSecureLayerVisible() const;
  95     Region                  getDirtyRegion(bool repaintEverything) const;
  96
  97     void                    setLayerStack(uint32_t stack);
  98     void                    setProjection(int orientation, const Rect& viewport, const Rect& frame);
  99
 100     int                     getOrientation() const { return mOrientation; }
 101     const Transform&        getTransform() const { return mGlobalTransform; }
 102     const Rect&             getViewport() const { return mViewport; }
 103     const Rect&             getFrame() const { return mFrame; }
 104     bool                    needsFiltering() const { return mNeedsFiltering; }
 105
 106     uint32_t                getLayerStack() const { return mLayerStack; }
 107     int32_t                 getDisplayType() const { return mType; }
 108     int32_t                 getHwcDisplayId() const { return mHwcDisplayId; }
 109     const wp<IBinder>&      getDisplayToken() const { return mDisplayToken; }
 110
 111     void swapBuffers(HWComposer& hwc) const;
 112     status_t compositionComplete() const;
 113
 114     // called after h/w composer has completed its set() call
 115     void onSwapBuffersCompleted(HWComposer& hwc) const;
 116
 117     Rect getBounds() const {
 118         return Rect(mDisplayWidth, mDisplayHeight);
 119     }
 120     inline Rect bounds() const { return getBounds(); }
 121
 122     void setDisplayName(const String8& displayName);
 123     const String8& getDisplayName() const { return mDisplayName; }
 124
 125     static EGLBoolean makeCurrent(EGLDisplay dpy,
 126             const sp<const DisplayDevice>& hw, EGLContext ctx);
 127
 128     /* ------------------------------------------------------------------------
 129      * blank / unblank management
 130      */
 131     void releaseScreen() const;
 132     void acquireScreen() const;
 133     bool isScreenAcquired() const;
 134     bool canDraw() const;
 135
 136     /* ------------------------------------------------------------------------
 137      * Debugging
 138      */
 139     uint32_t getPageFlipCount() const;
 140     void dump(String8& result, char* buffer, size_t SIZE) const;
 141
 142 private:
 143     void init(EGLConfig config);
 144
 145     /*
 146      *  Constants, set during initialization
 147      */
 148     sp<SurfaceFlinger> mFlinger;
 149     DisplayType mType;
 150     int32_t mHwcDisplayId;
 151     wp<IBinder> mDisplayToken;
 152
 153     // ANativeWindow this display is rendering into
 154     sp<ANativeWindow> mNativeWindow;
 155
 156     // set if mNativeWindow is a FramebufferSurface
 157     sp<FramebufferSurface> mFramebufferSurface;
 158
 159     EGLDisplay      mDisplay;
 160     EGLSurface      mSurface;
 161     EGLContext      mContext;
 162     int             mDisplayWidth;
 163     int             mDisplayHeight;
 164     PixelFormat     mFormat;
 165     uint32_t        mFlags;
 166     mutable uint32_t mPageFlipCount;
 167     String8         mDisplayName;
 168
 169     /*
 170      * Can only accessed from the main thread, these members
 171      * don't need synchronization.
 172      */
 173
 174     // list of visible layers on that display
 175     Vector< sp<LayerBase> > mVisibleLayersSortedByZ;
 176
 177     // Whether we have a visible secure layer on this display
 178     bool mSecureLayerVisible;
 179
 180     // Whether the screen is blanked;
 181     mutable int mScreenAcquired;
 182
 183
 184     /*
 185      * Transaction state
 186      */
 187     static status_t orientationToTransfrom(int orientation,
 188             int w, int h, Transform* tr);
 189
 190     void updateGeometryTransform();
 191
 192     uint32_t mLayerStack;
 193     int mOrientation;
 194     Rect mViewport;
 195     Rect mFrame;
 196     Transform mGlobalTransform;
 197     bool mNeedsFiltering;
 198 };
 199
 200 }; // namespace android
 201
 202 #endif // ANDROID_DISPLAY_DEVICE_H