blob: 470bf76792e4f4e610803f6aeac8426e813e1a25 [file] [log] [blame]
Mathias Agopiana350ff92010-08-10 17:14:02 -07001/*
2 * Copyright (C) 2010 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 Stoza9e56aa02015-11-02 13:00:03 -080021// #define LOG_NDEBUG 0
22
23#undef LOG_TAG
24#define LOG_TAG "HWComposer"
Mathias Agopian2965b262012-04-08 15:13:32 -070025#define ATRACE_TAG ATRACE_TAG_GRAPHICS
26
Lloyd Pique66d68602019-02-13 14:23:31 -080027#include "HWComposer.h"
28
Marin Shalamanovf8c63722020-10-06 13:11:21 +020029#include <android-base/properties.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080030#include <compositionengine/Output.h>
31#include <compositionengine/OutputLayer.h>
32#include <compositionengine/impl/OutputLayerCompositionState.h>
Leon Scroggins III959a7ff2023-02-07 11:24:25 -050033#include <ftl/concat.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080034#include <log/log.h>
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070035#include <ui/DebugUtils.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070036#include <ui/GraphicBuffer.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080037#include <utils/Errors.h>
38#include <utils/Trace.h>
Mathias Agopiana350ff92010-08-10 17:14:02 -070039
Lloyd Pique66d68602019-02-13 14:23:31 -080040#include "../Layer.h" // needed only for debugging
Marin Shalamanovf8c63722020-10-06 13:11:21 +020041#include "../SurfaceFlingerProperties.h"
Lloyd Pique66d68602019-02-13 14:23:31 -080042#include "ComposerHal.h"
43#include "HWC2.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070044
Dominik Laskowskic1f18f62018-06-13 15:17:55 -070045#define LOG_HWC_DISPLAY_ERROR(hwcDisplayId, msg) \
46 ALOGE("%s failed for HWC display %" PRIu64 ": %s", __FUNCTION__, hwcDisplayId, msg)
47
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070048#define LOG_DISPLAY_ERROR(displayId, msg) \
Dominik Laskowski34157762018-10-31 13:07:19 -070049 ALOGE("%s failed for display %s: %s", __FUNCTION__, to_string(displayId).c_str(), msg)
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070050
Dominik Laskowski34157762018-10-31 13:07:19 -070051#define LOG_HWC_ERROR(what, error, displayId) \
52 ALOGE("%s: %s failed for display %s: %s (%d)", __FUNCTION__, what, \
53 to_string(displayId).c_str(), to_string(error).c_str(), static_cast<int32_t>(error))
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070054
55#define RETURN_IF_INVALID_DISPLAY(displayId, ...) \
56 do { \
Dominik Laskowski075d3172018-05-24 15:50:06 -070057 if (mDisplayData.count(displayId) == 0) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070058 LOG_DISPLAY_ERROR(displayId, "Invalid display"); \
59 return __VA_ARGS__; \
60 } \
61 } while (false)
62
63#define RETURN_IF_HWC_ERROR_FOR(what, error, displayId, ...) \
64 do { \
Peiyong Line9d809e2020-04-14 13:10:48 -070065 if (error != hal::Error::NONE) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070066 LOG_HWC_ERROR(what, error, displayId); \
67 return __VA_ARGS__; \
68 } \
69 } while (false)
70
71#define RETURN_IF_HWC_ERROR(error, displayId, ...) \
72 RETURN_IF_HWC_ERROR_FOR(__FUNCTION__, error, displayId, __VA_ARGS__)
73
Kriti Dang674b9372022-11-18 10:58:44 +010074using aidl::android::hardware::graphics::common::HdrConversionCapability;
75using aidl::android::hardware::graphics::common::HdrConversionStrategy;
Ady Abrahamde549d42022-01-26 19:19:17 -080076using aidl::android::hardware::graphics::composer3::Capability;
77using aidl::android::hardware::graphics::composer3::DisplayCapability;
Peiyong Line9d809e2020-04-14 13:10:48 -070078namespace hal = android::hardware::graphics::composer::hal;
79
Marin Shalamanov6e840172020-12-14 22:13:28 +010080namespace android {
Peiyong Linbdd08cc2019-12-17 21:35:14 -080081
Lloyd Pique441d5042018-10-18 16:49:51 -070082HWComposer::~HWComposer() = default;
83
84namespace impl {
85
Marin Shalamanovf8c63722020-10-06 13:11:21 +020086HWComposer::HWComposer(std::unique_ptr<Hwc2::Composer> composer)
87 : mComposer(std::move(composer)),
Dominik Laskowski13948602021-03-08 20:48:28 -080088 mMaxVirtualDisplayDimension(static_cast<size_t>(sysprop::max_virtual_display_dimension(0))),
Marin Shalamanovf8c63722020-10-06 13:11:21 +020089 mUpdateDeviceProductInfoOnHotplugReconnect(
Dominik Laskowski13948602021-03-08 20:48:28 -080090 sysprop::update_device_product_info_on_hotplug_reconnect(false)) {}
Peiyong Linbdd08cc2019-12-17 21:35:14 -080091
92HWComposer::HWComposer(const std::string& composerServiceName)
Ady Abraham9fc28052021-10-14 17:21:38 -070093 : HWComposer(Hwc2::Composer::create(composerServiceName)) {}
Mathias Agopianbef42c52013-08-21 17:45:46 -070094
Dominik Laskowskib04f98a2018-11-07 21:07:16 -080095HWComposer::~HWComposer() {
96 mDisplayData.clear();
97}
Dan Stoza9e56aa02015-11-02 13:00:03 -080098
Yichi Chen3401b562022-01-17 15:42:35 +080099void HWComposer::setCallback(HWC2::ComposerCallback& callback) {
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800100 loadCapabilities();
101 loadLayerMetadataSupport();
Sally Qibb866c12022-10-17 11:31:20 -0700102 loadOverlayProperties();
Kriti Dang674b9372022-11-18 10:58:44 +0100103 loadHdrConversionCapabilities();
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800104
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800105 if (mRegisteredCallback) {
106 ALOGW("Callback already registered. Ignored extra registration attempt.");
107 return;
108 }
109 mRegisteredCallback = true;
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700110
Yichi Chen3401b562022-01-17 15:42:35 +0800111 mComposer->registerCallback(callback);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800112}
113
Peiyong Line9d809e2020-04-14 13:10:48 -0700114bool HWComposer::getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700115 DisplayIdentificationData* outData) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700116 const auto error = static_cast<hal::Error>(
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800117 mComposer->getDisplayIdentificationData(hwcDisplayId, outPort, outData));
Peiyong Line9d809e2020-04-14 13:10:48 -0700118 if (error != hal::Error::NONE) {
119 if (error != hal::Error::UNSUPPORTED) {
Chia-I Wud0aff9d2018-06-21 13:39:09 +0800120 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, to_string(error).c_str());
121 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700122 return false;
123 }
124 return true;
125}
126
Ady Abrahamde549d42022-01-26 19:19:17 -0800127bool HWComposer::hasCapability(Capability capability) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800128 return mCapabilities.count(capability) > 0;
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700129}
130
Ady Abrahamde549d42022-01-26 19:19:17 -0800131bool HWComposer::hasDisplayCapability(HalDisplayId displayId, DisplayCapability capability) const {
Dominik Laskowski1162e472020-04-02 19:02:47 -0700132 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham27fbcc72021-09-20 14:54:57 -0700133 return mDisplayData.at(displayId).hwcDisplay->hasCapability(capability);
Peiyong Lined531a32018-10-26 18:27:56 -0700134}
135
Peiyong Line9d809e2020-04-14 13:10:48 -0700136std::optional<DisplayIdentificationInfo> HWComposer::onHotplug(hal::HWDisplayId hwcDisplayId,
137 hal::Connection connection) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100138 switch (connection) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700139 case hal::Connection::CONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100140 return onHotplugConnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700141 case hal::Connection::DISCONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100142 return onHotplugDisconnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700143 case hal::Connection::INVALID:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700144 return {};
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700145 }
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700146}
147
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200148bool HWComposer::updatesDeviceProductInfoOnHotplugReconnect() const {
149 return mUpdateDeviceProductInfoOnHotplugReconnect;
150}
151
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500152std::optional<PhysicalDisplayId> HWComposer::onVsync(hal::HWDisplayId hwcDisplayId,
153 nsecs_t timestamp) {
154 const auto displayIdOpt = toPhysicalDisplayId(hwcDisplayId);
155 if (!displayIdOpt) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700156 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500157 return {};
Jesse Hall1bd20e02012-08-29 10:47:52 -0700158 }
Jesse Hall1bd20e02012-08-29 10:47:52 -0700159
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500160 RETURN_IF_INVALID_DISPLAY(*displayIdOpt, {});
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700161
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500162 auto& displayData = mDisplayData[*displayIdOpt];
Jesse Hall1bd20e02012-08-29 10:47:52 -0700163
Dan Stoza9e56aa02015-11-02 13:00:03 -0800164 {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800165 // There have been reports of HWCs that signal several vsync events
166 // with the same timestamp when turning the display off and on. This
167 // is a bug in the HWC implementation, but filter the extra events
168 // out here so they don't cause havoc downstream.
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400169 if (timestamp == displayData.lastPresentTimestamp) {
Dominik Laskowski34157762018-10-31 13:07:19 -0700170 ALOGW("Ignoring duplicate VSYNC event from HWC for display %s (t=%" PRId64 ")",
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500171 to_string(*displayIdOpt).c_str(), timestamp);
172 return {};
Dan Stoza9e56aa02015-11-02 13:00:03 -0800173 }
174
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400175 displayData.lastPresentTimestamp = timestamp;
Jesse Hall1c569c42013-04-05 13:44:52 -0700176 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800177
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500178 ATRACE_INT(ftl::Concat("HW_VSYNC_", displayIdOpt->value).c_str(),
179 displayData.vsyncTraceToggle);
Dominik Laskowski1af47932018-11-12 10:20:46 -0800180 displayData.vsyncTraceToggle = !displayData.vsyncTraceToggle;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800181
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500182 return displayIdOpt;
Jesse Hall1c569c42013-04-05 13:44:52 -0700183}
184
Dominik Laskowski13948602021-03-08 20:48:28 -0800185size_t HWComposer::getMaxVirtualDisplayCount() const {
186 return mComposer->getMaxVirtualDisplayCount();
187}
188
189size_t HWComposer::getMaxVirtualDisplayDimension() const {
190 return mMaxVirtualDisplayDimension;
191}
192
193bool HWComposer::allocateVirtualDisplay(HalVirtualDisplayId displayId, ui::Size resolution,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700194 ui::PixelFormat* format) {
Dominik Laskowski13948602021-03-08 20:48:28 -0800195 if (!resolution.isValid()) {
196 ALOGE("%s: Invalid resolution %dx%d", __func__, resolution.width, resolution.height);
197 return false;
Fabien Sanglarde29055f2017-03-08 11:36:46 -0800198 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200199
Dominik Laskowski13948602021-03-08 20:48:28 -0800200 const uint32_t width = static_cast<uint32_t>(resolution.width);
201 const uint32_t height = static_cast<uint32_t>(resolution.height);
202
203 if (mMaxVirtualDisplayDimension > 0 &&
204 (width > mMaxVirtualDisplayDimension || height > mMaxVirtualDisplayDimension)) {
205 ALOGE("%s: Resolution %ux%u exceeds maximum dimension %zu", __func__, width, height,
206 mMaxVirtualDisplayDimension);
207 return false;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200208 }
209
Dominik Laskowski13948602021-03-08 20:48:28 -0800210 hal::HWDisplayId hwcDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700211 const auto error = static_cast<hal::Error>(
Dominik Laskowski263eec42021-07-21 23:13:24 -0700212 mComposer->createVirtualDisplay(width, height, format, &hwcDisplayId));
Dominik Laskowski13948602021-03-08 20:48:28 -0800213 RETURN_IF_HWC_ERROR_FOR("createVirtualDisplay", error, displayId, false);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800214
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800215 auto display = std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities,
Peiyong Line9d809e2020-04-14 13:10:48 -0700216 hwcDisplayId, hal::DisplayType::VIRTUAL);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800217 display->setConnected(true);
Dominik Laskowski13948602021-03-08 20:48:28 -0800218 auto& displayData = mDisplayData[displayId];
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800219 displayData.hwcDisplay = std::move(display);
Dominik Laskowski13948602021-03-08 20:48:28 -0800220 return true;
Mathias Agopiane60b0682012-08-21 23:34:09 -0700221}
222
Marin Shalamanova524a092020-07-27 21:39:55 +0200223void HWComposer::allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId,
224 PhysicalDisplayId displayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100225 mPhysicalDisplayIdMap[hwcDisplayId] = displayId;
226
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700227 if (!mPrimaryHwcDisplayId) {
228 mPrimaryHwcDisplayId = hwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100229 }
230
231 auto& displayData = mDisplayData[displayId];
232 auto newDisplay =
233 std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -0700234 hal::DisplayType::PHYSICAL);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100235 newDisplay->setConnected(true);
236 displayData.hwcDisplay = std::move(newDisplay);
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100237}
238
239int32_t HWComposer::getAttribute(hal::HWDisplayId hwcDisplayId, hal::HWConfigId configId,
Marin Shalamanov045b7002021-01-07 16:56:24 +0100240 hal::Attribute attribute) const {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100241 int32_t value = 0;
242 auto error = static_cast<hal::Error>(
243 mComposer->getDisplayAttribute(hwcDisplayId, configId, attribute, &value));
244
245 RETURN_IF_HWC_ERROR_FOR("getDisplayAttribute", error, *toPhysicalDisplayId(hwcDisplayId), -1);
246 return value;
247}
248
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700249std::shared_ptr<HWC2::Layer> HWComposer::createLayer(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700250 RETURN_IF_INVALID_DISPLAY(displayId, nullptr);
251
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700252 auto expected = mDisplayData[displayId].hwcDisplay->createLayer();
253 if (!expected.has_value()) {
254 auto error = std::move(expected).error();
255 RETURN_IF_HWC_ERROR(error, displayId, nullptr);
256 }
257 return std::move(expected).value();
Steven Thomas94e35b92017-07-26 18:48:28 -0700258}
259
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200260bool HWComposer::isConnected(PhysicalDisplayId displayId) const {
Dominik Laskowskif2ddca62022-08-17 12:08:07 -0700261 return mDisplayData.count(displayId) && mDisplayData.at(displayId).hwcDisplay->isConnected();
Mathias Agopian9c6e2972011-09-20 17:21:56 -0700262}
263
Marin Shalamanov045b7002021-01-07 16:56:24 +0100264std::vector<HWComposer::HWCDisplayMode> HWComposer::getModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700265 RETURN_IF_INVALID_DISPLAY(displayId, {});
266
Marin Shalamanov045b7002021-01-07 16:56:24 +0100267 const auto hwcDisplayId = mDisplayData.at(displayId).hwcDisplay->getId();
268 std::vector<hal::HWConfigId> configIds;
269 auto error = static_cast<hal::Error>(mComposer->getDisplayConfigs(hwcDisplayId, &configIds));
270 RETURN_IF_HWC_ERROR_FOR("getDisplayConfigs", error, *toPhysicalDisplayId(hwcDisplayId), {});
271
272 std::vector<HWCDisplayMode> modes;
273 modes.reserve(configIds.size());
274 for (auto configId : configIds) {
275 modes.push_back(HWCDisplayMode{
276 .hwcId = configId,
277 .width = getAttribute(hwcDisplayId, configId, hal::Attribute::WIDTH),
278 .height = getAttribute(hwcDisplayId, configId, hal::Attribute::HEIGHT),
279 .vsyncPeriod = getAttribute(hwcDisplayId, configId, hal::Attribute::VSYNC_PERIOD),
280 .dpiX = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_X),
281 .dpiY = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_Y),
282 .configGroup = getAttribute(hwcDisplayId, configId, hal::Attribute::CONFIG_GROUP),
283 });
284 }
285
286 return modes;
Mathias Agopianda27af92012-09-13 18:17:13 -0700287}
288
Marin Shalamanov045b7002021-01-07 16:56:24 +0100289std::optional<hal::HWConfigId> HWComposer::getActiveMode(PhysicalDisplayId displayId) const {
290 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100291 const auto hwcId = *fromPhysicalDisplayId(displayId);
Dominik Laskowskie2c5b0a2022-08-10 14:53:53 -0700292
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100293 hal::HWConfigId configId;
Dominik Laskowskie2c5b0a2022-08-10 14:53:53 -0700294 const auto error = static_cast<hal::Error>(mComposer->getActiveConfig(hwcId, &configId));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100295
Dominik Laskowskie2c5b0a2022-08-10 14:53:53 -0700296 RETURN_IF_HWC_ERROR_FOR("getActiveConfig", error, displayId, std::nullopt);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100297 return configId;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700298}
299
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800300// Composer 2.4
301
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100302ui::DisplayConnectionType HWComposer::getDisplayConnectionType(PhysicalDisplayId displayId) const {
303 RETURN_IF_INVALID_DISPLAY(displayId, ui::DisplayConnectionType::Internal);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800304 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
305
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100306 ui::DisplayConnectionType type;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800307 const auto error = hwcDisplay->getConnectionType(&type);
308
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700309 const auto FALLBACK_TYPE = hwcDisplay->getId() == mPrimaryHwcDisplayId
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100310 ? ui::DisplayConnectionType::Internal
311 : ui::DisplayConnectionType::External;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800312
313 RETURN_IF_HWC_ERROR(error, displayId, FALLBACK_TYPE);
314 return type;
315}
316
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200317bool HWComposer::isVsyncPeriodSwitchSupported(PhysicalDisplayId displayId) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800318 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800319 return mDisplayData.at(displayId).hwcDisplay->isVsyncPeriodSwitchSupported();
320}
321
Marin Shalamanov045b7002021-01-07 16:56:24 +0100322status_t HWComposer::getDisplayVsyncPeriod(PhysicalDisplayId displayId,
323 nsecs_t* outVsyncPeriod) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800324 RETURN_IF_INVALID_DISPLAY(displayId, 0);
325
Marin Shalamanov045b7002021-01-07 16:56:24 +0100326 if (!isVsyncPeriodSwitchSupported(displayId)) {
327 return INVALID_OPERATION;
Dominik Laskowskif3749f82018-06-13 15:49:25 -0700328 }
Marin Shalamanov045b7002021-01-07 16:56:24 +0100329 const auto hwcId = *fromPhysicalDisplayId(displayId);
330 Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0;
331 auto error =
332 static_cast<hal::Error>(mComposer->getDisplayVsyncPeriod(hwcId, &vsyncPeriodNanos));
333 RETURN_IF_HWC_ERROR(error, displayId, 0);
334 *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos);
335 return NO_ERROR;
Lloyd Pique3c085a02018-05-09 19:38:32 -0700336}
337
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200338std::vector<ui::ColorMode> HWComposer::getColorModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700339 RETURN_IF_INVALID_DISPLAY(displayId, {});
340
Peiyong Linfd997e02018-03-28 15:29:00 -0700341 std::vector<ui::ColorMode> modes;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700342 auto error = mDisplayData.at(displayId).hwcDisplay->getColorModes(&modes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700343 RETURN_IF_HWC_ERROR(error, displayId, {});
Courtney Goeltzenleuchterfad9d8c2016-06-23 11:49:50 -0600344 return modes;
345}
346
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200347status_t HWComposer::setActiveColorMode(PhysicalDisplayId displayId, ui::ColorMode mode,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700348 ui::RenderIntent renderIntent) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700349 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Michael Wright28f24d02016-07-12 13:30:53 -0700350
351 auto& displayData = mDisplayData[displayId];
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700352 auto error = displayData.hwcDisplay->setColorMode(mode, renderIntent);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700353 RETURN_IF_HWC_ERROR_FOR(("setColorMode(" + decodeColorMode(mode) + ", " +
354 decodeRenderIntent(renderIntent) + ")")
355 .c_str(),
356 error, displayId, UNKNOWN_ERROR);
Michael Wright28f24d02016-07-12 13:30:53 -0700357
358 return NO_ERROR;
359}
360
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200361void HWComposer::setVsyncEnabled(PhysicalDisplayId displayId, hal::Vsync enabled) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700362 RETURN_IF_INVALID_DISPLAY(displayId);
363 auto& displayData = mDisplayData[displayId];
364
Dan Stoza9e56aa02015-11-02 13:00:03 -0800365 // NOTE: we use our own internal lock here because we have to call
366 // into the HWC with the lock held, and we want to make sure
367 // that even if HWC blocks (which it shouldn't), it won't
368 // affect other threads.
Dominik Laskowski1af47932018-11-12 10:20:46 -0800369 std::lock_guard lock(displayData.vsyncEnabledLock);
370 if (enabled == displayData.vsyncEnabled) {
371 return;
Colin Cross10fbdb62012-07-12 17:56:34 -0700372 }
Dominik Laskowski1af47932018-11-12 10:20:46 -0800373
374 ATRACE_CALL();
375 auto error = displayData.hwcDisplay->setVsyncEnabled(enabled);
376 RETURN_IF_HWC_ERROR(error, displayId);
377
378 displayData.vsyncEnabled = enabled;
379
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500380 ATRACE_INT(ftl::Concat("HW_VSYNC_ON_", displayId.value).c_str(),
381 enabled == hal::Vsync::ENABLE ? 1 : 0);
Colin Cross10fbdb62012-07-12 17:56:34 -0700382}
383
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200384status_t HWComposer::setClientTarget(HalDisplayId displayId, uint32_t slot,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700385 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
386 ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700387 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Jesse Hall851cfe82013-03-20 13:44:00 -0700388
Dominik Laskowski34157762018-10-31 13:07:19 -0700389 ALOGV("%s for display %s", __FUNCTION__, to_string(displayId).c_str());
Dan Stoza9e56aa02015-11-02 13:00:03 -0800390 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400391 auto error = hwcDisplay->setClientTarget(slot, target, acquireFence, dataspace);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700392 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Jesse Hall851cfe82013-03-20 13:44:00 -0700393 return NO_ERROR;
394}
395
Lloyd Pique66d68602019-02-13 14:23:31 -0800396status_t HWComposer::getDeviceCompositionChanges(
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200397 HalDisplayId displayId, bool frameUsesClientComposition,
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700398 std::chrono::steady_clock::time_point earliestPresentTime,
Ady Abraham43065bd2021-12-10 17:22:15 -0800399 const std::shared_ptr<FenceTime>& previousPresentFence, nsecs_t expectedPresentTime,
Lloyd Pique66d68602019-02-13 14:23:31 -0800400 std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800401 ATRACE_CALL();
402
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700403 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800404
405 auto& displayData = mDisplayData[displayId];
406 auto& hwcDisplay = displayData.hwcDisplay;
407 if (!hwcDisplay->isConnected()) {
408 return NO_ERROR;
409 }
410
411 uint32_t numTypes = 0;
412 uint32_t numRequests = 0;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700413
Peiyong Line9d809e2020-04-14 13:10:48 -0700414 hal::Error error = hal::Error::NONE;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700415
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700416 // First try to skip validate altogether. We can do that when
417 // 1. The previous frame has not been presented yet or already passed the
418 // earliest time to present. Otherwise, we may present a frame too early.
419 // 2. There is no client composition. Otherwise, we first need to render the
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700420 // client target buffer.
Ady Abraham43065bd2021-12-10 17:22:15 -0800421 const bool canSkipValidate = [&] {
422 // We must call validate if we have client composition
423 if (frameUsesClientComposition) {
424 return false;
425 }
426
427 // If composer supports getting the expected present time, we can skip
428 // as composer will make sure to prevent early presentation
429 if (mComposer->isSupported(Hwc2::Composer::OptionalFeature::ExpectedPresentTime)) {
430 return true;
431 }
432
433 // composer doesn't support getting the expected present time. We can only
434 // skip validate if we know that we are not going to present early.
435 return std::chrono::steady_clock::now() >= earliestPresentTime ||
436 previousPresentFence->getSignalTime() == Fence::SIGNAL_TIME_PENDING;
437 }();
438
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700439 displayData.validateWasSkipped = false;
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700440 if (canSkipValidate) {
Dominik Laskowski1af47932018-11-12 10:20:46 -0800441 sp<Fence> outPresentFence;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700442 uint32_t state = UINT32_MAX;
Ady Abraham43065bd2021-12-10 17:22:15 -0800443 error = hwcDisplay->presentOrValidate(expectedPresentTime, &numTypes, &numRequests,
444 &outPresentFence, &state);
Peiyong Line9d809e2020-04-14 13:10:48 -0700445 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700446 RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700447 }
448 if (state == 1) { //Present Succeeded.
Steven Thomas94e35b92017-07-26 18:48:28 -0700449 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700450 error = hwcDisplay->getReleaseFences(&releaseFences);
451 displayData.releaseFences = std::move(releaseFences);
452 displayData.lastPresentFence = outPresentFence;
453 displayData.validateWasSkipped = true;
454 displayData.presentError = error;
455 return NO_ERROR;
456 }
457 // Present failed but Validate ran.
458 } else {
Ady Abraham43065bd2021-12-10 17:22:15 -0800459 error = hwcDisplay->validate(expectedPresentTime, &numTypes, &numRequests);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700460 }
461 ALOGV("SkipValidate failed, Falling back to SLOW validate/present");
Peiyong Line9d809e2020-04-14 13:10:48 -0700462 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700463 RETURN_IF_HWC_ERROR_FOR("validate", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800464 }
465
Lloyd Pique66d68602019-02-13 14:23:31 -0800466 android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800467 changedTypes.reserve(numTypes);
468 error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700469 RETURN_IF_HWC_ERROR_FOR("getChangedCompositionTypes", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800470
Peiyong Line9d809e2020-04-14 13:10:48 -0700471 auto displayRequests = static_cast<hal::DisplayRequest>(0);
Lloyd Pique66d68602019-02-13 14:23:31 -0800472 android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800473 layerRequests.reserve(numRequests);
Lloyd Pique66d68602019-02-13 14:23:31 -0800474 error = hwcDisplay->getRequests(&displayRequests, &layerRequests);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700475 RETURN_IF_HWC_ERROR_FOR("getRequests", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800476
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700477 DeviceRequestedChanges::ClientTargetProperty clientTargetProperty;
Alec Mouri85065692022-03-18 00:58:26 +0000478 error = hwcDisplay->getClientTargetProperty(&clientTargetProperty);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800479
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700480 outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes), std::move(displayRequests),
481 std::move(layerRequests),
Alec Mouri85065692022-03-18 00:58:26 +0000482 std::move(clientTargetProperty)});
Dan Stoza9e56aa02015-11-02 13:00:03 -0800483 error = hwcDisplay->acceptChanges();
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700484 RETURN_IF_HWC_ERROR_FOR("acceptChanges", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800485
486 return NO_ERROR;
487}
488
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200489sp<Fence> HWComposer::getPresentFence(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700490 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700491 return mDisplayData.at(displayId).lastPresentFence;
Jesse Hall851cfe82013-03-20 13:44:00 -0700492}
493
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400494nsecs_t HWComposer::getPresentTimestamp(PhysicalDisplayId displayId) const {
495 RETURN_IF_INVALID_DISPLAY(displayId, 0);
496 return mDisplayData.at(displayId).lastPresentTimestamp;
497}
498
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200499sp<Fence> HWComposer::getLayerReleaseFence(HalDisplayId displayId, HWC2::Layer* layer) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700500 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Tim Murray2d3f8b82019-12-04 16:24:17 -0800501 const auto& displayFences = mDisplayData.at(displayId).releaseFences;
502 auto fence = displayFences.find(layer);
503 if (fence == displayFences.end()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800504 ALOGV("getLayerReleaseFence: Release fence not found");
505 return Fence::NO_FENCE;
Riley Andrews03414a12014-07-01 14:22:59 -0700506 }
Tim Murray2d3f8b82019-12-04 16:24:17 -0800507 return fence->second;
Riley Andrews03414a12014-07-01 14:22:59 -0700508}
509
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700510status_t HWComposer::presentAndGetReleaseFences(
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700511 HalDisplayId displayId, std::chrono::steady_clock::time_point earliestPresentTime,
512 const std::shared_ptr<FenceTime>& previousPresentFence) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800513 ATRACE_CALL();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700514
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700515 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Pablo Ceballosd814cf22015-09-11 14:37:39 -0700516
Dan Stoza9e56aa02015-11-02 13:00:03 -0800517 auto& displayData = mDisplayData[displayId];
518 auto& hwcDisplay = displayData.hwcDisplay;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700519
520 if (displayData.validateWasSkipped) {
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700521 // explicitly flush all pending commands
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400522 auto error = static_cast<hal::Error>(mComposer->executeCommands(hwcDisplay->getId()));
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800523 RETURN_IF_HWC_ERROR_FOR("executeCommands", error, displayId, UNKNOWN_ERROR);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700524 RETURN_IF_HWC_ERROR_FOR("present", displayData.presentError, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700525 return NO_ERROR;
526 }
527
Ady Abraham43065bd2021-12-10 17:22:15 -0800528 const bool waitForEarliestPresent =
529 !mComposer->isSupported(Hwc2::Composer::OptionalFeature::ExpectedPresentTime) &&
530 previousPresentFence->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
531
532 if (waitForEarliestPresent) {
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700533 ATRACE_NAME("wait for earliest present time");
534 std::this_thread::sleep_until(earliestPresentTime);
535 }
536
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800537 auto error = hwcDisplay->present(&displayData.lastPresentFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700538 RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700539
Steven Thomas94e35b92017-07-26 18:48:28 -0700540 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800541 error = hwcDisplay->getReleaseFences(&releaseFences);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700542 RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800543
544 displayData.releaseFences = std::move(releaseFences);
545
546 return NO_ERROR;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700547}
548
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200549status_t HWComposer::setPowerMode(PhysicalDisplayId displayId, hal::PowerMode mode) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700550 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
551
Peiyong Line9d809e2020-04-14 13:10:48 -0700552 if (mode == hal::PowerMode::OFF) {
553 setVsyncEnabled(displayId, hal::Vsync::DISABLE);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800554 }
555
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700556 const auto& displayData = mDisplayData[displayId];
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700557 auto& hwcDisplay = displayData.hwcDisplay;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800558 switch (mode) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700559 case hal::PowerMode::OFF:
560 case hal::PowerMode::ON:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800561 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
562 {
563 auto error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700564 if (error != hal::Error::NONE) {
565 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
566 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700567 }
Mathias Agopianda27af92012-09-13 18:17:13 -0700568 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800569 break;
Peiyong Line9d809e2020-04-14 13:10:48 -0700570 case hal::PowerMode::DOZE:
571 case hal::PowerMode::DOZE_SUSPEND:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800572 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
573 {
574 bool supportsDoze = false;
575 auto error = hwcDisplay->supportsDoze(&supportsDoze);
Peiyong Line9d809e2020-04-14 13:10:48 -0700576 if (error != hal::Error::NONE) {
Peiyong Lin306e4992018-05-07 16:18:22 -0700577 LOG_HWC_ERROR("supportsDoze", error, displayId);
578 }
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700579
Dan Stoza9e56aa02015-11-02 13:00:03 -0800580 if (!supportsDoze) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700581 mode = hal::PowerMode::ON;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800582 }
583
584 error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700585 if (error != hal::Error::NONE) {
586 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
587 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700588 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800589 }
590 break;
591 default:
592 ALOGV("setPowerMode: Not calling HWC");
593 break;
Mathias Agopianda27af92012-09-13 18:17:13 -0700594 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800595
596 return NO_ERROR;
597}
598
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100599status_t HWComposer::setActiveModeWithConstraints(
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100600 PhysicalDisplayId displayId, hal::HWConfigId hwcModeId,
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200601 const hal::VsyncPeriodChangeConstraints& constraints,
Peiyong Line9d809e2020-04-14 13:10:48 -0700602 hal::VsyncPeriodChangeTimeline* outTimeline) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700603 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800604
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100605 auto error = mDisplayData[displayId].hwcDisplay->setActiveConfigWithConstraints(hwcModeId,
606 constraints,
607 outTimeline);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700608 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800609 return NO_ERROR;
610}
611
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200612status_t HWComposer::setColorTransform(HalDisplayId displayId, const mat4& transform) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700613 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700614
615 auto& displayData = mDisplayData[displayId];
Ady Abrahamdc011a92021-12-21 14:06:44 -0800616 auto error = displayData.hwcDisplay->setColorTransform(transform);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700617 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700618 return NO_ERROR;
619}
620
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200621void HWComposer::disconnectDisplay(HalDisplayId displayId) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700622 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800623 auto& displayData = mDisplayData[displayId];
Dominik Laskowski7e045462018-05-30 13:02:02 -0700624 const auto hwcDisplayId = displayData.hwcDisplay->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700625
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800626 mPhysicalDisplayIdMap.erase(hwcDisplayId);
627 mDisplayData.erase(displayId);
Marin Shalamanov8b196592021-08-09 16:24:42 +0200628
629 // Reset the primary display ID if we're disconnecting it.
630 // This way isHeadless() will return false, which is necessary
631 // because getPrimaryDisplayId() will crash.
632 if (mPrimaryHwcDisplayId == hwcDisplayId) {
633 mPrimaryHwcDisplayId.reset();
634 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800635}
636
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200637status_t HWComposer::setOutputBuffer(HalVirtualDisplayId displayId, const sp<Fence>& acquireFence,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700638 const sp<GraphicBuffer>& buffer) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700639 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700640 const auto& displayData = mDisplayData[displayId];
Dan Stoza9e56aa02015-11-02 13:00:03 -0800641
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700642 auto error = displayData.hwcDisplay->setOutputBuffer(buffer, acquireFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700643 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800644 return NO_ERROR;
645}
646
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200647void HWComposer::clearReleaseFences(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700648 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800649 mDisplayData[displayId].releaseFences.clear();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700650}
651
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200652status_t HWComposer::getHdrCapabilities(HalDisplayId displayId, HdrCapabilities* outCapabilities) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700653 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stozac4f471e2016-03-24 09:31:08 -0700654
655 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Peiyong Lin62665892018-04-16 11:07:44 -0700656 auto error = hwcDisplay->getHdrCapabilities(outCapabilities);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700657 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Peiyong Lin62665892018-04-16 11:07:44 -0700658 return NO_ERROR;
Dan Stozac4f471e2016-03-24 09:31:08 -0700659}
660
Sally Qibb866c12022-10-17 11:31:20 -0700661const aidl::android::hardware::graphics::composer3::OverlayProperties&
662HWComposer::getOverlaySupport() const {
663 return mOverlayProperties;
Sally Qi0cbd08b2022-08-17 12:12:28 -0700664}
665
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200666int32_t HWComposer::getSupportedPerFrameMetadata(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700667 RETURN_IF_INVALID_DISPLAY(displayId, 0);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700668 return mDisplayData.at(displayId).hwcDisplay->getSupportedPerFrameMetadata();
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700669}
670
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200671std::vector<ui::RenderIntent> HWComposer::getRenderIntents(HalDisplayId displayId,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700672 ui::ColorMode colorMode) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700673 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700674
675 std::vector<ui::RenderIntent> renderIntents;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700676 auto error = mDisplayData.at(displayId).hwcDisplay->getRenderIntents(colorMode, &renderIntents);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700677 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700678 return renderIntents;
679}
680
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200681mat4 HWComposer::getDataspaceSaturationMatrix(HalDisplayId displayId, ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700682 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700683
684 mat4 matrix;
685 auto error = mDisplayData[displayId].hwcDisplay->getDataspaceSaturationMatrix(dataspace,
686 &matrix);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700687 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700688 return matrix;
689}
690
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200691status_t HWComposer::getDisplayedContentSamplingAttributes(HalDisplayId displayId,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700692 ui::PixelFormat* outFormat,
693 ui::Dataspace* outDataspace,
694 uint8_t* outComponentMask) {
695 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
696 const auto error =
697 mDisplayData[displayId]
698 .hwcDisplay->getDisplayedContentSamplingAttributes(outFormat, outDataspace,
699 outComponentMask);
Peiyong Line9d809e2020-04-14 13:10:48 -0700700 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700701 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
702 return NO_ERROR;
703}
704
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200705status_t HWComposer::setDisplayContentSamplingEnabled(HalDisplayId displayId, bool enabled,
Kevin DuBois74e53772018-11-19 10:52:38 -0800706 uint8_t componentMask, uint64_t maxFrames) {
707 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
708 const auto error =
709 mDisplayData[displayId].hwcDisplay->setDisplayContentSamplingEnabled(enabled,
710 componentMask,
711 maxFrames);
712
Peiyong Line9d809e2020-04-14 13:10:48 -0700713 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
714 if (error == hal::Error::BAD_PARAMETER) RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Kevin DuBois74e53772018-11-19 10:52:38 -0800715 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
716 return NO_ERROR;
717}
718
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200719status_t HWComposer::getDisplayedContentSample(HalDisplayId displayId, uint64_t maxFrames,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700720 uint64_t timestamp, DisplayedFrameStats* outStats) {
721 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
722 const auto error =
723 mDisplayData[displayId].hwcDisplay->getDisplayedContentSample(maxFrames, timestamp,
724 outStats);
725 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
726 return NO_ERROR;
727}
728
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700729ftl::Future<status_t> HWComposer::setDisplayBrightness(
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000730 PhysicalDisplayId displayId, float brightness, float brightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -0800731 const Hwc2::Composer::DisplayBrightnessOptions& options) {
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800732 RETURN_IF_INVALID_DISPLAY(displayId, ftl::yield<status_t>(BAD_INDEX));
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700733 auto& display = mDisplayData[displayId].hwcDisplay;
734
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700735 return display->setDisplayBrightness(brightness, brightnessNits, options)
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700736 .then([displayId](hal::Error error) -> status_t {
737 if (error == hal::Error::UNSUPPORTED) {
738 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
739 }
740 if (error == hal::Error::BAD_PARAMETER) {
741 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
742 }
743 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
744 return NO_ERROR;
745 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000746}
747
Matt Buckley50c44062022-01-17 20:48:10 +0000748bool HWComposer::getValidateSkipped(HalDisplayId displayId) const {
749 if (mDisplayData.count(displayId) == 0) {
750 return false;
751 }
752 return mDisplayData.at(displayId).validateWasSkipped;
753}
754
Kriti Dang7defaf32021-11-15 11:55:43 +0100755status_t HWComposer::setBootDisplayMode(PhysicalDisplayId displayId,
756 hal::HWConfigId displayModeId) {
757 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
758 const auto error = mDisplayData[displayId].hwcDisplay->setBootDisplayConfig(displayModeId);
759 if (error == hal::Error::UNSUPPORTED) {
760 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
761 }
762 if (error == hal::Error::BAD_PARAMETER) {
763 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
764 }
765 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
766 return NO_ERROR;
767}
768
769status_t HWComposer::clearBootDisplayMode(PhysicalDisplayId displayId) {
770 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
771 const auto error = mDisplayData[displayId].hwcDisplay->clearBootDisplayConfig();
772 if (error == hal::Error::UNSUPPORTED) {
773 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
774 }
775 if (error == hal::Error::BAD_PARAMETER) {
776 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
777 }
778 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
779 return NO_ERROR;
780}
781
Kriti Dang16ca2972022-02-01 20:07:03 +0100782std::optional<hal::HWConfigId> HWComposer::getPreferredBootDisplayMode(
783 PhysicalDisplayId displayId) {
784 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
785 hal::HWConfigId displayModeId;
Kriti Dang7defaf32021-11-15 11:55:43 +0100786 const auto error =
787 mDisplayData[displayId].hwcDisplay->getPreferredBootDisplayConfig(&displayModeId);
Kriti Dang16ca2972022-02-01 20:07:03 +0100788 if (error != hal::Error::NONE) {
789 LOG_DISPLAY_ERROR(displayId, to_string(error).c_str());
790 return std::nullopt;
Kriti Dang7defaf32021-11-15 11:55:43 +0100791 }
Kriti Dang7defaf32021-11-15 11:55:43 +0100792 return displayModeId;
793}
794
Kriti Dang674b9372022-11-18 10:58:44 +0100795std::vector<HdrConversionCapability> HWComposer::getHdrConversionCapabilities() const {
796 return mHdrConversionCapabilities;
797}
798
Kriti Dangd432bb52023-02-09 18:21:04 +0100799status_t HWComposer::setHdrConversionStrategy(
800 HdrConversionStrategy hdrConversionStrategy,
801 aidl::android::hardware::graphics::common::Hdr* outPreferredHdrOutputType) {
802 const auto error =
803 mComposer->setHdrConversionStrategy(hdrConversionStrategy, outPreferredHdrOutputType);
Kriti Dang674b9372022-11-18 10:58:44 +0100804 if (error != hal::Error::NONE) {
805 ALOGE("Error in setting HDR conversion strategy %s", to_string(error).c_str());
Kriti Dangd432bb52023-02-09 18:21:04 +0100806 return INVALID_OPERATION;
Kriti Dang674b9372022-11-18 10:58:44 +0100807 }
808 return NO_ERROR;
809}
810
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500811status_t HWComposer::getDisplayDecorationSupport(
812 PhysicalDisplayId displayId,
813 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
814 support) {
815 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
816 const auto error = mDisplayData[displayId].hwcDisplay->getDisplayDecorationSupport(support);
817 if (error == hal::Error::UNSUPPORTED) {
818 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
819 }
820 if (error == hal::Error::BAD_PARAMETER) {
821 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
822 }
823 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
824 return NO_ERROR;
825}
826
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200827status_t HWComposer::setAutoLowLatencyMode(PhysicalDisplayId displayId, bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100828 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
829 const auto error = mDisplayData[displayId].hwcDisplay->setAutoLowLatencyMode(on);
Peiyong Line9d809e2020-04-14 13:10:48 -0700830 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100831 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
832 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700833 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100834 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
835 }
836 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
837 return NO_ERROR;
838}
839
840status_t HWComposer::getSupportedContentTypes(
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800841 PhysicalDisplayId displayId,
842 std::vector<hal::ContentType>* outSupportedContentTypes) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100843 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800844 const auto error = mDisplayData.at(displayId).hwcDisplay->getSupportedContentTypes(
845 outSupportedContentTypes);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100846
847 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
848
849 return NO_ERROR;
850}
851
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200852status_t HWComposer::setContentType(PhysicalDisplayId displayId, hal::ContentType contentType) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100853 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
854 const auto error = mDisplayData[displayId].hwcDisplay->setContentType(contentType);
Peiyong Line9d809e2020-04-14 13:10:48 -0700855 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100856 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
857 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700858 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100859 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
860 }
861 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
862
863 return NO_ERROR;
864}
865
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800866const std::unordered_map<std::string, bool>& HWComposer::getSupportedLayerGenericMetadata() const {
867 return mSupportedLayerGenericMetadata;
868}
869
Yiwei Zhang5434a782018-12-05 18:06:32 -0800870void HWComposer::dump(std::string& result) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800871 result.append(mComposer->dumpDebugInfo());
Mathias Agopian83727852010-09-23 18:13:21 -0700872}
873
Marin Shalamanova524a092020-07-27 21:39:55 +0200874std::optional<PhysicalDisplayId> HWComposer::toPhysicalDisplayId(
875 hal::HWDisplayId hwcDisplayId) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700876 if (const auto it = mPhysicalDisplayIdMap.find(hwcDisplayId);
877 it != mPhysicalDisplayIdMap.end()) {
878 return it->second;
879 }
880 return {};
881}
882
Marin Shalamanova524a092020-07-27 21:39:55 +0200883std::optional<hal::HWDisplayId> HWComposer::fromPhysicalDisplayId(
884 PhysicalDisplayId displayId) const {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700885 if (const auto it = mDisplayData.find(displayId); it != mDisplayData.end()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700886 return it->second.hwcDisplay->getId();
887 }
888 return {};
889}
890
Peiyong Line9d809e2020-04-14 13:10:48 -0700891bool HWComposer::shouldIgnoreHotplugConnect(hal::HWDisplayId hwcDisplayId,
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100892 bool hasDisplayIdentificationData) const {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100893 if (mHasMultiDisplaySupport && !hasDisplayIdentificationData) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700894 ALOGE("Ignoring connection of display %" PRIu64 " without identification data",
895 hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100896 return true;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700897 }
898
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700899 // Legacy mode only supports IDs LEGACY_DISPLAY_TYPE_PRIMARY and LEGACY_DISPLAY_TYPE_EXTERNAL.
900 if (!mHasMultiDisplaySupport && mPhysicalDisplayIdMap.size() == 2) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700901 ALOGE("Ignoring connection of tertiary display %" PRIu64, hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100902 return true;
903 }
904
905 return false;
906}
907
Peiyong Line9d809e2020-04-14 13:10:48 -0700908std::optional<DisplayIdentificationInfo> HWComposer::onHotplugConnect(
909 hal::HWDisplayId hwcDisplayId) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100910 std::optional<DisplayIdentificationInfo> info;
911 if (const auto displayId = toPhysicalDisplayId(hwcDisplayId)) {
912 info = DisplayIdentificationInfo{.id = *displayId,
913 .name = std::string(),
914 .deviceProductInfo = std::nullopt};
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200915 if (mUpdateDeviceProductInfoOnHotplugReconnect) {
916 uint8_t port;
917 DisplayIdentificationData data;
918 getDisplayIdentificationData(hwcDisplayId, &port, &data);
919 if (auto newInfo = parseDisplayIdentificationData(port, data)) {
920 info->deviceProductInfo = std::move(newInfo->deviceProductInfo);
921 } else {
922 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
923 }
924 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700925 } else {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100926 uint8_t port;
927 DisplayIdentificationData data;
928 const bool hasDisplayIdentificationData =
929 getDisplayIdentificationData(hwcDisplayId, &port, &data);
930 if (mPhysicalDisplayIdMap.empty()) {
931 mHasMultiDisplaySupport = hasDisplayIdentificationData;
932 ALOGI("Switching to %s multi-display mode",
933 mHasMultiDisplaySupport ? "generalized" : "legacy");
934 }
935
936 if (shouldIgnoreHotplugConnect(hwcDisplayId, hasDisplayIdentificationData)) {
937 return {};
938 }
939
940 info = [this, hwcDisplayId, &port, &data, hasDisplayIdentificationData] {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700941 const bool isPrimary = !mPrimaryHwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100942 if (mHasMultiDisplaySupport) {
943 if (const auto info = parseDisplayIdentificationData(port, data)) {
944 return *info;
945 }
946 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
947 } else {
948 ALOGW_IF(hasDisplayIdentificationData,
949 "Ignoring identification data for display %" PRIu64, hwcDisplayId);
Peiyong Lin65248e02020-04-18 21:15:07 -0700950 port = isPrimary ? LEGACY_DISPLAY_TYPE_PRIMARY : LEGACY_DISPLAY_TYPE_EXTERNAL;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100951 }
952
Marin Shalamanova524a092020-07-27 21:39:55 +0200953 return DisplayIdentificationInfo{.id = PhysicalDisplayId::fromPort(port),
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700954 .name = isPrimary ? "Primary display"
955 : "Secondary display",
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100956 .deviceProductInfo = std::nullopt};
957 }();
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400958
959 mComposer->onHotplugConnect(hwcDisplayId);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700960 }
961
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100962 if (!isConnected(info->id)) {
963 allocatePhysicalDisplay(hwcDisplayId, info->id);
964 }
965 return info;
966}
967
968std::optional<DisplayIdentificationInfo> HWComposer::onHotplugDisconnect(
Peiyong Line9d809e2020-04-14 13:10:48 -0700969 hal::HWDisplayId hwcDisplayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700970 LOG_ALWAYS_FATAL_IF(hwcDisplayId == mPrimaryHwcDisplayId,
971 "Primary display cannot be disconnected.");
972
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100973 const auto displayId = toPhysicalDisplayId(hwcDisplayId);
974 if (!displayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700975 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100976 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700977 }
978
Dominik Laskowskif2ddca62022-08-17 12:08:07 -0700979 if (!isConnected(*displayId)) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700980 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Already disconnected");
Dominik Laskowskif2ddca62022-08-17 12:08:07 -0700981 return {};
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100982 }
Dominik Laskowskif2ddca62022-08-17 12:08:07 -0700983
984 // The display will later be destroyed by a call to HWComposer::disconnectDisplay. For now, mark
985 // it as disconnected.
986 mDisplayData.at(*displayId).hwcDisplay->setConnected(false);
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400987 mComposer->onHotplugDisconnect(hwcDisplayId);
Dominik Laskowskif2ddca62022-08-17 12:08:07 -0700988 return DisplayIdentificationInfo{.id = *displayId};
Steven Thomas6e8f7062017-11-22 14:15:29 -0800989}
990
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800991void HWComposer::loadCapabilities() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700992 static_assert(sizeof(hal::Capability) == sizeof(int32_t), "Capability size has changed");
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800993 auto capabilities = mComposer->getCapabilities();
994 for (auto capability : capabilities) {
Ady Abrahamde549d42022-01-26 19:19:17 -0800995 mCapabilities.emplace(capability);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800996 }
997}
998
Sally Qibb866c12022-10-17 11:31:20 -0700999void HWComposer::loadOverlayProperties() {
1000 mComposer->getOverlaySupport(&mOverlayProperties);
1001}
1002
Kriti Dang674b9372022-11-18 10:58:44 +01001003void HWComposer::loadHdrConversionCapabilities() {
1004 const auto error = mComposer->getHdrConversionCapabilities(&mHdrConversionCapabilities);
1005 if (error != hal::Error::NONE) {
1006 ALOGE("Error in fetching HDR conversion capabilities %s", to_string(error).c_str());
1007 mHdrConversionCapabilities = {};
1008 }
1009}
1010
ramindani32cf0602022-03-02 02:30:29 +00001011status_t HWComposer::setIdleTimerEnabled(PhysicalDisplayId displayId,
1012 std::chrono::milliseconds timeout) {
1013 ATRACE_CALL();
1014 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
1015 const auto error = mDisplayData[displayId].hwcDisplay->setIdleTimerEnabled(timeout);
1016 if (error == hal::Error::UNSUPPORTED) {
1017 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
1018 }
1019 if (error == hal::Error::BAD_PARAMETER) {
1020 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
1021 }
1022 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
1023 return NO_ERROR;
1024}
1025
ramindani06e518e2022-03-14 18:47:53 +00001026bool HWComposer::hasDisplayIdleTimerCapability(PhysicalDisplayId displayId) const {
ramindani32cf0602022-03-02 02:30:29 +00001027 RETURN_IF_INVALID_DISPLAY(displayId, false);
ramindani06e518e2022-03-14 18:47:53 +00001028 return mDisplayData.at(displayId).hwcDisplay->hasDisplayIdleTimerCapability();
1029}
1030
1031Hwc2::AidlTransform HWComposer::getPhysicalDisplayOrientation(PhysicalDisplayId displayId) const {
1032 ATRACE_CALL();
1033 RETURN_IF_INVALID_DISPLAY(displayId, Hwc2::AidlTransform::NONE);
1034 Hwc2::AidlTransform outTransform;
1035 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
1036 const auto error = hwcDisplay->getPhysicalDisplayOrientation(&outTransform);
1037 RETURN_IF_HWC_ERROR(error, displayId, Hwc2::AidlTransform::NONE);
1038 return outTransform;
ramindani32cf0602022-03-02 02:30:29 +00001039}
1040
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001041void HWComposer::loadLayerMetadataSupport() {
1042 mSupportedLayerGenericMetadata.clear();
1043
1044 std::vector<Hwc2::IComposerClient::LayerGenericMetadataKey> supportedMetadataKeyInfo;
1045 const auto error = mComposer->getLayerGenericMetadataKeys(&supportedMetadataKeyInfo);
1046 if (error != hardware::graphics::composer::V2_4::Error::NONE) {
Ady Abraham3891cbe2021-03-29 11:29:31 -07001047 if (error != hardware::graphics::composer::V2_4::Error::UNSUPPORTED) {
1048 ALOGE("%s: %s failed: %s (%d)", __FUNCTION__, "getLayerGenericMetadataKeys",
1049 toString(error).c_str(), static_cast<int32_t>(error));
1050 }
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001051 return;
1052 }
1053
1054 for (const auto& [name, mandatory] : supportedMetadataKeyInfo) {
1055 mSupportedLayerGenericMetadata.emplace(name, mandatory);
1056 }
1057}
1058
Lloyd Pique441d5042018-10-18 16:49:51 -07001059} // namespace impl
Dominik Laskowskif9750f22018-06-06 12:24:53 -07001060} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001061
1062// TODO(b/129481165): remove the #pragma below and fix conversion issues
1063#pragma clang diagnostic pop // ignored "-Wconversion"