1 /* 2 * Copyright 2021 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 #pragma once 18 19 #include "ComposerHal.h" 20 21 #include <ftl/shared_mutex.h> 22 #include <ui/DisplayMap.h> 23 24 #include <functional> 25 #include <optional> 26 #include <string> 27 #include <string_view> 28 #include <vector> 29 30 #include <android/hardware/graphics/composer/2.4/IComposer.h> 31 #include <android/hardware/graphics/composer/2.4/IComposerClient.h> 32 33 #include <aidl/android/hardware/graphics/composer3/IComposer.h> 34 #include <aidl/android/hardware/graphics/composer3/IComposerClient.h> 35 #include <android/hardware/graphics/composer3/ComposerClientReader.h> 36 #include <android/hardware/graphics/composer3/ComposerClientWriter.h> 37 38 #include <aidl/android/hardware/graphics/composer3/Composition.h> 39 #include <aidl/android/hardware/graphics/composer3/DisplayCapability.h> 40 41 namespace android::Hwc2 { 42 43 using aidl::android::hardware::graphics::common::DisplayDecorationSupport; 44 using aidl::android::hardware::graphics::common::HdrConversionCapability; 45 using aidl::android::hardware::graphics::common::HdrConversionStrategy; 46 using aidl::android::hardware::graphics::composer3::ComposerClientReader; 47 using aidl::android::hardware::graphics::composer3::ComposerClientWriter; 48 using aidl::android::hardware::graphics::composer3::Luts; 49 using aidl::android::hardware::graphics::composer3::OverlayProperties; 50 51 class AidlIComposerCallbackWrapper; 52 53 // Composer is a wrapper to IComposer, a proxy to server-side composer. 54 class AidlComposer final : public Hwc2::Composer { 55 public: 56 // Returns true if serviceName appears to be something that is meant to be used by AidlComposer. 57 static bool namesAnAidlComposerService(std::string_view serviceName); 58 59 explicit AidlComposer(const std::string& serviceName); 60 ~AidlComposer() override; 61 62 bool isSupported(OptionalFeature) const; 63 bool isVrrSupported() const; 64 65 std::vector<aidl::android::hardware::graphics::composer3::Capability> getCapabilities() 66 override; 67 std::string dumpDebugInfo() override; 68 69 void registerCallback(HWC2::ComposerCallback& callback) override; 70 71 // Explicitly flush all pending commands in the command buffer. 72 Error executeCommands(Display) override; 73 74 uint32_t getMaxVirtualDisplayCount() override; 75 Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format, 76 Display* outDisplay) override; 77 Error destroyVirtualDisplay(Display display) override; 78 79 Error acceptDisplayChanges(Display display) override; 80 81 Error createLayer(Display display, Layer* outLayer) override; 82 Error destroyLayer(Display display, Layer layer) override; 83 84 Error getActiveConfig(Display display, Config* outConfig) override; 85 Error getChangedCompositionTypes( 86 Display display, std::vector<Layer>* outLayers, 87 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes) 88 override; 89 Error getColorModes(Display display, std::vector<ColorMode>* outModes) override; 90 Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute, 91 int32_t* outValue) override; 92 Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs); 93 Error getDisplayConfigurations(Display, int32_t maxFrameIntervalNs, 94 std::vector<DisplayConfiguration>*); 95 Error getDisplayName(Display display, std::string* outName) override; 96 97 Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask, 98 std::vector<Layer>* outLayers, 99 std::vector<uint32_t>* outLayerRequestMasks) override; 100 101 Error getDozeSupport(Display display, bool* outSupport) override; 102 Error hasDisplayIdleTimerCapability(Display display, bool* outSupport) override; 103 Error getHdrCapabilities(Display display, std::vector<Hdr>* outHdrTypes, float* outMaxLuminance, 104 float* outMaxAverageLuminance, float* outMinLuminance) override; 105 Error getOverlaySupport(OverlayProperties* outProperties) override; 106 107 Error getReleaseFences(Display display, std::vector<Layer>* outLayers, 108 std::vector<int>* outReleaseFences) override; 109 110 Error getLayerPresentFences(Display display, std::vector<Layer>* outLayers, 111 std::vector<int>* outFences, 112 std::vector<int64_t>* outLatenciesNanos) override; 113 114 Error presentDisplay(Display display, int* outPresentFence) override; 115 116 Error setActiveConfig(Display display, Config config) override; 117 118 /* 119 * The composer caches client targets internally. When target is nullptr, 120 * the composer uses slot to look up the client target from its cache. 121 * When target is not nullptr, the cache is updated with the new target. 122 */ 123 Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target, 124 int acquireFence, Dataspace dataspace, 125 const std::vector<IComposerClient::Rect>& damage, 126 float hdrSdrRatio) override; 127 Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override; 128 Error setColorTransform(Display display, const float* matrix) override; 129 Error setOutputBuffer(Display display, const native_handle_t* buffer, 130 int releaseFence) override; 131 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override; 132 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override; 133 134 Error setClientTargetSlotCount(Display display) override; 135 136 Error validateDisplay(Display display, nsecs_t expectedPresentTime, int32_t frameIntervalNs, 137 uint32_t* outNumTypes, uint32_t* outNumRequests) override; 138 139 Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime, 140 int32_t frameIntervalNs, uint32_t* outNumTypes, 141 uint32_t* outNumRequests, int* outPresentFence, 142 uint32_t* state) override; 143 144 Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override; 145 /* see setClientTarget for the purpose of slot */ 146 Error setLayerBuffer(Display display, Layer layer, uint32_t slot, 147 const sp<GraphicBuffer>& buffer, int acquireFence) override; 148 Error setLayerBufferSlotsToClear(Display display, Layer layer, 149 const std::vector<uint32_t>& slotsToClear, 150 uint32_t activeBufferSlot) override; 151 Error setLayerSurfaceDamage(Display display, Layer layer, 152 const std::vector<IComposerClient::Rect>& damage) override; 153 Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override; 154 Error setLayerColor(Display display, Layer layer, const Color& color) override; 155 Error setLayerCompositionType( 156 Display display, Layer layer, 157 aidl::android::hardware::graphics::composer3::Composition type) override; 158 Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override; 159 Error setLayerDisplayFrame(Display display, Layer layer, 160 const IComposerClient::Rect& frame) override; 161 Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override; 162 Error setLayerSidebandStream(Display display, Layer layer, 163 const native_handle_t* stream) override; 164 Error setLayerSourceCrop(Display display, Layer layer, 165 const IComposerClient::FRect& crop) override; 166 Error setLayerTransform(Display display, Layer layer, Transform transform) override; 167 Error setLayerVisibleRegion(Display display, Layer layer, 168 const std::vector<IComposerClient::Rect>& visible) override; 169 Error setLayerZOrder(Display display, Layer layer, uint32_t z) override; 170 171 // Composer HAL 2.2 172 Error setLayerPerFrameMetadata( 173 Display display, Layer layer, 174 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override; 175 std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys( 176 Display display) override; 177 Error getRenderIntents(Display display, ColorMode colorMode, 178 std::vector<RenderIntent>* outRenderIntents) override; 179 Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override; 180 181 // Composer HAL 2.3 182 Error getDisplayIdentificationData(Display display, uint8_t* outPort, 183 std::vector<uint8_t>* outData) override; 184 Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override; 185 Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat, 186 Dataspace* outDataspace, 187 uint8_t* outComponentMask) override; 188 Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask, 189 uint64_t maxFrames) override; 190 Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp, 191 DisplayedFrameStats* outStats) override; 192 Error setLayerPerFrameMetadataBlobs( 193 Display display, Layer layer, 194 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override; 195 Error setDisplayBrightness(Display display, float brightness, float brightnessNits, 196 const DisplayBrightnessOptions& options) override; 197 198 // Composer HAL 2.4 199 Error getDisplayCapabilities( 200 Display display, 201 std::vector<aidl::android::hardware::graphics::composer3::DisplayCapability>* 202 outCapabilities) override; 203 V2_4::Error getDisplayConnectionType(Display display, 204 IComposerClient::DisplayConnectionType* outType) override; 205 V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override; 206 Error setActiveConfigWithConstraints( 207 Display display, Config config, 208 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints, 209 VsyncPeriodChangeTimeline* outTimeline) override; 210 V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override; 211 V2_4::Error getSupportedContentTypes( 212 Display displayId, 213 std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override; 214 V2_4::Error setContentType(Display displayId, 215 IComposerClient::ContentType contentType) override; 216 V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key, 217 bool mandatory, const std::vector<uint8_t>& value) override; 218 V2_4::Error getLayerGenericMetadataKeys( 219 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override; 220 Error getClientTargetProperty( 221 Display display, 222 aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness* 223 outClientTargetProperty) override; 224 225 // AIDL Composer HAL 226 Error setLayerBrightness(Display display, Layer layer, float brightness) override; 227 Error setLayerBlockingRegion(Display display, Layer layer, 228 const std::vector<IComposerClient::Rect>& blocking) override; 229 Error setBootDisplayConfig(Display displayId, Config) override; 230 Error clearBootDisplayConfig(Display displayId) override; 231 Error getPreferredBootDisplayConfig(Display displayId, Config*) override; 232 Error getDisplayDecorationSupport(Display display, 233 std::optional<DisplayDecorationSupport>* support) override; 234 Error setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) override; 235 236 Error getPhysicalDisplayOrientation(Display displayId, 237 AidlTransform* outDisplayOrientation) override; 238 void onHotplugConnect(Display) override; 239 void onHotplugDisconnect(Display) override; 240 Error getHdrConversionCapabilities(std::vector<HdrConversionCapability>*) override; 241 Error setHdrConversionStrategy(HdrConversionStrategy, Hdr*) override; 242 Error setRefreshRateChangedCallbackDebugEnabled(Display, bool) override; 243 Error notifyExpectedPresent(Display, nsecs_t expectedPresentTime, 244 int32_t frameIntervalNs) override; 245 Error getRequestedLuts( 246 Display display, std::vector<Layer>* outLayers, 247 std::vector<aidl::android::hardware::graphics::composer3::DisplayLuts::LayerLut>* 248 outLuts) override; 249 Error setLayerLuts(Display display, Layer layer, Luts& luts) override; 250 Error getMaxLayerPictureProfiles(Display, int32_t* outMaxProfiles) override; 251 Error setDisplayPictureProfileId(Display, PictureProfileId id) override; 252 Error setLayerPictureProfileId(Display, Layer, PictureProfileId id) override; 253 Error startHdcpNegotiation(Display, const aidl::android::hardware::drm::HdcpLevels&) override; 254 Error getLuts(Display, const std::vector<sp<GraphicBuffer>>&, 255 std::vector<aidl::android::hardware::graphics::composer3::Luts>*) override; 256 257 private: 258 // Many public functions above simply write a command into the command 259 // queue to batch the calls. validateDisplay and presentDisplay will call 260 // this function to execute the command queue. 261 Error execute(Display) REQUIRES_SHARED(mMutex); 262 263 // Ensures serviceName is fully qualified. 264 static std::string ensureFullyQualifiedName(std::string_view serviceName); 265 266 ftl::Optional<std::reference_wrapper<ComposerClientWriter>> getWriter(Display) 267 REQUIRES_SHARED(mMutex); 268 ftl::Optional<std::reference_wrapper<ComposerClientReader>> getReader(Display) 269 REQUIRES_SHARED(mMutex); 270 void addDisplay(Display) EXCLUDES(mMutex); 271 void removeDisplay(Display) EXCLUDES(mMutex); 272 void addReader(Display) REQUIRES(mMutex); 273 void removeReader(Display) REQUIRES(mMutex); 274 bool getLayerLifecycleBatchCommand(); 275 bool hasMultiThreadedPresentSupport(Display); 276 277 // 64KiB minus a small space for metadata such as read/write pointers 278 static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16; 279 // Max number of buffers that may be cached for a given layer 280 // We obtain this number by: 281 // 1. Tightly coupling this cache to the max size of BufferQueue 282 // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h) 283 static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1; 284 285 // Without DisplayCapability::MULTI_THREADED_PRESENT, we use a single reader 286 // for all displays. With the capability, we use a separate reader for each 287 // display. 288 bool mSingleReader = true; 289 // Invalid displayId used as a key to mReaders when mSingleReader is true. 290 static constexpr int64_t kSingleReaderKey = 0; 291 292 ui::PhysicalDisplayMap<Display, ComposerClientWriter> mWriters GUARDED_BY(mMutex); 293 ui::PhysicalDisplayMap<Display, ComposerClientReader> mReaders GUARDED_BY(mMutex); 294 295 // Protect access to mWriters and mReaders with a shared_mutex. Adding and 296 // removing a display require exclusive access, since the iterator or the 297 // writer/reader may be invalidated. Other calls need shared access while 298 // using the writer/reader, so they can use their display's writer/reader 299 // without it being deleted or the iterator being invalidated. 300 // TODO (b/257958323): Use std::shared_mutex and RAII once they support 301 // threading annotations. 302 ftl::SharedMutex mMutex; 303 304 int32_t mComposerInterfaceVersion = 1; 305 bool mEnableLayerCommandBatchingFlag = false; 306 std::atomic<int64_t> mLayerID = 1; 307 308 // Buffer slots for layers are cleared by setting the slot buffer to this buffer. 309 sp<GraphicBuffer> mClearSlotBuffer; 310 311 // Aidl interface 312 using AidlIComposer = aidl::android::hardware::graphics::composer3::IComposer; 313 using AidlIComposerClient = aidl::android::hardware::graphics::composer3::IComposerClient; 314 std::shared_ptr<AidlIComposer> mAidlComposer; 315 std::shared_ptr<AidlIComposerClient> mAidlComposerClient; 316 std::shared_ptr<AidlIComposerCallbackWrapper> mAidlComposerCallback; 317 }; 318 319 } // namespace android::Hwc2 320