blob: 2dfa67badaa83a73c26dc8a48ebee0c8bdb24dfd [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
Dan Stoza09e7a272016-04-14 12:31:01 -070033#include <algorithm>
Dan Stoza651bf312015-10-23 17:03:17 -070034#include <inttypes.h>
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
126Error Device::createVirtualDisplay(uint32_t width, uint32_t height,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700127 PixelFormat* format, Display** outDisplay)
Dan Stoza651bf312015-10-23 17:03:17 -0700128{
129 ALOGI("Creating virtual display");
130
131 hwc2_display_t displayId = 0;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800132 auto intError = mComposer->createVirtualDisplay(width, height,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700133 format, &displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700134 auto error = static_cast<Error>(intError);
135 if (error != Error::None) {
136 return error;
137 }
138
Steven Thomas94e35b92017-07-26 18:48:28 -0700139 auto display = std::make_unique<Display>(
140 *mComposer.get(), mCapabilities, displayId, DisplayType::Virtual);
Lloyd Piquebc792092018-01-17 11:52:30 -0800141 display->setConnected(true);
Steven Thomas94e35b92017-07-26 18:48:28 -0700142 *outDisplay = display.get();
Steven Thomas94e35b92017-07-26 18:48:28 -0700143 mDisplays.emplace(displayId, std::move(display));
144 ALOGI("Created virtual display");
Dan Stoza651bf312015-10-23 17:03:17 -0700145 return Error::None;
146}
147
Steven Thomas94e35b92017-07-26 18:48:28 -0700148void Device::destroyDisplay(hwc2_display_t displayId)
Dan Stoza651bf312015-10-23 17:03:17 -0700149{
Steven Thomas94e35b92017-07-26 18:48:28 -0700150 ALOGI("Destroying display %" PRIu64, displayId);
151 mDisplays.erase(displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700152}
153
Steven Thomas94e35b92017-07-26 18:48:28 -0700154void Device::onHotplug(hwc2_display_t displayId, Connection connection) {
155 if (connection == Connection::Connected) {
Steven Thomas3bed0522018-03-20 15:40:48 -0700156 // If we get a hotplug connected event for a display we already have,
157 // destroy the display and recreate it. This will force us to requery
158 // the display params and recreate all layers on that display.
159 auto oldDisplay = getDisplayById(displayId);
160 if (oldDisplay != nullptr && oldDisplay->isConnected()) {
161 ALOGI("Hotplug connecting an already connected display."
162 " Clearing old display state.");
Dan Stoza651bf312015-10-23 17:03:17 -0700163 }
Steven Thomas3bed0522018-03-20 15:40:48 -0700164 mDisplays.erase(displayId);
165
166 DisplayType displayType;
167 auto intError = mComposer->getDisplayType(displayId,
168 reinterpret_cast<Hwc2::IComposerClient::DisplayType *>(
169 &displayType));
170 auto error = static_cast<Error>(intError);
171 if (error != Error::None) {
172 ALOGE("getDisplayType(%" PRIu64 ") failed: %s (%d). "
173 "Aborting hotplug attempt.",
174 displayId, to_string(error).c_str(), intError);
175 return;
176 }
177
178 auto newDisplay = std::make_unique<Display>(
179 *mComposer.get(), mCapabilities, displayId, displayType);
Lloyd Piquebc792092018-01-17 11:52:30 -0800180 newDisplay->setConnected(true);
Steven Thomas3bed0522018-03-20 15:40:48 -0700181 mDisplays.emplace(displayId, std::move(newDisplay));
Steven Thomas94e35b92017-07-26 18:48:28 -0700182 } else if (connection == Connection::Disconnected) {
183 // The display will later be destroyed by a call to
184 // destroyDisplay(). For now we just mark it disconnected.
185 auto display = getDisplayById(displayId);
186 if (display) {
187 display->setConnected(false);
188 } else {
189 ALOGW("Attempted to disconnect unknown display %" PRIu64,
190 displayId);
191 }
Dan Stoza651bf312015-10-23 17:03:17 -0700192 }
193}
194
195// Other Device methods
196
Steven Thomas94e35b92017-07-26 18:48:28 -0700197Display* Device::getDisplayById(hwc2_display_t id) {
198 auto iter = mDisplays.find(id);
199 return iter == mDisplays.end() ? nullptr : iter->second.get();
Dan Stoza651bf312015-10-23 17:03:17 -0700200}
201
202// Device initialization methods
203
204void Device::loadCapabilities()
205{
206 static_assert(sizeof(Capability) == sizeof(int32_t),
207 "Capability size has changed");
Chia-I Wuaab99f52016-10-05 12:59:58 +0800208 auto capabilities = mComposer->getCapabilities();
209 for (auto capability : capabilities) {
210 mCapabilities.emplace(static_cast<Capability>(capability));
211 }
Dan Stoza651bf312015-10-23 17:03:17 -0700212}
213
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700214Error Device::flushCommands()
215{
216 return static_cast<Error>(mComposer->executeCommands());
217}
218
Dan Stoza651bf312015-10-23 17:03:17 -0700219// Display methods
220
Steven Thomas94e35b92017-07-26 18:48:28 -0700221Display::Display(android::Hwc2::Composer& composer,
Lloyd Piquebc792092018-01-17 11:52:30 -0800222 const std::unordered_set<Capability>& capabilities, hwc2_display_t id,
223 DisplayType type)
224 : mComposer(composer),
225 mCapabilities(capabilities),
226 mId(id),
227 mIsConnected(false),
228 mType(type) {
Dan Stoza651bf312015-10-23 17:03:17 -0700229 ALOGV("Created display %" PRIu64, id);
230}
231
Steven Thomas94e35b92017-07-26 18:48:28 -0700232Display::~Display() {
233 mLayers.clear();
234
Chris Forbesceb67d12017-04-11 12:20:00 -0700235 if (mType == DisplayType::Virtual) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700236 ALOGV("Destroying virtual display");
237 auto intError = mComposer.destroyVirtualDisplay(mId);
238 auto error = static_cast<Error>(intError);
239 ALOGE_IF(error != Error::None, "destroyVirtualDisplay(%" PRIu64
240 ") failed: %s (%d)", mId, to_string(error).c_str(), intError);
241 } else if (mType == DisplayType::Physical) {
242 auto error = setVsyncEnabled(HWC2::Vsync::Disable);
243 if (error != Error::None) {
244 ALOGE("~Display: Failed to disable vsync for display %" PRIu64
245 ": %s (%d)", mId, to_string(error).c_str(),
246 static_cast<int32_t>(error));
247 }
Dan Stoza651bf312015-10-23 17:03:17 -0700248 }
249}
250
251Display::Config::Config(Display& display, hwc2_config_t id)
252 : mDisplay(display),
253 mId(id),
254 mWidth(-1),
255 mHeight(-1),
256 mVsyncPeriod(-1),
257 mDpiX(-1),
258 mDpiY(-1) {}
259
260Display::Config::Builder::Builder(Display& display, hwc2_config_t id)
261 : mConfig(new Config(display, id)) {}
262
263float Display::Config::Builder::getDefaultDensity() {
264 // Default density is based on TVs: 1080p displays get XHIGH density, lower-
265 // resolution displays get TV density. Maybe eventually we'll need to update
266 // it for 4k displays, though hopefully those will just report accurate DPI
267 // information to begin with. This is also used for virtual displays and
268 // older HWC implementations, so be careful about orientation.
269
270 auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
271 if (longDimension >= 1080) {
272 return ACONFIGURATION_DENSITY_XHIGH;
273 } else {
274 return ACONFIGURATION_DENSITY_TV;
275 }
276}
277
278// Required by HWC2 display
279
280Error Display::acceptChanges()
281{
Steven Thomas94e35b92017-07-26 18:48:28 -0700282 auto intError = mComposer.acceptDisplayChanges(mId);
Dan Stoza651bf312015-10-23 17:03:17 -0700283 return static_cast<Error>(intError);
284}
285
Steven Thomas94e35b92017-07-26 18:48:28 -0700286Error Display::createLayer(Layer** outLayer)
Dan Stoza651bf312015-10-23 17:03:17 -0700287{
Steven Thomas94e35b92017-07-26 18:48:28 -0700288 if (!outLayer) {
289 return Error::BadParameter;
290 }
Dan Stoza651bf312015-10-23 17:03:17 -0700291 hwc2_layer_t layerId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700292 auto intError = mComposer.createLayer(mId, &layerId);
Dan Stoza651bf312015-10-23 17:03:17 -0700293 auto error = static_cast<Error>(intError);
294 if (error != Error::None) {
295 return error;
296 }
297
Steven Thomas94e35b92017-07-26 18:48:28 -0700298 auto layer = std::make_unique<Layer>(
299 mComposer, mCapabilities, mId, layerId);
300 *outLayer = layer.get();
301 mLayers.emplace(layerId, std::move(layer));
302 return Error::None;
303}
304
305Error Display::destroyLayer(Layer* layer)
306{
307 if (!layer) {
308 return Error::BadParameter;
309 }
310 mLayers.erase(layer->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700311 return Error::None;
312}
313
314Error Display::getActiveConfig(
315 std::shared_ptr<const Display::Config>* outConfig) const
316{
317 ALOGV("[%" PRIu64 "] getActiveConfig", mId);
318 hwc2_config_t configId = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700319 auto intError = mComposer.getActiveConfig(mId, &configId);
Dan Stoza651bf312015-10-23 17:03:17 -0700320 auto error = static_cast<Error>(intError);
321
322 if (error != Error::None) {
Fabien Sanglardb7432cc2016-11-11 09:40:27 -0800323 ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
324 *outConfig = nullptr;
Dan Stoza651bf312015-10-23 17:03:17 -0700325 return error;
326 }
327
328 if (mConfigs.count(configId) != 0) {
329 *outConfig = mConfigs.at(configId);
330 } else {
331 ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
332 configId);
333 // Return no error, but the caller needs to check for a null pointer to
334 // detect this case
335 *outConfig = nullptr;
336 }
337
338 return Error::None;
339}
340
341Error Display::getChangedCompositionTypes(
Steven Thomas94e35b92017-07-26 18:48:28 -0700342 std::unordered_map<Layer*, Composition>* outTypes)
Dan Stoza651bf312015-10-23 17:03:17 -0700343{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800344 std::vector<Hwc2::Layer> layerIds;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800345 std::vector<Hwc2::IComposerClient::Composition> types;
Steven Thomas94e35b92017-07-26 18:48:28 -0700346 auto intError = mComposer.getChangedCompositionTypes(
347 mId, &layerIds, &types);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800348 uint32_t numElements = layerIds.size();
349 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700350 error = static_cast<Error>(intError);
351 if (error != Error::None) {
352 return error;
353 }
354
355 outTypes->clear();
356 outTypes->reserve(numElements);
357 for (uint32_t element = 0; element < numElements; ++element) {
358 auto layer = getLayerById(layerIds[element]);
359 if (layer) {
360 auto type = static_cast<Composition>(types[element]);
361 ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
362 layer->getId(), to_string(type).c_str());
363 outTypes->emplace(layer, type);
364 } else {
365 ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
366 " on display %" PRIu64, layerIds[element], mId);
367 }
368 }
369
370 return Error::None;
371}
372
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700373Error Display::getColorModes(std::vector<ColorMode>* outModes) const
Dan Stoza076ac672016-03-14 10:47:53 -0700374{
Peiyong Linfd997e02018-03-28 15:29:00 -0700375 auto intError = mComposer.getColorModes(mId, outModes);
376 return static_cast<Error>(intError);
Dan Stoza076ac672016-03-14 10:47:53 -0700377}
378
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700379Error Display::getSupportedPerFrameMetadata(int32_t* outSupportedPerFrameMetadata) const
380{
381 *outSupportedPerFrameMetadata = 0;
382 std::vector<Hwc2::PerFrameMetadataKey> tmpKeys;
383 auto intError = mComposer.getPerFrameMetadataKeys(mId, &tmpKeys);
384 auto error = static_cast<Error>(intError);
385 if (error != Error::None) {
386 return error;
387 }
388
389 // Check whether a specific metadata type is supported. A metadata type is considered
390 // supported if and only if all required fields are supported.
391
392 // SMPTE2086
393 std::set<Hwc2::PerFrameMetadataKey> keys(tmpKeys.begin(), tmpKeys.end());
394 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X) &&
395 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y) &&
396 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X) &&
397 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y) &&
398 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X) &&
399 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y) &&
400 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_X) &&
401 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::WHITE_POINT_Y) &&
402 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_LUMINANCE) &&
403 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MIN_LUMINANCE)) {
404 *outSupportedPerFrameMetadata |= HdrMetadata::Type::SMPTE2086;
405 }
406 // CTA861_3
407 if (hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL) &&
408 hasMetadataKey(keys, Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL)) {
409 *outSupportedPerFrameMetadata |= HdrMetadata::Type::CTA861_3;
410 }
411
412 return Error::None;
413}
414
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700415Error Display::getRenderIntents(ColorMode colorMode,
416 std::vector<RenderIntent>* outRenderIntents) const
417{
418 auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
419 return static_cast<Error>(intError);
420}
421
422Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
423{
424 auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
425 return static_cast<Error>(intError);
426}
427
Dan Stoza651bf312015-10-23 17:03:17 -0700428std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
429{
430 std::vector<std::shared_ptr<const Config>> configs;
431 for (const auto& element : mConfigs) {
432 configs.emplace_back(element.second);
433 }
434 return configs;
435}
436
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700437Error Display::getIdentificationData(uint8_t* outPort, std::vector<uint8_t>* outData) const {
438 auto intError = mComposer.getDisplayIdentificationData(mId, outPort, outData);
439 return static_cast<Error>(intError);
440}
441
Dan Stoza651bf312015-10-23 17:03:17 -0700442Error Display::getName(std::string* outName) const
443{
Steven Thomas94e35b92017-07-26 18:48:28 -0700444 auto intError = mComposer.getDisplayName(mId, outName);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800445 return static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700446}
447
448Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
Steven Thomas94e35b92017-07-26 18:48:28 -0700449 std::unordered_map<Layer*, LayerRequest>* outLayerRequests)
Dan Stoza651bf312015-10-23 17:03:17 -0700450{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800451 uint32_t intDisplayRequests;
452 std::vector<Hwc2::Layer> layerIds;
453 std::vector<uint32_t> layerRequests;
Steven Thomas94e35b92017-07-26 18:48:28 -0700454 auto intError = mComposer.getDisplayRequests(
455 mId, &intDisplayRequests, &layerIds, &layerRequests);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800456 uint32_t numElements = layerIds.size();
457 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700458 if (error != Error::None) {
459 return error;
460 }
461
462 *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
463 outLayerRequests->clear();
464 outLayerRequests->reserve(numElements);
465 for (uint32_t element = 0; element < numElements; ++element) {
466 auto layer = getLayerById(layerIds[element]);
467 if (layer) {
468 auto layerRequest =
469 static_cast<LayerRequest>(layerRequests[element]);
470 outLayerRequests->emplace(layer, layerRequest);
471 } else {
472 ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
473 PRIu64, layerIds[element], mId);
474 }
475 }
476
477 return Error::None;
478}
479
480Error Display::getType(DisplayType* outType) const
481{
Chris Forbes016d73c2017-04-11 10:04:31 -0700482 *outType = mType;
Dan Stoza651bf312015-10-23 17:03:17 -0700483 return Error::None;
484}
485
486Error Display::supportsDoze(bool* outSupport) const
487{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800488 bool intSupport = false;
Steven Thomas94e35b92017-07-26 18:48:28 -0700489 auto intError = mComposer.getDozeSupport(mId, &intSupport);
Dan Stoza651bf312015-10-23 17:03:17 -0700490 auto error = static_cast<Error>(intError);
491 if (error != Error::None) {
492 return error;
493 }
494 *outSupport = static_cast<bool>(intSupport);
495 return Error::None;
496}
497
Peiyong Lin62665892018-04-16 11:07:44 -0700498Error Display::getHdrCapabilities(HdrCapabilities* outCapabilities) const
Dan Stoza7d7ae732016-03-16 12:23:40 -0700499{
Dan Stoza7d7ae732016-03-16 12:23:40 -0700500 float maxLuminance = -1.0f;
501 float maxAverageLuminance = -1.0f;
502 float minLuminance = -1.0f;
Peiyong Lin62665892018-04-16 11:07:44 -0700503 std::vector<Hwc2::Hdr> types;
504 auto intError = mComposer.getHdrCapabilities(mId, &types,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800505 &maxLuminance, &maxAverageLuminance, &minLuminance);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800506 auto error = static_cast<HWC2::Error>(intError);
507
Dan Stoza7d7ae732016-03-16 12:23:40 -0700508 if (error != Error::None) {
509 return error;
510 }
511
Peiyong Lin62665892018-04-16 11:07:44 -0700512 *outCapabilities = HdrCapabilities(std::move(types),
Dan Stoza7d7ae732016-03-16 12:23:40 -0700513 maxLuminance, maxAverageLuminance, minLuminance);
514 return Error::None;
515}
516
Dan Stoza651bf312015-10-23 17:03:17 -0700517Error Display::getReleaseFences(
Steven Thomas94e35b92017-07-26 18:48:28 -0700518 std::unordered_map<Layer*, sp<Fence>>* outFences) const
Dan Stoza651bf312015-10-23 17:03:17 -0700519{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800520 std::vector<Hwc2::Layer> layerIds;
521 std::vector<int> fenceFds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700522 auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800523 auto error = static_cast<Error>(intError);
524 uint32_t numElements = layerIds.size();
Dan Stoza651bf312015-10-23 17:03:17 -0700525 if (error != Error::None) {
526 return error;
527 }
528
Steven Thomas94e35b92017-07-26 18:48:28 -0700529 std::unordered_map<Layer*, sp<Fence>> releaseFences;
Dan Stoza651bf312015-10-23 17:03:17 -0700530 releaseFences.reserve(numElements);
531 for (uint32_t element = 0; element < numElements; ++element) {
532 auto layer = getLayerById(layerIds[element]);
533 if (layer) {
534 sp<Fence> fence(new Fence(fenceFds[element]));
Steven Thomas94e35b92017-07-26 18:48:28 -0700535 releaseFences.emplace(layer, fence);
Dan Stoza651bf312015-10-23 17:03:17 -0700536 } else {
537 ALOGE("getReleaseFences: invalid layer %" PRIu64
538 " found on display %" PRIu64, layerIds[element], mId);
Chia-I Wu5e74c652017-05-17 13:43:16 -0700539 for (; element < numElements; ++element) {
540 close(fenceFds[element]);
541 }
Dan Stoza651bf312015-10-23 17:03:17 -0700542 return Error::BadLayer;
543 }
544 }
545
546 *outFences = std::move(releaseFences);
547 return Error::None;
548}
549
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800550Error Display::present(sp<Fence>* outPresentFence)
Dan Stoza651bf312015-10-23 17:03:17 -0700551{
Naseer Ahmed847650b2016-06-17 11:14:25 -0400552 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700553 auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700554 auto error = static_cast<Error>(intError);
555 if (error != Error::None) {
556 return error;
557 }
558
Fabien Sanglard11d0fc32016-12-01 15:43:01 -0800559 *outPresentFence = new Fence(presentFenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700560 return Error::None;
561}
562
563Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
564{
565 if (config->getDisplayId() != mId) {
566 ALOGE("setActiveConfig received config %u for the wrong display %"
567 PRIu64 " (expected %" PRIu64 ")", config->getId(),
568 config->getDisplayId(), mId);
569 return Error::BadConfig;
570 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700571 auto intError = mComposer.setActiveConfig(mId, config->getId());
Dan Stoza651bf312015-10-23 17:03:17 -0700572 return static_cast<Error>(intError);
573}
574
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400575Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700576 const sp<Fence>& acquireFence, Dataspace dataspace)
Dan Stoza651bf312015-10-23 17:03:17 -0700577{
Dan Stoza5cf424b2016-05-20 14:02:39 -0700578 // TODO: Properly encode client target surface damage
Dan Stoza651bf312015-10-23 17:03:17 -0700579 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700580 auto intError = mComposer.setClientTarget(mId, slot, target,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700581 fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700582 return static_cast<Error>(intError);
583}
584
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700585Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
Dan Stoza076ac672016-03-14 10:47:53 -0700586{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700587 auto intError = mComposer.setColorMode(mId, mode, renderIntent);
Dan Stoza076ac672016-03-14 10:47:53 -0700588 return static_cast<Error>(intError);
589}
590
Dan Stoza5df2a862016-03-24 16:19:37 -0700591Error Display::setColorTransform(const android::mat4& matrix,
592 android_color_transform_t hint)
593{
Steven Thomas94e35b92017-07-26 18:48:28 -0700594 auto intError = mComposer.setColorTransform(mId,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800595 matrix.asArray(), static_cast<Hwc2::ColorTransform>(hint));
Dan Stoza5df2a862016-03-24 16:19:37 -0700596 return static_cast<Error>(intError);
597}
598
Dan Stoza651bf312015-10-23 17:03:17 -0700599Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
600 const sp<Fence>& releaseFence)
601{
602 int32_t fenceFd = releaseFence->dup();
603 auto handle = buffer->getNativeBuffer()->handle;
Steven Thomas94e35b92017-07-26 18:48:28 -0700604 auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
Dan Stoza38628982016-07-13 15:48:58 -0700605 close(fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700606 return static_cast<Error>(intError);
607}
608
609Error Display::setPowerMode(PowerMode mode)
610{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800611 auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700612 auto intError = mComposer.setPowerMode(mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700613 return static_cast<Error>(intError);
614}
615
616Error Display::setVsyncEnabled(Vsync enabled)
617{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800618 auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
Steven Thomas94e35b92017-07-26 18:48:28 -0700619 auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
Dan Stoza651bf312015-10-23 17:03:17 -0700620 return static_cast<Error>(intError);
621}
622
623Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
624{
625 uint32_t numTypes = 0;
626 uint32_t numRequests = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700627 auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
Dan Stoza651bf312015-10-23 17:03:17 -0700628 auto error = static_cast<Error>(intError);
629 if (error != Error::None && error != Error::HasChanges) {
630 return error;
631 }
632
633 *outNumTypes = numTypes;
634 *outNumRequests = numRequests;
635 return error;
636}
637
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700638Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
639 sp<android::Fence>* outPresentFence, uint32_t* state) {
640
641 uint32_t numTypes = 0;
642 uint32_t numRequests = 0;
643 int32_t presentFenceFd = -1;
Steven Thomas94e35b92017-07-26 18:48:28 -0700644 auto intError = mComposer.presentOrValidateDisplay(
645 mId, &numTypes, &numRequests, &presentFenceFd, state);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700646 auto error = static_cast<Error>(intError);
647 if (error != Error::None && error != Error::HasChanges) {
648 return error;
649 }
650
651 if (*state == 1) {
652 *outPresentFence = new Fence(presentFenceFd);
653 }
654
655 if (*state == 0) {
656 *outNumTypes = numTypes;
657 *outNumRequests = numRequests;
658 }
659 return error;
660}
Chia-I Wu0c6ce462017-06-22 10:48:28 -0700661
Dan Stoza651bf312015-10-23 17:03:17 -0700662// For use by Device
663
Steven Thomas94e35b92017-07-26 18:48:28 -0700664void Display::setConnected(bool connected) {
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800665 if (!mIsConnected && connected) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700666 mComposer.setClientTargetSlotCount(mId);
Steven Thomasb6c6ad42018-01-29 12:22:00 -0800667 if (mType == DisplayType::Physical) {
668 loadConfigs();
669 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700670 }
671 mIsConnected = connected;
672}
673
Dan Stoza651bf312015-10-23 17:03:17 -0700674int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
675{
676 int32_t value = 0;
Steven Thomas94e35b92017-07-26 18:48:28 -0700677 auto intError = mComposer.getDisplayAttribute(mId, configId,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800678 static_cast<Hwc2::IComposerClient::Attribute>(attribute),
679 &value);
Dan Stoza651bf312015-10-23 17:03:17 -0700680 auto error = static_cast<Error>(intError);
681 if (error != Error::None) {
682 ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
683 configId, to_string(attribute).c_str(),
684 to_string(error).c_str(), intError);
685 return -1;
686 }
687 return value;
688}
689
690void Display::loadConfig(hwc2_config_t configId)
691{
692 ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
693
694 auto config = Config::Builder(*this, configId)
695 .setWidth(getAttribute(configId, Attribute::Width))
696 .setHeight(getAttribute(configId, Attribute::Height))
697 .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod))
698 .setDpiX(getAttribute(configId, Attribute::DpiX))
699 .setDpiY(getAttribute(configId, Attribute::DpiY))
700 .build();
701 mConfigs.emplace(configId, std::move(config));
702}
703
704void Display::loadConfigs()
705{
706 ALOGV("[%" PRIu64 "] loadConfigs", mId);
707
Chia-I Wuaab99f52016-10-05 12:59:58 +0800708 std::vector<Hwc2::Config> configIds;
Steven Thomas94e35b92017-07-26 18:48:28 -0700709 auto intError = mComposer.getDisplayConfigs(mId, &configIds);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800710 auto error = static_cast<Error>(intError);
Dan Stoza651bf312015-10-23 17:03:17 -0700711 if (error != Error::None) {
712 ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
713 to_string(error).c_str(), intError);
714 return;
715 }
716
717 for (auto configId : configIds) {
718 loadConfig(configId);
719 }
720}
721
Dan Stoza651bf312015-10-23 17:03:17 -0700722// Other Display methods
723
Steven Thomas94e35b92017-07-26 18:48:28 -0700724Layer* Display::getLayerById(hwc2_layer_t id) const
Dan Stoza651bf312015-10-23 17:03:17 -0700725{
726 if (mLayers.count(id) == 0) {
727 return nullptr;
728 }
729
Steven Thomas94e35b92017-07-26 18:48:28 -0700730 return mLayers.at(id).get();
Dan Stoza651bf312015-10-23 17:03:17 -0700731}
732
733// Layer methods
734
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700735Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
Steven Thomas94e35b92017-07-26 18:48:28 -0700736 hwc2_display_t displayId, hwc2_layer_t layerId)
737 : mComposer(composer),
738 mCapabilities(capabilities),
739 mDisplayId(displayId),
740 mId(layerId)
Dan Stoza651bf312015-10-23 17:03:17 -0700741{
Steven Thomas94e35b92017-07-26 18:48:28 -0700742 ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
Dan Stoza651bf312015-10-23 17:03:17 -0700743}
744
745Layer::~Layer()
746{
Steven Thomas94e35b92017-07-26 18:48:28 -0700747 auto intError = mComposer.destroyLayer(mDisplayId, mId);
748 auto error = static_cast<Error>(intError);
749 ALOGE_IF(error != Error::None, "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
750 " failed: %s (%d)", mDisplayId, mId, to_string(error).c_str(),
751 intError);
752 if (mLayerDestroyedListener) {
753 mLayerDestroyedListener(this);
Dan Stoza651bf312015-10-23 17:03:17 -0700754 }
755}
756
Steven Thomas94e35b92017-07-26 18:48:28 -0700757void Layer::setLayerDestroyedListener(std::function<void(Layer*)> listener) {
758 LOG_ALWAYS_FATAL_IF(mLayerDestroyedListener && listener,
759 "Attempt to set layer destroyed listener multiple times");
760 mLayerDestroyedListener = listener;
761}
762
Dan Stoza651bf312015-10-23 17:03:17 -0700763Error Layer::setCursorPosition(int32_t x, int32_t y)
764{
Steven Thomas94e35b92017-07-26 18:48:28 -0700765 auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
Dan Stoza651bf312015-10-23 17:03:17 -0700766 return static_cast<Error>(intError);
767}
768
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400769Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
Dan Stoza651bf312015-10-23 17:03:17 -0700770 const sp<Fence>& acquireFence)
771{
772 int32_t fenceFd = acquireFence->dup();
Steven Thomas94e35b92017-07-26 18:48:28 -0700773 auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
774 fenceFd);
Dan Stoza651bf312015-10-23 17:03:17 -0700775 return static_cast<Error>(intError);
776}
777
778Error Layer::setSurfaceDamage(const Region& damage)
779{
780 // We encode default full-screen damage as INVALID_RECT upstream, but as 0
781 // rects for HWC
Chia-I Wuaab99f52016-10-05 12:59:58 +0800782 Hwc2::Error intError = Hwc2::Error::NONE;
Dan Stoza651bf312015-10-23 17:03:17 -0700783 if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
Steven Thomas94e35b92017-07-26 18:48:28 -0700784 intError = mComposer.setLayerSurfaceDamage(mDisplayId,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800785 mId, std::vector<Hwc2::IComposerClient::Rect>());
Dan Stoza651bf312015-10-23 17:03:17 -0700786 } else {
787 size_t rectCount = 0;
788 auto rectArray = damage.getArray(&rectCount);
789
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800790 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700791 for (size_t rect = 0; rect < rectCount; ++rect) {
792 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
793 rectArray[rect].right, rectArray[rect].bottom});
794 }
795
Steven Thomas94e35b92017-07-26 18:48:28 -0700796 intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700797 }
798
799 return static_cast<Error>(intError);
800}
801
802Error Layer::setBlendMode(BlendMode mode)
803{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800804 auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
Steven Thomas94e35b92017-07-26 18:48:28 -0700805 auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, intMode);
Dan Stoza651bf312015-10-23 17:03:17 -0700806 return static_cast<Error>(intError);
807}
808
809Error Layer::setColor(hwc_color_t color)
810{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800811 Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
Steven Thomas94e35b92017-07-26 18:48:28 -0700812 auto intError = mComposer.setLayerColor(mDisplayId, mId, hwcColor);
Dan Stoza651bf312015-10-23 17:03:17 -0700813 return static_cast<Error>(intError);
814}
815
816Error Layer::setCompositionType(Composition type)
817{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800818 auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
Steven Thomas94e35b92017-07-26 18:48:28 -0700819 auto intError = mComposer.setLayerCompositionType(
820 mDisplayId, mId, intType);
Dan Stoza651bf312015-10-23 17:03:17 -0700821 return static_cast<Error>(intError);
822}
823
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700824Error Layer::setDataspace(Dataspace dataspace)
Dan Stoza5df2a862016-03-24 16:19:37 -0700825{
Courtney Goeltzenleuchterc988ee42017-05-31 17:56:46 -0600826 if (dataspace == mDataSpace) {
827 return Error::None;
828 }
829 mDataSpace = dataspace;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700830 auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
Dan Stoza5df2a862016-03-24 16:19:37 -0700831 return static_cast<Error>(intError);
832}
833
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700834Error Layer::setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
835 const android::HdrMetadata& metadata)
836{
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700837 if (metadata == mHdrMetadata) {
838 return Error::None;
839 }
840
841 mHdrMetadata = metadata;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700842 int validTypes = mHdrMetadata.validTypes & supportedPerFrameMetadata;
843 std::vector<Hwc2::PerFrameMetadata> perFrameMetadatas;
844 if (validTypes & HdrMetadata::SMPTE2086) {
845 perFrameMetadatas.insert(perFrameMetadatas.end(),
846 {{Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
847 mHdrMetadata.smpte2086.displayPrimaryRed.x},
848 {Hwc2::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
849 mHdrMetadata.smpte2086.displayPrimaryRed.y},
850 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
851 mHdrMetadata.smpte2086.displayPrimaryGreen.x},
852 {Hwc2::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
853 mHdrMetadata.smpte2086.displayPrimaryGreen.y},
854 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
855 mHdrMetadata.smpte2086.displayPrimaryBlue.x},
856 {Hwc2::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
857 mHdrMetadata.smpte2086.displayPrimaryBlue.y},
858 {Hwc2::PerFrameMetadataKey::WHITE_POINT_X,
859 mHdrMetadata.smpte2086.whitePoint.x},
860 {Hwc2::PerFrameMetadataKey::WHITE_POINT_Y,
861 mHdrMetadata.smpte2086.whitePoint.y},
862 {Hwc2::PerFrameMetadataKey::MAX_LUMINANCE,
863 mHdrMetadata.smpte2086.maxLuminance},
864 {Hwc2::PerFrameMetadataKey::MIN_LUMINANCE,
865 mHdrMetadata.smpte2086.minLuminance}});
866 }
867
868 if (validTypes & HdrMetadata::CTA861_3) {
869 perFrameMetadatas.insert(perFrameMetadatas.end(),
870 {{Hwc2::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
871 mHdrMetadata.cta8613.maxContentLightLevel},
872 {Hwc2::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
873 mHdrMetadata.cta8613.maxFrameAverageLightLevel}});
874 }
875
876 auto intError = mComposer.setLayerPerFrameMetadata(mDisplayId, mId, perFrameMetadatas);
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700877 return static_cast<Error>(intError);
878}
879
Dan Stoza651bf312015-10-23 17:03:17 -0700880Error Layer::setDisplayFrame(const Rect& frame)
881{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800882 Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800883 frame.right, frame.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700884 auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700885 return static_cast<Error>(intError);
886}
887
888Error Layer::setPlaneAlpha(float alpha)
889{
Steven Thomas94e35b92017-07-26 18:48:28 -0700890 auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
Dan Stoza651bf312015-10-23 17:03:17 -0700891 return static_cast<Error>(intError);
892}
893
894Error Layer::setSidebandStream(const native_handle_t* stream)
895{
Steven Thomas94e35b92017-07-26 18:48:28 -0700896 if (mCapabilities.count(Capability::SidebandStream) == 0) {
Dan Stoza09e7a272016-04-14 12:31:01 -0700897 ALOGE("Attempted to call setSidebandStream without checking that the "
898 "device supports sideband streams");
899 return Error::Unsupported;
900 }
Steven Thomas94e35b92017-07-26 18:48:28 -0700901 auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
Dan Stoza651bf312015-10-23 17:03:17 -0700902 return static_cast<Error>(intError);
903}
904
905Error Layer::setSourceCrop(const FloatRect& crop)
906{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800907 Hwc2::IComposerClient::FRect hwcRect{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800908 crop.left, crop.top, crop.right, crop.bottom};
Steven Thomas94e35b92017-07-26 18:48:28 -0700909 auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
Dan Stoza651bf312015-10-23 17:03:17 -0700910 return static_cast<Error>(intError);
911}
912
913Error Layer::setTransform(Transform transform)
914{
Chia-I Wuaab99f52016-10-05 12:59:58 +0800915 auto intTransform = static_cast<Hwc2::Transform>(transform);
Steven Thomas94e35b92017-07-26 18:48:28 -0700916 auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
Dan Stoza651bf312015-10-23 17:03:17 -0700917 return static_cast<Error>(intError);
918}
919
920Error Layer::setVisibleRegion(const Region& region)
921{
922 size_t rectCount = 0;
923 auto rectArray = region.getArray(&rectCount);
924
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800925 std::vector<Hwc2::IComposerClient::Rect> hwcRects;
Dan Stoza651bf312015-10-23 17:03:17 -0700926 for (size_t rect = 0; rect < rectCount; ++rect) {
927 hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
928 rectArray[rect].right, rectArray[rect].bottom});
929 }
930
Steven Thomas94e35b92017-07-26 18:48:28 -0700931 auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
Dan Stoza651bf312015-10-23 17:03:17 -0700932 return static_cast<Error>(intError);
933}
934
935Error Layer::setZOrder(uint32_t z)
936{
Steven Thomas94e35b92017-07-26 18:48:28 -0700937 auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
Dan Stoza651bf312015-10-23 17:03:17 -0700938 return static_cast<Error>(intError);
939}
940
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500941Error Layer::setInfo(uint32_t type, uint32_t appId)
942{
Steven Thomas94e35b92017-07-26 18:48:28 -0700943 auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500944 return static_cast<Error>(intError);
945}
946
Dan Stoza651bf312015-10-23 17:03:17 -0700947} // namespace HWC2