blob: e21b0daa9611c8f6a5d498bb3c7219f1c2c672d8 [file] [log] [blame]
Dan Stoza651bf312015-10-23 17:03:17 -07001/*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Dan Stoza651bf312015-10-23 17:03:17 -070021// #define LOG_NDEBUG 0
22
23#undef LOG_TAG
24#define LOG_TAG "HWC2"
25#define ATRACE_TAG ATRACE_TAG_GRAPHICS
26
27#include "HWC2.h"
28
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080029#include <android/configuration.h>
30#include <ftl/future.h>
Dan Stoza651bf312015-10-23 17:03:17 -070031#include <ui/Fence.h>
Dan Stoza5a423ea2017-02-16 14:10:39 -080032#include <ui/FloatRect.h>
Dan Stoza651bf312015-10-23 17:03:17 -070033#include <ui/GraphicBuffer.h>
Dan Stoza651bf312015-10-23 17:03:17 -070034
Lloyd Pique3c085a02018-05-09 19:38:32 -070035#include <algorithm>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080036#include <cinttypes>
Lloyd Pique3c085a02018-05-09 19:38:32 -070037#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 "ComposerHal.h"
41
Peiyong Line9d809e2020-04-14 13:10:48 -070042namespace android {
43
Dan Stoza651bf312015-10-23 17:03:17 -070044using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080045using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070046using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070047using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070048using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070049using android::Rect;
50using android::Region;
51using android::sp;
52
53namespace HWC2 {
54
Peiyong Line9d809e2020-04-14 13:10:48 -070055using namespace android::hardware::graphics::composer::hal;
56
Chia-I Wuaab99f52016-10-05 12:59:58 +080057namespace Hwc2 = android::Hwc2;
58
Steven Thomas94e35b92017-07-26 18:48:28 -070059namespace {
60
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070061inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
62 const Hwc2::PerFrameMetadataKey& key) {
63 return keys.find(key) != keys.end();
64}
65
Steven Thomas94e35b92017-07-26 18:48:28 -070066} // namespace anonymous
67
Dan Stoza651bf312015-10-23 17:03:17 -070068// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -080069Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -070070
Ana Krulec4593b692019-01-11 22:07:25 -080071namespace impl {
Dominik Laskowski55c85402020-01-21 16:25:47 -080072
Peiyong Lin74ca2f42019-01-14 19:36:57 -080073Display::Display(android::Hwc2::Composer& composer,
Peiyong Line9d809e2020-04-14 13:10:48 -070074 const std::unordered_set<Capability>& capabilities, HWDisplayId id,
Lloyd Piquebc792092018-01-17 11:52:30 -080075 DisplayType type)
Peiyong Line9d809e2020-04-14 13:10:48 -070076 : mComposer(composer), mCapabilities(capabilities), mId(id), mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -070077 ALOGV("Created display %" PRIu64, id);
78}
79
Steven Thomas94e35b92017-07-26 18:48:28 -070080Display::~Display() {
Lloyd Piquea516c002021-05-07 14:36:58 -070081 // Note: The calls to onOwningDisplayDestroyed() are allowed (and expected)
82 // to call Display::onLayerDestroyed(). As that call removes entries from
83 // mLayers, we do not want to have a for loop directly over it here. Since
84 // the end goal is an empty mLayers anyway, we just go ahead and swap an
85 // initially empty local container with mLayers, and then enumerate
86 // the contents of the local container.
87 Layers destroyingLayers;
88 std::swap(mLayers, destroyingLayers);
89 for (const auto& [_, weakLayer] : destroyingLayers) {
90 if (std::shared_ptr layer = weakLayer.lock()) {
91 layer->onOwningDisplayDestroyed();
92 }
93 }
Steven Thomas94e35b92017-07-26 18:48:28 -070094
Peiyong Line9d809e2020-04-14 13:10:48 -070095 Error error = Error::NONE;
Dominik Laskowski55c85402020-01-21 16:25:47 -080096 const char* msg;
97 switch (mType) {
Peiyong Line9d809e2020-04-14 13:10:48 -070098 case DisplayType::PHYSICAL:
99 error = setVsyncEnabled(HWC2::Vsync::DISABLE);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800100 msg = "disable VSYNC for";
101 break;
102
Peiyong Line9d809e2020-04-14 13:10:48 -0700103 case DisplayType::VIRTUAL:
Dominik Laskowski55c85402020-01-21 16:25:47 -0800104 error = static_cast<Error>(mComposer.destroyVirtualDisplay(mId));
105 msg = "destroy virtual";
106 break;
107
Peiyong Line9d809e2020-04-14 13:10:48 -0700108 case DisplayType::INVALID: // Used in unit tests.
Dominik Laskowski55c85402020-01-21 16:25:47 -0800109 break;
Dan Stoza651bf312015-10-23 17:03:17 -0700110 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800111
Peiyong Line9d809e2020-04-14 13:10:48 -0700112 ALOGE_IF(error != Error::NONE, "%s: Failed to %s display %" PRIu64 ": %d", __FUNCTION__, msg,
113 mId, static_cast<int32_t>(error));
Dominik Laskowski55c85402020-01-21 16:25:47 -0800114
115 ALOGV("Destroyed display %" PRIu64, mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700116}
117
Dan Stoza651bf312015-10-23 17:03:17 -0700118// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700119Error Display::acceptChanges()
120{
Steven Thomas94e35b92017-07-26 18:48:28 -0700121 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700122 return static_cast<Error>(intError);
123}
124
Lloyd Piquea516c002021-05-07 14:36:58 -0700125base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700126 HWLayerId layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700127 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700128 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700129 if (error != Error::NONE) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700130 return base::unexpected(error);
Dan Stoza651bf312015-10-23 17:03:17 -0700131 }
132
Lloyd Piquea516c002021-05-07 14:36:58 -0700133 auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);
134 mLayers.emplace(layerId, layer);
135 return layer;
Steven Thomas94e35b92017-07-26 18:48:28 -0700136}
137
Lloyd Piquea516c002021-05-07 14:36:58 -0700138void Display::onLayerDestroyed(hal::HWLayerId layerId) {
139 mLayers.erase(layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700140}
141
Ady Abraham7159f572019-10-11 11:10:18 -0700142bool Display::isVsyncPeriodSwitchSupported() const {
143 ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId);
144
145 return mComposer.isVsyncPeriodSwitchSupported();
146}
147
Lloyd Pique35d58242018-12-18 16:33:25 -0800148Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800149 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800150 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700151 auto intError = mComposer.getChangedCompositionTypes(
152 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800153 uint32_t numElements = layerIds.size();
154 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700155 error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700156 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700157 return error;
158 }
159
160 outTypes->clear();
161 outTypes->reserve(numElements);
162 for (uint32_t element = 0; element < numElements; ++element) {
163 auto layer = getLayerById(layerIds[element]);
164 if (layer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700165 auto type = types[element];
Dan Stoza651bf312015-10-23 17:03:17 -0700166 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
167 layer->getId(), to_string(type).c_str());
Lloyd Piquea516c002021-05-07 14:36:58 -0700168 outTypes->emplace(layer.get(), type);
Dan Stoza651bf312015-10-23 17:03:17 -0700169 } else {
170 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
171 " on display %" PRIu64, layerIds[element], mId);
172 }
173 }
174
Peiyong Line9d809e2020-04-14 13:10:48 -0700175 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700176}
177
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700178Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700179{
Peiyong Linfd997e02018-03-28 15:29:00 -0700180 auto intError = mComposer.getColorModes(mId, outModes);
181 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700182}
183
Chia-I Wud7e01d72018-06-21 13:39:09 +0800184int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700185{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800186 int32_t supportedPerFrameMetadata = 0;
187
188 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
189 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700190
191 // Check whether a specific metadata type is supported. A metadata type is considered
192 // supported if and only if all required fields are supported.
193
194 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700195 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
196 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
197 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
198 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
199 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
200 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
201 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
202 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
203 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
204 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800205 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700206 }
207 // CTA861_3
208 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
209 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800210 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700211 }
212
Valerie Haue9e843a2018-12-18 13:39:23 -0800213 // HDR10PLUS
214 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
215 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
216 }
217
Chia-I Wud7e01d72018-06-21 13:39:09 +0800218 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700219}
220
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700221Error Display::getRenderIntents(ColorMode colorMode,
222 std::vector<RenderIntent>* outRenderIntents) const
223{
224 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
225 return static_cast<Error>(intError);
226}
227
228Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
229{
230 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
231 return static_cast<Error>(intError);
232}
233
Dan Stoza651bf312015-10-23 17:03:17 -0700234Error Display::getName(std::string* outName) const
235{
Steven Thomas94e35b92017-07-26 18:48:28 -0700236 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800237 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700238}
239
240Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800241 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Lloyd Piquee9eff972020-05-05 12:36:44 -0700242 uint32_t intDisplayRequests = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800243 std::vector<Hwc2::Layer> layerIds;
244 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700245 auto intError = mComposer.getDisplayRequests(
246 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800247 uint32_t numElements = layerIds.size();
248 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700249 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700250 return error;
251 }
252
253 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
254 outLayerRequests->clear();
255 outLayerRequests->reserve(numElements);
256 for (uint32_t element = 0; element < numElements; ++element) {
257 auto layer = getLayerById(layerIds[element]);
258 if (layer) {
259 auto layerRequest =
260 static_cast<LayerRequest>(layerRequests[element]);
Lloyd Piquea516c002021-05-07 14:36:58 -0700261 outLayerRequests->emplace(layer.get(), layerRequest);
Dan Stoza651bf312015-10-23 17:03:17 -0700262 } else {
263 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
264 PRIu64, layerIds[element], mId);
265 }
266 }
267
Peiyong Line9d809e2020-04-14 13:10:48 -0700268 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700269}
270
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100271Error Display::getConnectionType(ui::DisplayConnectionType* outType) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700272 if (mType != DisplayType::PHYSICAL) return Error::BAD_DISPLAY;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800273
274 using ConnectionType = Hwc2::IComposerClient::DisplayConnectionType;
275 ConnectionType connectionType;
276 const auto error = static_cast<Error>(mComposer.getDisplayConnectionType(mId, &connectionType));
Peiyong Line9d809e2020-04-14 13:10:48 -0700277 if (error != Error::NONE) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800278 return error;
279 }
280
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100281 *outType = connectionType == ConnectionType::INTERNAL ? ui::DisplayConnectionType::Internal
282 : ui::DisplayConnectionType::External;
Peiyong Line9d809e2020-04-14 13:10:48 -0700283 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700284}
285
Ady Abraham27fbcc72021-09-20 14:54:57 -0700286bool Display::hasCapability(hal::DisplayCapability capability) const {
287 std::scoped_lock lock(mDisplayCapabilitiesMutex);
288 if (mDisplayCapabilities) {
289 return mDisplayCapabilities->count(capability) > 0;
290 }
291
292 ALOGW("Can't query capability %d."
293 " Display Capabilities were not queried from HWC yet",
294 static_cast<int>(capability));
295
296 return false;
297}
298
Peiyong Lined531a32018-10-26 18:27:56 -0700299Error Display::supportsDoze(bool* outSupport) const {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700300 *outSupport = hasCapability(DisplayCapability::DOZE);
Peiyong Line9d809e2020-04-14 13:10:48 -0700301 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700302}
303
Peiyong Lin62665892018-04-16 11:07:44 -0700304Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700305{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700306 float maxLuminance = -1.0f;
307 float maxAverageLuminance = -1.0f;
308 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700309 std::vector<Hwc2::Hdr> types;
310 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800311 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800312 auto error = static_cast<HWC2::Error>(intError);
313
Peiyong Line9d809e2020-04-14 13:10:48 -0700314 if (error != Error::NONE) {
Dan Stoza7d7ae732016-03-16 12:23:40 -0700315 return error;
316 }
317
Peiyong Lin62665892018-04-16 11:07:44 -0700318 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700319 maxLuminance, maxAverageLuminance, minLuminance);
Peiyong Line9d809e2020-04-14 13:10:48 -0700320 return Error::NONE;
Dan Stoza7d7ae732016-03-16 12:23:40 -0700321}
322
Peiyong Line9d809e2020-04-14 13:10:48 -0700323Error Display::getDisplayedContentSamplingAttributes(hal::PixelFormat* outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700324 Dataspace* outDataspace,
325 uint8_t* outComponentMask) const {
326 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
327 outComponentMask);
328 return static_cast<Error>(intError);
329}
330
Kevin DuBois74e53772018-11-19 10:52:38 -0800331Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
332 uint64_t maxFrames) const {
333 auto intError =
334 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
335 return static_cast<Error>(intError);
336}
337
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700338Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
339 android::DisplayedFrameStats* outStats) const {
340 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
341 return static_cast<Error>(intError);
342}
343
Lloyd Pique35d58242018-12-18 16:33:25 -0800344Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800345 std::vector<Hwc2::Layer> layerIds;
346 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700347 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800348 auto error = static_cast<Error>(intError);
349 uint32_t numElements = layerIds.size();
Peiyong Line9d809e2020-04-14 13:10:48 -0700350 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700351 return error;
352 }
353
Lloyd Pique35d58242018-12-18 16:33:25 -0800354 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700355 releaseFences.reserve(numElements);
356 for (uint32_t element = 0; element < numElements; ++element) {
357 auto layer = getLayerById(layerIds[element]);
358 if (layer) {
359 sp<Fence> fence(new Fence(fenceFds[element]));
Lloyd Piquea516c002021-05-07 14:36:58 -0700360 releaseFences.emplace(layer.get(), fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700361 } else {
362 ALOGE("getReleaseFences: invalid layer %" PRIu64
363 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700364 for (; element < numElements; ++element) {
365 close(fenceFds[element]);
366 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700367 return Error::BAD_LAYER;
Dan Stoza651bf312015-10-23 17:03:17 -0700368 }
369 }
370
371 *outFences = std::move(releaseFences);
Peiyong Line9d809e2020-04-14 13:10:48 -0700372 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700373}
374
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800375Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700376{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400377 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700378 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700379 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700380 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700381 return error;
382 }
383
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800384 *outPresentFence = new Fence(presentFenceFd);
Peiyong Line9d809e2020-04-14 13:10:48 -0700385 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700386}
387
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100388Error Display::setActiveConfigWithConstraints(hal::HWConfigId configId,
389 const VsyncPeriodChangeConstraints& constraints,
390 VsyncPeriodChangeTimeline* outTimeline) {
Ady Abraham7159f572019-10-11 11:10:18 -0700391 ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId);
Ady Abraham7159f572019-10-11 11:10:18 -0700392
393 if (isVsyncPeriodSwitchSupported()) {
394 Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints;
395 hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos;
396 hwc2Constraints.seamlessRequired = constraints.seamlessRequired;
397
398 Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {};
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100399 auto intError = mComposer.setActiveConfigWithConstraints(mId, configId, hwc2Constraints,
400 &vsyncPeriodChangeTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -0700401 outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos;
402 outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired;
403 outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos;
404 return static_cast<Error>(intError);
405 }
406
407 // Use legacy setActiveConfig instead
408 ALOGV("fallback to legacy setActiveConfig");
409 const auto now = systemTime();
410 if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) {
411 ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied");
412 }
413
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100414 auto intError_2_4 = mComposer.setActiveConfig(mId, configId);
Ady Abraham7159f572019-10-11 11:10:18 -0700415 outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos);
416 outTimeline->refreshRequired = true;
417 outTimeline->refreshTimeNanos = now;
418 return static_cast<Error>(intError_2_4);
419}
420
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400421Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700422 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700423{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700424 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700425 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700426 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700427 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700428 return static_cast<Error>(intError);
429}
430
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700431Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700432{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700433 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700434 return static_cast<Error>(intError);
435}
436
Peiyong Line9d809e2020-04-14 13:10:48 -0700437Error Display::setColorTransform(const android::mat4& matrix, ColorTransform hint) {
438 auto intError = mComposer.setColorTransform(mId, matrix.asArray(), hint);
Dan Stoza5df2a862016-03-24 16:19:37 -0700439 return static_cast<Error>(intError);
440}
441
Dan Stoza651bf312015-10-23 17:03:17 -0700442Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
443 const sp<Fence>& releaseFence)
444{
445 int32_t fenceFd = releaseFence->dup();
446 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700447 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700448 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700449 return static_cast<Error>(intError);
450}
451
452Error Display::setPowerMode(PowerMode mode)
453{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800454 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700455 auto intError = mComposer.setPowerMode(mId, intMode);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700456
Peiyong Line9d809e2020-04-14 13:10:48 -0700457 if (mode == PowerMode::ON) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700458 std::call_once(mDisplayCapabilityQueryFlag, [this]() {
459 std::vector<Hwc2::DisplayCapability> tmpCapabilities;
460 auto error =
461 static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
Peiyong Line9d809e2020-04-14 13:10:48 -0700462 if (error == Error::NONE) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700463 std::scoped_lock lock(mDisplayCapabilitiesMutex);
464 mDisplayCapabilities.emplace();
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700465 for (auto capability : tmpCapabilities) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700466 mDisplayCapabilities->emplace(static_cast<DisplayCapability>(capability));
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700467 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700468 } else if (error == Error::UNSUPPORTED) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700469 std::scoped_lock lock(mDisplayCapabilitiesMutex);
470 mDisplayCapabilities.emplace();
Peiyong Line9d809e2020-04-14 13:10:48 -0700471 if (mCapabilities.count(Capability::SKIP_CLIENT_COLOR_TRANSFORM)) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700472 mDisplayCapabilities->emplace(DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700473 }
474 bool dozeSupport = false;
475 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
Peiyong Line9d809e2020-04-14 13:10:48 -0700476 if (error == Error::NONE && dozeSupport) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700477 mDisplayCapabilities->emplace(DisplayCapability::DOZE);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700478 }
479 }
480 });
481 }
482
Dan Stoza651bf312015-10-23 17:03:17 -0700483 return static_cast<Error>(intError);
484}
485
486Error Display::setVsyncEnabled(Vsync enabled)
487{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800488 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700489 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700490 return static_cast<Error>(intError);
491}
492
493Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
494{
495 uint32_t numTypes = 0;
496 uint32_t numRequests = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700497 auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700498 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700499 if (error != Error::NONE && !hasChangesError(error)) {
Dan Stoza651bf312015-10-23 17:03:17 -0700500 return error;
501 }
502
503 *outNumTypes = numTypes;
504 *outNumRequests = numRequests;
505 return error;
506}
507
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700508Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
509 sp<android::Fence>* outPresentFence, uint32_t* state) {
510
511 uint32_t numTypes = 0;
512 uint32_t numRequests = 0;
513 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700514 auto intError = mComposer.presentOrValidateDisplay(
515 mId, &numTypes, &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700516 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700517 if (error != Error::NONE && !hasChangesError(error)) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700518 return error;
519 }
520
521 if (*state == 1) {
522 *outPresentFence = new Fence(presentFenceFd);
523 }
524
525 if (*state == 0) {
526 *outNumTypes = numTypes;
527 *outNumRequests = numRequests;
528 }
529 return error;
530}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700531
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700532std::future<Error> Display::setDisplayBrightness(float brightness) {
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800533 return ftl::defer([composer = &mComposer, id = mId, brightness] {
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700534 const auto intError = composer->setDisplayBrightness(id, brightness);
535 return static_cast<Error>(intError);
536 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000537}
538
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700539Error Display::setAutoLowLatencyMode(bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100540 auto intError = mComposer.setAutoLowLatencyMode(mId, on);
541 return static_cast<Error>(intError);
542}
543
544Error Display::getSupportedContentTypes(std::vector<ContentType>* outSupportedContentTypes) const {
545 std::vector<Hwc2::IComposerClient::ContentType> tmpSupportedContentTypes;
546 auto intError = mComposer.getSupportedContentTypes(mId, &tmpSupportedContentTypes);
547 for (Hwc2::IComposerClient::ContentType contentType : tmpSupportedContentTypes) {
548 outSupportedContentTypes->push_back(static_cast<ContentType>(contentType));
549 }
550 return static_cast<Error>(intError);
551}
552
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700553Error Display::setContentType(ContentType contentType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700554 auto intError = mComposer.setContentType(mId, contentType);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100555 return static_cast<Error>(intError);
556}
557
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700558Error Display::getClientTargetProperty(ClientTargetProperty* outClientTargetProperty) {
559 const auto error = mComposer.getClientTargetProperty(mId, outClientTargetProperty);
560 return static_cast<Error>(error);
561}
562
Dan Stoza651bf312015-10-23 17:03:17 -0700563// For use by Device
564
Steven Thomas94e35b92017-07-26 18:48:28 -0700565void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800566 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700567 mComposer.setClientTargetSlotCount(mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700568 }
569 mIsConnected = connected;
570}
571
Dan Stoza651bf312015-10-23 17:03:17 -0700572// Other Display methods
573
Lloyd Piquea516c002021-05-07 14:36:58 -0700574std::shared_ptr<HWC2::Layer> Display::getLayerById(HWLayerId id) const {
575 auto it = mLayers.find(id);
576 return it != mLayers.end() ? it->second.lock() : nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700577}
Ana Krulec4593b692019-01-11 22:07:25 -0800578} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700579
580// Layer methods
581
Lloyd Pique35d58242018-12-18 16:33:25 -0800582Layer::~Layer() = default;
583
584namespace impl {
585
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700586Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Lloyd Piquea516c002021-05-07 14:36:58 -0700587 HWC2::Display& display, HWLayerId layerId)
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800588 : mComposer(composer),
589 mCapabilities(capabilities),
Lloyd Piquea516c002021-05-07 14:36:58 -0700590 mDisplay(&display),
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800591 mId(layerId),
592 mColorMatrix(android::mat4()) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700593 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, display.getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700594}
595
596Layer::~Layer()
597{
Lloyd Piquea516c002021-05-07 14:36:58 -0700598 onOwningDisplayDestroyed();
599}
600
601void Layer::onOwningDisplayDestroyed() {
602 // Note: onOwningDisplayDestroyed() may be called to perform cleanup by
603 // either the Layer dtor or by the Display dtor and must be safe to call
604 // from either path. In particular, the call to Display::onLayerDestroyed()
605 // is expected to be safe to do,
606
607 if (CC_UNLIKELY(!mDisplay)) {
608 return;
609 }
610
611 mDisplay->onLayerDestroyed(mId);
612
613 // Note: If the HWC display was actually disconnected, these calls are will
614 // return an error. We always make them as there may be other reasons for
615 // the HWC2::Display to be destroyed.
616 auto intError = mComposer.destroyLayer(mDisplay->getId(), mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700617 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700618 ALOGE_IF(error != Error::NONE,
619 "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
620 " failed: %s (%d)",
Lloyd Piquea516c002021-05-07 14:36:58 -0700621 mDisplay->getId(), mId, to_string(error).c_str(), intError);
622
623 mDisplay = nullptr;
Steven Thomas94e35b92017-07-26 18:48:28 -0700624}
625
Dan Stoza651bf312015-10-23 17:03:17 -0700626Error Layer::setCursorPosition(int32_t x, int32_t y)
627{
Lloyd Piquea516c002021-05-07 14:36:58 -0700628 if (CC_UNLIKELY(!mDisplay)) {
629 return Error::BAD_DISPLAY;
630 }
631
632 auto intError = mComposer.setCursorPosition(mDisplay->getId(), mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700633 return static_cast<Error>(intError);
634}
635
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400636Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700637 const sp<Fence>& acquireFence)
638{
Lloyd Piquea516c002021-05-07 14:36:58 -0700639 if (CC_UNLIKELY(!mDisplay)) {
640 return Error::BAD_DISPLAY;
641 }
642
Yichi Chen8366f562019-03-25 19:44:06 +0800643 if (buffer == nullptr && mBufferSlot == slot) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700644 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800645 }
646 mBufferSlot = slot;
647
Dan Stoza651bf312015-10-23 17:03:17 -0700648 int32_t fenceFd = acquireFence->dup();
Lloyd Piquea516c002021-05-07 14:36:58 -0700649 auto intError = mComposer.setLayerBuffer(mDisplay->getId(), mId, slot, buffer, fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700650 return static_cast<Error>(intError);
651}
652
653Error Layer::setSurfaceDamage(const Region& damage)
654{
Lloyd Piquea516c002021-05-07 14:36:58 -0700655 if (CC_UNLIKELY(!mDisplay)) {
656 return Error::BAD_DISPLAY;
657 }
658
Yichi Chen8366f562019-03-25 19:44:06 +0800659 if (damage.isRect() && mDamageRegion.isRect() &&
660 (damage.getBounds() == mDamageRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700661 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800662 }
663 mDamageRegion = damage;
664
Dan Stoza651bf312015-10-23 17:03:17 -0700665 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
666 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800667 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700668 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700669 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId,
670 std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700671 } else {
672 size_t rectCount = 0;
673 auto rectArray = damage.getArray(&rectCount);
674
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800675 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700676 for (size_t rect = 0; rect < rectCount; ++rect) {
677 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
678 rectArray[rect].right, rectArray[rect].bottom});
679 }
680
Lloyd Piquea516c002021-05-07 14:36:58 -0700681 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700682 }
683
684 return static_cast<Error>(intError);
685}
686
687Error Layer::setBlendMode(BlendMode mode)
688{
Lloyd Piquea516c002021-05-07 14:36:58 -0700689 if (CC_UNLIKELY(!mDisplay)) {
690 return Error::BAD_DISPLAY;
691 }
692
693 auto intError = mComposer.setLayerBlendMode(mDisplay->getId(), mId, mode);
Dan Stoza651bf312015-10-23 17:03:17 -0700694 return static_cast<Error>(intError);
695}
696
Peiyong Line9d809e2020-04-14 13:10:48 -0700697Error Layer::setColor(Color color) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700698 if (CC_UNLIKELY(!mDisplay)) {
699 return Error::BAD_DISPLAY;
700 }
701
702 auto intError = mComposer.setLayerColor(mDisplay->getId(), mId, color);
Dan Stoza651bf312015-10-23 17:03:17 -0700703 return static_cast<Error>(intError);
704}
705
706Error Layer::setCompositionType(Composition type)
707{
Lloyd Piquea516c002021-05-07 14:36:58 -0700708 if (CC_UNLIKELY(!mDisplay)) {
709 return Error::BAD_DISPLAY;
710 }
711
712 auto intError = mComposer.setLayerCompositionType(mDisplay->getId(), mId, type);
Dan Stoza651bf312015-10-23 17:03:17 -0700713 return static_cast<Error>(intError);
714}
715
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700716Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700717{
Lloyd Piquea516c002021-05-07 14:36:58 -0700718 if (CC_UNLIKELY(!mDisplay)) {
719 return Error::BAD_DISPLAY;
720 }
721
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600722 if (dataspace == mDataSpace) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700723 return Error::NONE;
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600724 }
725 mDataSpace = dataspace;
Lloyd Piquea516c002021-05-07 14:36:58 -0700726 auto intError = mComposer.setLayerDataspace(mDisplay->getId(), mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700727 return static_cast<Error>(intError);
728}
729
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700730Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
731 const android::HdrMetadata& metadata)
732{
Lloyd Piquea516c002021-05-07 14:36:58 -0700733 if (CC_UNLIKELY(!mDisplay)) {
734 return Error::BAD_DISPLAY;
735 }
736
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700737 if (metadata == mHdrMetadata) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700738 return Error::NONE;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700739 }
740
741 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700742 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
743 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
744 if (validTypes & HdrMetadata::SMPTE2086) {
745 perFrameMetadatas.insert(perFrameMetadatas.end(),
746 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800747 mHdrMetadata.smpte2086.displayPrimaryRed.x},
748 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
749 mHdrMetadata.smpte2086.displayPrimaryRed.y},
750 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
751 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
752 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
753 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
754 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
755 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
756 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
757 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
758 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
759 mHdrMetadata.smpte2086.whitePoint.x},
760 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
761 mHdrMetadata.smpte2086.whitePoint.y},
762 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
763 mHdrMetadata.smpte2086.maxLuminance},
764 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
765 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700766 }
767
768 if (validTypes & HdrMetadata::CTA861_3) {
769 perFrameMetadatas.insert(perFrameMetadatas.end(),
770 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800771 mHdrMetadata.cta8613.maxContentLightLevel},
772 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
773 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700774 }
775
Valerie Haue9e843a2018-12-18 13:39:23 -0800776 Error error = static_cast<Error>(
Lloyd Piquea516c002021-05-07 14:36:58 -0700777 mComposer.setLayerPerFrameMetadata(mDisplay->getId(), mId, perFrameMetadatas));
Valerie Haue9e843a2018-12-18 13:39:23 -0800778
779 if (validTypes & HdrMetadata::HDR10PLUS) {
Yichi Chen1d5146d2020-06-12 18:50:11 +0800780 if (CC_UNLIKELY(mHdrMetadata.hdr10plus.size() == 0)) {
781 return Error::BAD_PARAMETER;
782 }
783
Valerie Haue9e843a2018-12-18 13:39:23 -0800784 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
785 perFrameMetadataBlobs.push_back(
786 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
Lloyd Piquea516c002021-05-07 14:36:58 -0700787 Error setMetadataBlobsError =
788 static_cast<Error>(mComposer.setLayerPerFrameMetadataBlobs(mDisplay->getId(), mId,
789 perFrameMetadataBlobs));
Peiyong Line9d809e2020-04-14 13:10:48 -0700790 if (error == Error::NONE) {
Valerie Haue9e843a2018-12-18 13:39:23 -0800791 return setMetadataBlobsError;
792 }
793 }
794 return error;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700795}
796
Dan Stoza651bf312015-10-23 17:03:17 -0700797Error Layer::setDisplayFrame(const Rect& frame)
798{
Lloyd Piquea516c002021-05-07 14:36:58 -0700799 if (CC_UNLIKELY(!mDisplay)) {
800 return Error::BAD_DISPLAY;
801 }
802
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800803 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800804 frame.right, frame.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700805 auto intError = mComposer.setLayerDisplayFrame(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700806 return static_cast<Error>(intError);
807}
808
809Error Layer::setPlaneAlpha(float alpha)
810{
Lloyd Piquea516c002021-05-07 14:36:58 -0700811 if (CC_UNLIKELY(!mDisplay)) {
812 return Error::BAD_DISPLAY;
813 }
814
815 auto intError = mComposer.setLayerPlaneAlpha(mDisplay->getId(), mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700816 return static_cast<Error>(intError);
817}
818
819Error Layer::setSidebandStream(const native_handle_t* stream)
820{
Lloyd Piquea516c002021-05-07 14:36:58 -0700821 if (CC_UNLIKELY(!mDisplay)) {
822 return Error::BAD_DISPLAY;
823 }
824
Peiyong Line9d809e2020-04-14 13:10:48 -0700825 if (mCapabilities.count(Capability::SIDEBAND_STREAM) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700826 ALOGE("Attempted to call setSidebandStream without checking that the "
827 "device supports sideband streams");
Peiyong Line9d809e2020-04-14 13:10:48 -0700828 return Error::UNSUPPORTED;
Dan Stoza09e7a272016-04-14 12:31:01 -0700829 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700830 auto intError = mComposer.setLayerSidebandStream(mDisplay->getId(), mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700831 return static_cast<Error>(intError);
832}
833
834Error Layer::setSourceCrop(const FloatRect& crop)
835{
Lloyd Piquea516c002021-05-07 14:36:58 -0700836 if (CC_UNLIKELY(!mDisplay)) {
837 return Error::BAD_DISPLAY;
838 }
839
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800840 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800841 crop.left, crop.top, crop.right, crop.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700842 auto intError = mComposer.setLayerSourceCrop(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700843 return static_cast<Error>(intError);
844}
845
846Error Layer::setTransform(Transform transform)
847{
Lloyd Piquea516c002021-05-07 14:36:58 -0700848 if (CC_UNLIKELY(!mDisplay)) {
849 return Error::BAD_DISPLAY;
850 }
851
Chia-I Wuaab99f52016-10-05 12:59:58 +0800852 auto intTransform = static_cast<Hwc2::Transform>(transform);
Lloyd Piquea516c002021-05-07 14:36:58 -0700853 auto intError = mComposer.setLayerTransform(mDisplay->getId(), mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700854 return static_cast<Error>(intError);
855}
856
857Error Layer::setVisibleRegion(const Region& region)
858{
Lloyd Piquea516c002021-05-07 14:36:58 -0700859 if (CC_UNLIKELY(!mDisplay)) {
860 return Error::BAD_DISPLAY;
861 }
862
Yichi Chen8366f562019-03-25 19:44:06 +0800863 if (region.isRect() && mVisibleRegion.isRect() &&
864 (region.getBounds() == mVisibleRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700865 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800866 }
867 mVisibleRegion = region;
868
Dan Stoza651bf312015-10-23 17:03:17 -0700869 size_t rectCount = 0;
870 auto rectArray = region.getArray(&rectCount);
871
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800872 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700873 for (size_t rect = 0; rect < rectCount; ++rect) {
874 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
875 rectArray[rect].right, rectArray[rect].bottom});
876 }
877
Lloyd Piquea516c002021-05-07 14:36:58 -0700878 auto intError = mComposer.setLayerVisibleRegion(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700879 return static_cast<Error>(intError);
880}
881
882Error Layer::setZOrder(uint32_t z)
883{
Lloyd Piquea516c002021-05-07 14:36:58 -0700884 if (CC_UNLIKELY(!mDisplay)) {
885 return Error::BAD_DISPLAY;
886 }
887
888 auto intError = mComposer.setLayerZOrder(mDisplay->getId(), mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700889 return static_cast<Error>(intError);
890}
891
Peiyong Lin698147a2018-09-14 13:27:18 -0700892// Composer HAL 2.3
893Error Layer::setColorTransform(const android::mat4& matrix) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700894 if (CC_UNLIKELY(!mDisplay)) {
895 return Error::BAD_DISPLAY;
896 }
897
Peiyong Lin698147a2018-09-14 13:27:18 -0700898 if (matrix == mColorMatrix) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700899 return Error::NONE;
Peiyong Lin698147a2018-09-14 13:27:18 -0700900 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700901 auto intError = mComposer.setLayerColorTransform(mDisplay->getId(), mId, matrix.asArray());
Peiyong Lin04d25872019-04-18 10:26:19 -0700902 Error error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700903 if (error != Error::NONE) {
Peiyong Lin04d25872019-04-18 10:26:19 -0700904 return error;
905 }
906 mColorMatrix = matrix;
907 return error;
Peiyong Lin698147a2018-09-14 13:27:18 -0700908}
Lloyd Pique35d58242018-12-18 16:33:25 -0800909
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800910// Composer HAL 2.4
911Error Layer::setLayerGenericMetadata(const std::string& name, bool mandatory,
912 const std::vector<uint8_t>& value) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700913 if (CC_UNLIKELY(!mDisplay)) {
914 return Error::BAD_DISPLAY;
915 }
916
917 auto intError =
918 mComposer.setLayerGenericMetadata(mDisplay->getId(), mId, name, mandatory, value);
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800919 return static_cast<Error>(intError);
920}
921
Lloyd Pique35d58242018-12-18 16:33:25 -0800922} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700923} // namespace HWC2
Peiyong Line9d809e2020-04-14 13:10:48 -0700924} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -0800925
926// TODO(b/129481165): remove the #pragma below and fix conversion issues
927#pragma clang diagnostic pop // ignored "-Wconversion"