blob: cf1c3c10b705468de48b4df49be552db902f7c8a [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
ramindanic67d22c2023-11-28 14:58:47 -080018#include <chrono>
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080019#pragma clang diagnostic push
20#pragma clang diagnostic ignored "-Wconversion"
21
Dan Stoza9e56aa02015-11-02 13:00:03 -080022// #define LOG_NDEBUG 0
23
24#undef LOG_TAG
25#define LOG_TAG "HWComposer"
Mathias Agopian2965b262012-04-08 15:13:32 -070026#define ATRACE_TAG ATRACE_TAG_GRAPHICS
27
Lloyd Pique66d68602019-02-13 14:23:31 -080028#include "HWComposer.h"
29
Marin Shalamanovf8c63722020-10-06 13:11:21 +020030#include <android-base/properties.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080031#include <compositionengine/Output.h>
32#include <compositionengine/OutputLayer.h>
33#include <compositionengine/impl/OutputLayerCompositionState.h>
Leon Scroggins III959a7ff2023-02-07 11:24:25 -050034#include <ftl/concat.h>
ramindanib90711b2023-10-02 15:13:19 -070035#include <gui/TraceUtils.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080036#include <log/log.h>
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070037#include <ui/DebugUtils.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070038#include <ui/GraphicBuffer.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080039#include <utils/Errors.h>
40#include <utils/Trace.h>
Mathias Agopiana350ff92010-08-10 17:14:02 -070041
Lloyd Pique66d68602019-02-13 14:23:31 -080042#include "../Layer.h" // needed only for debugging
Marin Shalamanovf8c63722020-10-06 13:11:21 +020043#include "../SurfaceFlingerProperties.h"
Lloyd Pique66d68602019-02-13 14:23:31 -080044#include "ComposerHal.h"
45#include "HWC2.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070046
Dominik Laskowskic1f18f62018-06-13 15:17:55 -070047#define LOG_HWC_DISPLAY_ERROR(hwcDisplayId, msg) \
48 ALOGE("%s failed for HWC display %" PRIu64 ": %s", __FUNCTION__, hwcDisplayId, msg)
49
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070050#define LOG_DISPLAY_ERROR(displayId, msg) \
Dominik Laskowski34157762018-10-31 13:07:19 -070051 ALOGE("%s failed for display %s: %s", __FUNCTION__, to_string(displayId).c_str(), msg)
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070052
Dominik Laskowski34157762018-10-31 13:07:19 -070053#define LOG_HWC_ERROR(what, error, displayId) \
54 ALOGE("%s: %s failed for display %s: %s (%d)", __FUNCTION__, what, \
55 to_string(displayId).c_str(), to_string(error).c_str(), static_cast<int32_t>(error))
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070056
57#define RETURN_IF_INVALID_DISPLAY(displayId, ...) \
58 do { \
Dominik Laskowski075d3172018-05-24 15:50:06 -070059 if (mDisplayData.count(displayId) == 0) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070060 LOG_DISPLAY_ERROR(displayId, "Invalid display"); \
61 return __VA_ARGS__; \
62 } \
63 } while (false)
64
65#define RETURN_IF_HWC_ERROR_FOR(what, error, displayId, ...) \
66 do { \
Peiyong Line9d809e2020-04-14 13:10:48 -070067 if (error != hal::Error::NONE) { \
Dominik Laskowskifc2c0322018-04-19 14:47:33 -070068 LOG_HWC_ERROR(what, error, displayId); \
69 return __VA_ARGS__; \
70 } \
71 } while (false)
72
73#define RETURN_IF_HWC_ERROR(error, displayId, ...) \
74 RETURN_IF_HWC_ERROR_FOR(__FUNCTION__, error, displayId, __VA_ARGS__)
75
Kriti Dang674b9372022-11-18 10:58:44 +010076using aidl::android::hardware::graphics::common::HdrConversionCapability;
77using aidl::android::hardware::graphics::common::HdrConversionStrategy;
Ady Abrahamde549d42022-01-26 19:19:17 -080078using aidl::android::hardware::graphics::composer3::Capability;
79using aidl::android::hardware::graphics::composer3::DisplayCapability;
ramindani355fca82023-12-18 12:07:34 -080080using aidl::android::hardware::graphics::composer3::VrrConfig;
81using namespace std::string_literals;
Peiyong Line9d809e2020-04-14 13:10:48 -070082namespace hal = android::hardware::graphics::composer::hal;
83
Marin Shalamanov6e840172020-12-14 22:13:28 +010084namespace android {
Peiyong Linbdd08cc2019-12-17 21:35:14 -080085
Lloyd Pique441d5042018-10-18 16:49:51 -070086HWComposer::~HWComposer() = default;
87
88namespace impl {
89
Marin Shalamanovf8c63722020-10-06 13:11:21 +020090HWComposer::HWComposer(std::unique_ptr<Hwc2::Composer> composer)
91 : mComposer(std::move(composer)),
Dominik Laskowski13948602021-03-08 20:48:28 -080092 mMaxVirtualDisplayDimension(static_cast<size_t>(sysprop::max_virtual_display_dimension(0))),
Marin Shalamanovf8c63722020-10-06 13:11:21 +020093 mUpdateDeviceProductInfoOnHotplugReconnect(
ramindani355fca82023-12-18 12:07:34 -080094 sysprop::update_device_product_info_on_hotplug_reconnect(false)),
95 mEnableVrrTimeout(base::GetBoolProperty("debug.sf.vrr_timeout_hint_enabled"s, false)) {}
Peiyong Linbdd08cc2019-12-17 21:35:14 -080096
97HWComposer::HWComposer(const std::string& composerServiceName)
Ady Abraham9fc28052021-10-14 17:21:38 -070098 : HWComposer(Hwc2::Composer::create(composerServiceName)) {}
Mathias Agopianbef42c52013-08-21 17:45:46 -070099
Dominik Laskowskib04f98a2018-11-07 21:07:16 -0800100HWComposer::~HWComposer() {
101 mDisplayData.clear();
102}
Dan Stoza9e56aa02015-11-02 13:00:03 -0800103
Yichi Chen3401b562022-01-17 15:42:35 +0800104void HWComposer::setCallback(HWC2::ComposerCallback& callback) {
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800105 loadCapabilities();
106 loadLayerMetadataSupport();
Sally Qibb866c12022-10-17 11:31:20 -0700107 loadOverlayProperties();
Kriti Dang674b9372022-11-18 10:58:44 +0100108 loadHdrConversionCapabilities();
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800109
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800110 if (mRegisteredCallback) {
111 ALOGW("Callback already registered. Ignored extra registration attempt.");
112 return;
113 }
114 mRegisteredCallback = true;
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700115
Yichi Chen3401b562022-01-17 15:42:35 +0800116 mComposer->registerCallback(callback);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800117}
118
Peiyong Line9d809e2020-04-14 13:10:48 -0700119bool HWComposer::getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700120 DisplayIdentificationData* outData) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700121 const auto error = static_cast<hal::Error>(
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800122 mComposer->getDisplayIdentificationData(hwcDisplayId, outPort, outData));
Peiyong Line9d809e2020-04-14 13:10:48 -0700123 if (error != hal::Error::NONE) {
124 if (error != hal::Error::UNSUPPORTED) {
Chia-I Wud0aff9d2018-06-21 13:39:09 +0800125 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, to_string(error).c_str());
126 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700127 return false;
128 }
129 return true;
130}
131
Ady Abrahamde549d42022-01-26 19:19:17 -0800132bool HWComposer::hasCapability(Capability capability) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800133 return mCapabilities.count(capability) > 0;
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700134}
135
Ady Abrahamde549d42022-01-26 19:19:17 -0800136bool HWComposer::hasDisplayCapability(HalDisplayId displayId, DisplayCapability capability) const {
Dominik Laskowski1162e472020-04-02 19:02:47 -0700137 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham27fbcc72021-09-20 14:54:57 -0700138 return mDisplayData.at(displayId).hwcDisplay->hasCapability(capability);
Peiyong Lined531a32018-10-26 18:27:56 -0700139}
140
Peiyong Line9d809e2020-04-14 13:10:48 -0700141std::optional<DisplayIdentificationInfo> HWComposer::onHotplug(hal::HWDisplayId hwcDisplayId,
142 hal::Connection connection) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100143 switch (connection) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700144 case hal::Connection::CONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100145 return onHotplugConnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700146 case hal::Connection::DISCONNECTED:
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100147 return onHotplugDisconnect(hwcDisplayId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700148 case hal::Connection::INVALID:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700149 return {};
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700150 }
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700151}
152
Marin Shalamanovf8c63722020-10-06 13:11:21 +0200153bool HWComposer::updatesDeviceProductInfoOnHotplugReconnect() const {
154 return mUpdateDeviceProductInfoOnHotplugReconnect;
155}
156
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500157std::optional<PhysicalDisplayId> HWComposer::onVsync(hal::HWDisplayId hwcDisplayId,
158 nsecs_t timestamp) {
159 const auto displayIdOpt = toPhysicalDisplayId(hwcDisplayId);
160 if (!displayIdOpt) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700161 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500162 return {};
Jesse Hall1bd20e02012-08-29 10:47:52 -0700163 }
Jesse Hall1bd20e02012-08-29 10:47:52 -0700164
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500165 RETURN_IF_INVALID_DISPLAY(*displayIdOpt, {});
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700166
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500167 auto& displayData = mDisplayData[*displayIdOpt];
Jesse Hall1bd20e02012-08-29 10:47:52 -0700168
Dan Stoza9e56aa02015-11-02 13:00:03 -0800169 {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800170 // There have been reports of HWCs that signal several vsync events
171 // with the same timestamp when turning the display off and on. This
172 // is a bug in the HWC implementation, but filter the extra events
173 // out here so they don't cause havoc downstream.
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400174 if (timestamp == displayData.lastPresentTimestamp) {
Dominik Laskowski34157762018-10-31 13:07:19 -0700175 ALOGW("Ignoring duplicate VSYNC event from HWC for display %s (t=%" PRId64 ")",
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500176 to_string(*displayIdOpt).c_str(), timestamp);
177 return {};
Dan Stoza9e56aa02015-11-02 13:00:03 -0800178 }
179
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400180 displayData.lastPresentTimestamp = timestamp;
Jesse Hall1c569c42013-04-05 13:44:52 -0700181 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800182
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500183 ATRACE_INT(ftl::Concat("HW_VSYNC_", displayIdOpt->value).c_str(),
184 displayData.vsyncTraceToggle);
Dominik Laskowski1af47932018-11-12 10:20:46 -0800185 displayData.vsyncTraceToggle = !displayData.vsyncTraceToggle;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800186
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500187 return displayIdOpt;
Jesse Hall1c569c42013-04-05 13:44:52 -0700188}
189
Dominik Laskowski13948602021-03-08 20:48:28 -0800190size_t HWComposer::getMaxVirtualDisplayCount() const {
191 return mComposer->getMaxVirtualDisplayCount();
192}
193
194size_t HWComposer::getMaxVirtualDisplayDimension() const {
195 return mMaxVirtualDisplayDimension;
196}
197
198bool HWComposer::allocateVirtualDisplay(HalVirtualDisplayId displayId, ui::Size resolution,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700199 ui::PixelFormat* format) {
Dominik Laskowski13948602021-03-08 20:48:28 -0800200 if (!resolution.isValid()) {
201 ALOGE("%s: Invalid resolution %dx%d", __func__, resolution.width, resolution.height);
202 return false;
Fabien Sanglarde29055f2017-03-08 11:36:46 -0800203 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200204
Dominik Laskowski13948602021-03-08 20:48:28 -0800205 const uint32_t width = static_cast<uint32_t>(resolution.width);
206 const uint32_t height = static_cast<uint32_t>(resolution.height);
207
208 if (mMaxVirtualDisplayDimension > 0 &&
209 (width > mMaxVirtualDisplayDimension || height > mMaxVirtualDisplayDimension)) {
210 ALOGE("%s: Resolution %ux%u exceeds maximum dimension %zu", __func__, width, height,
211 mMaxVirtualDisplayDimension);
212 return false;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200213 }
214
Dominik Laskowski13948602021-03-08 20:48:28 -0800215 hal::HWDisplayId hwcDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700216 const auto error = static_cast<hal::Error>(
Dominik Laskowski263eec42021-07-21 23:13:24 -0700217 mComposer->createVirtualDisplay(width, height, format, &hwcDisplayId));
Dominik Laskowski13948602021-03-08 20:48:28 -0800218 RETURN_IF_HWC_ERROR_FOR("createVirtualDisplay", error, displayId, false);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800219
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800220 auto display = std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities,
Peiyong Line9d809e2020-04-14 13:10:48 -0700221 hwcDisplayId, hal::DisplayType::VIRTUAL);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800222 display->setConnected(true);
Dominik Laskowski13948602021-03-08 20:48:28 -0800223 auto& displayData = mDisplayData[displayId];
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800224 displayData.hwcDisplay = std::move(display);
Dominik Laskowski13948602021-03-08 20:48:28 -0800225 return true;
Mathias Agopiane60b0682012-08-21 23:34:09 -0700226}
227
Marin Shalamanova524a092020-07-27 21:39:55 +0200228void HWComposer::allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId,
229 PhysicalDisplayId displayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100230 mPhysicalDisplayIdMap[hwcDisplayId] = displayId;
231
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700232 if (!mPrimaryHwcDisplayId) {
233 mPrimaryHwcDisplayId = hwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100234 }
235
236 auto& displayData = mDisplayData[displayId];
237 auto newDisplay =
238 std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -0700239 hal::DisplayType::PHYSICAL);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100240 newDisplay->setConnected(true);
241 displayData.hwcDisplay = std::move(newDisplay);
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100242}
243
244int32_t HWComposer::getAttribute(hal::HWDisplayId hwcDisplayId, hal::HWConfigId configId,
Marin Shalamanov045b7002021-01-07 16:56:24 +0100245 hal::Attribute attribute) const {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100246 int32_t value = 0;
247 auto error = static_cast<hal::Error>(
248 mComposer->getDisplayAttribute(hwcDisplayId, configId, attribute, &value));
249
250 RETURN_IF_HWC_ERROR_FOR("getDisplayAttribute", error, *toPhysicalDisplayId(hwcDisplayId), -1);
251 return value;
252}
253
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700254std::shared_ptr<HWC2::Layer> HWComposer::createLayer(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700255 RETURN_IF_INVALID_DISPLAY(displayId, nullptr);
256
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700257 auto expected = mDisplayData[displayId].hwcDisplay->createLayer();
258 if (!expected.has_value()) {
259 auto error = std::move(expected).error();
260 RETURN_IF_HWC_ERROR(error, displayId, nullptr);
261 }
262 return std::move(expected).value();
Steven Thomas94e35b92017-07-26 18:48:28 -0700263}
264
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200265bool HWComposer::isConnected(PhysicalDisplayId displayId) const {
Dominik Laskowskif2ddca62022-08-17 12:08:07 -0700266 return mDisplayData.count(displayId) && mDisplayData.at(displayId).hwcDisplay->isConnected();
Mathias Agopian9c6e2972011-09-20 17:21:56 -0700267}
268
ramindani263a3f12023-07-18 20:44:49 -0700269std::vector<HWComposer::HWCDisplayMode> HWComposer::getModes(PhysicalDisplayId displayId,
270 int32_t maxFrameIntervalNs) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700271 RETURN_IF_INVALID_DISPLAY(displayId, {});
272
Marin Shalamanov045b7002021-01-07 16:56:24 +0100273 const auto hwcDisplayId = mDisplayData.at(displayId).hwcDisplay->getId();
ramindani0cd1d8d2023-06-13 13:43:23 -0700274
ramindani19919ff2023-12-07 11:27:06 -0800275 if (mComposer->isVrrSupported()) {
ramindani263a3f12023-07-18 20:44:49 -0700276 return getModesFromDisplayConfigurations(hwcDisplayId, maxFrameIntervalNs);
ramindani0cd1d8d2023-06-13 13:43:23 -0700277 }
278
279 return getModesFromLegacyDisplayConfigs(hwcDisplayId);
280}
281
282std::vector<HWComposer::HWCDisplayMode> HWComposer::getModesFromDisplayConfigurations(
ramindani263a3f12023-07-18 20:44:49 -0700283 uint64_t hwcDisplayId, int32_t maxFrameIntervalNs) const {
ramindani0cd1d8d2023-06-13 13:43:23 -0700284 std::vector<hal::DisplayConfiguration> configs;
ramindani263a3f12023-07-18 20:44:49 -0700285 auto error = static_cast<hal::Error>(
286 mComposer->getDisplayConfigurations(hwcDisplayId, maxFrameIntervalNs, &configs));
ramindani0cd1d8d2023-06-13 13:43:23 -0700287 RETURN_IF_HWC_ERROR_FOR("getDisplayConfigurations", error, *toPhysicalDisplayId(hwcDisplayId),
288 {});
289
290 std::vector<HWCDisplayMode> modes;
291 modes.reserve(configs.size());
292 for (auto config : configs) {
ramindania04b8a52023-08-07 18:49:47 -0700293 auto hwcMode = HWCDisplayMode{.hwcId = static_cast<hal::HWConfigId>(config.configId),
294 .width = config.width,
295 .height = config.height,
296 .vsyncPeriod = config.vsyncPeriod,
297 .configGroup = config.configGroup,
298 .vrrConfig = config.vrrConfig};
ramindani0cd1d8d2023-06-13 13:43:23 -0700299
300 if (config.dpi) {
301 hwcMode.dpiX = config.dpi->x;
302 hwcMode.dpiY = config.dpi->y;
303 }
304
ramindani355fca82023-12-18 12:07:34 -0800305 if (!mEnableVrrTimeout) {
306 hwcMode.vrrConfig->notifyExpectedPresentConfig = {};
307 }
308
ramindani0cd1d8d2023-06-13 13:43:23 -0700309 modes.push_back(hwcMode);
310 }
311
312 return modes;
313}
314
315std::vector<HWComposer::HWCDisplayMode> HWComposer::getModesFromLegacyDisplayConfigs(
316 uint64_t hwcDisplayId) const {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100317 std::vector<hal::HWConfigId> configIds;
318 auto error = static_cast<hal::Error>(mComposer->getDisplayConfigs(hwcDisplayId, &configIds));
319 RETURN_IF_HWC_ERROR_FOR("getDisplayConfigs", error, *toPhysicalDisplayId(hwcDisplayId), {});
320
321 std::vector<HWCDisplayMode> modes;
322 modes.reserve(configIds.size());
323 for (auto configId : configIds) {
ramindani0cd1d8d2023-06-13 13:43:23 -0700324 auto hwcMode = HWCDisplayMode{
Marin Shalamanov045b7002021-01-07 16:56:24 +0100325 .hwcId = configId,
326 .width = getAttribute(hwcDisplayId, configId, hal::Attribute::WIDTH),
327 .height = getAttribute(hwcDisplayId, configId, hal::Attribute::HEIGHT),
328 .vsyncPeriod = getAttribute(hwcDisplayId, configId, hal::Attribute::VSYNC_PERIOD),
Marin Shalamanov045b7002021-01-07 16:56:24 +0100329 .configGroup = getAttribute(hwcDisplayId, configId, hal::Attribute::CONFIG_GROUP),
ramindani0cd1d8d2023-06-13 13:43:23 -0700330 };
Marin Shalamanov045b7002021-01-07 16:56:24 +0100331
ramindani0cd1d8d2023-06-13 13:43:23 -0700332 const int32_t dpiX = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_X);
333 const int32_t dpiY = getAttribute(hwcDisplayId, configId, hal::Attribute::DPI_Y);
334 if (dpiX != -1) {
335 hwcMode.dpiX = static_cast<float>(dpiX) / 1000.f;
336 }
337 if (dpiY != -1) {
338 hwcMode.dpiY = static_cast<float>(dpiY) / 1000.f;
339 }
340
341 modes.push_back(hwcMode);
342 }
Marin Shalamanov045b7002021-01-07 16:56:24 +0100343 return modes;
Mathias Agopianda27af92012-09-13 18:17:13 -0700344}
345
Marin Shalamanov045b7002021-01-07 16:56:24 +0100346std::optional<hal::HWConfigId> HWComposer::getActiveMode(PhysicalDisplayId displayId) const {
347 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100348 const auto hwcId = *fromPhysicalDisplayId(displayId);
Dominik Laskowskie2c5b0a2022-08-10 14:53:53 -0700349
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100350 hal::HWConfigId configId;
Dominik Laskowskie2c5b0a2022-08-10 14:53:53 -0700351 const auto error = static_cast<hal::Error>(mComposer->getActiveConfig(hwcId, &configId));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100352
Dominik Laskowskie2c5b0a2022-08-10 14:53:53 -0700353 RETURN_IF_HWC_ERROR_FOR("getActiveConfig", error, displayId, std::nullopt);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100354 return configId;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700355}
356
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800357// Composer 2.4
358
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100359ui::DisplayConnectionType HWComposer::getDisplayConnectionType(PhysicalDisplayId displayId) const {
360 RETURN_IF_INVALID_DISPLAY(displayId, ui::DisplayConnectionType::Internal);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800361 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
362
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100363 ui::DisplayConnectionType type;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800364 const auto error = hwcDisplay->getConnectionType(&type);
365
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700366 const auto FALLBACK_TYPE = hwcDisplay->getId() == mPrimaryHwcDisplayId
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100367 ? ui::DisplayConnectionType::Internal
368 : ui::DisplayConnectionType::External;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800369
370 RETURN_IF_HWC_ERROR(error, displayId, FALLBACK_TYPE);
371 return type;
372}
373
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200374bool HWComposer::isVsyncPeriodSwitchSupported(PhysicalDisplayId displayId) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800375 RETURN_IF_INVALID_DISPLAY(displayId, false);
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800376 return mDisplayData.at(displayId).hwcDisplay->isVsyncPeriodSwitchSupported();
377}
378
Marin Shalamanov045b7002021-01-07 16:56:24 +0100379status_t HWComposer::getDisplayVsyncPeriod(PhysicalDisplayId displayId,
380 nsecs_t* outVsyncPeriod) const {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800381 RETURN_IF_INVALID_DISPLAY(displayId, 0);
382
Marin Shalamanov045b7002021-01-07 16:56:24 +0100383 if (!isVsyncPeriodSwitchSupported(displayId)) {
384 return INVALID_OPERATION;
Dominik Laskowskif3749f82018-06-13 15:49:25 -0700385 }
Marin Shalamanov045b7002021-01-07 16:56:24 +0100386 const auto hwcId = *fromPhysicalDisplayId(displayId);
387 Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0;
388 auto error =
389 static_cast<hal::Error>(mComposer->getDisplayVsyncPeriod(hwcId, &vsyncPeriodNanos));
390 RETURN_IF_HWC_ERROR(error, displayId, 0);
391 *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos);
392 return NO_ERROR;
Lloyd Pique3c085a02018-05-09 19:38:32 -0700393}
394
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200395std::vector<ui::ColorMode> HWComposer::getColorModes(PhysicalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700396 RETURN_IF_INVALID_DISPLAY(displayId, {});
397
Peiyong Linfd997e02018-03-28 15:29:00 -0700398 std::vector<ui::ColorMode> modes;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700399 auto error = mDisplayData.at(displayId).hwcDisplay->getColorModes(&modes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700400 RETURN_IF_HWC_ERROR(error, displayId, {});
Courtney Goeltzenleuchterfad9d8c2016-06-23 11:49:50 -0600401 return modes;
402}
403
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200404status_t HWComposer::setActiveColorMode(PhysicalDisplayId displayId, ui::ColorMode mode,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700405 ui::RenderIntent renderIntent) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700406 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Michael Wright28f24d02016-07-12 13:30:53 -0700407
408 auto& displayData = mDisplayData[displayId];
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700409 auto error = displayData.hwcDisplay->setColorMode(mode, renderIntent);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700410 RETURN_IF_HWC_ERROR_FOR(("setColorMode(" + decodeColorMode(mode) + ", " +
411 decodeRenderIntent(renderIntent) + ")")
412 .c_str(),
413 error, displayId, UNKNOWN_ERROR);
Michael Wright28f24d02016-07-12 13:30:53 -0700414
415 return NO_ERROR;
416}
417
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200418void HWComposer::setVsyncEnabled(PhysicalDisplayId displayId, hal::Vsync enabled) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700419 RETURN_IF_INVALID_DISPLAY(displayId);
420 auto& displayData = mDisplayData[displayId];
421
Dan Stoza9e56aa02015-11-02 13:00:03 -0800422 // NOTE: we use our own internal lock here because we have to call
423 // into the HWC with the lock held, and we want to make sure
424 // that even if HWC blocks (which it shouldn't), it won't
425 // affect other threads.
Dominik Laskowski1af47932018-11-12 10:20:46 -0800426 std::lock_guard lock(displayData.vsyncEnabledLock);
427 if (enabled == displayData.vsyncEnabled) {
428 return;
Colin Cross10fbdb62012-07-12 17:56:34 -0700429 }
Dominik Laskowski1af47932018-11-12 10:20:46 -0800430
431 ATRACE_CALL();
432 auto error = displayData.hwcDisplay->setVsyncEnabled(enabled);
433 RETURN_IF_HWC_ERROR(error, displayId);
434
435 displayData.vsyncEnabled = enabled;
436
Leon Scroggins III959a7ff2023-02-07 11:24:25 -0500437 ATRACE_INT(ftl::Concat("HW_VSYNC_ON_", displayId.value).c_str(),
438 enabled == hal::Vsync::ENABLE ? 1 : 0);
Colin Cross10fbdb62012-07-12 17:56:34 -0700439}
440
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200441status_t HWComposer::setClientTarget(HalDisplayId displayId, uint32_t slot,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700442 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
Alec Mourif97df4d2023-09-06 02:10:05 +0000443 ui::Dataspace dataspace, float hdrSdrRatio) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700444 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Jesse Hall851cfe82013-03-20 13:44:00 -0700445
Dominik Laskowski34157762018-10-31 13:07:19 -0700446 ALOGV("%s for display %s", __FUNCTION__, to_string(displayId).c_str());
Dan Stoza9e56aa02015-11-02 13:00:03 -0800447 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Alec Mourif97df4d2023-09-06 02:10:05 +0000448 auto error = hwcDisplay->setClientTarget(slot, target, acquireFence, dataspace, hdrSdrRatio);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700449 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Jesse Hall851cfe82013-03-20 13:44:00 -0700450 return NO_ERROR;
451}
452
Lloyd Pique66d68602019-02-13 14:23:31 -0800453status_t HWComposer::getDeviceCompositionChanges(
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200454 HalDisplayId displayId, bool frameUsesClientComposition,
Ady Abrahamf1db8032023-03-24 17:52:34 -0700455 std::optional<std::chrono::steady_clock::time_point> earliestPresentTime,
ramindani4aac32c2023-10-30 14:13:30 -0700456 nsecs_t expectedPresentTime, Fps frameInterval,
Lloyd Pique66d68602019-02-13 14:23:31 -0800457 std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800458 ATRACE_CALL();
459
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700460 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800461
462 auto& displayData = mDisplayData[displayId];
463 auto& hwcDisplay = displayData.hwcDisplay;
464 if (!hwcDisplay->isConnected()) {
465 return NO_ERROR;
466 }
467
468 uint32_t numTypes = 0;
469 uint32_t numRequests = 0;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700470
Peiyong Line9d809e2020-04-14 13:10:48 -0700471 hal::Error error = hal::Error::NONE;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700472
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700473 // First try to skip validate altogether. We can do that when
474 // 1. The previous frame has not been presented yet or already passed the
475 // earliest time to present. Otherwise, we may present a frame too early.
476 // 2. There is no client composition. Otherwise, we first need to render the
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700477 // client target buffer.
Ady Abraham43065bd2021-12-10 17:22:15 -0800478 const bool canSkipValidate = [&] {
479 // We must call validate if we have client composition
480 if (frameUsesClientComposition) {
481 return false;
482 }
483
484 // If composer supports getting the expected present time, we can skip
485 // as composer will make sure to prevent early presentation
Ady Abrahamf1db8032023-03-24 17:52:34 -0700486 if (!earliestPresentTime) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800487 return true;
488 }
489
490 // composer doesn't support getting the expected present time. We can only
491 // skip validate if we know that we are not going to present early.
Ady Abrahamf1db8032023-03-24 17:52:34 -0700492 return std::chrono::steady_clock::now() >= *earliestPresentTime;
Ady Abraham43065bd2021-12-10 17:22:15 -0800493 }();
494
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700495 displayData.validateWasSkipped = false;
ramindani0491e642023-11-16 17:42:14 -0800496 ATRACE_FORMAT("NextFrameInterval %d_Hz", frameInterval.getIntValue());
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700497 if (canSkipValidate) {
Leon Scroggins IIIabc2c452023-11-08 17:04:51 -0500498 sp<Fence> outPresentFence = Fence::NO_FENCE;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700499 uint32_t state = UINT32_MAX;
ramindani4aac32c2023-10-30 14:13:30 -0700500 error = hwcDisplay->presentOrValidate(expectedPresentTime, frameInterval.getPeriodNsecs(),
501 &numTypes, &numRequests, &outPresentFence, &state);
Peiyong Line9d809e2020-04-14 13:10:48 -0700502 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700503 RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700504 }
505 if (state == 1) { //Present Succeeded.
Steven Thomas94e35b92017-07-26 18:48:28 -0700506 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700507 error = hwcDisplay->getReleaseFences(&releaseFences);
508 displayData.releaseFences = std::move(releaseFences);
509 displayData.lastPresentFence = outPresentFence;
510 displayData.validateWasSkipped = true;
511 displayData.presentError = error;
512 return NO_ERROR;
513 }
514 // Present failed but Validate ran.
515 } else {
ramindani09acbb82023-11-03 09:02:38 -0700516 error = hwcDisplay->validate(expectedPresentTime, frameInterval.getPeriodNsecs(), &numTypes,
517 &numRequests);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700518 }
519 ALOGV("SkipValidate failed, Falling back to SLOW validate/present");
Peiyong Line9d809e2020-04-14 13:10:48 -0700520 if (!hasChangesError(error)) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700521 RETURN_IF_HWC_ERROR_FOR("validate", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800522 }
523
Lloyd Pique66d68602019-02-13 14:23:31 -0800524 android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800525 changedTypes.reserve(numTypes);
526 error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700527 RETURN_IF_HWC_ERROR_FOR("getChangedCompositionTypes", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800528
Peiyong Line9d809e2020-04-14 13:10:48 -0700529 auto displayRequests = static_cast<hal::DisplayRequest>(0);
Lloyd Pique66d68602019-02-13 14:23:31 -0800530 android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800531 layerRequests.reserve(numRequests);
Lloyd Pique66d68602019-02-13 14:23:31 -0800532 error = hwcDisplay->getRequests(&displayRequests, &layerRequests);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700533 RETURN_IF_HWC_ERROR_FOR("getRequests", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800534
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700535 DeviceRequestedChanges::ClientTargetProperty clientTargetProperty;
Alec Mouri85065692022-03-18 00:58:26 +0000536 error = hwcDisplay->getClientTargetProperty(&clientTargetProperty);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800537
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700538 outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes), std::move(displayRequests),
539 std::move(layerRequests),
Alec Mouri85065692022-03-18 00:58:26 +0000540 std::move(clientTargetProperty)});
Dan Stoza9e56aa02015-11-02 13:00:03 -0800541 error = hwcDisplay->acceptChanges();
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700542 RETURN_IF_HWC_ERROR_FOR("acceptChanges", error, displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800543
544 return NO_ERROR;
545}
546
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200547sp<Fence> HWComposer::getPresentFence(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700548 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700549 return mDisplayData.at(displayId).lastPresentFence;
Jesse Hall851cfe82013-03-20 13:44:00 -0700550}
551
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400552nsecs_t HWComposer::getPresentTimestamp(PhysicalDisplayId displayId) const {
553 RETURN_IF_INVALID_DISPLAY(displayId, 0);
554 return mDisplayData.at(displayId).lastPresentTimestamp;
555}
556
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200557sp<Fence> HWComposer::getLayerReleaseFence(HalDisplayId displayId, HWC2::Layer* layer) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700558 RETURN_IF_INVALID_DISPLAY(displayId, Fence::NO_FENCE);
Tim Murray2d3f8b82019-12-04 16:24:17 -0800559 const auto& displayFences = mDisplayData.at(displayId).releaseFences;
560 auto fence = displayFences.find(layer);
561 if (fence == displayFences.end()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800562 ALOGV("getLayerReleaseFence: Release fence not found");
563 return Fence::NO_FENCE;
Riley Andrews03414a12014-07-01 14:22:59 -0700564 }
Tim Murray2d3f8b82019-12-04 16:24:17 -0800565 return fence->second;
Riley Andrews03414a12014-07-01 14:22:59 -0700566}
567
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700568status_t HWComposer::presentAndGetReleaseFences(
Ady Abrahamf1db8032023-03-24 17:52:34 -0700569 HalDisplayId displayId,
570 std::optional<std::chrono::steady_clock::time_point> earliestPresentTime) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800571 ATRACE_CALL();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700572
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700573 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Pablo Ceballosd814cf22015-09-11 14:37:39 -0700574
Dan Stoza9e56aa02015-11-02 13:00:03 -0800575 auto& displayData = mDisplayData[displayId];
576 auto& hwcDisplay = displayData.hwcDisplay;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700577
578 if (displayData.validateWasSkipped) {
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700579 // explicitly flush all pending commands
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -0400580 auto error = static_cast<hal::Error>(mComposer->executeCommands(hwcDisplay->getId()));
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800581 RETURN_IF_HWC_ERROR_FOR("executeCommands", error, displayId, UNKNOWN_ERROR);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700582 RETURN_IF_HWC_ERROR_FOR("present", displayData.presentError, displayId, UNKNOWN_ERROR);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700583 return NO_ERROR;
584 }
585
Ady Abrahamf1db8032023-03-24 17:52:34 -0700586 if (earliestPresentTime) {
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700587 ATRACE_NAME("wait for earliest present time");
Ady Abrahamf1db8032023-03-24 17:52:34 -0700588 std::this_thread::sleep_until(*earliestPresentTime);
Ady Abrahamb42cdc12021-05-11 14:31:26 -0700589 }
590
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800591 auto error = hwcDisplay->present(&displayData.lastPresentFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700592 RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700593
Steven Thomas94e35b92017-07-26 18:48:28 -0700594 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800595 error = hwcDisplay->getReleaseFences(&releaseFences);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700596 RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800597
598 displayData.releaseFences = std::move(releaseFences);
599
600 return NO_ERROR;
Mathias Agopiana350ff92010-08-10 17:14:02 -0700601}
602
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200603status_t HWComposer::setPowerMode(PhysicalDisplayId displayId, hal::PowerMode mode) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700604 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
605
Peiyong Line9d809e2020-04-14 13:10:48 -0700606 if (mode == hal::PowerMode::OFF) {
607 setVsyncEnabled(displayId, hal::Vsync::DISABLE);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800608 }
609
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700610 const auto& displayData = mDisplayData[displayId];
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700611 auto& hwcDisplay = displayData.hwcDisplay;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800612 switch (mode) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700613 case hal::PowerMode::OFF:
614 case hal::PowerMode::ON:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800615 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
616 {
617 auto error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700618 if (error != hal::Error::NONE) {
619 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
620 displayId);
Peiyong Lin306e4992018-05-07 16:18:22 -0700621 }
Mathias Agopianda27af92012-09-13 18:17:13 -0700622 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800623 break;
Peiyong Line9d809e2020-04-14 13:10:48 -0700624 case hal::PowerMode::DOZE:
625 case hal::PowerMode::DOZE_SUSPEND:
Dan Stoza9e56aa02015-11-02 13:00:03 -0800626 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str());
627 {
628 bool supportsDoze = false;
Leon Scroggins III689c80f2023-06-05 17:49:32 -0400629 const auto queryDozeError = hwcDisplay->supportsDoze(&supportsDoze);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700630
Leon Scroggins III689c80f2023-06-05 17:49:32 -0400631 // queryDozeError might be NO_RESOURCES, in the case of a display that has never
632 // been turned on. In that case, attempt to set to DOZE anyway.
633 if (!supportsDoze && queryDozeError == hal::Error::NONE) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700634 mode = hal::PowerMode::ON;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800635 }
636
Leon Scroggins III689c80f2023-06-05 17:49:32 -0400637 auto error = hwcDisplay->setPowerMode(mode);
Peiyong Line9d809e2020-04-14 13:10:48 -0700638 if (error != hal::Error::NONE) {
639 LOG_HWC_ERROR(("setPowerMode(" + to_string(mode) + ")").c_str(), error,
640 displayId);
Leon Scroggins III689c80f2023-06-05 17:49:32 -0400641 // If the display had never been turned on, so its doze
642 // support was unknown, it may truly not support doze. Try
643 // switching it to ON instead.
644 if (queryDozeError == hal::Error::NO_RESOURCES) {
645 ALOGD("%s: failed to set %s to %s. Trying again with ON", __func__,
646 to_string(displayId).c_str(), to_string(mode).c_str());
647 error = hwcDisplay->setPowerMode(hal::PowerMode::ON);
648 if (error != hal::Error::NONE) {
649 LOG_HWC_ERROR("setPowerMode(ON)", error, displayId);
650 }
651 }
Peiyong Lin306e4992018-05-07 16:18:22 -0700652 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800653 }
654 break;
655 default:
656 ALOGV("setPowerMode: Not calling HWC");
657 break;
Mathias Agopianda27af92012-09-13 18:17:13 -0700658 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800659
660 return NO_ERROR;
661}
662
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100663status_t HWComposer::setActiveModeWithConstraints(
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100664 PhysicalDisplayId displayId, hal::HWConfigId hwcModeId,
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200665 const hal::VsyncPeriodChangeConstraints& constraints,
Peiyong Line9d809e2020-04-14 13:10:48 -0700666 hal::VsyncPeriodChangeTimeline* outTimeline) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700667 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800668
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100669 auto error = mDisplayData[displayId].hwcDisplay->setActiveConfigWithConstraints(hwcModeId,
670 constraints,
671 outTimeline);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700672 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800673 return NO_ERROR;
674}
675
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200676status_t HWComposer::setColorTransform(HalDisplayId displayId, const mat4& transform) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700677 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700678
679 auto& displayData = mDisplayData[displayId];
Ady Abrahamdc011a92021-12-21 14:06:44 -0800680 auto error = displayData.hwcDisplay->setColorTransform(transform);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700681 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9f26a9c2016-06-22 14:51:09 -0700682 return NO_ERROR;
683}
684
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200685void HWComposer::disconnectDisplay(HalDisplayId displayId) {
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700686 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800687 auto& displayData = mDisplayData[displayId];
Dominik Laskowski7e045462018-05-30 13:02:02 -0700688 const auto hwcDisplayId = displayData.hwcDisplay->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700689
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800690 mPhysicalDisplayIdMap.erase(hwcDisplayId);
691 mDisplayData.erase(displayId);
Marin Shalamanov8b196592021-08-09 16:24:42 +0200692
693 // Reset the primary display ID if we're disconnecting it.
694 // This way isHeadless() will return false, which is necessary
695 // because getPrimaryDisplayId() will crash.
696 if (mPrimaryHwcDisplayId == hwcDisplayId) {
697 mPrimaryHwcDisplayId.reset();
698 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800699}
700
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200701status_t HWComposer::setOutputBuffer(HalVirtualDisplayId displayId, const sp<Fence>& acquireFence,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700702 const sp<GraphicBuffer>& buffer) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700703 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700704 const auto& displayData = mDisplayData[displayId];
Dan Stoza9e56aa02015-11-02 13:00:03 -0800705
Dominik Laskowskic1f18f62018-06-13 15:17:55 -0700706 auto error = displayData.hwcDisplay->setOutputBuffer(buffer, acquireFence);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700707 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800708 return NO_ERROR;
709}
710
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200711void HWComposer::clearReleaseFences(HalDisplayId displayId) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700712 RETURN_IF_INVALID_DISPLAY(displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800713 mDisplayData[displayId].releaseFences.clear();
Mathias Agopian3e8b8532012-05-13 20:42:01 -0700714}
715
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200716status_t HWComposer::getHdrCapabilities(HalDisplayId displayId, HdrCapabilities* outCapabilities) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700717 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dan Stozac4f471e2016-03-24 09:31:08 -0700718
719 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
Peiyong Lin62665892018-04-16 11:07:44 -0700720 auto error = hwcDisplay->getHdrCapabilities(outCapabilities);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700721 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
Peiyong Lin62665892018-04-16 11:07:44 -0700722 return NO_ERROR;
Dan Stozac4f471e2016-03-24 09:31:08 -0700723}
724
Sally Qibb866c12022-10-17 11:31:20 -0700725const aidl::android::hardware::graphics::composer3::OverlayProperties&
726HWComposer::getOverlaySupport() const {
727 return mOverlayProperties;
Sally Qi0cbd08b2022-08-17 12:12:28 -0700728}
729
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200730int32_t HWComposer::getSupportedPerFrameMetadata(HalDisplayId displayId) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700731 RETURN_IF_INVALID_DISPLAY(displayId, 0);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700732 return mDisplayData.at(displayId).hwcDisplay->getSupportedPerFrameMetadata();
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700733}
734
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200735std::vector<ui::RenderIntent> HWComposer::getRenderIntents(HalDisplayId displayId,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700736 ui::ColorMode colorMode) const {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700737 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700738
739 std::vector<ui::RenderIntent> renderIntents;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700740 auto error = mDisplayData.at(displayId).hwcDisplay->getRenderIntents(colorMode, &renderIntents);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700741 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700742 return renderIntents;
743}
744
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200745mat4 HWComposer::getDataspaceSaturationMatrix(HalDisplayId displayId, ui::Dataspace dataspace) {
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700746 RETURN_IF_INVALID_DISPLAY(displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700747
748 mat4 matrix;
749 auto error = mDisplayData[displayId].hwcDisplay->getDataspaceSaturationMatrix(dataspace,
750 &matrix);
Dominik Laskowskifc2c0322018-04-19 14:47:33 -0700751 RETURN_IF_HWC_ERROR(error, displayId, {});
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700752 return matrix;
753}
754
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200755status_t HWComposer::getDisplayedContentSamplingAttributes(HalDisplayId displayId,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700756 ui::PixelFormat* outFormat,
757 ui::Dataspace* outDataspace,
758 uint8_t* outComponentMask) {
759 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
760 const auto error =
761 mDisplayData[displayId]
762 .hwcDisplay->getDisplayedContentSamplingAttributes(outFormat, outDataspace,
763 outComponentMask);
Peiyong Line9d809e2020-04-14 13:10:48 -0700764 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700765 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
766 return NO_ERROR;
767}
768
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200769status_t HWComposer::setDisplayContentSamplingEnabled(HalDisplayId displayId, bool enabled,
Kevin DuBois74e53772018-11-19 10:52:38 -0800770 uint8_t componentMask, uint64_t maxFrames) {
771 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
772 const auto error =
773 mDisplayData[displayId].hwcDisplay->setDisplayContentSamplingEnabled(enabled,
774 componentMask,
775 maxFrames);
776
Peiyong Line9d809e2020-04-14 13:10:48 -0700777 if (error == hal::Error::UNSUPPORTED) RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
778 if (error == hal::Error::BAD_PARAMETER) RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
Kevin DuBois74e53772018-11-19 10:52:38 -0800779 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
780 return NO_ERROR;
781}
782
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200783status_t HWComposer::getDisplayedContentSample(HalDisplayId displayId, uint64_t maxFrames,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700784 uint64_t timestamp, DisplayedFrameStats* outStats) {
785 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
786 const auto error =
787 mDisplayData[displayId].hwcDisplay->getDisplayedContentSample(maxFrames, timestamp,
788 outStats);
789 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
790 return NO_ERROR;
791}
792
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700793ftl::Future<status_t> HWComposer::setDisplayBrightness(
Alec Mouri4d8a05d2022-03-23 18:14:26 +0000794 PhysicalDisplayId displayId, float brightness, float brightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -0800795 const Hwc2::Composer::DisplayBrightnessOptions& options) {
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800796 RETURN_IF_INVALID_DISPLAY(displayId, ftl::yield<status_t>(BAD_INDEX));
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700797 auto& display = mDisplayData[displayId].hwcDisplay;
798
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700799 return display->setDisplayBrightness(brightness, brightnessNits, options)
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700800 .then([displayId](hal::Error error) -> status_t {
801 if (error == hal::Error::UNSUPPORTED) {
802 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
803 }
804 if (error == hal::Error::BAD_PARAMETER) {
805 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
806 }
807 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
808 return NO_ERROR;
809 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000810}
811
Matt Buckley50c44062022-01-17 20:48:10 +0000812bool HWComposer::getValidateSkipped(HalDisplayId displayId) const {
813 if (mDisplayData.count(displayId) == 0) {
814 return false;
815 }
816 return mDisplayData.at(displayId).validateWasSkipped;
817}
818
Kriti Dang7defaf32021-11-15 11:55:43 +0100819status_t HWComposer::setBootDisplayMode(PhysicalDisplayId displayId,
820 hal::HWConfigId displayModeId) {
821 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
822 const auto error = mDisplayData[displayId].hwcDisplay->setBootDisplayConfig(displayModeId);
823 if (error == hal::Error::UNSUPPORTED) {
824 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
825 }
826 if (error == hal::Error::BAD_PARAMETER) {
827 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
828 }
829 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
830 return NO_ERROR;
831}
832
833status_t HWComposer::clearBootDisplayMode(PhysicalDisplayId displayId) {
834 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
835 const auto error = mDisplayData[displayId].hwcDisplay->clearBootDisplayConfig();
836 if (error == hal::Error::UNSUPPORTED) {
837 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
838 }
839 if (error == hal::Error::BAD_PARAMETER) {
840 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
841 }
842 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
843 return NO_ERROR;
844}
845
Kriti Dang16ca2972022-02-01 20:07:03 +0100846std::optional<hal::HWConfigId> HWComposer::getPreferredBootDisplayMode(
847 PhysicalDisplayId displayId) {
848 RETURN_IF_INVALID_DISPLAY(displayId, std::nullopt);
849 hal::HWConfigId displayModeId;
Kriti Dang7defaf32021-11-15 11:55:43 +0100850 const auto error =
851 mDisplayData[displayId].hwcDisplay->getPreferredBootDisplayConfig(&displayModeId);
Kriti Dang16ca2972022-02-01 20:07:03 +0100852 if (error != hal::Error::NONE) {
853 LOG_DISPLAY_ERROR(displayId, to_string(error).c_str());
854 return std::nullopt;
Kriti Dang7defaf32021-11-15 11:55:43 +0100855 }
Kriti Dang7defaf32021-11-15 11:55:43 +0100856 return displayModeId;
857}
858
Kriti Dang674b9372022-11-18 10:58:44 +0100859std::vector<HdrConversionCapability> HWComposer::getHdrConversionCapabilities() const {
860 return mHdrConversionCapabilities;
861}
862
Kriti Dangd432bb52023-02-09 18:21:04 +0100863status_t HWComposer::setHdrConversionStrategy(
864 HdrConversionStrategy hdrConversionStrategy,
865 aidl::android::hardware::graphics::common::Hdr* outPreferredHdrOutputType) {
866 const auto error =
867 mComposer->setHdrConversionStrategy(hdrConversionStrategy, outPreferredHdrOutputType);
Kriti Dang674b9372022-11-18 10:58:44 +0100868 if (error != hal::Error::NONE) {
869 ALOGE("Error in setting HDR conversion strategy %s", to_string(error).c_str());
Kriti Dangd432bb52023-02-09 18:21:04 +0100870 return INVALID_OPERATION;
Kriti Dang674b9372022-11-18 10:58:44 +0100871 }
872 return NO_ERROR;
873}
874
ramindanib2158ee2023-02-13 20:29:59 -0800875status_t HWComposer::setRefreshRateChangedCallbackDebugEnabled(PhysicalDisplayId displayId,
876 bool enabled) {
877 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
878 const auto error =
879 mComposer->setRefreshRateChangedCallbackDebugEnabled(mDisplayData[displayId]
880 .hwcDisplay->getId(),
881 enabled);
882 if (error != hal::Error::NONE) {
883 ALOGE("Error in setting refresh refresh rate change callback debug enabled %s",
884 to_string(error).c_str());
885 return INVALID_OPERATION;
886 }
887 return NO_ERROR;
888}
889
ramindanic67d22c2023-11-28 14:58:47 -0800890status_t HWComposer::notifyExpectedPresent(PhysicalDisplayId displayId,
891 TimePoint expectedPresentTime, Fps frameInterval) {
ramindani3acaaf52023-09-25 10:31:27 -0700892 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
ramindanic67d22c2023-11-28 14:58:47 -0800893 ATRACE_FORMAT("%s ExpectedPresentTime in %.2fms frameInterval %.2fms", __func__,
894 ticks<std::milli, float>(expectedPresentTime - TimePoint::now()),
895 ticks<std::milli, float>(Duration::fromNs(frameInterval.getPeriodNsecs())));
896 const auto error = mComposer->notifyExpectedPresent(mDisplayData[displayId].hwcDisplay->getId(),
ramindanif8c0f102023-10-09 12:42:57 -0700897 expectedPresentTime.ns(),
898 frameInterval.getPeriodNsecs());
ramindani3acaaf52023-09-25 10:31:27 -0700899 if (error != hal::Error::NONE) {
900 ALOGE("Error in notifyExpectedPresent call %s", to_string(error).c_str());
901 return INVALID_OPERATION;
902 }
903 return NO_ERROR;
904}
905
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500906status_t HWComposer::getDisplayDecorationSupport(
907 PhysicalDisplayId displayId,
908 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
909 support) {
910 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
911 const auto error = mDisplayData[displayId].hwcDisplay->getDisplayDecorationSupport(support);
912 if (error == hal::Error::UNSUPPORTED) {
913 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
914 }
915 if (error == hal::Error::BAD_PARAMETER) {
916 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
917 }
918 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
919 return NO_ERROR;
920}
921
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200922status_t HWComposer::setAutoLowLatencyMode(PhysicalDisplayId displayId, bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100923 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
924 const auto error = mDisplayData[displayId].hwcDisplay->setAutoLowLatencyMode(on);
Peiyong Line9d809e2020-04-14 13:10:48 -0700925 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100926 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
927 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700928 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100929 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
930 }
931 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
932 return NO_ERROR;
933}
934
935status_t HWComposer::getSupportedContentTypes(
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800936 PhysicalDisplayId displayId,
937 std::vector<hal::ContentType>* outSupportedContentTypes) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100938 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800939 const auto error = mDisplayData.at(displayId).hwcDisplay->getSupportedContentTypes(
940 outSupportedContentTypes);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100941
942 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
943
944 return NO_ERROR;
945}
946
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200947status_t HWComposer::setContentType(PhysicalDisplayId displayId, hal::ContentType contentType) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100948 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
949 const auto error = mDisplayData[displayId].hwcDisplay->setContentType(contentType);
Peiyong Line9d809e2020-04-14 13:10:48 -0700950 if (error == hal::Error::UNSUPPORTED) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100951 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
952 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700953 if (error == hal::Error::BAD_PARAMETER) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100954 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
955 }
956 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
957
958 return NO_ERROR;
959}
960
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800961const std::unordered_map<std::string, bool>& HWComposer::getSupportedLayerGenericMetadata() const {
962 return mSupportedLayerGenericMetadata;
963}
964
Yiwei Zhang5434a782018-12-05 18:06:32 -0800965void HWComposer::dump(std::string& result) const {
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800966 result.append(mComposer->dumpDebugInfo());
Mathias Agopian83727852010-09-23 18:13:21 -0700967}
968
Marin Shalamanova524a092020-07-27 21:39:55 +0200969std::optional<PhysicalDisplayId> HWComposer::toPhysicalDisplayId(
970 hal::HWDisplayId hwcDisplayId) const {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700971 if (const auto it = mPhysicalDisplayIdMap.find(hwcDisplayId);
972 it != mPhysicalDisplayIdMap.end()) {
973 return it->second;
974 }
975 return {};
976}
977
Marin Shalamanova524a092020-07-27 21:39:55 +0200978std::optional<hal::HWDisplayId> HWComposer::fromPhysicalDisplayId(
979 PhysicalDisplayId displayId) const {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700980 if (const auto it = mDisplayData.find(displayId); it != mDisplayData.end()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700981 return it->second.hwcDisplay->getId();
982 }
983 return {};
984}
985
Peiyong Line9d809e2020-04-14 13:10:48 -0700986bool HWComposer::shouldIgnoreHotplugConnect(hal::HWDisplayId hwcDisplayId,
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100987 bool hasDisplayIdentificationData) const {
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100988 if (mHasMultiDisplaySupport && !hasDisplayIdentificationData) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700989 ALOGE("Ignoring connection of display %" PRIu64 " without identification data",
990 hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100991 return true;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700992 }
993
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700994 // Legacy mode only supports IDs LEGACY_DISPLAY_TYPE_PRIMARY and LEGACY_DISPLAY_TYPE_EXTERNAL.
995 if (!mHasMultiDisplaySupport && mPhysicalDisplayIdMap.size() == 2) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700996 ALOGE("Ignoring connection of tertiary display %" PRIu64, hwcDisplayId);
Marin Shalamanovbdd59152020-02-14 15:30:06 +0100997 return true;
998 }
999
1000 return false;
1001}
1002
Peiyong Line9d809e2020-04-14 13:10:48 -07001003std::optional<DisplayIdentificationInfo> HWComposer::onHotplugConnect(
1004 hal::HWDisplayId hwcDisplayId) {
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001005 std::optional<DisplayIdentificationInfo> info;
1006 if (const auto displayId = toPhysicalDisplayId(hwcDisplayId)) {
1007 info = DisplayIdentificationInfo{.id = *displayId,
1008 .name = std::string(),
1009 .deviceProductInfo = std::nullopt};
Marin Shalamanovf8c63722020-10-06 13:11:21 +02001010 if (mUpdateDeviceProductInfoOnHotplugReconnect) {
1011 uint8_t port;
1012 DisplayIdentificationData data;
1013 getDisplayIdentificationData(hwcDisplayId, &port, &data);
1014 if (auto newInfo = parseDisplayIdentificationData(port, data)) {
1015 info->deviceProductInfo = std::move(newInfo->deviceProductInfo);
1016 } else {
1017 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
1018 }
1019 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001020 } else {
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001021 uint8_t port;
1022 DisplayIdentificationData data;
1023 const bool hasDisplayIdentificationData =
1024 getDisplayIdentificationData(hwcDisplayId, &port, &data);
1025 if (mPhysicalDisplayIdMap.empty()) {
1026 mHasMultiDisplaySupport = hasDisplayIdentificationData;
1027 ALOGI("Switching to %s multi-display mode",
1028 mHasMultiDisplaySupport ? "generalized" : "legacy");
1029 }
1030
1031 if (shouldIgnoreHotplugConnect(hwcDisplayId, hasDisplayIdentificationData)) {
1032 return {};
1033 }
1034
1035 info = [this, hwcDisplayId, &port, &data, hasDisplayIdentificationData] {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001036 const bool isPrimary = !mPrimaryHwcDisplayId;
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001037 if (mHasMultiDisplaySupport) {
1038 if (const auto info = parseDisplayIdentificationData(port, data)) {
1039 return *info;
1040 }
1041 ALOGE("Failed to parse identification data for display %" PRIu64, hwcDisplayId);
1042 } else {
1043 ALOGW_IF(hasDisplayIdentificationData,
1044 "Ignoring identification data for display %" PRIu64, hwcDisplayId);
Peiyong Lin65248e02020-04-18 21:15:07 -07001045 port = isPrimary ? LEGACY_DISPLAY_TYPE_PRIMARY : LEGACY_DISPLAY_TYPE_EXTERNAL;
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001046 }
1047
Marin Shalamanova524a092020-07-27 21:39:55 +02001048 return DisplayIdentificationInfo{.id = PhysicalDisplayId::fromPort(port),
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001049 .name = isPrimary ? "Primary display"
1050 : "Secondary display",
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001051 .deviceProductInfo = std::nullopt};
1052 }();
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -04001053
1054 mComposer->onHotplugConnect(hwcDisplayId);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001055 }
1056
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001057 if (!isConnected(info->id)) {
1058 allocatePhysicalDisplay(hwcDisplayId, info->id);
1059 }
1060 return info;
1061}
1062
1063std::optional<DisplayIdentificationInfo> HWComposer::onHotplugDisconnect(
Peiyong Line9d809e2020-04-14 13:10:48 -07001064 hal::HWDisplayId hwcDisplayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001065 LOG_ALWAYS_FATAL_IF(hwcDisplayId == mPrimaryHwcDisplayId,
1066 "Primary display cannot be disconnected.");
1067
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001068 const auto displayId = toPhysicalDisplayId(hwcDisplayId);
1069 if (!displayId) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001070 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Invalid HWC display");
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001071 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -07001072 }
1073
Dominik Laskowskif2ddca62022-08-17 12:08:07 -07001074 if (!isConnected(*displayId)) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001075 LOG_HWC_DISPLAY_ERROR(hwcDisplayId, "Already disconnected");
Dominik Laskowskif2ddca62022-08-17 12:08:07 -07001076 return {};
Marin Shalamanovbdd59152020-02-14 15:30:06 +01001077 }
Dominik Laskowskif2ddca62022-08-17 12:08:07 -07001078
1079 // The display will later be destroyed by a call to HWComposer::disconnectDisplay. For now, mark
1080 // it as disconnected.
1081 mDisplayData.at(*displayId).hwcDisplay->setConnected(false);
Leon Scroggins IIIe24d78f2022-09-20 16:38:19 -04001082 mComposer->onHotplugDisconnect(hwcDisplayId);
Dominik Laskowskif2ddca62022-08-17 12:08:07 -07001083 return DisplayIdentificationInfo{.id = *displayId};
Steven Thomas6e8f7062017-11-22 14:15:29 -08001084}
1085
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001086void HWComposer::loadCapabilities() {
Peiyong Line9d809e2020-04-14 13:10:48 -07001087 static_assert(sizeof(hal::Capability) == sizeof(int32_t), "Capability size has changed");
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001088 auto capabilities = mComposer->getCapabilities();
1089 for (auto capability : capabilities) {
Ady Abrahamde549d42022-01-26 19:19:17 -08001090 mCapabilities.emplace(capability);
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001091 }
1092}
1093
Sally Qibb866c12022-10-17 11:31:20 -07001094void HWComposer::loadOverlayProperties() {
1095 mComposer->getOverlaySupport(&mOverlayProperties);
1096}
1097
Kriti Dang674b9372022-11-18 10:58:44 +01001098void HWComposer::loadHdrConversionCapabilities() {
1099 const auto error = mComposer->getHdrConversionCapabilities(&mHdrConversionCapabilities);
1100 if (error != hal::Error::NONE) {
1101 ALOGE("Error in fetching HDR conversion capabilities %s", to_string(error).c_str());
1102 mHdrConversionCapabilities = {};
1103 }
1104}
1105
ramindani32cf0602022-03-02 02:30:29 +00001106status_t HWComposer::setIdleTimerEnabled(PhysicalDisplayId displayId,
1107 std::chrono::milliseconds timeout) {
1108 ATRACE_CALL();
1109 RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
1110 const auto error = mDisplayData[displayId].hwcDisplay->setIdleTimerEnabled(timeout);
1111 if (error == hal::Error::UNSUPPORTED) {
1112 RETURN_IF_HWC_ERROR(error, displayId, INVALID_OPERATION);
1113 }
1114 if (error == hal::Error::BAD_PARAMETER) {
1115 RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
1116 }
1117 RETURN_IF_HWC_ERROR(error, displayId, UNKNOWN_ERROR);
1118 return NO_ERROR;
1119}
1120
ramindani06e518e2022-03-14 18:47:53 +00001121bool HWComposer::hasDisplayIdleTimerCapability(PhysicalDisplayId displayId) const {
ramindani32cf0602022-03-02 02:30:29 +00001122 RETURN_IF_INVALID_DISPLAY(displayId, false);
ramindani06e518e2022-03-14 18:47:53 +00001123 return mDisplayData.at(displayId).hwcDisplay->hasDisplayIdleTimerCapability();
1124}
1125
1126Hwc2::AidlTransform HWComposer::getPhysicalDisplayOrientation(PhysicalDisplayId displayId) const {
1127 ATRACE_CALL();
1128 RETURN_IF_INVALID_DISPLAY(displayId, Hwc2::AidlTransform::NONE);
1129 Hwc2::AidlTransform outTransform;
1130 const auto& hwcDisplay = mDisplayData.at(displayId).hwcDisplay;
1131 const auto error = hwcDisplay->getPhysicalDisplayOrientation(&outTransform);
1132 RETURN_IF_HWC_ERROR(error, displayId, Hwc2::AidlTransform::NONE);
1133 return outTransform;
ramindani32cf0602022-03-02 02:30:29 +00001134}
1135
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001136void HWComposer::loadLayerMetadataSupport() {
1137 mSupportedLayerGenericMetadata.clear();
1138
1139 std::vector<Hwc2::IComposerClient::LayerGenericMetadataKey> supportedMetadataKeyInfo;
1140 const auto error = mComposer->getLayerGenericMetadataKeys(&supportedMetadataKeyInfo);
1141 if (error != hardware::graphics::composer::V2_4::Error::NONE) {
Ady Abraham3891cbe2021-03-29 11:29:31 -07001142 if (error != hardware::graphics::composer::V2_4::Error::UNSUPPORTED) {
1143 ALOGE("%s: %s failed: %s (%d)", __FUNCTION__, "getLayerGenericMetadataKeys",
1144 toString(error).c_str(), static_cast<int32_t>(error));
1145 }
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001146 return;
1147 }
1148
1149 for (const auto& [name, mandatory] : supportedMetadataKeyInfo) {
1150 mSupportedLayerGenericMetadata.emplace(name, mandatory);
1151 }
1152}
1153
Lloyd Pique441d5042018-10-18 16:49:51 -07001154} // namespace impl
Dominik Laskowskif9750f22018-06-06 12:24:53 -07001155} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001156
1157// TODO(b/129481165): remove the #pragma below and fix conversion issues
1158#pragma clang diagnostic pop // ignored "-Wconversion"