blob: 62073b6ef43b64a23bf63ddfd455c3e852881b1d [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
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800146 auto display = std::make_unique<impl::Display>(*mComposer.get(), mCapabilities, displayId,
147 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
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800185 auto newDisplay = std::make_unique<impl::Display>(*mComposer.get(), mCapabilities,
186 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
Ana Krulec4593b692019-01-11 22:07:25 -0800227Display::~Display() = default;
Dan Stoza651bf312015-10-23 17:03:17 -0700228
Ana Krulec4593b692019-01-11 22:07:25 -0800229Display::Config::Config(Display& display, hwc2_config_t id)
230 : mDisplay(display),
231 mId(id),
232 mWidth(-1),
233 mHeight(-1),
234 mVsyncPeriod(-1),
235 mDpiX(-1),
236 mDpiY(-1) {}
237
238Display::Config::Builder::Builder(Display& display, hwc2_config_t id)
239 : mConfig(new Config(display, id)) {}
240
241float Display::Config::Builder::getDefaultDensity() {
242 // Default density is based on TVs: 1080p displays get XHIGH density, lower-
243 // resolution displays get TV density. Maybe eventually we'll need to update
244 // it for 4k displays, though hopefully those will just report accurate DPI
245 // information to begin with. This is also used for virtual displays and
246 // older HWC implementations, so be careful about orientation.
247
248 auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
249 if (longDimension >= 1080) {
250 return ACONFIGURATION_DENSITY_XHIGH;
251 } else {
252 return ACONFIGURATION_DENSITY_TV;
253 }
254}
255
256namespace impl {
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800257Display::Display(android::Hwc2::Composer& composer,
Lloyd Piquebc792092018-01-17 11:52:30 -0800258 const std::unordered_set<Capability>& capabilities, hwc2_display_t id,
259 DisplayType type)
260 : mComposer(composer),
261 mCapabilities(capabilities),
262 mId(id),
263 mIsConnected(false),
264 mType(type) {
Peiyong Lined531a32018-10-26 18:27:56 -0700265 std::vector<Hwc2::DisplayCapability> tmpCapabilities;
266 auto error = static_cast<Error>(mComposer.getDisplayCapabilities(mId, &tmpCapabilities));
267 if (error == Error::None) {
268 for (auto capability : tmpCapabilities) {
269 mDisplayCapabilities.emplace(static_cast<DisplayCapability>(capability));
270 }
271 } else if (error == Error::Unsupported) {
272 if (capabilities.count(Capability::SkipClientColorTransform)) {
273 mDisplayCapabilities.emplace(DisplayCapability::SkipClientColorTransform);
274 }
275 bool dozeSupport = false;
276 error = static_cast<Error>(mComposer.getDozeSupport(mId, &dozeSupport));
277 if (error == Error::None && dozeSupport) {
278 mDisplayCapabilities.emplace(DisplayCapability::Doze);
279 }
Dan Gittik57e63c52019-01-18 16:37:54 +0000280 bool brightnessSupport = false;
281 error = static_cast<Error>(mComposer.getDisplayBrightnessSupport(mId, &brightnessSupport));
282 if (error == Error::None && brightnessSupport) {
283 mDisplayCapabilities.emplace(DisplayCapability::Brightness);
284 }
Peiyong Lined531a32018-10-26 18:27:56 -0700285 }
Dan Stoza651bf312015-10-23 17:03:17 -0700286 ALOGV("Created display %" PRIu64, id);
287}
288
Steven Thomas94e35b92017-07-26 18:48:28 -0700289Display::~Display() {
290 mLayers.clear();
291
Chris Forbesceb67d12017-04-11 12:20:00 -0700292 if (mType == DisplayType::Virtual) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700293 ALOGV("Destroying virtual display");
294 auto intError = mComposer.destroyVirtualDisplay(mId);
295 auto error = static_cast<Error>(intError);
296 ALOGE_IF(error != Error::None, "destroyVirtualDisplay(%" PRIu64
297 ") failed: %s (%d)", mId, to_string(error).c_str(), intError);
298 } else if (mType == DisplayType::Physical) {
299 auto error = setVsyncEnabled(HWC2::Vsync::Disable);
300 if (error != Error::None) {
301 ALOGE("~Display: Failed to disable vsync for display %" PRIu64
302 ": %s (%d)", mId, to_string(error).c_str(),
303 static_cast<int32_t>(error));
304 }
Dan Stoza651bf312015-10-23 17:03:17 -0700305 }
306}
307
Dan Stoza651bf312015-10-23 17:03:17 -0700308// Required by HWC2 display
Dan Stoza651bf312015-10-23 17:03:17 -0700309Error Display::acceptChanges()
310{
Steven Thomas94e35b92017-07-26 18:48:28 -0700311 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700312 return static_cast<Error>(intError);
313}
314
Lloyd Pique35d58242018-12-18 16:33:25 -0800315Error Display::createLayer(HWC2::Layer** outLayer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700316 if (!outLayer) {
317 return Error::BadParameter;
318 }
Dan Stoza651bf312015-10-23 17:03:17 -0700319 hwc2_layer_t layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700320 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700321 auto error = static_cast<Error>(intError);
322 if (error != Error::None) {
323 return error;
324 }
325
Lloyd Pique35d58242018-12-18 16:33:25 -0800326 auto layer = std::make_unique<impl::Layer>(mComposer, mCapabilities, mId, layerId);
Steven Thomas94e35b92017-07-26 18:48:28 -0700327 *outLayer = layer.get();
328 mLayers.emplace(layerId, std::move(layer));
329 return Error::None;
330}
331
Lloyd Pique35d58242018-12-18 16:33:25 -0800332Error Display::destroyLayer(HWC2::Layer* layer) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700333 if (!layer) {
334 return Error::BadParameter;
335 }
336 mLayers.erase(layer->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700337 return Error::None;
338}
339
340Error Display::getActiveConfig(
341 std::shared_ptr<const Display::Config>* outConfig) const
342{
343 ALOGV("[%" PRIu64 "] getActiveConfig", mId);
344 hwc2_config_t configId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700345 auto intError = mComposer.getActiveConfig(mId, &configId);
Dan Stoza651bf312015-10-23 17:03:17 -0700346 auto error = static_cast<Error>(intError);
347
348 if (error != Error::None) {
Fabien Sanglardb7432cc2016-11-11 09:40:27 -0800349 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
350 *outConfig = nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700351 return error;
352 }
353
354 if (mConfigs.count(configId) != 0) {
355 *outConfig = mConfigs.at(configId);
356 } else {
357 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
358 configId);
359 // Return no error, but the caller needs to check for a null pointer to
360 // detect this case
361 *outConfig = nullptr;
362 }
363
364 return Error::None;
365}
366
Lloyd Pique3c085a02018-05-09 19:38:32 -0700367Error Display::getActiveConfigIndex(int* outIndex) const {
368 ALOGV("[%" PRIu64 "] getActiveConfigIndex", mId);
369 hwc2_config_t configId = 0;
370 auto intError = mComposer.getActiveConfig(mId, &configId);
371 auto error = static_cast<Error>(intError);
372
373 if (error != Error::None) {
374 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
375 *outIndex = -1;
376 return error;
377 }
378
379 auto pos = mConfigs.find(configId);
380 if (pos != mConfigs.end()) {
381 *outIndex = std::distance(mConfigs.begin(), pos);
382 } else {
383 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId, configId);
384 // Return no error, but the caller needs to check for a negative index
385 // to detect this case
386 *outIndex = -1;
387 }
388
389 return Error::None;
390}
391
Lloyd Pique35d58242018-12-18 16:33:25 -0800392Error Display::getChangedCompositionTypes(std::unordered_map<HWC2::Layer*, Composition>* outTypes) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800393 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800394 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700395 auto intError = mComposer.getChangedCompositionTypes(
396 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800397 uint32_t numElements = layerIds.size();
398 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700399 error = static_cast<Error>(intError);
400 if (error != Error::None) {
401 return error;
402 }
403
404 outTypes->clear();
405 outTypes->reserve(numElements);
406 for (uint32_t element = 0; element < numElements; ++element) {
407 auto layer = getLayerById(layerIds[element]);
408 if (layer) {
409 auto type = static_cast<Composition>(types[element]);
410 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
411 layer->getId(), to_string(type).c_str());
412 outTypes->emplace(layer, type);
413 } else {
414 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
415 " on display %" PRIu64, layerIds[element], mId);
416 }
417 }
418
419 return Error::None;
420}
421
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700422Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700423{
Peiyong Linfd997e02018-03-28 15:29:00 -0700424 auto intError = mComposer.getColorModes(mId, outModes);
425 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700426}
427
Chia-I Wud7e01d72018-06-21 13:39:09 +0800428int32_t Display::getSupportedPerFrameMetadata() const
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700429{
Chia-I Wud7e01d72018-06-21 13:39:09 +0800430 int32_t supportedPerFrameMetadata = 0;
431
432 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys = mComposer.getPerFrameMetadataKeys(mId);
433 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700434
435 // Check whether a specific metadata type is supported. A metadata type is considered
436 // supported if and only if all required fields are supported.
437
438 // SMPTE2086
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700439 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
440 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
441 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
442 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
443 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
444 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
445 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
446 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
447 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
448 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800449 supportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700450 }
451 // CTA861_3
452 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
453 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800454 supportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700455 }
456
Valerie Haue9e843a2018-12-18 13:39:23 -0800457 // HDR10PLUS
458 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI)) {
459 supportedPerFrameMetadata |= HdrMetadata::Type::HDR10PLUS;
460 }
461
Chia-I Wud7e01d72018-06-21 13:39:09 +0800462 return supportedPerFrameMetadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700463}
464
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700465Error Display::getRenderIntents(ColorMode colorMode,
466 std::vector<RenderIntent>* outRenderIntents) const
467{
468 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
469 return static_cast<Error>(intError);
470}
471
472Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
473{
474 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
475 return static_cast<Error>(intError);
476}
477
Dan Stoza651bf312015-10-23 17:03:17 -0700478std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
479{
480 std::vector<std::shared_ptr<const Config>> configs;
481 for (const auto& element : mConfigs) {
482 configs.emplace_back(element.second);
483 }
484 return configs;
485}
486
487Error Display::getName(std::string* outName) const
488{
Steven Thomas94e35b92017-07-26 18:48:28 -0700489 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800490 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700491}
492
493Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Lloyd Pique35d58242018-12-18 16:33:25 -0800494 std::unordered_map<HWC2::Layer*, LayerRequest>* outLayerRequests) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800495 uint32_t intDisplayRequests;
496 std::vector<Hwc2::Layer> layerIds;
497 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700498 auto intError = mComposer.getDisplayRequests(
499 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800500 uint32_t numElements = layerIds.size();
501 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700502 if (error != Error::None) {
503 return error;
504 }
505
506 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
507 outLayerRequests->clear();
508 outLayerRequests->reserve(numElements);
509 for (uint32_t element = 0; element < numElements; ++element) {
510 auto layer = getLayerById(layerIds[element]);
511 if (layer) {
512 auto layerRequest =
513 static_cast<LayerRequest>(layerRequests[element]);
514 outLayerRequests->emplace(layer, layerRequest);
515 } else {
516 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
517 PRIu64, layerIds[element], mId);
518 }
519 }
520
521 return Error::None;
522}
523
524Error Display::getType(DisplayType* outType) const
525{
Chris Forbes016d73c2017-04-11 10:04:31 -0700526 *outType = mType;
Dan Stoza651bf312015-10-23 17:03:17 -0700527 return Error::None;
528}
529
Peiyong Lined531a32018-10-26 18:27:56 -0700530Error Display::supportsDoze(bool* outSupport) const {
531 *outSupport = mDisplayCapabilities.count(DisplayCapability::Doze) > 0;
Dan Stoza651bf312015-10-23 17:03:17 -0700532 return Error::None;
533}
534
Peiyong Lin62665892018-04-16 11:07:44 -0700535Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700536{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700537 float maxLuminance = -1.0f;
538 float maxAverageLuminance = -1.0f;
539 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700540 std::vector<Hwc2::Hdr> types;
541 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800542 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800543 auto error = static_cast<HWC2::Error>(intError);
544
Dan Stoza7d7ae732016-03-16 12:23:40 -0700545 if (error != Error::None) {
546 return error;
547 }
548
Peiyong Lin62665892018-04-16 11:07:44 -0700549 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700550 maxLuminance, maxAverageLuminance, minLuminance);
551 return Error::None;
552}
553
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700554Error Display::getDisplayedContentSamplingAttributes(PixelFormat* outFormat,
555 Dataspace* outDataspace,
556 uint8_t* outComponentMask) const {
557 auto intError = mComposer.getDisplayedContentSamplingAttributes(mId, outFormat, outDataspace,
558 outComponentMask);
559 return static_cast<Error>(intError);
560}
561
Kevin DuBois74e53772018-11-19 10:52:38 -0800562Error Display::setDisplayContentSamplingEnabled(bool enabled, uint8_t componentMask,
563 uint64_t maxFrames) const {
564 auto intError =
565 mComposer.setDisplayContentSamplingEnabled(mId, enabled, componentMask, maxFrames);
566 return static_cast<Error>(intError);
567}
568
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700569Error Display::getDisplayedContentSample(uint64_t maxFrames, uint64_t timestamp,
570 android::DisplayedFrameStats* outStats) const {
571 auto intError = mComposer.getDisplayedContentSample(mId, maxFrames, timestamp, outStats);
572 return static_cast<Error>(intError);
573}
574
Lloyd Pique35d58242018-12-18 16:33:25 -0800575Error Display::getReleaseFences(std::unordered_map<HWC2::Layer*, sp<Fence>>* outFences) const {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800576 std::vector<Hwc2::Layer> layerIds;
577 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700578 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800579 auto error = static_cast<Error>(intError);
580 uint32_t numElements = layerIds.size();
Dan Stoza651bf312015-10-23 17:03:17 -0700581 if (error != Error::None) {
582 return error;
583 }
584
Lloyd Pique35d58242018-12-18 16:33:25 -0800585 std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700586 releaseFences.reserve(numElements);
587 for (uint32_t element = 0; element < numElements; ++element) {
588 auto layer = getLayerById(layerIds[element]);
589 if (layer) {
590 sp<Fence> fence(new Fence(fenceFds[element]));
Steven Thomas94e35b92017-07-26 18:48:28 -0700591 releaseFences.emplace(layer, fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700592 } else {
593 ALOGE("getReleaseFences: invalid layer %" PRIu64
594 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700595 for (; element < numElements; ++element) {
596 close(fenceFds[element]);
597 }
Dan Stoza651bf312015-10-23 17:03:17 -0700598 return Error::BadLayer;
599 }
600 }
601
602 *outFences = std::move(releaseFences);
603 return Error::None;
604}
605
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800606Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700607{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400608 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700609 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700610 auto error = static_cast<Error>(intError);
611 if (error != Error::None) {
612 return error;
613 }
614
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800615 *outPresentFence = new Fence(presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700616 return Error::None;
617}
618
619Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
620{
621 if (config->getDisplayId() != mId) {
622 ALOGE("setActiveConfig received config %u for the wrong display %"
623 PRIu64 " (expected %" PRIu64 ")", config->getId(),
624 config->getDisplayId(), mId);
625 return Error::BadConfig;
626 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700627 auto intError = mComposer.setActiveConfig(mId, config->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700628 return static_cast<Error>(intError);
629}
630
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400631Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700632 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700633{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700634 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700635 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700636 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700637 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700638 return static_cast<Error>(intError);
639}
640
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700641Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700642{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700643 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700644 return static_cast<Error>(intError);
645}
646
Dan Stoza5df2a862016-03-24 16:19:37 -0700647Error Display::setColorTransform(const android::mat4& matrix,
648 android_color_transform_t hint)
649{
Steven Thomas94e35b92017-07-26 18:48:28 -0700650 auto intError = mComposer.setColorTransform(mId,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800651 matrix.asArray(), static_cast<Hwc2::ColorTransform>(hint));
Dan Stoza5df2a862016-03-24 16:19:37 -0700652 return static_cast<Error>(intError);
653}
654
Dan Stoza651bf312015-10-23 17:03:17 -0700655Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
656 const sp<Fence>& releaseFence)
657{
658 int32_t fenceFd = releaseFence->dup();
659 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700660 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700661 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700662 return static_cast<Error>(intError);
663}
664
665Error Display::setPowerMode(PowerMode mode)
666{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800667 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700668 auto intError = mComposer.setPowerMode(mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700669 return static_cast<Error>(intError);
670}
671
672Error Display::setVsyncEnabled(Vsync enabled)
673{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800674 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700675 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700676 return static_cast<Error>(intError);
677}
678
679Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
680{
681 uint32_t numTypes = 0;
682 uint32_t numRequests = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700683 auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700684 auto error = static_cast<Error>(intError);
685 if (error != Error::None && error != Error::HasChanges) {
686 return error;
687 }
688
689 *outNumTypes = numTypes;
690 *outNumRequests = numRequests;
691 return error;
692}
693
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700694Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
695 sp<android::Fence>* outPresentFence, uint32_t* state) {
696
697 uint32_t numTypes = 0;
698 uint32_t numRequests = 0;
699 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700700 auto intError = mComposer.presentOrValidateDisplay(
701 mId, &numTypes, &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700702 auto error = static_cast<Error>(intError);
703 if (error != Error::None && error != Error::HasChanges) {
704 return error;
705 }
706
707 if (*state == 1) {
708 *outPresentFence = new Fence(presentFenceFd);
709 }
710
711 if (*state == 0) {
712 *outNumTypes = numTypes;
713 *outNumRequests = numRequests;
714 }
715 return error;
716}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700717
Dan Gittik57e63c52019-01-18 16:37:54 +0000718Error Display::setDisplayBrightness(float brightness) const {
719 auto intError = mComposer.setDisplayBrightness(mId, brightness);
720 return static_cast<Error>(intError);
721}
722
Dan Stoza651bf312015-10-23 17:03:17 -0700723// For use by Device
724
Steven Thomas94e35b92017-07-26 18:48:28 -0700725void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800726 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700727 mComposer.setClientTargetSlotCount(mId);
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800728 if (mType == DisplayType::Physical) {
729 loadConfigs();
730 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700731 }
732 mIsConnected = connected;
733}
734
Dan Stoza651bf312015-10-23 17:03:17 -0700735int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
736{
737 int32_t value = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700738 auto intError = mComposer.getDisplayAttribute(mId, configId,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800739 static_cast<Hwc2::IComposerClient::Attribute>(attribute),
740 &value);
Dan Stoza651bf312015-10-23 17:03:17 -0700741 auto error = static_cast<Error>(intError);
742 if (error != Error::None) {
743 ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
744 configId, to_string(attribute).c_str(),
745 to_string(error).c_str(), intError);
746 return -1;
747 }
748 return value;
749}
750
751void Display::loadConfig(hwc2_config_t configId)
752{
753 ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
754
755 auto config = Config::Builder(*this, configId)
756 .setWidth(getAttribute(configId, Attribute::Width))
757 .setHeight(getAttribute(configId, Attribute::Height))
758 .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod))
759 .setDpiX(getAttribute(configId, Attribute::DpiX))
760 .setDpiY(getAttribute(configId, Attribute::DpiY))
761 .build();
762 mConfigs.emplace(configId, std::move(config));
763}
764
765void Display::loadConfigs()
766{
767 ALOGV("[%" PRIu64 "] loadConfigs", mId);
768
Chia-I Wuaab99f52016-10-05 12:59:58 +0800769 std::vector<Hwc2::Config> configIds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700770 auto intError = mComposer.getDisplayConfigs(mId, &configIds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800771 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700772 if (error != Error::None) {
773 ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
774 to_string(error).c_str(), intError);
775 return;
776 }
777
778 for (auto configId : configIds) {
779 loadConfig(configId);
780 }
781}
782
Dan Stoza651bf312015-10-23 17:03:17 -0700783// Other Display methods
784
Lloyd Pique35d58242018-12-18 16:33:25 -0800785HWC2::Layer* Display::getLayerById(hwc2_layer_t id) const {
Dan Stoza651bf312015-10-23 17:03:17 -0700786 if (mLayers.count(id) == 0) {
787 return nullptr;
788 }
789
Steven Thomas94e35b92017-07-26 18:48:28 -0700790 return mLayers.at(id).get();
Dan Stoza651bf312015-10-23 17:03:17 -0700791}
Ana Krulec4593b692019-01-11 22:07:25 -0800792} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -0700793
794// Layer methods
795
Lloyd Pique35d58242018-12-18 16:33:25 -0800796Layer::~Layer() = default;
797
798namespace impl {
799
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700800Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Steven Thomas94e35b92017-07-26 18:48:28 -0700801 hwc2_display_t displayId, hwc2_layer_t layerId)
802 : mComposer(composer),
803 mCapabilities(capabilities),
804 mDisplayId(displayId),
Peiyong Lin698147a2018-09-14 13:27:18 -0700805 mId(layerId),
806 mColorMatrix(android::mat4())
Dan Stoza651bf312015-10-23 17:03:17 -0700807{
Steven Thomas94e35b92017-07-26 18:48:28 -0700808 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700809}
810
811Layer::~Layer()
812{
Steven Thomas94e35b92017-07-26 18:48:28 -0700813 auto intError = mComposer.destroyLayer(mDisplayId, mId);
814 auto error = static_cast<Error>(intError);
815 ALOGE_IF(error != Error::None, "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
816 " failed: %s (%d)", mDisplayId, mId, to_string(error).c_str(),
817 intError);
Steven Thomas94e35b92017-07-26 18:48:28 -0700818}
819
Dan Stoza651bf312015-10-23 17:03:17 -0700820Error Layer::setCursorPosition(int32_t x, int32_t y)
821{
Steven Thomas94e35b92017-07-26 18:48:28 -0700822 auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700823 return static_cast<Error>(intError);
824}
825
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400826Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700827 const sp<Fence>& acquireFence)
828{
829 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700830 auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
831 fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700832 return static_cast<Error>(intError);
833}
834
835Error Layer::setSurfaceDamage(const Region& damage)
836{
837 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
838 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800839 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700840 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700841 intError = mComposer.setLayerSurfaceDamage(mDisplayId,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800842 mId, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700843 } else {
844 size_t rectCount = 0;
845 auto rectArray = damage.getArray(&rectCount);
846
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800847 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700848 for (size_t rect = 0; rect < rectCount; ++rect) {
849 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
850 rectArray[rect].right, rectArray[rect].bottom});
851 }
852
Steven Thomas94e35b92017-07-26 18:48:28 -0700853 intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700854 }
855
856 return static_cast<Error>(intError);
857}
858
859Error Layer::setBlendMode(BlendMode mode)
860{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800861 auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700862 auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700863 return static_cast<Error>(intError);
864}
865
866Error Layer::setColor(hwc_color_t color)
867{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800868 Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
Steven Thomas94e35b92017-07-26 18:48:28 -0700869 auto intError = mComposer.setLayerColor(mDisplayId, mId, hwcColor);
Dan Stoza651bf312015-10-23 17:03:17 -0700870 return static_cast<Error>(intError);
871}
872
873Error Layer::setCompositionType(Composition type)
874{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800875 auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
Steven Thomas94e35b92017-07-26 18:48:28 -0700876 auto intError = mComposer.setLayerCompositionType(
877 mDisplayId, mId, intType);
Dan Stoza651bf312015-10-23 17:03:17 -0700878 return static_cast<Error>(intError);
879}
880
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700881Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700882{
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600883 if (dataspace == mDataSpace) {
884 return Error::None;
885 }
886 mDataSpace = dataspace;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700887 auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700888 return static_cast<Error>(intError);
889}
890
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700891Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
892 const android::HdrMetadata& metadata)
893{
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700894 if (metadata == mHdrMetadata) {
895 return Error::None;
896 }
897
898 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700899 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
900 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
901 if (validTypes & HdrMetadata::SMPTE2086) {
902 perFrameMetadatas.insert(perFrameMetadatas.end(),
903 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
Valerie Haue9e843a2018-12-18 13:39:23 -0800904 mHdrMetadata.smpte2086.displayPrimaryRed.x},
905 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
906 mHdrMetadata.smpte2086.displayPrimaryRed.y},
907 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
908 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
909 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
910 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
911 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
912 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
913 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
914 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
915 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
916 mHdrMetadata.smpte2086.whitePoint.x},
917 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
918 mHdrMetadata.smpte2086.whitePoint.y},
919 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
920 mHdrMetadata.smpte2086.maxLuminance},
921 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
922 mHdrMetadata.smpte2086.minLuminance}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700923 }
924
925 if (validTypes & HdrMetadata::CTA861_3) {
926 perFrameMetadatas.insert(perFrameMetadatas.end(),
927 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
Valerie Haue9e843a2018-12-18 13:39:23 -0800928 mHdrMetadata.cta8613.maxContentLightLevel},
929 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
930 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700931 }
932
Valerie Haue9e843a2018-12-18 13:39:23 -0800933 Error error = static_cast<Error>(
934 mComposer.setLayerPerFrameMetadata(mDisplayId, mId, perFrameMetadatas));
935
936 if (validTypes & HdrMetadata::HDR10PLUS) {
937 std::vector<Hwc2::PerFrameMetadataBlob> perFrameMetadataBlobs;
938 perFrameMetadataBlobs.push_back(
939 {Hwc2::PerFrameMetadataKey::HDR10_PLUS_SEI, mHdrMetadata.hdr10plus});
940 Error setMetadataBlobsError = static_cast<Error>(
941 mComposer.setLayerPerFrameMetadataBlobs(mDisplayId, mId, perFrameMetadataBlobs));
942 if (error == Error::None) {
943 return setMetadataBlobsError;
944 }
945 }
946 return error;
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700947}
948
Dan Stoza651bf312015-10-23 17:03:17 -0700949Error Layer::setDisplayFrame(const Rect& frame)
950{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800951 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800952 frame.right, frame.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700953 auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700954 return static_cast<Error>(intError);
955}
956
957Error Layer::setPlaneAlpha(float alpha)
958{
Steven Thomas94e35b92017-07-26 18:48:28 -0700959 auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700960 return static_cast<Error>(intError);
961}
962
963Error Layer::setSidebandStream(const native_handle_t* stream)
964{
Steven Thomas94e35b92017-07-26 18:48:28 -0700965 if (mCapabilities.count(Capability::SidebandStream) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700966 ALOGE("Attempted to call setSidebandStream without checking that the "
967 "device supports sideband streams");
968 return Error::Unsupported;
969 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700970 auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700971 return static_cast<Error>(intError);
972}
973
974Error Layer::setSourceCrop(const FloatRect& crop)
975{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800976 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800977 crop.left, crop.top, crop.right, crop.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700978 auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700979 return static_cast<Error>(intError);
980}
981
982Error Layer::setTransform(Transform transform)
983{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800984 auto intTransform = static_cast<Hwc2::Transform>(transform);
Steven Thomas94e35b92017-07-26 18:48:28 -0700985 auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700986 return static_cast<Error>(intError);
987}
988
989Error Layer::setVisibleRegion(const Region& region)
990{
991 size_t rectCount = 0;
992 auto rectArray = region.getArray(&rectCount);
993
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800994 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700995 for (size_t rect = 0; rect < rectCount; ++rect) {
996 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
997 rectArray[rect].right, rectArray[rect].bottom});
998 }
999
Steven Thomas94e35b92017-07-26 18:48:28 -07001000 auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -07001001 return static_cast<Error>(intError);
1002}
1003
1004Error Layer::setZOrder(uint32_t z)
1005{
Steven Thomas94e35b92017-07-26 18:48:28 -07001006 auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -07001007 return static_cast<Error>(intError);
1008}
1009
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001010Error Layer::setInfo(uint32_t type, uint32_t appId)
1011{
Steven Thomas94e35b92017-07-26 18:48:28 -07001012 auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001013 return static_cast<Error>(intError);
1014}
1015
Peiyong Lin698147a2018-09-14 13:27:18 -07001016// Composer HAL 2.3
1017Error Layer::setColorTransform(const android::mat4& matrix) {
1018 if (matrix == mColorMatrix) {
1019 return Error::None;
1020 }
1021 mColorMatrix = matrix;
1022 auto intError = mComposer.setLayerColorTransform(mDisplayId, mId, matrix.asArray());
1023 return static_cast<Error>(intError);
1024}
Lloyd Pique35d58242018-12-18 16:33:25 -08001025
1026} // namespace impl
Dan Stoza651bf312015-10-23 17:03:17 -07001027} // namespace HWC2