blob: 1bf43dacdf0051d313b2afea7c2ee28557283021 [file] [log] [blame]
Chia-I Wuaab99f52016-10-05 12:59:58 +08001/*
2 * Copyright 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Chia-I Wuaab99f52016-10-05 12:59:58 +080021#undef LOG_TAG
22#define LOG_TAG "HwcComposer"
23
Chia-I Wuaab99f52016-10-05 12:59:58 +080024#include <log/log.h>
25
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070026#include <algorithm>
27#include <cinttypes>
28
Chia-I Wuaab99f52016-10-05 12:59:58 +080029#include "ComposerHal.h"
30
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070031#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
32#include <gui/BufferQueue.h>
Wei Wangae211b42019-06-07 17:22:49 -070033#include <hidl/HidlTransportSupport.h>
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070034#include <hidl/HidlTransportUtils.h>
35
Chia-I Wuaab99f52016-10-05 12:59:58 +080036namespace android {
37
38using hardware::Return;
39using hardware::hidl_vec;
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010040using hardware::hidl_handle;
Chia-I Wuaab99f52016-10-05 12:59:58 +080041
42namespace Hwc2 {
43
Lloyd Piquea822d522017-12-20 16:42:57 -080044Composer::~Composer() = default;
45
Chia-I Wuaab99f52016-10-05 12:59:58 +080046namespace {
47
48class BufferHandle {
49public:
Chih-Hung Hsieh22749042018-12-20 15:50:39 -080050 explicit BufferHandle(const native_handle_t* buffer) {
Chia-I Wuaab99f52016-10-05 12:59:58 +080051 // nullptr is not a valid handle to HIDL
52 mHandle = (buffer) ? buffer : native_handle_init(mStorage, 0, 0);
53 }
54
Chih-Hung Hsieh22749042018-12-20 15:50:39 -080055 operator const hidl_handle&() const // NOLINT(google-explicit-constructor)
Chia-I Wuaab99f52016-10-05 12:59:58 +080056 {
57 return mHandle;
58 }
59
60private:
61 NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 0, 0);
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010062 hidl_handle mHandle;
Chia-I Wuaab99f52016-10-05 12:59:58 +080063};
64
65class FenceHandle
66{
67public:
68 FenceHandle(int fd, bool owned)
69 : mOwned(owned)
70 {
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010071 native_handle_t* handle;
Chia-I Wuaab99f52016-10-05 12:59:58 +080072 if (fd >= 0) {
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010073 handle = native_handle_init(mStorage, 1, 0);
74 handle->data[0] = fd;
Chia-I Wuaab99f52016-10-05 12:59:58 +080075 } else {
76 // nullptr is not a valid handle to HIDL
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010077 handle = native_handle_init(mStorage, 0, 0);
Chia-I Wuaab99f52016-10-05 12:59:58 +080078 }
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010079 mHandle = handle;
Chia-I Wuaab99f52016-10-05 12:59:58 +080080 }
81
82 ~FenceHandle()
83 {
84 if (mOwned) {
85 native_handle_close(mHandle);
86 }
87 }
88
Chih-Hung Hsieh22749042018-12-20 15:50:39 -080089 operator const hidl_handle&() const // NOLINT(google-explicit-constructor)
Chia-I Wuaab99f52016-10-05 12:59:58 +080090 {
91 return mHandle;
92 }
93
94private:
95 bool mOwned;
96 NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 1, 0);
Martijn Coenen7c5a92f2016-11-21 10:01:07 +010097 hidl_handle mHandle;
Chia-I Wuaab99f52016-10-05 12:59:58 +080098};
99
100// assume NO_RESOURCES when Status::isOk returns false
101constexpr Error kDefaultError = Error::NO_RESOURCES;
Ady Abraham7159f572019-10-11 11:10:18 -0700102constexpr V2_4::Error kDefaultError_2_4 = static_cast<V2_4::Error>(kDefaultError);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800103
104template<typename T, typename U>
105T unwrapRet(Return<T>& ret, const U& default_val)
106{
Steven Moreland9d021002017-01-03 17:10:54 -0800107 return (ret.isOk()) ? static_cast<T>(ret) :
Chia-I Wuaab99f52016-10-05 12:59:58 +0800108 static_cast<T>(default_val);
109}
110
111Error unwrapRet(Return<Error>& ret)
112{
113 return unwrapRet(ret, kDefaultError);
114}
115
Chia-I Wuaab99f52016-10-05 12:59:58 +0800116} // anonymous namespace
117
Lloyd Piquea822d522017-12-20 16:42:57 -0800118namespace impl {
119
Alec Mouri9c58bcd2020-09-09 18:57:07 -0700120Composer::Composer(const std::string& serviceName) : mWriter(kWriterInitialSize) {
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700121 mComposer = V2_1::IComposer::getService(serviceName);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500122
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800123 if (mComposer == nullptr) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800124 LOG_ALWAYS_FATAL("failed to get hwcomposer service");
125 }
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800126
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700127 if (sp<IComposer> composer_2_4 = IComposer::castFrom(mComposer)) {
128 composer_2_4->createClient_2_4([&](const auto& tmpError, const auto& tmpClient) {
Ady Abrahamf2e339e2019-10-16 18:23:35 -0700129 if (tmpError == V2_4::Error::NONE) {
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700130 mClient = tmpClient;
131 mClient_2_2 = tmpClient;
132 mClient_2_3 = tmpClient;
133 mClient_2_4 = tmpClient;
134 }
135 });
136 } else if (sp<V2_3::IComposer> composer_2_3 = V2_3::IComposer::castFrom(mComposer)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700137 composer_2_3->createClient_2_3([&](const auto& tmpError, const auto& tmpClient) {
138 if (tmpError == Error::NONE) {
139 mClient = tmpClient;
140 mClient_2_2 = tmpClient;
141 mClient_2_3 = tmpClient;
142 }
143 });
144 } else {
145 mComposer->createClient([&](const auto& tmpError, const auto& tmpClient) {
146 if (tmpError != Error::NONE) {
147 return;
148 }
149
150 mClient = tmpClient;
151 if (sp<V2_2::IComposer> composer_2_2 = V2_2::IComposer::castFrom(mComposer)) {
152 mClient_2_2 = V2_2::IComposerClient::castFrom(mClient);
153 LOG_ALWAYS_FATAL_IF(mClient_2_2 == nullptr,
154 "IComposer 2.2 did not return IComposerClient 2.2");
155 }
156 });
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800157 }
Daniel Nicoaraa50abc22017-05-15 10:34:08 -0400158
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700159 if (mClient == nullptr) {
160 LOG_ALWAYS_FATAL("failed to create composer client");
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700161 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800162}
163
Lloyd Piquea822d522017-12-20 16:42:57 -0800164Composer::~Composer() = default;
165
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800166std::vector<IComposer::Capability> Composer::getCapabilities()
Chia-I Wuaab99f52016-10-05 12:59:58 +0800167{
168 std::vector<IComposer::Capability> capabilities;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800169 mComposer->getCapabilities(
Chia-I Wuaab99f52016-10-05 12:59:58 +0800170 [&](const auto& tmpCapabilities) {
Chia-I Wu67e376d2016-12-19 11:36:22 +0800171 capabilities = tmpCapabilities;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800172 });
Chia-I Wuaab99f52016-10-05 12:59:58 +0800173 return capabilities;
174}
175
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800176std::string Composer::dumpDebugInfo()
Chia-I Wuaab99f52016-10-05 12:59:58 +0800177{
178 std::string info;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800179 mComposer->dumpDebugInfo([&](const auto& tmpInfo) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800180 info = tmpInfo.c_str();
181 });
182
183 return info;
184}
185
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800186void Composer::registerCallback(const sp<IComposerCallback>& callback)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800187{
Wei Wangae211b42019-06-07 17:22:49 -0700188 android::hardware::setMinSchedulerPolicy(callback, SCHED_FIFO, 2);
Ady Abraham7159f572019-10-11 11:10:18 -0700189 auto ret = [&]() {
190 if (mClient_2_4) {
191 return mClient_2_4->registerCallback_2_4(callback);
192 }
193 return mClient->registerCallback(callback);
194 }();
Steven Moreland9d021002017-01-03 17:10:54 -0800195 if (!ret.isOk()) {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800196 ALOGE("failed to register IComposerCallback");
197 }
198}
199
Steven Thomas0af4b9f2017-04-26 14:34:01 -0700200void Composer::resetCommands() {
201 mWriter.reset();
202}
203
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700204Error Composer::executeCommands() {
205 return execute();
206}
207
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800208uint32_t Composer::getMaxVirtualDisplayCount()
Chia-I Wuaab99f52016-10-05 12:59:58 +0800209{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800210 auto ret = mClient->getMaxVirtualDisplayCount();
Chia-I Wuaab99f52016-10-05 12:59:58 +0800211 return unwrapRet(ret, 0);
212}
213
214Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800215 PixelFormat* format, Display* outDisplay)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800216{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800217 const uint32_t bufferSlotCount = 1;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800218 Error error = kDefaultError;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700219 if (mClient_2_2) {
Kevin DuBois73d0f482019-01-25 11:18:03 -0800220 mClient_2_2->createVirtualDisplay_2_2(width, height,
221 static_cast<types::V1_1::PixelFormat>(*format),
222 bufferSlotCount,
223 [&](const auto& tmpError, const auto& tmpDisplay,
224 const auto& tmpFormat) {
225 error = tmpError;
226 if (error != Error::NONE) {
227 return;
228 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800229
Kevin DuBois73d0f482019-01-25 11:18:03 -0800230 *outDisplay = tmpDisplay;
231 *format = static_cast<types::V1_2::PixelFormat>(
232 tmpFormat);
233 });
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700234 } else {
235 mClient->createVirtualDisplay(width, height,
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700236 static_cast<types::V1_0::PixelFormat>(*format), bufferSlotCount,
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700237 [&](const auto& tmpError, const auto& tmpDisplay,
238 const auto& tmpFormat) {
239 error = tmpError;
240 if (error != Error::NONE) {
241 return;
242 }
243
244 *outDisplay = tmpDisplay;
245 *format = static_cast<PixelFormat>(tmpFormat);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800246 });
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700247 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800248
249 return error;
250}
251
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800252Error Composer::destroyVirtualDisplay(Display display)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800253{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800254 auto ret = mClient->destroyVirtualDisplay(display);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800255 return unwrapRet(ret);
256}
257
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800258Error Composer::acceptDisplayChanges(Display display)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800259{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800260 mWriter.selectDisplay(display);
261 mWriter.acceptDisplayChanges();
262 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800263}
264
Chia-I Wu67e376d2016-12-19 11:36:22 +0800265Error Composer::createLayer(Display display, Layer* outLayer)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800266{
267 Error error = kDefaultError;
Chia-I Wu06d63de2017-01-04 14:58:51 +0800268 mClient->createLayer(display, BufferQueue::NUM_BUFFER_SLOTS,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800269 [&](const auto& tmpError, const auto& tmpLayer) {
270 error = tmpError;
271 if (error != Error::NONE) {
272 return;
273 }
274
Chia-I Wu67e376d2016-12-19 11:36:22 +0800275 *outLayer = tmpLayer;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800276 });
277
278 return error;
279}
280
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800281Error Composer::destroyLayer(Display display, Layer layer)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800282{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800283 auto ret = mClient->destroyLayer(display, layer);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800284 return unwrapRet(ret);
285}
286
Chia-I Wu67e376d2016-12-19 11:36:22 +0800287Error Composer::getActiveConfig(Display display, Config* outConfig)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800288{
289 Error error = kDefaultError;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800290 mClient->getActiveConfig(display,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800291 [&](const auto& tmpError, const auto& tmpConfig) {
292 error = tmpError;
293 if (error != Error::NONE) {
294 return;
295 }
296
Chia-I Wu67e376d2016-12-19 11:36:22 +0800297 *outConfig = tmpConfig;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800298 });
299
300 return error;
301}
302
303Error Composer::getChangedCompositionTypes(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800304 std::vector<Layer>* outLayers,
305 std::vector<IComposerClient::Composition>* outTypes)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800306{
Chia-I Wu67e376d2016-12-19 11:36:22 +0800307 mReader.takeChangedCompositionTypes(display, outLayers, outTypes);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800308 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800309}
310
311Error Composer::getColorModes(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800312 std::vector<ColorMode>* outModes)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800313{
314 Error error = kDefaultError;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800315
Valerie Hau9758ae02018-10-09 16:05:09 -0700316 if (mClient_2_3) {
317 mClient_2_3->getColorModes_2_3(display, [&](const auto& tmpError, const auto& tmpModes) {
318 error = tmpError;
319 if (error != Error::NONE) {
320 return;
321 }
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700322
Valerie Hau9758ae02018-10-09 16:05:09 -0700323 *outModes = tmpModes;
324 });
325 } else if (mClient_2_2) {
326 mClient_2_2->getColorModes_2_2(display, [&](const auto& tmpError, const auto& tmpModes) {
327 error = tmpError;
328 if (error != Error::NONE) {
329 return;
330 }
331
332 for (types::V1_1::ColorMode colorMode : tmpModes) {
333 outModes->push_back(static_cast<ColorMode>(colorMode));
334 }
335 });
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700336 } else {
337 mClient->getColorModes(display,
338 [&](const auto& tmpError, const auto& tmpModes) {
339 error = tmpError;
340 if (error != Error::NONE) {
341 return;
342 }
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700343 for (types::V1_0::ColorMode colorMode : tmpModes) {
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700344 outModes->push_back(static_cast<ColorMode>(colorMode));
345 }
346 });
347 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800348
349 return error;
350}
351
352Error Composer::getDisplayAttribute(Display display, Config config,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800353 IComposerClient::Attribute attribute, int32_t* outValue)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800354{
355 Error error = kDefaultError;
Ady Abraham7159f572019-10-11 11:10:18 -0700356 if (mClient_2_4) {
357 mClient_2_4->getDisplayAttribute_2_4(display, config, attribute,
358 [&](const auto& tmpError, const auto& tmpValue) {
359 error = static_cast<Error>(tmpError);
360 if (error != Error::NONE) {
361 return;
362 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800363
Ady Abraham7159f572019-10-11 11:10:18 -0700364 *outValue = tmpValue;
365 });
366 } else {
367 mClient->getDisplayAttribute(display, config,
368 static_cast<V2_1::IComposerClient::Attribute>(attribute),
369 [&](const auto& tmpError, const auto& tmpValue) {
370 error = tmpError;
371 if (error != Error::NONE) {
372 return;
373 }
374
375 *outValue = tmpValue;
376 });
377 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800378
379 return error;
380}
381
382Error Composer::getDisplayConfigs(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800383 std::vector<Config>* outConfigs)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800384{
385 Error error = kDefaultError;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800386 mClient->getDisplayConfigs(display,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800387 [&](const auto& tmpError, const auto& tmpConfigs) {
388 error = tmpError;
389 if (error != Error::NONE) {
390 return;
391 }
392
Chia-I Wu67e376d2016-12-19 11:36:22 +0800393 *outConfigs = tmpConfigs;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800394 });
395
396 return error;
397}
398
Chia-I Wu67e376d2016-12-19 11:36:22 +0800399Error Composer::getDisplayName(Display display, std::string* outName)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800400{
401 Error error = kDefaultError;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800402 mClient->getDisplayName(display,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800403 [&](const auto& tmpError, const auto& tmpName) {
404 error = tmpError;
405 if (error != Error::NONE) {
406 return;
407 }
408
Chia-I Wu67e376d2016-12-19 11:36:22 +0800409 *outName = tmpName.c_str();
Chia-I Wuaab99f52016-10-05 12:59:58 +0800410 });
411
412 return error;
413}
414
415Error Composer::getDisplayRequests(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800416 uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
417 std::vector<uint32_t>* outLayerRequestMasks)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800418{
Chia-I Wu67e376d2016-12-19 11:36:22 +0800419 mReader.takeDisplayRequests(display, outDisplayRequestMask,
420 outLayers, outLayerRequestMasks);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800421 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800422}
423
Chia-I Wu67e376d2016-12-19 11:36:22 +0800424Error Composer::getDozeSupport(Display display, bool* outSupport)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800425{
426 Error error = kDefaultError;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800427 mClient->getDozeSupport(display,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800428 [&](const auto& tmpError, const auto& tmpSupport) {
429 error = tmpError;
430 if (error != Error::NONE) {
431 return;
432 }
433
Chia-I Wu67e376d2016-12-19 11:36:22 +0800434 *outSupport = tmpSupport;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800435 });
436
437 return error;
438}
439
Chia-I Wu67e376d2016-12-19 11:36:22 +0800440Error Composer::getHdrCapabilities(Display display,
441 std::vector<Hdr>* outTypes, float* outMaxLuminance,
442 float* outMaxAverageLuminance, float* outMinLuminance)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800443{
444 Error error = kDefaultError;
Valerie Haue9e843a2018-12-18 13:39:23 -0800445 if (mClient_2_3) {
446 mClient_2_3->getHdrCapabilities_2_3(display,
447 [&](const auto& tmpError, const auto& tmpTypes,
448 const auto& tmpMaxLuminance,
449 const auto& tmpMaxAverageLuminance,
450 const auto& tmpMinLuminance) {
451 error = tmpError;
452 if (error != Error::NONE) {
453 return;
454 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800455
Valerie Haue9e843a2018-12-18 13:39:23 -0800456 *outTypes = tmpTypes;
457 *outMaxLuminance = tmpMaxLuminance;
458 *outMaxAverageLuminance = tmpMaxAverageLuminance;
459 *outMinLuminance = tmpMinLuminance;
460 });
461 } else {
462 mClient->getHdrCapabilities(display,
463 [&](const auto& tmpError, const auto& tmpTypes,
464 const auto& tmpMaxLuminance,
465 const auto& tmpMaxAverageLuminance,
466 const auto& tmpMinLuminance) {
467 error = tmpError;
468 if (error != Error::NONE) {
469 return;
470 }
471
472 outTypes->clear();
473 for (auto type : tmpTypes) {
474 outTypes->push_back(static_cast<Hdr>(type));
475 }
476
477 *outMaxLuminance = tmpMaxLuminance;
478 *outMaxAverageLuminance = tmpMaxAverageLuminance;
479 *outMinLuminance = tmpMinLuminance;
480 });
481 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800482
483 return error;
484}
485
Chia-I Wu67e376d2016-12-19 11:36:22 +0800486Error Composer::getReleaseFences(Display display,
487 std::vector<Layer>* outLayers, std::vector<int>* outReleaseFences)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800488{
Chia-I Wu67e376d2016-12-19 11:36:22 +0800489 mReader.takeReleaseFences(display, outLayers, outReleaseFences);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800490 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800491}
492
Chia-I Wu67e376d2016-12-19 11:36:22 +0800493Error Composer::presentDisplay(Display display, int* outPresentFence)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800494{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800495 mWriter.selectDisplay(display);
496 mWriter.presentDisplay();
Chia-I Wuaab99f52016-10-05 12:59:58 +0800497
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800498 Error error = execute();
499 if (error != Error::NONE) {
500 return error;
501 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800502
Chia-I Wu67e376d2016-12-19 11:36:22 +0800503 mReader.takePresentFence(display, outPresentFence);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800504
505 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800506}
507
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800508Error Composer::setActiveConfig(Display display, Config config)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800509{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800510 auto ret = mClient->setActiveConfig(display, config);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800511 return unwrapRet(ret);
512}
513
Chia-I Wu06d63de2017-01-04 14:58:51 +0800514Error Composer::setClientTarget(Display display, uint32_t slot,
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400515 const sp<GraphicBuffer>& target,
Chia-I Wuaab99f52016-10-05 12:59:58 +0800516 int acquireFence, Dataspace dataspace,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800517 const std::vector<IComposerClient::Rect>& damage)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800518{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800519 mWriter.selectDisplay(display);
mamik94e91f62019-08-19 09:11:33 -0700520
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400521 const native_handle_t* handle = nullptr;
522 if (target.get()) {
523 handle = target->getNativeBuffer()->handle;
524 }
525
526 mWriter.setClientTarget(slot, handle, acquireFence, dataspace, damage);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800527 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800528}
529
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700530Error Composer::setColorMode(Display display, ColorMode mode,
531 RenderIntent renderIntent)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800532{
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700533 hardware::Return<Error> ret(kDefaultError);
Valerie Hau9758ae02018-10-09 16:05:09 -0700534 if (mClient_2_3) {
535 ret = mClient_2_3->setColorMode_2_3(display, mode, renderIntent);
536 } else if (mClient_2_2) {
537 ret = mClient_2_2->setColorMode_2_2(display, static_cast<types::V1_1::ColorMode>(mode),
538 renderIntent);
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700539 } else {
540 ret = mClient->setColorMode(display,
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700541 static_cast<types::V1_0::ColorMode>(mode));
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700542 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800543 return unwrapRet(ret);
544}
545
546Error Composer::setColorTransform(Display display, const float* matrix,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800547 ColorTransform hint)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800548{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800549 mWriter.selectDisplay(display);
550 mWriter.setColorTransform(matrix, hint);
551 return Error::NONE;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800552}
553
554Error Composer::setOutputBuffer(Display display, const native_handle_t* buffer,
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800555 int releaseFence)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800556{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800557 mWriter.selectDisplay(display);
558 mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
559 return Error::NONE;
560}
Chia-I Wuaab99f52016-10-05 12:59:58 +0800561
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700562Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode) {
563 Return<Error> ret(Error::UNSUPPORTED);
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700564 if (mClient_2_2) {
565 ret = mClient_2_2->setPowerMode_2_2(display, mode);
566 } else if (mode != IComposerClient::PowerMode::ON_SUSPEND) {
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700567 ret = mClient->setPowerMode(display, static_cast<V2_1::IComposerClient::PowerMode>(mode));
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700568 }
569
Chia-I Wuaab99f52016-10-05 12:59:58 +0800570 return unwrapRet(ret);
571}
572
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800573Error Composer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800574{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800575 auto ret = mClient->setVsyncEnabled(display, enabled);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800576 return unwrapRet(ret);
577}
578
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800579Error Composer::setClientTargetSlotCount(Display display)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800580{
Chia-I Wu06d63de2017-01-04 14:58:51 +0800581 const uint32_t bufferSlotCount = BufferQueue::NUM_BUFFER_SLOTS;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800582 auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
Chia-I Wuaab99f52016-10-05 12:59:58 +0800583 return unwrapRet(ret);
584}
585
Chia-I Wu67e376d2016-12-19 11:36:22 +0800586Error Composer::validateDisplay(Display display, uint32_t* outNumTypes,
587 uint32_t* outNumRequests)
Chia-I Wuaab99f52016-10-05 12:59:58 +0800588{
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800589 mWriter.selectDisplay(display);
590 mWriter.validateDisplay();
591
592 Error error = execute();
593 if (error != Error::NONE) {
594 return error;
595 }
596
Chia-I Wu67e376d2016-12-19 11:36:22 +0800597 mReader.hasChanges(display, outNumTypes, outNumRequests);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800598
599 return Error::NONE;
600}
601
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700602Error Composer::presentOrValidateDisplay(Display display, uint32_t* outNumTypes,
603 uint32_t* outNumRequests, int* outPresentFence, uint32_t* state) {
604 mWriter.selectDisplay(display);
605 mWriter.presentOrvalidateDisplay();
606
607 Error error = execute();
608 if (error != Error::NONE) {
609 return error;
610 }
611
612 mReader.takePresentOrValidateStage(display, state);
613
614 if (*state == 1) { // Present succeeded
615 mReader.takePresentFence(display, outPresentFence);
616 }
617
618 if (*state == 0) { // Validate succeeded.
619 mReader.hasChanges(display, outNumTypes, outNumRequests);
620 }
621
622 return Error::NONE;
623}
624
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800625Error Composer::setCursorPosition(Display display, Layer layer,
626 int32_t x, int32_t y)
627{
628 mWriter.selectDisplay(display);
629 mWriter.selectLayer(layer);
630 mWriter.setLayerCursorPosition(x, y);
631 return Error::NONE;
632}
633
634Error Composer::setLayerBuffer(Display display, Layer layer,
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400635 uint32_t slot, const sp<GraphicBuffer>& buffer, int acquireFence)
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800636{
637 mWriter.selectDisplay(display);
638 mWriter.selectLayer(layer);
mamik94e91f62019-08-19 09:11:33 -0700639
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400640 const native_handle_t* handle = nullptr;
641 if (buffer.get()) {
642 handle = buffer->getNativeBuffer()->handle;
643 }
644
645 mWriter.setLayerBuffer(slot, handle, acquireFence);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800646 return Error::NONE;
647}
648
649Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
650 const std::vector<IComposerClient::Rect>& damage)
651{
652 mWriter.selectDisplay(display);
653 mWriter.selectLayer(layer);
654 mWriter.setLayerSurfaceDamage(damage);
655 return Error::NONE;
656}
657
658Error Composer::setLayerBlendMode(Display display, Layer layer,
659 IComposerClient::BlendMode mode)
660{
661 mWriter.selectDisplay(display);
662 mWriter.selectLayer(layer);
663 mWriter.setLayerBlendMode(mode);
664 return Error::NONE;
665}
666
667Error Composer::setLayerColor(Display display, Layer layer,
668 const IComposerClient::Color& color)
669{
670 mWriter.selectDisplay(display);
671 mWriter.selectLayer(layer);
672 mWriter.setLayerColor(color);
673 return Error::NONE;
674}
675
676Error Composer::setLayerCompositionType(Display display, Layer layer,
677 IComposerClient::Composition type)
678{
679 mWriter.selectDisplay(display);
680 mWriter.selectLayer(layer);
681 mWriter.setLayerCompositionType(type);
682 return Error::NONE;
683}
684
685Error Composer::setLayerDataspace(Display display, Layer layer,
686 Dataspace dataspace)
687{
688 mWriter.selectDisplay(display);
689 mWriter.selectLayer(layer);
690 mWriter.setLayerDataspace(dataspace);
691 return Error::NONE;
692}
693
694Error Composer::setLayerDisplayFrame(Display display, Layer layer,
695 const IComposerClient::Rect& frame)
696{
697 mWriter.selectDisplay(display);
698 mWriter.selectLayer(layer);
699 mWriter.setLayerDisplayFrame(frame);
700 return Error::NONE;
701}
702
703Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
704 float alpha)
705{
706 mWriter.selectDisplay(display);
707 mWriter.selectLayer(layer);
708 mWriter.setLayerPlaneAlpha(alpha);
709 return Error::NONE;
710}
711
712Error Composer::setLayerSidebandStream(Display display, Layer layer,
713 const native_handle_t* stream)
714{
715 mWriter.selectDisplay(display);
716 mWriter.selectLayer(layer);
717 mWriter.setLayerSidebandStream(stream);
718 return Error::NONE;
719}
720
721Error Composer::setLayerSourceCrop(Display display, Layer layer,
722 const IComposerClient::FRect& crop)
723{
724 mWriter.selectDisplay(display);
725 mWriter.selectLayer(layer);
726 mWriter.setLayerSourceCrop(crop);
727 return Error::NONE;
728}
729
730Error Composer::setLayerTransform(Display display, Layer layer,
731 Transform transform)
732{
733 mWriter.selectDisplay(display);
734 mWriter.selectLayer(layer);
735 mWriter.setLayerTransform(transform);
736 return Error::NONE;
737}
738
739Error Composer::setLayerVisibleRegion(Display display, Layer layer,
740 const std::vector<IComposerClient::Rect>& visible)
741{
742 mWriter.selectDisplay(display);
743 mWriter.selectLayer(layer);
744 mWriter.setLayerVisibleRegion(visible);
745 return Error::NONE;
746}
747
748Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
749{
750 mWriter.selectDisplay(display);
751 mWriter.selectLayer(layer);
752 mWriter.setLayerZOrder(z);
753 return Error::NONE;
754}
755
756Error Composer::execute()
757{
758 // prepare input command queue
759 bool queueChanged = false;
760 uint32_t commandLength = 0;
761 hidl_vec<hidl_handle> commandHandles;
Chia-I Wu67e376d2016-12-19 11:36:22 +0800762 if (!mWriter.writeQueue(&queueChanged, &commandLength, &commandHandles)) {
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800763 mWriter.reset();
764 return Error::NO_RESOURCES;
765 }
766
767 // set up new input command queue if necessary
768 if (queueChanged) {
769 auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
770 auto error = unwrapRet(ret);
771 if (error != Error::NONE) {
772 mWriter.reset();
773 return error;
774 }
775 }
776
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700777 if (commandLength == 0) {
778 mWriter.reset();
779 return Error::NONE;
780 }
781
Chia-I Wuaab99f52016-10-05 12:59:58 +0800782 Error error = kDefaultError;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700783 hardware::Return<void> ret;
784 auto hidl_callback = [&](const auto& tmpError, const auto& tmpOutChanged,
785 const auto& tmpOutLength, const auto& tmpOutHandles)
786 {
787 error = tmpError;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800788
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700789 // set up new output command queue if necessary
790 if (error == Error::NONE && tmpOutChanged) {
791 error = kDefaultError;
792 mClient->getOutputCommandQueue(
793 [&](const auto& tmpError,
794 const auto& tmpDescriptor)
795 {
796 error = tmpError;
797 if (error != Error::NONE) {
798 return;
799 }
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800800
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700801 mReader.setMQDescriptor(tmpDescriptor);
802 });
803 }
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800804
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700805 if (error != Error::NONE) {
806 return;
807 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800808
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700809 if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
810 error = mReader.parse();
811 mReader.reset();
812 } else {
813 error = Error::NO_RESOURCES;
814 }
815 };
816 if (mClient_2_2) {
817 ret = mClient_2_2->executeCommands_2_2(commandLength, commandHandles, hidl_callback);
818 } else {
819 ret = mClient->executeCommands(commandLength, commandHandles, hidl_callback);
820 }
Chia-I Wuc0b2b0c2017-09-08 10:14:34 -0700821 // executeCommands can fail because of out-of-fd and we do not want to
822 // abort() in that case
823 if (!ret.isOk()) {
824 ALOGE("executeCommands failed because of %s", ret.description().c_str());
825 }
Chia-I Wuaab99f52016-10-05 12:59:58 +0800826
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800827 if (error == Error::NONE) {
828 std::vector<CommandReader::CommandError> commandErrors =
829 mReader.takeErrors();
830
831 for (const auto& cmdErr : commandErrors) {
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -0700832 auto command =
833 static_cast<IComposerClient::Command>(mWriter.getCommand(cmdErr.location));
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800834
835 if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700836 command == IComposerClient::Command::PRESENT_DISPLAY ||
837 command == IComposerClient::Command::PRESENT_OR_VALIDATE_DISPLAY) {
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800838 error = cmdErr.error;
839 } else {
840 ALOGW("command 0x%x generated error %d",
841 command, cmdErr.error);
842 }
843 }
844 }
845
846 mWriter.reset();
847
Chia-I Wuaab99f52016-10-05 12:59:58 +0800848 return error;
849}
850
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700851// Composer HAL 2.2
852
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700853Error Composer::setLayerPerFrameMetadata(Display display, Layer layer,
854 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) {
855 if (!mClient_2_2) {
856 return Error::UNSUPPORTED;
857 }
858
859 mWriter.selectDisplay(display);
860 mWriter.selectLayer(layer);
861 mWriter.setLayerPerFrameMetadata(perFrameMetadatas);
862 return Error::NONE;
863}
864
Chia-I Wud7e01d72018-06-21 13:39:09 +0800865std::vector<IComposerClient::PerFrameMetadataKey> Composer::getPerFrameMetadataKeys(
866 Display display) {
867 std::vector<IComposerClient::PerFrameMetadataKey> keys;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700868 if (!mClient_2_2) {
Chia-I Wud7e01d72018-06-21 13:39:09 +0800869 return keys;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700870 }
871
872 Error error = kDefaultError;
Valerie Haue9e843a2018-12-18 13:39:23 -0800873 if (mClient_2_3) {
874 mClient_2_3->getPerFrameMetadataKeys_2_3(display,
875 [&](const auto& tmpError, const auto& tmpKeys) {
876 error = tmpError;
877 if (error != Error::NONE) {
878 ALOGW("getPerFrameMetadataKeys failed "
879 "with %d",
880 tmpError);
881 return;
882 }
883 keys = tmpKeys;
884 });
885 } else {
886 mClient_2_2
887 ->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
888 error = tmpError;
889 if (error != Error::NONE) {
890 ALOGW("getPerFrameMetadataKeys failed with %d", tmpError);
891 return;
892 }
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700893
Valerie Haue9e843a2018-12-18 13:39:23 -0800894 keys.clear();
895 for (auto key : tmpKeys) {
896 keys.push_back(static_cast<IComposerClient::PerFrameMetadataKey>(key));
897 }
898 });
899 }
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700900
Chia-I Wud7e01d72018-06-21 13:39:09 +0800901 return keys;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700902}
903
904Error Composer::getRenderIntents(Display display, ColorMode colorMode,
905 std::vector<RenderIntent>* outRenderIntents) {
906 if (!mClient_2_2) {
907 outRenderIntents->push_back(RenderIntent::COLORIMETRIC);
908 return Error::NONE;
909 }
910
911 Error error = kDefaultError;
Valerie Hau9758ae02018-10-09 16:05:09 -0700912
913 auto getRenderIntentsLambda = [&](const auto& tmpError, const auto& tmpKeys) {
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700914 error = tmpError;
915 if (error != Error::NONE) {
916 return;
917 }
918
919 *outRenderIntents = tmpKeys;
Valerie Hau9758ae02018-10-09 16:05:09 -0700920 };
921
922 if (mClient_2_3) {
923 mClient_2_3->getRenderIntents_2_3(display, colorMode, getRenderIntentsLambda);
924 } else {
925 mClient_2_2->getRenderIntents(display, static_cast<types::V1_1::ColorMode>(colorMode),
926 getRenderIntentsLambda);
927 }
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700928
929 return error;
930}
931
932Error Composer::getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix)
933{
934 if (!mClient_2_2) {
935 *outMatrix = mat4();
936 return Error::NONE;
937 }
938
939 Error error = kDefaultError;
Valerie Hau9758ae02018-10-09 16:05:09 -0700940 mClient_2_2->getDataspaceSaturationMatrix(static_cast<types::V1_1::Dataspace>(dataspace),
941 [&](const auto& tmpError, const auto& tmpMatrix) {
942 error = tmpError;
943 if (error != Error::NONE) {
944 return;
945 }
946 *outMatrix = mat4(tmpMatrix.data());
947 });
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700948
949 return error;
950}
951
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700952// Composer HAL 2.3
953
954Error Composer::getDisplayIdentificationData(Display display, uint8_t* outPort,
955 std::vector<uint8_t>* outData) {
956 if (!mClient_2_3) {
957 return Error::UNSUPPORTED;
958 }
959
960 Error error = kDefaultError;
961 mClient_2_3->getDisplayIdentificationData(display,
962 [&](const auto& tmpError, const auto& tmpPort,
963 const auto& tmpData) {
964 error = tmpError;
965 if (error != Error::NONE) {
966 return;
967 }
968
969 *outPort = tmpPort;
970 *outData = tmpData;
971 });
972
973 return error;
974}
975
Peiyong Lin698147a2018-09-14 13:27:18 -0700976Error Composer::setLayerColorTransform(Display display, Layer layer, const float* matrix)
977{
978 if (!mClient_2_3) {
979 return Error::UNSUPPORTED;
980 }
981
982 mWriter.selectDisplay(display);
983 mWriter.selectLayer(layer);
984 mWriter.setLayerColorTransform(matrix);
985 return Error::NONE;
986}
987
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700988Error Composer::getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
989 Dataspace* outDataspace,
990 uint8_t* outComponentMask) {
991 if (!outFormat || !outDataspace || !outComponentMask) {
992 return Error::BAD_PARAMETER;
993 }
994 if (!mClient_2_3) {
995 return Error::UNSUPPORTED;
996 }
997 Error error = kDefaultError;
998 mClient_2_3->getDisplayedContentSamplingAttributes(display,
999 [&](const auto tmpError,
1000 const auto& tmpFormat,
1001 const auto& tmpDataspace,
1002 const auto& tmpComponentMask) {
1003 error = tmpError;
1004 if (error == Error::NONE) {
1005 *outFormat = tmpFormat;
1006 *outDataspace = tmpDataspace;
1007 *outComponentMask =
1008 static_cast<uint8_t>(
1009 tmpComponentMask);
1010 }
1011 });
1012 return error;
1013}
1014
Kevin DuBois74e53772018-11-19 10:52:38 -08001015Error Composer::setDisplayContentSamplingEnabled(Display display, bool enabled,
1016 uint8_t componentMask, uint64_t maxFrames) {
1017 if (!mClient_2_3) {
1018 return Error::UNSUPPORTED;
1019 }
1020
1021 auto enable = enabled ? V2_3::IComposerClient::DisplayedContentSampling::ENABLE
1022 : V2_3::IComposerClient::DisplayedContentSampling::DISABLE;
1023 return mClient_2_3->setDisplayedContentSamplingEnabled(display, enable, componentMask,
1024 maxFrames);
1025}
1026
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001027Error Composer::getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
1028 DisplayedFrameStats* outStats) {
1029 if (!outStats) {
1030 return Error::BAD_PARAMETER;
1031 }
1032 if (!mClient_2_3) {
1033 return Error::UNSUPPORTED;
1034 }
1035 Error error = kDefaultError;
1036 mClient_2_3->getDisplayedContentSample(display, maxFrames, timestamp,
1037 [&](const auto tmpError, auto tmpNumFrames,
1038 const auto& tmpSamples0, const auto& tmpSamples1,
1039 const auto& tmpSamples2, const auto& tmpSamples3) {
1040 error = tmpError;
1041 if (error == Error::NONE) {
1042 outStats->numFrames = tmpNumFrames;
1043 outStats->component_0_sample = tmpSamples0;
1044 outStats->component_1_sample = tmpSamples1;
1045 outStats->component_2_sample = tmpSamples2;
1046 outStats->component_3_sample = tmpSamples3;
1047 }
1048 });
1049 return error;
1050}
1051
Valerie Haue9e843a2018-12-18 13:39:23 -08001052Error Composer::setLayerPerFrameMetadataBlobs(
1053 Display display, Layer layer,
1054 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) {
1055 if (!mClient_2_3) {
1056 return Error::UNSUPPORTED;
1057 }
1058
1059 mWriter.selectDisplay(display);
1060 mWriter.selectLayer(layer);
1061 mWriter.setLayerPerFrameMetadataBlobs(metadata);
1062 return Error::NONE;
1063}
1064
Dan Gittik57e63c52019-01-18 16:37:54 +00001065Error Composer::setDisplayBrightness(Display display, float brightness) {
1066 if (!mClient_2_3) {
1067 return Error::UNSUPPORTED;
1068 }
1069 return mClient_2_3->setDisplayBrightness(display, brightness);
1070}
1071
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001072// Composer HAL 2.4
1073
1074Error Composer::getDisplayCapabilities(Display display,
1075 std::vector<DisplayCapability>* outCapabilities) {
1076 if (!mClient_2_3) {
1077 return Error::UNSUPPORTED;
1078 }
1079
Ady Abrahamf2e339e2019-10-16 18:23:35 -07001080 V2_4::Error error = kDefaultError_2_4;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001081 if (mClient_2_4) {
1082 mClient_2_4->getDisplayCapabilities_2_4(display,
1083 [&](const auto& tmpError, const auto& tmpCaps) {
1084 error = tmpError;
Ady Abrahamf2e339e2019-10-16 18:23:35 -07001085 if (error != V2_4::Error::NONE) {
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001086 return;
1087 }
1088 *outCapabilities = tmpCaps;
1089 });
1090 } else {
1091 mClient_2_3
1092 ->getDisplayCapabilities(display, [&](const auto& tmpError, const auto& tmpCaps) {
Ady Abrahamf2e339e2019-10-16 18:23:35 -07001093 error = static_cast<V2_4::Error>(tmpError);
1094 if (error != V2_4::Error::NONE) {
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001095 return;
1096 }
1097
1098 outCapabilities->resize(tmpCaps.size());
1099 std::transform(tmpCaps.begin(), tmpCaps.end(), outCapabilities->begin(),
1100 [](auto cap) { return static_cast<DisplayCapability>(cap); });
1101 });
1102 }
1103
Ady Abrahamf2e339e2019-10-16 18:23:35 -07001104 return static_cast<Error>(error);
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001105}
1106
Ady Abraham7159f572019-10-11 11:10:18 -07001107V2_4::Error Composer::getDisplayConnectionType(Display display,
1108 IComposerClient::DisplayConnectionType* outType) {
1109 using Error = V2_4::Error;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001110 if (!mClient_2_4) {
1111 return Error::UNSUPPORTED;
1112 }
1113
Ady Abraham7159f572019-10-11 11:10:18 -07001114 Error error = kDefaultError_2_4;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001115 mClient_2_4->getDisplayConnectionType(display, [&](const auto& tmpError, const auto& tmpType) {
1116 error = tmpError;
Ady Abrahamf2e339e2019-10-16 18:23:35 -07001117 if (error != V2_4::Error::NONE) {
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001118 return;
1119 }
1120
1121 *outType = tmpType;
1122 });
1123
Ady Abraham7159f572019-10-11 11:10:18 -07001124 return error;
1125}
1126
1127V2_4::Error Composer::getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) {
1128 using Error = V2_4::Error;
1129 if (!mClient_2_4) {
1130 return Error::UNSUPPORTED;
1131 }
1132
1133 Error error = kDefaultError_2_4;
1134 mClient_2_4->getDisplayVsyncPeriod(display,
1135 [&](const auto& tmpError, const auto& tmpVsyncPeriod) {
1136 error = tmpError;
1137 if (error != Error::NONE) {
1138 return;
1139 }
1140
1141 *outVsyncPeriod = tmpVsyncPeriod;
1142 });
1143
1144 return error;
1145}
1146
1147V2_4::Error Composer::setActiveConfigWithConstraints(
1148 Display display, Config config,
1149 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
1150 VsyncPeriodChangeTimeline* outTimeline) {
1151 using Error = V2_4::Error;
1152 if (!mClient_2_4) {
1153 return Error::UNSUPPORTED;
1154 }
1155
1156 Error error = kDefaultError_2_4;
1157 mClient_2_4->setActiveConfigWithConstraints(display, config, vsyncPeriodChangeConstraints,
1158 [&](const auto& tmpError, const auto& tmpTimeline) {
1159 error = tmpError;
1160 if (error != Error::NONE) {
1161 return;
1162 }
1163
1164 *outTimeline = tmpTimeline;
1165 });
1166
1167 return error;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -07001168}
1169
Galia Peycheva5492cb52019-10-30 14:13:16 +01001170V2_4::Error Composer::setAutoLowLatencyMode(Display display, bool on) {
1171 using Error = V2_4::Error;
1172 if (!mClient_2_4) {
1173 return Error::UNSUPPORTED;
1174 }
1175
1176 return mClient_2_4->setAutoLowLatencyMode(display, on);
1177}
1178
1179V2_4::Error Composer::getSupportedContentTypes(
1180 Display displayId, std::vector<IComposerClient::ContentType>* outSupportedContentTypes) {
1181 using Error = V2_4::Error;
1182 if (!mClient_2_4) {
1183 return Error::UNSUPPORTED;
1184 }
1185
1186 Error error = kDefaultError_2_4;
1187 mClient_2_4->getSupportedContentTypes(displayId,
1188 [&](const auto& tmpError,
1189 const auto& tmpSupportedContentTypes) {
1190 error = tmpError;
1191 if (error != Error::NONE) {
1192 return;
1193 }
1194
1195 *outSupportedContentTypes = tmpSupportedContentTypes;
1196 });
1197 return error;
1198}
1199
1200V2_4::Error Composer::setContentType(Display display, IComposerClient::ContentType contentType) {
1201 using Error = V2_4::Error;
1202 if (!mClient_2_4) {
1203 return Error::UNSUPPORTED;
1204 }
1205
1206 return mClient_2_4->setContentType(display, contentType);
1207}
1208
Dan Stoza18d48cb2019-10-21 15:39:24 -07001209V2_4::Error Composer::setLayerGenericMetadata(Display display, Layer layer, const std::string& key,
1210 bool mandatory, const std::vector<uint8_t>& value) {
1211 using Error = V2_4::Error;
1212 if (!mClient_2_4) {
1213 return Error::UNSUPPORTED;
1214 }
1215 mWriter.selectDisplay(display);
1216 mWriter.selectLayer(layer);
1217 mWriter.setLayerGenericMetadata(key, mandatory, value);
1218 return Error::NONE;
1219}
1220
1221V2_4::Error Composer::getLayerGenericMetadataKeys(
1222 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) {
1223 using Error = V2_4::Error;
1224 if (!mClient_2_4) {
1225 return Error::UNSUPPORTED;
1226 }
1227 Error error = kDefaultError_2_4;
1228 mClient_2_4->getLayerGenericMetadataKeys([&](const auto& tmpError, const auto& tmpKeys) {
1229 error = tmpError;
1230 if (error != Error::NONE) {
1231 return;
1232 }
1233
1234 *outKeys = tmpKeys;
1235 });
1236 return error;
1237}
1238
Peiyong Lindfc3f7c2020-05-07 20:15:50 -07001239Error Composer::getClientTargetProperty(
1240 Display display, IComposerClient::ClientTargetProperty* outClientTargetProperty) {
1241 mReader.takeClientTargetProperty(display, outClientTargetProperty);
1242 return Error::NONE;
1243}
1244
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001245CommandReader::~CommandReader()
Chia-I Wuaab99f52016-10-05 12:59:58 +08001246{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001247 resetData();
Chia-I Wuaab99f52016-10-05 12:59:58 +08001248}
1249
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001250Error CommandReader::parse()
Chia-I Wuaab99f52016-10-05 12:59:58 +08001251{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001252 resetData();
Chia-I Wuaab99f52016-10-05 12:59:58 +08001253
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001254 IComposerClient::Command command;
1255 uint16_t length = 0;
1256
1257 while (!isEmpty()) {
Peiyong Linafa0f572020-01-13 16:35:02 -08001258 if (!beginCommand(&command, &length)) {
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001259 break;
1260 }
1261
1262 bool parsed = false;
1263 switch (command) {
1264 case IComposerClient::Command::SELECT_DISPLAY:
1265 parsed = parseSelectDisplay(length);
1266 break;
1267 case IComposerClient::Command::SET_ERROR:
1268 parsed = parseSetError(length);
1269 break;
1270 case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
1271 parsed = parseSetChangedCompositionTypes(length);
1272 break;
1273 case IComposerClient::Command::SET_DISPLAY_REQUESTS:
1274 parsed = parseSetDisplayRequests(length);
1275 break;
1276 case IComposerClient::Command::SET_PRESENT_FENCE:
1277 parsed = parseSetPresentFence(length);
1278 break;
1279 case IComposerClient::Command::SET_RELEASE_FENCES:
1280 parsed = parseSetReleaseFences(length);
1281 break;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -07001282 case IComposerClient::Command ::SET_PRESENT_OR_VALIDATE_DISPLAY_RESULT:
1283 parsed = parseSetPresentOrValidateDisplayResult(length);
1284 break;
Peiyong Linafa0f572020-01-13 16:35:02 -08001285 case IComposerClient::Command::SET_CLIENT_TARGET_PROPERTY:
1286 parsed = parseSetClientTargetProperty(length);
1287 break;
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001288 default:
1289 parsed = false;
1290 break;
1291 }
1292
1293 endCommand();
1294
1295 if (!parsed) {
1296 ALOGE("failed to parse command 0x%x length %" PRIu16,
1297 command, length);
1298 break;
1299 }
1300 }
1301
1302 return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001303}
1304
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001305bool CommandReader::parseSelectDisplay(uint16_t length)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001306{
Daniel Nicoara3c9cbd42017-01-17 12:04:06 -05001307 if (length != CommandWriterBase::kSelectDisplayLength) {
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001308 return false;
1309 }
Chia-I Wuaab99f52016-10-05 12:59:58 +08001310
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001311 mCurrentReturnData = &mReturnData[read64()];
1312
1313 return true;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001314}
1315
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001316bool CommandReader::parseSetError(uint16_t length)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001317{
Daniel Nicoara3c9cbd42017-01-17 12:04:06 -05001318 if (length != CommandWriterBase::kSetErrorLength) {
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001319 return false;
1320 }
1321
1322 auto location = read();
1323 auto error = static_cast<Error>(readSigned());
1324
1325 mErrors.emplace_back(CommandError{location, error});
1326
1327 return true;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001328}
1329
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001330bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001331{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001332 // (layer id, composition type) pairs
1333 if (length % 3 != 0 || !mCurrentReturnData) {
1334 return false;
1335 }
1336
1337 uint32_t count = length / 3;
1338 mCurrentReturnData->changedLayers.reserve(count);
1339 mCurrentReturnData->compositionTypes.reserve(count);
1340 while (count > 0) {
1341 auto layer = read64();
1342 auto type = static_cast<IComposerClient::Composition>(readSigned());
1343
1344 mCurrentReturnData->changedLayers.push_back(layer);
1345 mCurrentReturnData->compositionTypes.push_back(type);
1346
1347 count--;
1348 }
1349
1350 return true;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001351}
1352
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001353bool CommandReader::parseSetDisplayRequests(uint16_t length)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001354{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001355 // display requests followed by (layer id, layer requests) pairs
1356 if (length % 3 != 1 || !mCurrentReturnData) {
1357 return false;
1358 }
1359
1360 mCurrentReturnData->displayRequests = read();
1361
1362 uint32_t count = (length - 1) / 3;
1363 mCurrentReturnData->requestedLayers.reserve(count);
1364 mCurrentReturnData->requestMasks.reserve(count);
1365 while (count > 0) {
1366 auto layer = read64();
1367 auto layerRequestMask = read();
1368
1369 mCurrentReturnData->requestedLayers.push_back(layer);
1370 mCurrentReturnData->requestMasks.push_back(layerRequestMask);
1371
1372 count--;
1373 }
1374
1375 return true;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001376}
1377
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001378bool CommandReader::parseSetPresentFence(uint16_t length)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001379{
Daniel Nicoara3c9cbd42017-01-17 12:04:06 -05001380 if (length != CommandWriterBase::kSetPresentFenceLength ||
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001381 !mCurrentReturnData) {
1382 return false;
1383 }
1384
1385 if (mCurrentReturnData->presentFence >= 0) {
1386 close(mCurrentReturnData->presentFence);
1387 }
1388 mCurrentReturnData->presentFence = readFence();
1389
1390 return true;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001391}
1392
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001393bool CommandReader::parseSetReleaseFences(uint16_t length)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001394{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001395 // (layer id, release fence index) pairs
1396 if (length % 3 != 0 || !mCurrentReturnData) {
1397 return false;
1398 }
1399
1400 uint32_t count = length / 3;
1401 mCurrentReturnData->releasedLayers.reserve(count);
1402 mCurrentReturnData->releaseFences.reserve(count);
1403 while (count > 0) {
1404 auto layer = read64();
1405 auto fence = readFence();
1406
1407 mCurrentReturnData->releasedLayers.push_back(layer);
1408 mCurrentReturnData->releaseFences.push_back(fence);
1409
1410 count--;
1411 }
1412
1413 return true;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001414}
1415
Fabien Sanglard249c0ae2017-06-19 19:22:36 -07001416bool CommandReader::parseSetPresentOrValidateDisplayResult(uint16_t length)
1417{
1418 if (length != CommandWriterBase::kPresentOrValidateDisplayResultLength || !mCurrentReturnData) {
1419 return false;
1420 }
1421 mCurrentReturnData->presentOrValidateState = read();
1422 return true;
1423}
1424
Peiyong Linafa0f572020-01-13 16:35:02 -08001425bool CommandReader::parseSetClientTargetProperty(uint16_t length) {
1426 if (length != CommandWriterBase::kSetClientTargetPropertyLength || !mCurrentReturnData) {
1427 return false;
1428 }
1429 mCurrentReturnData->clientTargetProperty.pixelFormat = static_cast<PixelFormat>(readSigned());
1430 mCurrentReturnData->clientTargetProperty.dataspace = static_cast<Dataspace>(readSigned());
1431 return true;
1432}
1433
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001434void CommandReader::resetData()
Chia-I Wuaab99f52016-10-05 12:59:58 +08001435{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001436 mErrors.clear();
1437
1438 for (auto& data : mReturnData) {
1439 if (data.second.presentFence >= 0) {
1440 close(data.second.presentFence);
1441 }
1442 for (auto fence : data.second.releaseFences) {
1443 if (fence >= 0) {
1444 close(fence);
1445 }
1446 }
1447 }
1448
1449 mReturnData.clear();
1450 mCurrentReturnData = nullptr;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001451}
1452
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001453std::vector<CommandReader::CommandError> CommandReader::takeErrors()
Chia-I Wuaab99f52016-10-05 12:59:58 +08001454{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001455 return std::move(mErrors);
Chia-I Wuaab99f52016-10-05 12:59:58 +08001456}
1457
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001458bool CommandReader::hasChanges(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +08001459 uint32_t* outNumChangedCompositionTypes,
1460 uint32_t* outNumLayerRequestMasks) const
Chia-I Wuaab99f52016-10-05 12:59:58 +08001461{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001462 auto found = mReturnData.find(display);
1463 if (found == mReturnData.end()) {
Chia-I Wu67e376d2016-12-19 11:36:22 +08001464 *outNumChangedCompositionTypes = 0;
1465 *outNumLayerRequestMasks = 0;
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001466 return false;
1467 }
1468
1469 const ReturnData& data = found->second;
1470
Chia-I Wu67e376d2016-12-19 11:36:22 +08001471 *outNumChangedCompositionTypes = data.compositionTypes.size();
1472 *outNumLayerRequestMasks = data.requestMasks.size();
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001473
1474 return !(data.compositionTypes.empty() && data.requestMasks.empty());
Chia-I Wuaab99f52016-10-05 12:59:58 +08001475}
1476
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001477void CommandReader::takeChangedCompositionTypes(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +08001478 std::vector<Layer>* outLayers,
1479 std::vector<IComposerClient::Composition>* outTypes)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001480{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001481 auto found = mReturnData.find(display);
1482 if (found == mReturnData.end()) {
Chia-I Wu67e376d2016-12-19 11:36:22 +08001483 outLayers->clear();
1484 outTypes->clear();
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001485 return;
1486 }
1487
1488 ReturnData& data = found->second;
1489
Chia-I Wu67e376d2016-12-19 11:36:22 +08001490 *outLayers = std::move(data.changedLayers);
1491 *outTypes = std::move(data.compositionTypes);
Chia-I Wuaab99f52016-10-05 12:59:58 +08001492}
1493
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001494void CommandReader::takeDisplayRequests(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +08001495 uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
1496 std::vector<uint32_t>* outLayerRequestMasks)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001497{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001498 auto found = mReturnData.find(display);
1499 if (found == mReturnData.end()) {
Chia-I Wu67e376d2016-12-19 11:36:22 +08001500 *outDisplayRequestMask = 0;
1501 outLayers->clear();
1502 outLayerRequestMasks->clear();
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001503 return;
1504 }
Chia-I Wuaab99f52016-10-05 12:59:58 +08001505
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001506 ReturnData& data = found->second;
1507
Chia-I Wu67e376d2016-12-19 11:36:22 +08001508 *outDisplayRequestMask = data.displayRequests;
1509 *outLayers = std::move(data.requestedLayers);
1510 *outLayerRequestMasks = std::move(data.requestMasks);
Chia-I Wuaab99f52016-10-05 12:59:58 +08001511}
1512
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001513void CommandReader::takeReleaseFences(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +08001514 std::vector<Layer>* outLayers, std::vector<int>* outReleaseFences)
Chia-I Wuaab99f52016-10-05 12:59:58 +08001515{
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001516 auto found = mReturnData.find(display);
1517 if (found == mReturnData.end()) {
Chia-I Wu67e376d2016-12-19 11:36:22 +08001518 outLayers->clear();
1519 outReleaseFences->clear();
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001520 return;
1521 }
1522
1523 ReturnData& data = found->second;
1524
Chia-I Wu67e376d2016-12-19 11:36:22 +08001525 *outLayers = std::move(data.releasedLayers);
1526 *outReleaseFences = std::move(data.releaseFences);
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001527}
1528
Chia-I Wu67e376d2016-12-19 11:36:22 +08001529void CommandReader::takePresentFence(Display display, int* outPresentFence)
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001530{
1531 auto found = mReturnData.find(display);
1532 if (found == mReturnData.end()) {
Chia-I Wu67e376d2016-12-19 11:36:22 +08001533 *outPresentFence = -1;
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001534 return;
1535 }
1536
1537 ReturnData& data = found->second;
1538
Chia-I Wu67e376d2016-12-19 11:36:22 +08001539 *outPresentFence = data.presentFence;
Chia-I Wucd8d7f02016-11-16 11:02:31 +08001540 data.presentFence = -1;
Chia-I Wuaab99f52016-10-05 12:59:58 +08001541}
1542
Fabien Sanglard249c0ae2017-06-19 19:22:36 -07001543void CommandReader::takePresentOrValidateStage(Display display, uint32_t* state) {
1544 auto found = mReturnData.find(display);
1545 if (found == mReturnData.end()) {
1546 *state= -1;
1547 return;
1548 }
1549 ReturnData& data = found->second;
1550 *state = data.presentOrValidateState;
1551}
1552
Peiyong Lindfc3f7c2020-05-07 20:15:50 -07001553void CommandReader::takeClientTargetProperty(
1554 Display display, IComposerClient::ClientTargetProperty* outClientTargetProperty) {
1555 auto found = mReturnData.find(display);
1556
1557 // If not found, return the default values.
1558 if (found == mReturnData.end()) {
1559 outClientTargetProperty->pixelFormat = PixelFormat::RGBA_8888;
1560 outClientTargetProperty->dataspace = Dataspace::UNKNOWN;
Yichi Chen1d5146d2020-06-12 18:50:11 +08001561 return;
Peiyong Lindfc3f7c2020-05-07 20:15:50 -07001562 }
1563
1564 ReturnData& data = found->second;
1565 *outClientTargetProperty = data.clientTargetProperty;
1566}
1567
Lloyd Piquea822d522017-12-20 16:42:57 -08001568} // namespace impl
Chia-I Wuaab99f52016-10-05 12:59:58 +08001569} // namespace Hwc2
Chia-I Wuaab99f52016-10-05 12:59:58 +08001570} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001571
1572// TODO(b/129481165): remove the #pragma below and fix conversion issues
1573#pragma clang diagnostic pop // ignored "-Wconversion"