blob: add93fd3be0022882a2deaa1bef8b2af2dfebc00 [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>
29#include <ui/Region.h>
30
31#include <android/configuration.h>
32
33#include <inttypes.h>
Lloyd Pique3c085a02018-05-09 19:38:32 -070034#include <algorithm>
35#include <iterator>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070036#include <set>
Dan Stoza651bf312015-10-23 17:03:17 -070037
Dan Stoza651bf312015-10-23 17:03:17 -070038using android::Fence;
Dan Stoza5a423ea2017-02-16 14:10:39 -080039using android::FloatRect;
Dan Stoza651bf312015-10-23 17:03:17 -070040using android::GraphicBuffer;
Dan Stoza7d7ae732016-03-16 12:23:40 -070041using android::HdrCapabilities;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070042using android::HdrMetadata;
Dan Stoza651bf312015-10-23 17:03:17 -070043using android::Rect;
44using android::Region;
45using android::sp;
Chia-I Wuaab99f52016-10-05 12:59:58 +080046using android::hardware::Return;
47using android::hardware::Void;
Dan Stoza651bf312015-10-23 17:03:17 -070048
49namespace HWC2 {
50
Chia-I Wuaab99f52016-10-05 12:59:58 +080051namespace Hwc2 = android::Hwc2;
Peiyong Lin34beb7a2018-03-28 11:57:12 -070052using android::ui::ColorMode;
53using android::ui::Dataspace;
54using android::ui::PixelFormat;
Peiyong Lin0e7a7912018-04-05 14:36:36 -070055using android::ui::RenderIntent;
Chia-I Wuaab99f52016-10-05 12:59:58 +080056
Steven Thomas94e35b92017-07-26 18:48:28 -070057namespace {
58
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070059inline bool hasMetadataKey(const std::set<Hwc2::PerFrameMetadataKey>& keys,
60 const Hwc2::PerFrameMetadataKey& key) {
61 return keys.find(key) != keys.end();
62}
63
Steven Thomas94e35b92017-07-26 18:48:28 -070064class ComposerCallbackBridge : public Hwc2::IComposerCallback {
65public:
66 ComposerCallbackBridge(ComposerCallback* callback, int32_t sequenceId)
Lloyd Pique715a2c12017-12-14 17:18:08 -080067 : mCallback(callback), mSequenceId(sequenceId) {}
Steven Thomas94e35b92017-07-26 18:48:28 -070068
69 Return<void> onHotplug(Hwc2::Display display,
70 IComposerCallback::Connection conn) override
71 {
72 HWC2::Connection connection = static_cast<HWC2::Connection>(conn);
Lloyd Pique715a2c12017-12-14 17:18:08 -080073 mCallback->onHotplugReceived(mSequenceId, display, connection);
Steven Thomas94e35b92017-07-26 18:48:28 -070074 return Void();
75 }
76
77 Return<void> onRefresh(Hwc2::Display display) override
78 {
79 mCallback->onRefreshReceived(mSequenceId, display);
80 return Void();
81 }
82
83 Return<void> onVsync(Hwc2::Display display, int64_t timestamp) override
84 {
85 mCallback->onVsyncReceived(mSequenceId, display, timestamp);
86 return Void();
87 }
88
Steven Thomas94e35b92017-07-26 18:48:28 -070089private:
90 ComposerCallback* mCallback;
91 int32_t mSequenceId;
Steven Thomas94e35b92017-07-26 18:48:28 -070092};
93
94} // namespace anonymous
95
96
Dan Stoza651bf312015-10-23 17:03:17 -070097// Device methods
98
Lloyd Piquea822d522017-12-20 16:42:57 -080099Device::Device(std::unique_ptr<android::Hwc2::Composer> composer) : mComposer(std::move(composer)) {
Dan Stoza651bf312015-10-23 17:03:17 -0700100 loadCapabilities();
Dan Stoza651bf312015-10-23 17:03:17 -0700101}
102
Steven Thomas94e35b92017-07-26 18:48:28 -0700103void Device::registerCallback(ComposerCallback* callback, int32_t sequenceId) {
104 if (mRegisteredCallback) {
105 ALOGW("Callback already registered. Ignored extra registration "
106 "attempt.");
107 return;
Dan Stoza651bf312015-10-23 17:03:17 -0700108 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700109 mRegisteredCallback = true;
110 sp<ComposerCallbackBridge> callbackBridge(
111 new ComposerCallbackBridge(callback, sequenceId));
112 mComposer->registerCallback(callbackBridge);
Dan Stoza651bf312015-10-23 17:03:17 -0700113}
114
115// Required by HWC2 device
116
117std::string Device::dump() const
118{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800119 return mComposer->dumpDebugInfo();
Dan Stoza651bf312015-10-23 17:03:17 -0700120}
121
122uint32_t Device::getMaxVirtualDisplayCount() const
123{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800124 return mComposer->getMaxVirtualDisplayCount();
Dan Stoza651bf312015-10-23 17:03:17 -0700125}
126
Dominik Laskowski0954b1d2018-06-13 14:58:49 -0700127Error Device::getDisplayIdentificationData(hwc2_display_t hwcDisplayId, uint8_t* outPort,
128 std::vector<uint8_t>* outData) const {
129 auto intError = mComposer->getDisplayIdentificationData(hwcDisplayId, outPort, outData);
130 return static_cast<Error>(intError);
131}
132
Dan Stoza651bf312015-10-23 17:03:17 -0700133Error Device::createVirtualDisplay(uint32_t width, uint32_t height,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700134 PixelFormat* format, Display** outDisplay)
Dan Stoza651bf312015-10-23 17:03:17 -0700135{
136 ALOGI("Creating virtual display");
137
138 hwc2_display_t displayId = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800139 auto intError = mComposer->createVirtualDisplay(width, height,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700140 format, &displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700141 auto error = static_cast<Error>(intError);
142 if (error != Error::None) {
143 return error;
144 }
145
Steven Thomas94e35b92017-07-26 18:48:28 -0700146 auto display = std::make_unique<Display>(
Michael Wright5d22d4f2018-06-21 02:50:34 +0100147 *mComposer.get(), mPowerAdvisor, mCapabilities, displayId, DisplayType::Virtual);
Lloyd Piquebc792092018-01-17 11:52:30 -0800148 display->setConnected(true);
Steven Thomas94e35b92017-07-26 18:48:28 -0700149 *outDisplay = display.get();
Steven Thomas94e35b92017-07-26 18:48:28 -0700150 mDisplays.emplace(displayId, std::move(display));
151 ALOGI("Created virtual display");
Dan Stoza651bf312015-10-23 17:03:17 -0700152 return Error::None;
153}
154
Steven Thomas94e35b92017-07-26 18:48:28 -0700155void Device::destroyDisplay(hwc2_display_t displayId)
Dan Stoza651bf312015-10-23 17:03:17 -0700156{
Steven Thomas94e35b92017-07-26 18:48:28 -0700157 ALOGI("Destroying display %" PRIu64, displayId);
158 mDisplays.erase(displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700159}
160
Steven Thomas94e35b92017-07-26 18:48:28 -0700161void Device::onHotplug(hwc2_display_t displayId, Connection connection) {
162 if (connection == Connection::Connected) {
Steven Thomas3bed0522018-03-20 15:40:48 -0700163 // If we get a hotplug connected event for a display we already have,
164 // destroy the display and recreate it. This will force us to requery
165 // the display params and recreate all layers on that display.
166 auto oldDisplay = getDisplayById(displayId);
167 if (oldDisplay != nullptr && oldDisplay->isConnected()) {
168 ALOGI("Hotplug connecting an already connected display."
169 " Clearing old display state.");
Dan Stoza651bf312015-10-23 17:03:17 -0700170 }
Steven Thomas3bed0522018-03-20 15:40:48 -0700171 mDisplays.erase(displayId);
172
173 DisplayType displayType;
174 auto intError = mComposer->getDisplayType(displayId,
175 reinterpret_cast<Hwc2::IComposerClient::DisplayType *>(
176 &displayType));
177 auto error = static_cast<Error>(intError);
178 if (error != Error::None) {
179 ALOGE("getDisplayType(%" PRIu64 ") failed: %s (%d). "
180 "Aborting hotplug attempt.",
181 displayId, to_string(error).c_str(), intError);
182 return;
183 }
184
185 auto newDisplay = std::make_unique<Display>(
Michael Wright5d22d4f2018-06-21 02:50:34 +0100186 *mComposer.get(), mPowerAdvisor, mCapabilities, displayId, displayType);
Lloyd Piquebc792092018-01-17 11:52:30 -0800187 newDisplay->setConnected(true);
Steven Thomas3bed0522018-03-20 15:40:48 -0700188 mDisplays.emplace(displayId, std::move(newDisplay));
Steven Thomas94e35b92017-07-26 18:48:28 -0700189 } else if (connection == Connection::Disconnected) {
190 // The display will later be destroyed by a call to
191 // destroyDisplay(). For now we just mark it disconnected.
192 auto display = getDisplayById(displayId);
193 if (display) {
194 display->setConnected(false);
195 } else {
196 ALOGW("Attempted to disconnect unknown display %" PRIu64,
197 displayId);
198 }
Dan Stoza651bf312015-10-23 17:03:17 -0700199 }
200}
201
202// Other Device methods
203
Steven Thomas94e35b92017-07-26 18:48:28 -0700204Display* Device::getDisplayById(hwc2_display_t id) {
205 auto iter = mDisplays.find(id);
206 return iter == mDisplays.end() ? nullptr : iter->second.get();
Dan Stoza651bf312015-10-23 17:03:17 -0700207}
208
209// Device initialization methods
210
211void Device::loadCapabilities()
212{
213 static_assert(sizeof(Capability) == sizeof(int32_t),
214 "Capability size has changed");
Chia-I Wuaab99f52016-10-05 12:59:58 +0800215 auto capabilities = mComposer->getCapabilities();
216 for (auto capability : capabilities) {
217 mCapabilities.emplace(static_cast<Capability>(capability));
218 }
Dan Stoza651bf312015-10-23 17:03:17 -0700219}
220
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700221Error Device::flushCommands()
222{
223 return static_cast<Error>(mComposer->executeCommands());
224}
225
Dan Stoza651bf312015-10-23 17:03:17 -0700226// Display methods
227
Michael Wright5d22d4f2018-06-21 02:50:34 +0100228Display::Display(android::Hwc2::Composer& composer, android::Hwc2::PowerAdvisor& advisor,
Lloyd Piquebc792092018-01-17 11:52:30 -0800229 const std::unordered_set<Capability>& capabilities, hwc2_display_t id,
230 DisplayType type)
231 : mComposer(composer),
Michael Wright5d22d4f2018-06-21 02:50:34 +0100232 mPowerAdvisor(advisor),
Lloyd Piquebc792092018-01-17 11:52:30 -0800233 mCapabilities(capabilities),
234 mId(id),
235 mIsConnected(false),
236 mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -0700237 ALOGV("Created display %" PRIu64, id);
238}
239
Steven Thomas94e35b92017-07-26 18:48:28 -0700240Display::~Display() {
241 mLayers.clear();
242
Chris Forbesceb67d12017-04-11 12:20:00 -0700243 if (mType == DisplayType::Virtual) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700244 ALOGV("Destroying virtual display");
245 auto intError = mComposer.destroyVirtualDisplay(mId);
246 auto error = static_cast<Error>(intError);
247 ALOGE_IF(error != Error::None, "destroyVirtualDisplay(%" PRIu64
248 ") failed: %s (%d)", mId, to_string(error).c_str(), intError);
249 } else if (mType == DisplayType::Physical) {
250 auto error = setVsyncEnabled(HWC2::Vsync::Disable);
251 if (error != Error::None) {
252 ALOGE("~Display: Failed to disable vsync for display %" PRIu64
253 ": %s (%d)", mId, to_string(error).c_str(),
254 static_cast<int32_t>(error));
255 }
Dan Stoza651bf312015-10-23 17:03:17 -0700256 }
257}
258
259Display::Config::Config(Display& display, hwc2_config_t id)
260 : mDisplay(display),
261 mId(id),
262 mWidth(-1),
263 mHeight(-1),
264 mVsyncPeriod(-1),
265 mDpiX(-1),
266 mDpiY(-1) {}
267
268Display::Config::Builder::Builder(Display& display, hwc2_config_t id)
269 : mConfig(new Config(display, id)) {}
270
271float Display::Config::Builder::getDefaultDensity() {
272 // Default density is based on TVs: 1080p displays get XHIGH density, lower-
273 // resolution displays get TV density. Maybe eventually we'll need to update
274 // it for 4k displays, though hopefully those will just report accurate DPI
275 // information to begin with. This is also used for virtual displays and
276 // older HWC implementations, so be careful about orientation.
277
278 auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
279 if (longDimension >= 1080) {
280 return ACONFIGURATION_DENSITY_XHIGH;
281 } else {
282 return ACONFIGURATION_DENSITY_TV;
283 }
284}
285
286// Required by HWC2 display
287
288Error Display::acceptChanges()
289{
Steven Thomas94e35b92017-07-26 18:48:28 -0700290 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700291 return static_cast<Error>(intError);
292}
293
Steven Thomas94e35b92017-07-26 18:48:28 -0700294Error Display::createLayer(Layer** outLayer)
Dan Stoza651bf312015-10-23 17:03:17 -0700295{
Steven Thomas94e35b92017-07-26 18:48:28 -0700296 if (!outLayer) {
297 return Error::BadParameter;
298 }
Dan Stoza651bf312015-10-23 17:03:17 -0700299 hwc2_layer_t layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700300 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700301 auto error = static_cast<Error>(intError);
302 if (error != Error::None) {
303 return error;
304 }
305
Steven Thomas94e35b92017-07-26 18:48:28 -0700306 auto layer = std::make_unique<Layer>(
307 mComposer, mCapabilities, mId, layerId);
308 *outLayer = layer.get();
309 mLayers.emplace(layerId, std::move(layer));
310 return Error::None;
311}
312
313Error Display::destroyLayer(Layer* layer)
314{
315 if (!layer) {
316 return Error::BadParameter;
317 }
318 mLayers.erase(layer->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700319 return Error::None;
320}
321
322Error Display::getActiveConfig(
323 std::shared_ptr<const Display::Config>* outConfig) const
324{
325 ALOGV("[%" PRIu64 "] getActiveConfig", mId);
326 hwc2_config_t configId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700327 auto intError = mComposer.getActiveConfig(mId, &configId);
Dan Stoza651bf312015-10-23 17:03:17 -0700328 auto error = static_cast<Error>(intError);
329
330 if (error != Error::None) {
Fabien Sanglardb7432cc2016-11-11 09:40:27 -0800331 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
332 *outConfig = nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700333 return error;
334 }
335
336 if (mConfigs.count(configId) != 0) {
337 *outConfig = mConfigs.at(configId);
338 } else {
339 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
340 configId);
341 // Return no error, but the caller needs to check for a null pointer to
342 // detect this case
343 *outConfig = nullptr;
344 }
345
346 return Error::None;
347}
348
Lloyd Pique3c085a02018-05-09 19:38:32 -0700349Error Display::getActiveConfigIndex(int* outIndex) const {
350 ALOGV("[%" PRIu64 "] getActiveConfigIndex", mId);
351 hwc2_config_t configId = 0;
352 auto intError = mComposer.getActiveConfig(mId, &configId);
353 auto error = static_cast<Error>(intError);
354
355 if (error != Error::None) {
356 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
357 *outIndex = -1;
358 return error;
359 }
360
361 auto pos = mConfigs.find(configId);
362 if (pos != mConfigs.end()) {
363 *outIndex = std::distance(mConfigs.begin(), pos);
364 } else {
365 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId, configId);
366 // Return no error, but the caller needs to check for a negative index
367 // to detect this case
368 *outIndex = -1;
369 }
370
371 return Error::None;
372}
373
Dan Stoza651bf312015-10-23 17:03:17 -0700374Error Display::getChangedCompositionTypes(
Steven Thomas94e35b92017-07-26 18:48:28 -0700375 std::unordered_map<Layer*, Composition>* outTypes)
Dan Stoza651bf312015-10-23 17:03:17 -0700376{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800377 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800378 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700379 auto intError = mComposer.getChangedCompositionTypes(
380 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800381 uint32_t numElements = layerIds.size();
382 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700383 error = static_cast<Error>(intError);
384 if (error != Error::None) {
385 return error;
386 }
387
388 outTypes->clear();
389 outTypes->reserve(numElements);
390 for (uint32_t element = 0; element < numElements; ++element) {
391 auto layer = getLayerById(layerIds[element]);
392 if (layer) {
393 auto type = static_cast<Composition>(types[element]);
394 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
395 layer->getId(), to_string(type).c_str());
396 outTypes->emplace(layer, type);
397 } else {
398 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
399 " on display %" PRIu64, layerIds[element], mId);
400 }
401 }
402
403 return Error::None;
404}
405
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700406Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700407{
Peiyong Linfd997e02018-03-28 15:29:00 -0700408 auto intError = mComposer.getColorModes(mId, outModes);
409 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700410}
411
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700412Error Display::getSupportedPerFrameMetadata(int32_t* outSupportedPerFrameMetadata) const
413{
414 *outSupportedPerFrameMetadata = 0;
415 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys;
416 auto intError = mComposer.getPerFrameMetadataKeys(mId, &tmpKeys);
417 auto error = static_cast<Error>(intError);
418 if (error != Error::None) {
419 return error;
420 }
421
422 // Check whether a specific metadata type is supported. A metadata type is considered
423 // supported if and only if all required fields are supported.
424
425 // SMPTE2086
426 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
427 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
428 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
429 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
430 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
431 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
432 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
433 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
434 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
435 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
436 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
437 *outSupportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
438 }
439 // CTA861_3
440 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
441 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
442 *outSupportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
443 }
444
445 return Error::None;
446}
447
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700448Error Display::getRenderIntents(ColorMode colorMode,
449 std::vector<RenderIntent>* outRenderIntents) const
450{
451 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
452 return static_cast<Error>(intError);
453}
454
455Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
456{
457 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
458 return static_cast<Error>(intError);
459}
460
Dan Stoza651bf312015-10-23 17:03:17 -0700461std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
462{
463 std::vector<std::shared_ptr<const Config>> configs;
464 for (const auto& element : mConfigs) {
465 configs.emplace_back(element.second);
466 }
467 return configs;
468}
469
470Error Display::getName(std::string* outName) const
471{
Steven Thomas94e35b92017-07-26 18:48:28 -0700472 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800473 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700474}
475
476Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Steven Thomas94e35b92017-07-26 18:48:28 -0700477 std::unordered_map<Layer*, LayerRequest>* outLayerRequests)
Dan Stoza651bf312015-10-23 17:03:17 -0700478{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800479 uint32_t intDisplayRequests;
480 std::vector<Hwc2::Layer> layerIds;
481 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700482 auto intError = mComposer.getDisplayRequests(
483 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800484 uint32_t numElements = layerIds.size();
485 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700486 if (error != Error::None) {
487 return error;
488 }
489
490 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
491 outLayerRequests->clear();
492 outLayerRequests->reserve(numElements);
493 for (uint32_t element = 0; element < numElements; ++element) {
494 auto layer = getLayerById(layerIds[element]);
495 if (layer) {
496 auto layerRequest =
497 static_cast<LayerRequest>(layerRequests[element]);
498 outLayerRequests->emplace(layer, layerRequest);
499 } else {
500 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
501 PRIu64, layerIds[element], mId);
502 }
503 }
504
505 return Error::None;
506}
507
508Error Display::getType(DisplayType* outType) const
509{
Chris Forbes016d73c2017-04-11 10:04:31 -0700510 *outType = mType;
Dan Stoza651bf312015-10-23 17:03:17 -0700511 return Error::None;
512}
513
514Error Display::supportsDoze(bool* outSupport) const
515{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800516 bool intSupport = false;
Steven Thomas94e35b92017-07-26 18:48:28 -0700517 auto intError = mComposer.getDozeSupport(mId, &intSupport);
Dan Stoza651bf312015-10-23 17:03:17 -0700518 auto error = static_cast<Error>(intError);
519 if (error != Error::None) {
520 return error;
521 }
522 *outSupport = static_cast<bool>(intSupport);
523 return Error::None;
524}
525
Peiyong Lin62665892018-04-16 11:07:44 -0700526Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700527{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700528 float maxLuminance = -1.0f;
529 float maxAverageLuminance = -1.0f;
530 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700531 std::vector<Hwc2::Hdr> types;
532 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800533 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800534 auto error = static_cast<HWC2::Error>(intError);
535
Dan Stoza7d7ae732016-03-16 12:23:40 -0700536 if (error != Error::None) {
537 return error;
538 }
539
Peiyong Lin62665892018-04-16 11:07:44 -0700540 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700541 maxLuminance, maxAverageLuminance, minLuminance);
542 return Error::None;
543}
544
Dan Stoza651bf312015-10-23 17:03:17 -0700545Error Display::getReleaseFences(
Steven Thomas94e35b92017-07-26 18:48:28 -0700546 std::unordered_map<Layer*, sp<Fence>>* outFences) const
Dan Stoza651bf312015-10-23 17:03:17 -0700547{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800548 std::vector<Hwc2::Layer> layerIds;
549 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700550 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800551 auto error = static_cast<Error>(intError);
552 uint32_t numElements = layerIds.size();
Dan Stoza651bf312015-10-23 17:03:17 -0700553 if (error != Error::None) {
554 return error;
555 }
556
Steven Thomas94e35b92017-07-26 18:48:28 -0700557 std::unordered_map<Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700558 releaseFences.reserve(numElements);
559 for (uint32_t element = 0; element < numElements; ++element) {
560 auto layer = getLayerById(layerIds[element]);
561 if (layer) {
562 sp<Fence> fence(new Fence(fenceFds[element]));
Steven Thomas94e35b92017-07-26 18:48:28 -0700563 releaseFences.emplace(layer, fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700564 } else {
565 ALOGE("getReleaseFences: invalid layer %" PRIu64
566 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700567 for (; element < numElements; ++element) {
568 close(fenceFds[element]);
569 }
Dan Stoza651bf312015-10-23 17:03:17 -0700570 return Error::BadLayer;
571 }
572 }
573
574 *outFences = std::move(releaseFences);
575 return Error::None;
576}
577
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800578Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700579{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400580 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700581 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700582 auto error = static_cast<Error>(intError);
583 if (error != Error::None) {
584 return error;
585 }
586
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800587 *outPresentFence = new Fence(presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700588 return Error::None;
589}
590
591Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
592{
593 if (config->getDisplayId() != mId) {
594 ALOGE("setActiveConfig received config %u for the wrong display %"
595 PRIu64 " (expected %" PRIu64 ")", config->getId(),
596 config->getDisplayId(), mId);
597 return Error::BadConfig;
598 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700599 auto intError = mComposer.setActiveConfig(mId, config->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700600 return static_cast<Error>(intError);
601}
602
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400603Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700604 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700605{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700606 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700607 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700608 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700609 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700610 return static_cast<Error>(intError);
611}
612
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700613Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700614{
Michael Wright5d22d4f2018-06-21 02:50:34 +0100615 // When the color mode is switched to DISPLAY_P3, we want to boost the GPU frequency
616 // so that GPU composition can finish in time. When color mode is switched from
617 // DISPLAY_P3, we want to reset GPU frequency.
618 const bool expensiveRenderingExpected = (mode == ColorMode::DISPLAY_P3);
619 mPowerAdvisor.setExpensiveRenderingExpected(mId, expensiveRenderingExpected);
620
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700621 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700622 return static_cast<Error>(intError);
623}
624
Dan Stoza5df2a862016-03-24 16:19:37 -0700625Error Display::setColorTransform(const android::mat4& matrix,
626 android_color_transform_t hint)
627{
Steven Thomas94e35b92017-07-26 18:48:28 -0700628 auto intError = mComposer.setColorTransform(mId,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800629 matrix.asArray(), static_cast<Hwc2::ColorTransform>(hint));
Dan Stoza5df2a862016-03-24 16:19:37 -0700630 return static_cast<Error>(intError);
631}
632
Dan Stoza651bf312015-10-23 17:03:17 -0700633Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
634 const sp<Fence>& releaseFence)
635{
636 int32_t fenceFd = releaseFence->dup();
637 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700638 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700639 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700640 return static_cast<Error>(intError);
641}
642
643Error Display::setPowerMode(PowerMode mode)
644{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800645 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700646 auto intError = mComposer.setPowerMode(mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700647 return static_cast<Error>(intError);
648}
649
650Error Display::setVsyncEnabled(Vsync enabled)
651{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800652 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700653 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700654 return static_cast<Error>(intError);
655}
656
657Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
658{
659 uint32_t numTypes = 0;
660 uint32_t numRequests = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700661 auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700662 auto error = static_cast<Error>(intError);
663 if (error != Error::None && error != Error::HasChanges) {
664 return error;
665 }
666
667 *outNumTypes = numTypes;
668 *outNumRequests = numRequests;
669 return error;
670}
671
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700672Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
673 sp<android::Fence>* outPresentFence, uint32_t* state) {
674
675 uint32_t numTypes = 0;
676 uint32_t numRequests = 0;
677 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700678 auto intError = mComposer.presentOrValidateDisplay(
679 mId, &numTypes, &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700680 auto error = static_cast<Error>(intError);
681 if (error != Error::None && error != Error::HasChanges) {
682 return error;
683 }
684
685 if (*state == 1) {
686 *outPresentFence = new Fence(presentFenceFd);
687 }
688
689 if (*state == 0) {
690 *outNumTypes = numTypes;
691 *outNumRequests = numRequests;
692 }
693 return error;
694}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700695
Dan Stoza651bf312015-10-23 17:03:17 -0700696// For use by Device
697
Steven Thomas94e35b92017-07-26 18:48:28 -0700698void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800699 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700700 mComposer.setClientTargetSlotCount(mId);
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800701 if (mType == DisplayType::Physical) {
702 loadConfigs();
703 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700704 }
705 mIsConnected = connected;
706}
707
Dan Stoza651bf312015-10-23 17:03:17 -0700708int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
709{
710 int32_t value = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700711 auto intError = mComposer.getDisplayAttribute(mId, configId,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800712 static_cast<Hwc2::IComposerClient::Attribute>(attribute),
713 &value);
Dan Stoza651bf312015-10-23 17:03:17 -0700714 auto error = static_cast<Error>(intError);
715 if (error != Error::None) {
716 ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
717 configId, to_string(attribute).c_str(),
718 to_string(error).c_str(), intError);
719 return -1;
720 }
721 return value;
722}
723
724void Display::loadConfig(hwc2_config_t configId)
725{
726 ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
727
728 auto config = Config::Builder(*this, configId)
729 .setWidth(getAttribute(configId, Attribute::Width))
730 .setHeight(getAttribute(configId, Attribute::Height))
731 .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod))
732 .setDpiX(getAttribute(configId, Attribute::DpiX))
733 .setDpiY(getAttribute(configId, Attribute::DpiY))
734 .build();
735 mConfigs.emplace(configId, std::move(config));
736}
737
738void Display::loadConfigs()
739{
740 ALOGV("[%" PRIu64 "] loadConfigs", mId);
741
Chia-I Wuaab99f52016-10-05 12:59:58 +0800742 std::vector<Hwc2::Config> configIds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700743 auto intError = mComposer.getDisplayConfigs(mId, &configIds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800744 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700745 if (error != Error::None) {
746 ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
747 to_string(error).c_str(), intError);
748 return;
749 }
750
751 for (auto configId : configIds) {
752 loadConfig(configId);
753 }
754}
755
Dan Stoza651bf312015-10-23 17:03:17 -0700756// Other Display methods
757
Steven Thomas94e35b92017-07-26 18:48:28 -0700758Layer* Display::getLayerById(hwc2_layer_t id) const
Dan Stoza651bf312015-10-23 17:03:17 -0700759{
760 if (mLayers.count(id) == 0) {
761 return nullptr;
762 }
763
Steven Thomas94e35b92017-07-26 18:48:28 -0700764 return mLayers.at(id).get();
Dan Stoza651bf312015-10-23 17:03:17 -0700765}
766
767// Layer methods
768
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700769Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Steven Thomas94e35b92017-07-26 18:48:28 -0700770 hwc2_display_t displayId, hwc2_layer_t layerId)
771 : mComposer(composer),
772 mCapabilities(capabilities),
773 mDisplayId(displayId),
774 mId(layerId)
Dan Stoza651bf312015-10-23 17:03:17 -0700775{
Steven Thomas94e35b92017-07-26 18:48:28 -0700776 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700777}
778
779Layer::~Layer()
780{
Steven Thomas94e35b92017-07-26 18:48:28 -0700781 auto intError = mComposer.destroyLayer(mDisplayId, mId);
782 auto error = static_cast<Error>(intError);
783 ALOGE_IF(error != Error::None, "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
784 " failed: %s (%d)", mDisplayId, mId, to_string(error).c_str(),
785 intError);
786 if (mLayerDestroyedListener) {
787 mLayerDestroyedListener(this);
Dan Stoza651bf312015-10-23 17:03:17 -0700788 }
789}
790
Steven Thomas94e35b92017-07-26 18:48:28 -0700791void Layer::setLayerDestroyedListener(std::function<void(Layer*)> listener) {
792 LOG_ALWAYS_FATAL_IF(mLayerDestroyedListener && listener,
793 "Attempt to set layer destroyed listener multiple times");
794 mLayerDestroyedListener = listener;
795}
796
Dan Stoza651bf312015-10-23 17:03:17 -0700797Error Layer::setCursorPosition(int32_t x, int32_t y)
798{
Steven Thomas94e35b92017-07-26 18:48:28 -0700799 auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700800 return static_cast<Error>(intError);
801}
802
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400803Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700804 const sp<Fence>& acquireFence)
805{
806 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700807 auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
808 fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700809 return static_cast<Error>(intError);
810}
811
812Error Layer::setSurfaceDamage(const Region& damage)
813{
814 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
815 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800816 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700817 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700818 intError = mComposer.setLayerSurfaceDamage(mDisplayId,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800819 mId, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700820 } else {
821 size_t rectCount = 0;
822 auto rectArray = damage.getArray(&rectCount);
823
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800824 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700825 for (size_t rect = 0; rect < rectCount; ++rect) {
826 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
827 rectArray[rect].right, rectArray[rect].bottom});
828 }
829
Steven Thomas94e35b92017-07-26 18:48:28 -0700830 intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700831 }
832
833 return static_cast<Error>(intError);
834}
835
836Error Layer::setBlendMode(BlendMode mode)
837{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800838 auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700839 auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700840 return static_cast<Error>(intError);
841}
842
843Error Layer::setColor(hwc_color_t color)
844{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800845 Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
Steven Thomas94e35b92017-07-26 18:48:28 -0700846 auto intError = mComposer.setLayerColor(mDisplayId, mId, hwcColor);
Dan Stoza651bf312015-10-23 17:03:17 -0700847 return static_cast<Error>(intError);
848}
849
850Error Layer::setCompositionType(Composition type)
851{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800852 auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
Steven Thomas94e35b92017-07-26 18:48:28 -0700853 auto intError = mComposer.setLayerCompositionType(
854 mDisplayId, mId, intType);
Dan Stoza651bf312015-10-23 17:03:17 -0700855 return static_cast<Error>(intError);
856}
857
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700858Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700859{
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600860 if (dataspace == mDataSpace) {
861 return Error::None;
862 }
863 mDataSpace = dataspace;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700864 auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700865 return static_cast<Error>(intError);
866}
867
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700868Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
869 const android::HdrMetadata& metadata)
870{
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700871 if (metadata == mHdrMetadata) {
872 return Error::None;
873 }
874
875 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700876 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
877 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
878 if (validTypes & HdrMetadata::SMPTE2086) {
879 perFrameMetadatas.insert(perFrameMetadatas.end(),
880 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
881 mHdrMetadata.smpte2086.displayPrimaryRed.x},
882 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
883 mHdrMetadata.smpte2086.displayPrimaryRed.y},
884 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
885 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
886 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
887 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
888 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
889 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
890 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
891 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
892 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
893 mHdrMetadata.smpte2086.whitePoint.x},
894 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
895 mHdrMetadata.smpte2086.whitePoint.y},
896 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
897 mHdrMetadata.smpte2086.maxLuminance},
898 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
899 mHdrMetadata.smpte2086.minLuminance}});
900 }
901
902 if (validTypes & HdrMetadata::CTA861_3) {
903 perFrameMetadatas.insert(perFrameMetadatas.end(),
904 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
905 mHdrMetadata.cta8613.maxContentLightLevel},
906 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
907 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
908 }
909
910 auto intError = mComposer.setLayerPerFrameMetadata(mDisplayId, mId, perFrameMetadatas);
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700911 return static_cast<Error>(intError);
912}
913
Dan Stoza651bf312015-10-23 17:03:17 -0700914Error Layer::setDisplayFrame(const Rect& frame)
915{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800916 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800917 frame.right, frame.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700918 auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700919 return static_cast<Error>(intError);
920}
921
922Error Layer::setPlaneAlpha(float alpha)
923{
Steven Thomas94e35b92017-07-26 18:48:28 -0700924 auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700925 return static_cast<Error>(intError);
926}
927
928Error Layer::setSidebandStream(const native_handle_t* stream)
929{
Steven Thomas94e35b92017-07-26 18:48:28 -0700930 if (mCapabilities.count(Capability::SidebandStream) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700931 ALOGE("Attempted to call setSidebandStream without checking that the "
932 "device supports sideband streams");
933 return Error::Unsupported;
934 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700935 auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700936 return static_cast<Error>(intError);
937}
938
939Error Layer::setSourceCrop(const FloatRect& crop)
940{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800941 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800942 crop.left, crop.top, crop.right, crop.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700943 auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700944 return static_cast<Error>(intError);
945}
946
947Error Layer::setTransform(Transform transform)
948{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800949 auto intTransform = static_cast<Hwc2::Transform>(transform);
Steven Thomas94e35b92017-07-26 18:48:28 -0700950 auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700951 return static_cast<Error>(intError);
952}
953
954Error Layer::setVisibleRegion(const Region& region)
955{
956 size_t rectCount = 0;
957 auto rectArray = region.getArray(&rectCount);
958
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800959 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700960 for (size_t rect = 0; rect < rectCount; ++rect) {
961 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
962 rectArray[rect].right, rectArray[rect].bottom});
963 }
964
Steven Thomas94e35b92017-07-26 18:48:28 -0700965 auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700966 return static_cast<Error>(intError);
967}
968
969Error Layer::setZOrder(uint32_t z)
970{
Steven Thomas94e35b92017-07-26 18:48:28 -0700971 auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700972 return static_cast<Error>(intError);
973}
974
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500975Error Layer::setInfo(uint32_t type, uint32_t appId)
976{
Steven Thomas94e35b92017-07-26 18:48:28 -0700977 auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500978 return static_cast<Error>(intError);
979}
980
Dan Stoza651bf312015-10-23 17:03:17 -0700981} // namespace HWC2