1 /* 2 * Copyright 2016 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 <optional> 22 #include <string> 23 #include <unordered_map> 24 #include <utility> 25 #include <vector> 26 27 // TODO(b/129481165): remove the #pragma below and fix conversion issues 28 #pragma clang diagnostic push 29 #pragma clang diagnostic ignored "-Wconversion" 30 #pragma clang diagnostic ignored "-Wextra" 31 32 #include <composer-command-buffer/2.4/ComposerCommandBuffer.h> 33 #include <gui/BufferQueue.h> 34 #include <gui/HdrMetadata.h> 35 #include <math/mat4.h> 36 #include <ui/DisplayedFrameStats.h> 37 #include <ui/GraphicBuffer.h> 38 #include <utils/StrongPointer.h> 39 40 #include <aidl/android/hardware/graphics/composer3/Composition.h> 41 42 // TODO(b/129481165): remove the #pragma below and fix conversion issues 43 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra" 44 45 namespace android::Hwc2 { 46 47 namespace types = hardware::graphics::common; 48 49 namespace V2_1 = hardware::graphics::composer::V2_1; 50 namespace V2_2 = hardware::graphics::composer::V2_2; 51 namespace V2_3 = hardware::graphics::composer::V2_3; 52 namespace V2_4 = hardware::graphics::composer::V2_4; 53 54 using types::V1_0::ColorTransform; 55 using types::V1_0::Transform; 56 using types::V1_1::RenderIntent; 57 using types::V1_2::ColorMode; 58 using types::V1_2::Dataspace; 59 using types::V1_2::PixelFormat; 60 61 using V2_1::Config; 62 using V2_1::Display; 63 using V2_1::Layer; 64 using V2_4::CommandReaderBase; 65 using V2_4::CommandWriterBase; 66 using V2_4::IComposer; 67 using V2_4::IComposerCallback; 68 using V2_4::IComposerClient; 69 using V2_4::VsyncPeriodChangeTimeline; 70 using V2_4::VsyncPeriodNanos; 71 using PerFrameMetadata = IComposerClient::PerFrameMetadata; 72 using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey; 73 using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob; 74 75 class CommandReader : public CommandReaderBase { 76 public: 77 ~CommandReader(); 78 79 // Parse and execute commands from the command queue. The commands are 80 // actually return values from the server and will be saved in ReturnData. 81 Error parse(); 82 83 // Get and clear saved errors. 84 struct CommandError { 85 uint32_t location; 86 Error error; 87 }; 88 std::vector<CommandError> takeErrors(); 89 90 bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes, 91 uint32_t* outNumLayerRequestMasks) const; 92 93 // Get and clear saved changed composition types. 94 void takeChangedCompositionTypes( 95 Display display, std::vector<Layer>* outLayers, 96 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes); 97 98 // Get and clear saved display requests. 99 void takeDisplayRequests(Display display, uint32_t* outDisplayRequestMask, 100 std::vector<Layer>* outLayers, 101 std::vector<uint32_t>* outLayerRequestMasks); 102 103 // Get and clear saved release fences. 104 void takeReleaseFences(Display display, std::vector<Layer>* outLayers, 105 std::vector<int>* outReleaseFences); 106 107 // Get and clear saved present fence. 108 void takePresentFence(Display display, int* outPresentFence); 109 110 // Get what stage succeeded during PresentOrValidate: Present or Validate 111 void takePresentOrValidateStage(Display display, uint32_t* state); 112 113 // Get the client target properties requested by hardware composer. 114 void takeClientTargetProperty(Display display, 115 IComposerClient::ClientTargetProperty* outClientTargetProperty); 116 117 private: 118 void resetData(); 119 120 bool parseSelectDisplay(uint16_t length); 121 bool parseSetError(uint16_t length); 122 bool parseSetChangedCompositionTypes(uint16_t length); 123 bool parseSetDisplayRequests(uint16_t length); 124 bool parseSetPresentFence(uint16_t length); 125 bool parseSetReleaseFences(uint16_t length); 126 bool parseSetPresentOrValidateDisplayResult(uint16_t length); 127 bool parseSetClientTargetProperty(uint16_t length); 128 129 struct ReturnData { 130 uint32_t displayRequests = 0; 131 132 std::vector<Layer> changedLayers; 133 std::vector<aidl::android::hardware::graphics::composer3::Composition> compositionTypes; 134 135 std::vector<Layer> requestedLayers; 136 std::vector<uint32_t> requestMasks; 137 138 int presentFence = -1; 139 140 std::vector<Layer> releasedLayers; 141 std::vector<int> releaseFences; 142 143 uint32_t presentOrValidateState; 144 145 // Composer 2.4 implementation can return a client target property 146 // structure to indicate the client target properties that hardware 147 // composer requests. The composer client must change the client target 148 // properties to match this request. 149 IComposerClient::ClientTargetProperty clientTargetProperty{PixelFormat::RGBA_8888, 150 Dataspace::UNKNOWN}; 151 }; 152 153 std::vector<CommandError> mErrors; 154 std::unordered_map<Display, ReturnData> mReturnData; 155 156 // When SELECT_DISPLAY is parsed, this is updated to point to the 157 // display's return data in mReturnData. We use it to avoid repeated 158 // map lookups. 159 ReturnData* mCurrentReturnData; 160 }; 161 162 // Composer is a wrapper to IComposer, a proxy to server-side composer. 163 class HidlComposer final : public Composer { 164 public: 165 explicit HidlComposer(const std::string& serviceName); 166 ~HidlComposer() override; 167 168 bool isSupported(OptionalFeature) const; 169 bool isVrrSupported() const; 170 171 std::vector<aidl::android::hardware::graphics::composer3::Capability> getCapabilities() 172 override; 173 std::string dumpDebugInfo() override; 174 175 void registerCallback(HWC2::ComposerCallback& callback) override; 176 177 // Explicitly flush all pending commands in the command buffer. 178 Error executeCommands(Display) override; 179 180 uint32_t getMaxVirtualDisplayCount() override; 181 Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format, 182 Display* outDisplay) override; 183 Error destroyVirtualDisplay(Display display) override; 184 185 Error acceptDisplayChanges(Display display) override; 186 187 Error createLayer(Display display, Layer* outLayer) override; 188 Error destroyLayer(Display display, Layer layer) override; 189 190 Error getActiveConfig(Display display, Config* outConfig) override; 191 Error getChangedCompositionTypes( 192 Display display, std::vector<Layer>* outLayers, 193 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes) 194 override; 195 Error getColorModes(Display display, std::vector<ColorMode>* outModes) override; 196 Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute, 197 int32_t* outValue) override; 198 Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs); 199 Error getDisplayConfigurations(Display, int32_t maxFrameIntervalNs, 200 std::vector<DisplayConfiguration>*); 201 Error getDisplayName(Display display, std::string* outName) override; 202 203 Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask, 204 std::vector<Layer>* outLayers, 205 std::vector<uint32_t>* outLayerRequestMasks) override; 206 207 Error getDozeSupport(Display display, bool* outSupport) override; 208 Error hasDisplayIdleTimerCapability(Display display, bool* outSupport) override; 209 Error getHdrCapabilities(Display display, std::vector<Hdr>* outHdrTypes, float* outMaxLuminance, 210 float* outMaxAverageLuminance, float* outMinLuminance) override; 211 Error getOverlaySupport(aidl::android::hardware::graphics::composer3::OverlayProperties* 212 outProperties) override; 213 214 Error getReleaseFences(Display display, std::vector<Layer>* outLayers, 215 std::vector<int>* outReleaseFences) override; 216 217 Error getLayerPresentFences(Display display, std::vector<Layer>* outLayers, 218 std::vector<int>* outFences, 219 std::vector<int64_t>* outLatenciesNanos) override; 220 221 Error presentDisplay(Display display, int* outPresentFence) override; 222 223 Error setActiveConfig(Display display, Config config) override; 224 225 /* 226 * The composer caches client targets internally. When target is nullptr, 227 * the composer uses slot to look up the client target from its cache. 228 * When target is not nullptr, the cache is updated with the new target. 229 */ 230 Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target, 231 int acquireFence, Dataspace dataspace, 232 const std::vector<IComposerClient::Rect>& damage, 233 float hdrSdrRatio) override; 234 Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override; 235 Error setColorTransform(Display display, const float* matrix) override; 236 Error setOutputBuffer(Display display, const native_handle_t* buffer, 237 int releaseFence) override; 238 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override; 239 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override; 240 241 Error setClientTargetSlotCount(Display display) override; 242 243 Error validateDisplay(Display display, nsecs_t expectedPresentTime, int32_t frameIntervalNs, 244 uint32_t* outNumTypes, uint32_t* outNumRequests) override; 245 246 Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime, 247 int32_t frameIntervalNs, uint32_t* outNumTypes, 248 uint32_t* outNumRequests, int* outPresentFence, 249 uint32_t* state) override; 250 251 Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override; 252 /* see setClientTarget for the purpose of slot */ 253 Error setLayerBuffer(Display display, Layer layer, uint32_t slot, 254 const sp<GraphicBuffer>& buffer, int acquireFence) override; 255 Error setLayerBufferSlotsToClear(Display display, Layer layer, 256 const std::vector<uint32_t>& slotsToClear, 257 uint32_t activeBufferSlot) override; 258 Error setLayerSurfaceDamage(Display display, Layer layer, 259 const std::vector<IComposerClient::Rect>& damage) override; 260 Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override; 261 Error setLayerColor(Display display, Layer layer, 262 const aidl::android::hardware::graphics::composer3::Color& color) override; 263 Error setLayerCompositionType( 264 Display display, Layer layer, 265 aidl::android::hardware::graphics::composer3::Composition type) override; 266 Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override; 267 Error setLayerDisplayFrame(Display display, Layer layer, 268 const IComposerClient::Rect& frame) override; 269 Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override; 270 Error setLayerSidebandStream(Display display, Layer layer, 271 const native_handle_t* stream) override; 272 Error setLayerSourceCrop(Display display, Layer layer, 273 const IComposerClient::FRect& crop) override; 274 Error setLayerTransform(Display display, Layer layer, Transform transform) override; 275 Error setLayerVisibleRegion(Display display, Layer layer, 276 const std::vector<IComposerClient::Rect>& visible) override; 277 Error setLayerZOrder(Display display, Layer layer, uint32_t z) override; 278 279 // Composer HAL 2.2 280 Error setLayerPerFrameMetadata( 281 Display display, Layer layer, 282 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override; 283 std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys( 284 Display display) override; 285 Error getRenderIntents(Display display, ColorMode colorMode, 286 std::vector<RenderIntent>* outRenderIntents) override; 287 Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override; 288 289 // Composer HAL 2.3 290 Error getDisplayIdentificationData(Display display, uint8_t* outPort, 291 std::vector<uint8_t>* outData) override; 292 Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override; 293 Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat, 294 Dataspace* outDataspace, 295 uint8_t* outComponentMask) override; 296 Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask, 297 uint64_t maxFrames) override; 298 Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp, 299 DisplayedFrameStats* outStats) override; 300 Error setLayerPerFrameMetadataBlobs( 301 Display display, Layer layer, 302 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override; 303 Error setDisplayBrightness(Display display, float brightness, float brightnessNits, 304 const DisplayBrightnessOptions& options) override; 305 306 // Composer HAL 2.4 307 Error getDisplayCapabilities( 308 Display display, 309 std::vector<aidl::android::hardware::graphics::composer3::DisplayCapability>* 310 outCapabilities) override; 311 V2_4::Error getDisplayConnectionType(Display display, 312 IComposerClient::DisplayConnectionType* outType) override; 313 V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override; 314 Error setActiveConfigWithConstraints( 315 Display display, Config config, 316 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints, 317 VsyncPeriodChangeTimeline* outTimeline) override; 318 V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override; 319 V2_4::Error getSupportedContentTypes( 320 Display displayId, 321 std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override; 322 V2_4::Error setContentType(Display displayId, 323 IComposerClient::ContentType contentType) override; 324 V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key, 325 bool mandatory, const std::vector<uint8_t>& value) override; 326 V2_4::Error getLayerGenericMetadataKeys( 327 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override; 328 Error getClientTargetProperty( 329 Display display, 330 aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness* 331 outClientTargetProperty) override; 332 333 // AIDL Composer HAL 334 Error setLayerBrightness(Display display, Layer layer, float brightness) override; 335 Error setLayerBlockingRegion(Display display, Layer layer, 336 const std::vector<IComposerClient::Rect>& blocking) override; 337 Error setBootDisplayConfig(Display displayId, Config) override; 338 Error clearBootDisplayConfig(Display displayId) override; 339 Error getPreferredBootDisplayConfig(Display displayId, Config*) override; 340 Error getDisplayDecorationSupport( 341 Display display, 342 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>* 343 support) override; 344 Error setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) override; 345 346 Error getPhysicalDisplayOrientation(Display displayId, 347 AidlTransform* outDisplayOrientation) override; 348 void onHotplugConnect(Display) override; 349 void onHotplugDisconnect(Display) override; 350 Error getHdrConversionCapabilities( 351 std::vector<aidl::android::hardware::graphics::common::HdrConversionCapability>*) 352 override; 353 Error setHdrConversionStrategy(aidl::android::hardware::graphics::common::HdrConversionStrategy, 354 Hdr*) override; 355 Error setRefreshRateChangedCallbackDebugEnabled(Display, bool) override; 356 Error notifyExpectedPresent(Display, nsecs_t, int32_t) override; 357 Error getRequestedLuts( 358 Display, std::vector<Layer>*, 359 std::vector<aidl::android::hardware::graphics::composer3::DisplayLuts::LayerLut>*) 360 override; 361 Error setLayerLuts(Display, Layer, 362 aidl::android::hardware::graphics::composer3::Luts&) override; 363 Error getMaxLayerPictureProfiles(Display, int32_t* outMaxProfiles) override; 364 Error setDisplayPictureProfileId(Display, PictureProfileId) override; 365 Error setLayerPictureProfileId(Display, Layer, PictureProfileId) override; 366 Error startHdcpNegotiation(Display, const aidl::android::hardware::drm::HdcpLevels&) override; 367 Error getLuts(Display, const std::vector<sp<GraphicBuffer>>&, 368 std::vector<aidl::android::hardware::graphics::composer3::Luts>*) override; 369 370 private: 371 class CommandWriter : public CommandWriterBase { 372 public: CommandWriter(uint32_t initialMaxSize)373 explicit CommandWriter(uint32_t initialMaxSize) : CommandWriterBase(initialMaxSize) {} ~CommandWriter()374 ~CommandWriter() override {} 375 }; 376 377 void registerCallback(const sp<IComposerCallback>& callback); 378 379 // Many public functions above simply write a command into the command 380 // queue to batch the calls. validateDisplay and presentDisplay will call 381 // this function to execute the command queue. 382 Error execute(); 383 384 sp<V2_1::IComposer> mComposer; 385 386 sp<V2_1::IComposerClient> mClient; 387 sp<V2_2::IComposerClient> mClient_2_2; 388 sp<V2_3::IComposerClient> mClient_2_3; 389 sp<IComposerClient> mClient_2_4; 390 391 // Buffer slots for layers are cleared by setting the slot buffer to this buffer. 392 sp<GraphicBuffer> mClearSlotBuffer; 393 394 // 64KiB minus a small space for metadata such as read/write pointers 395 static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16; 396 // Max number of buffers that may be cached for a given layer 397 // We obtain this number by: 398 // 1. Tightly coupling this cache to the max size of BufferQueue 399 // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h) 400 static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1; 401 CommandWriter mWriter; 402 CommandReader mReader; 403 }; 404 405 } // namespace android::Hwc2 406