blob: 08559bd9397de069dc85a9a347d6e878abb97a74 [file] [log] [blame]
Dan Stoza651bf312015-10-23 17:03:17 -07001/*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Dan Stoza651bf312015-10-23 17:03:17 -070021// #define LOG_NDEBUG 0
22
23#undef LOG_TAG
24#define LOG_TAG "HWC2"
25#define ATRACE_TAG ATRACE_TAG_GRAPHICS
26
27#include "HWC2.h"
28
Dan Stoza651bf312015-10-23 17:03:17 -070029#include <ui/Fence.h>
Dan Stoza5a423ea2017-02-16 14:10:39 -080030#include <ui/FloatRect.h>
Dan Stoza651bf312015-10-23 17:03:17 -070031#include <ui/GraphicBuffer.h>
Dan Stoza651bf312015-10-23 17:03:17 -070032
33#include <android/configuration.h>
34
35#include <inttypes.h>
Lloyd Pique3c085a02018-05-09 19:38:32 -070036#include <algorithm>
37#include <iterator>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070038#include <set>
Dan Stoza651bf312015-10-23 17:03:17 -070039
Dominik Laskowski5690bde2020-04-23 19:04:22 -070040#include "../Promise.h"
41#include "ComposerHal.h"
42
Peiyong Line9d809e2020-04-14 13:10:48 -070043namespace android {
44
Dan Stoza651bf312015-10-23 17:03:17 -070045using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080046using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070047using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070048using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070049using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070050using android::Rect;
51using android::Region;
52using android::sp;
53
54namespace HWC2 {
55
Peiyong Line9d809e2020-04-14 13:10:48 -070056using namespace android::hardware::graphics::composer::hal;
57
Chia-I Wuaab99f52016-10-05 12:59:58 +080058namespace Hwc2 = android::Hwc2;
59
Steven Thomas94e35b92017-07-26 18:48:28 -070060namespace {
61
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070062inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
63 const Hwc2::PerFrameMetadataKey& key) {
64 return keys.find(key) != keys.end();
65}
66
Steven Thomas94e35b92017-07-26 18:48:28 -070067} // namespace anonymous
68
Dan Stoza651bf312015-10-23 17:03:17 -070069// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -080070Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -070071
Peiyong Line9d809e2020-04-14 13:10:48 -070072Display::Config::Config(Display& display, HWConfigId id)
Ana Krulec4593b692019-01-11 22:07:25 -080073 : mDisplay(display),
74 mId(id),
75 mWidth(-1),
76 mHeight(-1),
77 mVsyncPeriod(-1),
78 mDpiX(-1),
79 mDpiY(-1) {}
80
Peiyong Line9d809e2020-04-14 13:10:48 -070081Display::Config::Builder::Builder(Display& display, HWConfigId id)
Ana Krulec4593b692019-01-11 22:07:25 -080082 : mConfig(new Config(display, id)) {}
83
84float Display::Config::Builder::getDefaultDensity() {
85 // Default density is based on TVs: 1080p displays get XHIGH density, lower-
86 // resolution displays get TV density. Maybe eventually we'll need to update
87 // it for 4k displays, though hopefully those will just report accurate DPI
88 // information to begin with. This is also used for virtual displays and
89 // older HWC implementations, so be careful about orientation.
90
91 auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
92 if (longDimension >= 1080) {
93 return ACONFIGURATION_DENSITY_XHIGH;
94 } else {
95 return ACONFIGURATION_DENSITY_TV;
96 }
97}
98
99namespace impl {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800100
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800101Display::Display(android::Hwc2::Composer& composer,
Peiyong Line9d809e2020-04-14 13:10:48 -0700102 const std::unordered_set<Capability>& capabilities, HWDisplayId id,
Lloyd Piquebc792092018-01-17 11:52:30 -0800103 DisplayType type)
Peiyong Line9d809e2020-04-14 13:10:48 -0700104 : mComposer(composer), mCapabilities(capabilities), mId(id), mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -0700105 ALOGV("Created display %" PRIu64, id);
106}
107
Steven Thomas94e35b92017-07-26 18:48:28 -0700108Display::~Display() {
109 mLayers.clear();
110
Peiyong Line9d809e2020-04-14 13:10:48 -0700111 Error error = Error::NONE;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800112 const char* msg;
113 switch (mType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700114 case DisplayType::PHYSICAL:
115 error = setVsyncEnabled(HWC2::Vsync::DISABLE);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800116 msg = "disable VSYNC for";
117 break;
118
Peiyong Line9d809e2020-04-14 13:10:48 -0700119 case DisplayType::VIRTUAL:
Dominik Laskowski55c85402020-01-21 16:25:47 -0800120 error = static_cast<Error>(mComposer.destroyVirtualDisplay(mId));
121 msg = "destroy virtual";
122 break;
123
Peiyong Line9d809e2020-04-14 13:10:48 -0700124 case DisplayType::INVALID: // Used in unit tests.
Dominik Laskowski55c85402020-01-21 16:25:47 -0800125 break;
Dan Stoza651bf312015-10-23 17:03:17 -0700126 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800127
Peiyong Line9d809e2020-04-14 13:10:48 -0700128 ALOGE_IF(error != Error::NONE, "%s: Failed to %s display %" PRIu64 ": %d", __FUNCTION__, msg,
129 mId, static_cast<int32_t>(error));
Dominik Laskowski55c85402020-01-21 16:25:47 -0800130
131 ALOGV("Destroyed display %" PRIu64, mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700132}
133
Dan Stoza651bf312015-10-23 17:03:17 -0700134// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700135Error Display::acceptChanges()
136{
Steven Thomas94e35b92017-07-26 18:48:28 -0700137 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700138 return static_cast<Error>(intError);
139}
140
Lloyd Pique35d58242018-12-18 16:33:25 -0800141Error Display::createLayer(HWC2::Layer** outLayer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700142 if (!outLayer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700143 return Error::BAD_PARAMETER;
Steven Thomas94e35b92017-07-26 18:48:28 -0700144 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700145 HWLayerId layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700146 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700147 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700148 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700149 return error;
150 }
151
Lloyd Pique35d58242018-12-18 16:33:25 -0800152 auto layer = std::make_unique<impl::Layer>(mComposer, mCapabilities, mId, layerId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700153 *outLayer = layer.get();
154 mLayers.emplace(layerId, std::move(layer));
Peiyong Line9d809e2020-04-14 13:10:48 -0700155 return Error::NONE;
Steven Thomas94e35b92017-07-26 18:48:28 -0700156}
157
Lloyd Pique35d58242018-12-18 16:33:25 -0800158Error Display::destroyLayer(HWC2::Layer* layer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700159 if (!layer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700160 return Error::BAD_PARAMETER;
Steven Thomas94e35b92017-07-26 18:48:28 -0700161 }
162 mLayers.erase(layer->getId());
Peiyong Line9d809e2020-04-14 13:10:48 -0700163 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700164}
165
166Error Display::getActiveConfig(
167 std::shared_ptr<const Display::Config>* outConfig) const
168{
169 ALOGV("[%" PRIu64 "] getActiveConfig", mId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700170 HWConfigId configId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700171 auto intError = mComposer.getActiveConfig(mId, &configId);
Dan Stoza651bf312015-10-23 17:03:17 -0700172 auto error = static_cast<Error>(intError);
173
Peiyong Line9d809e2020-04-14 13:10:48 -0700174 if (error != Error::NONE) {
Fabien Sanglardb7432cc2016-11-11 09:40:27 -0800175 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
176 *outConfig = nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700177 return error;
178 }
179
180 if (mConfigs.count(configId) != 0) {
181 *outConfig = mConfigs.at(configId);
182 } else {
183 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
184 configId);
185 // Return no error, but the caller needs to check for a null pointer to
186 // detect this case
187 *outConfig = nullptr;
188 }
189
Peiyong Line9d809e2020-04-14 13:10:48 -0700190 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700191}
192
Ady Abraham7159f572019-10-11 11:10:18 -0700193bool Display::isVsyncPeriodSwitchSupported() const {
194 ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId);
195
196 return mComposer.isVsyncPeriodSwitchSupported();
197}
198
199Error Display::getDisplayVsyncPeriod(nsecs_t* outVsyncPeriod) const {
200 ALOGV("[%" PRIu64 "] getDisplayVsyncPeriod", mId);
201
202 Error error;
203
204 if (isVsyncPeriodSwitchSupported()) {
205 Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0;
206 auto intError = mComposer.getDisplayVsyncPeriod(mId, &vsyncPeriodNanos);
207 error = static_cast<Error>(intError);
208 *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos);
209 } else {
210 // Get the default vsync period
Marin Shalamanov533e8e22020-06-08 20:35:48 +0200211 std::shared_ptr<const Display::Config> config;
212 error = getActiveConfig(&config);
213 if (error != Error::NONE) {
214 return error;
Ady Abraham7159f572019-10-11 11:10:18 -0700215 }
Marin Shalamanov533e8e22020-06-08 20:35:48 +0200216 if (!config) {
217 // HWC has updated the display modes and hasn't notified us yet.
218 return Error::BAD_CONFIG;
219 }
220
221 *outVsyncPeriod = config->getVsyncPeriod();
Ady Abraham7159f572019-10-11 11:10:18 -0700222 }
223
224 return error;
225}
226
Lloyd Pique3c085a02018-05-09 19:38:32 -0700227Error Display::getActiveConfigIndex(int* outIndex) const {
228 ALOGV("[%" PRIu64 "] getActiveConfigIndex", mId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700229 HWConfigId configId = 0;
Lloyd Pique3c085a02018-05-09 19:38:32 -0700230 auto intError = mComposer.getActiveConfig(mId, &configId);
231 auto error = static_cast<Error>(intError);
232
Peiyong Line9d809e2020-04-14 13:10:48 -0700233 if (error != Error::NONE) {
Lloyd Pique3c085a02018-05-09 19:38:32 -0700234 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
235 *outIndex = -1;
236 return error;
237 }
238
239 auto pos = mConfigs.find(configId);
240 if (pos != mConfigs.end()) {
241 *outIndex = std::distance(mConfigs.begin(), pos);
Ady Abraham7159f572019-10-11 11:10:18 -0700242 ALOGV("[%" PRIu64 "] index = %d", mId, *outIndex);
Lloyd Pique3c085a02018-05-09 19:38:32 -0700243 } else {
244 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId, configId);
245 // Return no error, but the caller needs to check for a negative index
246 // to detect this case
247 *outIndex = -1;
248 }
249
Peiyong Line9d809e2020-04-14 13:10:48 -0700250 return Error::NONE;
Lloyd Pique3c085a02018-05-09 19:38:32 -0700251}
252
Lloyd Pique35d58242018-12-18 16:33:25 -0800253Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800254 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800255 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700256 auto intError = mComposer.getChangedCompositionTypes(
257 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800258 uint32_t numElements = layerIds.size();
259 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700260 error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700261 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700262 return error;
263 }
264
265 outTypes->clear();
266 outTypes->reserve(numElements);
267 for (uint32_t element = 0; element < numElements; ++element) {
268 auto layer = getLayerById(layerIds[element]);
269 if (layer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700270 auto type = types[element];
Dan Stoza651bf312015-10-23 17:03:17 -0700271 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
272 layer->getId(), to_string(type).c_str());
273 outTypes->emplace(layer, type);
274 } else {
275 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
276 " on display %" PRIu64, layerIds[element], mId);
277 }
278 }
279
Peiyong Line9d809e2020-04-14 13:10:48 -0700280 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700281}
282
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700283Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700284{
Peiyong Linfd997e02018-03-28 15:29:00 -0700285 auto intError = mComposer.getColorModes(mId, outModes);
286 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700287}
288
Chia-I Wud7e01d72018-06-21 13:39:09 +0800289int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700290{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800291 int32_t supportedPerFrameMetadata = 0;
292
293 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
294 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700295
296 // Check whether a specific metadata type is supported. A metadata type is considered
297 // supported if and only if all required fields are supported.
298
299 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700300 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
301 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
302 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
303 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
304 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
305 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
306 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
307 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
308 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
309 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800310 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700311 }
312 // CTA861_3
313 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
314 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800315 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700316 }
317
Valerie Haue9e843a2018-12-18 13:39:23 -0800318 // HDR10PLUS
319 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
320 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
321 }
322
Chia-I Wud7e01d72018-06-21 13:39:09 +0800323 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700324}
325
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700326Error Display::getRenderIntents(ColorMode colorMode,
327 std::vector<RenderIntent>* outRenderIntents) const
328{
329 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
330 return static_cast<Error>(intError);
331}
332
333Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
334{
335 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
336 return static_cast<Error>(intError);
337}
338
Dan Stoza651bf312015-10-23 17:03:17 -0700339std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
340{
341 std::vector<std::shared_ptr<const Config>> configs;
342 for (const auto& element : mConfigs) {
343 configs.emplace_back(element.second);
344 }
345 return configs;
346}
347
348Error Display::getName(std::string* outName) const
349{
Steven Thomas94e35b92017-07-26 18:48:28 -0700350 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800351 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700352}
353
354Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800355 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Lloyd Piquee9eff972020-05-05 12:36:44 -0700356 uint32_t intDisplayRequests = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800357 std::vector<Hwc2::Layer> layerIds;
358 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700359 auto intError = mComposer.getDisplayRequests(
360 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800361 uint32_t numElements = layerIds.size();
362 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700363 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700364 return error;
365 }
366
367 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
368 outLayerRequests->clear();
369 outLayerRequests->reserve(numElements);
370 for (uint32_t element = 0; element < numElements; ++element) {
371 auto layer = getLayerById(layerIds[element]);
372 if (layer) {
373 auto layerRequest =
374 static_cast<LayerRequest>(layerRequests[element]);
375 outLayerRequests->emplace(layer, layerRequest);
376 } else {
377 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
378 PRIu64, layerIds[element], mId);
379 }
380 }
381
Peiyong Line9d809e2020-04-14 13:10:48 -0700382 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700383}
384
Dominik Laskowski55c85402020-01-21 16:25:47 -0800385Error Display::getConnectionType(android::DisplayConnectionType* outType) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700386 if (mType != DisplayType::PHYSICAL) return Error::BAD_DISPLAY;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800387
388 using ConnectionType = Hwc2::IComposerClient::DisplayConnectionType;
389 ConnectionType connectionType;
390 const auto error = static_cast<Error>(mComposer.getDisplayConnectionType(mId, &connectionType));
Peiyong Line9d809e2020-04-14 13:10:48 -0700391 if (error != Error::NONE) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800392 return error;
393 }
394
395 *outType = connectionType == ConnectionType::INTERNAL
396 ? android::DisplayConnectionType::Internal
397 : android::DisplayConnectionType::External;
Peiyong Line9d809e2020-04-14 13:10:48 -0700398 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700399}
400
Peiyong Lined531a32018-10-26 18:27:56 -0700401Error Display::supportsDoze(bool* outSupport) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700402 *outSupport = mDisplayCapabilities.count(DisplayCapability::DOZE) > 0;
403 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700404}
405
Peiyong Lin62665892018-04-16 11:07:44 -0700406Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700407{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700408 float maxLuminance = -1.0f;
409 float maxAverageLuminance = -1.0f;
410 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700411 std::vector<Hwc2::Hdr> types;
412 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800413 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800414 auto error = static_cast<HWC2::Error>(intError);
415
Peiyong Line9d809e2020-04-14 13:10:48 -0700416 if (error != Error::NONE) {
Dan Stoza7d7ae732016-03-16 12:23:40 -0700417 return error;
418 }
419
Peiyong Lin62665892018-04-16 11:07:44 -0700420 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700421 maxLuminance, maxAverageLuminance, minLuminance);
Peiyong Line9d809e2020-04-14 13:10:48 -0700422 return Error::NONE;
Dan Stoza7d7ae732016-03-16 12:23:40 -0700423}
424
Peiyong Line9d809e2020-04-14 13:10:48 -0700425Error Display::getDisplayedContentSamplingAttributes(hal::PixelFormat* outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700426 Dataspace* outDataspace,
427 uint8_t* outComponentMask) const {
428 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
429 outComponentMask);
430 return static_cast<Error>(intError);
431}
432
Kevin DuBois74e53772018-11-19 10:52:38 -0800433Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
434 uint64_t maxFrames) const {
435 auto intError =
436 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
437 return static_cast<Error>(intError);
438}
439
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700440Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
441 android::DisplayedFrameStats* outStats) const {
442 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
443 return static_cast<Error>(intError);
444}
445
Lloyd Pique35d58242018-12-18 16:33:25 -0800446Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800447 std::vector<Hwc2::Layer> layerIds;
448 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700449 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800450 auto error = static_cast<Error>(intError);
451 uint32_t numElements = layerIds.size();
Peiyong Line9d809e2020-04-14 13:10:48 -0700452 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700453 return error;
454 }
455
Lloyd Pique35d58242018-12-18 16:33:25 -0800456 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700457 releaseFences.reserve(numElements);
458 for (uint32_t element = 0; element < numElements; ++element) {
459 auto layer = getLayerById(layerIds[element]);
460 if (layer) {
461 sp<Fence> fence(new Fence(fenceFds[element]));
Steven Thomas94e35b92017-07-26 18:48:28 -0700462 releaseFences.emplace(layer, fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700463 } else {
464 ALOGE("getReleaseFences: invalid layer %" PRIu64
465 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700466 for (; element < numElements; ++element) {
467 close(fenceFds[element]);
468 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700469 return Error::BAD_LAYER;
Dan Stoza651bf312015-10-23 17:03:17 -0700470 }
471 }
472
473 *outFences = std::move(releaseFences);
Peiyong Line9d809e2020-04-14 13:10:48 -0700474 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700475}
476
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800477Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700478{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400479 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700480 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700481 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700482 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700483 return error;
484 }
485
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800486 *outPresentFence = new Fence(presentFenceFd);
Peiyong Line9d809e2020-04-14 13:10:48 -0700487 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700488}
489
Ady Abraham7159f572019-10-11 11:10:18 -0700490Error Display::setActiveConfigWithConstraints(
491 const std::shared_ptr<const HWC2::Display::Config>& config,
492 const VsyncPeriodChangeConstraints& constraints, VsyncPeriodChangeTimeline* outTimeline) {
493 ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId);
494 if (config->getDisplayId() != mId) {
495 ALOGE("setActiveConfigWithConstraints received config %u for the wrong display %" PRIu64
496 " (expected %" PRIu64 ")",
497 config->getId(), config->getDisplayId(), mId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700498 return Error::BAD_CONFIG;
Ady Abraham7159f572019-10-11 11:10:18 -0700499 }
500
501 if (isVsyncPeriodSwitchSupported()) {
502 Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints;
503 hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos;
504 hwc2Constraints.seamlessRequired = constraints.seamlessRequired;
505
506 Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {};
507 auto intError =
508 mComposer.setActiveConfigWithConstraints(mId, config->getId(), hwc2Constraints,
509 &vsyncPeriodChangeTimeline);
510 outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos;
511 outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired;
512 outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos;
513 return static_cast<Error>(intError);
514 }
515
516 // Use legacy setActiveConfig instead
517 ALOGV("fallback to legacy setActiveConfig");
518 const auto now = systemTime();
519 if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) {
520 ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied");
521 }
522
523 auto intError_2_4 = mComposer.setActiveConfig(mId, config->getId());
524 outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos);
525 outTimeline->refreshRequired = true;
526 outTimeline->refreshTimeNanos = now;
527 return static_cast<Error>(intError_2_4);
528}
529
Dan Stoza651bf312015-10-23 17:03:17 -0700530Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
531{
532 if (config->getDisplayId() != mId) {
533 ALOGE("setActiveConfig received config %u for the wrong display %"
534 PRIu64 " (expected %" PRIu64 ")", config->getId(),
535 config->getDisplayId(), mId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700536 return Error::BAD_CONFIG;
Dan Stoza651bf312015-10-23 17:03:17 -0700537 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700538 auto intError = mComposer.setActiveConfig(mId, config->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700539 return static_cast<Error>(intError);
540}
541
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400542Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700543 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700544{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700545 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700546 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700547 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700548 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700549 return static_cast<Error>(intError);
550}
551
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700552Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700553{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700554 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700555 return static_cast<Error>(intError);
556}
557
Peiyong Line9d809e2020-04-14 13:10:48 -0700558Error Display::setColorTransform(const android::mat4& matrix, ColorTransform hint) {
559 auto intError = mComposer.setColorTransform(mId, matrix.asArray(), hint);
Dan Stoza5df2a862016-03-24 16:19:37 -0700560 return static_cast<Error>(intError);
561}
562
Dan Stoza651bf312015-10-23 17:03:17 -0700563Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
564 const sp<Fence>& releaseFence)
565{
566 int32_t fenceFd = releaseFence->dup();
567 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700568 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700569 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700570 return static_cast<Error>(intError);
571}
572
573Error Display::setPowerMode(PowerMode mode)
574{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800575 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700576 auto intError = mComposer.setPowerMode(mId, intMode);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700577
Peiyong Line9d809e2020-04-14 13:10:48 -0700578 if (mode == PowerMode::ON) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700579 std::call_once(mDisplayCapabilityQueryFlag, [this]() {
580 std::vector<Hwc2::DisplayCapability> tmpCapabilities;
581 auto error =
582 static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
Peiyong Line9d809e2020-04-14 13:10:48 -0700583 if (error == Error::NONE) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700584 for (auto capability : tmpCapabilities) {
585 mDisplayCapabilities.emplace(static_cast<DisplayCapability>(capability));
586 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700587 } else if (error == Error::UNSUPPORTED) {
588 if (mCapabilities.count(Capability::SKIP_CLIENT_COLOR_TRANSFORM)) {
589 mDisplayCapabilities.emplace(DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700590 }
591 bool dozeSupport = false;
592 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
Peiyong Line9d809e2020-04-14 13:10:48 -0700593 if (error == Error::NONE && dozeSupport) {
594 mDisplayCapabilities.emplace(DisplayCapability::DOZE);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700595 }
596 }
597 });
598 }
599
Dan Stoza651bf312015-10-23 17:03:17 -0700600 return static_cast<Error>(intError);
601}
602
603Error Display::setVsyncEnabled(Vsync enabled)
604{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800605 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700606 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700607 return static_cast<Error>(intError);
608}
609
610Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
611{
612 uint32_t numTypes = 0;
613 uint32_t numRequests = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700614 auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700615 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700616 if (error != Error::NONE && !hasChangesError(error)) {
Dan Stoza651bf312015-10-23 17:03:17 -0700617 return error;
618 }
619
620 *outNumTypes = numTypes;
621 *outNumRequests = numRequests;
622 return error;
623}
624
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700625Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
626 sp<android::Fence>* outPresentFence, uint32_t* state) {
627
628 uint32_t numTypes = 0;
629 uint32_t numRequests = 0;
630 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700631 auto intError = mComposer.presentOrValidateDisplay(
632 mId, &numTypes, &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700633 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700634 if (error != Error::NONE && !hasChangesError(error)) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700635 return error;
636 }
637
638 if (*state == 1) {
639 *outPresentFence = new Fence(presentFenceFd);
640 }
641
642 if (*state == 0) {
643 *outNumTypes = numTypes;
644 *outNumRequests = numRequests;
645 }
646 return error;
647}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700648
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700649std::future<Error> Display::setDisplayBrightness(float brightness) {
650 return promise::defer([composer = &mComposer, id = mId, brightness] {
651 const auto intError = composer->setDisplayBrightness(id, brightness);
652 return static_cast<Error>(intError);
653 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000654}
655
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700656Error Display::setAutoLowLatencyMode(bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100657 auto intError = mComposer.setAutoLowLatencyMode(mId, on);
658 return static_cast<Error>(intError);
659}
660
661Error Display::getSupportedContentTypes(std::vector<ContentType>* outSupportedContentTypes) const {
662 std::vector<Hwc2::IComposerClient::ContentType> tmpSupportedContentTypes;
663 auto intError = mComposer.getSupportedContentTypes(mId, &tmpSupportedContentTypes);
664 for (Hwc2::IComposerClient::ContentType contentType : tmpSupportedContentTypes) {
665 outSupportedContentTypes->push_back(static_cast<ContentType>(contentType));
666 }
667 return static_cast<Error>(intError);
668}
669
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700670Error Display::setContentType(ContentType contentType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700671 auto intError = mComposer.setContentType(mId, contentType);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100672 return static_cast<Error>(intError);
673}
674
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700675Error Display::getClientTargetProperty(ClientTargetProperty* outClientTargetProperty) {
676 const auto error = mComposer.getClientTargetProperty(mId, outClientTargetProperty);
677 return static_cast<Error>(error);
678}
679
Dan Stoza651bf312015-10-23 17:03:17 -0700680// For use by Device
681
Steven Thomas94e35b92017-07-26 18:48:28 -0700682void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800683 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700684 mComposer.setClientTargetSlotCount(mId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700685 if (mType == DisplayType::PHYSICAL) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800686 loadConfigs();
687 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700688 }
689 mIsConnected = connected;
690}
691
Peiyong Line9d809e2020-04-14 13:10:48 -0700692int32_t Display::getAttribute(HWConfigId configId, Attribute attribute) {
Dan Stoza651bf312015-10-23 17:03:17 -0700693 int32_t value = 0;
Peiyong Line9d809e2020-04-14 13:10:48 -0700694 auto intError = mComposer.getDisplayAttribute(mId, configId, attribute, &value);
Dan Stoza651bf312015-10-23 17:03:17 -0700695 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700696 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700697 ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
698 configId, to_string(attribute).c_str(),
699 to_string(error).c_str(), intError);
700 return -1;
701 }
702 return value;
703}
704
Peiyong Line9d809e2020-04-14 13:10:48 -0700705void Display::loadConfig(HWConfigId configId) {
Dan Stoza651bf312015-10-23 17:03:17 -0700706 ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
707
708 auto config = Config::Builder(*this, configId)
Peiyong Line9d809e2020-04-14 13:10:48 -0700709 .setWidth(getAttribute(configId, hal::Attribute::WIDTH))
710 .setHeight(getAttribute(configId, hal::Attribute::HEIGHT))
711 .setVsyncPeriod(getAttribute(configId, hal::Attribute::VSYNC_PERIOD))
712 .setDpiX(getAttribute(configId, hal::Attribute::DPI_X))
713 .setDpiY(getAttribute(configId, hal::Attribute::DPI_Y))
714 .setConfigGroup(getAttribute(configId, hal::Attribute::CONFIG_GROUP))
Ady Abraham7159f572019-10-11 11:10:18 -0700715 .build();
Dan Stoza651bf312015-10-23 17:03:17 -0700716 mConfigs.emplace(configId, std::move(config));
717}
718
719void Display::loadConfigs()
720{
721 ALOGV("[%" PRIu64 "] loadConfigs", mId);
722
Peiyong Line9d809e2020-04-14 13:10:48 -0700723 std::vector<HWConfigId> configIds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700724 auto intError = mComposer.getDisplayConfigs(mId, &configIds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800725 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700726 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700727 ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
728 to_string(error).c_str(), intError);
729 return;
730 }
731
732 for (auto configId : configIds) {
733 loadConfig(configId);
734 }
735}
736
Dan Stoza651bf312015-10-23 17:03:17 -0700737// Other Display methods
738
Peiyong Line9d809e2020-04-14 13:10:48 -0700739HWC2::Layer* Display::getLayerById(HWLayerId id) const {
Dan Stoza651bf312015-10-23 17:03:17 -0700740 if (mLayers.count(id) == 0) {
741 return nullptr;
742 }
743
Steven Thomas94e35b92017-07-26 18:48:28 -0700744 return mLayers.at(id).get();
Dan Stoza651bf312015-10-23 17:03:17 -0700745}
Ana Krulec4593b692019-01-11 22:07:25 -0800746} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700747
748// Layer methods
749
Lloyd Pique35d58242018-12-18 16:33:25 -0800750Layer::~Layer() = default;
751
752namespace impl {
753
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700754Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Peiyong Line9d809e2020-04-14 13:10:48 -0700755 HWDisplayId displayId, HWLayerId layerId)
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800756 : mComposer(composer),
757 mCapabilities(capabilities),
758 mDisplayId(displayId),
759 mId(layerId),
760 mColorMatrix(android::mat4()) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700761 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700762}
763
764Layer::~Layer()
765{
Steven Thomas94e35b92017-07-26 18:48:28 -0700766 auto intError = mComposer.destroyLayer(mDisplayId, mId);
767 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700768 ALOGE_IF(error != Error::NONE,
769 "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
770 " failed: %s (%d)",
771 mDisplayId, mId, to_string(error).c_str(), intError);
Steven Thomas94e35b92017-07-26 18:48:28 -0700772}
773
Dan Stoza651bf312015-10-23 17:03:17 -0700774Error Layer::setCursorPosition(int32_t x, int32_t y)
775{
Steven Thomas94e35b92017-07-26 18:48:28 -0700776 auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700777 return static_cast<Error>(intError);
778}
779
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400780Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700781 const sp<Fence>& acquireFence)
782{
Yichi Chen8366f562019-03-25 19:44:06 +0800783 if (buffer == nullptr && mBufferSlot == slot) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700784 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800785 }
786 mBufferSlot = slot;
787
Dan Stoza651bf312015-10-23 17:03:17 -0700788 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700789 auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
790 fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700791 return static_cast<Error>(intError);
792}
793
794Error Layer::setSurfaceDamage(const Region& damage)
795{
Yichi Chen8366f562019-03-25 19:44:06 +0800796 if (damage.isRect() && mDamageRegion.isRect() &&
797 (damage.getBounds() == mDamageRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700798 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800799 }
800 mDamageRegion = damage;
801
Dan Stoza651bf312015-10-23 17:03:17 -0700802 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
803 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800804 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700805 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700806 intError = mComposer.setLayerSurfaceDamage(mDisplayId,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800807 mId, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700808 } else {
809 size_t rectCount = 0;
810 auto rectArray = damage.getArray(&rectCount);
811
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800812 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700813 for (size_t rect = 0; rect < rectCount; ++rect) {
814 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
815 rectArray[rect].right, rectArray[rect].bottom});
816 }
817
Steven Thomas94e35b92017-07-26 18:48:28 -0700818 intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700819 }
820
821 return static_cast<Error>(intError);
822}
823
824Error Layer::setBlendMode(BlendMode mode)
825{
Peiyong Line9d809e2020-04-14 13:10:48 -0700826 auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, mode);
Dan Stoza651bf312015-10-23 17:03:17 -0700827 return static_cast<Error>(intError);
828}
829
Peiyong Line9d809e2020-04-14 13:10:48 -0700830Error Layer::setColor(Color color) {
831 auto intError = mComposer.setLayerColor(mDisplayId, mId, color);
Dan Stoza651bf312015-10-23 17:03:17 -0700832 return static_cast<Error>(intError);
833}
834
835Error Layer::setCompositionType(Composition type)
836{
Peiyong Line9d809e2020-04-14 13:10:48 -0700837 auto intError = mComposer.setLayerCompositionType(mDisplayId, mId, type);
Dan Stoza651bf312015-10-23 17:03:17 -0700838 return static_cast<Error>(intError);
839}
840
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700841Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700842{
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600843 if (dataspace == mDataSpace) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700844 return Error::NONE;
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600845 }
846 mDataSpace = dataspace;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700847 auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700848 return static_cast<Error>(intError);
849}
850
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700851Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
852 const android::HdrMetadata& metadata)
853{
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700854 if (metadata == mHdrMetadata) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700855 return Error::NONE;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700856 }
857
858 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700859 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
860 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
861 if (validTypes & HdrMetadata::SMPTE2086) {
862 perFrameMetadatas.insert(perFrameMetadatas.end(),
863 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800864 mHdrMetadata.smpte2086.displayPrimaryRed.x},
865 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
866 mHdrMetadata.smpte2086.displayPrimaryRed.y},
867 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
868 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
869 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
870 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
871 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
872 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
873 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
874 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
875 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
876 mHdrMetadata.smpte2086.whitePoint.x},
877 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
878 mHdrMetadata.smpte2086.whitePoint.y},
879 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
880 mHdrMetadata.smpte2086.maxLuminance},
881 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
882 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700883 }
884
885 if (validTypes & HdrMetadata::CTA861_3) {
886 perFrameMetadatas.insert(perFrameMetadatas.end(),
887 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800888 mHdrMetadata.cta8613.maxContentLightLevel},
889 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
890 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700891 }
892
Valerie Haue9e843a2018-12-18 13:39:23 -0800893 Error error = static_cast<Error>(
894 mComposer.setLayerPerFrameMetadata(mDisplayId, mId, perFrameMetadatas));
895
896 if (validTypes & HdrMetadata::HDR10PLUS) {
Yichi Chen1d5146d2020-06-12 18:50:11 +0800897 if (CC_UNLIKELY(mHdrMetadata.hdr10plus.size() == 0)) {
898 return Error::BAD_PARAMETER;
899 }
900
Valerie Haue9e843a2018-12-18 13:39:23 -0800901 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
902 perFrameMetadataBlobs.push_back(
903 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
904 Error setMetadataBlobsError = static_cast<Error>(
905 mComposer.setLayerPerFrameMetadataBlobs(mDisplayId, mId, perFrameMetadataBlobs));
Peiyong Line9d809e2020-04-14 13:10:48 -0700906 if (error == Error::NONE) {
Valerie Haue9e843a2018-12-18 13:39:23 -0800907 return setMetadataBlobsError;
908 }
909 }
910 return error;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700911}
912
Dan Stoza651bf312015-10-23 17:03:17 -0700913Error Layer::setDisplayFrame(const Rect& frame)
914{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800915 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800916 frame.right, frame.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700917 auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700918 return static_cast<Error>(intError);
919}
920
921Error Layer::setPlaneAlpha(float alpha)
922{
Steven Thomas94e35b92017-07-26 18:48:28 -0700923 auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700924 return static_cast<Error>(intError);
925}
926
927Error Layer::setSidebandStream(const native_handle_t* stream)
928{
Peiyong Line9d809e2020-04-14 13:10:48 -0700929 if (mCapabilities.count(Capability::SIDEBAND_STREAM) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700930 ALOGE("Attempted to call setSidebandStream without checking that the "
931 "device supports sideband streams");
Peiyong Line9d809e2020-04-14 13:10:48 -0700932 return Error::UNSUPPORTED;
Dan Stoza09e7a272016-04-14 12:31:01 -0700933 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700934 auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700935 return static_cast<Error>(intError);
936}
937
938Error Layer::setSourceCrop(const FloatRect& crop)
939{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800940 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800941 crop.left, crop.top, crop.right, crop.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700942 auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700943 return static_cast<Error>(intError);
944}
945
946Error Layer::setTransform(Transform transform)
947{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800948 auto intTransform = static_cast<Hwc2::Transform>(transform);
Steven Thomas94e35b92017-07-26 18:48:28 -0700949 auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700950 return static_cast<Error>(intError);
951}
952
953Error Layer::setVisibleRegion(const Region& region)
954{
Yichi Chen8366f562019-03-25 19:44:06 +0800955 if (region.isRect() && mVisibleRegion.isRect() &&
956 (region.getBounds() == mVisibleRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700957 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800958 }
959 mVisibleRegion = region;
960
Dan Stoza651bf312015-10-23 17:03:17 -0700961 size_t rectCount = 0;
962 auto rectArray = region.getArray(&rectCount);
963
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800964 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700965 for (size_t rect = 0; rect < rectCount; ++rect) {
966 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
967 rectArray[rect].right, rectArray[rect].bottom});
968 }
969
Steven Thomas94e35b92017-07-26 18:48:28 -0700970 auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700971 return static_cast<Error>(intError);
972}
973
974Error Layer::setZOrder(uint32_t z)
975{
Steven Thomas94e35b92017-07-26 18:48:28 -0700976 auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700977 return static_cast<Error>(intError);
978}
979
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500980Error Layer::setInfo(uint32_t type, uint32_t appId)
981{
Steven Thomas94e35b92017-07-26 18:48:28 -0700982 auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500983 return static_cast<Error>(intError);
984}
985
Peiyong Lin698147a2018-09-14 13:27:18 -0700986// Composer HAL 2.3
987Error Layer::setColorTransform(const android::mat4& matrix) {
988 if (matrix == mColorMatrix) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700989 return Error::NONE;
Peiyong Lin698147a2018-09-14 13:27:18 -0700990 }
Peiyong Lin698147a2018-09-14 13:27:18 -0700991 auto intError = mComposer.setLayerColorTransform(mDisplayId, mId, matrix.asArray());
Peiyong Lin04d25872019-04-18 10:26:19 -0700992 Error error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700993 if (error != Error::NONE) {
Peiyong Lin04d25872019-04-18 10:26:19 -0700994 return error;
995 }
996 mColorMatrix = matrix;
997 return error;
Peiyong Lin698147a2018-09-14 13:27:18 -0700998}
Lloyd Pique35d58242018-12-18 16:33:25 -0800999
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001000// Composer HAL 2.4
1001Error Layer::setLayerGenericMetadata(const std::string& name, bool mandatory,
1002 const std::vector<uint8_t>& value) {
1003 auto intError = mComposer.setLayerGenericMetadata(mDisplayId, mId, name, mandatory, value);
1004 return static_cast<Error>(intError);
1005}
1006
Lloyd Pique35d58242018-12-18 16:33:25 -08001007} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -07001008} // namespace HWC2
Peiyong Line9d809e2020-04-14 13:10:48 -07001009} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001010
1011// TODO(b/129481165): remove the #pragma below and fix conversion issues
1012#pragma clang diagnostic pop // ignored "-Wconversion"