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     enum {
  69         NO_LAYER_STACK = 0xFFFFFFFF,
  70     };
  71
  72     DisplayDevice(
  73             const sp<SurfaceFlinger>& flinger,
  74             DisplayType type,
  75             bool isSecure,
  76             const wp<IBinder>& displayToken,
  77             const sp<ANativeWindow>& nativeWindow,
  78             const sp<FramebufferSurface>& framebufferSurface,
  79             EGLConfig config);
  80
  81     ~DisplayDevice();
  82
  83     // whether this is a valid object. An invalid DisplayDevice is returned
  84     // when an non existing id is requested
  85     bool isValid() const;
  86
  87     // isSecure indicates whether this display can be trusted to display
  88     // secure surfaces.
  89     bool isSecure() const { return mIsSecure; }
  90
  91     // Flip the front and back buffers if the back buffer is "dirty".  Might
  92     // be instantaneous, might involve copying the frame buffer around.
  93     void flip(const Region& dirty) const;
  94
  95     int         getWidth() const;
  96     int         getHeight() const;
  97     PixelFormat getFormat() const;
  98     uint32_t    getFlags() const;
  99
 100     EGLSurface  getEGLSurface() const;
 101
 102     void                    setVisibleLayersSortedByZ(const Vector< sp<LayerBase> >& layers);
 103     const Vector< sp<LayerBase> >& getVisibleLayersSortedByZ() const;
 104     bool                    getSecureLayerVisible() const;
 105     Region                  getDirtyRegion(bool repaintEverything) const;
 106
 107     void                    setLayerStack(uint32_t stack);
 108     void                    setProjection(int orientation, const Rect& viewport, const Rect& frame);
 109
 110     int                     getOrientation() const { return mOrientation; }
 111     const Transform&        getTransform() const { return mGlobalTransform; }
 112     const Rect              getViewport() const { return mViewport; }
 113     const Rect              getFrame() const { return mFrame; }
 114     const Rect&             getScissor() const { return mScissor; }
 115     bool                    needsFiltering() const { return mNeedsFiltering; }
 116
 117     uint32_t                getLayerStack() const { return mLayerStack; }
 118     int32_t                 getDisplayType() const { return mType; }
 119     int32_t                 getHwcDisplayId() const { return mHwcDisplayId; }
 120     const wp<IBinder>&      getDisplayToken() const { return mDisplayToken; }
 121
 122     void swapBuffers(HWComposer& hwc) const;
 123     status_t compositionComplete() const;
 124
 125     // called after h/w composer has completed its set() call
 126     void onSwapBuffersCompleted(HWComposer& hwc) const;
 127
 128     Rect getBounds() const {
 129         return Rect(mDisplayWidth, mDisplayHeight);
 130     }
 131     inline Rect bounds() const { return getBounds(); }
 132
 133     void setDisplayName(const String8& displayName);
 134     const String8& getDisplayName() const { return mDisplayName; }
 135
 136     static EGLBoolean makeCurrent(EGLDisplay dpy,
 137             const sp<const DisplayDevice>& hw, EGLContext ctx);
 138
 139     static void setViewportAndProjection(const sp<const DisplayDevice>& hw);
 140
 141     /* ------------------------------------------------------------------------
 142      * blank / unblank management
 143      */
 144     void releaseScreen() const;
 145     void acquireScreen() const;
 146     bool isScreenAcquired() const;
 147     bool canDraw() const;
 148
 149     /* ------------------------------------------------------------------------
 150      * Debugging
 151      */
 152     uint32_t getPageFlipCount() const;
 153     void dump(String8& result, char* buffer, size_t SIZE) const;
 154
 155 private:
 156     void init(EGLConfig config);
 157
 158     /*
 159      *  Constants, set during initialization
 160      */
 161     sp<SurfaceFlinger> mFlinger;
 162     DisplayType mType;
 163     int32_t mHwcDisplayId;
 164     wp<IBinder> mDisplayToken;
 165
 166     // ANativeWindow this display is rendering into
 167     sp<ANativeWindow> mNativeWindow;
 168
 169     // set if mNativeWindow is a FramebufferSurface
 170     sp<FramebufferSurface> mFramebufferSurface;
 171
 172     EGLDisplay      mDisplay;
 173     EGLSurface      mSurface;
 174     EGLContext      mContext;
 175     int             mDisplayWidth;
 176     int             mDisplayHeight;
 177     PixelFormat     mFormat;
 178     uint32_t        mFlags;
 179     mutable uint32_t mPageFlipCount;
 180     String8         mDisplayName;
 181     bool            mIsSecure;
 182
 183     /*
 184      * Can only accessed from the main thread, these members
 185      * don't need synchronization.
 186      */
 187
 188     // list of visible layers on that display
 189     Vector< sp<LayerBase> > mVisibleLayersSortedByZ;
 190
 191     // Whether we have a visible secure layer on this display
 192     bool mSecureLayerVisible;
 193
 194     // Whether the screen is blanked;
 195     mutable int mScreenAcquired;
 196
 197
 198     /*
 199      * Transaction state
 200      */
 201     static status_t orientationToTransfrom(int orientation,
 202             int w, int h, Transform* tr);
 203
 204     uint32_t mLayerStack;
 205     int mOrientation;
 206     // user-provided visible area of the layer stack
 207     Rect mViewport;
 208     // user-provided rectangle where mViewport gets mapped to
 209     Rect mFrame;
 210     // pre-computed scissor to apply to the display
 211     Rect mScissor;
 212     Transform mGlobalTransform;
 213     bool mNeedsFiltering;
 214 };
 215
 216 }; // namespace android
 217
 218 #endif // ANDROID_DISPLAY_DEVICE_H