blob: a274995eecc00e88911c624fa3f8d6bbfebd4a37 [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>
Dominik Laskowski88096872023-12-08 15:26:04 -050030#include <common/FlagManager.h>
Dan Stoza651bf312015-10-23 17:03:17 -070031#include <ui/Fence.h>
Dan Stoza5a423ea2017-02-16 14:10:39 -080032#include <ui/FloatRect.h>
Dan Stoza651bf312015-10-23 17:03:17 -070033#include <ui/GraphicBuffer.h>
Brian Lindahl7a4cb7e2024-10-30 10:42:21 -060034#include <ui/PictureProfileHandle.h>
Dan Stoza651bf312015-10-23 17:03:17 -070035
Lloyd Pique3c085a02018-05-09 19:38:32 -070036#include <algorithm>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080037#include <cinttypes>
Lloyd Pique3c085a02018-05-09 19:38:32 -070038#include <iterator>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070039#include <set>
Dan Stoza651bf312015-10-23 17:03:17 -070040
Ady Abraham6e60b142022-01-06 18:10:35 -080041using aidl::android::hardware::graphics::composer3::Color;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050042using aidl::android::hardware::graphics::composer3::Composition;
Ady Abrahamde549d42022-01-26 19:19:17 -080043using AidlCapability = aidl::android::hardware::graphics::composer3::Capability;
Leon Scroggins III5967aec2021-12-29 11:14:22 -050044using aidl::android::hardware::graphics::composer3::DisplayCapability;
Sally Qi11dcd582024-08-16 18:11:27 -070045using aidl::android::hardware::graphics::composer3::DisplayLuts;
Sally Qi0abc4a52024-09-26 16:13:06 -070046using aidl::android::hardware::graphics::composer3::LutProperties;
47using aidl::android::hardware::graphics::composer3::Luts;
Sally Qi0cbd08b2022-08-17 12:12:28 -070048using aidl::android::hardware::graphics::composer3::OverlayProperties;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050049
Peiyong Line9d809e2020-04-14 13:10:48 -070050namespace android {
51
Dan Stoza651bf312015-10-23 17:03:17 -070052using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080053using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070054using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070055using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070056using android::HdrMetadata;
Brian Lindahl7a4cb7e2024-10-30 10:42:21 -060057using android::PictureProfileHandle;
Dan Stoza651bf312015-10-23 17:03:17 -070058using android::Rect;
59using android::Region;
60using android::sp;
61
62namespace HWC2 {
63
Peiyong Line9d809e2020-04-14 13:10:48 -070064using namespace android::hardware::graphics::composer::hal;
65
Chia-I Wuaab99f52016-10-05 12:59:58 +080066namespace Hwc2 = android::Hwc2;
67
Steven Thomas94e35b92017-07-26 18:48:28 -070068namespace {
69
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070070inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
71 const Hwc2::PerFrameMetadataKey& key) {
72 return keys.find(key) != keys.end();
73}
74
Steven Thomas94e35b92017-07-26 18:48:28 -070075} // namespace anonymous
76
Dan Stoza651bf312015-10-23 17:03:17 -070077// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -080078Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -070079
Ana Krulec4593b692019-01-11 22:07:25 -080080namespace impl {
Dominik Laskowski55c85402020-01-21 16:25:47 -080081
Peiyong Lin74ca2f42019-01-14 19:36:57 -080082Display::Display(android::Hwc2::Composer& composer,
Ady Abrahamde549d42022-01-26 19:19:17 -080083 const std::unordered_set<AidlCapability>& capabilities, HWDisplayId id,
Lloyd Piquebc792092018-01-17 11:52:30 -080084 DisplayType type)
Peiyong Line9d809e2020-04-14 13:10:48 -070085 : mComposer(composer), mCapabilities(capabilities), mId(id), mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -070086 ALOGV("Created display %" PRIu64, id);
HyunKyounga264a352024-04-24 18:51:33 +090087 if (mType == hal::DisplayType::VIRTUAL) {
88 loadDisplayCapabilities();
89 }
Dan Stoza651bf312015-10-23 17:03:17 -070090}
91
Steven Thomas94e35b92017-07-26 18:48:28 -070092Display::~Display() {
Lloyd Piquea516c002021-05-07 14:36:58 -070093 // Note: The calls to onOwningDisplayDestroyed() are allowed (and expected)
94 // to call Display::onLayerDestroyed(). As that call removes entries from
95 // mLayers, we do not want to have a for loop directly over it here. Since
96 // the end goal is an empty mLayers anyway, we just go ahead and swap an
97 // initially empty local container with mLayers, and then enumerate
98 // the contents of the local container.
99 Layers destroyingLayers;
100 std::swap(mLayers, destroyingLayers);
101 for (const auto& [_, weakLayer] : destroyingLayers) {
102 if (std::shared_ptr layer = weakLayer.lock()) {
103 layer->onOwningDisplayDestroyed();
104 }
105 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700106
Peiyong Line9d809e2020-04-14 13:10:48 -0700107 Error error = Error::NONE;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800108 const char* msg;
109 switch (mType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700110 case DisplayType::PHYSICAL:
111 error = setVsyncEnabled(HWC2::Vsync::DISABLE);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800112 msg = "disable VSYNC for";
113 break;
114
Peiyong Line9d809e2020-04-14 13:10:48 -0700115 case DisplayType::VIRTUAL:
Dominik Laskowski55c85402020-01-21 16:25:47 -0800116 error = static_cast<Error>(mComposer.destroyVirtualDisplay(mId));
117 msg = "destroy virtual";
118 break;
119
Peiyong Line9d809e2020-04-14 13:10:48 -0700120 case DisplayType::INVALID: // Used in unit tests.
Dominik Laskowski55c85402020-01-21 16:25:47 -0800121 break;
Dan Stoza651bf312015-10-23 17:03:17 -0700122 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800123
Peiyong Line9d809e2020-04-14 13:10:48 -0700124 ALOGE_IF(error != Error::NONE, "%s: Failed to %s display %" PRIu64 ": %d", __FUNCTION__, msg,
125 mId, static_cast<int32_t>(error));
Dominik Laskowski55c85402020-01-21 16:25:47 -0800126
127 ALOGV("Destroyed display %" PRIu64, mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700128}
129
Dan Stoza651bf312015-10-23 17:03:17 -0700130// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700131Error Display::acceptChanges()
132{
Steven Thomas94e35b92017-07-26 18:48:28 -0700133 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700134 return static_cast<Error>(intError);
135}
136
Lloyd Piquea516c002021-05-07 14:36:58 -0700137base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700138 HWLayerId layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700139 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700140 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700141 if (error != Error::NONE) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700142 return base::unexpected(error);
Dan Stoza651bf312015-10-23 17:03:17 -0700143 }
144
Lloyd Piquea516c002021-05-07 14:36:58 -0700145 auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);
146 mLayers.emplace(layerId, layer);
147 return layer;
Steven Thomas94e35b92017-07-26 18:48:28 -0700148}
149
Lloyd Piquea516c002021-05-07 14:36:58 -0700150void Display::onLayerDestroyed(hal::HWLayerId layerId) {
151 mLayers.erase(layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700152}
153
Ady Abraham7159f572019-10-11 11:10:18 -0700154bool Display::isVsyncPeriodSwitchSupported() const {
155 ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId);
156
Ady Abraham4d211cf2021-12-14 16:19:03 -0800157 return mComposer.isSupported(android::Hwc2::Composer::OptionalFeature::RefreshRateSwitching);
Ady Abraham7159f572019-10-11 11:10:18 -0700158}
159
ramindani32cf0602022-03-02 02:30:29 +0000160bool Display::hasDisplayIdleTimerCapability() const {
161 bool isCapabilitySupported = false;
162 return mComposer.hasDisplayIdleTimerCapability(mId, &isCapabilitySupported) == Error::NONE &&
163 isCapabilitySupported;
164}
165
ramindani06e518e2022-03-14 18:47:53 +0000166Error Display::getPhysicalDisplayOrientation(Hwc2::AidlTransform* outTransform) const {
167 auto error = mComposer.getPhysicalDisplayOrientation(mId, outTransform);
168 return static_cast<Error>(error);
169}
170
Lloyd Pique35d58242018-12-18 16:33:25 -0800171Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800172 std::vector<Hwc2::Layer> layerIds;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500173 std::vector<Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700174 auto intError = mComposer.getChangedCompositionTypes(
175 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800176 uint32_t numElements = layerIds.size();
linkaid1bb3142023-12-20 10:18:16 +0800177 const auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700178 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700179 return error;
180 }
181
182 outTypes->clear();
183 outTypes->reserve(numElements);
184 for (uint32_t element = 0; element < numElements; ++element) {
185 auto layer = getLayerById(layerIds[element]);
186 if (layer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700187 auto type = types[element];
Dan Stoza651bf312015-10-23 17:03:17 -0700188 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
189 layer->getId(), to_string(type).c_str());
Lloyd Piquea516c002021-05-07 14:36:58 -0700190 outTypes->emplace(layer.get(), type);
Dan Stoza651bf312015-10-23 17:03:17 -0700191 } else {
192 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
193 " on display %" PRIu64, layerIds[element], mId);
194 }
195 }
196
Peiyong Line9d809e2020-04-14 13:10:48 -0700197 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700198}
199
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700200Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700201{
Peiyong Linfd997e02018-03-28 15:29:00 -0700202 auto intError = mComposer.getColorModes(mId, outModes);
203 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700204}
205
Chia-I Wud7e01d72018-06-21 13:39:09 +0800206int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700207{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800208 int32_t supportedPerFrameMetadata = 0;
209
210 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
211 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700212
213 // Check whether a specific metadata type is supported. A metadata type is considered
214 // supported if and only if all required fields are supported.
215
216 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700217 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
218 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
219 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
220 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
221 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
222 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
223 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
224 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
225 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
226 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800227 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700228 }
229 // CTA861_3
230 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
231 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800232 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700233 }
234
Valerie Haue9e843a2018-12-18 13:39:23 -0800235 // HDR10PLUS
236 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
237 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
238 }
239
Chia-I Wud7e01d72018-06-21 13:39:09 +0800240 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700241}
242
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700243Error Display::getRenderIntents(ColorMode colorMode,
244 std::vector<RenderIntent>* outRenderIntents) const
245{
246 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
247 return static_cast<Error>(intError);
248}
249
250Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
251{
252 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
253 return static_cast<Error>(intError);
254}
255
Dan Stoza651bf312015-10-23 17:03:17 -0700256Error Display::getName(std::string* outName) const
257{
Steven Thomas94e35b92017-07-26 18:48:28 -0700258 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800259 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700260}
261
262Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800263 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Lloyd Piquee9eff972020-05-05 12:36:44 -0700264 uint32_t intDisplayRequests = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800265 std::vector<Hwc2::Layer> layerIds;
266 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700267 auto intError = mComposer.getDisplayRequests(
268 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800269 uint32_t numElements = layerIds.size();
270 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700271 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700272 return error;
273 }
274
275 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
276 outLayerRequests->clear();
277 outLayerRequests->reserve(numElements);
278 for (uint32_t element = 0; element < numElements; ++element) {
279 auto layer = getLayerById(layerIds[element]);
280 if (layer) {
281 auto layerRequest =
282 static_cast<LayerRequest>(layerRequests[element]);
Lloyd Piquea516c002021-05-07 14:36:58 -0700283 outLayerRequests->emplace(layer.get(), layerRequest);
Dan Stoza651bf312015-10-23 17:03:17 -0700284 } else {
285 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
286 PRIu64, layerIds[element], mId);
287 }
288 }
289
Peiyong Line9d809e2020-04-14 13:10:48 -0700290 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700291}
292
Dominik Laskowski969cdcb2024-02-08 16:35:29 -0500293ftl::Expected<ui::DisplayConnectionType, hal::Error> Display::getConnectionType() const {
294 if (!mConnectionType) {
295 mConnectionType = [this]() -> decltype(mConnectionType) {
296 if (mType != DisplayType::PHYSICAL) {
297 return ftl::Unexpected(Error::BAD_DISPLAY);
298 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800299
Dominik Laskowski969cdcb2024-02-08 16:35:29 -0500300 using ConnectionType = Hwc2::IComposerClient::DisplayConnectionType;
301 ConnectionType connectionType;
302
303 if (const auto error = static_cast<Error>(
304 mComposer.getDisplayConnectionType(mId, &connectionType));
305 error != Error::NONE) {
306 return ftl::Unexpected(error);
307 }
308
309 return connectionType == ConnectionType::INTERNAL ? ui::DisplayConnectionType::Internal
310 : ui::DisplayConnectionType::External;
311 }();
Dominik Laskowski55c85402020-01-21 16:25:47 -0800312 }
313
Dominik Laskowski969cdcb2024-02-08 16:35:29 -0500314 return *mConnectionType;
Dan Stoza651bf312015-10-23 17:03:17 -0700315}
316
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500317bool Display::hasCapability(DisplayCapability capability) const {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700318 std::scoped_lock lock(mDisplayCapabilitiesMutex);
319 if (mDisplayCapabilities) {
320 return mDisplayCapabilities->count(capability) > 0;
321 }
322
Leon Scroggins III515f0382021-12-29 11:17:04 -0500323 ALOGW("Can't query capability %s."
Ady Abraham27fbcc72021-09-20 14:54:57 -0700324 " Display Capabilities were not queried from HWC yet",
Leon Scroggins III515f0382021-12-29 11:17:04 -0500325 to_string(capability).c_str());
Ady Abraham27fbcc72021-09-20 14:54:57 -0700326
327 return false;
328}
329
Peiyong Lined531a32018-10-26 18:27:56 -0700330Error Display::supportsDoze(bool* outSupport) const {
Leon Scroggins III689c80f2023-06-05 17:49:32 -0400331 {
332 std::scoped_lock lock(mDisplayCapabilitiesMutex);
333 if (!mDisplayCapabilities) {
334 // The display has not turned on since boot, so DOZE support is unknown.
335 ALOGW("%s: haven't queried capabilities yet!", __func__);
336 return Error::NO_RESOURCES;
337 }
338 }
Ady Abraham27fbcc72021-09-20 14:54:57 -0700339 *outSupport = hasCapability(DisplayCapability::DOZE);
Peiyong Line9d809e2020-04-14 13:10:48 -0700340 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700341}
342
Peiyong Lin62665892018-04-16 11:07:44 -0700343Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700344{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700345 float maxLuminance = -1.0f;
346 float maxAverageLuminance = -1.0f;
347 float minLuminance = -1.0f;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100348 std::vector<Hwc2::Hdr> hdrTypes;
349 auto intError = mComposer.getHdrCapabilities(mId, &hdrTypes, &maxLuminance,
350 &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800351 auto error = static_cast<HWC2::Error>(intError);
352
Peiyong Line9d809e2020-04-14 13:10:48 -0700353 if (error != Error::NONE) {
Dan Stoza7d7ae732016-03-16 12:23:40 -0700354 return error;
355 }
356
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100357 *outCapabilities =
358 HdrCapabilities(std::move(hdrTypes), maxLuminance, maxAverageLuminance, minLuminance);
Peiyong Line9d809e2020-04-14 13:10:48 -0700359 return Error::NONE;
Dan Stoza7d7ae732016-03-16 12:23:40 -0700360}
361
Sally Qibb866c12022-10-17 11:31:20 -0700362Error Display::getOverlaySupport(OverlayProperties* outProperties) const {
363 auto intError = mComposer.getOverlaySupport(outProperties);
364 return static_cast<Error>(intError);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700365}
366
Peiyong Line9d809e2020-04-14 13:10:48 -0700367Error Display::getDisplayedContentSamplingAttributes(hal::PixelFormat* outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700368 Dataspace* outDataspace,
369 uint8_t* outComponentMask) const {
370 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
371 outComponentMask);
372 return static_cast<Error>(intError);
373}
374
Kevin DuBois74e53772018-11-19 10:52:38 -0800375Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
376 uint64_t maxFrames) const {
377 auto intError =
378 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
379 return static_cast<Error>(intError);
380}
381
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700382Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
383 android::DisplayedFrameStats* outStats) const {
384 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
385 return static_cast<Error>(intError);
386}
387
Lloyd Pique35d58242018-12-18 16:33:25 -0800388Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800389 std::vector<Hwc2::Layer> layerIds;
390 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700391 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800392 auto error = static_cast<Error>(intError);
393 uint32_t numElements = layerIds.size();
Peiyong Line9d809e2020-04-14 13:10:48 -0700394 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700395 return error;
396 }
397
Lloyd Pique35d58242018-12-18 16:33:25 -0800398 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700399 releaseFences.reserve(numElements);
400 for (uint32_t element = 0; element < numElements; ++element) {
401 auto layer = getLayerById(layerIds[element]);
402 if (layer) {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700403 sp<Fence> fence(sp<Fence>::make(fenceFds[element]));
Lloyd Piquea516c002021-05-07 14:36:58 -0700404 releaseFences.emplace(layer.get(), fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700405 } else {
406 ALOGE("getReleaseFences: invalid layer %" PRIu64
407 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700408 for (; element < numElements; ++element) {
409 close(fenceFds[element]);
410 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700411 return Error::BAD_LAYER;
Dan Stoza651bf312015-10-23 17:03:17 -0700412 }
413 }
414
415 *outFences = std::move(releaseFences);
Peiyong Line9d809e2020-04-14 13:10:48 -0700416 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700417}
418
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800419Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700420{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400421 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700422 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700423 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700424 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700425 return error;
426 }
427
Ady Abrahamd11bade2022-08-01 16:18:03 -0700428 *outPresentFence = sp<Fence>::make(presentFenceFd);
Peiyong Line9d809e2020-04-14 13:10:48 -0700429 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700430}
431
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100432Error Display::setActiveConfigWithConstraints(hal::HWConfigId configId,
433 const VsyncPeriodChangeConstraints& constraints,
434 VsyncPeriodChangeTimeline* outTimeline) {
Ady Abraham7159f572019-10-11 11:10:18 -0700435 ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId);
Ady Abraham7159f572019-10-11 11:10:18 -0700436
Dominik Laskowski88096872023-12-08 15:26:04 -0500437 // FIXME (b/319505580): At least the first config set on an external display must be
438 // `setActiveConfig`, so skip over the block that calls `setActiveConfigWithConstraints`
439 // for simplicity.
Dominik Laskowski88096872023-12-08 15:26:04 -0500440 const bool connected_display = FlagManager::getInstance().connected_display();
Dominik Laskowski88096872023-12-08 15:26:04 -0500441
442 if (isVsyncPeriodSwitchSupported() &&
Dominik Laskowski969cdcb2024-02-08 16:35:29 -0500443 (!connected_display ||
444 getConnectionType().value_opt() != ui::DisplayConnectionType::External)) {
Ady Abraham7159f572019-10-11 11:10:18 -0700445 Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints;
446 hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos;
447 hwc2Constraints.seamlessRequired = constraints.seamlessRequired;
448
449 Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {};
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100450 auto intError = mComposer.setActiveConfigWithConstraints(mId, configId, hwc2Constraints,
451 &vsyncPeriodChangeTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -0700452 outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos;
453 outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired;
454 outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos;
455 return static_cast<Error>(intError);
456 }
457
458 // Use legacy setActiveConfig instead
459 ALOGV("fallback to legacy setActiveConfig");
460 const auto now = systemTime();
461 if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) {
462 ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied");
463 }
464
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100465 auto intError_2_4 = mComposer.setActiveConfig(mId, configId);
Ady Abraham7159f572019-10-11 11:10:18 -0700466 outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos);
467 outTimeline->refreshRequired = true;
468 outTimeline->refreshTimeNanos = now;
469 return static_cast<Error>(intError_2_4);
470}
471
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400472Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Alec Mourif97df4d2023-09-06 02:10:05 +0000473 const sp<Fence>& acquireFence, Dataspace dataspace,
474 float hdrSdrRatio) {
Dan Stoza5cf424b2016-05-20 14:02:39 -0700475 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700476 int32_t fenceFd = acquireFence->dup();
Alec Mourif97df4d2023-09-06 02:10:05 +0000477 auto intError =
478 mComposer.setClientTarget(mId, slot, target, fenceFd, dataspace,
479 std::vector<Hwc2::IComposerClient::Rect>(), hdrSdrRatio);
Dan Stoza651bf312015-10-23 17:03:17 -0700480 return static_cast<Error>(intError);
481}
482
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700483Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700484{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700485 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700486 return static_cast<Error>(intError);
487}
488
Ady Abrahamdc011a92021-12-21 14:06:44 -0800489Error Display::setColorTransform(const android::mat4& matrix) {
490 auto intError = mComposer.setColorTransform(mId, matrix.asArray());
Dan Stoza5df2a862016-03-24 16:19:37 -0700491 return static_cast<Error>(intError);
492}
493
Dan Stoza651bf312015-10-23 17:03:17 -0700494Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
495 const sp<Fence>& releaseFence)
496{
497 int32_t fenceFd = releaseFence->dup();
498 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700499 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700500 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700501 return static_cast<Error>(intError);
502}
503
504Error Display::setPowerMode(PowerMode mode)
505{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800506 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700507 auto intError = mComposer.setPowerMode(mId, intMode);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700508
Peiyong Line9d809e2020-04-14 13:10:48 -0700509 if (mode == PowerMode::ON) {
HyunKyounga264a352024-04-24 18:51:33 +0900510 loadDisplayCapabilities();
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700511 }
512
Dan Stoza651bf312015-10-23 17:03:17 -0700513 return static_cast<Error>(intError);
514}
515
516Error Display::setVsyncEnabled(Vsync enabled)
517{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800518 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700519 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700520 return static_cast<Error>(intError);
521}
522
ramindani09acbb82023-11-03 09:02:38 -0700523Error Display::validate(nsecs_t expectedPresentTime, int32_t frameIntervalNs, uint32_t* outNumTypes,
Ady Abraham43065bd2021-12-10 17:22:15 -0800524 uint32_t* outNumRequests) {
Dan Stoza651bf312015-10-23 17:03:17 -0700525 uint32_t numTypes = 0;
526 uint32_t numRequests = 0;
ramindani09acbb82023-11-03 09:02:38 -0700527 auto intError = mComposer.validateDisplay(mId, expectedPresentTime, frameIntervalNs, &numTypes,
528 &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700529 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700530 if (error != Error::NONE && !hasChangesError(error)) {
Dan Stoza651bf312015-10-23 17:03:17 -0700531 return error;
532 }
533
534 *outNumTypes = numTypes;
535 *outNumRequests = numRequests;
536 return error;
537}
538
ramindani4aac32c2023-10-30 14:13:30 -0700539Error Display::presentOrValidate(nsecs_t expectedPresentTime, int32_t frameIntervalNs,
540 uint32_t* outNumTypes, uint32_t* outNumRequests,
541 sp<android::Fence>* outPresentFence, uint32_t* state) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700542 uint32_t numTypes = 0;
543 uint32_t numRequests = 0;
544 int32_t presentFenceFd = -1;
ramindani4aac32c2023-10-30 14:13:30 -0700545 auto intError =
546 mComposer.presentOrValidateDisplay(mId, expectedPresentTime, frameIntervalNs, &numTypes,
547 &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700548 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700549 if (error != Error::NONE && !hasChangesError(error)) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700550 return error;
551 }
552
553 if (*state == 1) {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700554 *outPresentFence = sp<Fence>::make(presentFenceFd);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700555 }
556
557 if (*state == 0) {
558 *outNumTypes = numTypes;
559 *outNumRequests = numRequests;
560 }
561 return error;
562}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700563
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700564ftl::Future<Error> Display::setDisplayBrightness(
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000565 float brightness, float brightnessNits,
566 const Hwc2::Composer::DisplayBrightnessOptions& options) {
567 return ftl::defer([composer = &mComposer, id = mId, brightness, brightnessNits, options] {
568 const auto intError =
569 composer->setDisplayBrightness(id, brightness, brightnessNits, options);
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700570 return static_cast<Error>(intError);
571 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000572}
573
Kriti Dang7defaf32021-11-15 11:55:43 +0100574Error Display::setBootDisplayConfig(hal::HWConfigId configId) {
575 auto intError = mComposer.setBootDisplayConfig(mId, configId);
576 return static_cast<Error>(intError);
577}
578
579Error Display::clearBootDisplayConfig() {
580 auto intError = mComposer.clearBootDisplayConfig(mId);
581 return static_cast<Error>(intError);
582}
583
584Error Display::getPreferredBootDisplayConfig(hal::HWConfigId* configId) const {
585 auto intError = mComposer.getPreferredBootDisplayConfig(mId, configId);
586 return static_cast<Error>(intError);
587}
588
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700589Error Display::setAutoLowLatencyMode(bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100590 auto intError = mComposer.setAutoLowLatencyMode(mId, on);
591 return static_cast<Error>(intError);
592}
593
594Error Display::getSupportedContentTypes(std::vector<ContentType>* outSupportedContentTypes) const {
595 std::vector<Hwc2::IComposerClient::ContentType> tmpSupportedContentTypes;
596 auto intError = mComposer.getSupportedContentTypes(mId, &tmpSupportedContentTypes);
597 for (Hwc2::IComposerClient::ContentType contentType : tmpSupportedContentTypes) {
598 outSupportedContentTypes->push_back(static_cast<ContentType>(contentType));
599 }
600 return static_cast<Error>(intError);
601}
602
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700603Error Display::setContentType(ContentType contentType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700604 auto intError = mComposer.setContentType(mId, contentType);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100605 return static_cast<Error>(intError);
606}
607
Alec Mouri85065692022-03-18 00:58:26 +0000608Error Display::getClientTargetProperty(
609 aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness*
610 outClientTargetProperty) {
611 const auto error = mComposer.getClientTargetProperty(mId, outClientTargetProperty);
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700612 return static_cast<Error>(error);
613}
614
Sally Qi95f669a2024-08-27 11:31:42 -0700615Error Display::getRequestedLuts(LayerLuts* outLuts,
616 LutFileDescriptorMapper& lutFileDescriptorMapper) {
617 std::vector<Hwc2::Layer> layerIds;
618 std::vector<DisplayLuts::LayerLut> tmpLuts;
619 const auto error = static_cast<Error>(mComposer.getRequestedLuts(mId, &layerIds, &tmpLuts));
620 if (error != Error::NONE) {
621 return error;
622 }
623
624 uint32_t numElements = layerIds.size();
625 outLuts->clear();
626 for (uint32_t i = 0; i < numElements; ++i) {
627 auto layer = getLayerById(layerIds[i]);
628 if (layer) {
629 auto& layerLut = tmpLuts[i];
Sally Qi0abc4a52024-09-26 16:13:06 -0700630 if (layerLut.luts.pfd.get() > 0 && layerLut.luts.offsets.has_value()) {
631 const auto& offsets = layerLut.luts.offsets.value();
632 std::vector<std::pair<int32_t, LutProperties>> lutOffsetsAndProperties;
633 lutOffsetsAndProperties.reserve(offsets.size());
634 std::transform(offsets.begin(), offsets.end(), layerLut.luts.lutProperties.begin(),
635 std::back_inserter(lutOffsetsAndProperties),
636 [](int32_t i, LutProperties j) { return std::make_pair(i, j); });
637 outLuts->emplace_or_replace(layer.get(), lutOffsetsAndProperties);
638 lutFileDescriptorMapper.emplace_or_replace(layer.get(),
639 ndk::ScopedFileDescriptor(
640 layerLut.luts.pfd.release()));
641 }
Sally Qi492cec32024-06-28 14:34:47 -0700642 }
643 }
Sally Qi95f669a2024-08-27 11:31:42 -0700644
645 return Error::NONE;
Sally Qi492cec32024-06-28 14:34:47 -0700646}
647
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500648Error Display::getDisplayDecorationSupport(
649 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
650 support) {
651 const auto error = mComposer.getDisplayDecorationSupport(mId, support);
652 return static_cast<Error>(error);
653}
654
ramindani32cf0602022-03-02 02:30:29 +0000655Error Display::setIdleTimerEnabled(std::chrono::milliseconds timeout) {
656 const auto error = mComposer.setIdleTimerEnabled(mId, timeout);
657 return static_cast<Error>(error);
658}
659
Brian Lindahl7a4cb7e2024-10-30 10:42:21 -0600660Error Display::getMaxLayerPictureProfiles(int32_t* outMaxProfiles) {
661 const auto error = mComposer.getMaxLayerPictureProfiles(mId, outMaxProfiles);
662 return static_cast<Error>(error);
663}
664
665Error Display::setPictureProfileHandle(const PictureProfileHandle& handle) {
666 const auto error = mComposer.setDisplayPictureProfileId(mId, handle.getId());
667 return static_cast<Error>(error);
668}
669
Dan Stoza651bf312015-10-23 17:03:17 -0700670// For use by Device
671
Steven Thomas94e35b92017-07-26 18:48:28 -0700672void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800673 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700674 mComposer.setClientTargetSlotCount(mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700675 }
676 mIsConnected = connected;
677}
678
Dan Stoza651bf312015-10-23 17:03:17 -0700679// Other Display methods
680
Lloyd Piquea516c002021-05-07 14:36:58 -0700681std::shared_ptr<HWC2::Layer> Display::getLayerById(HWLayerId id) const {
682 auto it = mLayers.find(id);
683 return it != mLayers.end() ? it->second.lock() : nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700684}
HyunKyounga264a352024-04-24 18:51:33 +0900685
686void Display::loadDisplayCapabilities() {
687 std::call_once(mDisplayCapabilityQueryFlag, [this]() {
688 std::vector<DisplayCapability> tmpCapabilities;
689 auto error =
690 static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
691 if (error == Error::NONE) {
692 std::scoped_lock lock(mDisplayCapabilitiesMutex);
693 mDisplayCapabilities.emplace();
694 for (auto capability : tmpCapabilities) {
695 mDisplayCapabilities->emplace(capability);
696 }
697 } else if (error == Error::UNSUPPORTED) {
698 std::scoped_lock lock(mDisplayCapabilitiesMutex);
699 mDisplayCapabilities.emplace();
700 if (mCapabilities.count(AidlCapability::SKIP_CLIENT_COLOR_TRANSFORM)) {
701 mDisplayCapabilities->emplace(DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
702 }
703 bool dozeSupport = false;
704 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
705 if (error == Error::NONE && dozeSupport) {
706 mDisplayCapabilities->emplace(DisplayCapability::DOZE);
707 }
708 }
709 });
710}
Lucas Berthou8d0a0c42024-08-27 14:32:31 +0000711
712void Display::setPhysicalSizeInMm(std::optional<ui::Size> size) {
713 mPhysicalSize = size;
714}
715
Ana Krulec4593b692019-01-11 22:07:25 -0800716} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700717
718// Layer methods
719
Leon Scroggins III4459bf42022-01-04 13:58:26 -0500720namespace {
721std::vector<Hwc2::IComposerClient::Rect> convertRegionToHwcRects(const Region& region) {
722 size_t rectCount = 0;
723 Rect const* rectArray = region.getArray(&rectCount);
724
725 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
726 hwcRects.reserve(rectCount);
727 for (size_t rect = 0; rect < rectCount; ++rect) {
728 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top, rectArray[rect].right,
729 rectArray[rect].bottom});
730 }
731 return hwcRects;
732}
733} // namespace
734
Lloyd Pique35d58242018-12-18 16:33:25 -0800735Layer::~Layer() = default;
736
737namespace impl {
738
Ady Abrahamde549d42022-01-26 19:19:17 -0800739Layer::Layer(android::Hwc2::Composer& composer,
740 const std::unordered_set<AidlCapability>& capabilities, HWC2::Display& display,
741 HWLayerId layerId)
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800742 : mComposer(composer),
743 mCapabilities(capabilities),
Lloyd Piquea516c002021-05-07 14:36:58 -0700744 mDisplay(&display),
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800745 mId(layerId),
746 mColorMatrix(android::mat4()) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700747 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, display.getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700748}
749
750Layer::~Layer()
751{
Lloyd Piquea516c002021-05-07 14:36:58 -0700752 onOwningDisplayDestroyed();
753}
754
755void Layer::onOwningDisplayDestroyed() {
756 // Note: onOwningDisplayDestroyed() may be called to perform cleanup by
757 // either the Layer dtor or by the Display dtor and must be safe to call
758 // from either path. In particular, the call to Display::onLayerDestroyed()
759 // is expected to be safe to do,
760
761 if (CC_UNLIKELY(!mDisplay)) {
762 return;
763 }
764
765 mDisplay->onLayerDestroyed(mId);
766
767 // Note: If the HWC display was actually disconnected, these calls are will
768 // return an error. We always make them as there may be other reasons for
769 // the HWC2::Display to be destroyed.
770 auto intError = mComposer.destroyLayer(mDisplay->getId(), mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700771 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700772 ALOGE_IF(error != Error::NONE,
773 "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
774 " failed: %s (%d)",
Lloyd Piquea516c002021-05-07 14:36:58 -0700775 mDisplay->getId(), mId, to_string(error).c_str(), intError);
776
777 mDisplay = nullptr;
Steven Thomas94e35b92017-07-26 18:48:28 -0700778}
779
Dan Stoza651bf312015-10-23 17:03:17 -0700780Error Layer::setCursorPosition(int32_t x, int32_t y)
781{
Lloyd Piquea516c002021-05-07 14:36:58 -0700782 if (CC_UNLIKELY(!mDisplay)) {
783 return Error::BAD_DISPLAY;
784 }
785
786 auto intError = mComposer.setCursorPosition(mDisplay->getId(), mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700787 return static_cast<Error>(intError);
788}
789
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400790Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700791 const sp<Fence>& acquireFence)
792{
Lloyd Piquea516c002021-05-07 14:36:58 -0700793 if (CC_UNLIKELY(!mDisplay)) {
794 return Error::BAD_DISPLAY;
795 }
796
Yichi Chen8366f562019-03-25 19:44:06 +0800797 if (buffer == nullptr && mBufferSlot == slot) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700798 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800799 }
800 mBufferSlot = slot;
801
Dan Stoza651bf312015-10-23 17:03:17 -0700802 int32_t fenceFd = acquireFence->dup();
Lloyd Piquea516c002021-05-07 14:36:58 -0700803 auto intError = mComposer.setLayerBuffer(mDisplay->getId(), mId, slot, buffer, fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700804 return static_cast<Error>(intError);
805}
806
Brian Lindahlb158a5c2022-12-15 15:21:13 -0700807Error Layer::setBufferSlotsToClear(const std::vector<uint32_t>& slotsToClear,
808 uint32_t activeBufferSlot) {
Brian Lindahl90553da2022-12-06 13:36:30 -0700809 if (CC_UNLIKELY(!mDisplay)) {
810 return Error::BAD_DISPLAY;
811 }
Brian Lindahlb158a5c2022-12-15 15:21:13 -0700812 auto intError = mComposer.setLayerBufferSlotsToClear(mDisplay->getId(), mId, slotsToClear,
813 activeBufferSlot);
Brian Lindahl90553da2022-12-06 13:36:30 -0700814 return static_cast<Error>(intError);
815}
816
Dan Stoza651bf312015-10-23 17:03:17 -0700817Error Layer::setSurfaceDamage(const Region& damage)
818{
Lloyd Piquea516c002021-05-07 14:36:58 -0700819 if (CC_UNLIKELY(!mDisplay)) {
820 return Error::BAD_DISPLAY;
821 }
822
Yichi Chen8366f562019-03-25 19:44:06 +0800823 if (damage.isRect() && mDamageRegion.isRect() &&
824 (damage.getBounds() == mDamageRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700825 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800826 }
827 mDamageRegion = damage;
828
Dan Stoza651bf312015-10-23 17:03:17 -0700829 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
830 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800831 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700832 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700833 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId,
834 std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700835 } else {
Leon Scroggins III4459bf42022-01-04 13:58:26 -0500836 const auto hwcRects = convertRegionToHwcRects(damage);
Lloyd Piquea516c002021-05-07 14:36:58 -0700837 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700838 }
839
840 return static_cast<Error>(intError);
841}
842
843Error Layer::setBlendMode(BlendMode mode)
844{
Lloyd Piquea516c002021-05-07 14:36:58 -0700845 if (CC_UNLIKELY(!mDisplay)) {
846 return Error::BAD_DISPLAY;
847 }
848
849 auto intError = mComposer.setLayerBlendMode(mDisplay->getId(), mId, mode);
Dan Stoza651bf312015-10-23 17:03:17 -0700850 return static_cast<Error>(intError);
851}
852
Peiyong Line9d809e2020-04-14 13:10:48 -0700853Error Layer::setColor(Color color) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700854 if (CC_UNLIKELY(!mDisplay)) {
855 return Error::BAD_DISPLAY;
856 }
857
858 auto intError = mComposer.setLayerColor(mDisplay->getId(), mId, color);
Dan Stoza651bf312015-10-23 17:03:17 -0700859 return static_cast<Error>(intError);
860}
861
862Error Layer::setCompositionType(Composition type)
863{
Lloyd Piquea516c002021-05-07 14:36:58 -0700864 if (CC_UNLIKELY(!mDisplay)) {
865 return Error::BAD_DISPLAY;
866 }
867
868 auto intError = mComposer.setLayerCompositionType(mDisplay->getId(), mId, type);
Dan Stoza651bf312015-10-23 17:03:17 -0700869 return static_cast<Error>(intError);
870}
871
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700872Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700873{
Lloyd Piquea516c002021-05-07 14:36:58 -0700874 if (CC_UNLIKELY(!mDisplay)) {
875 return Error::BAD_DISPLAY;
876 }
877
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600878 if (dataspace == mDataSpace) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700879 return Error::NONE;
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600880 }
881 mDataSpace = dataspace;
Lloyd Piquea516c002021-05-07 14:36:58 -0700882 auto intError = mComposer.setLayerDataspace(mDisplay->getId(), mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700883 return static_cast<Error>(intError);
884}
885
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700886Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
887 const android::HdrMetadata& metadata)
888{
Lloyd Piquea516c002021-05-07 14:36:58 -0700889 if (CC_UNLIKELY(!mDisplay)) {
890 return Error::BAD_DISPLAY;
891 }
892
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700893 if (metadata == mHdrMetadata) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700894 return Error::NONE;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700895 }
896
897 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700898 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
899 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
900 if (validTypes & HdrMetadata::SMPTE2086) {
901 perFrameMetadatas.insert(perFrameMetadatas.end(),
902 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800903 mHdrMetadata.smpte2086.displayPrimaryRed.x},
904 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
905 mHdrMetadata.smpte2086.displayPrimaryRed.y},
906 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
907 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
908 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
909 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
910 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
911 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
912 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
913 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
914 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
915 mHdrMetadata.smpte2086.whitePoint.x},
916 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
917 mHdrMetadata.smpte2086.whitePoint.y},
918 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
919 mHdrMetadata.smpte2086.maxLuminance},
920 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
921 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700922 }
923
924 if (validTypes & HdrMetadata::CTA861_3) {
925 perFrameMetadatas.insert(perFrameMetadatas.end(),
926 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800927 mHdrMetadata.cta8613.maxContentLightLevel},
928 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
929 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700930 }
931
Alec Mouri66d83482022-01-11 11:14:44 -0800932 const Error error = static_cast<Error>(
933 mComposer.setLayerPerFrameMetadata(mDisplay->getId(), mId, perFrameMetadatas));
934 if (error != Error::NONE) {
935 return error;
936 }
Valerie Haue9e843a2018-12-18 13:39:23 -0800937
Alec Mouri66d83482022-01-11 11:14:44 -0800938 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
Valerie Haue9e843a2018-12-18 13:39:23 -0800939 if (validTypes & HdrMetadata::HDR10PLUS) {
Yichi Chen1d5146d2020-06-12 18:50:11 +0800940 if (CC_UNLIKELY(mHdrMetadata.hdr10plus.size() == 0)) {
941 return Error::BAD_PARAMETER;
942 }
943
Valerie Haue9e843a2018-12-18 13:39:23 -0800944 perFrameMetadataBlobs.push_back(
945 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
Valerie Haue9e843a2018-12-18 13:39:23 -0800946 }
Alec Mouri66d83482022-01-11 11:14:44 -0800947
948 return static_cast<Error>(
949 mComposer.setLayerPerFrameMetadataBlobs(mDisplay->getId(), mId, perFrameMetadataBlobs));
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700950}
951
Dan Stoza651bf312015-10-23 17:03:17 -0700952Error Layer::setDisplayFrame(const Rect& frame)
953{
Lloyd Piquea516c002021-05-07 14:36:58 -0700954 if (CC_UNLIKELY(!mDisplay)) {
955 return Error::BAD_DISPLAY;
956 }
957
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800958 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800959 frame.right, frame.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700960 auto intError = mComposer.setLayerDisplayFrame(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700961 return static_cast<Error>(intError);
962}
963
964Error Layer::setPlaneAlpha(float alpha)
965{
Lloyd Piquea516c002021-05-07 14:36:58 -0700966 if (CC_UNLIKELY(!mDisplay)) {
967 return Error::BAD_DISPLAY;
968 }
969
970 auto intError = mComposer.setLayerPlaneAlpha(mDisplay->getId(), mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700971 return static_cast<Error>(intError);
972}
973
974Error Layer::setSidebandStream(const native_handle_t* stream)
975{
Lloyd Piquea516c002021-05-07 14:36:58 -0700976 if (CC_UNLIKELY(!mDisplay)) {
977 return Error::BAD_DISPLAY;
978 }
979
Ady Abrahamde549d42022-01-26 19:19:17 -0800980 if (mCapabilities.count(AidlCapability::SIDEBAND_STREAM) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700981 ALOGE("Attempted to call setSidebandStream without checking that the "
982 "device supports sideband streams");
Peiyong Line9d809e2020-04-14 13:10:48 -0700983 return Error::UNSUPPORTED;
Dan Stoza09e7a272016-04-14 12:31:01 -0700984 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700985 auto intError = mComposer.setLayerSidebandStream(mDisplay->getId(), mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700986 return static_cast<Error>(intError);
987}
988
989Error Layer::setSourceCrop(const FloatRect& crop)
990{
Lloyd Piquea516c002021-05-07 14:36:58 -0700991 if (CC_UNLIKELY(!mDisplay)) {
992 return Error::BAD_DISPLAY;
993 }
994
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800995 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800996 crop.left, crop.top, crop.right, crop.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700997 auto intError = mComposer.setLayerSourceCrop(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700998 return static_cast<Error>(intError);
999}
1000
1001Error Layer::setTransform(Transform transform)
1002{
Lloyd Piquea516c002021-05-07 14:36:58 -07001003 if (CC_UNLIKELY(!mDisplay)) {
1004 return Error::BAD_DISPLAY;
1005 }
1006
Chia-I Wuaab99f52016-10-05 12:59:58 +08001007 auto intTransform = static_cast<Hwc2::Transform>(transform);
Lloyd Piquea516c002021-05-07 14:36:58 -07001008 auto intError = mComposer.setLayerTransform(mDisplay->getId(), mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -07001009 return static_cast<Error>(intError);
1010}
1011
1012Error Layer::setVisibleRegion(const Region& region)
1013{
Lloyd Piquea516c002021-05-07 14:36:58 -07001014 if (CC_UNLIKELY(!mDisplay)) {
1015 return Error::BAD_DISPLAY;
1016 }
1017
Yichi Chen8366f562019-03-25 19:44:06 +08001018 if (region.isRect() && mVisibleRegion.isRect() &&
1019 (region.getBounds() == mVisibleRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001020 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +08001021 }
1022 mVisibleRegion = region;
Leon Scroggins III4459bf42022-01-04 13:58:26 -05001023 const auto hwcRects = convertRegionToHwcRects(region);
Lloyd Piquea516c002021-05-07 14:36:58 -07001024 auto intError = mComposer.setLayerVisibleRegion(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -07001025 return static_cast<Error>(intError);
1026}
1027
1028Error Layer::setZOrder(uint32_t z)
1029{
Lloyd Piquea516c002021-05-07 14:36:58 -07001030 if (CC_UNLIKELY(!mDisplay)) {
1031 return Error::BAD_DISPLAY;
1032 }
1033
1034 auto intError = mComposer.setLayerZOrder(mDisplay->getId(), mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -07001035 return static_cast<Error>(intError);
1036}
1037
Peiyong Lin698147a2018-09-14 13:27:18 -07001038// Composer HAL 2.3
1039Error Layer::setColorTransform(const android::mat4& matrix) {
Lloyd Piquea516c002021-05-07 14:36:58 -07001040 if (CC_UNLIKELY(!mDisplay)) {
1041 return Error::BAD_DISPLAY;
1042 }
1043
Peiyong Lin698147a2018-09-14 13:27:18 -07001044 if (matrix == mColorMatrix) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001045 return Error::NONE;
Peiyong Lin698147a2018-09-14 13:27:18 -07001046 }
Lloyd Piquea516c002021-05-07 14:36:58 -07001047 auto intError = mComposer.setLayerColorTransform(mDisplay->getId(), mId, matrix.asArray());
Peiyong Lin04d25872019-04-18 10:26:19 -07001048 Error error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -07001049 if (error != Error::NONE) {
Peiyong Lin04d25872019-04-18 10:26:19 -07001050 return error;
1051 }
1052 mColorMatrix = matrix;
1053 return error;
Peiyong Lin698147a2018-09-14 13:27:18 -07001054}
Lloyd Pique35d58242018-12-18 16:33:25 -08001055
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001056// Composer HAL 2.4
1057Error Layer::setLayerGenericMetadata(const std::string& name, bool mandatory,
1058 const std::vector<uint8_t>& value) {
Lloyd Piquea516c002021-05-07 14:36:58 -07001059 if (CC_UNLIKELY(!mDisplay)) {
1060 return Error::BAD_DISPLAY;
1061 }
1062
1063 auto intError =
1064 mComposer.setLayerGenericMetadata(mDisplay->getId(), mId, name, mandatory, value);
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001065 return static_cast<Error>(intError);
1066}
1067
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001068// AIDL HAL
Alec Mouri6da0e272022-02-07 12:45:57 -08001069Error Layer::setBrightness(float brightness) {
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001070 if (CC_UNLIKELY(!mDisplay)) {
1071 return Error::BAD_DISPLAY;
1072 }
1073
Alec Mouri6da0e272022-02-07 12:45:57 -08001074 auto intError = mComposer.setLayerBrightness(mDisplay->getId(), mId, brightness);
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001075 return static_cast<Error>(intError);
1076}
1077
Leon Scroggins IIId77d3162022-01-05 10:42:28 -05001078Error Layer::setBlockingRegion(const Region& region) {
1079 if (CC_UNLIKELY(!mDisplay)) {
1080 return Error::BAD_DISPLAY;
1081 }
1082
1083 if (region.isRect() && mBlockingRegion.isRect() &&
1084 (region.getBounds() == mBlockingRegion.getBounds())) {
1085 return Error::NONE;
1086 }
1087 mBlockingRegion = region;
1088 const auto hwcRects = convertRegionToHwcRects(region);
1089 const auto intError = mComposer.setLayerBlockingRegion(mDisplay->getId(), mId, hwcRects);
1090 return static_cast<Error>(intError);
1091}
1092
Sally Qi0abc4a52024-09-26 16:13:06 -07001093Error Layer::setLuts(aidl::android::hardware::graphics::composer3::Luts& luts) {
Sally Qi11dcd582024-08-16 18:11:27 -07001094 if (CC_UNLIKELY(!mDisplay)) {
1095 return Error::BAD_DISPLAY;
1096 }
1097 const auto intError = mComposer.setLayerLuts(mDisplay->getId(), mId, luts);
1098 return static_cast<Error>(intError);
1099}
1100
Brian Lindahl7a4cb7e2024-10-30 10:42:21 -06001101Error Layer::setPictureProfileHandle(const PictureProfileHandle& handle) {
1102 if (CC_UNLIKELY(!mDisplay)) {
1103 return Error::BAD_DISPLAY;
1104 }
1105 const auto intError =
1106 mComposer.setLayerPictureProfileId(mDisplay->getId(), mId, handle.getId());
1107 return static_cast<Error>(intError);
1108}
1109
Lloyd Pique35d58242018-12-18 16:33:25 -08001110} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -07001111} // namespace HWC2
Peiyong Line9d809e2020-04-14 13:10:48 -07001112} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001113
1114// TODO(b/129481165): remove the #pragma below and fix conversion issues
1115#pragma clang diagnostic pop // ignored "-Wconversion"