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 46struct ANativeWindow; 47 48namespace android { 49 50struct DisplayInfo; 51class DisplaySurface; 52class Fence; 53class IGraphicBufferProducer; 54class Layer; 55class SurfaceFlinger; 56class HWComposer; 57 58class DisplayDevice : public LightRefBase<DisplayDevice> 59{ 60public: 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 209private: 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 279struct 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 304