blob: cf677955bf073626713cdddbba305eca8064d61b [file] [log] [blame]
Chia-I Wuaab99f52016-10-05 12:59:58 +08001/*
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
Ady Abraham9fc28052021-10-14 17:21:38 -070017#pragma once
Chia-I Wuaab99f52016-10-05 12:59:58 +080018
Chia-I Wucd8d7f02016-11-16 11:02:31 +080019#include <memory>
Chia-I Wuaab99f52016-10-05 12:59:58 +080020
Ady Abraham8a82ba62020-01-17 12:43:17 -080021// TODO(b/129481165): remove the #pragma below and fix conversion issues
22#pragma clang diagnostic push
23#pragma clang diagnostic ignored "-Wconversion"
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010024#pragma clang diagnostic ignored "-Wextra"
Ady Abraham8a82ba62020-01-17 12:43:17 -080025
Peiyong Linafa0f572020-01-13 16:35:02 -080026#include <composer-command-buffer/2.4/ComposerCommandBuffer.h>
Alec Mourie7cc1c22021-04-27 15:23:26 -070027#include <gui/BufferQueue.h>
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070028#include <gui/HdrMetadata.h>
Peiyong Lin0e7a7912018-04-05 14:36:36 -070029#include <math/mat4.h>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070030#include <ui/DisplayedFrameStats.h>
Lloyd Piqued0094aa2017-12-20 16:43:28 -080031#include <ui/GraphicBuffer.h>
Chia-I Wuaab99f52016-10-05 12:59:58 +080032#include <utils/StrongPointer.h>
33
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050034#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Kriti Dang674b9372022-11-18 10:58:44 +010035#include <aidl/android/hardware/graphics/common/HdrConversionCapability.h>
36#include <aidl/android/hardware/graphics/common/HdrConversionStrategy.h>
Ady Abrahamde549d42022-01-26 19:19:17 -080037#include <aidl/android/hardware/graphics/composer3/Capability.h>
Alec Mouri85065692022-03-18 00:58:26 +000038#include <aidl/android/hardware/graphics/composer3/ClientTargetPropertyWithBrightness.h>
Ady Abraham6e60b142022-01-06 18:10:35 -080039#include <aidl/android/hardware/graphics/composer3/Color.h>
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050040#include <aidl/android/hardware/graphics/composer3/Composition.h>
Leon Scroggins III5967aec2021-12-29 11:14:22 -050041#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
Yichi Chen3401b562022-01-17 15:42:35 +080042#include <aidl/android/hardware/graphics/composer3/IComposerCallback.h>
Sally Qi0cbd08b2022-08-17 12:12:28 -070043#include <aidl/android/hardware/graphics/composer3/OverlayProperties.h>
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050044
ramindani06e518e2022-03-14 18:47:53 +000045#include <aidl/android/hardware/graphics/common/Transform.h>
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050046#include <optional>
47
Ady Abraham8a82ba62020-01-17 12:43:17 -080048// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010049#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
Ady Abraham8a82ba62020-01-17 12:43:17 -080050
Yichi Chen3401b562022-01-17 15:42:35 +080051namespace android {
52namespace HWC2 {
53struct ComposerCallback;
54} // namespace HWC2
55
56namespace Hwc2 {
Chia-I Wuaab99f52016-10-05 12:59:58 +080057
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070058namespace types = hardware::graphics::common;
Chia-I Wuaab99f52016-10-05 12:59:58 +080059
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070060namespace V2_1 = hardware::graphics::composer::V2_1;
61namespace V2_2 = hardware::graphics::composer::V2_2;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070062namespace V2_3 = hardware::graphics::composer::V2_3;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070063namespace V2_4 = hardware::graphics::composer::V2_4;
Yichi Chen3401b562022-01-17 15:42:35 +080064namespace V3_0 = ::aidl::android::hardware::graphics::composer3;
Chia-I Wuaab99f52016-10-05 12:59:58 +080065
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070066using types::V1_0::ColorTransform;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070067using types::V1_0::Transform;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070068using types::V1_1::RenderIntent;
Valerie Hau9758ae02018-10-09 16:05:09 -070069using types::V1_2::ColorMode;
70using types::V1_2::Dataspace;
Kevin DuBois73d0f482019-01-25 11:18:03 -080071using types::V1_2::PixelFormat;
Valerie Haue9e843a2018-12-18 13:39:23 -080072
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070073using V2_1::Config;
74using V2_1::Display;
75using V2_1::Error;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070076using V2_1::Layer;
Peiyong Linafa0f572020-01-13 16:35:02 -080077using V2_4::CommandReaderBase;
78using V2_4::CommandWriterBase;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070079using V2_4::IComposer;
Ady Abraham7159f572019-10-11 11:10:18 -070080using V2_4::IComposerCallback;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070081using V2_4::IComposerClient;
Ady Abraham7159f572019-10-11 11:10:18 -070082using V2_4::VsyncPeriodChangeTimeline;
83using V2_4::VsyncPeriodNanos;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070084using PerFrameMetadata = IComposerClient::PerFrameMetadata;
85using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
Valerie Haue9e843a2018-12-18 13:39:23 -080086using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob;
ramindani06e518e2022-03-14 18:47:53 +000087using AidlTransform = ::aidl::android::hardware::graphics::common::Transform;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +010088using aidl::android::hardware::graphics::common::Hdr;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070089
Lloyd Piquea822d522017-12-20 16:42:57 -080090class Composer {
91public:
Ady Abraham9fc28052021-10-14 17:21:38 -070092 static std::unique_ptr<Composer> create(const std::string& serviceName);
93
Lloyd Piquea822d522017-12-20 16:42:57 -080094 virtual ~Composer() = 0;
95
Ady Abraham4d211cf2021-12-14 16:19:03 -080096 enum class OptionalFeature {
97 RefreshRateSwitching,
Ady Abraham43065bd2021-12-10 17:22:15 -080098 ExpectedPresentTime,
Alec Mouricdf16792021-12-10 13:16:06 -080099 // Whether setDisplayBrightness is able to be applied as part of a display command.
100 DisplayBrightnessCommand,
ramindani32cf0602022-03-02 02:30:29 +0000101 KernelIdleTimer,
ramindani06e518e2022-03-14 18:47:53 +0000102 PhysicalDisplayOrientation,
Ady Abraham4d211cf2021-12-14 16:19:03 -0800103 };
104
105 virtual bool isSupported(OptionalFeature) const = 0;
106
Ady Abrahamde549d42022-01-26 19:19:17 -0800107 virtual std::vector<aidl::android::hardware::graphics::composer3::Capability>
108 getCapabilities() = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800109 virtual std::string dumpDebugInfo() = 0;
110
Yichi Chen3401b562022-01-17 15:42:35 +0800111 virtual void registerCallback(HWC2::ComposerCallback& callback) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800112
Lloyd Piquea822d522017-12-20 16:42:57 -0800113 // Explicitly flush all pending commands in the command buffer.
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400114 virtual Error executeCommands(Display) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800115
116 virtual uint32_t getMaxVirtualDisplayCount() = 0;
Dominik Laskowski13948602021-03-08 20:48:28 -0800117 virtual Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat*,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700118 Display* outDisplay) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800119 virtual Error destroyVirtualDisplay(Display display) = 0;
120
121 virtual Error acceptDisplayChanges(Display display) = 0;
122
123 virtual Error createLayer(Display display, Layer* outLayer) = 0;
124 virtual Error destroyLayer(Display display, Layer layer) = 0;
125
126 virtual Error getActiveConfig(Display display, Config* outConfig) = 0;
Yichi Chen3401b562022-01-17 15:42:35 +0800127 virtual Error getChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,
128 std::vector<V3_0::Composition>* outTypes) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800129 virtual Error getColorModes(Display display, std::vector<ColorMode>* outModes) = 0;
130 virtual Error getDisplayAttribute(Display display, Config config,
131 IComposerClient::Attribute attribute, int32_t* outValue) = 0;
132 virtual Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs) = 0;
133 virtual Error getDisplayName(Display display, std::string* outName) = 0;
134
135 virtual Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
136 std::vector<Layer>* outLayers,
137 std::vector<uint32_t>* outLayerRequestMasks) = 0;
138
Lloyd Piquea822d522017-12-20 16:42:57 -0800139 virtual Error getDozeSupport(Display display, bool* outSupport) = 0;
ramindani32cf0602022-03-02 02:30:29 +0000140 virtual Error hasDisplayIdleTimerCapability(Display display, bool* outSupport) = 0;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100141 virtual Error getHdrCapabilities(Display display, std::vector<Hdr>* outHdrTypes,
Lloyd Piquea822d522017-12-20 16:42:57 -0800142 float* outMaxLuminance, float* outMaxAverageLuminance,
143 float* outMinLuminance) = 0;
144
145 virtual Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
146 std::vector<int>* outReleaseFences) = 0;
147
148 virtual Error presentDisplay(Display display, int* outPresentFence) = 0;
149
150 virtual Error setActiveConfig(Display display, Config config) = 0;
151
152 /*
153 * The composer caches client targets internally. When target is nullptr,
154 * the composer uses slot to look up the client target from its cache.
155 * When target is not nullptr, the cache is updated with the new target.
156 */
157 virtual Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
158 int acquireFence, Dataspace dataspace,
159 const std::vector<IComposerClient::Rect>& damage) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700160 virtual Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) = 0;
Ady Abrahamdc011a92021-12-21 14:06:44 -0800161 virtual Error setColorTransform(Display display, const float* matrix) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800162 virtual Error setOutputBuffer(Display display, const native_handle_t* buffer,
163 int releaseFence) = 0;
164 virtual Error setPowerMode(Display display, IComposerClient::PowerMode mode) = 0;
165 virtual Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) = 0;
166
167 virtual Error setClientTargetSlotCount(Display display) = 0;
168
Ady Abraham43065bd2021-12-10 17:22:15 -0800169 virtual Error validateDisplay(Display display, nsecs_t expectedPresentTime,
170 uint32_t* outNumTypes, uint32_t* outNumRequests) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800171
Ady Abraham43065bd2021-12-10 17:22:15 -0800172 virtual Error presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime,
173 uint32_t* outNumTypes, uint32_t* outNumRequests,
174 int* outPresentFence, uint32_t* state) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800175
176 virtual Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) = 0;
177 /* see setClientTarget for the purpose of slot */
178 virtual Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
179 const sp<GraphicBuffer>& buffer, int acquireFence) = 0;
Brian Lindahlb158a5c2022-12-15 15:21:13 -0700180 virtual Error setLayerBufferSlotsToClear(Display display, Layer layer,
181 const std::vector<uint32_t>& slotsToClear,
182 uint32_t activeBufferSlot) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800183 virtual Error setLayerSurfaceDamage(Display display, Layer layer,
184 const std::vector<IComposerClient::Rect>& damage) = 0;
185 virtual Error setLayerBlendMode(Display display, Layer layer,
186 IComposerClient::BlendMode mode) = 0;
Ady Abraham6e60b142022-01-06 18:10:35 -0800187 virtual Error setLayerColor(
188 Display display, Layer layer,
189 const aidl::android::hardware::graphics::composer3::Color& color) = 0;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500190 virtual Error setLayerCompositionType(
191 Display display, Layer layer,
192 aidl::android::hardware::graphics::composer3::Composition type) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800193 virtual Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) = 0;
194 virtual Error setLayerDisplayFrame(Display display, Layer layer,
195 const IComposerClient::Rect& frame) = 0;
196 virtual Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) = 0;
197 virtual Error setLayerSidebandStream(Display display, Layer layer,
198 const native_handle_t* stream) = 0;
199 virtual Error setLayerSourceCrop(Display display, Layer layer,
200 const IComposerClient::FRect& crop) = 0;
201 virtual Error setLayerTransform(Display display, Layer layer, Transform transform) = 0;
202 virtual Error setLayerVisibleRegion(Display display, Layer layer,
203 const std::vector<IComposerClient::Rect>& visible) = 0;
204 virtual Error setLayerZOrder(Display display, Layer layer, uint32_t z) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700205
206 // Composer HAL 2.2
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700207 virtual Error setLayerPerFrameMetadata(
208 Display display, Layer layer,
209 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) = 0;
Chia-I Wud7e01d72018-06-21 13:39:09 +0800210 virtual std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
211 Display display) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700212 virtual Error getRenderIntents(Display display, ColorMode colorMode,
213 std::vector<RenderIntent>* outRenderIntents) = 0;
214 virtual Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) = 0;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700215
216 // Composer HAL 2.3
217 virtual Error getDisplayIdentificationData(Display display, uint8_t* outPort,
218 std::vector<uint8_t>* outData) = 0;
Peiyong Lin698147a2018-09-14 13:27:18 -0700219 virtual Error setLayerColorTransform(Display display, Layer layer,
220 const float* matrix) = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700221 virtual Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
222 Dataspace* outDataspace,
223 uint8_t* outComponentMask) = 0;
Kevin DuBois74e53772018-11-19 10:52:38 -0800224 virtual Error setDisplayContentSamplingEnabled(Display display, bool enabled,
225 uint8_t componentMask, uint64_t maxFrames) = 0;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700226 virtual Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
227 DisplayedFrameStats* outStats) = 0;
Valerie Haue9e843a2018-12-18 13:39:23 -0800228 virtual Error setLayerPerFrameMetadataBlobs(
229 Display display, Layer layer, const std::vector<PerFrameMetadataBlob>& metadata) = 0;
Alec Mouricdf16792021-12-10 13:16:06 -0800230 // Options for setting the display brightness
231 struct DisplayBrightnessOptions {
232 // If true, then immediately submits a brightness change request to composer. Otherwise,
233 // submission of the brightness change may be deferred until presenting the next frame.
234 // applyImmediately should only be false if OptionalFeature::DisplayBrightnessCommand is
235 // supported.
236 bool applyImmediately = true;
Alec Mouricdf16792021-12-10 13:16:06 -0800237
238 bool operator==(const DisplayBrightnessOptions& other) const {
Alec Mouri90a19272021-12-30 14:11:38 -0800239 return applyImmediately == other.applyImmediately;
Alec Mouricdf16792021-12-10 13:16:06 -0800240 }
241 };
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000242 virtual Error setDisplayBrightness(Display display, float brightness, float brightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -0800243 const DisplayBrightnessOptions& options) = 0;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700244
245 // Composer HAL 2.4
Yichi Chen3401b562022-01-17 15:42:35 +0800246 virtual Error getDisplayCapabilities(Display display,
247 std::vector<V3_0::DisplayCapability>* outCapabilities) = 0;
Ady Abraham7159f572019-10-11 11:10:18 -0700248 virtual V2_4::Error getDisplayConnectionType(
249 Display display, IComposerClient::DisplayConnectionType* outType) = 0;
250 virtual V2_4::Error getDisplayVsyncPeriod(Display display,
251 VsyncPeriodNanos* outVsyncPeriod) = 0;
252 virtual V2_4::Error setActiveConfigWithConstraints(
253 Display display, Config config,
254 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
255 VsyncPeriodChangeTimeline* outTimeline) = 0;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100256
257 virtual V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) = 0;
258 virtual V2_4::Error getSupportedContentTypes(
259 Display displayId,
260 std::vector<IComposerClient::ContentType>* outSupportedContentTypes) = 0;
261 virtual V2_4::Error setContentType(Display displayId,
262 IComposerClient::ContentType contentType) = 0;
Dan Stoza18d48cb2019-10-21 15:39:24 -0700263 virtual V2_4::Error setLayerGenericMetadata(Display display, Layer layer,
264 const std::string& key, bool mandatory,
265 const std::vector<uint8_t>& value) = 0;
266 virtual V2_4::Error getLayerGenericMetadataKeys(
267 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) = 0;
Kriti Dang7defaf32021-11-15 11:55:43 +0100268
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700269 virtual Error getClientTargetProperty(
Alec Mouri85065692022-03-18 00:58:26 +0000270 Display display, V3_0::ClientTargetPropertyWithBrightness* outClientTargetProperty) = 0;
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700271
272 // AIDL Composer
Alec Mouri6da0e272022-02-07 12:45:57 -0800273 virtual Error setLayerBrightness(Display display, Layer layer, float brightness) = 0;
Leon Scroggins IIId77d3162022-01-05 10:42:28 -0500274 virtual Error setLayerBlockingRegion(Display display, Layer layer,
275 const std::vector<IComposerClient::Rect>& blocking) = 0;
Kriti Dang7defaf32021-11-15 11:55:43 +0100276 virtual Error setBootDisplayConfig(Display displayId, Config) = 0;
277 virtual Error clearBootDisplayConfig(Display displayId) = 0;
278 virtual Error getPreferredBootDisplayConfig(Display displayId, Config*) = 0;
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500279 virtual Error getDisplayDecorationSupport(
280 Display display,
281 std::optional<::aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
282 support) = 0;
ramindani32cf0602022-03-02 02:30:29 +0000283 virtual Error setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) = 0;
ramindani06e518e2022-03-14 18:47:53 +0000284 virtual Error getPhysicalDisplayOrientation(Display displayId,
285 AidlTransform* outDisplayOrientation) = 0;
Sally Qi0cbd08b2022-08-17 12:12:28 -0700286 virtual Error getOverlaySupport(V3_0::OverlayProperties* outProperties) = 0;
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400287 virtual void onHotplugConnect(Display) = 0;
288 virtual void onHotplugDisconnect(Display) = 0;
Kriti Dang674b9372022-11-18 10:58:44 +0100289 virtual Error getHdrConversionCapabilities(
290 std::vector<::aidl::android::hardware::graphics::common::HdrConversionCapability>*) = 0;
291 virtual Error setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +0100292 ::aidl::android::hardware::graphics::common::HdrConversionStrategy, Hdr*) = 0;
ramindanib2158ee2023-02-13 20:29:59 -0800293 virtual Error setRefreshRateChangedCallbackDebugEnabled(Display, bool) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800294};
295
Yichi Chen3401b562022-01-17 15:42:35 +0800296} // namespace Hwc2
297} // namespace android