blob: 1ea13a7b2dba914b9c6effced14c7293a2679272 [file] [log] [blame]
Lloyd Pique45a165a2018-10-19 11:54:47 -07001/*
2 * Copyright 2019 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
Lloyd Pique32cbe282018-10-19 13:09:22 -070017#include <android-base/stringprintf.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070018#include <compositionengine/CompositionEngine.h>
Lloyd Piqued3d69882019-02-28 16:03:46 -080019#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070020#include <compositionengine/DisplayCreationArgs.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070021#include <compositionengine/DisplaySurface.h>
Lloyd Piquedf336d92019-03-07 21:38:42 -080022#include <compositionengine/LayerFE.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070023#include <compositionengine/impl/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070024#include <compositionengine/impl/DisplayColorProfile.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070025#include <compositionengine/impl/DumpHelpers.h>
Lloyd Pique66d68602019-02-13 14:23:31 -080026#include <compositionengine/impl/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070027#include <compositionengine/impl/RenderSurface.h>
Lloyd Pique3b5a69e2020-01-16 17:51:01 -080028
Lloyd Pique66d68602019-02-13 14:23:31 -080029#include <utils/Trace.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070030
Lloyd Pique3b5a69e2020-01-16 17:51:01 -080031// TODO(b/129481165): remove the #pragma below and fix conversion issues
32#pragma clang diagnostic push
33#pragma clang diagnostic ignored "-Wconversion"
34
Lloyd Pique45a165a2018-10-19 11:54:47 -070035#include "DisplayHardware/HWComposer.h"
Lloyd Pique3b5a69e2020-01-16 17:51:01 -080036
37// TODO(b/129481165): remove the #pragma below and fix conversion issues
38#pragma clang diagnostic pop // ignored "-Wconversion"
39
Lloyd Pique688abd42019-02-15 15:42:24 -080040#include "DisplayHardware/PowerAdvisor.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070041
Leon Scroggins III5967aec2021-12-29 11:14:22 -050042using aidl::android::hardware::graphics::composer3::DisplayCapability;
43
Lloyd Pique45a165a2018-10-19 11:54:47 -070044namespace android::compositionengine::impl {
45
Lloyd Pique35fca9d2019-02-13 14:24:11 -080046std::shared_ptr<Display> createDisplay(
Lloyd Pique45a165a2018-10-19 11:54:47 -070047 const compositionengine::CompositionEngine& compositionEngine,
Lloyd Piquea38ea7e2019-04-16 18:10:26 -070048 const compositionengine::DisplayCreationArgs& args) {
49 return createDisplayTemplated<Display>(compositionEngine, args);
Lloyd Pique45a165a2018-10-19 11:54:47 -070050}
51
Lloyd Pique45a165a2018-10-19 11:54:47 -070052Display::~Display() = default;
53
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070054void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {
Dominik Laskowski13948602021-03-08 20:48:28 -080055 mId = args.id;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070056 mPowerAdvisor = args.powerAdvisor;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070057 editState().isSecure = args.isSecure;
Angel Aguayob084e0c2021-08-04 23:27:28 +000058 editState().displaySpace.setBounds(args.pixels);
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070059 setName(args.name);
Kriti Dang646f8ec2022-01-18 14:35:02 +010060 bool isBootModeSupported = getCompositionEngine().getHwComposer().getBootDisplayModeSupport();
61 const auto physicalId = PhysicalDisplayId::tryCast(mId);
62 if (physicalId && isBootModeSupported) {
63 mPreferredBootDisplayModeId = static_cast<int32_t>(
64 getCompositionEngine().getHwComposer().getPreferredBootDisplayMode(*physicalId));
65 }
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070066}
67
68bool Display::isValid() const {
69 return Output::isValid() && mPowerAdvisor;
70}
71
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020072DisplayId Display::getId() const {
Lloyd Pique45a165a2018-10-19 11:54:47 -070073 return mId;
74}
75
76bool Display::isSecure() const {
Lloyd Pique32cbe282018-10-19 13:09:22 -070077 return getState().isSecure;
Lloyd Pique45a165a2018-10-19 11:54:47 -070078}
79
80bool Display::isVirtual() const {
Dominik Laskowski29fa1462021-04-27 15:51:50 -070081 return VirtualDisplayId::tryCast(mId).has_value();
Lloyd Pique45a165a2018-10-19 11:54:47 -070082}
83
Lloyd Pique6c564cf2019-05-17 17:31:36 -070084std::optional<DisplayId> Display::getDisplayId() const {
85 return mId;
86}
87
Kriti Dang646f8ec2022-01-18 14:35:02 +010088int32_t Display::getPreferredBootModeId() const {
89 return mPreferredBootDisplayModeId;
90}
91
Lloyd Pique45a165a2018-10-19 11:54:47 -070092void Display::disconnect() {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020093 if (mIsDisconnected) {
Lloyd Pique45a165a2018-10-19 11:54:47 -070094 return;
95 }
96
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020097 mIsDisconnected = true;
Dominik Laskowski13948602021-03-08 20:48:28 -080098
99 if (const auto id = HalDisplayId::tryCast(mId)) {
100 getCompositionEngine().getHwComposer().disconnectDisplay(*id);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200101 }
Lloyd Pique45a165a2018-10-19 11:54:47 -0700102}
103
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800104void Display::setColorTransform(const compositionengine::CompositionRefreshArgs& args) {
105 Output::setColorTransform(args);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200106 const auto halDisplayId = HalDisplayId::tryCast(mId);
107 if (mIsDisconnected || !halDisplayId || CC_LIKELY(!args.colorTransformMatrix)) {
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800108 return;
109 }
Lloyd Pique32cbe282018-10-19 13:09:22 -0700110
111 auto& hwc = getCompositionEngine().getHwComposer();
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200112 status_t result = hwc.setColorTransform(*halDisplayId, *args.colorTransformMatrix);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700113 ALOGE_IF(result != NO_ERROR, "Failed to set color transform on display \"%s\": %d",
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200114 to_string(mId).c_str(), result);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700115}
116
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800117void Display::setColorProfile(const ColorProfile& colorProfile) {
118 const ui::Dataspace targetDataspace =
119 getDisplayColorProfile()->getTargetDataspace(colorProfile.mode, colorProfile.dataspace,
120 colorProfile.colorSpaceAgnosticDataspace);
Lloyd Piquef5275482019-01-29 18:42:42 -0800121
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800122 if (colorProfile.mode == getState().colorMode &&
123 colorProfile.dataspace == getState().dataspace &&
124 colorProfile.renderIntent == getState().renderIntent &&
125 targetDataspace == getState().targetDataspace) {
Lloyd Pique32cbe282018-10-19 13:09:22 -0700126 return;
127 }
128
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700129 if (isVirtual()) {
130 ALOGW("%s: Invalid operation on virtual display", __func__);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700131 return;
132 }
133
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800134 Output::setColorProfile(colorProfile);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700135
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200136 const auto physicalId = PhysicalDisplayId::tryCast(mId);
137 LOG_FATAL_IF(!physicalId);
138 getCompositionEngine().getHwComposer().setActiveColorMode(*physicalId, colorProfile.mode,
139 colorProfile.renderIntent);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700140}
141
142void Display::dump(std::string& out) const {
143 using android::base::StringAppendF;
144
145 StringAppendF(&out, " Composition Display State: [\"%s\"]", getName().c_str());
146
147 out.append("\n ");
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700148 dumpVal(out, "isVirtual", isVirtual());
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200149 dumpVal(out, "DisplayId", to_string(mId));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700150 out.append("\n");
151
152 Output::dumpBase(out);
153}
154
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700155void Display::createDisplayColorProfile(const DisplayColorProfileCreationArgs& args) {
156 setDisplayColorProfile(compositionengine::impl::createDisplayColorProfile(args));
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700157}
158
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700159void Display::createRenderSurface(const RenderSurfaceCreationArgs& args) {
160 setRenderSurface(
161 compositionengine::impl::createRenderSurface(getCompositionEngine(), *this, args));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700162}
163
Vishnu Nair9b079a22020-01-21 14:36:08 -0800164void Display::createClientCompositionCache(uint32_t cacheSize) {
165 cacheClientCompositionRequests(cacheSize);
166}
167
Lloyd Piquedf336d92019-03-07 21:38:42 -0800168std::unique_ptr<compositionengine::OutputLayer> Display::createOutputLayer(
Lloyd Piquedf336d92019-03-07 21:38:42 -0800169 const sp<compositionengine::LayerFE>& layerFE) const {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200170 auto outputLayer = impl::createOutputLayer(*this, layerFE);
Lloyd Piquedf336d92019-03-07 21:38:42 -0800171
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200172 if (const auto halDisplayId = HalDisplayId::tryCast(mId);
173 outputLayer && !mIsDisconnected && halDisplayId) {
Lloyd Piquedf336d92019-03-07 21:38:42 -0800174 auto& hwc = getCompositionEngine().getHwComposer();
Lloyd Pique1b33fc32021-05-07 14:36:58 -0700175 auto hwcLayer = hwc.createLayer(*halDisplayId);
Lloyd Piquedf336d92019-03-07 21:38:42 -0800176 ALOGE_IF(!hwcLayer, "Failed to create a HWC layer for a HWC supported display %s",
177 getName().c_str());
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200178 outputLayer->setHwcLayer(std::move(hwcLayer));
Lloyd Piquedf336d92019-03-07 21:38:42 -0800179 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200180 return outputLayer;
Lloyd Piquedf336d92019-03-07 21:38:42 -0800181}
182
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800183void Display::setReleasedLayers(const compositionengine::CompositionRefreshArgs& refreshArgs) {
184 Output::setReleasedLayers(refreshArgs);
185
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200186 if (mIsDisconnected || GpuVirtualDisplayId::tryCast(mId) ||
187 refreshArgs.layersWithQueuedFrames.empty()) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800188 return;
189 }
190
191 // For layers that are being removed from a HWC display, and that have
192 // queued frames, add them to a a list of released layers so we can properly
193 // set a fence.
194 compositionengine::Output::ReleasedLayers releasedLayers;
195
196 // Any non-null entries in the current list of layers are layers that are no
197 // longer going to be visible
Lloyd Piquede196652020-01-22 17:29:58 -0800198 for (auto* outputLayer : getOutputLayersOrderedByZ()) {
199 if (!outputLayer) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800200 continue;
201 }
202
Lloyd Piquede196652020-01-22 17:29:58 -0800203 compositionengine::LayerFE* layerFE = &outputLayer->getLayerFE();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800204 const bool hasQueuedFrames =
Lloyd Piquede196652020-01-22 17:29:58 -0800205 std::any_of(refreshArgs.layersWithQueuedFrames.cbegin(),
206 refreshArgs.layersWithQueuedFrames.cend(),
207 [layerFE](sp<compositionengine::LayerFE> layerWithQueuedFrames) {
208 return layerFE == layerWithQueuedFrames.get();
209 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800210
211 if (hasQueuedFrames) {
212 releasedLayers.emplace_back(layerFE);
213 }
214 }
215
216 setReleasedLayers(std::move(releasedLayers));
217}
218
Lloyd Pique66d68602019-02-13 14:23:31 -0800219void Display::chooseCompositionStrategy() {
220 ATRACE_CALL();
221 ALOGV(__FUNCTION__);
222
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200223 if (mIsDisconnected) {
224 return;
225 }
226
Lloyd Pique66d68602019-02-13 14:23:31 -0800227 // Default to the base settings -- client composition only.
228 Output::chooseCompositionStrategy();
229
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200230 // If we don't have a HWC display, then we are done.
231 const auto halDisplayId = HalDisplayId::tryCast(mId);
232 if (!halDisplayId) {
Lloyd Pique66d68602019-02-13 14:23:31 -0800233 return;
234 }
235
236 // Get any composition changes requested by the HWC device, and apply them.
237 std::optional<android::HWComposer::DeviceRequestedChanges> changes;
238 auto& hwc = getCompositionEngine().getHwComposer();
Alec Mouricdf16792021-12-10 13:16:06 -0800239 if (const auto physicalDisplayId = PhysicalDisplayId::tryCast(*halDisplayId);
240 physicalDisplayId && getState().displayBrightness) {
241 const status_t result =
242 hwc.setDisplayBrightness(*physicalDisplayId, *getState().displayBrightness,
243 Hwc2::Composer::DisplayBrightnessOptions{
244 .applyImmediately = false})
245 .get();
246 ALOGE_IF(result != NO_ERROR, "setDisplayBrightness failed for %s: %d, (%s)",
247 getName().c_str(), result, strerror(-result));
248 }
249
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200250 if (status_t result =
251 hwc.getDeviceCompositionChanges(*halDisplayId, anyLayersRequireClientComposition(),
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700252 getState().earliestPresentTime,
Ady Abraham43065bd2021-12-10 17:22:15 -0800253 getState().previousPresentFence,
254 getState().expectedPresentTime, &changes);
Lloyd Pique66d68602019-02-13 14:23:31 -0800255 result != NO_ERROR) {
256 ALOGE("chooseCompositionStrategy failed for %s: %d (%s)", getName().c_str(), result,
257 strerror(-result));
258 return;
259 }
260 if (changes) {
261 applyChangedTypesToLayers(changes->changedTypes);
262 applyDisplayRequests(changes->displayRequests);
263 applyLayerRequestsToLayers(changes->layerRequests);
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700264 applyClientTargetRequests(changes->clientTargetProperty,
265 changes->clientTargetWhitePointNits);
Lloyd Pique66d68602019-02-13 14:23:31 -0800266 }
267
268 // Determine what type of composition we are doing from the final state
269 auto& state = editState();
270 state.usesClientComposition = anyLayersRequireClientComposition();
271 state.usesDeviceComposition = !allLayersRequireClientComposition();
Alec Mouricdf16792021-12-10 13:16:06 -0800272 // Clear out the display brightness now that it's been communicated to composer.
273 state.displayBrightness.reset();
Lloyd Pique66d68602019-02-13 14:23:31 -0800274}
275
Lloyd Pique688abd42019-02-15 15:42:24 -0800276bool Display::getSkipColorTransform() const {
Dominik Laskowski1162e472020-04-02 19:02:47 -0700277 const auto& hwc = getCompositionEngine().getHwComposer();
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200278 if (const auto halDisplayId = HalDisplayId::tryCast(mId)) {
279 return hwc.hasDisplayCapability(*halDisplayId,
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500280 DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200281 }
282
283 return hwc.hasCapability(hal::Capability::SKIP_CLIENT_COLOR_TRANSFORM);
Lloyd Pique688abd42019-02-15 15:42:24 -0800284}
285
Lloyd Pique66d68602019-02-13 14:23:31 -0800286bool Display::anyLayersRequireClientComposition() const {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700287 const auto layers = getOutputLayersOrderedByZ();
288 return std::any_of(layers.begin(), layers.end(),
Lloyd Pique66d68602019-02-13 14:23:31 -0800289 [](const auto& layer) { return layer->requiresClientComposition(); });
290}
291
292bool Display::allLayersRequireClientComposition() const {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700293 const auto layers = getOutputLayersOrderedByZ();
294 return std::all_of(layers.begin(), layers.end(),
Lloyd Pique66d68602019-02-13 14:23:31 -0800295 [](const auto& layer) { return layer->requiresClientComposition(); });
296}
297
298void Display::applyChangedTypesToLayers(const ChangedTypes& changedTypes) {
299 if (changedTypes.empty()) {
300 return;
301 }
302
Lloyd Pique01c77c12019-04-17 12:48:32 -0700303 for (auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Pique66d68602019-02-13 14:23:31 -0800304 auto hwcLayer = layer->getHwcLayer();
305 if (!hwcLayer) {
306 continue;
307 }
308
309 if (auto it = changedTypes.find(hwcLayer); it != changedTypes.end()) {
310 layer->applyDeviceCompositionTypeChange(
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500311 static_cast<aidl::android::hardware::graphics::composer3::Composition>(
312 it->second));
Lloyd Pique66d68602019-02-13 14:23:31 -0800313 }
314 }
315}
316
317void Display::applyDisplayRequests(const DisplayRequests& displayRequests) {
318 auto& state = editState();
319 state.flipClientTarget = (static_cast<uint32_t>(displayRequests) &
Peiyong Line9d809e2020-04-14 13:10:48 -0700320 static_cast<uint32_t>(hal::DisplayRequest::FLIP_CLIENT_TARGET)) != 0;
Lloyd Pique66d68602019-02-13 14:23:31 -0800321 // Note: HWC2::DisplayRequest::WriteClientTargetToOutput is currently ignored.
322}
323
324void Display::applyLayerRequestsToLayers(const LayerRequests& layerRequests) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700325 for (auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Pique66d68602019-02-13 14:23:31 -0800326 layer->prepareForDeviceLayerRequests();
327
328 auto hwcLayer = layer->getHwcLayer();
329 if (!hwcLayer) {
330 continue;
331 }
332
333 if (auto it = layerRequests.find(hwcLayer); it != layerRequests.end()) {
334 layer->applyDeviceLayerRequest(
335 static_cast<Hwc2::IComposerClient::LayerRequest>(it->second));
336 }
337 }
338}
339
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700340void Display::applyClientTargetRequests(const ClientTargetProperty& clientTargetProperty,
341 float whitePointNits) {
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700342 if (clientTargetProperty.dataspace == ui::Dataspace::UNKNOWN) {
343 return;
344 }
Ady Abraham0094dc62021-06-03 10:08:33 -0700345
346 editState().dataspace = clientTargetProperty.dataspace;
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700347 editState().clientTargetWhitePointNits = whitePointNits;
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700348 getRenderSurface()->setBufferDataspace(clientTargetProperty.dataspace);
349 getRenderSurface()->setBufferPixelFormat(clientTargetProperty.pixelFormat);
350}
351
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800352compositionengine::Output::FrameFences Display::presentAndGetFrameFences() {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200353 auto fences = impl::Output::presentAndGetFrameFences();
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800354
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200355 const auto halDisplayIdOpt = HalDisplayId::tryCast(mId);
356 if (mIsDisconnected || !halDisplayIdOpt) {
357 return fences;
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800358 }
359
360 auto& hwc = getCompositionEngine().getHwComposer();
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700361 hwc.presentAndGetReleaseFences(*halDisplayIdOpt, getState().earliestPresentTime,
362 getState().previousPresentFence);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800363
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200364 fences.presentFence = hwc.getPresentFence(*halDisplayIdOpt);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800365
366 // TODO(b/121291683): Change HWComposer call to return entire map
Lloyd Pique01c77c12019-04-17 12:48:32 -0700367 for (const auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800368 auto hwcLayer = layer->getHwcLayer();
369 if (!hwcLayer) {
370 continue;
371 }
372
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200373 fences.layerFences.emplace(hwcLayer, hwc.getLayerReleaseFence(*halDisplayIdOpt, hwcLayer));
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800374 }
375
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200376 hwc.clearReleaseFences(*halDisplayIdOpt);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800377
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200378 return fences;
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800379}
380
Lloyd Pique688abd42019-02-15 15:42:24 -0800381void Display::setExpensiveRenderingExpected(bool enabled) {
382 Output::setExpensiveRenderingExpected(enabled);
383
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200384 if (mPowerAdvisor && !GpuVirtualDisplayId::tryCast(mId)) {
385 mPowerAdvisor->setExpensiveRenderingExpected(mId, enabled);
Lloyd Pique688abd42019-02-15 15:42:24 -0800386 }
387}
388
Lloyd Piqued3d69882019-02-28 16:03:46 -0800389void Display::finishFrame(const compositionengine::CompositionRefreshArgs& refreshArgs) {
390 // We only need to actually compose the display if:
391 // 1) It is being handled by hardware composer, which may need this to
392 // keep its virtual display state machine in sync, or
393 // 2) There is work to be done (the dirty region isn't empty)
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700394 if (GpuVirtualDisplayId::tryCast(mId) && getDirtyRegion().isEmpty()) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200395 ALOGV("Skipping display composition");
396 return;
Lloyd Piqued3d69882019-02-28 16:03:46 -0800397 }
398
399 impl::Output::finishFrame(refreshArgs);
400}
401
Lloyd Pique45a165a2018-10-19 11:54:47 -0700402} // namespace android::compositionengine::impl