1 /* 2 * Copyright 2015 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_SF_HWC2_H 18 #define ANDROID_SF_HWC2_H 19 20 #define HWC2_INCLUDE_STRINGIFICATION 21 #define HWC2_USE_CPP11 22 #include <hardware/hwcomposer2.h> 23 #undef HWC2_INCLUDE_STRINGIFICATION 24 #undef HWC2_USE_CPP11 25 26 #include <ui/HdrCapabilities.h> 27 #include <math/mat4.h> 28 29 #include <utils/Log.h> 30 #include <utils/StrongPointer.h> 31 #include <utils/Timers.h> 32 33 #include <functional> 34 #include <string> 35 #include <unordered_map> 36 #include <unordered_set> 37 #include <vector> 38 #include <map> 39 40 namespace android { 41 class Fence; 42 class FloatRect; 43 class GraphicBuffer; 44 class Rect; 45 class Region; 46 namespace Hwc2 { 47 class Composer; 48 } 49 } 50 51 namespace HWC2 { 52 53 class Display; 54 class Layer; 55 56 typedef std::function<void(std::shared_ptr<Display>, Connection)> 57 HotplugCallback; 58 typedef std::function<void(std::shared_ptr<Display>)> RefreshCallback; 59 typedef std::function<void(std::shared_ptr<Display>, nsecs_t)> VsyncCallback; 60 61 // C++ Wrapper around hwc2_device_t. Load all functions pointers 62 // and handle callback registration. 63 class Device 64 { 65 public: 66 // useVrComposer is passed to the composer HAL. When true, the composer HAL 67 // will use the vr composer service, otherwise it uses the real hardware 68 // composer. 69 Device(bool useVrComposer); 70 ~Device(); 71 72 friend class HWC2::Display; 73 friend class HWC2::Layer; 74 75 // Required by HWC2 76 77 std::string dump() const; 78 getCapabilities()79 const std::unordered_set<Capability>& getCapabilities() const { 80 return mCapabilities; 81 }; 82 83 uint32_t getMaxVirtualDisplayCount() const; 84 Error createVirtualDisplay(uint32_t width, uint32_t height, 85 android_pixel_format_t* format, 86 std::shared_ptr<Display>* outDisplay); 87 88 void registerHotplugCallback(HotplugCallback hotplug); 89 void registerRefreshCallback(RefreshCallback refresh); 90 void registerVsyncCallback(VsyncCallback vsync); 91 92 // For use by callbacks 93 94 void callHotplug(std::shared_ptr<Display> display, Connection connected); 95 void callRefresh(std::shared_ptr<Display> display); 96 void callVsync(std::shared_ptr<Display> display, nsecs_t timestamp); 97 98 // Other Device methods 99 100 // This will create a Display if one is not found, but it will not be marked 101 // as connected. This Display may be null if the display has been torn down 102 // but has not been removed from the map yet. 103 std::shared_ptr<Display> getDisplayById(hwc2_display_t id); 104 105 bool hasCapability(HWC2::Capability capability) const; 106 getComposer()107 android::Hwc2::Composer* getComposer() { return mComposer.get(); } 108 109 private: 110 // Initialization methods 111 112 void loadCapabilities(); 113 void registerCallbacks(); 114 115 // For use by Display 116 117 void destroyVirtualDisplay(hwc2_display_t display); 118 119 // Member variables 120 std::unique_ptr<android::Hwc2::Composer> mComposer; 121 122 std::unordered_set<Capability> mCapabilities; 123 std::unordered_map<hwc2_display_t, std::weak_ptr<Display>> mDisplays; 124 125 HotplugCallback mHotplug; 126 std::vector<std::pair<std::shared_ptr<Display>, Connection>> 127 mPendingHotplugs; 128 RefreshCallback mRefresh; 129 std::vector<std::shared_ptr<Display>> mPendingRefreshes; 130 VsyncCallback mVsync; 131 std::vector<std::pair<std::shared_ptr<Display>, nsecs_t>> mPendingVsyncs; 132 }; 133 134 // Convenience C++ class to access hwc2_device_t Display functions directly. 135 class Display : public std::enable_shared_from_this<Display> 136 { 137 public: 138 Display(Device& device, hwc2_display_t id); 139 ~Display(); 140 141 friend class HWC2::Device; 142 friend class HWC2::Layer; 143 144 class Config 145 { 146 public: 147 class Builder 148 { 149 public: 150 Builder(Display& display, hwc2_config_t id); 151 build()152 std::shared_ptr<const Config> build() { 153 return std::const_pointer_cast<const Config>( 154 std::move(mConfig)); 155 } 156 setWidth(int32_t width)157 Builder& setWidth(int32_t width) { 158 mConfig->mWidth = width; 159 return *this; 160 } setHeight(int32_t height)161 Builder& setHeight(int32_t height) { 162 mConfig->mHeight = height; 163 return *this; 164 } setVsyncPeriod(int32_t vsyncPeriod)165 Builder& setVsyncPeriod(int32_t vsyncPeriod) { 166 mConfig->mVsyncPeriod = vsyncPeriod; 167 return *this; 168 } setDpiX(int32_t dpiX)169 Builder& setDpiX(int32_t dpiX) { 170 if (dpiX == -1) { 171 mConfig->mDpiX = getDefaultDensity(); 172 } else { 173 mConfig->mDpiX = dpiX / 1000.0f; 174 } 175 return *this; 176 } setDpiY(int32_t dpiY)177 Builder& setDpiY(int32_t dpiY) { 178 if (dpiY == -1) { 179 mConfig->mDpiY = getDefaultDensity(); 180 } else { 181 mConfig->mDpiY = dpiY / 1000.0f; 182 } 183 return *this; 184 } 185 186 private: 187 float getDefaultDensity(); 188 std::shared_ptr<Config> mConfig; 189 }; 190 getDisplayId()191 hwc2_display_t getDisplayId() const { return mDisplay.getId(); } getId()192 hwc2_config_t getId() const { return mId; } 193 getWidth()194 int32_t getWidth() const { return mWidth; } getHeight()195 int32_t getHeight() const { return mHeight; } getVsyncPeriod()196 nsecs_t getVsyncPeriod() const { return mVsyncPeriod; } getDpiX()197 float getDpiX() const { return mDpiX; } getDpiY()198 float getDpiY() const { return mDpiY; } 199 200 private: 201 Config(Display& display, hwc2_config_t id); 202 203 Display& mDisplay; 204 hwc2_config_t mId; 205 206 int32_t mWidth; 207 int32_t mHeight; 208 nsecs_t mVsyncPeriod; 209 float mDpiX; 210 float mDpiY; 211 }; 212 213 // Required by HWC2 214 215 [[clang::warn_unused_result]] Error acceptChanges(); 216 [[clang::warn_unused_result]] Error createLayer( 217 std::shared_ptr<Layer>* outLayer); 218 [[clang::warn_unused_result]] Error getActiveConfig( 219 std::shared_ptr<const Config>* outConfig) const; 220 [[clang::warn_unused_result]] Error getChangedCompositionTypes( 221 std::unordered_map<std::shared_ptr<Layer>, Composition>* outTypes); 222 [[clang::warn_unused_result]] Error getColorModes( 223 std::vector<android_color_mode_t>* outModes) const; 224 225 // Doesn't call into the HWC2 device, so no errors are possible 226 std::vector<std::shared_ptr<const Config>> getConfigs() const; 227 228 [[clang::warn_unused_result]] Error getName(std::string* outName) const; 229 [[clang::warn_unused_result]] Error getRequests( 230 DisplayRequest* outDisplayRequests, 231 std::unordered_map<std::shared_ptr<Layer>, LayerRequest>* 232 outLayerRequests); 233 [[clang::warn_unused_result]] Error getType(DisplayType* outType) const; 234 [[clang::warn_unused_result]] Error supportsDoze(bool* outSupport) const; 235 [[clang::warn_unused_result]] Error getHdrCapabilities( 236 std::unique_ptr<android::HdrCapabilities>* outCapabilities) const; 237 [[clang::warn_unused_result]] Error getReleaseFences( 238 std::unordered_map<std::shared_ptr<Layer>, 239 android::sp<android::Fence>>* outFences) const; 240 [[clang::warn_unused_result]] Error present( 241 android::sp<android::Fence>* outPresentFence); 242 [[clang::warn_unused_result]] Error setActiveConfig( 243 const std::shared_ptr<const Config>& config); 244 [[clang::warn_unused_result]] Error setClientTarget( 245 uint32_t slot, const android::sp<android::GraphicBuffer>& target, 246 const android::sp<android::Fence>& acquireFence, 247 android_dataspace_t dataspace); 248 [[clang::warn_unused_result]] Error setColorMode(android_color_mode_t mode); 249 [[clang::warn_unused_result]] Error setColorTransform( 250 const android::mat4& matrix, android_color_transform_t hint); 251 [[clang::warn_unused_result]] Error setOutputBuffer( 252 const android::sp<android::GraphicBuffer>& buffer, 253 const android::sp<android::Fence>& releaseFence); 254 [[clang::warn_unused_result]] Error setPowerMode(PowerMode mode); 255 [[clang::warn_unused_result]] Error setVsyncEnabled(Vsync enabled); 256 [[clang::warn_unused_result]] Error validate(uint32_t* outNumTypes, 257 uint32_t* outNumRequests); 258 [[clang::warn_unused_result]] Error presentOrValidate(uint32_t* outNumTypes, 259 uint32_t* outNumRequests, 260 android::sp<android::Fence>* outPresentFence, uint32_t* state); 261 262 // Most methods in this class write a command to a command buffer. The 263 // command buffer is implicitly submitted in validate, present, and 264 // presentOrValidate. This method provides a way to discard the commands, 265 // which can be used to discard stale commands. 266 void discardCommands(); 267 268 // Other Display methods 269 getDevice()270 Device& getDevice() const { return mDevice; } getId()271 hwc2_display_t getId() const { return mId; } isConnected()272 bool isConnected() const { return mIsConnected; } 273 274 private: 275 // For use by Device 276 setConnected(bool connected)277 void setConnected(bool connected) { mIsConnected = connected; } 278 int32_t getAttribute(hwc2_config_t configId, Attribute attribute); 279 void loadConfig(hwc2_config_t configId); 280 void loadConfigs(); 281 282 // For use by Layer 283 void destroyLayer(hwc2_layer_t layerId); 284 285 // This may fail (and return a null pointer) if no layer with this ID exists 286 // on this display 287 std::shared_ptr<Layer> getLayerById(hwc2_layer_t id) const; 288 289 // Member variables 290 291 Device& mDevice; 292 hwc2_display_t mId; 293 bool mIsConnected; 294 DisplayType mType; 295 std::unordered_map<hwc2_layer_t, std::weak_ptr<Layer>> mLayers; 296 // The ordering in this map matters, for getConfigs(), when it is 297 // converted to a vector 298 std::map<hwc2_config_t, std::shared_ptr<const Config>> mConfigs; 299 }; 300 301 // Convenience C++ class to access hwc2_device_t Layer functions directly. 302 class Layer 303 { 304 public: 305 Layer(const std::shared_ptr<Display>& display, hwc2_layer_t id); 306 ~Layer(); 307 isAbandoned()308 bool isAbandoned() const { return mDisplay.expired(); } getId()309 hwc2_layer_t getId() const { return mId; } 310 311 [[clang::warn_unused_result]] Error setCursorPosition(int32_t x, int32_t y); 312 [[clang::warn_unused_result]] Error setBuffer(uint32_t slot, 313 const android::sp<android::GraphicBuffer>& buffer, 314 const android::sp<android::Fence>& acquireFence); 315 [[clang::warn_unused_result]] Error setSurfaceDamage( 316 const android::Region& damage); 317 318 [[clang::warn_unused_result]] Error setBlendMode(BlendMode mode); 319 [[clang::warn_unused_result]] Error setColor(hwc_color_t color); 320 [[clang::warn_unused_result]] Error setCompositionType(Composition type); 321 [[clang::warn_unused_result]] Error setDataspace( 322 android_dataspace_t dataspace); 323 [[clang::warn_unused_result]] Error setDisplayFrame( 324 const android::Rect& frame); 325 [[clang::warn_unused_result]] Error setPlaneAlpha(float alpha); 326 [[clang::warn_unused_result]] Error setSidebandStream( 327 const native_handle_t* stream); 328 [[clang::warn_unused_result]] Error setSourceCrop( 329 const android::FloatRect& crop); 330 [[clang::warn_unused_result]] Error setTransform(Transform transform); 331 [[clang::warn_unused_result]] Error setVisibleRegion( 332 const android::Region& region); 333 [[clang::warn_unused_result]] Error setZOrder(uint32_t z); 334 [[clang::warn_unused_result]] Error setInfo(uint32_t type, uint32_t appId); 335 336 private: 337 std::weak_ptr<Display> mDisplay; 338 hwc2_display_t mDisplayId; 339 Device& mDevice; 340 hwc2_layer_t mId; 341 }; 342 343 } // namespace HWC2 344 345 #endif // ANDROID_SF_HWC2_H 346