blob: ab16027d65f87481f3d5bebd0d8c1920ad1de18a [file] [log] [blame]
Ady Abraham9fc28052021-10-14 17:21:38 -07001/*
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
17// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
21#undef LOG_TAG
22#define LOG_TAG "HwcComposer"
23#define ATRACE_TAG ATRACE_TAG_GRAPHICS
24
25#include "HidlComposerHal.h"
26
27#include <android/binder_manager.h>
28#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
29#include <hidl/HidlTransportSupport.h>
30#include <hidl/HidlTransportUtils.h>
31#include <log/log.h>
32#include <utils/Trace.h>
Leon Scroggins III09c25412021-12-02 14:49:56 -050033#include "Hal.h"
Ady Abraham9fc28052021-10-14 17:21:38 -070034
35#include <algorithm>
36#include <cinttypes>
37
38namespace android {
39
40using hardware::hidl_handle;
41using hardware::hidl_vec;
42using hardware::Return;
43
44namespace Hwc2 {
45
46HidlComposer::~HidlComposer() = default;
47
48namespace {
49
50class BufferHandle {
51public:
52 explicit BufferHandle(const native_handle_t* buffer) {
53 // nullptr is not a valid handle to HIDL
54 mHandle = (buffer) ? buffer : native_handle_init(mStorage, 0, 0);
55 }
56
57 operator const hidl_handle&() const // NOLINT(google-explicit-constructor)
58 {
59 return mHandle;
60 }
61
62private:
63 NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 0, 0);
64 hidl_handle mHandle;
65};
66
67class FenceHandle {
68public:
69 FenceHandle(int fd, bool owned) : mOwned(owned) {
70 native_handle_t* handle;
71 if (fd >= 0) {
72 handle = native_handle_init(mStorage, 1, 0);
73 handle->data[0] = fd;
74 } else {
75 // nullptr is not a valid handle to HIDL
76 handle = native_handle_init(mStorage, 0, 0);
77 }
78 mHandle = handle;
79 }
80
81 ~FenceHandle() {
82 if (mOwned) {
83 native_handle_close(mHandle);
84 }
85 }
86
87 operator const hidl_handle&() const // NOLINT(google-explicit-constructor)
88 {
89 return mHandle;
90 }
91
92private:
93 bool mOwned;
94 NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 1, 0);
95 hidl_handle mHandle;
96};
97
98// assume NO_RESOURCES when Status::isOk returns false
99constexpr Error kDefaultError = Error::NO_RESOURCES;
100constexpr V2_4::Error kDefaultError_2_4 = static_cast<V2_4::Error>(kDefaultError);
101
102template <typename T, typename U>
103T unwrapRet(Return<T>& ret, const U& default_val) {
104 return (ret.isOk()) ? static_cast<T>(ret) : static_cast<T>(default_val);
105}
106
107Error unwrapRet(Return<Error>& ret) {
108 return unwrapRet(ret, kDefaultError);
109}
110
111} // anonymous namespace
112
113HidlComposer::HidlComposer(const std::string& serviceName) : mWriter(kWriterInitialSize) {
114 mComposer = V2_1::IComposer::getService(serviceName);
115
116 if (mComposer == nullptr) {
117 LOG_ALWAYS_FATAL("failed to get hwcomposer service");
118 }
119
120 if (sp<IComposer> composer_2_4 = IComposer::castFrom(mComposer)) {
121 composer_2_4->createClient_2_4([&](const auto& tmpError, const auto& tmpClient) {
122 if (tmpError == V2_4::Error::NONE) {
123 mClient = tmpClient;
124 mClient_2_2 = tmpClient;
125 mClient_2_3 = tmpClient;
126 mClient_2_4 = tmpClient;
127 }
128 });
129 } else if (sp<V2_3::IComposer> composer_2_3 = V2_3::IComposer::castFrom(mComposer)) {
130 composer_2_3->createClient_2_3([&](const auto& tmpError, const auto& tmpClient) {
131 if (tmpError == Error::NONE) {
132 mClient = tmpClient;
133 mClient_2_2 = tmpClient;
134 mClient_2_3 = tmpClient;
135 }
136 });
137 } else {
138 mComposer->createClient([&](const auto& tmpError, const auto& tmpClient) {
139 if (tmpError != Error::NONE) {
140 return;
141 }
142
143 mClient = tmpClient;
144 if (sp<V2_2::IComposer> composer_2_2 = V2_2::IComposer::castFrom(mComposer)) {
145 mClient_2_2 = V2_2::IComposerClient::castFrom(mClient);
146 LOG_ALWAYS_FATAL_IF(mClient_2_2 == nullptr,
147 "IComposer 2.2 did not return IComposerClient 2.2");
148 }
149 });
150 }
151
152 if (mClient == nullptr) {
153 LOG_ALWAYS_FATAL("failed to create composer client");
154 }
155}
156
Ady Abraham4d211cf2021-12-14 16:19:03 -0800157bool HidlComposer::isSupported(OptionalFeature feature) const {
158 switch (feature) {
159 case OptionalFeature::RefreshRateSwitching:
160 return mClient_2_4 != nullptr;
161 }
162}
163
Ady Abraham9fc28052021-10-14 17:21:38 -0700164std::vector<IComposer::Capability> HidlComposer::getCapabilities() {
165 std::vector<IComposer::Capability> capabilities;
166 mComposer->getCapabilities(
167 [&](const auto& tmpCapabilities) { capabilities = tmpCapabilities; });
168 return capabilities;
169}
170
171std::string HidlComposer::dumpDebugInfo() {
172 std::string info;
173 mComposer->dumpDebugInfo([&](const auto& tmpInfo) { info = tmpInfo.c_str(); });
174
175 return info;
176}
177
178void HidlComposer::registerCallback(const sp<IComposerCallback>& callback) {
179 android::hardware::setMinSchedulerPolicy(callback, SCHED_FIFO, 2);
180
181 auto ret = [&]() {
182 if (mClient_2_4) {
183 return mClient_2_4->registerCallback_2_4(callback);
184 }
185 return mClient->registerCallback(callback);
186 }();
187 if (!ret.isOk()) {
188 ALOGE("failed to register IComposerCallback");
189 }
190}
191
192void HidlComposer::resetCommands() {
193 mWriter.reset();
194}
195
196Error HidlComposer::executeCommands() {
197 return execute();
198}
199
200uint32_t HidlComposer::getMaxVirtualDisplayCount() {
201 auto ret = mClient->getMaxVirtualDisplayCount();
202 return unwrapRet(ret, 0);
203}
204
205Error HidlComposer::createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
206 Display* outDisplay) {
207 const uint32_t bufferSlotCount = 1;
208 Error error = kDefaultError;
209 if (mClient_2_2) {
210 mClient_2_2->createVirtualDisplay_2_2(width, height,
211 static_cast<types::V1_1::PixelFormat>(*format),
212 bufferSlotCount,
213 [&](const auto& tmpError, const auto& tmpDisplay,
214 const auto& tmpFormat) {
215 error = tmpError;
216 if (error != Error::NONE) {
217 return;
218 }
219
220 *outDisplay = tmpDisplay;
221 *format = static_cast<types::V1_2::PixelFormat>(
222 tmpFormat);
223 });
224 } else {
225 mClient->createVirtualDisplay(width, height, static_cast<types::V1_0::PixelFormat>(*format),
226 bufferSlotCount,
227 [&](const auto& tmpError, const auto& tmpDisplay,
228 const auto& tmpFormat) {
229 error = tmpError;
230 if (error != Error::NONE) {
231 return;
232 }
233
234 *outDisplay = tmpDisplay;
235 *format = static_cast<PixelFormat>(tmpFormat);
236 });
237 }
238
239 return error;
240}
241
242Error HidlComposer::destroyVirtualDisplay(Display display) {
243 auto ret = mClient->destroyVirtualDisplay(display);
244 return unwrapRet(ret);
245}
246
247Error HidlComposer::acceptDisplayChanges(Display display) {
248 mWriter.selectDisplay(display);
249 mWriter.acceptDisplayChanges();
250 return Error::NONE;
251}
252
253Error HidlComposer::createLayer(Display display, Layer* outLayer) {
254 Error error = kDefaultError;
255 mClient->createLayer(display, kMaxLayerBufferCount,
256 [&](const auto& tmpError, const auto& tmpLayer) {
257 error = tmpError;
258 if (error != Error::NONE) {
259 return;
260 }
261
262 *outLayer = tmpLayer;
263 });
264
265 return error;
266}
267
268Error HidlComposer::destroyLayer(Display display, Layer layer) {
269 auto ret = mClient->destroyLayer(display, layer);
270 return unwrapRet(ret);
271}
272
273Error HidlComposer::getActiveConfig(Display display, Config* outConfig) {
274 Error error = kDefaultError;
275 mClient->getActiveConfig(display, [&](const auto& tmpError, const auto& tmpConfig) {
276 error = tmpError;
277 if (error != Error::NONE) {
278 return;
279 }
280
281 *outConfig = tmpConfig;
282 });
283
284 return error;
285}
286
287Error HidlComposer::getChangedCompositionTypes(
288 Display display, std::vector<Layer>* outLayers,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500289 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes) {
Ady Abraham9fc28052021-10-14 17:21:38 -0700290 mReader.takeChangedCompositionTypes(display, outLayers, outTypes);
291 return Error::NONE;
292}
293
294Error HidlComposer::getColorModes(Display display, std::vector<ColorMode>* outModes) {
295 Error error = kDefaultError;
296
297 if (mClient_2_3) {
298 mClient_2_3->getColorModes_2_3(display, [&](const auto& tmpError, const auto& tmpModes) {
299 error = tmpError;
300 if (error != Error::NONE) {
301 return;
302 }
303
304 *outModes = tmpModes;
305 });
306 } else if (mClient_2_2) {
307 mClient_2_2->getColorModes_2_2(display, [&](const auto& tmpError, const auto& tmpModes) {
308 error = tmpError;
309 if (error != Error::NONE) {
310 return;
311 }
312
313 for (types::V1_1::ColorMode colorMode : tmpModes) {
314 outModes->push_back(static_cast<ColorMode>(colorMode));
315 }
316 });
317 } else {
318 mClient->getColorModes(display, [&](const auto& tmpError, const auto& tmpModes) {
319 error = tmpError;
320 if (error != Error::NONE) {
321 return;
322 }
323 for (types::V1_0::ColorMode colorMode : tmpModes) {
324 outModes->push_back(static_cast<ColorMode>(colorMode));
325 }
326 });
327 }
328
329 return error;
330}
331
332Error HidlComposer::getDisplayAttribute(Display display, Config config,
333 IComposerClient::Attribute attribute, int32_t* outValue) {
334 Error error = kDefaultError;
335 if (mClient_2_4) {
336 mClient_2_4->getDisplayAttribute_2_4(display, config, attribute,
337 [&](const auto& tmpError, const auto& tmpValue) {
338 error = static_cast<Error>(tmpError);
339 if (error != Error::NONE) {
340 return;
341 }
342
343 *outValue = tmpValue;
344 });
345 } else {
346 mClient->getDisplayAttribute(display, config,
347 static_cast<V2_1::IComposerClient::Attribute>(attribute),
348 [&](const auto& tmpError, const auto& tmpValue) {
349 error = tmpError;
350 if (error != Error::NONE) {
351 return;
352 }
353
354 *outValue = tmpValue;
355 });
356 }
357
358 return error;
359}
360
361Error HidlComposer::getDisplayConfigs(Display display, std::vector<Config>* outConfigs) {
362 Error error = kDefaultError;
363 mClient->getDisplayConfigs(display, [&](const auto& tmpError, const auto& tmpConfigs) {
364 error = tmpError;
365 if (error != Error::NONE) {
366 return;
367 }
368
369 *outConfigs = tmpConfigs;
370 });
371
372 return error;
373}
374
375Error HidlComposer::getDisplayName(Display display, std::string* outName) {
376 Error error = kDefaultError;
377 mClient->getDisplayName(display, [&](const auto& tmpError, const auto& tmpName) {
378 error = tmpError;
379 if (error != Error::NONE) {
380 return;
381 }
382
383 *outName = tmpName.c_str();
384 });
385
386 return error;
387}
388
389Error HidlComposer::getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
390 std::vector<Layer>* outLayers,
391 std::vector<uint32_t>* outLayerRequestMasks) {
392 mReader.takeDisplayRequests(display, outDisplayRequestMask, outLayers, outLayerRequestMasks);
393 return Error::NONE;
394}
395
396Error HidlComposer::getDozeSupport(Display display, bool* outSupport) {
397 Error error = kDefaultError;
398 mClient->getDozeSupport(display, [&](const auto& tmpError, const auto& tmpSupport) {
399 error = tmpError;
400 if (error != Error::NONE) {
401 return;
402 }
403
404 *outSupport = tmpSupport;
405 });
406
407 return error;
408}
409
410Error HidlComposer::getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,
411 float* outMaxLuminance, float* outMaxAverageLuminance,
412 float* outMinLuminance) {
413 Error error = kDefaultError;
414 if (mClient_2_3) {
415 mClient_2_3->getHdrCapabilities_2_3(display,
416 [&](const auto& tmpError, const auto& tmpTypes,
417 const auto& tmpMaxLuminance,
418 const auto& tmpMaxAverageLuminance,
419 const auto& tmpMinLuminance) {
420 error = tmpError;
421 if (error != Error::NONE) {
422 return;
423 }
424
425 *outTypes = tmpTypes;
426 *outMaxLuminance = tmpMaxLuminance;
427 *outMaxAverageLuminance = tmpMaxAverageLuminance;
428 *outMinLuminance = tmpMinLuminance;
429 });
430 } else {
431 mClient->getHdrCapabilities(display,
432 [&](const auto& tmpError, const auto& tmpTypes,
433 const auto& tmpMaxLuminance,
434 const auto& tmpMaxAverageLuminance,
435 const auto& tmpMinLuminance) {
436 error = tmpError;
437 if (error != Error::NONE) {
438 return;
439 }
440
441 outTypes->clear();
442 for (auto type : tmpTypes) {
443 outTypes->push_back(static_cast<Hdr>(type));
444 }
445
446 *outMaxLuminance = tmpMaxLuminance;
447 *outMaxAverageLuminance = tmpMaxAverageLuminance;
448 *outMinLuminance = tmpMinLuminance;
449 });
450 }
451
452 return error;
453}
454
455Error HidlComposer::getReleaseFences(Display display, std::vector<Layer>* outLayers,
456 std::vector<int>* outReleaseFences) {
457 mReader.takeReleaseFences(display, outLayers, outReleaseFences);
458 return Error::NONE;
459}
460
461Error HidlComposer::presentDisplay(Display display, int* outPresentFence) {
462 ATRACE_NAME("HwcPresentDisplay");
463 mWriter.selectDisplay(display);
464 mWriter.presentDisplay();
465
466 Error error = execute();
467 if (error != Error::NONE) {
468 return error;
469 }
470
471 mReader.takePresentFence(display, outPresentFence);
472
473 return Error::NONE;
474}
475
476Error HidlComposer::setActiveConfig(Display display, Config config) {
477 auto ret = mClient->setActiveConfig(display, config);
478 return unwrapRet(ret);
479}
480
481Error HidlComposer::setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
482 int acquireFence, Dataspace dataspace,
483 const std::vector<IComposerClient::Rect>& damage) {
484 mWriter.selectDisplay(display);
485
486 const native_handle_t* handle = nullptr;
487 if (target.get()) {
488 handle = target->getNativeBuffer()->handle;
489 }
490
491 mWriter.setClientTarget(slot, handle, acquireFence, dataspace, damage);
492 return Error::NONE;
493}
494
495Error HidlComposer::setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) {
496 hardware::Return<Error> ret(kDefaultError);
497 if (mClient_2_3) {
498 ret = mClient_2_3->setColorMode_2_3(display, mode, renderIntent);
499 } else if (mClient_2_2) {
500 ret = mClient_2_2->setColorMode_2_2(display, static_cast<types::V1_1::ColorMode>(mode),
501 renderIntent);
502 } else {
503 ret = mClient->setColorMode(display, static_cast<types::V1_0::ColorMode>(mode));
504 }
505 return unwrapRet(ret);
506}
507
508Error HidlComposer::setColorTransform(Display display, const float* matrix, ColorTransform hint) {
509 mWriter.selectDisplay(display);
510 mWriter.setColorTransform(matrix, hint);
511 return Error::NONE;
512}
513
514Error HidlComposer::setOutputBuffer(Display display, const native_handle_t* buffer,
515 int releaseFence) {
516 mWriter.selectDisplay(display);
517 mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
518 return Error::NONE;
519}
520
521Error HidlComposer::setPowerMode(Display display, IComposerClient::PowerMode mode) {
522 Return<Error> ret(Error::UNSUPPORTED);
523 if (mClient_2_2) {
524 ret = mClient_2_2->setPowerMode_2_2(display, mode);
525 } else if (mode != IComposerClient::PowerMode::ON_SUSPEND) {
526 ret = mClient->setPowerMode(display, static_cast<V2_1::IComposerClient::PowerMode>(mode));
527 }
528
529 return unwrapRet(ret);
530}
531
532Error HidlComposer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled) {
533 auto ret = mClient->setVsyncEnabled(display, enabled);
534 return unwrapRet(ret);
535}
536
537Error HidlComposer::setClientTargetSlotCount(Display display) {
538 const uint32_t bufferSlotCount = BufferQueue::NUM_BUFFER_SLOTS;
539 auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
540 return unwrapRet(ret);
541}
542
543Error HidlComposer::validateDisplay(Display display, uint32_t* outNumTypes,
544 uint32_t* outNumRequests) {
545 ATRACE_NAME("HwcValidateDisplay");
546 mWriter.selectDisplay(display);
547 mWriter.validateDisplay();
548
549 Error error = execute();
550 if (error != Error::NONE) {
551 return error;
552 }
553
554 mReader.hasChanges(display, outNumTypes, outNumRequests);
555
556 return Error::NONE;
557}
558
559Error HidlComposer::presentOrValidateDisplay(Display display, uint32_t* outNumTypes,
560 uint32_t* outNumRequests, int* outPresentFence,
561 uint32_t* state) {
562 ATRACE_NAME("HwcPresentOrValidateDisplay");
563 mWriter.selectDisplay(display);
564 mWriter.presentOrvalidateDisplay();
565
566 Error error = execute();
567 if (error != Error::NONE) {
568 return error;
569 }
570
571 mReader.takePresentOrValidateStage(display, state);
572
573 if (*state == 1) { // Present succeeded
574 mReader.takePresentFence(display, outPresentFence);
575 }
576
577 if (*state == 0) { // Validate succeeded.
578 mReader.hasChanges(display, outNumTypes, outNumRequests);
579 }
580
581 return Error::NONE;
582}
583
584Error HidlComposer::setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) {
585 mWriter.selectDisplay(display);
586 mWriter.selectLayer(layer);
587 mWriter.setLayerCursorPosition(x, y);
588 return Error::NONE;
589}
590
591Error HidlComposer::setLayerBuffer(Display display, Layer layer, uint32_t slot,
592 const sp<GraphicBuffer>& buffer, int acquireFence) {
593 mWriter.selectDisplay(display);
594 mWriter.selectLayer(layer);
595
596 const native_handle_t* handle = nullptr;
597 if (buffer.get()) {
598 handle = buffer->getNativeBuffer()->handle;
599 }
600
601 mWriter.setLayerBuffer(slot, handle, acquireFence);
602 return Error::NONE;
603}
604
605Error HidlComposer::setLayerSurfaceDamage(Display display, Layer layer,
606 const std::vector<IComposerClient::Rect>& damage) {
607 mWriter.selectDisplay(display);
608 mWriter.selectLayer(layer);
609 mWriter.setLayerSurfaceDamage(damage);
610 return Error::NONE;
611}
612
613Error HidlComposer::setLayerBlendMode(Display display, Layer layer,
614 IComposerClient::BlendMode mode) {
615 mWriter.selectDisplay(display);
616 mWriter.selectLayer(layer);
617 mWriter.setLayerBlendMode(mode);
618 return Error::NONE;
619}
620
621Error HidlComposer::setLayerColor(Display display, Layer layer,
622 const IComposerClient::Color& color) {
623 mWriter.selectDisplay(display);
624 mWriter.selectLayer(layer);
625 mWriter.setLayerColor(color);
626 return Error::NONE;
627}
628
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500629static IComposerClient::Composition to_hidl_type(
630 aidl::android::hardware::graphics::composer3::Composition type) {
Leon Scroggins III09c25412021-12-02 14:49:56 -0500631 LOG_ALWAYS_FATAL_IF(static_cast<int32_t>(type) >
632 static_cast<int32_t>(IComposerClient::Composition::SIDEBAND),
633 "Trying to use %s, which is not supported by HidlComposer!",
634 android::to_string(type).c_str());
635
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500636 return static_cast<IComposerClient::Composition>(type);
637}
638
639Error HidlComposer::setLayerCompositionType(
640 Display display, Layer layer,
641 aidl::android::hardware::graphics::composer3::Composition type) {
Ady Abraham9fc28052021-10-14 17:21:38 -0700642 mWriter.selectDisplay(display);
643 mWriter.selectLayer(layer);
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500644 mWriter.setLayerCompositionType(to_hidl_type(type));
Ady Abraham9fc28052021-10-14 17:21:38 -0700645 return Error::NONE;
646}
647
648Error HidlComposer::setLayerDataspace(Display display, Layer layer, Dataspace dataspace) {
649 mWriter.selectDisplay(display);
650 mWriter.selectLayer(layer);
651 mWriter.setLayerDataspace(dataspace);
652 return Error::NONE;
653}
654
655Error HidlComposer::setLayerDisplayFrame(Display display, Layer layer,
656 const IComposerClient::Rect& frame) {
657 mWriter.selectDisplay(display);
658 mWriter.selectLayer(layer);
659 mWriter.setLayerDisplayFrame(frame);
660 return Error::NONE;
661}
662
663Error HidlComposer::setLayerPlaneAlpha(Display display, Layer layer, float alpha) {
664 mWriter.selectDisplay(display);
665 mWriter.selectLayer(layer);
666 mWriter.setLayerPlaneAlpha(alpha);
667 return Error::NONE;
668}
669
670Error HidlComposer::setLayerSidebandStream(Display display, Layer layer,
671 const native_handle_t* stream) {
672 mWriter.selectDisplay(display);
673 mWriter.selectLayer(layer);
674 mWriter.setLayerSidebandStream(stream);
675 return Error::NONE;
676}
677
678Error HidlComposer::setLayerSourceCrop(Display display, Layer layer,
679 const IComposerClient::FRect& crop) {
680 mWriter.selectDisplay(display);
681 mWriter.selectLayer(layer);
682 mWriter.setLayerSourceCrop(crop);
683 return Error::NONE;
684}
685
686Error HidlComposer::setLayerTransform(Display display, Layer layer, Transform transform) {
687 mWriter.selectDisplay(display);
688 mWriter.selectLayer(layer);
689 mWriter.setLayerTransform(transform);
690 return Error::NONE;
691}
692
693Error HidlComposer::setLayerVisibleRegion(Display display, Layer layer,
694 const std::vector<IComposerClient::Rect>& visible) {
695 mWriter.selectDisplay(display);
696 mWriter.selectLayer(layer);
697 mWriter.setLayerVisibleRegion(visible);
698 return Error::NONE;
699}
700
701Error HidlComposer::setLayerZOrder(Display display, Layer layer, uint32_t z) {
702 mWriter.selectDisplay(display);
703 mWriter.selectLayer(layer);
704 mWriter.setLayerZOrder(z);
705 return Error::NONE;
706}
707
708Error HidlComposer::execute() {
709 // prepare input command queue
710 bool queueChanged = false;
711 uint32_t commandLength = 0;
712 hidl_vec<hidl_handle> commandHandles;
713 if (!mWriter.writeQueue(&queueChanged, &commandLength, &commandHandles)) {
714 mWriter.reset();
715 return Error::NO_RESOURCES;
716 }
717
718 // set up new input command queue if necessary
719 if (queueChanged) {
720 auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
721 auto error = unwrapRet(ret);
722 if (error != Error::NONE) {
723 mWriter.reset();
724 return error;
725 }
726 }
727
728 if (commandLength == 0) {
729 mWriter.reset();
730 return Error::NONE;
731 }
732
733 Error error = kDefaultError;
734 hardware::Return<void> ret;
735 auto hidl_callback = [&](const auto& tmpError, const auto& tmpOutChanged,
736 const auto& tmpOutLength, const auto& tmpOutHandles) {
737 error = tmpError;
738
739 // set up new output command queue if necessary
740 if (error == Error::NONE && tmpOutChanged) {
741 error = kDefaultError;
742 mClient->getOutputCommandQueue([&](const auto& tmpError, const auto& tmpDescriptor) {
743 error = tmpError;
744 if (error != Error::NONE) {
745 return;
746 }
747
748 mReader.setMQDescriptor(tmpDescriptor);
749 });
750 }
751
752 if (error != Error::NONE) {
753 return;
754 }
755
756 if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
757 error = mReader.parse();
758 mReader.reset();
759 } else {
760 error = Error::NO_RESOURCES;
761 }
762 };
763 if (mClient_2_2) {
764 ret = mClient_2_2->executeCommands_2_2(commandLength, commandHandles, hidl_callback);
765 } else {
766 ret = mClient->executeCommands(commandLength, commandHandles, hidl_callback);
767 }
768 // executeCommands can fail because of out-of-fd and we do not want to
769 // abort() in that case
770 if (!ret.isOk()) {
771 ALOGE("executeCommands failed because of %s", ret.description().c_str());
772 }
773
774 if (error == Error::NONE) {
775 std::vector<CommandReader::CommandError> commandErrors = mReader.takeErrors();
776
777 for (const auto& cmdErr : commandErrors) {
778 auto command =
779 static_cast<IComposerClient::Command>(mWriter.getCommand(cmdErr.location));
780
781 if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
782 command == IComposerClient::Command::PRESENT_DISPLAY ||
783 command == IComposerClient::Command::PRESENT_OR_VALIDATE_DISPLAY) {
784 error = cmdErr.error;
785 } else {
786 ALOGW("command 0x%x generated error %d", command, cmdErr.error);
787 }
788 }
789 }
790
791 mWriter.reset();
792
793 return error;
794}
795
796// Composer HAL 2.2
797
798Error HidlComposer::setLayerPerFrameMetadata(
799 Display display, Layer layer,
800 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) {
801 if (!mClient_2_2) {
802 return Error::UNSUPPORTED;
803 }
804
805 mWriter.selectDisplay(display);
806 mWriter.selectLayer(layer);
807 mWriter.setLayerPerFrameMetadata(perFrameMetadatas);
808 return Error::NONE;
809}
810
811std::vector<IComposerClient::PerFrameMetadataKey> HidlComposer::getPerFrameMetadataKeys(
812 Display display) {
813 std::vector<IComposerClient::PerFrameMetadataKey> keys;
814 if (!mClient_2_2) {
815 return keys;
816 }
817
818 Error error = kDefaultError;
819 if (mClient_2_3) {
820 mClient_2_3->getPerFrameMetadataKeys_2_3(display,
821 [&](const auto& tmpError, const auto& tmpKeys) {
822 error = tmpError;
823 if (error != Error::NONE) {
824 ALOGW("getPerFrameMetadataKeys failed "
825 "with %d",
826 tmpError);
827 return;
828 }
829 keys = tmpKeys;
830 });
831 } else {
832 mClient_2_2
833 ->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
834 error = tmpError;
835 if (error != Error::NONE) {
836 ALOGW("getPerFrameMetadataKeys failed with %d", tmpError);
837 return;
838 }
839
840 keys.clear();
841 for (auto key : tmpKeys) {
842 keys.push_back(static_cast<IComposerClient::PerFrameMetadataKey>(key));
843 }
844 });
845 }
846
847 return keys;
848}
849
850Error HidlComposer::getRenderIntents(Display display, ColorMode colorMode,
851 std::vector<RenderIntent>* outRenderIntents) {
852 if (!mClient_2_2) {
853 outRenderIntents->push_back(RenderIntent::COLORIMETRIC);
854 return Error::NONE;
855 }
856
857 Error error = kDefaultError;
858
859 auto getRenderIntentsLambda = [&](const auto& tmpError, const auto& tmpKeys) {
860 error = tmpError;
861 if (error != Error::NONE) {
862 return;
863 }
864
865 *outRenderIntents = tmpKeys;
866 };
867
868 if (mClient_2_3) {
869 mClient_2_3->getRenderIntents_2_3(display, colorMode, getRenderIntentsLambda);
870 } else {
871 mClient_2_2->getRenderIntents(display, static_cast<types::V1_1::ColorMode>(colorMode),
872 getRenderIntentsLambda);
873 }
874
875 return error;
876}
877
878Error HidlComposer::getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) {
879 if (!mClient_2_2) {
880 *outMatrix = mat4();
881 return Error::NONE;
882 }
883
884 Error error = kDefaultError;
885 mClient_2_2->getDataspaceSaturationMatrix(static_cast<types::V1_1::Dataspace>(dataspace),
886 [&](const auto& tmpError, const auto& tmpMatrix) {
887 error = tmpError;
888 if (error != Error::NONE) {
889 return;
890 }
891 *outMatrix = mat4(tmpMatrix.data());
892 });
893
894 return error;
895}
896
897// Composer HAL 2.3
898
899Error HidlComposer::getDisplayIdentificationData(Display display, uint8_t* outPort,
900 std::vector<uint8_t>* outData) {
901 if (!mClient_2_3) {
902 return Error::UNSUPPORTED;
903 }
904
905 Error error = kDefaultError;
906 mClient_2_3->getDisplayIdentificationData(display,
907 [&](const auto& tmpError, const auto& tmpPort,
908 const auto& tmpData) {
909 error = tmpError;
910 if (error != Error::NONE) {
911 return;
912 }
913
914 *outPort = tmpPort;
915 *outData = tmpData;
916 });
917
918 return error;
919}
920
921Error HidlComposer::setLayerColorTransform(Display display, Layer layer, const float* matrix) {
922 if (!mClient_2_3) {
923 return Error::UNSUPPORTED;
924 }
925
926 mWriter.selectDisplay(display);
927 mWriter.selectLayer(layer);
928 mWriter.setLayerColorTransform(matrix);
929 return Error::NONE;
930}
931
932Error HidlComposer::getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
933 Dataspace* outDataspace,
934 uint8_t* outComponentMask) {
935 if (!outFormat || !outDataspace || !outComponentMask) {
936 return Error::BAD_PARAMETER;
937 }
938 if (!mClient_2_3) {
939 return Error::UNSUPPORTED;
940 }
941 Error error = kDefaultError;
942 mClient_2_3->getDisplayedContentSamplingAttributes(display,
943 [&](const auto tmpError,
944 const auto& tmpFormat,
945 const auto& tmpDataspace,
946 const auto& tmpComponentMask) {
947 error = tmpError;
948 if (error == Error::NONE) {
949 *outFormat = tmpFormat;
950 *outDataspace = tmpDataspace;
951 *outComponentMask =
952 static_cast<uint8_t>(
953 tmpComponentMask);
954 }
955 });
956 return error;
957}
958
959Error HidlComposer::setDisplayContentSamplingEnabled(Display display, bool enabled,
960 uint8_t componentMask, uint64_t maxFrames) {
961 if (!mClient_2_3) {
962 return Error::UNSUPPORTED;
963 }
964
965 auto enable = enabled ? V2_3::IComposerClient::DisplayedContentSampling::ENABLE
966 : V2_3::IComposerClient::DisplayedContentSampling::DISABLE;
967 return mClient_2_3->setDisplayedContentSamplingEnabled(display, enable, componentMask,
968 maxFrames);
969}
970
971Error HidlComposer::getDisplayedContentSample(Display display, uint64_t maxFrames,
972 uint64_t timestamp, DisplayedFrameStats* outStats) {
973 if (!outStats) {
974 return Error::BAD_PARAMETER;
975 }
976 if (!mClient_2_3) {
977 return Error::UNSUPPORTED;
978 }
979 Error error = kDefaultError;
980 mClient_2_3->getDisplayedContentSample(display, maxFrames, timestamp,
981 [&](const auto tmpError, auto tmpNumFrames,
982 const auto& tmpSamples0, const auto& tmpSamples1,
983 const auto& tmpSamples2, const auto& tmpSamples3) {
984 error = tmpError;
985 if (error == Error::NONE) {
986 outStats->numFrames = tmpNumFrames;
987 outStats->component_0_sample = tmpSamples0;
988 outStats->component_1_sample = tmpSamples1;
989 outStats->component_2_sample = tmpSamples2;
990 outStats->component_3_sample = tmpSamples3;
991 }
992 });
993 return error;
994}
995
996Error HidlComposer::setLayerPerFrameMetadataBlobs(
997 Display display, Layer layer,
998 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) {
999 if (!mClient_2_3) {
1000 return Error::UNSUPPORTED;
1001 }
1002
1003 mWriter.selectDisplay(display);
1004 mWriter.selectLayer(layer);
1005 mWriter.setLayerPerFrameMetadataBlobs(metadata);
1006 return Error::NONE;
1007}
1008
1009Error HidlComposer::setDisplayBrightness(Display display, float brightness) {
1010 if (!mClient_2_3) {
1011 return Error::UNSUPPORTED;
1012 }
1013 return mClient_2_3->setDisplayBrightness(display, brightness);
1014}
1015
1016// Composer HAL 2.4
1017
1018Error HidlComposer::getDisplayCapabilities(Display display,
1019 std::vector<DisplayCapability>* outCapabilities) {
1020 if (!mClient_2_3) {
1021 return Error::UNSUPPORTED;
1022 }
1023
1024 V2_4::Error error = kDefaultError_2_4;
1025 if (mClient_2_4) {
1026 mClient_2_4->getDisplayCapabilities_2_4(display,
1027 [&](const auto& tmpError, const auto& tmpCaps) {
1028 error = tmpError;
1029 if (error != V2_4::Error::NONE) {
1030 return;
1031 }
1032 *outCapabilities = tmpCaps;
1033 });
1034 } else {
1035 mClient_2_3
1036 ->getDisplayCapabilities(display, [&](const auto& tmpError, const auto& tmpCaps) {
1037 error = static_cast<V2_4::Error>(tmpError);
1038 if (error != V2_4::Error::NONE) {
1039 return;
1040 }
1041
1042 outCapabilities->resize(tmpCaps.size());
1043 std::transform(tmpCaps.begin(), tmpCaps.end(), outCapabilities->begin(),
1044 [](auto cap) { return static_cast<DisplayCapability>(cap); });
1045 });
1046 }
1047
1048 return static_cast<Error>(error);
1049}
1050
1051V2_4::Error HidlComposer::getDisplayConnectionType(
1052 Display display, IComposerClient::DisplayConnectionType* outType) {
1053 using Error = V2_4::Error;
1054 if (!mClient_2_4) {
1055 return Error::UNSUPPORTED;
1056 }
1057
1058 Error error = kDefaultError_2_4;
1059 mClient_2_4->getDisplayConnectionType(display, [&](const auto& tmpError, const auto& tmpType) {
1060 error = tmpError;
1061 if (error != V2_4::Error::NONE) {
1062 return;
1063 }
1064
1065 *outType = tmpType;
1066 });
1067
1068 return error;
1069}
1070
1071V2_4::Error HidlComposer::getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) {
1072 using Error = V2_4::Error;
1073 if (!mClient_2_4) {
1074 return Error::UNSUPPORTED;
1075 }
1076
1077 Error error = kDefaultError_2_4;
1078 mClient_2_4->getDisplayVsyncPeriod(display,
1079 [&](const auto& tmpError, const auto& tmpVsyncPeriod) {
1080 error = tmpError;
1081 if (error != Error::NONE) {
1082 return;
1083 }
1084
1085 *outVsyncPeriod = tmpVsyncPeriod;
1086 });
1087
1088 return error;
1089}
1090
1091V2_4::Error HidlComposer::setActiveConfigWithConstraints(
1092 Display display, Config config,
1093 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
1094 VsyncPeriodChangeTimeline* outTimeline) {
1095 using Error = V2_4::Error;
1096 if (!mClient_2_4) {
1097 return Error::UNSUPPORTED;
1098 }
1099
1100 Error error = kDefaultError_2_4;
1101 mClient_2_4->setActiveConfigWithConstraints(display, config, vsyncPeriodChangeConstraints,
1102 [&](const auto& tmpError, const auto& tmpTimeline) {
1103 error = tmpError;
1104 if (error != Error::NONE) {
1105 return;
1106 }
1107
1108 *outTimeline = tmpTimeline;
1109 });
1110
1111 return error;
1112}
1113
1114V2_4::Error HidlComposer::setAutoLowLatencyMode(Display display, bool on) {
1115 using Error = V2_4::Error;
1116 if (!mClient_2_4) {
1117 return Error::UNSUPPORTED;
1118 }
1119
1120 return mClient_2_4->setAutoLowLatencyMode(display, on);
1121}
1122
1123V2_4::Error HidlComposer::getSupportedContentTypes(
1124 Display displayId, std::vector<IComposerClient::ContentType>* outSupportedContentTypes) {
1125 using Error = V2_4::Error;
1126 if (!mClient_2_4) {
1127 return Error::UNSUPPORTED;
1128 }
1129
1130 Error error = kDefaultError_2_4;
1131 mClient_2_4->getSupportedContentTypes(displayId,
1132 [&](const auto& tmpError,
1133 const auto& tmpSupportedContentTypes) {
1134 error = tmpError;
1135 if (error != Error::NONE) {
1136 return;
1137 }
1138
1139 *outSupportedContentTypes = tmpSupportedContentTypes;
1140 });
1141 return error;
1142}
1143
1144V2_4::Error HidlComposer::setContentType(Display display,
1145 IComposerClient::ContentType contentType) {
1146 using Error = V2_4::Error;
1147 if (!mClient_2_4) {
1148 return Error::UNSUPPORTED;
1149 }
1150
1151 return mClient_2_4->setContentType(display, contentType);
1152}
1153
1154V2_4::Error HidlComposer::setLayerGenericMetadata(Display display, Layer layer,
1155 const std::string& key, bool mandatory,
1156 const std::vector<uint8_t>& value) {
1157 using Error = V2_4::Error;
1158 if (!mClient_2_4) {
1159 return Error::UNSUPPORTED;
1160 }
1161 mWriter.selectDisplay(display);
1162 mWriter.selectLayer(layer);
1163 mWriter.setLayerGenericMetadata(key, mandatory, value);
1164 return Error::NONE;
1165}
1166
1167V2_4::Error HidlComposer::getLayerGenericMetadataKeys(
1168 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) {
1169 using Error = V2_4::Error;
1170 if (!mClient_2_4) {
1171 return Error::UNSUPPORTED;
1172 }
1173 Error error = kDefaultError_2_4;
1174 mClient_2_4->getLayerGenericMetadataKeys([&](const auto& tmpError, const auto& tmpKeys) {
1175 error = tmpError;
1176 if (error != Error::NONE) {
1177 return;
1178 }
1179
1180 *outKeys = tmpKeys;
1181 });
1182 return error;
1183}
1184
1185Error HidlComposer::getClientTargetProperty(
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001186 Display display, IComposerClient::ClientTargetProperty* outClientTargetProperty,
1187 float* outWhitePointNits) {
Ady Abraham9fc28052021-10-14 17:21:38 -07001188 mReader.takeClientTargetProperty(display, outClientTargetProperty);
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001189 *outWhitePointNits = -1.f;
1190 return Error::NONE;
1191}
1192
1193Error HidlComposer::setLayerWhitePointNits(Display, Layer, float) {
Ady Abraham9fc28052021-10-14 17:21:38 -07001194 return Error::NONE;
1195}
1196
1197CommandReader::~CommandReader() {
1198 resetData();
1199}
1200
1201Error CommandReader::parse() {
1202 resetData();
1203
1204 IComposerClient::Command command;
1205 uint16_t length = 0;
1206
1207 while (!isEmpty()) {
1208 if (!beginCommand(&command, &length)) {
1209 break;
1210 }
1211
1212 bool parsed = false;
1213 switch (command) {
1214 case IComposerClient::Command::SELECT_DISPLAY:
1215 parsed = parseSelectDisplay(length);
1216 break;
1217 case IComposerClient::Command::SET_ERROR:
1218 parsed = parseSetError(length);
1219 break;
1220 case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
1221 parsed = parseSetChangedCompositionTypes(length);
1222 break;
1223 case IComposerClient::Command::SET_DISPLAY_REQUESTS:
1224 parsed = parseSetDisplayRequests(length);
1225 break;
1226 case IComposerClient::Command::SET_PRESENT_FENCE:
1227 parsed = parseSetPresentFence(length);
1228 break;
1229 case IComposerClient::Command::SET_RELEASE_FENCES:
1230 parsed = parseSetReleaseFences(length);
1231 break;
1232 case IComposerClient::Command ::SET_PRESENT_OR_VALIDATE_DISPLAY_RESULT:
1233 parsed = parseSetPresentOrValidateDisplayResult(length);
1234 break;
1235 case IComposerClient::Command::SET_CLIENT_TARGET_PROPERTY:
1236 parsed = parseSetClientTargetProperty(length);
1237 break;
1238 default:
1239 parsed = false;
1240 break;
1241 }
1242
1243 endCommand();
1244
1245 if (!parsed) {
1246 ALOGE("failed to parse command 0x%x length %" PRIu16, command, length);
1247 break;
1248 }
1249 }
1250
1251 return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
1252}
1253
1254bool CommandReader::parseSelectDisplay(uint16_t length) {
1255 if (length != CommandWriterBase::kSelectDisplayLength) {
1256 return false;
1257 }
1258
1259 mCurrentReturnData = &mReturnData[read64()];
1260
1261 return true;
1262}
1263
1264bool CommandReader::parseSetError(uint16_t length) {
1265 if (length != CommandWriterBase::kSetErrorLength) {
1266 return false;
1267 }
1268
1269 auto location = read();
1270 auto error = static_cast<Error>(readSigned());
1271
1272 mErrors.emplace_back(CommandError{location, error});
1273
1274 return true;
1275}
1276
1277bool CommandReader::parseSetChangedCompositionTypes(uint16_t length) {
1278 // (layer id, composition type) pairs
1279 if (length % 3 != 0 || !mCurrentReturnData) {
1280 return false;
1281 }
1282
1283 uint32_t count = length / 3;
1284 mCurrentReturnData->changedLayers.reserve(count);
1285 mCurrentReturnData->compositionTypes.reserve(count);
1286 while (count > 0) {
1287 auto layer = read64();
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001288 auto type = static_cast<aidl::android::hardware::graphics::composer3::Composition>(
1289 readSigned());
Ady Abraham9fc28052021-10-14 17:21:38 -07001290
1291 mCurrentReturnData->changedLayers.push_back(layer);
1292 mCurrentReturnData->compositionTypes.push_back(type);
1293
1294 count--;
1295 }
1296
1297 return true;
1298}
1299
1300bool CommandReader::parseSetDisplayRequests(uint16_t length) {
1301 // display requests followed by (layer id, layer requests) pairs
1302 if (length % 3 != 1 || !mCurrentReturnData) {
1303 return false;
1304 }
1305
1306 mCurrentReturnData->displayRequests = read();
1307
1308 uint32_t count = (length - 1) / 3;
1309 mCurrentReturnData->requestedLayers.reserve(count);
1310 mCurrentReturnData->requestMasks.reserve(count);
1311 while (count > 0) {
1312 auto layer = read64();
1313 auto layerRequestMask = read();
1314
1315 mCurrentReturnData->requestedLayers.push_back(layer);
1316 mCurrentReturnData->requestMasks.push_back(layerRequestMask);
1317
1318 count--;
1319 }
1320
1321 return true;
1322}
1323
1324bool CommandReader::parseSetPresentFence(uint16_t length) {
1325 if (length != CommandWriterBase::kSetPresentFenceLength || !mCurrentReturnData) {
1326 return false;
1327 }
1328
1329 if (mCurrentReturnData->presentFence >= 0) {
1330 close(mCurrentReturnData->presentFence);
1331 }
1332 mCurrentReturnData->presentFence = readFence();
1333
1334 return true;
1335}
1336
1337bool CommandReader::parseSetReleaseFences(uint16_t length) {
1338 // (layer id, release fence index) pairs
1339 if (length % 3 != 0 || !mCurrentReturnData) {
1340 return false;
1341 }
1342
1343 uint32_t count = length / 3;
1344 mCurrentReturnData->releasedLayers.reserve(count);
1345 mCurrentReturnData->releaseFences.reserve(count);
1346 while (count > 0) {
1347 auto layer = read64();
1348 auto fence = readFence();
1349
1350 mCurrentReturnData->releasedLayers.push_back(layer);
1351 mCurrentReturnData->releaseFences.push_back(fence);
1352
1353 count--;
1354 }
1355
1356 return true;
1357}
1358
1359bool CommandReader::parseSetPresentOrValidateDisplayResult(uint16_t length) {
1360 if (length != CommandWriterBase::kPresentOrValidateDisplayResultLength || !mCurrentReturnData) {
1361 return false;
1362 }
1363 mCurrentReturnData->presentOrValidateState = read();
1364 return true;
1365}
1366
1367bool CommandReader::parseSetClientTargetProperty(uint16_t length) {
1368 if (length != CommandWriterBase::kSetClientTargetPropertyLength || !mCurrentReturnData) {
1369 return false;
1370 }
1371 mCurrentReturnData->clientTargetProperty.pixelFormat = static_cast<PixelFormat>(readSigned());
1372 mCurrentReturnData->clientTargetProperty.dataspace = static_cast<Dataspace>(readSigned());
1373 return true;
1374}
1375
1376void CommandReader::resetData() {
1377 mErrors.clear();
1378
1379 for (auto& data : mReturnData) {
1380 if (data.second.presentFence >= 0) {
1381 close(data.second.presentFence);
1382 }
1383 for (auto fence : data.second.releaseFences) {
1384 if (fence >= 0) {
1385 close(fence);
1386 }
1387 }
1388 }
1389
1390 mReturnData.clear();
1391 mCurrentReturnData = nullptr;
1392}
1393
1394std::vector<CommandReader::CommandError> CommandReader::takeErrors() {
1395 return std::move(mErrors);
1396}
1397
1398bool CommandReader::hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
1399 uint32_t* outNumLayerRequestMasks) const {
1400 auto found = mReturnData.find(display);
1401 if (found == mReturnData.end()) {
1402 *outNumChangedCompositionTypes = 0;
1403 *outNumLayerRequestMasks = 0;
1404 return false;
1405 }
1406
1407 const ReturnData& data = found->second;
1408
1409 *outNumChangedCompositionTypes = data.compositionTypes.size();
1410 *outNumLayerRequestMasks = data.requestMasks.size();
1411
1412 return !(data.compositionTypes.empty() && data.requestMasks.empty());
1413}
1414
1415void CommandReader::takeChangedCompositionTypes(
1416 Display display, std::vector<Layer>* outLayers,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001417 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes) {
Ady Abraham9fc28052021-10-14 17:21:38 -07001418 auto found = mReturnData.find(display);
1419 if (found == mReturnData.end()) {
1420 outLayers->clear();
1421 outTypes->clear();
1422 return;
1423 }
1424
1425 ReturnData& data = found->second;
1426
1427 *outLayers = std::move(data.changedLayers);
1428 *outTypes = std::move(data.compositionTypes);
1429}
1430
1431void CommandReader::takeDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
1432 std::vector<Layer>* outLayers,
1433 std::vector<uint32_t>* outLayerRequestMasks) {
1434 auto found = mReturnData.find(display);
1435 if (found == mReturnData.end()) {
1436 *outDisplayRequestMask = 0;
1437 outLayers->clear();
1438 outLayerRequestMasks->clear();
1439 return;
1440 }
1441
1442 ReturnData& data = found->second;
1443
1444 *outDisplayRequestMask = data.displayRequests;
1445 *outLayers = std::move(data.requestedLayers);
1446 *outLayerRequestMasks = std::move(data.requestMasks);
1447}
1448
1449void CommandReader::takeReleaseFences(Display display, std::vector<Layer>* outLayers,
1450 std::vector<int>* outReleaseFences) {
1451 auto found = mReturnData.find(display);
1452 if (found == mReturnData.end()) {
1453 outLayers->clear();
1454 outReleaseFences->clear();
1455 return;
1456 }
1457
1458 ReturnData& data = found->second;
1459
1460 *outLayers = std::move(data.releasedLayers);
1461 *outReleaseFences = std::move(data.releaseFences);
1462}
1463
1464void CommandReader::takePresentFence(Display display, int* outPresentFence) {
1465 auto found = mReturnData.find(display);
1466 if (found == mReturnData.end()) {
1467 *outPresentFence = -1;
1468 return;
1469 }
1470
1471 ReturnData& data = found->second;
1472
1473 *outPresentFence = data.presentFence;
1474 data.presentFence = -1;
1475}
1476
1477void CommandReader::takePresentOrValidateStage(Display display, uint32_t* state) {
1478 auto found = mReturnData.find(display);
1479 if (found == mReturnData.end()) {
1480 *state = -1;
1481 return;
1482 }
1483 ReturnData& data = found->second;
1484 *state = data.presentOrValidateState;
1485}
1486
1487void CommandReader::takeClientTargetProperty(
1488 Display display, IComposerClient::ClientTargetProperty* outClientTargetProperty) {
1489 auto found = mReturnData.find(display);
1490
1491 // If not found, return the default values.
1492 if (found == mReturnData.end()) {
1493 outClientTargetProperty->pixelFormat = PixelFormat::RGBA_8888;
1494 outClientTargetProperty->dataspace = Dataspace::UNKNOWN;
1495 return;
1496 }
1497
1498 ReturnData& data = found->second;
1499 *outClientTargetProperty = data.clientTargetProperty;
1500}
1501
1502} // namespace Hwc2
1503} // namespace android
1504
1505// TODO(b/129481165): remove the #pragma below and fix conversion issues
1506#pragma clang diagnostic pop // ignored "-Wconversion"