1 /*
2 * Copyright (C) 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 #include <set>
18
19 #include "ComposerCommandEngine.h"
20 #include "Util.h"
21
22 namespace aidl::android::hardware::graphics::composer3::impl {
23
24 #define DISPATCH_LAYER_COMMAND(display, layerCmd, field, funcName) \
25 do { \
26 if (layerCmd.field) { \
27 executeSetLayer##funcName(display, layerCmd.layer, *layerCmd.field); \
28 } \
29 } while (0)
30
31 #define DISPATCH_LAYER_COMMAND_SIMPLE(display, layerCmd, field, funcName) \
32 do { \
33 dispatchLayerCommand(display, layerCmd.layer, #field, layerCmd.field, \
34 &IComposerHal::setLayer##funcName); \
35 } while (0)
36
37 #define DISPATCH_DISPLAY_COMMAND(displayCmd, field, funcName) \
38 do { \
39 if (displayCmd.field) { \
40 execute##funcName(displayCmd.display, *displayCmd.field); \
41 } \
42 } while (0)
43
44 #define DISPATCH_DISPLAY_BOOL_COMMAND(displayCmd, field, funcName) \
45 do { \
46 if (displayCmd.field) { \
47 execute##funcName(displayCmd.display); \
48 } \
49 } while (0)
50
51 #define DISPATCH_DISPLAY_BOOL_COMMAND_AND_DATA(displayCmd, field, data, funcName) \
52 do { \
53 if (displayCmd.field) { \
54 execute##funcName(displayCmd.display, displayCmd.data); \
55 } \
56 } while (0)
57
init()58 bool ComposerCommandEngine::init() {
59 mWriter = std::make_unique<ComposerServiceWriter>();
60 return (mWriter != nullptr);
61 }
62
execute(const std::vector<DisplayCommand> & commands,std::vector<CommandResultPayload> * result)63 int32_t ComposerCommandEngine::execute(const std::vector<DisplayCommand>& commands,
64 std::vector<CommandResultPayload>* result) {
65 std::set<int64_t> displaysPendingBrightenssChange;
66 mCommandIndex = 0;
67 for (const auto& command : commands) {
68 dispatchDisplayCommand(command);
69 ++mCommandIndex;
70 // The input commands could have 2+ commands for the same display.
71 // If the first has pending brightness change, the second presentDisplay will apply it.
72 if (command.validateDisplay || command.presentDisplay ||
73 command.presentOrValidateDisplay) {
74 displaysPendingBrightenssChange.erase(command.display);
75 } else if (command.brightness) {
76 displaysPendingBrightenssChange.insert(command.display);
77 }
78 }
79
80 *result = mWriter->getPendingCommandResults();
81 mWriter->reset();
82
83 // standalone display brightness command shouldn't wait for next present or validate
84 for (auto display : displaysPendingBrightenssChange) {
85 auto err = mHal->flushDisplayBrightnessChange(display);
86 if (err) {
87 return err;
88 }
89 }
90 return ::android::NO_ERROR;
91 }
92
dispatchDisplayCommand(const DisplayCommand & command)93 void ComposerCommandEngine::dispatchDisplayCommand(const DisplayCommand& command) {
94 // place SetDisplayBrightness before SetLayerWhitePointNits since current
95 // display brightness is used to validate the layer white point nits.
96 DISPATCH_DISPLAY_COMMAND(command, brightness, SetDisplayBrightness);
97 for (const auto& layerCmd : command.layers) {
98 dispatchLayerCommand(command.display, layerCmd);
99 }
100
101 DISPATCH_DISPLAY_COMMAND(command, colorTransformMatrix, SetColorTransform);
102 DISPATCH_DISPLAY_COMMAND(command, clientTarget, SetClientTarget);
103 DISPATCH_DISPLAY_COMMAND(command, virtualDisplayOutputBuffer, SetOutputBuffer);
104 DISPATCH_DISPLAY_BOOL_COMMAND_AND_DATA(command, validateDisplay, expectedPresentTime,
105 ValidateDisplay);
106 DISPATCH_DISPLAY_BOOL_COMMAND(command, acceptDisplayChanges, AcceptDisplayChanges);
107 DISPATCH_DISPLAY_BOOL_COMMAND(command, presentDisplay, PresentDisplay);
108 DISPATCH_DISPLAY_BOOL_COMMAND_AND_DATA(command, presentOrValidateDisplay, expectedPresentTime,
109 PresentOrValidateDisplay);
110 }
111
dispatchLayerCommand(int64_t display,const LayerCommand & command)112 void ComposerCommandEngine::dispatchLayerCommand(int64_t display, const LayerCommand& command) {
113 DISPATCH_LAYER_COMMAND(display, command, cursorPosition, CursorPosition);
114 DISPATCH_LAYER_COMMAND(display, command, buffer, Buffer);
115 DISPATCH_LAYER_COMMAND(display, command, damage, SurfaceDamage);
116 DISPATCH_LAYER_COMMAND(display, command, blendMode, BlendMode);
117 DISPATCH_LAYER_COMMAND(display, command, color, Color);
118 DISPATCH_LAYER_COMMAND(display, command, composition, Composition);
119 DISPATCH_LAYER_COMMAND(display, command, dataspace, Dataspace);
120 DISPATCH_LAYER_COMMAND(display, command, displayFrame, DisplayFrame);
121 DISPATCH_LAYER_COMMAND(display, command, planeAlpha, PlaneAlpha);
122 DISPATCH_LAYER_COMMAND(display, command, sidebandStream, SidebandStream);
123 DISPATCH_LAYER_COMMAND(display, command, sourceCrop, SourceCrop);
124 DISPATCH_LAYER_COMMAND(display, command, transform, Transform);
125 DISPATCH_LAYER_COMMAND(display, command, visibleRegion, VisibleRegion);
126 DISPATCH_LAYER_COMMAND(display, command, z, ZOrder);
127 DISPATCH_LAYER_COMMAND(display, command, colorTransform, ColorTransform);
128 DISPATCH_LAYER_COMMAND(display, command, brightness, Brightness);
129 DISPATCH_LAYER_COMMAND(display, command, perFrameMetadata, PerFrameMetadata);
130 DISPATCH_LAYER_COMMAND(display, command, perFrameMetadataBlob, PerFrameMetadataBlobs);
131 DISPATCH_LAYER_COMMAND_SIMPLE(display, command, blockingRegion, BlockingRegion);
132 }
133
executeValidateDisplayInternal(int64_t display)134 int32_t ComposerCommandEngine::executeValidateDisplayInternal(int64_t display) {
135 std::vector<int64_t> changedLayers;
136 std::vector<Composition> compositionTypes;
137 uint32_t displayRequestMask = 0x0;
138 std::vector<int64_t> requestedLayers;
139 std::vector<int32_t> requestMasks;
140 ClientTargetProperty clientTargetProperty{common::PixelFormat::RGBA_8888,
141 common::Dataspace::UNKNOWN};
142 DimmingStage dimmingStage;
143 auto err =
144 mHal->validateDisplay(display, &changedLayers, &compositionTypes, &displayRequestMask,
145 &requestedLayers, &requestMasks, &clientTargetProperty,
146 &dimmingStage);
147 mResources->setDisplayMustValidateState(display, false);
148 if (!err) {
149 mWriter->setChangedCompositionTypes(display, changedLayers, compositionTypes);
150 mWriter->setDisplayRequests(display, displayRequestMask, requestedLayers, requestMasks);
151 static constexpr float kBrightness = 1.f;
152 mWriter->setClientTargetProperty(display, clientTargetProperty, kBrightness, dimmingStage);
153 } else {
154 LOG(ERROR) << __func__ << ": err " << err;
155 mWriter->setError(mCommandIndex, err);
156 }
157 return err;
158 }
159
executeSetColorTransform(int64_t display,const std::vector<float> & matrix)160 void ComposerCommandEngine::executeSetColorTransform(int64_t display,
161 const std::vector<float>& matrix) {
162 auto err = mHal->setColorTransform(display, matrix);
163 if (err) {
164 LOG(ERROR) << __func__ << ": err " << err;
165 mWriter->setError(mCommandIndex, err);
166 }
167 }
168
executeSetClientTarget(int64_t display,const ClientTarget & command)169 void ComposerCommandEngine::executeSetClientTarget(int64_t display, const ClientTarget& command) {
170 bool useCache = !command.buffer.handle;
171 buffer_handle_t handle = useCache
172 ? nullptr
173 : ::android::makeFromAidl(*command.buffer.handle);
174 buffer_handle_t clientTarget;
175 auto bufferReleaser = mResources->createReleaser(true);
176 auto err = mResources->getDisplayClientTarget(display, command.buffer.slot, useCache, handle,
177 clientTarget, bufferReleaser.get());
178 if (!err) {
179 err = mHal->setClientTarget(display, clientTarget, command.buffer.fence,
180 command.dataspace, command.damage);
181 if (err) {
182 LOG(ERROR) << __func__ << " setClientTarget: err " << err;
183 mWriter->setError(mCommandIndex, err);
184 }
185 } else {
186 LOG(ERROR) << __func__ << " getDisplayClientTarget : err " << err;
187 mWriter->setError(mCommandIndex, err);
188 }
189 }
190
executeSetOutputBuffer(uint64_t display,const Buffer & buffer)191 void ComposerCommandEngine::executeSetOutputBuffer(uint64_t display, const Buffer& buffer) {
192 bool useCache = !buffer.handle;
193 buffer_handle_t handle = useCache
194 ? nullptr
195 : ::android::makeFromAidl(*buffer.handle);
196 buffer_handle_t outputBuffer;
197 auto bufferReleaser = mResources->createReleaser(true);
198 auto err = mResources->getDisplayOutputBuffer(display, buffer.slot, useCache, handle,
199 outputBuffer, bufferReleaser.get());
200 if (!err) {
201 err = mHal->setOutputBuffer(display, outputBuffer, buffer.fence);
202 if (err) {
203 LOG(ERROR) << __func__ << " setOutputBuffer: err " << err;
204 mWriter->setError(mCommandIndex, err);
205 }
206 } else {
207 LOG(ERROR) << __func__ << " getDisplayOutputBuffer: err " << err;
208 mWriter->setError(mCommandIndex, err);
209 }
210 }
211
executeSetExpectedPresentTimeInternal(int64_t display,const std::optional<ClockMonotonicTimestamp> expectedPresentTime)212 void ComposerCommandEngine::executeSetExpectedPresentTimeInternal(
213 int64_t display, const std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
214 mHal->setExpectedPresentTime(display, expectedPresentTime);
215 }
216
executeValidateDisplay(int64_t display,const std::optional<ClockMonotonicTimestamp> expectedPresentTime)217 void ComposerCommandEngine::executeValidateDisplay(
218 int64_t display, const std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
219 executeSetExpectedPresentTimeInternal(display, expectedPresentTime);
220 executeValidateDisplayInternal(display);
221 }
222
executeSetDisplayBrightness(uint64_t display,const DisplayBrightness & command)223 void ComposerCommandEngine::executeSetDisplayBrightness(uint64_t display,
224 const DisplayBrightness& command) {
225 auto err = mHal->setDisplayBrightness(display, command.brightness);
226 if (err) {
227 LOG(ERROR) << __func__ << ": err " << err;
228 mWriter->setError(mCommandIndex, err);
229 }
230 }
231
executePresentOrValidateDisplay(int64_t display,const std::optional<ClockMonotonicTimestamp> expectedPresentTime)232 void ComposerCommandEngine::executePresentOrValidateDisplay(
233 int64_t display, const std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
234 executeSetExpectedPresentTimeInternal(display, expectedPresentTime);
235
236 int err;
237 // First try to Present as is.
238 if (mHal->hasCapability(Capability::SKIP_VALIDATE)) {
239 err = mResources->mustValidateDisplay(display) ? IComposerClient::EX_NOT_VALIDATED
240 : executePresentDisplay(display);
241 if (!err) {
242 mWriter->setPresentOrValidateResult(display, PresentOrValidate::Result::Presented);
243 return;
244 }
245 }
246
247 // Fallback to validate
248 err = executeValidateDisplayInternal(display);
249 if (!err) {
250 mWriter->setPresentOrValidateResult(display, PresentOrValidate::Result::Validated);
251 }
252 }
253
executeAcceptDisplayChanges(int64_t display)254 void ComposerCommandEngine::executeAcceptDisplayChanges(int64_t display) {
255 auto err = mHal->acceptDisplayChanges(display);
256 if (err) {
257 LOG(ERROR) << __func__ << ": err " << err;
258 mWriter->setError(mCommandIndex, err);
259 }
260 }
261
executePresentDisplay(int64_t display)262 int ComposerCommandEngine::executePresentDisplay(int64_t display) {
263 ndk::ScopedFileDescriptor presentFence;
264 std::vector<int64_t> layers;
265 std::vector<ndk::ScopedFileDescriptor> fences;
266 auto err = mHal->presentDisplay(display, presentFence, &layers, &fences);
267 if (!err) {
268 mWriter->setPresentFence(display, std::move(presentFence));
269 mWriter->setReleaseFences(display, layers, std::move(fences));
270 }
271
272 return err;
273 }
274
executeSetLayerCursorPosition(int64_t display,int64_t layer,const common::Point & cursorPosition)275 void ComposerCommandEngine::executeSetLayerCursorPosition(int64_t display, int64_t layer,
276 const common::Point& cursorPosition) {
277 auto err = mHal->setLayerCursorPosition(display, layer, cursorPosition.x, cursorPosition.y);
278 if (err) {
279 LOG(ERROR) << __func__ << ": err " << err;
280 mWriter->setError(mCommandIndex, err);
281 }
282 }
283
executeSetLayerBuffer(int64_t display,int64_t layer,const Buffer & buffer)284 void ComposerCommandEngine::executeSetLayerBuffer(int64_t display, int64_t layer,
285 const Buffer& buffer) {
286 bool useCache = !buffer.handle;
287 buffer_handle_t handle = useCache
288 ? nullptr
289 : ::android::makeFromAidl(*buffer.handle);
290 buffer_handle_t hwcBuffer;
291 auto bufferReleaser = mResources->createReleaser(true);
292 auto err = mResources->getLayerBuffer(display, layer, buffer.slot, useCache,
293 handle, hwcBuffer, bufferReleaser.get());
294 if (!err) {
295 err = mHal->setLayerBuffer(display, layer, hwcBuffer, buffer.fence);
296 if (err) {
297 LOG(ERROR) << __func__ << ": setLayerBuffer err " << err;
298 mWriter->setError(mCommandIndex, err);
299 }
300 } else {
301 LOG(ERROR) << __func__ << ": getLayerBuffer err " << err;
302 mWriter->setError(mCommandIndex, err);
303 }
304 }
305
executeSetLayerSurfaceDamage(int64_t display,int64_t layer,const std::vector<std::optional<common::Rect>> & damage)306 void ComposerCommandEngine::executeSetLayerSurfaceDamage(int64_t display, int64_t layer,
307 const std::vector<std::optional<common::Rect>>& damage) {
308 auto err = mHal->setLayerSurfaceDamage(display, layer, damage);
309 if (err) {
310 LOG(ERROR) << __func__ << ": err " << err;
311 mWriter->setError(mCommandIndex, err);
312 }
313 }
314
executeSetLayerBlendMode(int64_t display,int64_t layer,const ParcelableBlendMode & blendMode)315 void ComposerCommandEngine::executeSetLayerBlendMode(int64_t display, int64_t layer,
316 const ParcelableBlendMode& blendMode) {
317 auto err = mHal->setLayerBlendMode(display, layer, blendMode.blendMode);
318 if (err) {
319 LOG(ERROR) << __func__ << ": err " << err;
320 mWriter->setError(mCommandIndex, err);
321 }
322 }
323
executeSetLayerColor(int64_t display,int64_t layer,const Color & color)324 void ComposerCommandEngine::executeSetLayerColor(int64_t display, int64_t layer,
325 const Color& color) {
326 auto err = mHal->setLayerColor(display, layer, color);
327 if (err) {
328 LOG(ERROR) << __func__ << ": err " << err;
329 mWriter->setError(mCommandIndex, err);
330 }
331 }
332
executeSetLayerComposition(int64_t display,int64_t layer,const ParcelableComposition & composition)333 void ComposerCommandEngine::executeSetLayerComposition(int64_t display, int64_t layer,
334 const ParcelableComposition& composition) {
335 auto err = mHal->setLayerCompositionType(display, layer, composition.composition);
336 if (err) {
337 LOG(ERROR) << __func__ << ": err " << err;
338 mWriter->setError(mCommandIndex, err);
339 }
340 }
341
executeSetLayerDataspace(int64_t display,int64_t layer,const ParcelableDataspace & dataspace)342 void ComposerCommandEngine::executeSetLayerDataspace(int64_t display, int64_t layer,
343 const ParcelableDataspace& dataspace) {
344 auto err = mHal->setLayerDataspace(display, layer, dataspace.dataspace);
345 if (err) {
346 LOG(ERROR) << __func__ << ": err " << err;
347 mWriter->setError(mCommandIndex, err);
348 }
349 }
350
executeSetLayerDisplayFrame(int64_t display,int64_t layer,const common::Rect & rect)351 void ComposerCommandEngine::executeSetLayerDisplayFrame(int64_t display, int64_t layer,
352 const common::Rect& rect) {
353 auto err = mHal->setLayerDisplayFrame(display, layer, rect);
354 if (err) {
355 LOG(ERROR) << __func__ << ": err " << err;
356 mWriter->setError(mCommandIndex, err);
357 }
358 }
359
executeSetLayerPlaneAlpha(int64_t display,int64_t layer,const PlaneAlpha & planeAlpha)360 void ComposerCommandEngine::executeSetLayerPlaneAlpha(int64_t display, int64_t layer,
361 const PlaneAlpha& planeAlpha) {
362 auto err = mHal->setLayerPlaneAlpha(display, layer, planeAlpha.alpha);
363 if (err) {
364 LOG(ERROR) << __func__ << ": err " << err;
365 mWriter->setError(mCommandIndex, err);
366 }
367 }
368
executeSetLayerSidebandStream(int64_t display,int64_t layer,const AidlNativeHandle & sidebandStream)369 void ComposerCommandEngine::executeSetLayerSidebandStream(int64_t display, int64_t layer,
370 const AidlNativeHandle& sidebandStream) {
371 buffer_handle_t handle = ::android::makeFromAidl(sidebandStream);
372 buffer_handle_t stream;
373
374 auto bufferReleaser = mResources->createReleaser(false);
375 auto err = mResources->getLayerSidebandStream(display, layer, handle,
376 stream, bufferReleaser.get());
377 if (err) {
378 err = mHal->setLayerSidebandStream(display, layer, stream);
379 }
380 if (err) {
381 LOG(ERROR) << __func__ << ": err " << err;
382 mWriter->setError(mCommandIndex, err);
383 }
384 }
385
executeSetLayerSourceCrop(int64_t display,int64_t layer,const common::FRect & sourceCrop)386 void ComposerCommandEngine::executeSetLayerSourceCrop(int64_t display, int64_t layer,
387 const common::FRect& sourceCrop) {
388 auto err = mHal->setLayerSourceCrop(display, layer, sourceCrop);
389 if (err) {
390 LOG(ERROR) << __func__ << ": err " << err;
391 mWriter->setError(mCommandIndex, err);
392 }
393 }
394
executeSetLayerTransform(int64_t display,int64_t layer,const ParcelableTransform & transform)395 void ComposerCommandEngine::executeSetLayerTransform(int64_t display, int64_t layer,
396 const ParcelableTransform& transform) {
397 auto err = mHal->setLayerTransform(display, layer, transform.transform);
398 if (err) {
399 LOG(ERROR) << __func__ << ": err " << err;
400 mWriter->setError(mCommandIndex, err);
401 }
402 }
403
executeSetLayerVisibleRegion(int64_t display,int64_t layer,const std::vector<std::optional<common::Rect>> & visibleRegion)404 void ComposerCommandEngine::executeSetLayerVisibleRegion(int64_t display, int64_t layer,
405 const std::vector<std::optional<common::Rect>>& visibleRegion) {
406 auto err = mHal->setLayerVisibleRegion(display, layer, visibleRegion);
407 if (err) {
408 LOG(ERROR) << __func__ << ": err " << err;
409 mWriter->setError(mCommandIndex, err);
410 }
411 }
412
executeSetLayerZOrder(int64_t display,int64_t layer,const ZOrder & zOrder)413 void ComposerCommandEngine::executeSetLayerZOrder(int64_t display, int64_t layer,
414 const ZOrder& zOrder) {
415 auto err = mHal->setLayerZOrder(display, layer, zOrder.z);
416 if (err) {
417 LOG(ERROR) << __func__ << ": err " << err;
418 mWriter->setError(mCommandIndex, err);
419 }
420 }
421
executeSetLayerPerFrameMetadata(int64_t display,int64_t layer,const std::vector<std::optional<PerFrameMetadata>> & perFrameMetadata)422 void ComposerCommandEngine::executeSetLayerPerFrameMetadata(int64_t display, int64_t layer,
423 const std::vector<std::optional<PerFrameMetadata>>& perFrameMetadata) {
424 auto err = mHal->setLayerPerFrameMetadata(display, layer, perFrameMetadata);
425 if (err) {
426 LOG(ERROR) << __func__ << ": err " << err;
427 mWriter->setError(mCommandIndex, err);
428 }
429 }
430
executeSetLayerColorTransform(int64_t display,int64_t layer,const std::vector<float> & matrix)431 void ComposerCommandEngine::executeSetLayerColorTransform(int64_t display, int64_t layer,
432 const std::vector<float>& matrix) {
433 auto err = mHal->setLayerColorTransform(display, layer, matrix);
434 if (err) {
435 LOG(ERROR) << __func__ << ": err " << err;
436 mWriter->setError(mCommandIndex, err);
437 }
438 }
439
executeSetLayerBrightness(int64_t display,int64_t layer,const LayerBrightness & brightness)440 void ComposerCommandEngine::executeSetLayerBrightness(int64_t display, int64_t layer,
441 const LayerBrightness& brightness) {
442 auto err = mHal->setLayerBrightness(display, layer, brightness.brightness);
443 if (err) {
444 LOG(ERROR) << __func__ << ": err " << err;
445 mWriter->setError(mCommandIndex, err);
446 }
447 }
448
executeSetLayerPerFrameMetadataBlobs(int64_t display,int64_t layer,const std::vector<std::optional<PerFrameMetadataBlob>> & metadata)449 void ComposerCommandEngine::executeSetLayerPerFrameMetadataBlobs(int64_t display, int64_t layer,
450 const std::vector<std::optional<PerFrameMetadataBlob>>& metadata) {
451 auto err = mHal->setLayerPerFrameMetadataBlobs(display, layer, metadata);
452 if (err) {
453 LOG(ERROR) << __func__ << ": err " << err;
454 mWriter->setError(mCommandIndex, err);
455 }
456 }
457
458 } // namespace aidl::android::hardware::graphics::composer3::impl
459