blob: 548d839333cfa9185377762ffcfee8868075bcf9 [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
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050042using aidl::android::hardware::graphics::composer3::Composition;
Leon Scroggins III5967aec2021-12-29 11:14:22 -050043using aidl::android::hardware::graphics::composer3::DisplayCapability;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -050044
Peiyong Line9d809e2020-04-14 13:10:48 -070045namespace android {
46
Dan Stoza651bf312015-10-23 17:03:17 -070047using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080048using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070049using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070050using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070051using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070052using android::Rect;
53using android::Region;
54using android::sp;
55
56namespace HWC2 {
57
Peiyong Line9d809e2020-04-14 13:10:48 -070058using namespace android::hardware::graphics::composer::hal;
59
Chia-I Wuaab99f52016-10-05 12:59:58 +080060namespace Hwc2 = android::Hwc2;
61
Steven Thomas94e35b92017-07-26 18:48:28 -070062namespace {
63
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070064inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
65 const Hwc2::PerFrameMetadataKey& key) {
66 return keys.find(key) != keys.end();
67}
68
Steven Thomas94e35b92017-07-26 18:48:28 -070069} // namespace anonymous
70
Dan Stoza651bf312015-10-23 17:03:17 -070071// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -080072Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -070073
Ana Krulec4593b692019-01-11 22:07:25 -080074namespace impl {
Dominik Laskowski55c85402020-01-21 16:25:47 -080075
Peiyong Lin74ca2f42019-01-14 19:36:57 -080076Display::Display(android::Hwc2::Composer& composer,
Peiyong Line9d809e2020-04-14 13:10:48 -070077 const std::unordered_set<Capability>& capabilities, HWDisplayId id,
Lloyd Piquebc792092018-01-17 11:52:30 -080078 DisplayType type)
Peiyong Line9d809e2020-04-14 13:10:48 -070079 : mComposer(composer), mCapabilities(capabilities), mId(id), mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -070080 ALOGV("Created display %" PRIu64, id);
81}
82
Steven Thomas94e35b92017-07-26 18:48:28 -070083Display::~Display() {
Lloyd Piquea516c002021-05-07 14:36:58 -070084 // Note: The calls to onOwningDisplayDestroyed() are allowed (and expected)
85 // to call Display::onLayerDestroyed(). As that call removes entries from
86 // mLayers, we do not want to have a for loop directly over it here. Since
87 // the end goal is an empty mLayers anyway, we just go ahead and swap an
88 // initially empty local container with mLayers, and then enumerate
89 // the contents of the local container.
90 Layers destroyingLayers;
91 std::swap(mLayers, destroyingLayers);
92 for (const auto& [_, weakLayer] : destroyingLayers) {
93 if (std::shared_ptr layer = weakLayer.lock()) {
94 layer->onOwningDisplayDestroyed();
95 }
96 }
Steven Thomas94e35b92017-07-26 18:48:28 -070097
Peiyong Line9d809e2020-04-14 13:10:48 -070098 Error error = Error::NONE;
Dominik Laskowski55c85402020-01-21 16:25:47 -080099 const char* msg;
100 switch (mType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700101 case DisplayType::PHYSICAL:
102 error = setVsyncEnabled(HWC2::Vsync::DISABLE);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800103 msg = "disable VSYNC for";
104 break;
105
Peiyong Line9d809e2020-04-14 13:10:48 -0700106 case DisplayType::VIRTUAL:
Dominik Laskowski55c85402020-01-21 16:25:47 -0800107 error = static_cast<Error>(mComposer.destroyVirtualDisplay(mId));
108 msg = "destroy virtual";
109 break;
110
Peiyong Line9d809e2020-04-14 13:10:48 -0700111 case DisplayType::INVALID: // Used in unit tests.
Dominik Laskowski55c85402020-01-21 16:25:47 -0800112 break;
Dan Stoza651bf312015-10-23 17:03:17 -0700113 }
Dominik Laskowski55c85402020-01-21 16:25:47 -0800114
Peiyong Line9d809e2020-04-14 13:10:48 -0700115 ALOGE_IF(error != Error::NONE, "%s: Failed to %s display %" PRIu64 ": %d", __FUNCTION__, msg,
116 mId, static_cast<int32_t>(error));
Dominik Laskowski55c85402020-01-21 16:25:47 -0800117
118 ALOGV("Destroyed display %" PRIu64, mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700119}
120
Dan Stoza651bf312015-10-23 17:03:17 -0700121// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700122Error Display::acceptChanges()
123{
Steven Thomas94e35b92017-07-26 18:48:28 -0700124 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700125 return static_cast<Error>(intError);
126}
127
Lloyd Piquea516c002021-05-07 14:36:58 -0700128base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
Peiyong Line9d809e2020-04-14 13:10:48 -0700129 HWLayerId layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700130 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700131 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700132 if (error != Error::NONE) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700133 return base::unexpected(error);
Dan Stoza651bf312015-10-23 17:03:17 -0700134 }
135
Lloyd Piquea516c002021-05-07 14:36:58 -0700136 auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);
137 mLayers.emplace(layerId, layer);
138 return layer;
Steven Thomas94e35b92017-07-26 18:48:28 -0700139}
140
Lloyd Piquea516c002021-05-07 14:36:58 -0700141void Display::onLayerDestroyed(hal::HWLayerId layerId) {
142 mLayers.erase(layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700143}
144
Ady Abraham7159f572019-10-11 11:10:18 -0700145bool Display::isVsyncPeriodSwitchSupported() const {
146 ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId);
147
Ady Abraham4d211cf2021-12-14 16:19:03 -0800148 return mComposer.isSupported(android::Hwc2::Composer::OptionalFeature::RefreshRateSwitching);
Ady Abraham7159f572019-10-11 11:10:18 -0700149}
150
Lloyd Pique35d58242018-12-18 16:33:25 -0800151Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800152 std::vector<Hwc2::Layer> layerIds;
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500153 std::vector<Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700154 auto intError = mComposer.getChangedCompositionTypes(
155 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800156 uint32_t numElements = layerIds.size();
157 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700158 error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700159 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700160 return error;
161 }
162
163 outTypes->clear();
164 outTypes->reserve(numElements);
165 for (uint32_t element = 0; element < numElements; ++element) {
166 auto layer = getLayerById(layerIds[element]);
167 if (layer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700168 auto type = types[element];
Dan Stoza651bf312015-10-23 17:03:17 -0700169 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
170 layer->getId(), to_string(type).c_str());
Lloyd Piquea516c002021-05-07 14:36:58 -0700171 outTypes->emplace(layer.get(), type);
Dan Stoza651bf312015-10-23 17:03:17 -0700172 } else {
173 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
174 " on display %" PRIu64, layerIds[element], mId);
175 }
176 }
177
Peiyong Line9d809e2020-04-14 13:10:48 -0700178 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700179}
180
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700181Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700182{
Peiyong Linfd997e02018-03-28 15:29:00 -0700183 auto intError = mComposer.getColorModes(mId, outModes);
184 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700185}
186
Chia-I Wud7e01d72018-06-21 13:39:09 +0800187int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700188{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800189 int32_t supportedPerFrameMetadata = 0;
190
191 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
192 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700193
194 // Check whether a specific metadata type is supported. A metadata type is considered
195 // supported if and only if all required fields are supported.
196
197 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700198 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
199 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
200 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
201 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
202 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
203 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
204 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
205 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
206 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
207 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800208 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700209 }
210 // CTA861_3
211 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
212 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800213 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700214 }
215
Valerie Haue9e843a2018-12-18 13:39:23 -0800216 // HDR10PLUS
217 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
218 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
219 }
220
Chia-I Wud7e01d72018-06-21 13:39:09 +0800221 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700222}
223
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700224Error Display::getRenderIntents(ColorMode colorMode,
225 std::vector<RenderIntent>* outRenderIntents) const
226{
227 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
228 return static_cast<Error>(intError);
229}
230
231Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
232{
233 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
234 return static_cast<Error>(intError);
235}
236
Dan Stoza651bf312015-10-23 17:03:17 -0700237Error Display::getName(std::string* outName) const
238{
Steven Thomas94e35b92017-07-26 18:48:28 -0700239 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800240 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700241}
242
243Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800244 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Lloyd Piquee9eff972020-05-05 12:36:44 -0700245 uint32_t intDisplayRequests = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800246 std::vector<Hwc2::Layer> layerIds;
247 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700248 auto intError = mComposer.getDisplayRequests(
249 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800250 uint32_t numElements = layerIds.size();
251 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700252 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700253 return error;
254 }
255
256 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
257 outLayerRequests->clear();
258 outLayerRequests->reserve(numElements);
259 for (uint32_t element = 0; element < numElements; ++element) {
260 auto layer = getLayerById(layerIds[element]);
261 if (layer) {
262 auto layerRequest =
263 static_cast<LayerRequest>(layerRequests[element]);
Lloyd Piquea516c002021-05-07 14:36:58 -0700264 outLayerRequests->emplace(layer.get(), layerRequest);
Dan Stoza651bf312015-10-23 17:03:17 -0700265 } else {
266 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
267 PRIu64, layerIds[element], mId);
268 }
269 }
270
Peiyong Line9d809e2020-04-14 13:10:48 -0700271 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700272}
273
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100274Error Display::getConnectionType(ui::DisplayConnectionType* outType) const {
Peiyong Line9d809e2020-04-14 13:10:48 -0700275 if (mType != DisplayType::PHYSICAL) return Error::BAD_DISPLAY;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800276
277 using ConnectionType = Hwc2::IComposerClient::DisplayConnectionType;
278 ConnectionType connectionType;
279 const auto error = static_cast<Error>(mComposer.getDisplayConnectionType(mId, &connectionType));
Peiyong Line9d809e2020-04-14 13:10:48 -0700280 if (error != Error::NONE) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800281 return error;
282 }
283
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100284 *outType = connectionType == ConnectionType::INTERNAL ? ui::DisplayConnectionType::Internal
285 : ui::DisplayConnectionType::External;
Peiyong Line9d809e2020-04-14 13:10:48 -0700286 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700287}
288
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500289bool Display::hasCapability(DisplayCapability capability) const {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700290 std::scoped_lock lock(mDisplayCapabilitiesMutex);
291 if (mDisplayCapabilities) {
292 return mDisplayCapabilities->count(capability) > 0;
293 }
294
Leon Scroggins III515f0382021-12-29 11:17:04 -0500295 ALOGW("Can't query capability %s."
Ady Abraham27fbcc72021-09-20 14:54:57 -0700296 " Display Capabilities were not queried from HWC yet",
Leon Scroggins III515f0382021-12-29 11:17:04 -0500297 to_string(capability).c_str());
Ady Abraham27fbcc72021-09-20 14:54:57 -0700298
299 return false;
300}
301
Peiyong Lined531a32018-10-26 18:27:56 -0700302Error Display::supportsDoze(bool* outSupport) const {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700303 *outSupport = hasCapability(DisplayCapability::DOZE);
Peiyong Line9d809e2020-04-14 13:10:48 -0700304 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700305}
306
Peiyong Lin62665892018-04-16 11:07:44 -0700307Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700308{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700309 float maxLuminance = -1.0f;
310 float maxAverageLuminance = -1.0f;
311 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700312 std::vector<Hwc2::Hdr> types;
313 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800314 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800315 auto error = static_cast<HWC2::Error>(intError);
316
Peiyong Line9d809e2020-04-14 13:10:48 -0700317 if (error != Error::NONE) {
Dan Stoza7d7ae732016-03-16 12:23:40 -0700318 return error;
319 }
320
Peiyong Lin62665892018-04-16 11:07:44 -0700321 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700322 maxLuminance, maxAverageLuminance, minLuminance);
Peiyong Line9d809e2020-04-14 13:10:48 -0700323 return Error::NONE;
Dan Stoza7d7ae732016-03-16 12:23:40 -0700324}
325
Peiyong Line9d809e2020-04-14 13:10:48 -0700326Error Display::getDisplayedContentSamplingAttributes(hal::PixelFormat* outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700327 Dataspace* outDataspace,
328 uint8_t* outComponentMask) const {
329 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
330 outComponentMask);
331 return static_cast<Error>(intError);
332}
333
Kevin DuBois74e53772018-11-19 10:52:38 -0800334Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
335 uint64_t maxFrames) const {
336 auto intError =
337 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
338 return static_cast<Error>(intError);
339}
340
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700341Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
342 android::DisplayedFrameStats* outStats) const {
343 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
344 return static_cast<Error>(intError);
345}
346
Lloyd Pique35d58242018-12-18 16:33:25 -0800347Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800348 std::vector<Hwc2::Layer> layerIds;
349 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700350 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800351 auto error = static_cast<Error>(intError);
352 uint32_t numElements = layerIds.size();
Peiyong Line9d809e2020-04-14 13:10:48 -0700353 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700354 return error;
355 }
356
Lloyd Pique35d58242018-12-18 16:33:25 -0800357 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700358 releaseFences.reserve(numElements);
359 for (uint32_t element = 0; element < numElements; ++element) {
360 auto layer = getLayerById(layerIds[element]);
361 if (layer) {
362 sp<Fence> fence(new Fence(fenceFds[element]));
Lloyd Piquea516c002021-05-07 14:36:58 -0700363 releaseFences.emplace(layer.get(), fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700364 } else {
365 ALOGE("getReleaseFences: invalid layer %" PRIu64
366 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700367 for (; element < numElements; ++element) {
368 close(fenceFds[element]);
369 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700370 return Error::BAD_LAYER;
Dan Stoza651bf312015-10-23 17:03:17 -0700371 }
372 }
373
374 *outFences = std::move(releaseFences);
Peiyong Line9d809e2020-04-14 13:10:48 -0700375 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700376}
377
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800378Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700379{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400380 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700381 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700382 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700383 if (error != Error::NONE) {
Dan Stoza651bf312015-10-23 17:03:17 -0700384 return error;
385 }
386
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800387 *outPresentFence = new Fence(presentFenceFd);
Peiyong Line9d809e2020-04-14 13:10:48 -0700388 return Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700389}
390
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100391Error Display::setActiveConfigWithConstraints(hal::HWConfigId configId,
392 const VsyncPeriodChangeConstraints& constraints,
393 VsyncPeriodChangeTimeline* outTimeline) {
Ady Abraham7159f572019-10-11 11:10:18 -0700394 ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId);
Ady Abraham7159f572019-10-11 11:10:18 -0700395
396 if (isVsyncPeriodSwitchSupported()) {
397 Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints;
398 hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos;
399 hwc2Constraints.seamlessRequired = constraints.seamlessRequired;
400
401 Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {};
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100402 auto intError = mComposer.setActiveConfigWithConstraints(mId, configId, hwc2Constraints,
403 &vsyncPeriodChangeTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -0700404 outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos;
405 outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired;
406 outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos;
407 return static_cast<Error>(intError);
408 }
409
410 // Use legacy setActiveConfig instead
411 ALOGV("fallback to legacy setActiveConfig");
412 const auto now = systemTime();
413 if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) {
414 ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied");
415 }
416
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100417 auto intError_2_4 = mComposer.setActiveConfig(mId, configId);
Ady Abraham7159f572019-10-11 11:10:18 -0700418 outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos);
419 outTimeline->refreshRequired = true;
420 outTimeline->refreshTimeNanos = now;
421 return static_cast<Error>(intError_2_4);
422}
423
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400424Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700425 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700426{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700427 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700428 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700429 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700430 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700431 return static_cast<Error>(intError);
432}
433
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700434Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700435{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700436 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700437 return static_cast<Error>(intError);
438}
439
Ady Abrahamdc011a92021-12-21 14:06:44 -0800440Error Display::setColorTransform(const android::mat4& matrix) {
441 auto intError = mComposer.setColorTransform(mId, matrix.asArray());
Dan Stoza5df2a862016-03-24 16:19:37 -0700442 return static_cast<Error>(intError);
443}
444
Dan Stoza651bf312015-10-23 17:03:17 -0700445Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
446 const sp<Fence>& releaseFence)
447{
448 int32_t fenceFd = releaseFence->dup();
449 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700450 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700451 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700452 return static_cast<Error>(intError);
453}
454
455Error Display::setPowerMode(PowerMode mode)
456{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800457 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700458 auto intError = mComposer.setPowerMode(mId, intMode);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700459
Peiyong Line9d809e2020-04-14 13:10:48 -0700460 if (mode == PowerMode::ON) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700461 std::call_once(mDisplayCapabilityQueryFlag, [this]() {
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500462 std::vector<DisplayCapability> tmpCapabilities;
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700463 auto error =
464 static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
Peiyong Line9d809e2020-04-14 13:10:48 -0700465 if (error == Error::NONE) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700466 std::scoped_lock lock(mDisplayCapabilitiesMutex);
467 mDisplayCapabilities.emplace();
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700468 for (auto capability : tmpCapabilities) {
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500469 mDisplayCapabilities->emplace(capability);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700470 }
Peiyong Line9d809e2020-04-14 13:10:48 -0700471 } else if (error == Error::UNSUPPORTED) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700472 std::scoped_lock lock(mDisplayCapabilitiesMutex);
473 mDisplayCapabilities.emplace();
Peiyong Line9d809e2020-04-14 13:10:48 -0700474 if (mCapabilities.count(Capability::SKIP_CLIENT_COLOR_TRANSFORM)) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700475 mDisplayCapabilities->emplace(DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700476 }
477 bool dozeSupport = false;
478 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
Peiyong Line9d809e2020-04-14 13:10:48 -0700479 if (error == Error::NONE && dozeSupport) {
Ady Abraham27fbcc72021-09-20 14:54:57 -0700480 mDisplayCapabilities->emplace(DisplayCapability::DOZE);
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700481 }
482 }
483 });
484 }
485
Dan Stoza651bf312015-10-23 17:03:17 -0700486 return static_cast<Error>(intError);
487}
488
489Error Display::setVsyncEnabled(Vsync enabled)
490{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800491 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700492 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700493 return static_cast<Error>(intError);
494}
495
Ady Abraham43065bd2021-12-10 17:22:15 -0800496Error Display::validate(nsecs_t expectedPresentTime, uint32_t* outNumTypes,
497 uint32_t* outNumRequests) {
Dan Stoza651bf312015-10-23 17:03:17 -0700498 uint32_t numTypes = 0;
499 uint32_t numRequests = 0;
Ady Abraham43065bd2021-12-10 17:22:15 -0800500 auto intError = mComposer.validateDisplay(mId, expectedPresentTime, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700501 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700502 if (error != Error::NONE && !hasChangesError(error)) {
Dan Stoza651bf312015-10-23 17:03:17 -0700503 return error;
504 }
505
506 *outNumTypes = numTypes;
507 *outNumRequests = numRequests;
508 return error;
509}
510
Ady Abraham43065bd2021-12-10 17:22:15 -0800511Error Display::presentOrValidate(nsecs_t expectedPresentTime, uint32_t* outNumTypes,
512 uint32_t* outNumRequests, sp<android::Fence>* outPresentFence,
513 uint32_t* state) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700514 uint32_t numTypes = 0;
515 uint32_t numRequests = 0;
516 int32_t presentFenceFd = -1;
Ady Abraham43065bd2021-12-10 17:22:15 -0800517 auto intError = mComposer.presentOrValidateDisplay(mId, expectedPresentTime, &numTypes,
518 &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700519 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700520 if (error != Error::NONE && !hasChangesError(error)) {
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700521 return error;
522 }
523
524 if (*state == 1) {
525 *outPresentFence = new Fence(presentFenceFd);
526 }
527
528 if (*state == 0) {
529 *outNumTypes = numTypes;
530 *outNumRequests = numRequests;
531 }
532 return error;
533}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700534
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700535std::future<Error> Display::setDisplayBrightness(float brightness) {
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800536 return ftl::defer([composer = &mComposer, id = mId, brightness] {
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700537 const auto intError = composer->setDisplayBrightness(id, brightness);
538 return static_cast<Error>(intError);
539 });
Dan Gittik57e63c52019-01-18 16:37:54 +0000540}
541
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700542Error Display::setAutoLowLatencyMode(bool on) {
Galia Peycheva5492cb52019-10-30 14:13:16 +0100543 auto intError = mComposer.setAutoLowLatencyMode(mId, on);
544 return static_cast<Error>(intError);
545}
546
547Error Display::getSupportedContentTypes(std::vector<ContentType>* outSupportedContentTypes) const {
548 std::vector<Hwc2::IComposerClient::ContentType> tmpSupportedContentTypes;
549 auto intError = mComposer.getSupportedContentTypes(mId, &tmpSupportedContentTypes);
550 for (Hwc2::IComposerClient::ContentType contentType : tmpSupportedContentTypes) {
551 outSupportedContentTypes->push_back(static_cast<ContentType>(contentType));
552 }
553 return static_cast<Error>(intError);
554}
555
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700556Error Display::setContentType(ContentType contentType) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700557 auto intError = mComposer.setContentType(mId, contentType);
Galia Peycheva5492cb52019-10-30 14:13:16 +0100558 return static_cast<Error>(intError);
559}
560
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700561Error Display::getClientTargetProperty(ClientTargetProperty* outClientTargetProperty,
562 float* outWhitePointNits) {
563 const auto error =
564 mComposer.getClientTargetProperty(mId, outClientTargetProperty, outWhitePointNits);
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700565 return static_cast<Error>(error);
566}
567
Dan Stoza651bf312015-10-23 17:03:17 -0700568// For use by Device
569
Steven Thomas94e35b92017-07-26 18:48:28 -0700570void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800571 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700572 mComposer.setClientTargetSlotCount(mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700573 }
574 mIsConnected = connected;
575}
576
Dan Stoza651bf312015-10-23 17:03:17 -0700577// Other Display methods
578
Lloyd Piquea516c002021-05-07 14:36:58 -0700579std::shared_ptr<HWC2::Layer> Display::getLayerById(HWLayerId id) const {
580 auto it = mLayers.find(id);
581 return it != mLayers.end() ? it->second.lock() : nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700582}
Ana Krulec4593b692019-01-11 22:07:25 -0800583} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700584
585// Layer methods
586
Lloyd Pique35d58242018-12-18 16:33:25 -0800587Layer::~Layer() = default;
588
589namespace impl {
590
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700591Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Lloyd Piquea516c002021-05-07 14:36:58 -0700592 HWC2::Display& display, HWLayerId layerId)
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800593 : mComposer(composer),
594 mCapabilities(capabilities),
Lloyd Piquea516c002021-05-07 14:36:58 -0700595 mDisplay(&display),
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800596 mId(layerId),
597 mColorMatrix(android::mat4()) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700598 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, display.getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700599}
600
601Layer::~Layer()
602{
Lloyd Piquea516c002021-05-07 14:36:58 -0700603 onOwningDisplayDestroyed();
604}
605
606void Layer::onOwningDisplayDestroyed() {
607 // Note: onOwningDisplayDestroyed() may be called to perform cleanup by
608 // either the Layer dtor or by the Display dtor and must be safe to call
609 // from either path. In particular, the call to Display::onLayerDestroyed()
610 // is expected to be safe to do,
611
612 if (CC_UNLIKELY(!mDisplay)) {
613 return;
614 }
615
616 mDisplay->onLayerDestroyed(mId);
617
618 // Note: If the HWC display was actually disconnected, these calls are will
619 // return an error. We always make them as there may be other reasons for
620 // the HWC2::Display to be destroyed.
621 auto intError = mComposer.destroyLayer(mDisplay->getId(), mId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700622 auto error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700623 ALOGE_IF(error != Error::NONE,
624 "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
625 " failed: %s (%d)",
Lloyd Piquea516c002021-05-07 14:36:58 -0700626 mDisplay->getId(), mId, to_string(error).c_str(), intError);
627
628 mDisplay = nullptr;
Steven Thomas94e35b92017-07-26 18:48:28 -0700629}
630
Dan Stoza651bf312015-10-23 17:03:17 -0700631Error Layer::setCursorPosition(int32_t x, int32_t y)
632{
Lloyd Piquea516c002021-05-07 14:36:58 -0700633 if (CC_UNLIKELY(!mDisplay)) {
634 return Error::BAD_DISPLAY;
635 }
636
637 auto intError = mComposer.setCursorPosition(mDisplay->getId(), mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700638 return static_cast<Error>(intError);
639}
640
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400641Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700642 const sp<Fence>& acquireFence)
643{
Lloyd Piquea516c002021-05-07 14:36:58 -0700644 if (CC_UNLIKELY(!mDisplay)) {
645 return Error::BAD_DISPLAY;
646 }
647
Yichi Chen8366f562019-03-25 19:44:06 +0800648 if (buffer == nullptr && mBufferSlot == slot) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700649 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800650 }
651 mBufferSlot = slot;
652
Dan Stoza651bf312015-10-23 17:03:17 -0700653 int32_t fenceFd = acquireFence->dup();
Lloyd Piquea516c002021-05-07 14:36:58 -0700654 auto intError = mComposer.setLayerBuffer(mDisplay->getId(), mId, slot, buffer, fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700655 return static_cast<Error>(intError);
656}
657
658Error Layer::setSurfaceDamage(const Region& damage)
659{
Lloyd Piquea516c002021-05-07 14:36:58 -0700660 if (CC_UNLIKELY(!mDisplay)) {
661 return Error::BAD_DISPLAY;
662 }
663
Yichi Chen8366f562019-03-25 19:44:06 +0800664 if (damage.isRect() && mDamageRegion.isRect() &&
665 (damage.getBounds() == mDamageRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700666 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800667 }
668 mDamageRegion = damage;
669
Dan Stoza651bf312015-10-23 17:03:17 -0700670 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
671 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800672 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700673 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700674 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId,
675 std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700676 } else {
677 size_t rectCount = 0;
678 auto rectArray = damage.getArray(&rectCount);
679
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800680 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700681 for (size_t rect = 0; rect < rectCount; ++rect) {
682 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
683 rectArray[rect].right, rectArray[rect].bottom});
684 }
685
Lloyd Piquea516c002021-05-07 14:36:58 -0700686 intError = mComposer.setLayerSurfaceDamage(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700687 }
688
689 return static_cast<Error>(intError);
690}
691
692Error Layer::setBlendMode(BlendMode mode)
693{
Lloyd Piquea516c002021-05-07 14:36:58 -0700694 if (CC_UNLIKELY(!mDisplay)) {
695 return Error::BAD_DISPLAY;
696 }
697
698 auto intError = mComposer.setLayerBlendMode(mDisplay->getId(), mId, mode);
Dan Stoza651bf312015-10-23 17:03:17 -0700699 return static_cast<Error>(intError);
700}
701
Peiyong Line9d809e2020-04-14 13:10:48 -0700702Error Layer::setColor(Color color) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700703 if (CC_UNLIKELY(!mDisplay)) {
704 return Error::BAD_DISPLAY;
705 }
706
707 auto intError = mComposer.setLayerColor(mDisplay->getId(), mId, color);
Dan Stoza651bf312015-10-23 17:03:17 -0700708 return static_cast<Error>(intError);
709}
710
711Error Layer::setCompositionType(Composition type)
712{
Lloyd Piquea516c002021-05-07 14:36:58 -0700713 if (CC_UNLIKELY(!mDisplay)) {
714 return Error::BAD_DISPLAY;
715 }
716
717 auto intError = mComposer.setLayerCompositionType(mDisplay->getId(), mId, type);
Dan Stoza651bf312015-10-23 17:03:17 -0700718 return static_cast<Error>(intError);
719}
720
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700721Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700722{
Lloyd Piquea516c002021-05-07 14:36:58 -0700723 if (CC_UNLIKELY(!mDisplay)) {
724 return Error::BAD_DISPLAY;
725 }
726
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600727 if (dataspace == mDataSpace) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700728 return Error::NONE;
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600729 }
730 mDataSpace = dataspace;
Lloyd Piquea516c002021-05-07 14:36:58 -0700731 auto intError = mComposer.setLayerDataspace(mDisplay->getId(), mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700732 return static_cast<Error>(intError);
733}
734
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700735Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
736 const android::HdrMetadata& metadata)
737{
Lloyd Piquea516c002021-05-07 14:36:58 -0700738 if (CC_UNLIKELY(!mDisplay)) {
739 return Error::BAD_DISPLAY;
740 }
741
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700742 if (metadata == mHdrMetadata) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700743 return Error::NONE;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700744 }
745
746 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700747 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
748 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
749 if (validTypes & HdrMetadata::SMPTE2086) {
750 perFrameMetadatas.insert(perFrameMetadatas.end(),
751 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800752 mHdrMetadata.smpte2086.displayPrimaryRed.x},
753 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
754 mHdrMetadata.smpte2086.displayPrimaryRed.y},
755 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
756 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
757 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
758 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
759 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
760 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
761 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
762 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
763 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
764 mHdrMetadata.smpte2086.whitePoint.x},
765 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
766 mHdrMetadata.smpte2086.whitePoint.y},
767 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
768 mHdrMetadata.smpte2086.maxLuminance},
769 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
770 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700771 }
772
773 if (validTypes & HdrMetadata::CTA861_3) {
774 perFrameMetadatas.insert(perFrameMetadatas.end(),
775 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800776 mHdrMetadata.cta8613.maxContentLightLevel},
777 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
778 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700779 }
780
Valerie Haue9e843a2018-12-18 13:39:23 -0800781 Error error = static_cast<Error>(
Lloyd Piquea516c002021-05-07 14:36:58 -0700782 mComposer.setLayerPerFrameMetadata(mDisplay->getId(), mId, perFrameMetadatas));
Valerie Haue9e843a2018-12-18 13:39:23 -0800783
784 if (validTypes & HdrMetadata::HDR10PLUS) {
Yichi Chen1d5146d2020-06-12 18:50:11 +0800785 if (CC_UNLIKELY(mHdrMetadata.hdr10plus.size() == 0)) {
786 return Error::BAD_PARAMETER;
787 }
788
Valerie Haue9e843a2018-12-18 13:39:23 -0800789 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
790 perFrameMetadataBlobs.push_back(
791 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
Lloyd Piquea516c002021-05-07 14:36:58 -0700792 Error setMetadataBlobsError =
793 static_cast<Error>(mComposer.setLayerPerFrameMetadataBlobs(mDisplay->getId(), mId,
794 perFrameMetadataBlobs));
Peiyong Line9d809e2020-04-14 13:10:48 -0700795 if (error == Error::NONE) {
Valerie Haue9e843a2018-12-18 13:39:23 -0800796 return setMetadataBlobsError;
797 }
798 }
799 return error;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700800}
801
Dan Stoza651bf312015-10-23 17:03:17 -0700802Error Layer::setDisplayFrame(const Rect& frame)
803{
Lloyd Piquea516c002021-05-07 14:36:58 -0700804 if (CC_UNLIKELY(!mDisplay)) {
805 return Error::BAD_DISPLAY;
806 }
807
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800808 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800809 frame.right, frame.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700810 auto intError = mComposer.setLayerDisplayFrame(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700811 return static_cast<Error>(intError);
812}
813
814Error Layer::setPlaneAlpha(float alpha)
815{
Lloyd Piquea516c002021-05-07 14:36:58 -0700816 if (CC_UNLIKELY(!mDisplay)) {
817 return Error::BAD_DISPLAY;
818 }
819
820 auto intError = mComposer.setLayerPlaneAlpha(mDisplay->getId(), mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700821 return static_cast<Error>(intError);
822}
823
824Error Layer::setSidebandStream(const native_handle_t* stream)
825{
Lloyd Piquea516c002021-05-07 14:36:58 -0700826 if (CC_UNLIKELY(!mDisplay)) {
827 return Error::BAD_DISPLAY;
828 }
829
Peiyong Line9d809e2020-04-14 13:10:48 -0700830 if (mCapabilities.count(Capability::SIDEBAND_STREAM) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700831 ALOGE("Attempted to call setSidebandStream without checking that the "
832 "device supports sideband streams");
Peiyong Line9d809e2020-04-14 13:10:48 -0700833 return Error::UNSUPPORTED;
Dan Stoza09e7a272016-04-14 12:31:01 -0700834 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700835 auto intError = mComposer.setLayerSidebandStream(mDisplay->getId(), mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700836 return static_cast<Error>(intError);
837}
838
839Error Layer::setSourceCrop(const FloatRect& crop)
840{
Lloyd Piquea516c002021-05-07 14:36:58 -0700841 if (CC_UNLIKELY(!mDisplay)) {
842 return Error::BAD_DISPLAY;
843 }
844
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800845 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800846 crop.left, crop.top, crop.right, crop.bottom};
Lloyd Piquea516c002021-05-07 14:36:58 -0700847 auto intError = mComposer.setLayerSourceCrop(mDisplay->getId(), mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700848 return static_cast<Error>(intError);
849}
850
851Error Layer::setTransform(Transform transform)
852{
Lloyd Piquea516c002021-05-07 14:36:58 -0700853 if (CC_UNLIKELY(!mDisplay)) {
854 return Error::BAD_DISPLAY;
855 }
856
Chia-I Wuaab99f52016-10-05 12:59:58 +0800857 auto intTransform = static_cast<Hwc2::Transform>(transform);
Lloyd Piquea516c002021-05-07 14:36:58 -0700858 auto intError = mComposer.setLayerTransform(mDisplay->getId(), mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700859 return static_cast<Error>(intError);
860}
861
862Error Layer::setVisibleRegion(const Region& region)
863{
Lloyd Piquea516c002021-05-07 14:36:58 -0700864 if (CC_UNLIKELY(!mDisplay)) {
865 return Error::BAD_DISPLAY;
866 }
867
Yichi Chen8366f562019-03-25 19:44:06 +0800868 if (region.isRect() && mVisibleRegion.isRect() &&
869 (region.getBounds() == mVisibleRegion.getBounds())) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700870 return Error::NONE;
Yichi Chen8366f562019-03-25 19:44:06 +0800871 }
872 mVisibleRegion = region;
873
Dan Stoza651bf312015-10-23 17:03:17 -0700874 size_t rectCount = 0;
875 auto rectArray = region.getArray(&rectCount);
876
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800877 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700878 for (size_t rect = 0; rect < rectCount; ++rect) {
879 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
880 rectArray[rect].right, rectArray[rect].bottom});
881 }
882
Lloyd Piquea516c002021-05-07 14:36:58 -0700883 auto intError = mComposer.setLayerVisibleRegion(mDisplay->getId(), mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700884 return static_cast<Error>(intError);
885}
886
887Error Layer::setZOrder(uint32_t z)
888{
Lloyd Piquea516c002021-05-07 14:36:58 -0700889 if (CC_UNLIKELY(!mDisplay)) {
890 return Error::BAD_DISPLAY;
891 }
892
893 auto intError = mComposer.setLayerZOrder(mDisplay->getId(), mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700894 return static_cast<Error>(intError);
895}
896
Peiyong Lin698147a2018-09-14 13:27:18 -0700897// Composer HAL 2.3
898Error Layer::setColorTransform(const android::mat4& matrix) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700899 if (CC_UNLIKELY(!mDisplay)) {
900 return Error::BAD_DISPLAY;
901 }
902
Peiyong Lin698147a2018-09-14 13:27:18 -0700903 if (matrix == mColorMatrix) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700904 return Error::NONE;
Peiyong Lin698147a2018-09-14 13:27:18 -0700905 }
Lloyd Piquea516c002021-05-07 14:36:58 -0700906 auto intError = mComposer.setLayerColorTransform(mDisplay->getId(), mId, matrix.asArray());
Peiyong Lin04d25872019-04-18 10:26:19 -0700907 Error error = static_cast<Error>(intError);
Peiyong Line9d809e2020-04-14 13:10:48 -0700908 if (error != Error::NONE) {
Peiyong Lin04d25872019-04-18 10:26:19 -0700909 return error;
910 }
911 mColorMatrix = matrix;
912 return error;
Peiyong Lin698147a2018-09-14 13:27:18 -0700913}
Lloyd Pique35d58242018-12-18 16:33:25 -0800914
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800915// Composer HAL 2.4
916Error Layer::setLayerGenericMetadata(const std::string& name, bool mandatory,
917 const std::vector<uint8_t>& value) {
Lloyd Piquea516c002021-05-07 14:36:58 -0700918 if (CC_UNLIKELY(!mDisplay)) {
919 return Error::BAD_DISPLAY;
920 }
921
922 auto intError =
923 mComposer.setLayerGenericMetadata(mDisplay->getId(), mId, name, mandatory, value);
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800924 return static_cast<Error>(intError);
925}
926
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700927// AIDL HAL
928Error Layer::setWhitePointNits(float whitePointNits) {
929 if (CC_UNLIKELY(!mDisplay)) {
930 return Error::BAD_DISPLAY;
931 }
932
933 auto intError = mComposer.setLayerWhitePointNits(mDisplay->getId(), mId, whitePointNits);
934 return static_cast<Error>(intError);
935}
936
Lloyd Pique35d58242018-12-18 16:33:25 -0800937} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700938} // namespace HWC2
Peiyong Line9d809e2020-04-14 13:10:48 -0700939} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -0800940
941// TODO(b/129481165): remove the #pragma below and fix conversion issues
942#pragma clang diagnostic pop // ignored "-Wconversion"