blob: dd3dba1caf64ec54adae29443c500311dc3aad1c [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"
Chia-I Wuaab99f52016-10-05 12:59:58 +080028#include "ComposerHal.h"
Dan Stoza651bf312015-10-23 17:03:17 -070029
Dan Stoza651bf312015-10-23 17:03:17 -070030#include <ui/Fence.h>
Dan Stoza5a423ea2017-02-16 14:10:39 -080031#include <ui/FloatRect.h>
Dan Stoza651bf312015-10-23 17:03:17 -070032#include <ui/GraphicBuffer.h>
Dan Stoza651bf312015-10-23 17:03:17 -070033
34#include <android/configuration.h>
35
36#include <inttypes.h>
Lloyd Pique3c085a02018-05-09 19:38:32 -070037#include <algorithm>
38#include <iterator>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070039#include <set>
Dan Stoza651bf312015-10-23 17:03:17 -070040
Dan Stoza651bf312015-10-23 17:03:17 -070041using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080042using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070043using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070044using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070045using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070046using android::Rect;
47using android::Region;
48using android::sp;
49
50namespace HWC2 {
51
Chia-I Wuaab99f52016-10-05 12:59:58 +080052namespace Hwc2 = android::Hwc2;
Peiyong Lin34beb7a2018-03-28 11:57:12 -070053using android::ui::ColorMode;
54using android::ui::Dataspace;
55using android::ui::PixelFormat;
Peiyong Lin0e7a7912018-04-05 14:36:36 -070056using android::ui::RenderIntent;
Chia-I Wuaab99f52016-10-05 12:59:58 +080057
Steven Thomas94e35b92017-07-26 18:48:28 -070058namespace {
59
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070060inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
61 const Hwc2::PerFrameMetadataKey& key) {
62 return keys.find(key) != keys.end();
63}
64
Steven Thomas94e35b92017-07-26 18:48:28 -070065} // namespace anonymous
66
Dan Stoza651bf312015-10-23 17:03:17 -070067// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -080068Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -070069
Ana Krulec4593b692019-01-11 22:07:25 -080070Display::Config::Config(Display& display, hwc2_config_t id)
71 : mDisplay(display),
72 mId(id),
73 mWidth(-1),
74 mHeight(-1),
75 mVsyncPeriod(-1),
76 mDpiX(-1),
77 mDpiY(-1) {}
78
79Display::Config::Builder::Builder(Display& display, hwc2_config_t id)
80 : mConfig(new Config(display, id)) {}
81
82float Display::Config::Builder::getDefaultDensity() {
83 // Default density is based on TVs: 1080p displays get XHIGH density, lower-
84 // resolution displays get TV density. Maybe eventually we'll need to update
85 // it for 4k displays, though hopefully those will just report accurate DPI
86 // information to begin with. This is also used for virtual displays and
87 // older HWC implementations, so be careful about orientation.
88
89 auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
90 if (longDimension >= 1080) {
91 return ACONFIGURATION_DENSITY_XHIGH;
92 } else {
93 return ACONFIGURATION_DENSITY_TV;
94 }
95}
96
97namespace impl {
Dominik Laskowski55c85402020-01-21 16:25:47 -080098
Peiyong Lin74ca2f42019-01-14 19:36:57 -080099Display::Display(android::Hwc2::Composer& composer,
Lloyd Piquebc792092018-01-17 11:52:30 -0800100 const std::unordered_set<Capability>& capabilities, hwc2_display_t id,
101 DisplayType type)
102 : mComposer(composer),
103 mCapabilities(capabilities),
104 mId(id),
Lloyd Piquebc792092018-01-17 11:52:30 -0800105 mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -0700106 ALOGV("Created display %" PRIu64, id);
107}
108
Steven Thomas94e35b92017-07-26 18:48:28 -0700109Display::~Display() {
110 mLayers.clear();
111
Dominik Laskowski55c85402020-01-21 16:25:47 -0800112 Error error = Error::None;
113 const char* msg;
114 switch (mType) {
115 case DisplayType::Physical:
116 error = setVsyncEnabled(HWC2::Vsync::Disable);
117 msg = "disable VSYNC for";
118 break;
119
120 case DisplayType::Virtual:
121 error = static_cast<Error>(mComposer.destroyVirtualDisplay(mId));
122 msg = "destroy virtual";
123 break;
124
125 case DisplayType::Invalid: // Used in unit tests.
126 break;
Dan Stoza651bf312015-10-23 17:03:17 -0700127 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800128
129 ALOGE_IF(error != Error::None, "%s: Failed to %s display %" PRIu64 ": %s (%d)", __FUNCTION__,
130 msg, mId, to_string(error).c_str(), static_cast<int32_t>(error));
131
132 ALOGV("Destroyed display %" PRIu64, mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700133}
134
Dan Stoza651bf312015-10-23 17:03:17 -0700135// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700136Error Display::acceptChanges()
137{
Steven Thomas94e35b92017-07-26 18:48:28 -0700138 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700139 return static_cast<Error>(intError);
140}
141
Lloyd Pique35d58242018-12-18 16:33:25 -0800142Error Display::createLayer(HWC2::Layer** outLayer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700143 if (!outLayer) {
144 return Error::BadParameter;
145 }
Dan Stoza651bf312015-10-23 17:03:17 -0700146 hwc2_layer_t layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700147 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700148 auto error = static_cast<Error>(intError);
149 if (error != Error::None) {
150 return error;
151 }
152
Lloyd Pique35d58242018-12-18 16:33:25 -0800153 auto layer = std::make_unique<impl::Layer>(mComposer, mCapabilities, mId, layerId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700154 *outLayer = layer.get();
155 mLayers.emplace(layerId, std::move(layer));
156 return Error::None;
157}
158
Lloyd Pique35d58242018-12-18 16:33:25 -0800159Error Display::destroyLayer(HWC2::Layer* layer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700160 if (!layer) {
161 return Error::BadParameter;
162 }
163 mLayers.erase(layer->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700164 return Error::None;
165}
166
167Error Display::getActiveConfig(
168 std::shared_ptr<const Display::Config>* outConfig) const
169{
170 ALOGV("[%" PRIu64 "] getActiveConfig", mId);
171 hwc2_config_t configId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700172 auto intError = mComposer.getActiveConfig(mId, &configId);
Dan Stoza651bf312015-10-23 17:03:17 -0700173 auto error = static_cast<Error>(intError);
174
175 if (error != Error::None) {
Fabien Sanglardb7432cc2016-11-11 09:40:27 -0800176 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
177 *outConfig = nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700178 return error;
179 }
180
181 if (mConfigs.count(configId) != 0) {
182 *outConfig = mConfigs.at(configId);
183 } else {
184 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
185 configId);
186 // Return no error, but the caller needs to check for a null pointer to
187 // detect this case
188 *outConfig = nullptr;
189 }
190
191 return Error::None;
192}
193
Ady Abraham7159f572019-10-11 11:10:18 -0700194bool Display::isVsyncPeriodSwitchSupported() const {
195 ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId);
196
197 return mComposer.isVsyncPeriodSwitchSupported();
198}
199
200Error Display::getDisplayVsyncPeriod(nsecs_t* outVsyncPeriod) const {
201 ALOGV("[%" PRIu64 "] getDisplayVsyncPeriod", mId);
202
203 Error error;
204
205 if (isVsyncPeriodSwitchSupported()) {
206 Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0;
207 auto intError = mComposer.getDisplayVsyncPeriod(mId, &vsyncPeriodNanos);
208 error = static_cast<Error>(intError);
209 *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos);
210 } else {
211 // Get the default vsync period
212 hwc2_config_t configId = 0;
213 auto intError_2_1 = mComposer.getActiveConfig(mId, &configId);
214 error = static_cast<Error>(intError_2_1);
215 if (error == Error::None) {
216 auto config = mConfigs.at(configId);
217 *outVsyncPeriod = config->getVsyncPeriod();
218 }
219 }
220
221 return error;
222}
223
Lloyd Pique3c085a02018-05-09 19:38:32 -0700224Error Display::getActiveConfigIndex(int* outIndex) const {
225 ALOGV("[%" PRIu64 "] getActiveConfigIndex", mId);
226 hwc2_config_t configId = 0;
227 auto intError = mComposer.getActiveConfig(mId, &configId);
228 auto error = static_cast<Error>(intError);
229
230 if (error != Error::None) {
231 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
232 *outIndex = -1;
233 return error;
234 }
235
236 auto pos = mConfigs.find(configId);
237 if (pos != mConfigs.end()) {
238 *outIndex = std::distance(mConfigs.begin(), pos);
Ady Abraham7159f572019-10-11 11:10:18 -0700239 ALOGV("[%" PRIu64 "] index = %d", mId, *outIndex);
Lloyd Pique3c085a02018-05-09 19:38:32 -0700240 } else {
241 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId, configId);
242 // Return no error, but the caller needs to check for a negative index
243 // to detect this case
244 *outIndex = -1;
245 }
246
247 return Error::None;
248}
249
Lloyd Pique35d58242018-12-18 16:33:25 -0800250Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800251 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800252 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700253 auto intError = mComposer.getChangedCompositionTypes(
254 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800255 uint32_t numElements = layerIds.size();
256 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700257 error = static_cast<Error>(intError);
258 if (error != Error::None) {
259 return error;
260 }
261
262 outTypes->clear();
263 outTypes->reserve(numElements);
264 for (uint32_t element = 0; element < numElements; ++element) {
265 auto layer = getLayerById(layerIds[element]);
266 if (layer) {
267 auto type = static_cast<Composition>(types[element]);
268 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
269 layer->getId(), to_string(type).c_str());
270 outTypes->emplace(layer, type);
271 } else {
272 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
273 " on display %" PRIu64, layerIds[element], mId);
274 }
275 }
276
277 return Error::None;
278}
279
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700280Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700281{
Peiyong Linfd997e02018-03-28 15:29:00 -0700282 auto intError = mComposer.getColorModes(mId, outModes);
283 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700284}
285
Chia-I Wud7e01d72018-06-21 13:39:09 +0800286int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700287{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800288 int32_t supportedPerFrameMetadata = 0;
289
290 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
291 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700292
293 // Check whether a specific metadata type is supported. A metadata type is considered
294 // supported if and only if all required fields are supported.
295
296 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700297 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
298 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
299 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
300 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
301 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
302 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
303 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
304 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
305 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
306 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800307 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700308 }
309 // CTA861_3
310 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
311 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800312 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700313 }
314
Valerie Haue9e843a2018-12-18 13:39:23 -0800315 // HDR10PLUS
316 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
317 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
318 }
319
Chia-I Wud7e01d72018-06-21 13:39:09 +0800320 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700321}
322
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700323Error Display::getRenderIntents(ColorMode colorMode,
324 std::vector<RenderIntent>* outRenderIntents) const
325{
326 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
327 return static_cast<Error>(intError);
328}
329
330Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
331{
332 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
333 return static_cast<Error>(intError);
334}
335
Dan Stoza651bf312015-10-23 17:03:17 -0700336std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
337{
338 std::vector<std::shared_ptr<const Config>> configs;
339 for (const auto& element : mConfigs) {
340 configs.emplace_back(element.second);
341 }
342 return configs;
343}
344
345Error Display::getName(std::string* outName) const
346{
Steven Thomas94e35b92017-07-26 18:48:28 -0700347 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800348 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700349}
350
351Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800352 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800353 uint32_t intDisplayRequests;
354 std::vector<Hwc2::Layer> layerIds;
355 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700356 auto intError = mComposer.getDisplayRequests(
357 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800358 uint32_t numElements = layerIds.size();
359 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700360 if (error != Error::None) {
361 return error;
362 }
363
364 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
365 outLayerRequests->clear();
366 outLayerRequests->reserve(numElements);
367 for (uint32_t element = 0; element < numElements; ++element) {
368 auto layer = getLayerById(layerIds[element]);
369 if (layer) {
370 auto layerRequest =
371 static_cast<LayerRequest>(layerRequests[element]);
372 outLayerRequests->emplace(layer, layerRequest);
373 } else {
374 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
375 PRIu64, layerIds[element], mId);
376 }
377 }
378
379 return Error::None;
380}
381
Dominik Laskowski55c85402020-01-21 16:25:47 -0800382Error Display::getConnectionType(android::DisplayConnectionType* outType) const {
383 if (mType != DisplayType::Physical) return Error::BadDisplay;
384
385 using ConnectionType = Hwc2::IComposerClient::DisplayConnectionType;
386 ConnectionType connectionType;
387 const auto error = static_cast<Error>(mComposer.getDisplayConnectionType(mId, &connectionType));
388 if (error != Error::None) {
389 return error;
390 }
391
392 *outType = connectionType == ConnectionType::INTERNAL
393 ? android::DisplayConnectionType::Internal
394 : android::DisplayConnectionType::External;
Dan Stoza651bf312015-10-23 17:03:17 -0700395 return Error::None;
396}
397
Peiyong Lined531a32018-10-26 18:27:56 -0700398Error Display::supportsDoze(bool* outSupport) const {
399 *outSupport = mDisplayCapabilities.count(DisplayCapability::Doze) > 0;
Dan Stoza651bf312015-10-23 17:03:17 -0700400 return Error::None;
401}
402
Peiyong Lin62665892018-04-16 11:07:44 -0700403Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700404{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700405 float maxLuminance = -1.0f;
406 float maxAverageLuminance = -1.0f;
407 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700408 std::vector<Hwc2::Hdr> types;
409 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800410 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800411 auto error = static_cast<HWC2::Error>(intError);
412
Dan Stoza7d7ae732016-03-16 12:23:40 -0700413 if (error != Error::None) {
414 return error;
415 }
416
Peiyong Lin62665892018-04-16 11:07:44 -0700417 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700418 maxLuminance, maxAverageLuminance, minLuminance);
419 return Error::None;
420}
421
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700422Error Display::getDisplayedContentSamplingAttributes(PixelFormat* outFormat,
423 Dataspace* outDataspace,
424 uint8_t* outComponentMask) const {
425 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
426 outComponentMask);
427 return static_cast<Error>(intError);
428}
429
Kevin DuBois74e53772018-11-19 10:52:38 -0800430Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
431 uint64_t maxFrames) const {
432 auto intError =
433 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
434 return static_cast<Error>(intError);
435}
436
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700437Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
438 android::DisplayedFrameStats* outStats) const {
439 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
440 return static_cast<Error>(intError);
441}
442
Lloyd Pique35d58242018-12-18 16:33:25 -0800443Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800444 std::vector<Hwc2::Layer> layerIds;
445 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700446 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800447 auto error = static_cast<Error>(intError);
448 uint32_t numElements = layerIds.size();
Dan Stoza651bf312015-10-23 17:03:17 -0700449 if (error != Error::None) {
450 return error;
451 }
452
Lloyd Pique35d58242018-12-18 16:33:25 -0800453 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700454 releaseFences.reserve(numElements);
455 for (uint32_t element = 0; element < numElements; ++element) {
456 auto layer = getLayerById(layerIds[element]);
457 if (layer) {
458 sp<Fence> fence(new Fence(fenceFds[element]));
Steven Thomas94e35b92017-07-26 18:48:28 -0700459 releaseFences.emplace(layer, fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700460 } else {
461 ALOGE("getReleaseFences: invalid layer %" PRIu64
462 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700463 for (; element < numElements; ++element) {
464 close(fenceFds[element]);
465 }
Dan Stoza651bf312015-10-23 17:03:17 -0700466 return Error::BadLayer;
467 }
468 }
469
470 *outFences = std::move(releaseFences);
471 return Error::None;
472}
473
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800474Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700475{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400476 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700477 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700478 auto error = static_cast<Error>(intError);
479 if (error != Error::None) {
480 return error;
481 }
482
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800483 *outPresentFence = new Fence(presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700484 return Error::None;
485}
486
Ady Abraham7159f572019-10-11 11:10:18 -0700487Error Display::setActiveConfigWithConstraints(
488 const std::shared_ptr<const HWC2::Display::Config>& config,
489 const VsyncPeriodChangeConstraints& constraints, VsyncPeriodChangeTimeline* outTimeline) {
490 ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId);
491 if (config->getDisplayId() != mId) {
492 ALOGE("setActiveConfigWithConstraints received config %u for the wrong display %" PRIu64
493 " (expected %" PRIu64 ")",
494 config->getId(), config->getDisplayId(), mId);
495 return Error::BadConfig;
496 }
497
498 if (isVsyncPeriodSwitchSupported()) {
499 Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints;
500 hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos;
501 hwc2Constraints.seamlessRequired = constraints.seamlessRequired;
502
503 Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {};
504 auto intError =
505 mComposer.setActiveConfigWithConstraints(mId, config->getId(), hwc2Constraints,
506 &vsyncPeriodChangeTimeline);
507 outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos;
508 outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired;
509 outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos;
510 return static_cast<Error>(intError);
511 }
512
513 // Use legacy setActiveConfig instead
514 ALOGV("fallback to legacy setActiveConfig");
515 const auto now = systemTime();
516 if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) {
517 ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied");
518 }
519
520 auto intError_2_4 = mComposer.setActiveConfig(mId, config->getId());
521 outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos);
522 outTimeline->refreshRequired = true;
523 outTimeline->refreshTimeNanos = now;
524 return static_cast<Error>(intError_2_4);
525}
526
Dan Stoza651bf312015-10-23 17:03:17 -0700527Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
528{
529 if (config->getDisplayId() != mId) {
530 ALOGE("setActiveConfig received config %u for the wrong display %"
531 PRIu64 " (expected %" PRIu64 ")", config->getId(),
532 config->getDisplayId(), mId);
533 return Error::BadConfig;
534 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700535 auto intError = mComposer.setActiveConfig(mId, config->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700536 return static_cast<Error>(intError);
537}
538
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400539Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700540 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700541{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700542 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700543 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700544 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700545 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700546 return static_cast<Error>(intError);
547}
548
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700549Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700550{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700551 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700552 return static_cast<Error>(intError);
553}
554
Dan Stoza5df2a862016-03-24 16:19:37 -0700555Error Display::setColorTransform(const android::mat4& matrix,
556 android_color_transform_t hint)
557{
Steven Thomas94e35b92017-07-26 18:48:28 -0700558 auto intError = mComposer.setColorTransform(mId,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800559 matrix.asArray(), static_cast<Hwc2::ColorTransform>(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
578 if (mode == PowerMode::On) {
579 std::call_once(mDisplayCapabilityQueryFlag, [this]() {
580 std::vector<Hwc2::DisplayCapability> tmpCapabilities;
581 auto error =
582 static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
583 if (error == Error::None) {
584 for (auto capability : tmpCapabilities) {
585 mDisplayCapabilities.emplace(static_cast<DisplayCapability>(capability));
586 }
587 } else if (error == Error::Unsupported) {
588 if (mCapabilities.count(Capability::SkipClientColorTransform)) {
589 mDisplayCapabilities.emplace(DisplayCapability::SkipClientColorTransform);
590 }
591 bool dozeSupport = false;
592 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
593 if (error == Error::None && dozeSupport) {
594 mDisplayCapabilities.emplace(DisplayCapability::Doze);
595 }
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);
616 if (error != Error::None && error != Error::HasChanges) {
617 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);
634 if (error != Error::None && error != Error::HasChanges) {
635 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
Dan Gittik57e63c52019-01-18 16:37:54 +0000649Error Display::setDisplayBrightness(float brightness) const {
650 auto intError = mComposer.setDisplayBrightness(mId, brightness);
651 return static_cast<Error>(intError);
652}
653
Galia Peycheva5492cb52019-10-30 14:13:16 +0100654Error Display::setAutoLowLatencyMode(bool on) const {
655 auto intError = mComposer.setAutoLowLatencyMode(mId, on);
656 return static_cast<Error>(intError);
657}
658
659Error Display::getSupportedContentTypes(std::vector<ContentType>* outSupportedContentTypes) const {
660 std::vector<Hwc2::IComposerClient::ContentType> tmpSupportedContentTypes;
661 auto intError = mComposer.getSupportedContentTypes(mId, &tmpSupportedContentTypes);
662 for (Hwc2::IComposerClient::ContentType contentType : tmpSupportedContentTypes) {
663 outSupportedContentTypes->push_back(static_cast<ContentType>(contentType));
664 }
665 return static_cast<Error>(intError);
666}
667
668Error Display::setContentType(ContentType contentType) const {
669 using Hwc2_ContentType = Hwc2::IComposerClient::ContentType;
670 auto intError = mComposer.setContentType(mId, static_cast<Hwc2_ContentType>(contentType));
671 return static_cast<Error>(intError);
672}
673
Dan Stoza651bf312015-10-23 17:03:17 -0700674// For use by Device
675
Steven Thomas94e35b92017-07-26 18:48:28 -0700676void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800677 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700678 mComposer.setClientTargetSlotCount(mId);
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800679 if (mType == DisplayType::Physical) {
680 loadConfigs();
681 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700682 }
683 mIsConnected = connected;
684}
685
Dan Stoza651bf312015-10-23 17:03:17 -0700686int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
687{
688 int32_t value = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700689 auto intError = mComposer.getDisplayAttribute(mId, configId,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800690 static_cast<Hwc2::IComposerClient::Attribute>(attribute),
691 &value);
Dan Stoza651bf312015-10-23 17:03:17 -0700692 auto error = static_cast<Error>(intError);
693 if (error != Error::None) {
694 ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
695 configId, to_string(attribute).c_str(),
696 to_string(error).c_str(), intError);
697 return -1;
698 }
699 return value;
700}
701
702void Display::loadConfig(hwc2_config_t configId)
703{
704 ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
705
706 auto config = Config::Builder(*this, configId)
Ady Abraham7159f572019-10-11 11:10:18 -0700707 .setWidth(getAttribute(configId, Attribute::Width))
708 .setHeight(getAttribute(configId, Attribute::Height))
709 .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod))
710 .setDpiX(getAttribute(configId, Attribute::DpiX))
711 .setDpiY(getAttribute(configId, Attribute::DpiY))
712 .setConfigGroup(getAttribute(configId, Attribute::ConfigGroup))
713 .build();
Dan Stoza651bf312015-10-23 17:03:17 -0700714 mConfigs.emplace(configId, std::move(config));
715}
716
717void Display::loadConfigs()
718{
719 ALOGV("[%" PRIu64 "] loadConfigs", mId);
720
Chia-I Wuaab99f52016-10-05 12:59:58 +0800721 std::vector<Hwc2::Config> configIds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700722 auto intError = mComposer.getDisplayConfigs(mId, &configIds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800723 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700724 if (error != Error::None) {
725 ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
726 to_string(error).c_str(), intError);
727 return;
728 }
729
730 for (auto configId : configIds) {
731 loadConfig(configId);
732 }
733}
734
Dan Stoza651bf312015-10-23 17:03:17 -0700735// Other Display methods
736
Lloyd Pique35d58242018-12-18 16:33:25 -0800737HWC2::Layer* Display::getLayerById(hwc2_layer_t id) const {
Dan Stoza651bf312015-10-23 17:03:17 -0700738 if (mLayers.count(id) == 0) {
739 return nullptr;
740 }
741
Steven Thomas94e35b92017-07-26 18:48:28 -0700742 return mLayers.at(id).get();
Dan Stoza651bf312015-10-23 17:03:17 -0700743}
Ana Krulec4593b692019-01-11 22:07:25 -0800744} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700745
746// Layer methods
747
Lloyd Pique35d58242018-12-18 16:33:25 -0800748Layer::~Layer() = default;
749
750namespace impl {
751
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700752Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Steven Thomas94e35b92017-07-26 18:48:28 -0700753 hwc2_display_t displayId, hwc2_layer_t layerId)
754 : mComposer(composer),
755 mCapabilities(capabilities),
756 mDisplayId(displayId),
Peiyong Lin698147a2018-09-14 13:27:18 -0700757 mId(layerId),
758 mColorMatrix(android::mat4())
Dan Stoza651bf312015-10-23 17:03:17 -0700759{
Steven Thomas94e35b92017-07-26 18:48:28 -0700760 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700761}
762
763Layer::~Layer()
764{
Steven Thomas94e35b92017-07-26 18:48:28 -0700765 auto intError = mComposer.destroyLayer(mDisplayId, mId);
766 auto error = static_cast<Error>(intError);
767 ALOGE_IF(error != Error::None, "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
768 " failed: %s (%d)", mDisplayId, mId, to_string(error).c_str(),
769 intError);
Steven Thomas94e35b92017-07-26 18:48:28 -0700770}
771
Dan Stoza651bf312015-10-23 17:03:17 -0700772Error Layer::setCursorPosition(int32_t x, int32_t y)
773{
Steven Thomas94e35b92017-07-26 18:48:28 -0700774 auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700775 return static_cast<Error>(intError);
776}
777
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400778Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700779 const sp<Fence>& acquireFence)
780{
Yichi Chen8366f562019-03-25 19:44:06 +0800781 if (buffer == nullptr && mBufferSlot == slot) {
782 return Error::None;
783 }
784 mBufferSlot = slot;
785
Dan Stoza651bf312015-10-23 17:03:17 -0700786 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700787 auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
788 fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700789 return static_cast<Error>(intError);
790}
791
792Error Layer::setSurfaceDamage(const Region& damage)
793{
Yichi Chen8366f562019-03-25 19:44:06 +0800794 if (damage.isRect() && mDamageRegion.isRect() &&
795 (damage.getBounds() == mDamageRegion.getBounds())) {
796 return Error::None;
797 }
798 mDamageRegion = damage;
799
Dan Stoza651bf312015-10-23 17:03:17 -0700800 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
801 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800802 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700803 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700804 intError = mComposer.setLayerSurfaceDamage(mDisplayId,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800805 mId, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700806 } else {
807 size_t rectCount = 0;
808 auto rectArray = damage.getArray(&rectCount);
809
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800810 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700811 for (size_t rect = 0; rect < rectCount; ++rect) {
812 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
813 rectArray[rect].right, rectArray[rect].bottom});
814 }
815
Steven Thomas94e35b92017-07-26 18:48:28 -0700816 intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700817 }
818
819 return static_cast<Error>(intError);
820}
821
822Error Layer::setBlendMode(BlendMode mode)
823{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800824 auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700825 auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700826 return static_cast<Error>(intError);
827}
828
829Error Layer::setColor(hwc_color_t color)
830{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800831 Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
Steven Thomas94e35b92017-07-26 18:48:28 -0700832 auto intError = mComposer.setLayerColor(mDisplayId, mId, hwcColor);
Dan Stoza651bf312015-10-23 17:03:17 -0700833 return static_cast<Error>(intError);
834}
835
836Error Layer::setCompositionType(Composition type)
837{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800838 auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
Steven Thomas94e35b92017-07-26 18:48:28 -0700839 auto intError = mComposer.setLayerCompositionType(
840 mDisplayId, mId, intType);
Dan Stoza651bf312015-10-23 17:03:17 -0700841 return static_cast<Error>(intError);
842}
843
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700844Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700845{
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600846 if (dataspace == mDataSpace) {
847 return Error::None;
848 }
849 mDataSpace = dataspace;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700850 auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700851 return static_cast<Error>(intError);
852}
853
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700854Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
855 const android::HdrMetadata& metadata)
856{
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700857 if (metadata == mHdrMetadata) {
858 return Error::None;
859 }
860
861 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700862 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
863 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
864 if (validTypes & HdrMetadata::SMPTE2086) {
865 perFrameMetadatas.insert(perFrameMetadatas.end(),
866 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800867 mHdrMetadata.smpte2086.displayPrimaryRed.x},
868 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
869 mHdrMetadata.smpte2086.displayPrimaryRed.y},
870 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
871 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
872 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
873 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
874 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
875 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
876 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
877 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
878 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
879 mHdrMetadata.smpte2086.whitePoint.x},
880 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
881 mHdrMetadata.smpte2086.whitePoint.y},
882 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
883 mHdrMetadata.smpte2086.maxLuminance},
884 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
885 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700886 }
887
888 if (validTypes & HdrMetadata::CTA861_3) {
889 perFrameMetadatas.insert(perFrameMetadatas.end(),
890 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800891 mHdrMetadata.cta8613.maxContentLightLevel},
892 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
893 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700894 }
895
Valerie Haue9e843a2018-12-18 13:39:23 -0800896 Error error = static_cast<Error>(
897 mComposer.setLayerPerFrameMetadata(mDisplayId, mId, perFrameMetadatas));
898
899 if (validTypes & HdrMetadata::HDR10PLUS) {
900 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
901 perFrameMetadataBlobs.push_back(
902 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
903 Error setMetadataBlobsError = static_cast<Error>(
904 mComposer.setLayerPerFrameMetadataBlobs(mDisplayId, mId, perFrameMetadataBlobs));
905 if (error == Error::None) {
906 return setMetadataBlobsError;
907 }
908 }
909 return error;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700910}
911
Dan Stoza651bf312015-10-23 17:03:17 -0700912Error Layer::setDisplayFrame(const Rect& frame)
913{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800914 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800915 frame.right, frame.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700916 auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700917 return static_cast<Error>(intError);
918}
919
920Error Layer::setPlaneAlpha(float alpha)
921{
Steven Thomas94e35b92017-07-26 18:48:28 -0700922 auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700923 return static_cast<Error>(intError);
924}
925
926Error Layer::setSidebandStream(const native_handle_t* stream)
927{
Steven Thomas94e35b92017-07-26 18:48:28 -0700928 if (mCapabilities.count(Capability::SidebandStream) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700929 ALOGE("Attempted to call setSidebandStream without checking that the "
930 "device supports sideband streams");
931 return Error::Unsupported;
932 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700933 auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700934 return static_cast<Error>(intError);
935}
936
937Error Layer::setSourceCrop(const FloatRect& crop)
938{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800939 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800940 crop.left, crop.top, crop.right, crop.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700941 auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700942 return static_cast<Error>(intError);
943}
944
945Error Layer::setTransform(Transform transform)
946{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800947 auto intTransform = static_cast<Hwc2::Transform>(transform);
Steven Thomas94e35b92017-07-26 18:48:28 -0700948 auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700949 return static_cast<Error>(intError);
950}
951
952Error Layer::setVisibleRegion(const Region& region)
953{
Yichi Chen8366f562019-03-25 19:44:06 +0800954 if (region.isRect() && mVisibleRegion.isRect() &&
955 (region.getBounds() == mVisibleRegion.getBounds())) {
956 return Error::None;
957 }
958 mVisibleRegion = region;
959
Dan Stoza651bf312015-10-23 17:03:17 -0700960 size_t rectCount = 0;
961 auto rectArray = region.getArray(&rectCount);
962
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800963 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700964 for (size_t rect = 0; rect < rectCount; ++rect) {
965 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
966 rectArray[rect].right, rectArray[rect].bottom});
967 }
968
Steven Thomas94e35b92017-07-26 18:48:28 -0700969 auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700970 return static_cast<Error>(intError);
971}
972
973Error Layer::setZOrder(uint32_t z)
974{
Steven Thomas94e35b92017-07-26 18:48:28 -0700975 auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700976 return static_cast<Error>(intError);
977}
978
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500979Error Layer::setInfo(uint32_t type, uint32_t appId)
980{
Steven Thomas94e35b92017-07-26 18:48:28 -0700981 auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500982 return static_cast<Error>(intError);
983}
984
Peiyong Lin698147a2018-09-14 13:27:18 -0700985// Composer HAL 2.3
986Error Layer::setColorTransform(const android::mat4& matrix) {
987 if (matrix == mColorMatrix) {
988 return Error::None;
989 }
Peiyong Lin698147a2018-09-14 13:27:18 -0700990 auto intError = mComposer.setLayerColorTransform(mDisplayId, mId, matrix.asArray());
Peiyong Lin04d25872019-04-18 10:26:19 -0700991 Error error = static_cast<Error>(intError);
992 if (error != Error::None) {
993 return error;
994 }
995 mColorMatrix = matrix;
996 return error;
Peiyong Lin698147a2018-09-14 13:27:18 -0700997}
Lloyd Pique35d58242018-12-18 16:33:25 -0800998
999} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -07001000} // namespace HWC2
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001001
1002// TODO(b/129481165): remove the #pragma below and fix conversion issues
1003#pragma clang diagnostic pop // ignored "-Wconversion"