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