blob: 12a94a70d6d54feb811e2f4b9469f0c4e8230b57 [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
17// #define LOG_NDEBUG 0
18
19#undef LOG_TAG
20#define LOG_TAG "HWC2"
21#define ATRACE_TAG ATRACE_TAG_GRAPHICS
22
23#include "HWC2.h"
Chia-I Wuaab99f52016-10-05 12:59:58 +080024#include "ComposerHal.h"
Dan Stoza651bf312015-10-23 17:03:17 -070025
Dan Stoza651bf312015-10-23 17:03:17 -070026#include <ui/Fence.h>
Dan Stoza5a423ea2017-02-16 14:10:39 -080027#include <ui/FloatRect.h>
Dan Stoza651bf312015-10-23 17:03:17 -070028#include <ui/GraphicBuffer.h>
Dan Stoza651bf312015-10-23 17:03:17 -070029
30#include <android/configuration.h>
31
32#include <inttypes.h>
Lloyd Pique3c085a02018-05-09 19:38:32 -070033#include <algorithm>
34#include <iterator>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070035#include <set>
Dan Stoza651bf312015-10-23 17:03:17 -070036
Dan Stoza651bf312015-10-23 17:03:17 -070037using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080038using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070039using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070040using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070041using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070042using android::Rect;
43using android::Region;
44using android::sp;
Chia-I Wuaab99f52016-10-05 12:59:58 +080045using android::hardware::Return;
46using android::hardware::Void;
Dan Stoza651bf312015-10-23 17:03:17 -070047
48namespace HWC2 {
49
Chia-I Wuaab99f52016-10-05 12:59:58 +080050namespace Hwc2 = android::Hwc2;
Peiyong Lin34beb7a2018-03-28 11:57:12 -070051using android::ui::ColorMode;
52using android::ui::Dataspace;
53using android::ui::PixelFormat;
Peiyong Lin0e7a7912018-04-05 14:36:36 -070054using android::ui::RenderIntent;
Chia-I Wuaab99f52016-10-05 12:59:58 +080055
Steven Thomas94e35b92017-07-26 18:48:28 -070056namespace {
57
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070058inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
59 const Hwc2::PerFrameMetadataKey& key) {
60 return keys.find(key) != keys.end();
61}
62
Steven Thomas94e35b92017-07-26 18:48:28 -070063class ComposerCallbackBridge : public Hwc2::IComposerCallback {
64public:
65 ComposerCallbackBridge(ComposerCallback* callback, int32_t sequenceId)
Lloyd Pique715a2c12017-12-14 17:18:08 -080066 : mCallback(callback), mSequenceId(sequenceId) {}
Steven Thomas94e35b92017-07-26 18:48:28 -070067
68 Return<void> onHotplug(Hwc2::Display display,
69 IComposerCallback::Connection conn) override
70 {
71 HWC2::Connection connection = static_cast<HWC2::Connection>(conn);
Lloyd Pique715a2c12017-12-14 17:18:08 -080072 mCallback->onHotplugReceived(mSequenceId, display, connection);
Steven Thomas94e35b92017-07-26 18:48:28 -070073 return Void();
74 }
75
76 Return<void> onRefresh(Hwc2::Display display) override
77 {
78 mCallback->onRefreshReceived(mSequenceId, display);
79 return Void();
80 }
81
82 Return<void> onVsync(Hwc2::Display display, int64_t timestamp) override
83 {
84 mCallback->onVsyncReceived(mSequenceId, display, timestamp);
85 return Void();
86 }
87
Steven Thomas94e35b92017-07-26 18:48:28 -070088private:
89 ComposerCallback* mCallback;
90 int32_t mSequenceId;
Steven Thomas94e35b92017-07-26 18:48:28 -070091};
92
93} // namespace anonymous
94
95
Dan Stoza651bf312015-10-23 17:03:17 -070096// Device methods
97
Lloyd Piquea822d522017-12-20 16:42:57 -080098Device::Device(std::unique_ptr<android::Hwc2::Composer> composer) : mComposer(std::move(composer)) {
Dan Stoza651bf312015-10-23 17:03:17 -070099 loadCapabilities();
Dan Stoza651bf312015-10-23 17:03:17 -0700100}
101
Steven Thomas94e35b92017-07-26 18:48:28 -0700102void Device::registerCallback(ComposerCallback* callback, int32_t sequenceId) {
103 if (mRegisteredCallback) {
104 ALOGW("Callback already registered. Ignored extra registration "
105 "attempt.");
106 return;
Dan Stoza651bf312015-10-23 17:03:17 -0700107 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700108 mRegisteredCallback = true;
109 sp<ComposerCallbackBridge> callbackBridge(
110 new ComposerCallbackBridge(callback, sequenceId));
111 mComposer->registerCallback(callbackBridge);
Dan Stoza651bf312015-10-23 17:03:17 -0700112}
113
114// Required by HWC2 device
115
116std::string Device::dump() const
117{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800118 return mComposer->dumpDebugInfo();
Dan Stoza651bf312015-10-23 17:03:17 -0700119}
120
121uint32_t Device::getMaxVirtualDisplayCount() const
122{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800123 return mComposer->getMaxVirtualDisplayCount();
Dan Stoza651bf312015-10-23 17:03:17 -0700124}
125
Dominik Laskowski0954b1d2018-06-13 14:58:49 -0700126Error Device::getDisplayIdentificationData(hwc2_display_t hwcDisplayId, uint8_t* outPort,
127 std::vector<uint8_t>* outData) const {
128 auto intError = mComposer->getDisplayIdentificationData(hwcDisplayId, outPort, outData);
129 return static_cast<Error>(intError);
130}
131
Dan Stoza651bf312015-10-23 17:03:17 -0700132Error Device::createVirtualDisplay(uint32_t width, uint32_t height,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700133 PixelFormat* format, Display** outDisplay)
Dan Stoza651bf312015-10-23 17:03:17 -0700134{
135 ALOGI("Creating virtual display");
136
137 hwc2_display_t displayId = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800138 auto intError = mComposer->createVirtualDisplay(width, height,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700139 format, &displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700140 auto error = static_cast<Error>(intError);
141 if (error != Error::None) {
142 return error;
143 }
144
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800145 auto display = std::make_unique<impl::Display>(*mComposer.get(), mCapabilities, displayId,
146 DisplayType::Virtual);
Lloyd Piquebc792092018-01-17 11:52:30 -0800147 display->setConnected(true);
Steven Thomas94e35b92017-07-26 18:48:28 -0700148 *outDisplay = display.get();
Steven Thomas94e35b92017-07-26 18:48:28 -0700149 mDisplays.emplace(displayId, std::move(display));
150 ALOGI("Created virtual display");
Dan Stoza651bf312015-10-23 17:03:17 -0700151 return Error::None;
152}
153
Steven Thomas94e35b92017-07-26 18:48:28 -0700154void Device::destroyDisplay(hwc2_display_t displayId)
Dan Stoza651bf312015-10-23 17:03:17 -0700155{
Steven Thomas94e35b92017-07-26 18:48:28 -0700156 ALOGI("Destroying display %" PRIu64, displayId);
157 mDisplays.erase(displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700158}
159
Steven Thomas94e35b92017-07-26 18:48:28 -0700160void Device::onHotplug(hwc2_display_t displayId, Connection connection) {
161 if (connection == Connection::Connected) {
Steven Thomas3bed0522018-03-20 15:40:48 -0700162 // If we get a hotplug connected event for a display we already have,
163 // destroy the display and recreate it. This will force us to requery
164 // the display params and recreate all layers on that display.
165 auto oldDisplay = getDisplayById(displayId);
166 if (oldDisplay != nullptr && oldDisplay->isConnected()) {
167 ALOGI("Hotplug connecting an already connected display."
168 " Clearing old display state.");
Dan Stoza651bf312015-10-23 17:03:17 -0700169 }
Steven Thomas3bed0522018-03-20 15:40:48 -0700170 mDisplays.erase(displayId);
171
172 DisplayType displayType;
173 auto intError = mComposer->getDisplayType(displayId,
174 reinterpret_cast<Hwc2::IComposerClient::DisplayType *>(
175 &displayType));
176 auto error = static_cast<Error>(intError);
177 if (error != Error::None) {
178 ALOGE("getDisplayType(%" PRIu64 ") failed: %s (%d). "
179 "Aborting hotplug attempt.",
180 displayId, to_string(error).c_str(), intError);
181 return;
182 }
183
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800184 auto newDisplay = std::make_unique<impl::Display>(*mComposer.get(), mCapabilities,
185 displayId, displayType);
Lloyd Piquebc792092018-01-17 11:52:30 -0800186 newDisplay->setConnected(true);
Steven Thomas3bed0522018-03-20 15:40:48 -0700187 mDisplays.emplace(displayId, std::move(newDisplay));
Steven Thomas94e35b92017-07-26 18:48:28 -0700188 } else if (connection == Connection::Disconnected) {
189 // The display will later be destroyed by a call to
190 // destroyDisplay(). For now we just mark it disconnected.
191 auto display = getDisplayById(displayId);
192 if (display) {
193 display->setConnected(false);
194 } else {
195 ALOGW("Attempted to disconnect unknown display %" PRIu64,
196 displayId);
197 }
Dan Stoza651bf312015-10-23 17:03:17 -0700198 }
199}
200
201// Other Device methods
202
Steven Thomas94e35b92017-07-26 18:48:28 -0700203Display* Device::getDisplayById(hwc2_display_t id) {
204 auto iter = mDisplays.find(id);
205 return iter == mDisplays.end() ? nullptr : iter->second.get();
Dan Stoza651bf312015-10-23 17:03:17 -0700206}
207
208// Device initialization methods
209
210void Device::loadCapabilities()
211{
212 static_assert(sizeof(Capability) == sizeof(int32_t),
213 "Capability size has changed");
Chia-I Wuaab99f52016-10-05 12:59:58 +0800214 auto capabilities = mComposer->getCapabilities();
215 for (auto capability : capabilities) {
216 mCapabilities.emplace(static_cast<Capability>(capability));
217 }
Dan Stoza651bf312015-10-23 17:03:17 -0700218}
219
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700220Error Device::flushCommands()
221{
222 return static_cast<Error>(mComposer->executeCommands());
223}
224
Dan Stoza651bf312015-10-23 17:03:17 -0700225// Display methods
Ana Krulec4593b692019-01-11 22:07:25 -0800226Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -0700227
Ana Krulec4593b692019-01-11 22:07:25 -0800228Display::Config::Config(Display& display, hwc2_config_t id)
229 : mDisplay(display),
230 mId(id),
231 mWidth(-1),
232 mHeight(-1),
233 mVsyncPeriod(-1),
234 mDpiX(-1),
235 mDpiY(-1) {}
236
237Display::Config::Builder::Builder(Display& display, hwc2_config_t id)
238 : mConfig(new Config(display, id)) {}
239
240float Display::Config::Builder::getDefaultDensity() {
241 // Default density is based on TVs: 1080p displays get XHIGH density, lower-
242 // resolution displays get TV density. Maybe eventually we'll need to update
243 // it for 4k displays, though hopefully those will just report accurate DPI
244 // information to begin with. This is also used for virtual displays and
245 // older HWC implementations, so be careful about orientation.
246
247 auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
248 if (longDimension >= 1080) {
249 return ACONFIGURATION_DENSITY_XHIGH;
250 } else {
251 return ACONFIGURATION_DENSITY_TV;
252 }
253}
254
255namespace impl {
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800256Display::Display(android::Hwc2::Composer& composer,
Lloyd Piquebc792092018-01-17 11:52:30 -0800257 const std::unordered_set<Capability>& capabilities, hwc2_display_t id,
258 DisplayType type)
259 : mComposer(composer),
260 mCapabilities(capabilities),
261 mId(id),
262 mIsConnected(false),
263 mType(type) {
Peiyong Lined531a32018-10-26 18:27:56 -0700264 std::vector<Hwc2::DisplayCapability> tmpCapabilities;
265 auto error = static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
266 if (error == Error::None) {
267 for (auto capability : tmpCapabilities) {
268 mDisplayCapabilities.emplace(static_cast<DisplayCapability>(capability));
269 }
270 } else if (error == Error::Unsupported) {
271 if (capabilities.count(Capability::SkipClientColorTransform)) {
272 mDisplayCapabilities.emplace(DisplayCapability::SkipClientColorTransform);
273 }
274 bool dozeSupport = false;
275 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
276 if (error == Error::None && dozeSupport) {
277 mDisplayCapabilities.emplace(DisplayCapability::Doze);
278 }
Dan Gittik57e63c52019-01-18 16:37:54 +0000279 bool brightnessSupport = false;
280 error = static_cast<Error>(mComposer.getDisplayBrightnessSupport(mId, &brightnessSupport));
281 if (error == Error::None && brightnessSupport) {
282 mDisplayCapabilities.emplace(DisplayCapability::Brightness);
283 }
Peiyong Lined531a32018-10-26 18:27:56 -0700284 }
Dan Stoza651bf312015-10-23 17:03:17 -0700285 ALOGV("Created display %" PRIu64, id);
286}
287
Steven Thomas94e35b92017-07-26 18:48:28 -0700288Display::~Display() {
289 mLayers.clear();
290
Chris Forbesceb67d12017-04-11 12:20:00 -0700291 if (mType == DisplayType::Virtual) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700292 ALOGV("Destroying virtual display");
293 auto intError = mComposer.destroyVirtualDisplay(mId);
294 auto error = static_cast<Error>(intError);
295 ALOGE_IF(error != Error::None, "destroyVirtualDisplay(%" PRIu64
296 ") failed: %s (%d)", mId, to_string(error).c_str(), intError);
297 } else if (mType == DisplayType::Physical) {
298 auto error = setVsyncEnabled(HWC2::Vsync::Disable);
299 if (error != Error::None) {
300 ALOGE("~Display: Failed to disable vsync for display %" PRIu64
301 ": %s (%d)", mId, to_string(error).c_str(),
302 static_cast<int32_t>(error));
303 }
Dan Stoza651bf312015-10-23 17:03:17 -0700304 }
305}
306
Dan Stoza651bf312015-10-23 17:03:17 -0700307// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700308Error Display::acceptChanges()
309{
Steven Thomas94e35b92017-07-26 18:48:28 -0700310 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700311 return static_cast<Error>(intError);
312}
313
Lloyd Pique35d58242018-12-18 16:33:25 -0800314Error Display::createLayer(HWC2::Layer** outLayer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700315 if (!outLayer) {
316 return Error::BadParameter;
317 }
Dan Stoza651bf312015-10-23 17:03:17 -0700318 hwc2_layer_t layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700319 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700320 auto error = static_cast<Error>(intError);
321 if (error != Error::None) {
322 return error;
323 }
324
Lloyd Pique35d58242018-12-18 16:33:25 -0800325 auto layer = std::make_unique<impl::Layer>(mComposer, mCapabilities, mId, layerId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700326 *outLayer = layer.get();
327 mLayers.emplace(layerId, std::move(layer));
328 return Error::None;
329}
330
Lloyd Pique35d58242018-12-18 16:33:25 -0800331Error Display::destroyLayer(HWC2::Layer* layer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700332 if (!layer) {
333 return Error::BadParameter;
334 }
335 mLayers.erase(layer->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700336 return Error::None;
337}
338
339Error Display::getActiveConfig(
340 std::shared_ptr<const Display::Config>* outConfig) const
341{
342 ALOGV("[%" PRIu64 "] getActiveConfig", mId);
343 hwc2_config_t configId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700344 auto intError = mComposer.getActiveConfig(mId, &configId);
Dan Stoza651bf312015-10-23 17:03:17 -0700345 auto error = static_cast<Error>(intError);
346
347 if (error != Error::None) {
Fabien Sanglardb7432cc2016-11-11 09:40:27 -0800348 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
349 *outConfig = nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700350 return error;
351 }
352
353 if (mConfigs.count(configId) != 0) {
354 *outConfig = mConfigs.at(configId);
355 } else {
356 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
357 configId);
358 // Return no error, but the caller needs to check for a null pointer to
359 // detect this case
360 *outConfig = nullptr;
361 }
362
363 return Error::None;
364}
365
Lloyd Pique3c085a02018-05-09 19:38:32 -0700366Error Display::getActiveConfigIndex(int* outIndex) const {
367 ALOGV("[%" PRIu64 "] getActiveConfigIndex", mId);
368 hwc2_config_t configId = 0;
369 auto intError = mComposer.getActiveConfig(mId, &configId);
370 auto error = static_cast<Error>(intError);
371
372 if (error != Error::None) {
373 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
374 *outIndex = -1;
375 return error;
376 }
377
378 auto pos = mConfigs.find(configId);
379 if (pos != mConfigs.end()) {
380 *outIndex = std::distance(mConfigs.begin(), pos);
381 } else {
382 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId, configId);
383 // Return no error, but the caller needs to check for a negative index
384 // to detect this case
385 *outIndex = -1;
386 }
387
388 return Error::None;
389}
390
Lloyd Pique35d58242018-12-18 16:33:25 -0800391Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800392 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800393 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700394 auto intError = mComposer.getChangedCompositionTypes(
395 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800396 uint32_t numElements = layerIds.size();
397 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700398 error = static_cast<Error>(intError);
399 if (error != Error::None) {
400 return error;
401 }
402
403 outTypes->clear();
404 outTypes->reserve(numElements);
405 for (uint32_t element = 0; element < numElements; ++element) {
406 auto layer = getLayerById(layerIds[element]);
407 if (layer) {
408 auto type = static_cast<Composition>(types[element]);
409 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
410 layer->getId(), to_string(type).c_str());
411 outTypes->emplace(layer, type);
412 } else {
413 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
414 " on display %" PRIu64, layerIds[element], mId);
415 }
416 }
417
418 return Error::None;
419}
420
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700421Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700422{
Peiyong Linfd997e02018-03-28 15:29:00 -0700423 auto intError = mComposer.getColorModes(mId, outModes);
424 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700425}
426
Chia-I Wud7e01d72018-06-21 13:39:09 +0800427int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700428{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800429 int32_t supportedPerFrameMetadata = 0;
430
431 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
432 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700433
434 // Check whether a specific metadata type is supported. A metadata type is considered
435 // supported if and only if all required fields are supported.
436
437 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700438 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
439 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
440 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
441 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
442 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
443 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
444 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
445 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
446 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
447 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800448 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700449 }
450 // CTA861_3
451 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
452 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800453 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700454 }
455
Valerie Haue9e843a2018-12-18 13:39:23 -0800456 // HDR10PLUS
457 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
458 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
459 }
460
Chia-I Wud7e01d72018-06-21 13:39:09 +0800461 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700462}
463
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700464Error Display::getRenderIntents(ColorMode colorMode,
465 std::vector<RenderIntent>* outRenderIntents) const
466{
467 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
468 return static_cast<Error>(intError);
469}
470
471Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
472{
473 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
474 return static_cast<Error>(intError);
475}
476
Dan Stoza651bf312015-10-23 17:03:17 -0700477std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
478{
479 std::vector<std::shared_ptr<const Config>> configs;
480 for (const auto& element : mConfigs) {
481 configs.emplace_back(element.second);
482 }
483 return configs;
484}
485
486Error Display::getName(std::string* outName) const
487{
Steven Thomas94e35b92017-07-26 18:48:28 -0700488 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800489 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700490}
491
492Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800493 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800494 uint32_t intDisplayRequests;
495 std::vector<Hwc2::Layer> layerIds;
496 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700497 auto intError = mComposer.getDisplayRequests(
498 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800499 uint32_t numElements = layerIds.size();
500 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700501 if (error != Error::None) {
502 return error;
503 }
504
505 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
506 outLayerRequests->clear();
507 outLayerRequests->reserve(numElements);
508 for (uint32_t element = 0; element < numElements; ++element) {
509 auto layer = getLayerById(layerIds[element]);
510 if (layer) {
511 auto layerRequest =
512 static_cast<LayerRequest>(layerRequests[element]);
513 outLayerRequests->emplace(layer, layerRequest);
514 } else {
515 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
516 PRIu64, layerIds[element], mId);
517 }
518 }
519
520 return Error::None;
521}
522
523Error Display::getType(DisplayType* outType) const
524{
Chris Forbes016d73c2017-04-11 10:04:31 -0700525 *outType = mType;
Dan Stoza651bf312015-10-23 17:03:17 -0700526 return Error::None;
527}
528
Peiyong Lined531a32018-10-26 18:27:56 -0700529Error Display::supportsDoze(bool* outSupport) const {
530 *outSupport = mDisplayCapabilities.count(DisplayCapability::Doze) > 0;
Dan Stoza651bf312015-10-23 17:03:17 -0700531 return Error::None;
532}
533
Peiyong Lin62665892018-04-16 11:07:44 -0700534Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700535{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700536 float maxLuminance = -1.0f;
537 float maxAverageLuminance = -1.0f;
538 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700539 std::vector<Hwc2::Hdr> types;
540 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800541 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800542 auto error = static_cast<HWC2::Error>(intError);
543
Dan Stoza7d7ae732016-03-16 12:23:40 -0700544 if (error != Error::None) {
545 return error;
546 }
547
Peiyong Lin62665892018-04-16 11:07:44 -0700548 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700549 maxLuminance, maxAverageLuminance, minLuminance);
550 return Error::None;
551}
552
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700553Error Display::getDisplayedContentSamplingAttributes(PixelFormat* outFormat,
554 Dataspace* outDataspace,
555 uint8_t* outComponentMask) const {
556 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
557 outComponentMask);
558 return static_cast<Error>(intError);
559}
560
Kevin DuBois74e53772018-11-19 10:52:38 -0800561Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
562 uint64_t maxFrames) const {
563 auto intError =
564 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
565 return static_cast<Error>(intError);
566}
567
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700568Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
569 android::DisplayedFrameStats* outStats) const {
570 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
571 return static_cast<Error>(intError);
572}
573
Lloyd Pique35d58242018-12-18 16:33:25 -0800574Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800575 std::vector<Hwc2::Layer> layerIds;
576 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700577 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800578 auto error = static_cast<Error>(intError);
579 uint32_t numElements = layerIds.size();
Dan Stoza651bf312015-10-23 17:03:17 -0700580 if (error != Error::None) {
581 return error;
582 }
583
Lloyd Pique35d58242018-12-18 16:33:25 -0800584 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700585 releaseFences.reserve(numElements);
586 for (uint32_t element = 0; element < numElements; ++element) {
587 auto layer = getLayerById(layerIds[element]);
588 if (layer) {
589 sp<Fence> fence(new Fence(fenceFds[element]));
Steven Thomas94e35b92017-07-26 18:48:28 -0700590 releaseFences.emplace(layer, fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700591 } else {
592 ALOGE("getReleaseFences: invalid layer %" PRIu64
593 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700594 for (; element < numElements; ++element) {
595 close(fenceFds[element]);
596 }
Dan Stoza651bf312015-10-23 17:03:17 -0700597 return Error::BadLayer;
598 }
599 }
600
601 *outFences = std::move(releaseFences);
602 return Error::None;
603}
604
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800605Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700606{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400607 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700608 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700609 auto error = static_cast<Error>(intError);
610 if (error != Error::None) {
611 return error;
612 }
613
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800614 *outPresentFence = new Fence(presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700615 return Error::None;
616}
617
618Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
619{
620 if (config->getDisplayId() != mId) {
621 ALOGE("setActiveConfig received config %u for the wrong display %"
622 PRIu64 " (expected %" PRIu64 ")", config->getId(),
623 config->getDisplayId(), mId);
624 return Error::BadConfig;
625 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700626 auto intError = mComposer.setActiveConfig(mId, config->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700627 return static_cast<Error>(intError);
628}
629
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400630Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700631 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700632{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700633 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700634 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700635 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700636 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700637 return static_cast<Error>(intError);
638}
639
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700640Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700641{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700642 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700643 return static_cast<Error>(intError);
644}
645
Dan Stoza5df2a862016-03-24 16:19:37 -0700646Error Display::setColorTransform(const android::mat4& matrix,
647 android_color_transform_t hint)
648{
Steven Thomas94e35b92017-07-26 18:48:28 -0700649 auto intError = mComposer.setColorTransform(mId,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800650 matrix.asArray(), static_cast<Hwc2::ColorTransform>(hint));
Dan Stoza5df2a862016-03-24 16:19:37 -0700651 return static_cast<Error>(intError);
652}
653
Dan Stoza651bf312015-10-23 17:03:17 -0700654Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
655 const sp<Fence>& releaseFence)
656{
657 int32_t fenceFd = releaseFence->dup();
658 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700659 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700660 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700661 return static_cast<Error>(intError);
662}
663
664Error Display::setPowerMode(PowerMode mode)
665{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800666 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700667 auto intError = mComposer.setPowerMode(mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700668 return static_cast<Error>(intError);
669}
670
671Error Display::setVsyncEnabled(Vsync enabled)
672{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800673 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700674 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700675 return static_cast<Error>(intError);
676}
677
678Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
679{
680 uint32_t numTypes = 0;
681 uint32_t numRequests = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700682 auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700683 auto error = static_cast<Error>(intError);
684 if (error != Error::None && error != Error::HasChanges) {
685 return error;
686 }
687
688 *outNumTypes = numTypes;
689 *outNumRequests = numRequests;
690 return error;
691}
692
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700693Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
694 sp<android::Fence>* outPresentFence, uint32_t* state) {
695
696 uint32_t numTypes = 0;
697 uint32_t numRequests = 0;
698 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700699 auto intError = mComposer.presentOrValidateDisplay(
700 mId, &numTypes, &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700701 auto error = static_cast<Error>(intError);
702 if (error != Error::None && error != Error::HasChanges) {
703 return error;
704 }
705
706 if (*state == 1) {
707 *outPresentFence = new Fence(presentFenceFd);
708 }
709
710 if (*state == 0) {
711 *outNumTypes = numTypes;
712 *outNumRequests = numRequests;
713 }
714 return error;
715}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700716
Dan Gittik57e63c52019-01-18 16:37:54 +0000717Error Display::setDisplayBrightness(float brightness) const {
718 auto intError = mComposer.setDisplayBrightness(mId, brightness);
719 return static_cast<Error>(intError);
720}
721
Dan Stoza651bf312015-10-23 17:03:17 -0700722// For use by Device
723
Steven Thomas94e35b92017-07-26 18:48:28 -0700724void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800725 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700726 mComposer.setClientTargetSlotCount(mId);
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800727 if (mType == DisplayType::Physical) {
728 loadConfigs();
729 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700730 }
731 mIsConnected = connected;
732}
733
Dan Stoza651bf312015-10-23 17:03:17 -0700734int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
735{
736 int32_t value = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700737 auto intError = mComposer.getDisplayAttribute(mId, configId,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800738 static_cast<Hwc2::IComposerClient::Attribute>(attribute),
739 &value);
Dan Stoza651bf312015-10-23 17:03:17 -0700740 auto error = static_cast<Error>(intError);
741 if (error != Error::None) {
742 ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
743 configId, to_string(attribute).c_str(),
744 to_string(error).c_str(), intError);
745 return -1;
746 }
747 return value;
748}
749
750void Display::loadConfig(hwc2_config_t configId)
751{
752 ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
753
754 auto config = Config::Builder(*this, configId)
755 .setWidth(getAttribute(configId, Attribute::Width))
756 .setHeight(getAttribute(configId, Attribute::Height))
757 .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod))
758 .setDpiX(getAttribute(configId, Attribute::DpiX))
759 .setDpiY(getAttribute(configId, Attribute::DpiY))
760 .build();
761 mConfigs.emplace(configId, std::move(config));
762}
763
764void Display::loadConfigs()
765{
766 ALOGV("[%" PRIu64 "] loadConfigs", mId);
767
Chia-I Wuaab99f52016-10-05 12:59:58 +0800768 std::vector<Hwc2::Config> configIds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700769 auto intError = mComposer.getDisplayConfigs(mId, &configIds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800770 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700771 if (error != Error::None) {
772 ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
773 to_string(error).c_str(), intError);
774 return;
775 }
776
777 for (auto configId : configIds) {
778 loadConfig(configId);
779 }
780}
781
Dan Stoza651bf312015-10-23 17:03:17 -0700782// Other Display methods
783
Lloyd Pique35d58242018-12-18 16:33:25 -0800784HWC2::Layer* Display::getLayerById(hwc2_layer_t id) const {
Dan Stoza651bf312015-10-23 17:03:17 -0700785 if (mLayers.count(id) == 0) {
786 return nullptr;
787 }
788
Steven Thomas94e35b92017-07-26 18:48:28 -0700789 return mLayers.at(id).get();
Dan Stoza651bf312015-10-23 17:03:17 -0700790}
Ana Krulec4593b692019-01-11 22:07:25 -0800791} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700792
793// Layer methods
794
Lloyd Pique35d58242018-12-18 16:33:25 -0800795Layer::~Layer() = default;
796
797namespace impl {
798
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700799Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Steven Thomas94e35b92017-07-26 18:48:28 -0700800 hwc2_display_t displayId, hwc2_layer_t layerId)
801 : mComposer(composer),
802 mCapabilities(capabilities),
803 mDisplayId(displayId),
Peiyong Lin698147a2018-09-14 13:27:18 -0700804 mId(layerId),
805 mColorMatrix(android::mat4())
Dan Stoza651bf312015-10-23 17:03:17 -0700806{
Steven Thomas94e35b92017-07-26 18:48:28 -0700807 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700808}
809
810Layer::~Layer()
811{
Steven Thomas94e35b92017-07-26 18:48:28 -0700812 auto intError = mComposer.destroyLayer(mDisplayId, mId);
813 auto error = static_cast<Error>(intError);
814 ALOGE_IF(error != Error::None, "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
815 " failed: %s (%d)", mDisplayId, mId, to_string(error).c_str(),
816 intError);
Steven Thomas94e35b92017-07-26 18:48:28 -0700817}
818
Dan Stoza651bf312015-10-23 17:03:17 -0700819Error Layer::setCursorPosition(int32_t x, int32_t y)
820{
Steven Thomas94e35b92017-07-26 18:48:28 -0700821 auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700822 return static_cast<Error>(intError);
823}
824
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400825Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700826 const sp<Fence>& acquireFence)
827{
Yichi Chen8366f562019-03-25 19:44:06 +0800828 if (buffer == nullptr && mBufferSlot == slot) {
829 return Error::None;
830 }
831 mBufferSlot = slot;
832
Dan Stoza651bf312015-10-23 17:03:17 -0700833 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700834 auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
835 fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700836 return static_cast<Error>(intError);
837}
838
839Error Layer::setSurfaceDamage(const Region& damage)
840{
Yichi Chen8366f562019-03-25 19:44:06 +0800841 if (damage.isRect() && mDamageRegion.isRect() &&
842 (damage.getBounds() == mDamageRegion.getBounds())) {
843 return Error::None;
844 }
845 mDamageRegion = damage;
846
Dan Stoza651bf312015-10-23 17:03:17 -0700847 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
848 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800849 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700850 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700851 intError = mComposer.setLayerSurfaceDamage(mDisplayId,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800852 mId, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700853 } else {
854 size_t rectCount = 0;
855 auto rectArray = damage.getArray(&rectCount);
856
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800857 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700858 for (size_t rect = 0; rect < rectCount; ++rect) {
859 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
860 rectArray[rect].right, rectArray[rect].bottom});
861 }
862
Steven Thomas94e35b92017-07-26 18:48:28 -0700863 intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700864 }
865
866 return static_cast<Error>(intError);
867}
868
869Error Layer::setBlendMode(BlendMode mode)
870{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800871 auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700872 auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700873 return static_cast<Error>(intError);
874}
875
876Error Layer::setColor(hwc_color_t color)
877{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800878 Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
Steven Thomas94e35b92017-07-26 18:48:28 -0700879 auto intError = mComposer.setLayerColor(mDisplayId, mId, hwcColor);
Dan Stoza651bf312015-10-23 17:03:17 -0700880 return static_cast<Error>(intError);
881}
882
883Error Layer::setCompositionType(Composition type)
884{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800885 auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
Steven Thomas94e35b92017-07-26 18:48:28 -0700886 auto intError = mComposer.setLayerCompositionType(
887 mDisplayId, mId, intType);
Dan Stoza651bf312015-10-23 17:03:17 -0700888 return static_cast<Error>(intError);
889}
890
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700891Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700892{
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600893 if (dataspace == mDataSpace) {
894 return Error::None;
895 }
896 mDataSpace = dataspace;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700897 auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700898 return static_cast<Error>(intError);
899}
900
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700901Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
902 const android::HdrMetadata& metadata)
903{
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700904 if (metadata == mHdrMetadata) {
905 return Error::None;
906 }
907
908 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700909 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
910 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
911 if (validTypes & HdrMetadata::SMPTE2086) {
912 perFrameMetadatas.insert(perFrameMetadatas.end(),
913 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800914 mHdrMetadata.smpte2086.displayPrimaryRed.x},
915 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
916 mHdrMetadata.smpte2086.displayPrimaryRed.y},
917 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
918 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
919 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
920 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
921 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
922 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
923 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
924 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
925 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
926 mHdrMetadata.smpte2086.whitePoint.x},
927 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
928 mHdrMetadata.smpte2086.whitePoint.y},
929 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
930 mHdrMetadata.smpte2086.maxLuminance},
931 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
932 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700933 }
934
935 if (validTypes & HdrMetadata::CTA861_3) {
936 perFrameMetadatas.insert(perFrameMetadatas.end(),
937 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800938 mHdrMetadata.cta8613.maxContentLightLevel},
939 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
940 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700941 }
942
Valerie Haue9e843a2018-12-18 13:39:23 -0800943 Error error = static_cast<Error>(
944 mComposer.setLayerPerFrameMetadata(mDisplayId, mId, perFrameMetadatas));
945
946 if (validTypes & HdrMetadata::HDR10PLUS) {
947 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
948 perFrameMetadataBlobs.push_back(
949 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
950 Error setMetadataBlobsError = static_cast<Error>(
951 mComposer.setLayerPerFrameMetadataBlobs(mDisplayId, mId, perFrameMetadataBlobs));
952 if (error == Error::None) {
953 return setMetadataBlobsError;
954 }
955 }
956 return error;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700957}
958
Dan Stoza651bf312015-10-23 17:03:17 -0700959Error Layer::setDisplayFrame(const Rect& frame)
960{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800961 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800962 frame.right, frame.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700963 auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700964 return static_cast<Error>(intError);
965}
966
967Error Layer::setPlaneAlpha(float alpha)
968{
Steven Thomas94e35b92017-07-26 18:48:28 -0700969 auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700970 return static_cast<Error>(intError);
971}
972
973Error Layer::setSidebandStream(const native_handle_t* stream)
974{
Steven Thomas94e35b92017-07-26 18:48:28 -0700975 if (mCapabilities.count(Capability::SidebandStream) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700976 ALOGE("Attempted to call setSidebandStream without checking that the "
977 "device supports sideband streams");
978 return Error::Unsupported;
979 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700980 auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700981 return static_cast<Error>(intError);
982}
983
984Error Layer::setSourceCrop(const FloatRect& crop)
985{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800986 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800987 crop.left, crop.top, crop.right, crop.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700988 auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700989 return static_cast<Error>(intError);
990}
991
992Error Layer::setTransform(Transform transform)
993{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800994 auto intTransform = static_cast<Hwc2::Transform>(transform);
Steven Thomas94e35b92017-07-26 18:48:28 -0700995 auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700996 return static_cast<Error>(intError);
997}
998
999Error Layer::setVisibleRegion(const Region& region)
1000{
Yichi Chen8366f562019-03-25 19:44:06 +08001001 if (region.isRect() && mVisibleRegion.isRect() &&
1002 (region.getBounds() == mVisibleRegion.getBounds())) {
1003 return Error::None;
1004 }
1005 mVisibleRegion = region;
1006
Dan Stoza651bf312015-10-23 17:03:17 -07001007 size_t rectCount = 0;
1008 auto rectArray = region.getArray(&rectCount);
1009
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001010 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -07001011 for (size_t rect = 0; rect < rectCount; ++rect) {
1012 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
1013 rectArray[rect].right, rectArray[rect].bottom});
1014 }
1015
Steven Thomas94e35b92017-07-26 18:48:28 -07001016 auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -07001017 return static_cast<Error>(intError);
1018}
1019
1020Error Layer::setZOrder(uint32_t z)
1021{
Steven Thomas94e35b92017-07-26 18:48:28 -07001022 auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -07001023 return static_cast<Error>(intError);
1024}
1025
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001026Error Layer::setInfo(uint32_t type, uint32_t appId)
1027{
Steven Thomas94e35b92017-07-26 18:48:28 -07001028 auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001029 return static_cast<Error>(intError);
1030}
1031
Peiyong Lin698147a2018-09-14 13:27:18 -07001032// Composer HAL 2.3
1033Error Layer::setColorTransform(const android::mat4& matrix) {
1034 if (matrix == mColorMatrix) {
1035 return Error::None;
1036 }
1037 mColorMatrix = matrix;
1038 auto intError = mComposer.setLayerColorTransform(mDisplayId, mId, matrix.asArray());
1039 return static_cast<Error>(intError);
1040}
Lloyd Pique35d58242018-12-18 16:33:25 -08001041
1042} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -07001043} // namespace HWC2