blob: 0c2b77de7d3e7fcffdeb63d61e26738d65044b63 [file] [log] [blame]
Dan Stoza651bf312015-10-23 17:03:17 -07001/*
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
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Dan Stoza651bf312015-10-23 17:03:17 -070021// #define LOG_NDEBUG 0
22
23#undef LOG_TAG
24#define LOG_TAG "HWC2"
25#define ATRACE_TAG ATRACE_TAG_GRAPHICS
26
27#include "HWC2.h"
28
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080029#include <android/configuration.h>
Dan Stoza651bf312015-10-23 17:03:17 -070030#include <ui/Fence.h>
Dan Stoza5a423ea2017-02-16 14:10:39 -080031#include <ui/FloatRect.h>
Dan Stoza651bf312015-10-23 17:03:17 -070032#include <ui/GraphicBuffer.h>
Dan Stoza651bf312015-10-23 17:03:17 -070033
Lloyd Pique3c085a02018-05-09 19:38:32 -070034#include <algorithm>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080035#include <cinttypes>
Lloyd Pique3c085a02018-05-09 19:38:32 -070036#include <iterator>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070037#include <set>
Dan Stoza651bf312015-10-23 17:03:17 -070038
Ady Abraham6e60b142022-01-06 18:10:35 -080039using aidl::android::hardware::graphics::composer3::Color;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050040using aidl::android::hardware::graphics::composer3::Composition;
Ady Abrahamde549d42022-01-26 19:19:17 -080041using AidlCapability = aidl::android::hardware::graphics::composer3::Capability;
Leon Scroggins III5967aec2021-12-29 11:14:22 -050042using aidl::android::hardware::graphics::composer3::DisplayCapability;
Sally Qi0cbd08b2022-08-17 12:12:28 -070043using aidl::android::hardware::graphics::composer3::OverlayProperties;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050044
Peiyong Line9d809e2020-04-14 13:10:48 -070045namespace android {
46
Dan Stoza651bf312015-10-23 17:03:17 -070047using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080048using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070049using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070050using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070051using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070052using android::Rect;
53using android::Region;
54using android::sp;
55
56namespace HWC2 {
57
Peiyong Line9d809e2020-04-14 13:10:48 -070058using namespace android::hardware::graphics::composer::hal;
59
Chia-I Wuaab99f52016-10-05 12:59:58 +080060namespace Hwc2 = android::Hwc2;
61
Steven Thomas94e35b92017-07-26 18:48:28 -070062namespace {
63
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070064inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
65 const Hwc2::PerFrameMetadataKey& key) {
66 return keys.find(key) != keys.end();
67}
68
Steven Thomas94e35b92017-07-26 18:48:28 -070069} // namespace anonymous
70
Dan Stoza651bf312015-10-23 17:03:17 -070071// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -080072Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -070073
Ana Krulec4593b692019-01-11 22:07:25 -080074namespace impl {
Dominik Laskowski55c85402020-01-21 16:25:47 -080075
Peiyong Lin74ca2f42019-01-14 19:36:57 -080076Display::Display(android::Hwc2::Composer& composer,
Ady Abrahamde549d42022-01-26 19:19:17 -080077 const std::unordered_set<AidlCapability>& capabilities, HWDisplayId id,
Lloyd Piquebc792092018-01-17 11:52:30 -080078 DisplayType type)
Peiyong Line9d809e2020-04-14 13:10:48 -070079 : mComposer(composer), mCapabilities(capabilities), mId(id), mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -070080 ALOGV("Created display %" PRIu64, id);
81}
82
Steven Thomas94e35b92017-07-26 18:48:28 -070083Display::~Display() {
Lloyd Piquea516c002021-05-07 14:36:58 -070084 // Note: The calls to onOwningDisplayDestroyed() are allowed (and expected)
85 // to call Display::onLayerDestroyed(). As that call removes entries from
86 // mLayers, we do not want to have a for loop directly over it here. Since
87 // the end goal is an empty mLayers anyway, we just go ahead and swap an
88 // initially empty local container with mLayers, and then enumerate
89 // the contents of the local container.
90 Layers destroyingLayers;
91 std::swap(mLayers, destroyingLayers);
92 for (const auto& [_, weakLayer] : destroyingLayers) {
93 if (std::shared_ptr layer = weakLayer.lock()) {
94 layer->onOwningDisplayDestroyed();
95 }
96 }
Steven Thomas94e35b92017-07-26 18:48:28 -070097
Peiyong Line9d809e2020-04-14 13:10:48 -070098 Error error = Error::NONE;
Dominik Laskowski55c85402020-01-21 16:25:47 -080099 const char* msg;
100 switch (mType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700101 case DisplayType::PHYSICAL:
102 error = setVsyncEnabled(HWC2::Vsync::DISABLE);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800103 msg = "disable VSYNC for";
104 break;
105
Peiyong Line9d809e2020-04-14 13:10:48 -0700106 case DisplayType::VIRTUAL:
Dominik Laskowski55c85402020-01-21 16:25:47 -0800107 error = static_cast<Error>(mComposer.destroyVirtualDisplay(mId));
108 msg = "destroy virtual";
109 break;
110
Peiyong Line9d809e2020-04-14 13:10:48 -0700111 case DisplayType::INVALID: // Used in unit tests.
Dominik Laskowski55c85402020-01-21 16:25:47 -0800112 break;
Dan Stoza651bf312015-10-23 17:03:17 -0700113 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800114
Peiyong Line9d809e2020-04-14 13:10:48 -0700115 ALOGE_IF(error != Error::NONE, "%s: Failed to %s display %" PRIu64 ": %d", __FUNCTION__, msg,
116 mId, static_cast<int32_t>(error));
Dominik Laskowski55c85402020-01-21 16:25:47 -0800117
118 ALOGV("Destroyed display %" PRIu64, mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700119}
120
Dan Stoza651bf312015-10-23 17:03:17 -0700121// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700122Error Display::acceptChanges()
123{
Steven Thomas94e35b92017-07-26 18:48:28 -0700124 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700125 return static_cast<Error>(intError);
126}
127
Lloyd Piquea516c002021-05-07 14:36:58 -0700128base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700129 HWLayerId layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700130 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700131 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700132 if (error != Error::NONE) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700133 return base::unexpected(error);
Dan Stoza651bf312015-10-23 17:03:17 -0700134 }
135
Lloyd Piquea516c002021-05-07 14:36:58 -0700136 auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);
137 mLayers.emplace(layerId, layer);
138 return layer;
Steven Thomas94e35b92017-07-26 18:48:28 -0700139}
140
Lloyd Piquea516c002021-05-07 14:36:58 -0700141void Display::onLayerDestroyed(hal::HWLayerId layerId) {
142 mLayers.erase(layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700143}
144
Ady Abraham7159f572019-10-11 11:10:18 -0700145bool Display::isVsyncPeriodSwitchSupported() const {
146 ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId);
147
Ady Abraham4d211cf2021-12-14 16:19:03 -0800148 return mComposer.isSupported(android::Hwc2::Composer::OptionalFeature::RefreshRateSwitching);
Ady Abraham7159f572019-10-11 11:10:18 -0700149}
150
ramindani32cf0602022-03-02 02:30:29 +0000151bool Display::hasDisplayIdleTimerCapability() const {
152 bool isCapabilitySupported = false;
153 return mComposer.hasDisplayIdleTimerCapability(mId, &isCapabilitySupported) == Error::NONE &&
154 isCapabilitySupported;
155}
156
ramindani06e518e2022-03-14 18:47:53 +0000157Error Display::getPhysicalDisplayOrientation(Hwc2::AidlTransform* outTransform) const {
158 auto error = mComposer.getPhysicalDisplayOrientation(mId, outTransform);
159 return static_cast<Error>(error);
160}
161
Lloyd Pique35d58242018-12-18 16:33:25 -0800162Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800163 std::vector<Hwc2::Layer> layerIds;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500164 std::vector<Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700165 auto intError = mComposer.getChangedCompositionTypes(
166 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800167 uint32_t numElements = layerIds.size();
168 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700169 error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700170 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700171 return error;
172 }
173
174 outTypes->clear();
175 outTypes->reserve(numElements);
176 for (uint32_t element = 0; element < numElements; ++element) {
177 auto layer = getLayerById(layerIds[element]);
178 if (layer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700179 auto type = types[element];
Dan Stoza651bf312015-10-23 17:03:17 -0700180 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
181 layer->getId(), to_string(type).c_str());
Lloyd Piquea516c002021-05-07 14:36:58 -0700182 outTypes->emplace(layer.get(), type);
Dan Stoza651bf312015-10-23 17:03:17 -0700183 } else {
184 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
185 " on display %" PRIu64, layerIds[element], mId);
186 }
187 }
188
Peiyong Line9d809e2020-04-14 13:10:48 -0700189 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700190}
191
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700192Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700193{
Peiyong Linfd997e02018-03-28 15:29:00 -0700194 auto intError = mComposer.getColorModes(mId, outModes);
195 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700196}
197
Chia-I Wud7e01d72018-06-21 13:39:09 +0800198int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700199{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800200 int32_t supportedPerFrameMetadata = 0;
201
202 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
203 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700204
205 // Check whether a specific metadata type is supported. A metadata type is considered
206 // supported if and only if all required fields are supported.
207
208 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700209 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
210 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
211 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
212 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
213 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
214 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
215 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
216 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
217 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
218 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800219 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700220 }
221 // CTA861_3
222 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
223 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800224 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700225 }
226
Valerie Haue9e843a2018-12-18 13:39:23 -0800227 // HDR10PLUS
228 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
229 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
230 }
231
Chia-I Wud7e01d72018-06-21 13:39:09 +0800232 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700233}
234
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700235Error Display::getRenderIntents(ColorMode colorMode,
236 std::vector<RenderIntent>* outRenderIntents) const
237{
238 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
239 return static_cast<Error>(intError);
240}
241
242Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
243{
244 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
245 return static_cast<Error>(intError);
246}
247
Dan Stoza651bf312015-10-23 17:03:17 -0700248Error Display::getName(std::string* outName) const
249{
Steven Thomas94e35b92017-07-26 18:48:28 -0700250 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800251 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700252}
253
254Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800255 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Lloyd Piquee9eff972020-05-05 12:36:44 -0700256 uint32_t intDisplayRequests = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800257 std::vector<Hwc2::Layer> layerIds;
258 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700259 auto intError = mComposer.getDisplayRequests(
260 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800261 uint32_t numElements = layerIds.size();
262 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700263 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700264 return error;
265 }
266
267 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
268 outLayerRequests->clear();
269 outLayerRequests->reserve(numElements);
270 for (uint32_t element = 0; element < numElements; ++element) {
271 auto layer = getLayerById(layerIds[element]);
272 if (layer) {
273 auto layerRequest =
274 static_cast<LayerRequest>(layerRequests[element]);
Lloyd Piquea516c002021-05-07 14:36:58 -0700275 outLayerRequests->emplace(layer.get(), layerRequest);
Dan Stoza651bf312015-10-23 17:03:17 -0700276 } else {
277 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
278 PRIu64, layerIds[element], mId);
279 }
280 }
281
Peiyong Line9d809e2020-04-14 13:10:48 -0700282 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700283}
284
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100285Error Display::getConnectionType(ui::DisplayConnectionType* outType) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700286 if (mType != DisplayType::PHYSICAL) return Error::BAD_DISPLAY;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800287
288 using ConnectionType = Hwc2::IComposerClient::DisplayConnectionType;
289 ConnectionType connectionType;
290 const auto error = static_cast<Error>(mComposer.getDisplayConnectionType(mId, &connectionType));
Peiyong Line9d809e2020-04-14 13:10:48 -0700291 if (error != Error::NONE) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800292 return error;
293 }
294
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100295 *outType = connectionType == ConnectionType::INTERNAL ? ui::DisplayConnectionType::Internal
296 : ui::DisplayConnectionType::External;
Peiyong Line9d809e2020-04-14 13:10:48 -0700297 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700298}
299
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500300bool Display::hasCapability(DisplayCapability capability) const {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700301 std::scoped_lock lock(mDisplayCapabilitiesMutex);
302 if (mDisplayCapabilities) {
303 return mDisplayCapabilities->count(capability) > 0;
304 }
305
Leon Scroggins III515f0382021-12-29 11:17:04 -0500306 ALOGW("Can't query capability %s."
Ady Abraham27fbcc72021-09-20 14:54:57 -0700307 " Display Capabilities were not queried from HWC yet",
Leon Scroggins III515f0382021-12-29 11:17:04 -0500308 to_string(capability).c_str());
Ady Abraham27fbcc72021-09-20 14:54:57 -0700309
310 return false;
311}
312
Peiyong Lined531a32018-10-26 18:27:56 -0700313Error Display::supportsDoze(bool* outSupport) const {
Leon Scroggins III689c80f2023-06-05 17:49:32 -0400314 {
315 std::scoped_lock lock(mDisplayCapabilitiesMutex);
316 if (!mDisplayCapabilities) {
317 // The display has not turned on since boot, so DOZE support is unknown.
318 ALOGW("%s: haven't queried capabilities yet!", __func__);
319 return Error::NO_RESOURCES;
320 }
321 }
Ady Abraham27fbcc72021-09-20 14:54:57 -0700322 *outSupport = hasCapability(DisplayCapability::DOZE);
Peiyong Line9d809e2020-04-14 13:10:48 -0700323 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700324}
325
Peiyong Lin62665892018-04-16 11:07:44 -0700326Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700327{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700328 float maxLuminance = -1.0f;
329 float maxAverageLuminance = -1.0f;
330 float minLuminance = -1.0f;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100331 std::vector<Hwc2::Hdr> hdrTypes;
332 auto intError = mComposer.getHdrCapabilities(mId, &hdrTypes, &maxLuminance,
333 &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800334 auto error = static_cast<HWC2::Error>(intError);
335
Peiyong Line9d809e2020-04-14 13:10:48 -0700336 if (error != Error::NONE) {
Dan Stoza7d7ae732016-03-16 12:23:40 -0700337 return error;
338 }
339
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100340 *outCapabilities =
341 HdrCapabilities(std::move(hdrTypes), maxLuminance, maxAverageLuminance, minLuminance);
Peiyong Line9d809e2020-04-14 13:10:48 -0700342 return Error::NONE;
Dan Stoza7d7ae732016-03-16 12:23:40 -0700343}
344
Sally Qibb866c12022-10-17 11:31:20 -0700345Error Display::getOverlaySupport(OverlayProperties* outProperties) const {
346 auto intError = mComposer.getOverlaySupport(outProperties);
347 return static_cast<Error>(intError);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700348}
349
Peiyong Line9d809e2020-04-14 13:10:48 -0700350Error Display::getDisplayedContentSamplingAttributes(hal::PixelFormat* outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700351 Dataspace* outDataspace,
352 uint8_t* outComponentMask) const {
353 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
354 outComponentMask);
355 return static_cast<Error>(intError);
356}
357
Kevin DuBois74e53772018-11-19 10:52:38 -0800358Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
359 uint64_t maxFrames) const {
360 auto intError =
361 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
362 return static_cast<Error>(intError);
363}
364
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700365Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
366 android::DisplayedFrameStats* outStats) const {
367 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
368 return static_cast<Error>(intError);
369}
370
Lloyd Pique35d58242018-12-18 16:33:25 -0800371Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800372 std::vector<Hwc2::Layer> layerIds;
373 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700374 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800375 auto error = static_cast<Error>(intError);
376 uint32_t numElements = layerIds.size();
Peiyong Line9d809e2020-04-14 13:10:48 -0700377 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700378 return error;
379 }
380
Lloyd Pique35d58242018-12-18 16:33:25 -0800381 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700382 releaseFences.reserve(numElements);
383 for (uint32_t element = 0; element < numElements; ++element) {
384 auto layer = getLayerById(layerIds[element]);
385 if (layer) {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700386 sp<Fence> fence(sp<Fence>::make(fenceFds[element]));
Lloyd Piquea516c002021-05-07 14:36:58 -0700387 releaseFences.emplace(layer.get(), fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700388 } else {
389 ALOGE("getReleaseFences: invalid layer %" PRIu64
390 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700391 for (; element < numElements; ++element) {
392 close(fenceFds[element]);
393 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700394 return Error::BAD_LAYER;
Dan Stoza651bf312015-10-23 17:03:17 -0700395 }
396 }
397
398 *outFences = std::move(releaseFences);
Peiyong Line9d809e2020-04-14 13:10:48 -0700399 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700400}
401
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800402Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700403{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400404 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700405 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700406 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700407 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700408 return error;
409 }
410
Ady Abrahamd11bade2022-08-01 16:18:03 -0700411 *outPresentFence = sp<Fence>::make(presentFenceFd);
Peiyong Line9d809e2020-04-14 13:10:48 -0700412 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700413}
414
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100415Error Display::setActiveConfigWithConstraints(hal::HWConfigId configId,
416 const VsyncPeriodChangeConstraints& constraints,
417 VsyncPeriodChangeTimeline* outTimeline) {
Ady Abraham7159f572019-10-11 11:10:18 -0700418 ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId);
Ady Abraham7159f572019-10-11 11:10:18 -0700419
420 if (isVsyncPeriodSwitchSupported()) {
421 Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints;
422 hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos;
423 hwc2Constraints.seamlessRequired = constraints.seamlessRequired;
424
425 Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {};
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100426 auto intError = mComposer.setActiveConfigWithConstraints(mId, configId, hwc2Constraints,
427 &vsyncPeriodChangeTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -0700428 outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos;
429 outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired;
430 outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos;
431 return static_cast<Error>(intError);
432 }
433
434 // Use legacy setActiveConfig instead
435 ALOGV("fallback to legacy setActiveConfig");
436 const auto now = systemTime();
437 if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) {
438 ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied");
439 }
440
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100441 auto intError_2_4 = mComposer.setActiveConfig(mId, configId);
Ady Abraham7159f572019-10-11 11:10:18 -0700442 outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos);
443 outTimeline->refreshRequired = true;
444 outTimeline->refreshTimeNanos = now;
445 return static_cast<Error>(intError_2_4);
446}
447
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400448Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700449 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700450{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700451 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700452 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700453 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700454 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700455 return static_cast<Error>(intError);
456}
457
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700458Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700459{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700460 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700461 return static_cast<Error>(intError);
462}
463
Ady Abrahamdc011a92021-12-21 14:06:44 -0800464Error Display::setColorTransform(const android::mat4& matrix) {
465 auto intError = mComposer.setColorTransform(mId, matrix.asArray());
Dan Stoza5df2a862016-03-24 16:19:37 -0700466 return static_cast<Error>(intError);
467}
468
Dan Stoza651bf312015-10-23 17:03:17 -0700469Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
470 const sp<Fence>& releaseFence)
471{
472 int32_t fenceFd = releaseFence->dup();
473 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700474 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700475 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700476 return static_cast<Error>(intError);
477}
478
479Error Display::setPowerMode(PowerMode mode)
480{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800481 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700482 auto intError = mComposer.setPowerMode(mId, intMode);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700483
Peiyong Line9d809e2020-04-14 13:10:48 -0700484 if (mode == PowerMode::ON) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700485 std::call_once(mDisplayCapabilityQueryFlag, [this]() {
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500486 std::vector<DisplayCapability> tmpCapabilities;
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700487 auto error =
488 static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
Peiyong Line9d809e2020-04-14 13:10:48 -0700489 if (error == Error::NONE) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700490 std::scoped_lock lock(mDisplayCapabilitiesMutex);
491 mDisplayCapabilities.emplace();
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700492 for (auto capability : tmpCapabilities) {
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500493 mDisplayCapabilities->emplace(capability);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700494 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700495 } else if (error == Error::UNSUPPORTED) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700496 std::scoped_lock lock(mDisplayCapabilitiesMutex);
497 mDisplayCapabilities.emplace();
Ady Abrahamde549d42022-01-26 19:19:17 -0800498 if (mCapabilities.count(AidlCapability::SKIP_CLIENT_COLOR_TRANSFORM)) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700499 mDisplayCapabilities->emplace(DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700500 }
501 bool dozeSupport = false;
502 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
Peiyong Line9d809e2020-04-14 13:10:48 -0700503 if (error == Error::NONE && dozeSupport) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700504 mDisplayCapabilities->emplace(DisplayCapability::DOZE);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700505 }
506 }
507 });
508 }
509
Dan Stoza651bf312015-10-23 17:03:17 -0700510 return static_cast<Error>(intError);
511}
512
513Error Display::setVsyncEnabled(Vsync enabled)
514{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800515 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700516 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700517 return static_cast<Error>(intError);
518}
519
Ady Abraham43065bd2021-12-10 17:22:15 -0800520Error Display::validate(nsecs_t expectedPresentTime, uint32_t* outNumTypes,
521 uint32_t* outNumRequests) {
Dan Stoza651bf312015-10-23 17:03:17 -0700522 uint32_t numTypes = 0;
523 uint32_t numRequests = 0;
Ady Abraham43065bd2021-12-10 17:22:15 -0800524 auto intError = mComposer.validateDisplay(mId, expectedPresentTime, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700525 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700526 if (error != Error::NONE && !hasChangesError(error)) {
Dan Stoza651bf312015-10-23 17:03:17 -0700527 return error;
528 }
529
530 *outNumTypes = numTypes;
531 *outNumRequests = numRequests;
532 return error;
533}
534
Ady Abraham43065bd2021-12-10 17:22:15 -0800535Error Display::presentOrValidate(nsecs_t expectedPresentTime, uint32_t* outNumTypes,
536 uint32_t* outNumRequests, sp<android::Fence>* outPresentFence,
537 uint32_t* state) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700538 uint32_t numTypes = 0;
539 uint32_t numRequests = 0;
540 int32_t presentFenceFd = -1;
Ady Abraham43065bd2021-12-10 17:22:15 -0800541 auto intError = mComposer.presentOrValidateDisplay(mId, expectedPresentTime, &numTypes,
542 &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700543 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700544 if (error != Error::NONE && !hasChangesError(error)) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700545 return error;
546 }
547
548 if (*state == 1) {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700549 *outPresentFence = sp<Fence>::make(presentFenceFd);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700550 }
551
552 if (*state == 0) {
553 *outNumTypes = numTypes;
554 *outNumRequests = numRequests;
555 }
556 return error;
557}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700558
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700559ftl::Future<Error> Display::setDisplayBrightness(
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000560 float brightness, float brightnessNits,
561 const Hwc2::Composer::DisplayBrightnessOptions& options) {
562 return ftl::defer([composer = &mComposer, id = mId, brightness, brightnessNits, options] {
563 const auto intError =
564 composer->setDisplayBrightness(id, brightness, brightnessNits, options);
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700565 return static_cast<Error>(intError);
566 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000567}
568
Kriti Dang7defaf32021-11-15 11:55:43 +0100569Error Display::setBootDisplayConfig(hal::HWConfigId configId) {
570 auto intError = mComposer.setBootDisplayConfig(mId, configId);
571 return static_cast<Error>(intError);
572}
573
574Error Display::clearBootDisplayConfig() {
575 auto intError = mComposer.clearBootDisplayConfig(mId);
576 return static_cast<Error>(intError);
577}
578
579Error Display::getPreferredBootDisplayConfig(hal::HWConfigId* configId) const {
580 auto intError = mComposer.getPreferredBootDisplayConfig(mId, configId);
581 return static_cast<Error>(intError);
582}
583
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700584Error Display::setAutoLowLatencyMode(bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100585 auto intError = mComposer.setAutoLowLatencyMode(mId, on);
586 return static_cast<Error>(intError);
587}
588
589Error Display::getSupportedContentTypes(std::vector<ContentType>* outSupportedContentTypes) const {
590 std::vector<Hwc2::IComposerClient::ContentType> tmpSupportedContentTypes;
591 auto intError = mComposer.getSupportedContentTypes(mId, &tmpSupportedContentTypes);
592 for (Hwc2::IComposerClient::ContentType contentType : tmpSupportedContentTypes) {
593 outSupportedContentTypes->push_back(static_cast<ContentType>(contentType));
594 }
595 return static_cast<Error>(intError);
596}
597
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700598Error Display::setContentType(ContentType contentType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700599 auto intError = mComposer.setContentType(mId, contentType);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100600 return static_cast<Error>(intError);
601}
602
Alec Mouri85065692022-03-18 00:58:26 +0000603Error Display::getClientTargetProperty(
604 aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness*
605 outClientTargetProperty) {
606 const auto error = mComposer.getClientTargetProperty(mId, outClientTargetProperty);
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700607 return static_cast<Error>(error);
608}
609
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500610Error Display::getDisplayDecorationSupport(
611 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
612 support) {
613 const auto error = mComposer.getDisplayDecorationSupport(mId, support);
614 return static_cast<Error>(error);
615}
616
ramindani32cf0602022-03-02 02:30:29 +0000617Error Display::setIdleTimerEnabled(std::chrono::milliseconds timeout) {
618 const auto error = mComposer.setIdleTimerEnabled(mId, timeout);
619 return static_cast<Error>(error);
620}
621
Dan Stoza651bf312015-10-23 17:03:17 -0700622// For use by Device
623
Steven Thomas94e35b92017-07-26 18:48:28 -0700624void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800625 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700626 mComposer.setClientTargetSlotCount(mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700627 }
628 mIsConnected = connected;
629}
630
Dan Stoza651bf312015-10-23 17:03:17 -0700631// Other Display methods
632
Lloyd Piquea516c002021-05-07 14:36:58 -0700633std::shared_ptr<HWC2::Layer> Display::getLayerById(HWLayerId id) const {
634 auto it = mLayers.find(id);
635 return it != mLayers.end() ? it->second.lock() : nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700636}
Ana Krulec4593b692019-01-11 22:07:25 -0800637} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700638
639// Layer methods
640
Leon Scroggins III4459bf42022-01-04 13:58:26 -0500641namespace {
642std::vector<Hwc2::IComposerClient::Rect> convertRegionToHwcRects(const Region& region) {
643 size_t rectCount = 0;
644 Rect const* rectArray = region.getArray(&rectCount);
645
646 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
647 hwcRects.reserve(rectCount);
648 for (size_t rect = 0; rect < rectCount; ++rect) {
649 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top, rectArray[rect].right,
650 rectArray[rect].bottom});
651 }
652 return hwcRects;
653}
654} // namespace
655
Lloyd Pique35d58242018-12-18 16:33:25 -0800656Layer::~Layer() = default;
657
658namespace impl {
659
Ady Abrahamde549d42022-01-26 19:19:17 -0800660Layer::Layer(android::Hwc2::Composer& composer,
661 const std::unordered_set<AidlCapability>& capabilities, HWC2::Display& display,
662 HWLayerId layerId)
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800663 : mComposer(composer),
664 mCapabilities(capabilities),
Lloyd Piquea516c002021-05-07 14:36:58 -0700665 mDisplay(&display),
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800666 mId(layerId),
667 mColorMatrix(android::mat4()) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700668 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, display.getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700669}
670
671Layer::~Layer()
672{
Lloyd Piquea516c002021-05-07 14:36:58 -0700673 onOwningDisplayDestroyed();
674}
675
676void Layer::onOwningDisplayDestroyed() {
677 // Note: onOwningDisplayDestroyed() may be called to perform cleanup by
678 // either the Layer dtor or by the Display dtor and must be safe to call
679 // from either path. In particular, the call to Display::onLayerDestroyed()
680 // is expected to be safe to do,
681
682 if (CC_UNLIKELY(!mDisplay)) {
683 return;
684 }
685
686 mDisplay->onLayerDestroyed(mId);
687
688 // Note: If the HWC display was actually disconnected, these calls are will
689 // return an error. We always make them as there may be other reasons for
690 // the HWC2::Display to be destroyed.
691 auto intError = mComposer.destroyLayer(mDisplay->getId(), mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700692 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700693 ALOGE_IF(error != Error::NONE,
694 "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
695 " failed: %s (%d)",
Lloyd Piquea516c002021-05-07 14:36:58 -0700696 mDisplay->getId(), mId, to_string(error).c_str(), intError);
697
698 mDisplay = nullptr;
Steven Thomas94e35b92017-07-26 18:48:28 -0700699}
700
Dan Stoza651bf312015-10-23 17:03:17 -0700701Error Layer::setCursorPosition(int32_t x, int32_t y)
702{
Lloyd Piquea516c002021-05-07 14:36:58 -0700703 if (CC_UNLIKELY(!mDisplay)) {
704 return Error::BAD_DISPLAY;
705 }
706
707 auto intError = mComposer.setCursorPosition(mDisplay->getId(), mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700708 return static_cast<Error>(intError);
709}
710
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400711Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700712 const sp<Fence>& acquireFence)
713{
Lloyd Piquea516c002021-05-07 14:36:58 -0700714 if (CC_UNLIKELY(!mDisplay)) {
715 return Error::BAD_DISPLAY;
716 }
717
Yichi Chen8366f562019-03-25 19:44:06 +0800718 if (buffer == nullptr && mBufferSlot == slot) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700719 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800720 }
721 mBufferSlot = slot;
722
Dan Stoza651bf312015-10-23 17:03:17 -0700723 int32_t fenceFd = acquireFence->dup();
Lloyd Piquea516c002021-05-07 14:36:58 -0700724 auto intError = mComposer.setLayerBuffer(mDisplay->getId(), mId, slot, buffer, fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700725 return static_cast<Error>(intError);
726}
727
Brian Lindahlb158a5c2022-12-15 15:21:13 -0700728Error Layer::setBufferSlotsToClear(const std::vector<uint32_t>& slotsToClear,
729 uint32_t activeBufferSlot) {
Brian Lindahl90553da2022-12-06 13:36:30 -0700730 if (CC_UNLIKELY(!mDisplay)) {
731 return Error::BAD_DISPLAY;
732 }
Brian Lindahlb158a5c2022-12-15 15:21:13 -0700733 auto intError = mComposer.setLayerBufferSlotsToClear(mDisplay->getId(), mId, slotsToClear,
734 activeBufferSlot);
Brian Lindahl90553da2022-12-06 13:36:30 -0700735 return static_cast<Error>(intError);
736}
737
Dan Stoza651bf312015-10-23 17:03:17 -0700738Error Layer::setSurfaceDamage(const Region& damage)
739{
Lloyd Piquea516c002021-05-07 14:36:58 -0700740 if (CC_UNLIKELY(!mDisplay)) {
741 return Error::BAD_DISPLAY;
742 }
743
Yichi Chen8366f562019-03-25 19:44:06 +0800744 if (damage.isRect() && mDamageRegion.isRect() &&
745 (damage.getBounds() == mDamageRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700746 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800747 }
748 mDamageRegion = damage;
749
Dan Stoza651bf312015-10-23 17:03:17 -0700750 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
751 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800752 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700753 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700754 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId,
755 std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700756 } else {
Leon Scroggins III4459bf42022-01-04 13:58:26 -0500757 const auto hwcRects = convertRegionToHwcRects(damage);
Lloyd Piquea516c002021-05-07 14:36:58 -0700758 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700759 }
760
761 return static_cast<Error>(intError);
762}
763
764Error Layer::setBlendMode(BlendMode mode)
765{
Lloyd Piquea516c002021-05-07 14:36:58 -0700766 if (CC_UNLIKELY(!mDisplay)) {
767 return Error::BAD_DISPLAY;
768 }
769
770 auto intError = mComposer.setLayerBlendMode(mDisplay->getId(), mId, mode);
Dan Stoza651bf312015-10-23 17:03:17 -0700771 return static_cast<Error>(intError);
772}
773
Peiyong Line9d809e2020-04-14 13:10:48 -0700774Error Layer::setColor(Color color) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700775 if (CC_UNLIKELY(!mDisplay)) {
776 return Error::BAD_DISPLAY;
777 }
778
779 auto intError = mComposer.setLayerColor(mDisplay->getId(), mId, color);
Dan Stoza651bf312015-10-23 17:03:17 -0700780 return static_cast<Error>(intError);
781}
782
783Error Layer::setCompositionType(Composition type)
784{
Lloyd Piquea516c002021-05-07 14:36:58 -0700785 if (CC_UNLIKELY(!mDisplay)) {
786 return Error::BAD_DISPLAY;
787 }
788
789 auto intError = mComposer.setLayerCompositionType(mDisplay->getId(), mId, type);
Dan Stoza651bf312015-10-23 17:03:17 -0700790 return static_cast<Error>(intError);
791}
792
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700793Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700794{
Lloyd Piquea516c002021-05-07 14:36:58 -0700795 if (CC_UNLIKELY(!mDisplay)) {
796 return Error::BAD_DISPLAY;
797 }
798
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600799 if (dataspace == mDataSpace) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700800 return Error::NONE;
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600801 }
802 mDataSpace = dataspace;
Lloyd Piquea516c002021-05-07 14:36:58 -0700803 auto intError = mComposer.setLayerDataspace(mDisplay->getId(), mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700804 return static_cast<Error>(intError);
805}
806
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700807Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
808 const android::HdrMetadata& metadata)
809{
Lloyd Piquea516c002021-05-07 14:36:58 -0700810 if (CC_UNLIKELY(!mDisplay)) {
811 return Error::BAD_DISPLAY;
812 }
813
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700814 if (metadata == mHdrMetadata) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700815 return Error::NONE;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700816 }
817
818 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700819 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
820 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
821 if (validTypes & HdrMetadata::SMPTE2086) {
822 perFrameMetadatas.insert(perFrameMetadatas.end(),
823 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800824 mHdrMetadata.smpte2086.displayPrimaryRed.x},
825 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
826 mHdrMetadata.smpte2086.displayPrimaryRed.y},
827 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
828 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
829 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
830 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
831 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
832 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
833 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
834 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
835 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
836 mHdrMetadata.smpte2086.whitePoint.x},
837 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
838 mHdrMetadata.smpte2086.whitePoint.y},
839 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
840 mHdrMetadata.smpte2086.maxLuminance},
841 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
842 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700843 }
844
845 if (validTypes & HdrMetadata::CTA861_3) {
846 perFrameMetadatas.insert(perFrameMetadatas.end(),
847 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800848 mHdrMetadata.cta8613.maxContentLightLevel},
849 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
850 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700851 }
852
Alec Mouri66d83482022-01-11 11:14:44 -0800853 const Error error = static_cast<Error>(
854 mComposer.setLayerPerFrameMetadata(mDisplay->getId(), mId, perFrameMetadatas));
855 if (error != Error::NONE) {
856 return error;
857 }
Valerie Haue9e843a2018-12-18 13:39:23 -0800858
Alec Mouri66d83482022-01-11 11:14:44 -0800859 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
Valerie Haue9e843a2018-12-18 13:39:23 -0800860 if (validTypes & HdrMetadata::HDR10PLUS) {
Yichi Chen1d5146d2020-06-12 18:50:11 +0800861 if (CC_UNLIKELY(mHdrMetadata.hdr10plus.size() == 0)) {
862 return Error::BAD_PARAMETER;
863 }
864
Valerie Haue9e843a2018-12-18 13:39:23 -0800865 perFrameMetadataBlobs.push_back(
866 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
Valerie Haue9e843a2018-12-18 13:39:23 -0800867 }
Alec Mouri66d83482022-01-11 11:14:44 -0800868
869 return static_cast<Error>(
870 mComposer.setLayerPerFrameMetadataBlobs(mDisplay->getId(), mId, perFrameMetadataBlobs));
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700871}
872
Dan Stoza651bf312015-10-23 17:03:17 -0700873Error Layer::setDisplayFrame(const Rect& frame)
874{
Lloyd Piquea516c002021-05-07 14:36:58 -0700875 if (CC_UNLIKELY(!mDisplay)) {
876 return Error::BAD_DISPLAY;
877 }
878
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800879 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800880 frame.right, frame.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700881 auto intError = mComposer.setLayerDisplayFrame(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700882 return static_cast<Error>(intError);
883}
884
885Error Layer::setPlaneAlpha(float alpha)
886{
Lloyd Piquea516c002021-05-07 14:36:58 -0700887 if (CC_UNLIKELY(!mDisplay)) {
888 return Error::BAD_DISPLAY;
889 }
890
891 auto intError = mComposer.setLayerPlaneAlpha(mDisplay->getId(), mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700892 return static_cast<Error>(intError);
893}
894
895Error Layer::setSidebandStream(const native_handle_t* stream)
896{
Lloyd Piquea516c002021-05-07 14:36:58 -0700897 if (CC_UNLIKELY(!mDisplay)) {
898 return Error::BAD_DISPLAY;
899 }
900
Ady Abrahamde549d42022-01-26 19:19:17 -0800901 if (mCapabilities.count(AidlCapability::SIDEBAND_STREAM) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700902 ALOGE("Attempted to call setSidebandStream without checking that the "
903 "device supports sideband streams");
Peiyong Line9d809e2020-04-14 13:10:48 -0700904 return Error::UNSUPPORTED;
Dan Stoza09e7a272016-04-14 12:31:01 -0700905 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700906 auto intError = mComposer.setLayerSidebandStream(mDisplay->getId(), mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700907 return static_cast<Error>(intError);
908}
909
910Error Layer::setSourceCrop(const FloatRect& crop)
911{
Lloyd Piquea516c002021-05-07 14:36:58 -0700912 if (CC_UNLIKELY(!mDisplay)) {
913 return Error::BAD_DISPLAY;
914 }
915
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800916 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800917 crop.left, crop.top, crop.right, crop.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700918 auto intError = mComposer.setLayerSourceCrop(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700919 return static_cast<Error>(intError);
920}
921
922Error Layer::setTransform(Transform transform)
923{
Lloyd Piquea516c002021-05-07 14:36:58 -0700924 if (CC_UNLIKELY(!mDisplay)) {
925 return Error::BAD_DISPLAY;
926 }
927
Chia-I Wuaab99f52016-10-05 12:59:58 +0800928 auto intTransform = static_cast<Hwc2::Transform>(transform);
Lloyd Piquea516c002021-05-07 14:36:58 -0700929 auto intError = mComposer.setLayerTransform(mDisplay->getId(), mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700930 return static_cast<Error>(intError);
931}
932
933Error Layer::setVisibleRegion(const Region& region)
934{
Lloyd Piquea516c002021-05-07 14:36:58 -0700935 if (CC_UNLIKELY(!mDisplay)) {
936 return Error::BAD_DISPLAY;
937 }
938
Yichi Chen8366f562019-03-25 19:44:06 +0800939 if (region.isRect() && mVisibleRegion.isRect() &&
940 (region.getBounds() == mVisibleRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700941 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800942 }
943 mVisibleRegion = region;
Leon Scroggins III4459bf42022-01-04 13:58:26 -0500944 const auto hwcRects = convertRegionToHwcRects(region);
Lloyd Piquea516c002021-05-07 14:36:58 -0700945 auto intError = mComposer.setLayerVisibleRegion(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700946 return static_cast<Error>(intError);
947}
948
949Error Layer::setZOrder(uint32_t z)
950{
Lloyd Piquea516c002021-05-07 14:36:58 -0700951 if (CC_UNLIKELY(!mDisplay)) {
952 return Error::BAD_DISPLAY;
953 }
954
955 auto intError = mComposer.setLayerZOrder(mDisplay->getId(), mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700956 return static_cast<Error>(intError);
957}
958
Peiyong Lin698147a2018-09-14 13:27:18 -0700959// Composer HAL 2.3
960Error Layer::setColorTransform(const android::mat4& matrix) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700961 if (CC_UNLIKELY(!mDisplay)) {
962 return Error::BAD_DISPLAY;
963 }
964
Peiyong Lin698147a2018-09-14 13:27:18 -0700965 if (matrix == mColorMatrix) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700966 return Error::NONE;
Peiyong Lin698147a2018-09-14 13:27:18 -0700967 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700968 auto intError = mComposer.setLayerColorTransform(mDisplay->getId(), mId, matrix.asArray());
Peiyong Lin04d25872019-04-18 10:26:19 -0700969 Error error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700970 if (error != Error::NONE) {
Peiyong Lin04d25872019-04-18 10:26:19 -0700971 return error;
972 }
973 mColorMatrix = matrix;
974 return error;
Peiyong Lin698147a2018-09-14 13:27:18 -0700975}
Lloyd Pique35d58242018-12-18 16:33:25 -0800976
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800977// Composer HAL 2.4
978Error Layer::setLayerGenericMetadata(const std::string& name, bool mandatory,
979 const std::vector<uint8_t>& value) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700980 if (CC_UNLIKELY(!mDisplay)) {
981 return Error::BAD_DISPLAY;
982 }
983
984 auto intError =
985 mComposer.setLayerGenericMetadata(mDisplay->getId(), mId, name, mandatory, value);
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800986 return static_cast<Error>(intError);
987}
988
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700989// AIDL HAL
Alec Mouri6da0e272022-02-07 12:45:57 -0800990Error Layer::setBrightness(float brightness) {
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700991 if (CC_UNLIKELY(!mDisplay)) {
992 return Error::BAD_DISPLAY;
993 }
994
Alec Mouri6da0e272022-02-07 12:45:57 -0800995 auto intError = mComposer.setLayerBrightness(mDisplay->getId(), mId, brightness);
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700996 return static_cast<Error>(intError);
997}
998
Leon Scroggins IIId77d3162022-01-05 10:42:28 -0500999Error Layer::setBlockingRegion(const Region& region) {
1000 if (CC_UNLIKELY(!mDisplay)) {
1001 return Error::BAD_DISPLAY;
1002 }
1003
1004 if (region.isRect() && mBlockingRegion.isRect() &&
1005 (region.getBounds() == mBlockingRegion.getBounds())) {
1006 return Error::NONE;
1007 }
1008 mBlockingRegion = region;
1009 const auto hwcRects = convertRegionToHwcRects(region);
1010 const auto intError = mComposer.setLayerBlockingRegion(mDisplay->getId(), mId, hwcRects);
1011 return static_cast<Error>(intError);
1012}
1013
Lloyd Pique35d58242018-12-18 16:33:25 -08001014} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -07001015} // namespace HWC2
Peiyong Line9d809e2020-04-14 13:10:48 -07001016} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001017
1018// TODO(b/129481165): remove the #pragma below and fix conversion issues
1019#pragma clang diagnostic pop // ignored "-Wconversion"