1 /*
2 * Copyright 2021 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 #undef LOG_TAG
18 #define LOG_TAG "HwcComposer"
19 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
20
21 #include "AidlComposerHal.h"
22
23 #include <SurfaceFlingerProperties.h>
24 #include <android-base/file.h>
25 #include <android/binder_ibinder_platform.h>
26 #include <android/binder_manager.h>
27 #include <common/FlagManager.h>
28 #include <common/trace.h>
29 #include <fmt/core.h>
30 #include <log/log.h>
31
32 #include <aidl/android/hardware/graphics/composer3/BnComposerCallback.h>
33
34 #include <algorithm>
35 #include <cinttypes>
36 #include <string>
37 #include <string_view>
38
39 #include "HWC2.h"
40
41 namespace android {
42
43 using aidl::android::hardware::graphics::composer3::BnComposerCallback;
44 using aidl::android::hardware::graphics::composer3::Capability;
45 using aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness;
46 using aidl::android::hardware::graphics::composer3::CommandResultPayload;
47 using aidl::android::hardware::graphics::composer3::Luts;
48 using aidl::android::hardware::graphics::composer3::PowerMode;
49 using aidl::android::hardware::graphics::composer3::VirtualDisplay;
50
51 using AidlColorMode = aidl::android::hardware::graphics::composer3::ColorMode;
52 using AidlContentType = aidl::android::hardware::graphics::composer3::ContentType;
53 using AidlDisplayIdentification =
54 aidl::android::hardware::graphics::composer3::DisplayIdentification;
55 using AidlDisplayContentSample = aidl::android::hardware::graphics::composer3::DisplayContentSample;
56 using AidlDisplayAttribute = aidl::android::hardware::graphics::composer3::DisplayAttribute;
57 using AidlDisplayCapability = aidl::android::hardware::graphics::composer3::DisplayCapability;
58 using AidlHdrCapabilities = aidl::android::hardware::graphics::composer3::HdrCapabilities;
59 using AidlHdrConversionCapability =
60 aidl::android::hardware::graphics::common::HdrConversionCapability;
61 using AidlHdcpLevels = aidl::android::hardware::drm::HdcpLevels;
62 using AidlHdrConversionStrategy = aidl::android::hardware::graphics::common::HdrConversionStrategy;
63 using AidlOverlayProperties = aidl::android::hardware::graphics::composer3::OverlayProperties;
64 using AidlPerFrameMetadata = aidl::android::hardware::graphics::composer3::PerFrameMetadata;
65 using AidlPerFrameMetadataKey = aidl::android::hardware::graphics::composer3::PerFrameMetadataKey;
66 using AidlPerFrameMetadataBlob = aidl::android::hardware::graphics::composer3::PerFrameMetadataBlob;
67 using AidlRenderIntent = aidl::android::hardware::graphics::composer3::RenderIntent;
68 using AidlVsyncPeriodChangeConstraints =
69 aidl::android::hardware::graphics::composer3::VsyncPeriodChangeConstraints;
70 using AidlVsyncPeriodChangeTimeline =
71 aidl::android::hardware::graphics::composer3::VsyncPeriodChangeTimeline;
72 using AidlDisplayContentSamplingAttributes =
73 aidl::android::hardware::graphics::composer3::DisplayContentSamplingAttributes;
74 using AidlFormatColorComponent = aidl::android::hardware::graphics::composer3::FormatColorComponent;
75 using AidlDisplayConnectionType =
76 aidl::android::hardware::graphics::composer3::DisplayConnectionType;
77
78 using AidlColorTransform = aidl::android::hardware::graphics::common::ColorTransform;
79 using AidlDataspace = aidl::android::hardware::graphics::common::Dataspace;
80 using AidlDisplayHotplugEvent = aidl::android::hardware::graphics::common::DisplayHotplugEvent;
81 using AidlFRect = aidl::android::hardware::graphics::common::FRect;
82 using AidlRect = aidl::android::hardware::graphics::common::Rect;
83 using AidlTransform = aidl::android::hardware::graphics::common::Transform;
84
85 namespace Hwc2 {
86
87 namespace {
88
89 template <typename To, typename From>
translate(From x)90 To translate(From x) {
91 return static_cast<To>(x);
92 }
93
94 template <typename To, typename From>
translate(const std::vector<From> & in)95 std::vector<To> translate(const std::vector<From>& in) {
96 std::vector<To> out;
97 out.reserve(in.size());
98 std::transform(in.begin(), in.end(), std::back_inserter(out),
99 [](From x) { return translate<To>(x); });
100 return out;
101 }
102
103 template <>
translate(IComposerClient::Rect x)104 AidlRect translate(IComposerClient::Rect x) {
105 return AidlRect{
106 .left = x.left,
107 .top = x.top,
108 .right = x.right,
109 .bottom = x.bottom,
110 };
111 }
112
113 template <>
translate(IComposerClient::FRect x)114 AidlFRect translate(IComposerClient::FRect x) {
115 return AidlFRect{
116 .left = x.left,
117 .top = x.top,
118 .right = x.right,
119 .bottom = x.bottom,
120 };
121 }
122
123 template <>
translate(IComposerClient::PerFrameMetadataBlob x)124 AidlPerFrameMetadataBlob translate(IComposerClient::PerFrameMetadataBlob x) {
125 AidlPerFrameMetadataBlob blob;
126 blob.key = translate<AidlPerFrameMetadataKey>(x.key),
127 std::copy(x.blob.begin(), x.blob.end(), std::inserter(blob.blob, blob.blob.end()));
128 return blob;
129 }
130
131 template <>
translate(IComposerClient::PerFrameMetadata x)132 AidlPerFrameMetadata translate(IComposerClient::PerFrameMetadata x) {
133 return AidlPerFrameMetadata{
134 .key = translate<AidlPerFrameMetadataKey>(x.key),
135 .value = x.value,
136 };
137 }
138
139 template <>
translate(AidlDisplayContentSample x)140 DisplayedFrameStats translate(AidlDisplayContentSample x) {
141 return DisplayedFrameStats{
142 .numFrames = static_cast<uint64_t>(x.frameCount),
143 .component_0_sample = translate<uint64_t>(x.sampleComponent0),
144 .component_1_sample = translate<uint64_t>(x.sampleComponent1),
145 .component_2_sample = translate<uint64_t>(x.sampleComponent2),
146 .component_3_sample = translate<uint64_t>(x.sampleComponent3),
147 };
148 }
149
150 template <>
translate(IComposerClient::VsyncPeriodChangeConstraints x)151 AidlVsyncPeriodChangeConstraints translate(IComposerClient::VsyncPeriodChangeConstraints x) {
152 return AidlVsyncPeriodChangeConstraints{
153 .desiredTimeNanos = x.desiredTimeNanos,
154 .seamlessRequired = x.seamlessRequired,
155 };
156 }
157
158 template <>
translate(AidlVsyncPeriodChangeTimeline x)159 VsyncPeriodChangeTimeline translate(AidlVsyncPeriodChangeTimeline x) {
160 return VsyncPeriodChangeTimeline{
161 .newVsyncAppliedTimeNanos = x.newVsyncAppliedTimeNanos,
162 .refreshRequired = x.refreshRequired,
163 .refreshTimeNanos = x.refreshTimeNanos,
164 };
165 }
makeMat4(std::vector<float> in)166 mat4 makeMat4(std::vector<float> in) {
167 return mat4(static_cast<const float*>(in.data()));
168 }
169
170 } // namespace
171
172 class AidlIComposerCallbackWrapper : public BnComposerCallback {
173 public:
AidlIComposerCallbackWrapper(HWC2::ComposerCallback & callback)174 AidlIComposerCallbackWrapper(HWC2::ComposerCallback& callback) : mCallback(callback) {}
175
onHotplug(int64_t in_display,bool in_connected)176 ::ndk::ScopedAStatus onHotplug(int64_t in_display, bool in_connected) override {
177 const auto event = in_connected ? AidlDisplayHotplugEvent::CONNECTED
178 : AidlDisplayHotplugEvent::DISCONNECTED;
179 mCallback.onComposerHalHotplugEvent(translate<Display>(in_display), event);
180 return ::ndk::ScopedAStatus::ok();
181 }
182
onRefresh(int64_t in_display)183 ::ndk::ScopedAStatus onRefresh(int64_t in_display) override {
184 mCallback.onComposerHalRefresh(translate<Display>(in_display));
185 return ::ndk::ScopedAStatus::ok();
186 }
187
onSeamlessPossible(int64_t in_display)188 ::ndk::ScopedAStatus onSeamlessPossible(int64_t in_display) override {
189 mCallback.onComposerHalSeamlessPossible(translate<Display>(in_display));
190 return ::ndk::ScopedAStatus::ok();
191 }
192
onVsync(int64_t in_display,int64_t in_timestamp,int32_t in_vsyncPeriodNanos)193 ::ndk::ScopedAStatus onVsync(int64_t in_display, int64_t in_timestamp,
194 int32_t in_vsyncPeriodNanos) override {
195 mCallback.onComposerHalVsync(translate<Display>(in_display), in_timestamp,
196 static_cast<uint32_t>(in_vsyncPeriodNanos));
197 return ::ndk::ScopedAStatus::ok();
198 }
199
onVsyncPeriodTimingChanged(int64_t in_display,const AidlVsyncPeriodChangeTimeline & in_updatedTimeline)200 ::ndk::ScopedAStatus onVsyncPeriodTimingChanged(
201 int64_t in_display, const AidlVsyncPeriodChangeTimeline& in_updatedTimeline) override {
202 mCallback.onComposerHalVsyncPeriodTimingChanged(translate<Display>(in_display),
203 translate<V2_4::VsyncPeriodChangeTimeline>(
204 in_updatedTimeline));
205 return ::ndk::ScopedAStatus::ok();
206 }
207
onVsyncIdle(int64_t in_display)208 ::ndk::ScopedAStatus onVsyncIdle(int64_t in_display) override {
209 mCallback.onComposerHalVsyncIdle(translate<Display>(in_display));
210 return ::ndk::ScopedAStatus::ok();
211 }
212
onRefreshRateChangedDebug(const RefreshRateChangedDebugData & refreshRateChangedDebugData)213 ::ndk::ScopedAStatus onRefreshRateChangedDebug(
214 const RefreshRateChangedDebugData& refreshRateChangedDebugData) override {
215 mCallback.onRefreshRateChangedDebug(refreshRateChangedDebugData);
216 return ::ndk::ScopedAStatus::ok();
217 }
218
onHotplugEvent(int64_t in_display,AidlDisplayHotplugEvent event)219 ::ndk::ScopedAStatus onHotplugEvent(int64_t in_display,
220 AidlDisplayHotplugEvent event) override {
221 mCallback.onComposerHalHotplugEvent(translate<Display>(in_display), event);
222 return ::ndk::ScopedAStatus::ok();
223 }
224
onHdcpLevelsChanged(int64_t in_display,const AidlHdcpLevels & levels)225 ::ndk::ScopedAStatus onHdcpLevelsChanged(int64_t in_display,
226 const AidlHdcpLevels& levels) override {
227 mCallback.onComposerHalHdcpLevelsChanged(translate<Display>(in_display), levels);
228 return ::ndk::ScopedAStatus::ok();
229 }
230
231 private:
232 HWC2::ComposerCallback& mCallback;
233 };
234
ensureFullyQualifiedName(std::string_view serviceName)235 std::string AidlComposer::ensureFullyQualifiedName(std::string_view serviceName) {
236 if (!serviceName.starts_with(AidlIComposer::descriptor)) {
237 return fmt::format("{}/{}", AidlIComposer::descriptor, serviceName);
238 } else {
239 return std::string{serviceName};
240 }
241 }
242
namesAnAidlComposerService(std::string_view serviceName)243 bool AidlComposer::namesAnAidlComposerService(std::string_view serviceName) {
244 if (!serviceName.starts_with(AidlIComposer::descriptor)) {
245 return AServiceManager_isDeclared(ensureFullyQualifiedName(serviceName).c_str());
246 }
247 return true;
248 }
249
AidlComposer(const std::string & serviceName)250 AidlComposer::AidlComposer(const std::string& serviceName) {
251 // This only waits if the service is actually declared
252 mAidlComposer = AidlIComposer::fromBinder(ndk::SpAIBinder(
253 AServiceManager_waitForService(ensureFullyQualifiedName(serviceName).c_str())));
254 if (!mAidlComposer) {
255 LOG_ALWAYS_FATAL("Failed to get AIDL composer service");
256 return;
257 }
258
259 if (!mAidlComposer->createClient(&mAidlComposerClient).isOk()) {
260 LOG_ALWAYS_FATAL("Can't create AidlComposerClient");
261 return;
262 }
263
264 addReader(translate<Display>(kSingleReaderKey));
265
266 // If unable to read interface version, then become backwards compatible.
267 const auto status = mAidlComposerClient->getInterfaceVersion(&mComposerInterfaceVersion);
268 if (!status.isOk()) {
269 ALOGE("getInterfaceVersion for AidlComposer constructor failed %s",
270 status.getDescription().c_str());
271 }
272
273 if (mComposerInterfaceVersion <= 1) {
274 if (sysprop::clear_slots_with_set_layer_buffer(false)) {
275 mClearSlotBuffer = sp<GraphicBuffer>::make(1, 1, PIXEL_FORMAT_RGBX_8888,
276 GraphicBuffer::USAGE_HW_COMPOSER |
277 GraphicBuffer::USAGE_SW_READ_OFTEN |
278 GraphicBuffer::USAGE_SW_WRITE_OFTEN,
279 "AidlComposer");
280 if (!mClearSlotBuffer || mClearSlotBuffer->initCheck() != ::android::OK) {
281 LOG_ALWAYS_FATAL("Failed to allocate a buffer for clearing layer buffer slots");
282 return;
283 }
284 }
285 }
286 if (getLayerLifecycleBatchCommand()) {
287 mEnableLayerCommandBatchingFlag =
288 FlagManager::getInstance().enable_layer_command_batching();
289 }
290 ALOGI("Loaded AIDL composer3 HAL service");
291 }
292
293 AidlComposer::~AidlComposer() = default;
294
isSupported(OptionalFeature feature) const295 bool AidlComposer::isSupported(OptionalFeature feature) const {
296 switch (feature) {
297 case OptionalFeature::RefreshRateSwitching:
298 case OptionalFeature::ExpectedPresentTime:
299 case OptionalFeature::DisplayBrightnessCommand:
300 case OptionalFeature::KernelIdleTimer:
301 case OptionalFeature::PhysicalDisplayOrientation:
302 return true;
303 }
304 }
305
isVrrSupported() const306 bool AidlComposer::isVrrSupported() const {
307 return mComposerInterfaceVersion >= 3 && FlagManager::getInstance().vrr_config();
308 }
309
getCapabilities()310 std::vector<Capability> AidlComposer::getCapabilities() {
311 std::vector<Capability> capabilities;
312 const auto status = mAidlComposer->getCapabilities(&capabilities);
313 if (!status.isOk()) {
314 ALOGE("getCapabilities failed %s", status.getDescription().c_str());
315 return {};
316 }
317 return capabilities;
318 }
319
dumpDebugInfo()320 std::string AidlComposer::dumpDebugInfo() {
321 int pipefds[2];
322 int result = pipe(pipefds);
323 if (result < 0) {
324 ALOGE("dumpDebugInfo: pipe failed: %s", strerror(errno));
325 return {};
326 }
327
328 std::string str;
329 // Use other thread to read pipe to prevent
330 // pipe is full, making HWC be blocked in writing.
331 std::thread t([&]() { base::ReadFdToString(pipefds[0], &str); });
332 const auto status = mAidlComposer->dump(pipefds[1], /*args*/ nullptr, /*numArgs*/ 0);
333 // Close the write-end of the pipe to make sure that when reading from the
334 // read-end we will get eof instead of blocking forever
335 close(pipefds[1]);
336
337 if (status != STATUS_OK) {
338 ALOGE("dumpDebugInfo: dump failed: %d", status);
339 }
340
341 t.join();
342 close(pipefds[0]);
343
344 std::string hash;
345 mAidlComposer->getInterfaceHash(&hash);
346 return std::string(mAidlComposer->descriptor) +
347 " version:" + std::to_string(mComposerInterfaceVersion) + " hash:" + hash + str;
348 }
349
registerCallback(HWC2::ComposerCallback & callback)350 void AidlComposer::registerCallback(HWC2::ComposerCallback& callback) {
351 if (mAidlComposerCallback) {
352 ALOGE("Callback already registered");
353 }
354
355 mAidlComposerCallback = ndk::SharedRefBase::make<AidlIComposerCallbackWrapper>(callback);
356
357 ndk::SpAIBinder binder = mAidlComposerCallback->asBinder();
358 if (!FlagManager::getInstance().disable_sched_fifo_composer_callback()) {
359 AIBinder_setMinSchedulerPolicy(binder.get(), SCHED_FIFO, 2);
360 }
361
362 const auto status = mAidlComposerClient->registerCallback(mAidlComposerCallback);
363 if (!status.isOk()) {
364 ALOGE("registerCallback failed %s", status.getDescription().c_str());
365 }
366 }
367
executeCommands(Display display)368 Error AidlComposer::executeCommands(Display display) {
369 mMutex.lock_shared();
370 auto error = execute(display);
371 mMutex.unlock_shared();
372 return error;
373 }
374
getMaxVirtualDisplayCount()375 uint32_t AidlComposer::getMaxVirtualDisplayCount() {
376 int32_t count = 0;
377 const auto status = mAidlComposerClient->getMaxVirtualDisplayCount(&count);
378 if (!status.isOk()) {
379 ALOGE("getMaxVirtualDisplayCount failed %s", status.getDescription().c_str());
380 return 0;
381 }
382 return static_cast<uint32_t>(count);
383 }
384
createVirtualDisplay(uint32_t width,uint32_t height,PixelFormat * format,Display * outDisplay)385 Error AidlComposer::createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
386 Display* outDisplay) {
387 using AidlPixelFormat = aidl::android::hardware::graphics::common::PixelFormat;
388 const int32_t bufferSlotCount = 1;
389 VirtualDisplay virtualDisplay;
390 const auto status =
391 mAidlComposerClient->createVirtualDisplay(static_cast<int32_t>(width),
392 static_cast<int32_t>(height),
393 static_cast<AidlPixelFormat>(*format),
394 bufferSlotCount, &virtualDisplay);
395
396 if (!status.isOk()) {
397 ALOGE("createVirtualDisplay failed %s", status.getDescription().c_str());
398 return static_cast<Error>(status.getServiceSpecificError());
399 }
400
401 *outDisplay = translate<Display>(virtualDisplay.display);
402 *format = static_cast<PixelFormat>(virtualDisplay.format);
403 addDisplay(translate<Display>(virtualDisplay.display));
404 return Error::NONE;
405 }
406
destroyVirtualDisplay(Display display)407 Error AidlComposer::destroyVirtualDisplay(Display display) {
408 const auto status = mAidlComposerClient->destroyVirtualDisplay(translate<int64_t>(display));
409 if (!status.isOk()) {
410 ALOGE("destroyVirtualDisplay failed %s", status.getDescription().c_str());
411 return static_cast<Error>(status.getServiceSpecificError());
412 }
413 removeDisplay(display);
414 return Error::NONE;
415 }
416
acceptDisplayChanges(Display display)417 Error AidlComposer::acceptDisplayChanges(Display display) {
418 Error error = Error::NONE;
419 mMutex.lock_shared();
420 if (auto writer = getWriter(display)) {
421 writer->get().acceptDisplayChanges(translate<int64_t>(display));
422 } else {
423 error = Error::BAD_DISPLAY;
424 }
425 mMutex.unlock_shared();
426 return error;
427 }
428
createLayer(Display display,Layer * outLayer)429 Error AidlComposer::createLayer(Display display, Layer* outLayer) {
430 int64_t layer;
431 Error error = Error::NONE;
432 if (!mEnableLayerCommandBatchingFlag) {
433 const auto status = mAidlComposerClient->createLayer(translate<int64_t>(display),
434 kMaxLayerBufferCount, &layer);
435 if (!status.isOk()) {
436 ALOGE("createLayer failed %s", status.getDescription().c_str());
437 return static_cast<Error>(status.getServiceSpecificError());
438 }
439 } else {
440 // generate a unique layerID. map in AidlComposer with <SF_layerID, HWC_layerID>
441 // Add this as a new displayCommand in execute command.
442 // return the SF generated layerID instead of calling HWC
443 layer = mLayerID++;
444 mMutex.lock_shared();
445 if (auto writer = getWriter(display)) {
446 writer->get().setLayerLifecycleBatchCommandType(translate<int64_t>(display),
447 translate<int64_t>(layer),
448 LayerLifecycleBatchCommandType::CREATE);
449 writer->get().setNewBufferSlotCount(translate<int64_t>(display),
450 translate<int64_t>(layer), kMaxLayerBufferCount);
451 } else {
452 error = Error::BAD_DISPLAY;
453 }
454 mMutex.unlock_shared();
455 }
456 *outLayer = translate<Layer>(layer);
457 return error;
458 }
459
destroyLayer(Display display,Layer layer)460 Error AidlComposer::destroyLayer(Display display, Layer layer) {
461 Error error = Error::NONE;
462 if (!mEnableLayerCommandBatchingFlag) {
463 const auto status = mAidlComposerClient->destroyLayer(translate<int64_t>(display),
464 translate<int64_t>(layer));
465 if (!status.isOk()) {
466 ALOGE("destroyLayer failed %s", status.getDescription().c_str());
467 return static_cast<Error>(status.getServiceSpecificError());
468 }
469 } else {
470 mMutex.lock_shared();
471 if (auto writer = getWriter(display)) {
472 writer->get()
473 .setLayerLifecycleBatchCommandType(translate<int64_t>(display),
474 translate<int64_t>(layer),
475 LayerLifecycleBatchCommandType::DESTROY);
476 } else {
477 error = Error::BAD_DISPLAY;
478 }
479 mMutex.unlock_shared();
480 }
481
482 return error;
483 }
484
getActiveConfig(Display display,Config * outConfig)485 Error AidlComposer::getActiveConfig(Display display, Config* outConfig) {
486 int32_t config;
487 const auto status = mAidlComposerClient->getActiveConfig(translate<int64_t>(display), &config);
488 if (!status.isOk()) {
489 ALOGE("getActiveConfig failed %s", status.getDescription().c_str());
490 return static_cast<Error>(status.getServiceSpecificError());
491 }
492 *outConfig = translate<Config>(config);
493 return Error::NONE;
494 }
495
getChangedCompositionTypes(Display display,std::vector<Layer> * outLayers,std::vector<aidl::android::hardware::graphics::composer3::Composition> * outTypes)496 Error AidlComposer::getChangedCompositionTypes(
497 Display display, std::vector<Layer>* outLayers,
498 std::vector<aidl::android::hardware::graphics::composer3::Composition>* outTypes) {
499 std::vector<ChangedCompositionLayer> changedLayers;
500 Error error = Error::NONE;
501 {
502 mMutex.lock_shared();
503 if (auto reader = getReader(display)) {
504 changedLayers = reader->get().takeChangedCompositionTypes(translate<int64_t>(display));
505 } else {
506 error = Error::BAD_DISPLAY;
507 }
508 mMutex.unlock_shared();
509 }
510 outLayers->reserve(changedLayers.size());
511 outTypes->reserve(changedLayers.size());
512
513 for (const auto& layer : changedLayers) {
514 outLayers->emplace_back(translate<Layer>(layer.layer));
515 outTypes->emplace_back(layer.composition);
516 }
517 return error;
518 }
519
getColorModes(Display display,std::vector<ColorMode> * outModes)520 Error AidlComposer::getColorModes(Display display, std::vector<ColorMode>* outModes) {
521 std::vector<AidlColorMode> modes;
522 const auto status = mAidlComposerClient->getColorModes(translate<int64_t>(display), &modes);
523 if (!status.isOk()) {
524 ALOGE("getColorModes failed %s", status.getDescription().c_str());
525 return static_cast<Error>(status.getServiceSpecificError());
526 }
527 *outModes = translate<ColorMode>(modes);
528 return Error::NONE;
529 }
530
getDisplayAttribute(Display display,Config config,IComposerClient::Attribute attribute,int32_t * outValue)531 Error AidlComposer::getDisplayAttribute(Display display, Config config,
532 IComposerClient::Attribute attribute, int32_t* outValue) {
533 #pragma clang diagnostic push
534 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
535 const auto status =
536 mAidlComposerClient->getDisplayAttribute(translate<int64_t>(display),
537 translate<int32_t>(config),
538 static_cast<AidlDisplayAttribute>(attribute),
539 outValue);
540 #pragma clang diagnostic pop
541
542 if (!status.isOk()) {
543 ALOGE("getDisplayAttribute failed %s", status.getDescription().c_str());
544 return static_cast<Error>(status.getServiceSpecificError());
545 }
546 return Error::NONE;
547 }
548
getDisplayConfigs(Display display,std::vector<Config> * outConfigs)549 Error AidlComposer::getDisplayConfigs(Display display, std::vector<Config>* outConfigs) {
550 std::vector<int32_t> configs;
551
552 #pragma clang diagnostic push
553 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
554 const auto status =
555 mAidlComposerClient->getDisplayConfigs(translate<int64_t>(display), &configs);
556 #pragma clang diagnostic pop
557
558 if (!status.isOk()) {
559 ALOGE("getDisplayConfigs failed %s", status.getDescription().c_str());
560 return static_cast<Error>(status.getServiceSpecificError());
561 }
562 *outConfigs = translate<Config>(configs);
563 return Error::NONE;
564 }
565
getDisplayConfigurations(Display display,int32_t maxFrameIntervalNs,std::vector<DisplayConfiguration> * outConfigs)566 Error AidlComposer::getDisplayConfigurations(Display display, int32_t maxFrameIntervalNs,
567 std::vector<DisplayConfiguration>* outConfigs) {
568 const auto status =
569 mAidlComposerClient->getDisplayConfigurations(translate<int64_t>(display),
570 maxFrameIntervalNs, outConfigs);
571 if (!status.isOk()) {
572 ALOGE("getDisplayConfigurations failed %s", status.getDescription().c_str());
573 return static_cast<Error>(status.getServiceSpecificError());
574 }
575
576 return Error::NONE;
577 }
578
getDisplayName(Display display,std::string * outName)579 Error AidlComposer::getDisplayName(Display display, std::string* outName) {
580 const auto status = mAidlComposerClient->getDisplayName(translate<int64_t>(display), outName);
581 if (!status.isOk()) {
582 ALOGE("getDisplayName failed %s", status.getDescription().c_str());
583 return static_cast<Error>(status.getServiceSpecificError());
584 }
585 return Error::NONE;
586 }
587
getDisplayRequests(Display display,uint32_t * outDisplayRequestMask,std::vector<Layer> * outLayers,std::vector<uint32_t> * outLayerRequestMasks)588 Error AidlComposer::getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
589 std::vector<Layer>* outLayers,
590 std::vector<uint32_t>* outLayerRequestMasks) {
591 Error error = Error::NONE;
592 DisplayRequest displayRequests;
593 {
594 mMutex.lock_shared();
595 if (auto reader = getReader(display)) {
596 displayRequests = reader->get().takeDisplayRequests(translate<int64_t>(display));
597 } else {
598 error = Error::BAD_DISPLAY;
599 }
600 mMutex.unlock_shared();
601 }
602 *outDisplayRequestMask = translate<uint32_t>(displayRequests.mask);
603 outLayers->reserve(displayRequests.layerRequests.size());
604 outLayerRequestMasks->reserve(displayRequests.layerRequests.size());
605
606 for (const auto& layer : displayRequests.layerRequests) {
607 outLayers->emplace_back(translate<Layer>(layer.layer));
608 outLayerRequestMasks->emplace_back(translate<uint32_t>(layer.mask));
609 }
610 return error;
611 }
612
getDozeSupport(Display display,bool * outSupport)613 Error AidlComposer::getDozeSupport(Display display, bool* outSupport) {
614 std::vector<AidlDisplayCapability> capabilities;
615 const auto status =
616 mAidlComposerClient->getDisplayCapabilities(translate<int64_t>(display), &capabilities);
617 if (!status.isOk()) {
618 ALOGE("getDisplayCapabilities failed %s", status.getDescription().c_str());
619 return static_cast<Error>(status.getServiceSpecificError());
620 }
621 *outSupport = std::find(capabilities.begin(), capabilities.end(),
622 AidlDisplayCapability::DOZE) != capabilities.end();
623 return Error::NONE;
624 }
625
hasDisplayIdleTimerCapability(Display display,bool * outSupport)626 Error AidlComposer::hasDisplayIdleTimerCapability(Display display, bool* outSupport) {
627 std::vector<AidlDisplayCapability> capabilities;
628 const auto status =
629 mAidlComposerClient->getDisplayCapabilities(translate<int64_t>(display), &capabilities);
630 if (!status.isOk()) {
631 ALOGE("getDisplayCapabilities failed %s", status.getDescription().c_str());
632 return static_cast<Error>(status.getServiceSpecificError());
633 }
634 *outSupport = std::find(capabilities.begin(), capabilities.end(),
635 AidlDisplayCapability::DISPLAY_IDLE_TIMER) != capabilities.end();
636 return Error::NONE;
637 }
638
getHdrCapabilities(Display display,std::vector<Hdr> * outTypes,float * outMaxLuminance,float * outMaxAverageLuminance,float * outMinLuminance)639 Error AidlComposer::getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,
640 float* outMaxLuminance, float* outMaxAverageLuminance,
641 float* outMinLuminance) {
642 AidlHdrCapabilities capabilities;
643 const auto status =
644 mAidlComposerClient->getHdrCapabilities(translate<int64_t>(display), &capabilities);
645 if (!status.isOk()) {
646 ALOGE("getHdrCapabilities failed %s", status.getDescription().c_str());
647 return static_cast<Error>(status.getServiceSpecificError());
648 }
649
650 *outTypes = capabilities.types;
651 *outMaxLuminance = capabilities.maxLuminance;
652 *outMaxAverageLuminance = capabilities.maxAverageLuminance;
653 *outMinLuminance = capabilities.minLuminance;
654 return Error::NONE;
655 }
656
getLayerLifecycleBatchCommand()657 bool AidlComposer::getLayerLifecycleBatchCommand() {
658 std::vector<Capability> capabilities = getCapabilities();
659 bool hasCapability = std::find(capabilities.begin(), capabilities.end(),
660 Capability::LAYER_LIFECYCLE_BATCH_COMMAND) != capabilities.end();
661 return hasCapability;
662 }
663
getOverlaySupport(AidlOverlayProperties * outProperties)664 Error AidlComposer::getOverlaySupport(AidlOverlayProperties* outProperties) {
665 const auto status = mAidlComposerClient->getOverlaySupport(outProperties);
666 if (!status.isOk()) {
667 ALOGE("getOverlaySupport failed %s", status.getDescription().c_str());
668 return static_cast<Error>(status.getServiceSpecificError());
669 }
670 return Error::NONE;
671 }
672
getReleaseFences(Display display,std::vector<Layer> * outLayers,std::vector<int> * outReleaseFences)673 Error AidlComposer::getReleaseFences(Display display, std::vector<Layer>* outLayers,
674 std::vector<int>* outReleaseFences) {
675 Error error = Error::NONE;
676 std::vector<ReleaseFences::Layer> fences;
677 {
678 mMutex.lock_shared();
679 if (auto reader = getReader(display)) {
680 fences = reader->get().takeReleaseFences(translate<int64_t>(display));
681 } else {
682 error = Error::BAD_DISPLAY;
683 }
684 mMutex.unlock_shared();
685 }
686 outLayers->reserve(fences.size());
687 outReleaseFences->reserve(fences.size());
688
689 for (auto& fence : fences) {
690 outLayers->emplace_back(translate<Layer>(fence.layer));
691 // take ownership
692 const int fenceOwner = fence.fence.get();
693 *fence.fence.getR() = -1;
694 outReleaseFences->emplace_back(fenceOwner);
695 }
696 return error;
697 }
698
getLayerPresentFences(Display display,std::vector<Layer> * outLayers,std::vector<int> * outFences,std::vector<int64_t> * outLatenciesNanos)699 Error AidlComposer::getLayerPresentFences(Display display, std::vector<Layer>* outLayers,
700 std::vector<int>* outFences,
701 std::vector<int64_t>* outLatenciesNanos) {
702 Error error = Error::NONE;
703 std::vector<PresentFence::LayerPresentFence> fences;
704 {
705 mMutex.lock_shared();
706 if (auto reader = getReader(display)) {
707 fences = reader->get().takeLayerPresentFences(translate<int64_t>(display));
708 } else {
709 error = Error::BAD_DISPLAY;
710 }
711 mMutex.unlock_shared();
712 }
713
714 outLayers->reserve(fences.size());
715 outFences->reserve(fences.size());
716 outLatenciesNanos->reserve(fences.size());
717
718 for (auto& fence : fences) {
719 outLayers->emplace_back(translate<Layer>(fence.layer));
720 // take ownership
721 const int fenceOwner = fence.bufferFence.get();
722 *fence.bufferFence.getR() = -1;
723 outFences->emplace_back(fenceOwner);
724 outLatenciesNanos->emplace_back(fence.bufferLatencyNanos);
725 }
726 return error;
727 }
728
presentDisplay(Display display,int * outPresentFence)729 Error AidlComposer::presentDisplay(Display display, int* outPresentFence) {
730 const auto displayId = translate<int64_t>(display);
731 SFTRACE_FORMAT("HwcPresentDisplay %" PRId64, displayId);
732
733 Error error = Error::NONE;
734 mMutex.lock_shared();
735 auto writer = getWriter(display);
736 auto reader = getReader(display);
737 if (writer && reader) {
738 writer->get().presentDisplay(displayId);
739 error = execute(display);
740 } else {
741 error = Error::BAD_DISPLAY;
742 }
743
744 if (error != Error::NONE) {
745 mMutex.unlock_shared();
746 return error;
747 }
748
749 auto fence = reader->get().takePresentFence(displayId);
750 mMutex.unlock_shared();
751 // take ownership
752 *outPresentFence = fence.get();
753 *fence.getR() = -1;
754 return Error::NONE;
755 }
756
setActiveConfig(Display display,Config config)757 Error AidlComposer::setActiveConfig(Display display, Config config) {
758 const auto status = mAidlComposerClient->setActiveConfig(translate<int64_t>(display),
759 translate<int32_t>(config));
760 if (!status.isOk()) {
761 ALOGE("setActiveConfig failed %s", status.getDescription().c_str());
762 return static_cast<Error>(status.getServiceSpecificError());
763 }
764 return Error::NONE;
765 }
766
setClientTarget(Display display,uint32_t slot,const sp<GraphicBuffer> & target,int acquireFence,Dataspace dataspace,const std::vector<IComposerClient::Rect> & damage,float hdrSdrRatio)767 Error AidlComposer::setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
768 int acquireFence, Dataspace dataspace,
769 const std::vector<IComposerClient::Rect>& damage,
770 float hdrSdrRatio) {
771 const native_handle_t* handle = nullptr;
772 if (target.get()) {
773 handle = target->getNativeBuffer()->handle;
774 }
775
776 Error error = Error::NONE;
777 mMutex.lock_shared();
778 if (auto writer = getWriter(display)) {
779 writer->get()
780 .setClientTarget(translate<int64_t>(display), slot, handle, acquireFence,
781 translate<aidl::android::hardware::graphics::common::Dataspace>(
782 dataspace),
783 translate<AidlRect>(damage), hdrSdrRatio);
784 } else {
785 error = Error::BAD_DISPLAY;
786 }
787 mMutex.unlock_shared();
788 return error;
789 }
790
setColorMode(Display display,ColorMode mode,RenderIntent renderIntent)791 Error AidlComposer::setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) {
792 const auto status =
793 mAidlComposerClient->setColorMode(translate<int64_t>(display),
794 translate<AidlColorMode>(mode),
795 translate<AidlRenderIntent>(renderIntent));
796 if (!status.isOk()) {
797 ALOGE("setColorMode failed %s", status.getDescription().c_str());
798 return static_cast<Error>(status.getServiceSpecificError());
799 }
800 return Error::NONE;
801 }
802
setColorTransform(Display display,const float * matrix)803 Error AidlComposer::setColorTransform(Display display, const float* matrix) {
804 auto error = Error::NONE;
805 mMutex.lock_shared();
806 if (auto writer = getWriter(display)) {
807 writer->get().setColorTransform(translate<int64_t>(display), matrix);
808 } else {
809 error = Error::BAD_DISPLAY;
810 }
811 mMutex.unlock_shared();
812 return error;
813 }
814
setOutputBuffer(Display display,const native_handle_t * buffer,int releaseFence)815 Error AidlComposer::setOutputBuffer(Display display, const native_handle_t* buffer,
816 int releaseFence) {
817 auto error = Error::NONE;
818 mMutex.lock_shared();
819 if (auto writer = getWriter(display)) {
820 writer->get().setOutputBuffer(translate<int64_t>(display), 0, buffer, dup(releaseFence));
821 } else {
822 error = Error::BAD_DISPLAY;
823 }
824 mMutex.unlock_shared();
825 return error;
826 }
827
setPowerMode(Display display,IComposerClient::PowerMode mode)828 Error AidlComposer::setPowerMode(Display display, IComposerClient::PowerMode mode) {
829 const auto status = mAidlComposerClient->setPowerMode(translate<int64_t>(display),
830 translate<PowerMode>(mode));
831 if (!status.isOk()) {
832 ALOGE("setPowerMode failed %s", status.getDescription().c_str());
833 return static_cast<Error>(status.getServiceSpecificError());
834 }
835 return Error::NONE;
836 }
837
setVsyncEnabled(Display display,IComposerClient::Vsync enabled)838 Error AidlComposer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled) {
839 const bool enableVsync = enabled == IComposerClient::Vsync::ENABLE;
840 const auto status =
841 mAidlComposerClient->setVsyncEnabled(translate<int64_t>(display), enableVsync);
842 if (!status.isOk()) {
843 ALOGE("setVsyncEnabled failed %s", status.getDescription().c_str());
844 return static_cast<Error>(status.getServiceSpecificError());
845 }
846 return Error::NONE;
847 }
848
setClientTargetSlotCount(Display display)849 Error AidlComposer::setClientTargetSlotCount(Display display) {
850 const int32_t bufferSlotCount = BufferQueue::NUM_BUFFER_SLOTS;
851 const auto status = mAidlComposerClient->setClientTargetSlotCount(translate<int64_t>(display),
852 bufferSlotCount);
853 if (!status.isOk()) {
854 ALOGE("setClientTargetSlotCount failed %s", status.getDescription().c_str());
855 return static_cast<Error>(status.getServiceSpecificError());
856 }
857 return Error::NONE;
858 }
859
validateDisplay(Display display,nsecs_t expectedPresentTime,int32_t frameIntervalNs,uint32_t * outNumTypes,uint32_t * outNumRequests)860 Error AidlComposer::validateDisplay(Display display, nsecs_t expectedPresentTime,
861 int32_t frameIntervalNs, uint32_t* outNumTypes,
862 uint32_t* outNumRequests) {
863 const auto displayId = translate<int64_t>(display);
864 SFTRACE_FORMAT("HwcValidateDisplay %" PRId64, displayId);
865
866 Error error = Error::NONE;
867 mMutex.lock_shared();
868 auto writer = getWriter(display);
869 auto reader = getReader(display);
870 if (writer && reader) {
871 writer->get().validateDisplay(displayId, ClockMonotonicTimestamp{expectedPresentTime},
872 frameIntervalNs);
873 error = execute(display);
874 } else {
875 error = Error::BAD_DISPLAY;
876 }
877
878 if (error != Error::NONE) {
879 mMutex.unlock_shared();
880 return error;
881 }
882
883 reader->get().hasChanges(displayId, outNumTypes, outNumRequests);
884
885 mMutex.unlock_shared();
886 return Error::NONE;
887 }
888
presentOrValidateDisplay(Display display,nsecs_t expectedPresentTime,int32_t frameIntervalNs,uint32_t * outNumTypes,uint32_t * outNumRequests,int * outPresentFence,uint32_t * state)889 Error AidlComposer::presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime,
890 int32_t frameIntervalNs, uint32_t* outNumTypes,
891 uint32_t* outNumRequests, int* outPresentFence,
892 uint32_t* state) {
893 const auto displayId = translate<int64_t>(display);
894 SFTRACE_FORMAT("HwcPresentOrValidateDisplay %" PRId64, displayId);
895
896 Error error = Error::NONE;
897 mMutex.lock_shared();
898 auto writer = getWriter(display);
899 auto reader = getReader(display);
900 if (writer && reader) {
901 writer->get().presentOrvalidateDisplay(displayId,
902 ClockMonotonicTimestamp{expectedPresentTime},
903 frameIntervalNs);
904 error = execute(display);
905 } else {
906 error = Error::BAD_DISPLAY;
907 }
908
909 if (error != Error::NONE) {
910 mMutex.unlock_shared();
911 return error;
912 }
913
914 const auto result = reader->get().takePresentOrValidateStage(displayId);
915 if (!result.has_value()) {
916 *state = translate<uint32_t>(-1);
917 mMutex.unlock_shared();
918 return Error::NO_RESOURCES;
919 }
920
921 *state = translate<uint32_t>(*result);
922
923 if (*result == PresentOrValidate::Result::Presented) {
924 auto fence = reader->get().takePresentFence(displayId);
925 // take ownership
926 *outPresentFence = fence.get();
927 *fence.getR() = -1;
928 }
929
930 if (*result == PresentOrValidate::Result::Validated) {
931 reader->get().hasChanges(displayId, outNumTypes, outNumRequests);
932 }
933
934 mMutex.unlock_shared();
935 return Error::NONE;
936 }
937
setCursorPosition(Display display,Layer layer,int32_t x,int32_t y)938 Error AidlComposer::setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) {
939 Error error = Error::NONE;
940 mMutex.lock_shared();
941 if (auto writer = getWriter(display)) {
942 writer->get().setLayerCursorPosition(translate<int64_t>(display), translate<int64_t>(layer),
943 x, y);
944 } else {
945 error = Error::BAD_DISPLAY;
946 }
947 mMutex.unlock_shared();
948 return error;
949 }
950
setLayerBuffer(Display display,Layer layer,uint32_t slot,const sp<GraphicBuffer> & buffer,int acquireFence)951 Error AidlComposer::setLayerBuffer(Display display, Layer layer, uint32_t slot,
952 const sp<GraphicBuffer>& buffer, int acquireFence) {
953 const native_handle_t* handle = nullptr;
954 if (buffer.get()) {
955 handle = buffer->getNativeBuffer()->handle;
956 }
957
958 Error error = Error::NONE;
959 mMutex.lock_shared();
960 if (auto writer = getWriter(display)) {
961 writer->get().setLayerBuffer(translate<int64_t>(display), translate<int64_t>(layer), slot,
962 handle, acquireFence);
963 } else {
964 error = Error::BAD_DISPLAY;
965 }
966 mMutex.unlock_shared();
967 return error;
968 }
969
setLayerBufferSlotsToClear(Display display,Layer layer,const std::vector<uint32_t> & slotsToClear,uint32_t activeBufferSlot)970 Error AidlComposer::setLayerBufferSlotsToClear(Display display, Layer layer,
971 const std::vector<uint32_t>& slotsToClear,
972 uint32_t activeBufferSlot) {
973 if (slotsToClear.empty()) {
974 return Error::NONE;
975 }
976
977 Error error = Error::NONE;
978 mMutex.lock_shared();
979 if (auto writer = getWriter(display)) {
980 if (mComposerInterfaceVersion > 1) {
981 writer->get().setLayerBufferSlotsToClear(translate<int64_t>(display),
982 translate<int64_t>(layer), slotsToClear);
983 // Backwards compatible way of clearing buffer slots is to set the layer buffer with a
984 // placeholder buffer, using the slot that needs to cleared... tricky.
985 } else if (mClearSlotBuffer != nullptr) {
986 for (uint32_t slot : slotsToClear) {
987 // Don't clear the active buffer slot because we need to restore the active buffer
988 // after clearing the requested buffer slots with a placeholder buffer.
989 if (slot != activeBufferSlot) {
990 writer->get().setLayerBufferWithNewCommand(translate<int64_t>(display),
991 translate<int64_t>(layer), slot,
992 mClearSlotBuffer->handle,
993 /*fence*/ -1);
994 }
995 }
996 // Since we clear buffers by setting them to a placeholder buffer, we want to make
997 // sure that the last setLayerBuffer command is sent with the currently active
998 // buffer, not the placeholder buffer, so that there is no perceptual change when
999 // buffers are discarded.
1000 writer->get().setLayerBufferWithNewCommand(translate<int64_t>(display),
1001 translate<int64_t>(layer), activeBufferSlot,
1002 // The active buffer is still cached in
1003 // its slot and doesn't need a fence.
1004 /*buffer*/ nullptr, /*fence*/ -1);
1005 }
1006 } else {
1007 error = Error::BAD_DISPLAY;
1008 }
1009 mMutex.unlock_shared();
1010 return error;
1011 }
1012
setLayerSurfaceDamage(Display display,Layer layer,const std::vector<IComposerClient::Rect> & damage)1013 Error AidlComposer::setLayerSurfaceDamage(Display display, Layer layer,
1014 const std::vector<IComposerClient::Rect>& damage) {
1015 Error error = Error::NONE;
1016 mMutex.lock_shared();
1017 if (auto writer = getWriter(display)) {
1018 writer->get().setLayerSurfaceDamage(translate<int64_t>(display), translate<int64_t>(layer),
1019 translate<AidlRect>(damage));
1020 } else {
1021 error = Error::BAD_DISPLAY;
1022 }
1023 mMutex.unlock_shared();
1024 return error;
1025 }
1026
setLayerBlendMode(Display display,Layer layer,IComposerClient::BlendMode mode)1027 Error AidlComposer::setLayerBlendMode(Display display, Layer layer,
1028 IComposerClient::BlendMode mode) {
1029 Error error = Error::NONE;
1030 mMutex.lock_shared();
1031 if (auto writer = getWriter(display)) {
1032 writer->get().setLayerBlendMode(translate<int64_t>(display), translate<int64_t>(layer),
1033 translate<BlendMode>(mode));
1034 } else {
1035 error = Error::BAD_DISPLAY;
1036 }
1037 mMutex.unlock_shared();
1038 return error;
1039 }
1040
setLayerColor(Display display,Layer layer,const Color & color)1041 Error AidlComposer::setLayerColor(Display display, Layer layer, const Color& color) {
1042 Error error = Error::NONE;
1043 mMutex.lock_shared();
1044 if (auto writer = getWriter(display)) {
1045 writer->get().setLayerColor(translate<int64_t>(display), translate<int64_t>(layer), color);
1046 } else {
1047 error = Error::BAD_DISPLAY;
1048 }
1049 mMutex.unlock_shared();
1050 return error;
1051 }
1052
setLayerCompositionType(Display display,Layer layer,aidl::android::hardware::graphics::composer3::Composition type)1053 Error AidlComposer::setLayerCompositionType(
1054 Display display, Layer layer,
1055 aidl::android::hardware::graphics::composer3::Composition type) {
1056 Error error = Error::NONE;
1057 mMutex.lock_shared();
1058 if (auto writer = getWriter(display)) {
1059 writer->get().setLayerCompositionType(translate<int64_t>(display),
1060 translate<int64_t>(layer), type);
1061 } else {
1062 error = Error::BAD_DISPLAY;
1063 }
1064 mMutex.unlock_shared();
1065 return error;
1066 }
1067
setLayerDataspace(Display display,Layer layer,Dataspace dataspace)1068 Error AidlComposer::setLayerDataspace(Display display, Layer layer, Dataspace dataspace) {
1069 Error error = Error::NONE;
1070 mMutex.lock_shared();
1071 if (auto writer = getWriter(display)) {
1072 writer->get().setLayerDataspace(translate<int64_t>(display), translate<int64_t>(layer),
1073 translate<AidlDataspace>(dataspace));
1074 } else {
1075 error = Error::BAD_DISPLAY;
1076 }
1077 mMutex.unlock_shared();
1078 return error;
1079 }
1080
setLayerDisplayFrame(Display display,Layer layer,const IComposerClient::Rect & frame)1081 Error AidlComposer::setLayerDisplayFrame(Display display, Layer layer,
1082 const IComposerClient::Rect& frame) {
1083 Error error = Error::NONE;
1084 mMutex.lock_shared();
1085 if (auto writer = getWriter(display)) {
1086 writer->get().setLayerDisplayFrame(translate<int64_t>(display), translate<int64_t>(layer),
1087 translate<AidlRect>(frame));
1088 } else {
1089 error = Error::BAD_DISPLAY;
1090 }
1091 mMutex.unlock_shared();
1092 return error;
1093 }
1094
setLayerPlaneAlpha(Display display,Layer layer,float alpha)1095 Error AidlComposer::setLayerPlaneAlpha(Display display, Layer layer, float alpha) {
1096 Error error = Error::NONE;
1097 mMutex.lock_shared();
1098 if (auto writer = getWriter(display)) {
1099 writer->get().setLayerPlaneAlpha(translate<int64_t>(display), translate<int64_t>(layer),
1100 alpha);
1101 } else {
1102 error = Error::BAD_DISPLAY;
1103 }
1104 mMutex.unlock_shared();
1105 return error;
1106 }
1107
setLayerSidebandStream(Display display,Layer layer,const native_handle_t * stream)1108 Error AidlComposer::setLayerSidebandStream(Display display, Layer layer,
1109 const native_handle_t* stream) {
1110 Error error = Error::NONE;
1111 mMutex.lock_shared();
1112 if (auto writer = getWriter(display)) {
1113 writer->get().setLayerSidebandStream(translate<int64_t>(display), translate<int64_t>(layer),
1114 stream);
1115 } else {
1116 error = Error::BAD_DISPLAY;
1117 }
1118 mMutex.unlock_shared();
1119 return error;
1120 }
1121
setLayerSourceCrop(Display display,Layer layer,const IComposerClient::FRect & crop)1122 Error AidlComposer::setLayerSourceCrop(Display display, Layer layer,
1123 const IComposerClient::FRect& crop) {
1124 Error error = Error::NONE;
1125 mMutex.lock_shared();
1126 if (auto writer = getWriter(display)) {
1127 writer->get().setLayerSourceCrop(translate<int64_t>(display), translate<int64_t>(layer),
1128 translate<AidlFRect>(crop));
1129 } else {
1130 error = Error::BAD_DISPLAY;
1131 }
1132 mMutex.unlock_shared();
1133 return error;
1134 }
1135
setLayerTransform(Display display,Layer layer,Transform transform)1136 Error AidlComposer::setLayerTransform(Display display, Layer layer, Transform transform) {
1137 Error error = Error::NONE;
1138 mMutex.lock_shared();
1139 if (auto writer = getWriter(display)) {
1140 writer->get().setLayerTransform(translate<int64_t>(display), translate<int64_t>(layer),
1141 translate<AidlTransform>(transform));
1142 } else {
1143 error = Error::BAD_DISPLAY;
1144 }
1145 mMutex.unlock_shared();
1146 return error;
1147 }
1148
setLayerVisibleRegion(Display display,Layer layer,const std::vector<IComposerClient::Rect> & visible)1149 Error AidlComposer::setLayerVisibleRegion(Display display, Layer layer,
1150 const std::vector<IComposerClient::Rect>& visible) {
1151 Error error = Error::NONE;
1152 mMutex.lock_shared();
1153 if (auto writer = getWriter(display)) {
1154 writer->get().setLayerVisibleRegion(translate<int64_t>(display), translate<int64_t>(layer),
1155 translate<AidlRect>(visible));
1156 } else {
1157 error = Error::BAD_DISPLAY;
1158 }
1159 mMutex.unlock_shared();
1160 return error;
1161 }
1162
setLayerZOrder(Display display,Layer layer,uint32_t z)1163 Error AidlComposer::setLayerZOrder(Display display, Layer layer, uint32_t z) {
1164 Error error = Error::NONE;
1165 mMutex.lock_shared();
1166 if (auto writer = getWriter(display)) {
1167 writer->get().setLayerZOrder(translate<int64_t>(display), translate<int64_t>(layer), z);
1168 } else {
1169 error = Error::BAD_DISPLAY;
1170 }
1171 mMutex.unlock_shared();
1172 return error;
1173 }
1174
execute(Display display)1175 Error AidlComposer::execute(Display display) {
1176 auto writer = getWriter(display);
1177 auto reader = getReader(display);
1178 if (!writer || !reader) {
1179 return Error::BAD_DISPLAY;
1180 }
1181
1182 auto commands = writer->get().takePendingCommands();
1183 if (commands.empty()) {
1184 return Error::NONE;
1185 }
1186
1187 { // scope for results
1188 std::vector<CommandResultPayload> results;
1189 auto status = mAidlComposerClient->executeCommands(commands, &results);
1190 if (!status.isOk()) {
1191 ALOGE("executeCommands failed %s", status.getDescription().c_str());
1192 return static_cast<Error>(status.getServiceSpecificError());
1193 }
1194
1195 reader->get().parse(std::move(results));
1196 }
1197 const auto commandErrors = reader->get().takeErrors();
1198 Error error = Error::NONE;
1199 for (const auto& cmdErr : commandErrors) {
1200 const auto index = static_cast<size_t>(cmdErr.commandIndex);
1201 if (index < 0 || index >= commands.size()) {
1202 ALOGE("invalid command index %zu", index);
1203 return Error::BAD_PARAMETER;
1204 }
1205
1206 const auto& command = commands[index];
1207 if (command.validateDisplay || command.presentDisplay || command.presentOrValidateDisplay) {
1208 error = translate<Error>(cmdErr.errorCode);
1209 } else {
1210 ALOGW("command '%s' generated error %" PRId32, command.toString().c_str(),
1211 cmdErr.errorCode);
1212 }
1213 }
1214
1215 return error;
1216 }
1217
setLayerPerFrameMetadata(Display display,Layer layer,const std::vector<IComposerClient::PerFrameMetadata> & perFrameMetadatas)1218 Error AidlComposer::setLayerPerFrameMetadata(
1219 Display display, Layer layer,
1220 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) {
1221 Error error = Error::NONE;
1222 mMutex.lock_shared();
1223 if (auto writer = getWriter(display)) {
1224 writer->get().setLayerPerFrameMetadata(translate<int64_t>(display),
1225 translate<int64_t>(layer),
1226 translate<AidlPerFrameMetadata>(perFrameMetadatas));
1227 } else {
1228 error = Error::BAD_DISPLAY;
1229 }
1230 mMutex.unlock_shared();
1231 return error;
1232 }
1233
getPerFrameMetadataKeys(Display display)1234 std::vector<IComposerClient::PerFrameMetadataKey> AidlComposer::getPerFrameMetadataKeys(
1235 Display display) {
1236 std::vector<AidlPerFrameMetadataKey> keys;
1237 const auto status =
1238 mAidlComposerClient->getPerFrameMetadataKeys(translate<int64_t>(display), &keys);
1239 if (!status.isOk()) {
1240 ALOGE("getPerFrameMetadataKeys failed %s", status.getDescription().c_str());
1241 return {};
1242 }
1243 return translate<IComposerClient::PerFrameMetadataKey>(keys);
1244 }
1245
getRenderIntents(Display display,ColorMode colorMode,std::vector<RenderIntent> * outRenderIntents)1246 Error AidlComposer::getRenderIntents(Display display, ColorMode colorMode,
1247 std::vector<RenderIntent>* outRenderIntents) {
1248 std::vector<AidlRenderIntent> renderIntents;
1249 const auto status = mAidlComposerClient->getRenderIntents(translate<int64_t>(display),
1250 translate<AidlColorMode>(colorMode),
1251 &renderIntents);
1252 if (!status.isOk()) {
1253 ALOGE("getRenderIntents failed %s", status.getDescription().c_str());
1254 return static_cast<Error>(status.getServiceSpecificError());
1255 }
1256 *outRenderIntents = translate<RenderIntent>(renderIntents);
1257 return Error::NONE;
1258 }
1259
getDataspaceSaturationMatrix(Dataspace dataspace,mat4 * outMatrix)1260 Error AidlComposer::getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) {
1261 std::vector<float> matrix;
1262 const auto status =
1263 mAidlComposerClient->getDataspaceSaturationMatrix(translate<AidlDataspace>(dataspace),
1264 &matrix);
1265 if (!status.isOk()) {
1266 ALOGE("getDataspaceSaturationMatrix failed %s", status.getDescription().c_str());
1267 return static_cast<Error>(status.getServiceSpecificError());
1268 }
1269 *outMatrix = makeMat4(matrix);
1270 return Error::NONE;
1271 }
1272
getDisplayIdentificationData(Display display,uint8_t * outPort,std::vector<uint8_t> * outData)1273 Error AidlComposer::getDisplayIdentificationData(Display display, uint8_t* outPort,
1274 std::vector<uint8_t>* outData) {
1275 AidlDisplayIdentification displayIdentification;
1276 const auto status =
1277 mAidlComposerClient->getDisplayIdentificationData(translate<int64_t>(display),
1278 &displayIdentification);
1279 if (!status.isOk()) {
1280 ALOGE("getDisplayIdentificationData failed %s", status.getDescription().c_str());
1281 return static_cast<Error>(status.getServiceSpecificError());
1282 }
1283
1284 *outPort = static_cast<uint8_t>(displayIdentification.port);
1285 *outData = displayIdentification.data;
1286
1287 return Error::NONE;
1288 }
1289
setLayerColorTransform(Display display,Layer layer,const float * matrix)1290 Error AidlComposer::setLayerColorTransform(Display display, Layer layer, const float* matrix) {
1291 Error error = Error::NONE;
1292 mMutex.lock_shared();
1293 if (auto writer = getWriter(display)) {
1294 writer->get().setLayerColorTransform(translate<int64_t>(display), translate<int64_t>(layer),
1295 matrix);
1296 } else {
1297 error = Error::BAD_DISPLAY;
1298 }
1299 mMutex.unlock_shared();
1300 return error;
1301 }
1302
getDisplayedContentSamplingAttributes(Display display,PixelFormat * outFormat,Dataspace * outDataspace,uint8_t * outComponentMask)1303 Error AidlComposer::getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
1304 Dataspace* outDataspace,
1305 uint8_t* outComponentMask) {
1306 if (!outFormat || !outDataspace || !outComponentMask) {
1307 return Error::BAD_PARAMETER;
1308 }
1309
1310 AidlDisplayContentSamplingAttributes attributes;
1311 const auto status =
1312 mAidlComposerClient->getDisplayedContentSamplingAttributes(translate<int64_t>(display),
1313 &attributes);
1314 if (!status.isOk()) {
1315 ALOGE("getDisplayedContentSamplingAttributes failed %s", status.getDescription().c_str());
1316 return static_cast<Error>(status.getServiceSpecificError());
1317 }
1318
1319 *outFormat = translate<PixelFormat>(attributes.format);
1320 *outDataspace = translate<Dataspace>(attributes.dataspace);
1321 *outComponentMask = static_cast<uint8_t>(attributes.componentMask);
1322 return Error::NONE;
1323 }
1324
setDisplayContentSamplingEnabled(Display display,bool enabled,uint8_t componentMask,uint64_t maxFrames)1325 Error AidlComposer::setDisplayContentSamplingEnabled(Display display, bool enabled,
1326 uint8_t componentMask, uint64_t maxFrames) {
1327 const auto status =
1328 mAidlComposerClient
1329 ->setDisplayedContentSamplingEnabled(translate<int64_t>(display), enabled,
1330 static_cast<AidlFormatColorComponent>(
1331 componentMask),
1332 static_cast<int64_t>(maxFrames));
1333 if (!status.isOk()) {
1334 ALOGE("setDisplayedContentSamplingEnabled failed %s", status.getDescription().c_str());
1335 return static_cast<Error>(status.getServiceSpecificError());
1336 }
1337 return Error::NONE;
1338 }
1339
getDisplayedContentSample(Display display,uint64_t maxFrames,uint64_t timestamp,DisplayedFrameStats * outStats)1340 Error AidlComposer::getDisplayedContentSample(Display display, uint64_t maxFrames,
1341 uint64_t timestamp, DisplayedFrameStats* outStats) {
1342 if (!outStats) {
1343 return Error::BAD_PARAMETER;
1344 }
1345
1346 AidlDisplayContentSample sample;
1347 const auto status =
1348 mAidlComposerClient->getDisplayedContentSample(translate<int64_t>(display),
1349 static_cast<int64_t>(maxFrames),
1350 static_cast<int64_t>(timestamp),
1351 &sample);
1352 if (!status.isOk()) {
1353 ALOGE("getDisplayedContentSample failed %s", status.getDescription().c_str());
1354 return static_cast<Error>(status.getServiceSpecificError());
1355 }
1356 *outStats = translate<DisplayedFrameStats>(sample);
1357 return Error::NONE;
1358 }
1359
setLayerPerFrameMetadataBlobs(Display display,Layer layer,const std::vector<IComposerClient::PerFrameMetadataBlob> & metadata)1360 Error AidlComposer::setLayerPerFrameMetadataBlobs(
1361 Display display, Layer layer,
1362 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) {
1363 Error error = Error::NONE;
1364 mMutex.lock_shared();
1365 if (auto writer = getWriter(display)) {
1366 writer->get().setLayerPerFrameMetadataBlobs(translate<int64_t>(display),
1367 translate<int64_t>(layer),
1368 translate<AidlPerFrameMetadataBlob>(metadata));
1369 } else {
1370 error = Error::BAD_DISPLAY;
1371 }
1372 mMutex.unlock_shared();
1373 return error;
1374 }
1375
setDisplayBrightness(Display display,float brightness,float brightnessNits,const DisplayBrightnessOptions & options)1376 Error AidlComposer::setDisplayBrightness(Display display, float brightness, float brightnessNits,
1377 const DisplayBrightnessOptions& options) {
1378 Error error = Error::NONE;
1379 mMutex.lock_shared();
1380 if (auto writer = getWriter(display)) {
1381 writer->get().setDisplayBrightness(translate<int64_t>(display), brightness, brightnessNits);
1382
1383 if (options.applyImmediately) {
1384 error = execute(display);
1385 mMutex.unlock_shared();
1386 return error;
1387 }
1388 } else {
1389 error = Error::BAD_DISPLAY;
1390 }
1391 mMutex.unlock_shared();
1392 return error;
1393 }
1394
getDisplayCapabilities(Display display,std::vector<AidlDisplayCapability> * outCapabilities)1395 Error AidlComposer::getDisplayCapabilities(Display display,
1396 std::vector<AidlDisplayCapability>* outCapabilities) {
1397 const auto status = mAidlComposerClient->getDisplayCapabilities(translate<int64_t>(display),
1398 outCapabilities);
1399 if (!status.isOk()) {
1400 ALOGE("getDisplayCapabilities failed %s", status.getDescription().c_str());
1401 outCapabilities->clear();
1402 return static_cast<Error>(status.getServiceSpecificError());
1403 }
1404 return Error::NONE;
1405 }
1406
getDisplayConnectionType(Display display,IComposerClient::DisplayConnectionType * outType)1407 V2_4::Error AidlComposer::getDisplayConnectionType(
1408 Display display, IComposerClient::DisplayConnectionType* outType) {
1409 AidlDisplayConnectionType type;
1410 const auto status =
1411 mAidlComposerClient->getDisplayConnectionType(translate<int64_t>(display), &type);
1412 if (!status.isOk()) {
1413 ALOGE("getDisplayConnectionType failed %s", status.getDescription().c_str());
1414 return static_cast<V2_4::Error>(status.getServiceSpecificError());
1415 }
1416 *outType = translate<IComposerClient::DisplayConnectionType>(type);
1417 return V2_4::Error::NONE;
1418 }
1419
getDisplayVsyncPeriod(Display display,VsyncPeriodNanos * outVsyncPeriod)1420 V2_4::Error AidlComposer::getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) {
1421 int32_t vsyncPeriod;
1422 const auto status =
1423 mAidlComposerClient->getDisplayVsyncPeriod(translate<int64_t>(display), &vsyncPeriod);
1424 if (!status.isOk()) {
1425 ALOGE("getDisplayVsyncPeriod failed %s", status.getDescription().c_str());
1426 return static_cast<V2_4::Error>(status.getServiceSpecificError());
1427 }
1428 *outVsyncPeriod = translate<VsyncPeriodNanos>(vsyncPeriod);
1429 return V2_4::Error::NONE;
1430 }
1431
setActiveConfigWithConstraints(Display display,Config config,const IComposerClient::VsyncPeriodChangeConstraints & vsyncPeriodChangeConstraints,VsyncPeriodChangeTimeline * outTimeline)1432 Error AidlComposer::setActiveConfigWithConstraints(
1433 Display display, Config config,
1434 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
1435 VsyncPeriodChangeTimeline* outTimeline) {
1436 AidlVsyncPeriodChangeTimeline timeline;
1437 const auto status =
1438 mAidlComposerClient
1439 ->setActiveConfigWithConstraints(translate<int64_t>(display),
1440 translate<int32_t>(config),
1441 translate<AidlVsyncPeriodChangeConstraints>(
1442 vsyncPeriodChangeConstraints),
1443 &timeline);
1444 if (!status.isOk()) {
1445 ALOGE("setActiveConfigWithConstraints failed %s", status.getDescription().c_str());
1446 return static_cast<Error>(status.getServiceSpecificError());
1447 }
1448 *outTimeline = translate<VsyncPeriodChangeTimeline>(timeline);
1449 return Error::NONE;
1450 }
1451
setAutoLowLatencyMode(Display display,bool on)1452 V2_4::Error AidlComposer::setAutoLowLatencyMode(Display display, bool on) {
1453 const auto status = mAidlComposerClient->setAutoLowLatencyMode(translate<int64_t>(display), on);
1454 if (!status.isOk()) {
1455 ALOGE("setAutoLowLatencyMode failed %s", status.getDescription().c_str());
1456 return static_cast<V2_4::Error>(status.getServiceSpecificError());
1457 }
1458 return V2_4::Error::NONE;
1459 }
1460
getSupportedContentTypes(Display displayId,std::vector<IComposerClient::ContentType> * outSupportedContentTypes)1461 V2_4::Error AidlComposer::getSupportedContentTypes(
1462 Display displayId, std::vector<IComposerClient::ContentType>* outSupportedContentTypes) {
1463 std::vector<AidlContentType> types;
1464 const auto status =
1465 mAidlComposerClient->getSupportedContentTypes(translate<int64_t>(displayId), &types);
1466 if (!status.isOk()) {
1467 ALOGE("getSupportedContentTypes failed %s", status.getDescription().c_str());
1468 return static_cast<V2_4::Error>(status.getServiceSpecificError());
1469 }
1470 *outSupportedContentTypes = translate<IComposerClient::ContentType>(types);
1471 return V2_4::Error::NONE;
1472 }
1473
setContentType(Display display,IComposerClient::ContentType contentType)1474 V2_4::Error AidlComposer::setContentType(Display display,
1475 IComposerClient::ContentType contentType) {
1476 const auto status =
1477 mAidlComposerClient->setContentType(translate<int64_t>(display),
1478 translate<AidlContentType>(contentType));
1479 if (!status.isOk()) {
1480 ALOGE("setContentType failed %s", status.getDescription().c_str());
1481 return static_cast<V2_4::Error>(status.getServiceSpecificError());
1482 }
1483 return V2_4::Error::NONE;
1484 }
1485
setLayerGenericMetadata(Display,Layer,const std::string &,bool,const std::vector<uint8_t> &)1486 V2_4::Error AidlComposer::setLayerGenericMetadata(Display, Layer, const std::string&, bool,
1487 const std::vector<uint8_t>&) {
1488 // There are no users for this API. See b/209691612.
1489 return V2_4::Error::UNSUPPORTED;
1490 }
1491
getLayerGenericMetadataKeys(std::vector<IComposerClient::LayerGenericMetadataKey> *)1492 V2_4::Error AidlComposer::getLayerGenericMetadataKeys(
1493 std::vector<IComposerClient::LayerGenericMetadataKey>*) {
1494 // There are no users for this API. See b/209691612.
1495 return V2_4::Error::UNSUPPORTED;
1496 }
1497
setBootDisplayConfig(Display display,Config config)1498 Error AidlComposer::setBootDisplayConfig(Display display, Config config) {
1499 const auto status = mAidlComposerClient->setBootDisplayConfig(translate<int64_t>(display),
1500 translate<int32_t>(config));
1501 if (!status.isOk()) {
1502 ALOGE("setBootDisplayConfig failed %s", status.getDescription().c_str());
1503 return static_cast<Error>(status.getServiceSpecificError());
1504 }
1505 return Error::NONE;
1506 }
1507
clearBootDisplayConfig(Display display)1508 Error AidlComposer::clearBootDisplayConfig(Display display) {
1509 const auto status = mAidlComposerClient->clearBootDisplayConfig(translate<int64_t>(display));
1510 if (!status.isOk()) {
1511 ALOGE("clearBootDisplayConfig failed %s", status.getDescription().c_str());
1512 return static_cast<Error>(status.getServiceSpecificError());
1513 }
1514 return Error::NONE;
1515 }
1516
getPreferredBootDisplayConfig(Display display,Config * config)1517 Error AidlComposer::getPreferredBootDisplayConfig(Display display, Config* config) {
1518 int32_t displayConfig;
1519 const auto status =
1520 mAidlComposerClient->getPreferredBootDisplayConfig(translate<int64_t>(display),
1521 &displayConfig);
1522 if (!status.isOk()) {
1523 ALOGE("getPreferredBootDisplayConfig failed %s", status.getDescription().c_str());
1524 return static_cast<Error>(status.getServiceSpecificError());
1525 }
1526 *config = translate<uint32_t>(displayConfig);
1527 return Error::NONE;
1528 }
1529
getHdrConversionCapabilities(std::vector<AidlHdrConversionCapability> * hdrConversionCapabilities)1530 Error AidlComposer::getHdrConversionCapabilities(
1531 std::vector<AidlHdrConversionCapability>* hdrConversionCapabilities) {
1532 const auto status =
1533 mAidlComposerClient->getHdrConversionCapabilities(hdrConversionCapabilities);
1534 if (!status.isOk()) {
1535 hdrConversionCapabilities = {};
1536 ALOGE("getHdrConversionCapabilities failed %s", status.getDescription().c_str());
1537 return static_cast<Error>(status.getServiceSpecificError());
1538 }
1539 return Error::NONE;
1540 }
1541
setHdrConversionStrategy(AidlHdrConversionStrategy hdrConversionStrategy,Hdr * outPreferredHdrOutputType)1542 Error AidlComposer::setHdrConversionStrategy(AidlHdrConversionStrategy hdrConversionStrategy,
1543 Hdr* outPreferredHdrOutputType) {
1544 const auto status = mAidlComposerClient->setHdrConversionStrategy(hdrConversionStrategy,
1545 outPreferredHdrOutputType);
1546 if (!status.isOk()) {
1547 ALOGE("setHdrConversionStrategy failed %s", status.getDescription().c_str());
1548 return static_cast<Error>(status.getServiceSpecificError());
1549 }
1550 return Error::NONE;
1551 }
1552
setRefreshRateChangedCallbackDebugEnabled(Display displayId,bool enabled)1553 Error AidlComposer::setRefreshRateChangedCallbackDebugEnabled(Display displayId, bool enabled) {
1554 const auto status =
1555 mAidlComposerClient->setRefreshRateChangedCallbackDebugEnabled(translate<int64_t>(
1556 displayId),
1557 enabled);
1558 if (!status.isOk()) {
1559 ALOGE("setRefreshRateChangedCallbackDebugEnabled failed %s",
1560 status.getDescription().c_str());
1561 return static_cast<Error>(status.getServiceSpecificError());
1562 }
1563 return Error::NONE;
1564 }
1565
notifyExpectedPresent(Display displayId,nsecs_t expectedPresentTime,int32_t frameIntervalNs)1566 Error AidlComposer::notifyExpectedPresent(Display displayId, nsecs_t expectedPresentTime,
1567 int32_t frameIntervalNs) {
1568 const auto status =
1569 mAidlComposerClient->notifyExpectedPresent(translate<int64_t>(displayId),
1570 ClockMonotonicTimestamp{expectedPresentTime},
1571 frameIntervalNs);
1572
1573 if (!status.isOk()) {
1574 ALOGE("notifyExpectedPresent failed %s", status.getDescription().c_str());
1575 return static_cast<Error>(status.getServiceSpecificError());
1576 }
1577 return Error::NONE;
1578 }
1579
getClientTargetProperty(Display display,ClientTargetPropertyWithBrightness * outClientTargetProperty)1580 Error AidlComposer::getClientTargetProperty(
1581 Display display, ClientTargetPropertyWithBrightness* outClientTargetProperty) {
1582 Error error = Error::NONE;
1583 mMutex.lock_shared();
1584 if (auto reader = getReader(display)) {
1585 *outClientTargetProperty =
1586 reader->get().takeClientTargetProperty(translate<int64_t>(display));
1587 } else {
1588 error = Error::BAD_DISPLAY;
1589 }
1590 mMutex.unlock_shared();
1591 return error;
1592 }
1593
getRequestedLuts(Display display,std::vector<Layer> * outLayers,std::vector<DisplayLuts::LayerLut> * outLuts)1594 Error AidlComposer::getRequestedLuts(Display display, std::vector<Layer>* outLayers,
1595 std::vector<DisplayLuts::LayerLut>* outLuts) {
1596 Error error = Error::NONE;
1597 mMutex.lock_shared();
1598 if (auto reader = getReader(display)) {
1599 *outLuts = reader->get().takeDisplayLuts(translate<int64_t>(display));
1600 } else {
1601 error = Error::BAD_DISPLAY;
1602 }
1603 mMutex.unlock_shared();
1604
1605 outLayers->reserve(outLuts->size());
1606 for (const auto& layerLut : *outLuts) {
1607 outLayers->emplace_back(translate<Layer>(layerLut.layer));
1608 }
1609 return error;
1610 }
1611
setLayerLuts(Display display,Layer layer,Luts & luts)1612 Error AidlComposer::setLayerLuts(Display display, Layer layer, Luts& luts) {
1613 Error error = Error::NONE;
1614 mMutex.lock_shared();
1615 if (auto writer = getWriter(display)) {
1616 writer->get().setLayerLuts(translate<int64_t>(display), translate<int64_t>(layer), luts);
1617 } else {
1618 error = Error::BAD_DISPLAY;
1619 }
1620 mMutex.unlock_shared();
1621 return error;
1622 }
1623
setLayerBrightness(Display display,Layer layer,float brightness)1624 Error AidlComposer::setLayerBrightness(Display display, Layer layer, float brightness) {
1625 Error error = Error::NONE;
1626 mMutex.lock_shared();
1627 if (auto writer = getWriter(display)) {
1628 writer->get().setLayerBrightness(translate<int64_t>(display), translate<int64_t>(layer),
1629 brightness);
1630 } else {
1631 error = Error::BAD_DISPLAY;
1632 }
1633 mMutex.unlock_shared();
1634 return error;
1635 }
1636
setLayerBlockingRegion(Display display,Layer layer,const std::vector<IComposerClient::Rect> & blocking)1637 Error AidlComposer::setLayerBlockingRegion(Display display, Layer layer,
1638 const std::vector<IComposerClient::Rect>& blocking) {
1639 Error error = Error::NONE;
1640 mMutex.lock_shared();
1641 if (auto writer = getWriter(display)) {
1642 writer->get().setLayerBlockingRegion(translate<int64_t>(display), translate<int64_t>(layer),
1643 translate<AidlRect>(blocking));
1644 } else {
1645 error = Error::BAD_DISPLAY;
1646 }
1647 mMutex.unlock_shared();
1648 return error;
1649 }
1650
getDisplayDecorationSupport(Display display,std::optional<DisplayDecorationSupport> * support)1651 Error AidlComposer::getDisplayDecorationSupport(Display display,
1652 std::optional<DisplayDecorationSupport>* support) {
1653 const auto status =
1654 mAidlComposerClient->getDisplayDecorationSupport(translate<int64_t>(display), support);
1655 if (!status.isOk()) {
1656 ALOGE("getDisplayDecorationSupport failed %s", status.getDescription().c_str());
1657 support->reset();
1658 return static_cast<Error>(status.getServiceSpecificError());
1659 }
1660 return Error::NONE;
1661 }
1662
setIdleTimerEnabled(Display displayId,std::chrono::milliseconds timeout)1663 Error AidlComposer::setIdleTimerEnabled(Display displayId, std::chrono::milliseconds timeout) {
1664 const auto status =
1665 mAidlComposerClient->setIdleTimerEnabled(translate<int64_t>(displayId),
1666 translate<int32_t>(timeout.count()));
1667 if (!status.isOk()) {
1668 ALOGE("setIdleTimerEnabled failed %s", status.getDescription().c_str());
1669 return static_cast<Error>(status.getServiceSpecificError());
1670 }
1671 return Error::NONE;
1672 }
1673
getPhysicalDisplayOrientation(Display displayId,AidlTransform * outDisplayOrientation)1674 Error AidlComposer::getPhysicalDisplayOrientation(Display displayId,
1675 AidlTransform* outDisplayOrientation) {
1676 const auto status =
1677 mAidlComposerClient->getDisplayPhysicalOrientation(translate<int64_t>(displayId),
1678 outDisplayOrientation);
1679 if (!status.isOk()) {
1680 ALOGE("getPhysicalDisplayOrientation failed %s", status.getDescription().c_str());
1681 return static_cast<Error>(status.getServiceSpecificError());
1682 }
1683 return Error::NONE;
1684 }
1685
getMaxLayerPictureProfiles(Display display,int32_t * outMaxProfiles)1686 Error AidlComposer::getMaxLayerPictureProfiles(Display display, int32_t* outMaxProfiles) {
1687 const auto status = mAidlComposerClient->getMaxLayerPictureProfiles(translate<int64_t>(display),
1688 outMaxProfiles);
1689 if (!status.isOk()) {
1690 ALOGE("getMaxLayerPictureProfiles failed %s", status.getDescription().c_str());
1691 return static_cast<Error>(status.getServiceSpecificError());
1692 }
1693 return Error::NONE;
1694 }
1695
setDisplayPictureProfileId(Display display,PictureProfileId id)1696 Error AidlComposer::setDisplayPictureProfileId(Display display, PictureProfileId id) {
1697 Error error = Error::NONE;
1698 mMutex.lock_shared();
1699 if (auto writer = getWriter(display)) {
1700 writer->get().setDisplayPictureProfileId(translate<int64_t>(display), id);
1701 } else {
1702 error = Error::BAD_DISPLAY;
1703 }
1704 mMutex.unlock_shared();
1705 return error;
1706 }
1707
setLayerPictureProfileId(Display display,Layer layer,PictureProfileId id)1708 Error AidlComposer::setLayerPictureProfileId(Display display, Layer layer, PictureProfileId id) {
1709 Error error = Error::NONE;
1710 mMutex.lock_shared();
1711 if (auto writer = getWriter(display)) {
1712 writer->get().setLayerPictureProfileId(translate<int64_t>(display),
1713 translate<int64_t>(layer), id);
1714 } else {
1715 error = Error::BAD_DISPLAY;
1716 }
1717 mMutex.unlock_shared();
1718 return error;
1719 }
1720
startHdcpNegotiation(Display display,const aidl::android::hardware::drm::HdcpLevels & levels)1721 Error AidlComposer::startHdcpNegotiation(Display display,
1722 const aidl::android::hardware::drm::HdcpLevels& levels) {
1723 const auto status =
1724 mAidlComposerClient->startHdcpNegotiation(translate<int64_t>(display), levels);
1725 if (!status.isOk()) {
1726 ALOGE("startHdcpNegotiation failed %s", status.getDescription().c_str());
1727 return static_cast<Error>(status.getServiceSpecificError());
1728 }
1729
1730 return Error::NONE;
1731 }
1732
getLuts(Display display,const std::vector<sp<GraphicBuffer>> & buffers,std::vector<aidl::android::hardware::graphics::composer3::Luts> * luts)1733 Error AidlComposer::getLuts(Display display, const std::vector<sp<GraphicBuffer>>& buffers,
1734 std::vector<aidl::android::hardware::graphics::composer3::Luts>* luts) {
1735 std::vector<aidl::android::hardware::graphics::composer3::Buffer> aidlBuffers;
1736 aidlBuffers.reserve(buffers.size());
1737
1738 for (auto& buffer : buffers) {
1739 if (buffer.get()) {
1740 aidl::android::hardware::graphics::composer3::Buffer aidlBuffer;
1741 aidlBuffer.handle.emplace(::android::dupToAidl(buffer->getNativeBuffer()->handle));
1742 aidlBuffers.emplace_back(std::move(aidlBuffer));
1743 }
1744 }
1745
1746 const auto status =
1747 mAidlComposerClient->getLuts(translate<int64_t>(display), aidlBuffers, luts);
1748 if (!status.isOk()) {
1749 ALOGE("getLuts failed %s", status.getDescription().c_str());
1750 return static_cast<Error>(status.getServiceSpecificError());
1751 }
1752
1753 return Error::NONE;
1754 }
1755
getWriter(Display display)1756 ftl::Optional<std::reference_wrapper<ComposerClientWriter>> AidlComposer::getWriter(Display display)
1757 REQUIRES_SHARED(mMutex) {
1758 return mWriters.get(display);
1759 }
1760
getReader(Display display)1761 ftl::Optional<std::reference_wrapper<ComposerClientReader>> AidlComposer::getReader(Display display)
1762 REQUIRES_SHARED(mMutex) {
1763 if (mSingleReader) {
1764 display = translate<Display>(kSingleReaderKey);
1765 }
1766 return mReaders.get(display);
1767 }
1768
removeDisplay(Display display)1769 void AidlComposer::removeDisplay(Display display) {
1770 mMutex.lock();
1771 bool wasErased = mWriters.erase(display);
1772 ALOGW_IF(!wasErased,
1773 "Attempting to remove writer for display %" PRId64 " which is not connected",
1774 translate<int64_t>(display));
1775 if (!mSingleReader) {
1776 removeReader(display);
1777 }
1778 mMutex.unlock();
1779 }
1780
onHotplugDisconnect(Display display)1781 void AidlComposer::onHotplugDisconnect(Display display) {
1782 removeDisplay(display);
1783 }
1784
hasMultiThreadedPresentSupport(Display display)1785 bool AidlComposer::hasMultiThreadedPresentSupport(Display display) {
1786 const auto displayId = translate<int64_t>(display);
1787 std::vector<AidlDisplayCapability> capabilities;
1788 const auto status = mAidlComposerClient->getDisplayCapabilities(displayId, &capabilities);
1789 if (!status.isOk()) {
1790 ALOGE("getDisplayCapabilities failed %s", status.getDescription().c_str());
1791 return false;
1792 }
1793 return std::find(capabilities.begin(), capabilities.end(),
1794 AidlDisplayCapability::MULTI_THREADED_PRESENT) != capabilities.end();
1795 }
1796
addReader(Display display)1797 void AidlComposer::addReader(Display display) {
1798 const auto displayId = translate<int64_t>(display);
1799 std::optional<int64_t> displayOpt;
1800 if (displayId != kSingleReaderKey) {
1801 displayOpt.emplace(displayId);
1802 }
1803 auto [it, added] = mReaders.try_emplace(display, std::move(displayOpt));
1804 ALOGW_IF(!added, "Attempting to add writer for display %" PRId64 " which is already connected",
1805 displayId);
1806 }
1807
removeReader(Display display)1808 void AidlComposer::removeReader(Display display) {
1809 bool wasErased = mReaders.erase(display);
1810 ALOGW_IF(!wasErased,
1811 "Attempting to remove reader for display %" PRId64 " which is not connected",
1812 translate<int64_t>(display));
1813 }
1814
addDisplay(Display display)1815 void AidlComposer::addDisplay(Display display) {
1816 const auto displayId = translate<int64_t>(display);
1817 mMutex.lock();
1818 auto [it, added] = mWriters.try_emplace(display, displayId);
1819 ALOGW_IF(!added, "Attempting to add writer for display %" PRId64 " which is already connected",
1820 displayId);
1821 if (mSingleReader) {
1822 if (hasMultiThreadedPresentSupport(display)) {
1823 mSingleReader = false;
1824 removeReader(translate<Display>(kSingleReaderKey));
1825 // Note that this includes the new display.
1826 for (const auto& [existingDisplay, _] : mWriters) {
1827 addReader(existingDisplay);
1828 }
1829 }
1830 } else {
1831 addReader(display);
1832 }
1833 mMutex.unlock();
1834 }
1835
onHotplugConnect(Display display)1836 void AidlComposer::onHotplugConnect(Display display) {
1837 addDisplay(display);
1838 }
1839 } // namespace Hwc2
1840 } // namespace android
1841