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 "Transform.h"
  21
  22 #include <stdlib.h>
  23
  24 #ifndef USE_HWC2
  25 #include <ui/PixelFormat.h>
  26 #endif
  27 #include <ui/Region.h>
  28
  29 #include <EGL/egl.h>
  30 #include <EGL/eglext.h>
  31
  32 #ifdef USE_HWC2
  33 #include <binder/IBinder.h>
  34 #include <utils/RefBase.h>
  35 #endif
  36 #include <utils/Mutex.h>
  37 #include <utils/String8.h>
  38 #include <utils/Timers.h>
  39
  40 #include <hardware/hwcomposer_defs.h>
  41
  42 #ifdef USE_HWC2
  43 #include <memory>
  44 #endif
  45
  46 struct ANativeWindow;
  47
  48 namespace android {
  49
  50 struct DisplayInfo;
  51 class DisplaySurface;
  52 class Fence;
  53 class IGraphicBufferProducer;
  54 class Layer;
  55 class SurfaceFlinger;
  56 class HWComposer;
  57
  58 class DisplayDevice : public LightRefBase<DisplayDevice>
  59 {
  60 public:
  61     // region in layer-stack space
  62     mutable Region dirtyRegion;
  63     // region in screen space
  64     mutable Region swapRegion;
  65     // region in screen space
  66     Region undefinedRegion;
  67     bool lastCompositionHadVisibleLayers;
  68
  69     enum DisplayType {
  70         DISPLAY_ID_INVALID = -1,
  71         DISPLAY_PRIMARY     = HWC_DISPLAY_PRIMARY,
  72         DISPLAY_EXTERNAL    = HWC_DISPLAY_EXTERNAL,
  73         DISPLAY_VIRTUAL     = HWC_DISPLAY_VIRTUAL,
  74         NUM_BUILTIN_DISPLAY_TYPES = HWC_NUM_PHYSICAL_DISPLAY_TYPES,
  75     };
  76
  77     enum {
  78         PARTIAL_UPDATES = 0x00020000, // video driver feature
  79         SWAP_RECTANGLE  = 0x00080000,
  80     };
  81
  82     enum {
  83         NO_LAYER_STACK = 0xFFFFFFFF,
  84     };
  85
  86     // clang-format off
  87     DisplayDevice(
  88             const sp<SurfaceFlinger>& flinger,
  89             DisplayType type,
  90             int32_t hwcId,
  91 #ifndef USE_HWC2
  92             int format,
  93 #endif
  94             bool isSecure,
  95             const wp<IBinder>& displayToken,
  96             const sp<DisplaySurface>& displaySurface,
  97             const sp<IGraphicBufferProducer>& producer,
  98             EGLConfig config,
  99             bool supportWideColor);
 100     // clang-format on
 101
 102     ~DisplayDevice();
 103
 104     // whether this is a valid object. An invalid DisplayDevice is returned
 105     // when an non existing id is requested
 106     bool isValid() const;
 107
 108     // isSecure indicates whether this display can be trusted to display
 109     // secure surfaces.
 110     bool isSecure() const { return mIsSecure; }
 111
 112     // Flip the front and back buffers if the back buffer is "dirty".  Might
 113     // be instantaneous, might involve copying the frame buffer around.
 114     void flip(const Region& dirty) const;
 115
 116     int         getWidth() const;
 117     int         getHeight() const;
 118 #ifndef USE_HWC2
 119     PixelFormat getFormat() const;
 120 #endif
 121     uint32_t    getFlags() const;
 122
 123     EGLSurface  getEGLSurface() const;
 124
 125     void                    setVisibleLayersSortedByZ(const Vector< sp<Layer> >& layers);
 126     const Vector< sp<Layer> >& getVisibleLayersSortedByZ() const;
 127     Region                  getDirtyRegion(bool repaintEverything) const;
 128
 129     void                    setLayerStack(uint32_t stack);
 130     void                    setDisplaySize(const int newWidth, const int newHeight);
 131     void                    setProjection(int orientation, const Rect& viewport, const Rect& frame);
 132
 133     int                     getOrientation() const { return mOrientation; }
 134     uint32_t                getOrientationTransform() const;
 135     static uint32_t         getPrimaryDisplayOrientationTransform();
 136     const Transform&        getTransform() const { return mGlobalTransform; }
 137     const Rect              getViewport() const { return mViewport; }
 138     const Rect              getFrame() const { return mFrame; }
 139     const Rect&             getScissor() const { return mScissor; }
 140     bool                    needsFiltering() const { return mNeedsFiltering; }
 141
 142     uint32_t                getLayerStack() const { return mLayerStack; }
 143     int32_t                 getDisplayType() const { return mType; }
 144     int32_t                 getHwcDisplayId() const { return mHwcDisplayId; }
 145     const wp<IBinder>&      getDisplayToken() const { return mDisplayToken; }
 146
 147     // We pass in mustRecompose so we can keep VirtualDisplaySurface's state
 148     // machine happy without actually queueing a buffer if nothing has changed
 149     status_t beginFrame(bool mustRecompose) const;
 150 #ifdef USE_HWC2
 151     status_t prepareFrame(HWComposer& hwc);
 152     bool getWideColorSupport() const { return mDisplayHasWideColor; }
 153 #else
 154     status_t prepareFrame(const HWComposer& hwc) const;
 155 #endif
 156
 157     void swapBuffers(HWComposer& hwc) const;
 158 #ifndef USE_HWC2
 159     status_t compositionComplete() const;
 160 #endif
 161
 162     // called after h/w composer has completed its set() call
 163 #ifdef USE_HWC2
 164     void onSwapBuffersCompleted() const;
 165 #else
 166     void onSwapBuffersCompleted(HWComposer& hwc) const;
 167 #endif
 168
 169     Rect getBounds() const {
 170         return Rect(mDisplayWidth, mDisplayHeight);
 171     }
 172     inline Rect bounds() const { return getBounds(); }
 173
 174     void setDisplayName(const String8& displayName);
 175     const String8& getDisplayName() const { return mDisplayName; }
 176
 177     EGLBoolean makeCurrent(EGLDisplay dpy, EGLContext ctx) const;
 178     void setViewportAndProjection() const;
 179
 180     const sp<Fence>& getClientTargetAcquireFence() const;
 181
 182     /* ------------------------------------------------------------------------
 183      * Display power mode management.
 184      */
 185     int getPowerMode() const;
 186     void setPowerMode(int mode);
 187     bool isDisplayOn() const;
 188
 189 #ifdef USE_HWC2
 190     android_color_mode_t getActiveColorMode() const;
 191     void setActiveColorMode(android_color_mode_t mode);
 192 #endif
 193
 194     /* ------------------------------------------------------------------------
 195      * Display active config management.
 196      */
 197     int getActiveConfig() const;
 198     void setActiveConfig(int mode);
 199
 200     // release HWC resources (if any) for removable displays
 201     void disconnect(HWComposer& hwc);
 202
 203     /* ------------------------------------------------------------------------
 204      * Debugging
 205      */
 206     uint32_t getPageFlipCount() const;
 207     void dump(String8& result) const;
 208
 209 private:
 210     /*
 211      *  Constants, set during initialization
 212      */
 213     sp<SurfaceFlinger> mFlinger;
 214     DisplayType mType;
 215     int32_t mHwcDisplayId;
 216     wp<IBinder> mDisplayToken;
 217
 218     // ANativeWindow this display is rendering into
 219     sp<ANativeWindow> mNativeWindow;
 220     sp<DisplaySurface> mDisplaySurface;
 221
 222     EGLConfig       mConfig;
 223     EGLDisplay      mDisplay;
 224     EGLSurface      mSurface;
 225     int             mDisplayWidth;
 226     int             mDisplayHeight;
 227 #ifndef USE_HWC2
 228     PixelFormat     mFormat;
 229 #endif
 230     uint32_t        mFlags;
 231     mutable uint32_t mPageFlipCount;
 232     String8         mDisplayName;
 233     bool            mIsSecure;
 234
 235     /*
 236      * Can only accessed from the main thread, these members
 237      * don't need synchronization.
 238      */
 239
 240     // list of visible layers on that display
 241     Vector< sp<Layer> > mVisibleLayersSortedByZ;
 242
 243     /*
 244      * Transaction state
 245      */
 246     static status_t orientationToTransfrom(int orientation,
 247             int w, int h, Transform* tr);
 248
 249     // The identifier of the active layer stack for this display. Several displays
 250     // can use the same layer stack: A z-ordered group of layers (sometimes called
 251     // "surfaces"). Any given layer can only be on a single layer stack.
 252     uint32_t mLayerStack;
 253
 254     int mOrientation;
 255     static uint32_t sPrimaryDisplayOrientation;
 256     // user-provided visible area of the layer stack
 257     Rect mViewport;
 258     // user-provided rectangle where mViewport gets mapped to
 259     Rect mFrame;
 260     // pre-computed scissor to apply to the display
 261     Rect mScissor;
 262     Transform mGlobalTransform;
 263     bool mNeedsFiltering;
 264     // Current power mode
 265     int mPowerMode;
 266     // Current active config
 267     int mActiveConfig;
 268 #ifdef USE_HWC2
 269     // current active color mode
 270     android_color_mode_t mActiveColorMode;
 271
 272     // Need to know if display is wide-color capable or not.
 273     // Initialized by SurfaceFlinger when the DisplayDevice is created.
 274     // Fed to RenderEngine during composition.
 275     bool mDisplayHasWideColor;
 276 #endif
 277 };
 278
 279 struct DisplayDeviceState {
 280     DisplayDeviceState() = default;
 281     DisplayDeviceState(DisplayDevice::DisplayType type, bool isSecure);
 282
 283     bool isValid() const { return type >= 0; }
 284     bool isMainDisplay() const { return type == DisplayDevice::DISPLAY_PRIMARY; }
 285     bool isVirtualDisplay() const { return type >= DisplayDevice::DISPLAY_VIRTUAL; }
 286
 287     static std::atomic<int32_t> nextDisplayId;
 288     int32_t displayId = nextDisplayId++;
 289     DisplayDevice::DisplayType type = DisplayDevice::DISPLAY_ID_INVALID;
 290     sp<IGraphicBufferProducer> surface;
 291     uint32_t layerStack = DisplayDevice::NO_LAYER_STACK;
 292     Rect viewport;
 293     Rect frame;
 294     uint8_t orientation = 0;
 295     uint32_t width = 0;
 296     uint32_t height = 0;
 297     String8 displayName;
 298     bool isSecure = false;
 299 };
 300
 301 }; // namespace android
 302
 303 #endif // ANDROID_DISPLAY_DEVICE_H