blob: 7693a80a76b65584f3bf2fbbccf3cdea991109f1 [file] [log] [blame]
Ady Abraham9fc28052021-10-14 17:21:38 -07001/*
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"
Dominik Laskowski6b049ff2023-01-29 15:46:45 -050020
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -040021#include <ftl/shared_mutex.h>
Dominik Laskowski6b049ff2023-01-29 15:46:45 -050022#include <ui/DisplayMap.h>
Ady Abraham9fc28052021-10-14 17:21:38 -070023
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -040024#include <functional>
Ady Abraham9fc28052021-10-14 17:21:38 -070025#include <optional>
26#include <string>
Ady Abraham9fc28052021-10-14 17:21:38 -070027#include <utility>
28#include <vector>
29
30// TODO(b/129481165): remove the #pragma below and fix conversion issues
31#pragma clang diagnostic push
32#pragma clang diagnostic ignored "-Wconversion"
33#pragma clang diagnostic ignored "-Wextra"
34
35#include <android/hardware/graphics/composer/2.4/IComposer.h>
36#include <android/hardware/graphics/composer/2.4/IComposerClient.h>
37
38#include <aidl/android/hardware/graphics/composer3/IComposer.h>
39#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
Ady Abrahambea99ba2021-12-15 18:17:52 -080040#include <android/hardware/graphics/composer3/ComposerClientReader.h>
41#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
Ady Abraham9fc28052021-10-14 17:21:38 -070042
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050043#include <aidl/android/hardware/graphics/composer3/Composition.h>
Leon Scroggins III5967aec2021-12-29 11:14:22 -050044#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050045
Ady Abraham9fc28052021-10-14 17:21:38 -070046// TODO(b/129481165): remove the #pragma below and fix conversion issues
47#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
48
49namespace android::Hwc2 {
50
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050051using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
Kriti Dang674b9372022-11-18 10:58:44 +010052using aidl::android::hardware::graphics::common::HdrConversionCapability;
53using aidl::android::hardware::graphics::common::HdrConversionStrategy;
Ady Abrahambea99ba2021-12-15 18:17:52 -080054using aidl::android::hardware::graphics::composer3::ComposerClientReader;
55using aidl::android::hardware::graphics::composer3::ComposerClientWriter;
Sally Qi0cbd08b2022-08-17 12:12:28 -070056using aidl::android::hardware::graphics::composer3::OverlayProperties;
Ady Abraham9fc28052021-10-14 17:21:38 -070057
58class AidlIComposerCallbackWrapper;
59
Ady Abraham9fc28052021-10-14 17:21:38 -070060// Composer is a wrapper to IComposer, a proxy to server-side composer.
61class AidlComposer final : public Hwc2::Composer {
62public:
63 static bool isDeclared(const std::string& serviceName);
64
65 explicit AidlComposer(const std::string& serviceName);
66 ~AidlComposer() override;
67
Ady Abraham4d211cf2021-12-14 16:19:03 -080068 bool isSupported(OptionalFeature) const;
ramindani0cd1d8d2023-06-13 13:43:23 -070069 bool getDisplayConfigurationsSupported() const;
Ady Abraham4d211cf2021-12-14 16:19:03 -080070
Ady Abrahamde549d42022-01-26 19:19:17 -080071 std::vector<aidl::android::hardware::graphics::composer3::Capability> getCapabilities()
72 override;
Ady Abraham9fc28052021-10-14 17:21:38 -070073 std::string dumpDebugInfo() override;
74
Yichi Chen3401b562022-01-17 15:42:35 +080075 void registerCallback(HWC2::ComposerCallback& callback) override;
Ady Abraham9fc28052021-10-14 17:21:38 -070076
Ady Abraham9fc28052021-10-14 17:21:38 -070077 // Explicitly flush all pending commands in the command buffer.
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -040078 Error executeCommands(Display) override;
Ady Abraham9fc28052021-10-14 17:21:38 -070079
80 uint32_t getMaxVirtualDisplayCount() override;
81 Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
82 Display* outDisplay) override;
83 Error destroyVirtualDisplay(Display display) override;
84
85 Error acceptDisplayChanges(Display display) override;
86
87 Error createLayer(Display display, Layer* outLayer) override;
88 Error destroyLayer(Display display, Layer layer) override;
89
90 Error getActiveConfig(Display display, Config* outConfig) override;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050091 Error getChangedCompositionTypes(
92 Display display, std::vector<Layer>* outLayers,
93 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes)
94 override;
Ady Abraham9fc28052021-10-14 17:21:38 -070095 Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;
96 Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
97 int32_t* outValue) override;
98 Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
ramindani263a3f12023-07-18 20:44:49 -070099 Error getDisplayConfigurations(Display, int32_t maxFrameIntervalNs,
100 std::vector<DisplayConfiguration>*);
Ady Abraham9fc28052021-10-14 17:21:38 -0700101 Error getDisplayName(Display display, std::string* outName) override;
102
103 Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
104 std::vector<Layer>* outLayers,
105 std::vector<uint32_t>* outLayerRequestMasks) override;
106
107 Error getDozeSupport(Display display, bool* outSupport) override;
ramindani32cf0602022-03-02 02:30:29 +0000108 Error hasDisplayIdleTimerCapability(Display display, bool* outSupport) override;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100109 Error getHdrCapabilities(Display display, std::vector<Hdr>* outHdrTypes, float* outMaxLuminance,
Ady Abraham9fc28052021-10-14 17:21:38 -0700110 float* outMaxAverageLuminance, float* outMinLuminance) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -0700111 Error getOverlaySupport(OverlayProperties* outProperties) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700112
113 Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
114 std::vector<int>* outReleaseFences) override;
115
116 Error presentDisplay(Display display, int* outPresentFence) override;
117
118 Error setActiveConfig(Display display, Config config) override;
119
120 /*
121 * The composer caches client targets internally. When target is nullptr,
122 * the composer uses slot to look up the client target from its cache.
123 * When target is not nullptr, the cache is updated with the new target.
124 */
125 Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
126 int acquireFence, Dataspace dataspace,
127 const std::vector<IComposerClient::Rect>& damage) override;
128 Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
Ady Abrahamdc011a92021-12-21 14:06:44 -0800129 Error setColorTransform(Display display, const float* matrix) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700130 Error setOutputBuffer(Display display, const native_handle_t* buffer,
131 int releaseFence) override;
132 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
133 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;
134
135 Error setClientTargetSlotCount(Display display) override;
136
Ady Abraham43065bd2021-12-10 17:22:15 -0800137 Error validateDisplay(Display display, nsecs_t expectedPresentTime, uint32_t* outNumTypes,
Ady Abraham9fc28052021-10-14 17:21:38 -0700138 uint32_t* outNumRequests) override;
139
Ady Abraham43065bd2021-12-10 17:22:15 -0800140 Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime,
141 uint32_t* outNumTypes, uint32_t* outNumRequests,
Ady Abraham9fc28052021-10-14 17:21:38 -0700142 int* outPresentFence, 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;
Brian Lindahlb158a5c2022-12-15 15:21:13 -0700148 Error setLayerBufferSlotsToClear(Display display, Layer layer,
149 const std::vector<uint32_t>& slotsToClear,
150 uint32_t activeBufferSlot) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700151 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;
Ady Abraham6e60b142022-01-06 18:10:35 -0800154 Error setLayerColor(Display display, Layer layer, const Color& color) override;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500155 Error setLayerCompositionType(
156 Display display, Layer layer,
157 aidl::android::hardware::graphics::composer3::Composition type) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700158 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;
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000195 Error setDisplayBrightness(Display display, float brightness, float brightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -0800196 const DisplayBrightnessOptions& options) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700197
198 // Composer HAL 2.4
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500199 Error getDisplayCapabilities(
200 Display display,
201 std::vector<aidl::android::hardware::graphics::composer3::DisplayCapability>*
202 outCapabilities) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700203 V2_4::Error getDisplayConnectionType(Display display,
204 IComposerClient::DisplayConnectionType* outType) override;
205 V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override;
206 V2_4::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;
Alec Mouri85065692022-03-18 00:58:26 +0000220 Error getClientTargetProperty(
221 Display display,
222 aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness*
223 outClientTargetProperty) override;
Leon Scroggins IIId77d3162022-01-05 10:42:28 -0500224
225 // AIDL Composer HAL
Alec Mouri6da0e272022-02-07 12:45:57 -0800226 Error setLayerBrightness(Display display, Layer layer, float brightness) override;
Leon Scroggins IIId77d3162022-01-05 10:42:28 -0500227 Error setLayerBlockingRegion(Display display, Layer layer,
228 const std::vector<IComposerClient::Rect>& blocking) override;
Kriti Dang7defaf32021-11-15 11:55:43 +0100229 Error setBootDisplayConfig(Display displayId, Config) override;
230 Error clearBootDisplayConfig(Display displayId) override;
231 Error getPreferredBootDisplayConfig(Display displayId, Config*) override;
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500232 Error getDisplayDecorationSupport(Display display,
233 std::optional<DisplayDecorationSupport>* support) override;
ramindani32cf0602022-03-02 02:30:29 +0000234 Error setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) override;
Ady Abraham9fc28052021-10-14 17:21:38 -0700235
ramindani06e518e2022-03-14 18:47:53 +0000236 Error getPhysicalDisplayOrientation(Display displayId,
237 AidlTransform* outDisplayOrientation) override;
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400238 void onHotplugConnect(Display) override;
239 void onHotplugDisconnect(Display) override;
Kriti Dang674b9372022-11-18 10:58:44 +0100240 Error getHdrConversionCapabilities(std::vector<HdrConversionCapability>*) override;
Kriti Dangd432bb52023-02-09 18:21:04 +0100241 Error setHdrConversionStrategy(HdrConversionStrategy, Hdr*) override;
ramindanib2158ee2023-02-13 20:29:59 -0800242 Error setRefreshRateChangedCallbackDebugEnabled(Display, bool) override;
ramindani3acaaf52023-09-25 10:31:27 -0700243 Error notifyExpectedPresent(Display, nsecs_t expectedPresentTime,
244 int32_t frameIntervalNs) override;
ramindani06e518e2022-03-14 18:47:53 +0000245
Ady Abraham9fc28052021-10-14 17:21:38 -0700246private:
Ady Abraham9fc28052021-10-14 17:21:38 -0700247 // Many public functions above simply write a command into the command
248 // queue to batch the calls. validateDisplay and presentDisplay will call
249 // this function to execute the command queue.
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400250 Error execute(Display) REQUIRES_SHARED(mMutex);
Ady Abraham9fc28052021-10-14 17:21:38 -0700251
252 // returns the default instance name for the given service
253 static std::string instance(const std::string& serviceName);
254
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400255 ftl::Optional<std::reference_wrapper<ComposerClientWriter>> getWriter(Display)
256 REQUIRES_SHARED(mMutex);
257 ftl::Optional<std::reference_wrapper<ComposerClientReader>> getReader(Display)
258 REQUIRES_SHARED(mMutex);
259 void addDisplay(Display) EXCLUDES(mMutex);
260 void removeDisplay(Display) EXCLUDES(mMutex);
261 void addReader(Display) REQUIRES(mMutex);
262 void removeReader(Display) REQUIRES(mMutex);
263
264 bool hasMultiThreadedPresentSupport(Display);
265
Ady Abraham9fc28052021-10-14 17:21:38 -0700266 // 64KiB minus a small space for metadata such as read/write pointers
267 static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16;
268 // Max number of buffers that may be cached for a given layer
269 // We obtain this number by:
270 // 1. Tightly coupling this cache to the max size of BufferQueue
271 // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)
272 static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400273
274 // Without DisplayCapability::MULTI_THREADED_PRESENT, we use a single reader
275 // for all displays. With the capability, we use a separate reader for each
276 // display.
277 bool mSingleReader = true;
278 // Invalid displayId used as a key to mReaders when mSingleReader is true.
279 static constexpr int64_t kSingleReaderKey = 0;
280
Dominik Laskowski6b049ff2023-01-29 15:46:45 -0500281 ui::PhysicalDisplayMap<Display, ComposerClientWriter> mWriters GUARDED_BY(mMutex);
282 ui::PhysicalDisplayMap<Display, ComposerClientReader> mReaders GUARDED_BY(mMutex);
283
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400284 // Protect access to mWriters and mReaders with a shared_mutex. Adding and
285 // removing a display require exclusive access, since the iterator or the
286 // writer/reader may be invalidated. Other calls need shared access while
287 // using the writer/reader, so they can use their display's writer/reader
288 // without it being deleted or the iterator being invalidated.
289 // TODO (b/257958323): Use std::shared_mutex and RAII once they support
290 // threading annotations.
291 ftl::SharedMutex mMutex;
Ady Abraham9fc28052021-10-14 17:21:38 -0700292
ramindani0cd1d8d2023-06-13 13:43:23 -0700293 int32_t mComposerInterfaceVersion = 1;
294
Brian Lindahl90553da2022-12-06 13:36:30 -0700295 // Buffer slots for layers are cleared by setting the slot buffer to this buffer.
296 sp<GraphicBuffer> mClearSlotBuffer;
297
Ady Abraham9fc28052021-10-14 17:21:38 -0700298 // Aidl interface
299 using AidlIComposer = aidl::android::hardware::graphics::composer3::IComposer;
300 using AidlIComposerClient = aidl::android::hardware::graphics::composer3::IComposerClient;
301 std::shared_ptr<AidlIComposer> mAidlComposer;
302 std::shared_ptr<AidlIComposerClient> mAidlComposerClient;
303 std::shared_ptr<AidlIComposerCallbackWrapper> mAidlComposerCallback;
304};
305
306} // namespace android::Hwc2