blob: 17aefc5492f3f6f180a687dbdbaeab12d23d7915 [file] [log] [blame]
Lloyd Pique32cbe282018-10-19 13:09:22 -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
Alec Mouria90a5702021-04-16 16:36:21 +000017#include <SurfaceFlingerProperties.sysprop.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070018#include <android-base/stringprintf.h>
19#include <compositionengine/CompositionEngine.h>
Lloyd Piquef8cf14d2019-02-28 16:03:12 -080020#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070021#include <compositionengine/DisplayColorProfile.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080022#include <compositionengine/LayerFE.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070023#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070024#include <compositionengine/RenderSurface.h>
Vishnu Naira3140382022-02-24 14:07:11 -080025#include <compositionengine/impl/HwcAsyncWorker.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070026#include <compositionengine/impl/Output.h>
Lloyd Piquea38ea7e2019-04-16 18:10:26 -070027#include <compositionengine/impl/OutputCompositionState.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080028#include <compositionengine/impl/OutputLayer.h>
Lloyd Piquea38ea7e2019-04-16 18:10:26 -070029#include <compositionengine/impl/OutputLayerCompositionState.h>
Dan Stoza269dc4d2021-01-15 15:07:43 -080030#include <compositionengine/impl/planner/Planner.h>
Sally Qi59a9f502021-10-12 18:53:23 +000031#include <ftl/future.h>
Dan Stoza269dc4d2021-01-15 15:07:43 -080032
Alec Mouria90a5702021-04-16 16:36:21 +000033#include <thread>
34
35#include "renderengine/ExternalTexture.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 push
39#pragma clang diagnostic ignored "-Wconversion"
40
Lloyd Pique688abd42019-02-15 15:42:24 -080041#include <renderengine/DisplaySettings.h>
42#include <renderengine/RenderEngine.h>
Lloyd Pique3b5a69e2020-01-16 17:51:01 -080043
44// TODO(b/129481165): remove the #pragma below and fix conversion issues
45#pragma clang diagnostic pop // ignored "-Wconversion"
46
Dan Stoza269dc4d2021-01-15 15:07:43 -080047#include <android-base/properties.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070048#include <ui/DebugUtils.h>
Lloyd Pique688abd42019-02-15 15:42:24 -080049#include <ui/HdrCapabilities.h>
Lloyd Pique66d68602019-02-13 14:23:31 -080050#include <utils/Trace.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070051
Lloyd Pique688abd42019-02-15 15:42:24 -080052#include "TracedOrdinal.h"
53
Leon Scroggins III9a0afda2022-01-11 16:53:09 -050054using aidl::android::hardware::graphics::composer3::Composition;
55
Lloyd Piquefeb73d72018-12-04 17:23:44 -080056namespace android::compositionengine {
57
58Output::~Output() = default;
59
60namespace impl {
Vishnu Nair9cf89262022-02-26 09:17:49 -080061using CompositionStrategyPredictionState =
62 OutputCompositionState::CompositionStrategyPredictionState;
Lloyd Piquec29e4c62019-03-07 21:48:19 -080063namespace {
64
65template <typename T>
66class Reversed {
67public:
68 explicit Reversed(const T& container) : mContainer(container) {}
69 auto begin() { return mContainer.rbegin(); }
70 auto end() { return mContainer.rend(); }
71
72private:
73 const T& mContainer;
74};
75
76// Helper for enumerating over a container in reverse order
77template <typename T>
78Reversed<T> reversed(const T& c) {
79 return Reversed<T>(c);
80}
81
Marin Shalamanovb15d2272020-09-17 21:41:52 +020082struct ScaleVector {
83 float x;
84 float y;
85};
86
87// Returns a ScaleVector (x, y) such that from.scale(x, y) = to',
88// where to' will have the same size as "to". In the case where "from" and "to"
89// start at the origin to'=to.
90ScaleVector getScale(const Rect& from, const Rect& to) {
91 return {.x = static_cast<float>(to.width()) / from.width(),
92 .y = static_cast<float>(to.height()) / from.height()};
93}
94
Lloyd Piquec29e4c62019-03-07 21:48:19 -080095} // namespace
96
Lloyd Piquea38ea7e2019-04-16 18:10:26 -070097std::shared_ptr<Output> createOutput(
98 const compositionengine::CompositionEngine& compositionEngine) {
99 return createOutputTemplated<Output>(compositionEngine);
100}
Lloyd Pique32cbe282018-10-19 13:09:22 -0700101
102Output::~Output() = default;
103
Lloyd Pique32cbe282018-10-19 13:09:22 -0700104bool Output::isValid() const {
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700105 return mDisplayColorProfile && mDisplayColorProfile->isValid() && mRenderSurface &&
106 mRenderSurface->isValid();
Lloyd Pique32cbe282018-10-19 13:09:22 -0700107}
108
Lloyd Pique6c564cf2019-05-17 17:31:36 -0700109std::optional<DisplayId> Output::getDisplayId() const {
110 return {};
111}
112
Lloyd Pique32cbe282018-10-19 13:09:22 -0700113const std::string& Output::getName() const {
114 return mName;
115}
116
117void Output::setName(const std::string& name) {
118 mName = name;
119}
120
121void Output::setCompositionEnabled(bool enabled) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700122 auto& outputState = editState();
123 if (outputState.isEnabled == enabled) {
Lloyd Pique32cbe282018-10-19 13:09:22 -0700124 return;
125 }
126
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700127 outputState.isEnabled = enabled;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700128 dirtyEntireOutput();
129}
130
Alec Mouri023c1882021-05-08 16:36:33 -0700131void Output::setLayerCachingEnabled(bool enabled) {
132 if (enabled == (mPlanner != nullptr)) {
133 return;
134 }
135
136 if (enabled) {
Alec Mouridf6201b2021-06-01 16:20:42 -0700137 mPlanner = std::make_unique<planner::Planner>(getCompositionEngine().getRenderEngine());
Alec Mouri023c1882021-05-08 16:36:33 -0700138 if (mRenderSurface) {
139 mPlanner->setDisplaySize(mRenderSurface->getSize());
140 }
141 } else {
142 mPlanner.reset();
143 }
Alec Mouric773472b2021-05-19 14:29:05 -0700144
145 for (auto* outputLayer : getOutputLayersOrderedByZ()) {
146 if (!outputLayer) {
147 continue;
148 }
149
150 outputLayer->editState().overrideInfo = {};
151 }
Alec Mouri023c1882021-05-08 16:36:33 -0700152}
153
Ady Abrahamdb036a82021-07-16 14:18:34 -0700154void Output::setLayerCachingTexturePoolEnabled(bool enabled) {
155 if (mPlanner) {
156 mPlanner->setTexturePoolEnabled(enabled);
157 }
158}
159
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200160void Output::setProjection(ui::Rotation orientation, const Rect& layerStackSpaceRect,
161 const Rect& orientedDisplaySpaceRect) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700162 auto& outputState = editState();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200163
Angel Aguayob084e0c2021-08-04 23:27:28 +0000164 outputState.displaySpace.setOrientation(orientation);
165 LOG_FATAL_IF(outputState.displaySpace.getBoundsAsRect() == Rect::INVALID_RECT,
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200166 "The display bounds are unknown.");
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200167
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200168 // Compute orientedDisplaySpace
Angel Aguayob084e0c2021-08-04 23:27:28 +0000169 ui::Size orientedSize = outputState.displaySpace.getBounds();
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200170 if (orientation == ui::ROTATION_90 || orientation == ui::ROTATION_270) {
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200171 std::swap(orientedSize.width, orientedSize.height);
172 }
Angel Aguayob084e0c2021-08-04 23:27:28 +0000173 outputState.orientedDisplaySpace.setBounds(orientedSize);
174 outputState.orientedDisplaySpace.setContent(orientedDisplaySpaceRect);
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200175
176 // Compute displaySpace.content
177 const uint32_t transformOrientationFlags = ui::Transform::toRotationFlags(orientation);
178 ui::Transform rotation;
179 if (transformOrientationFlags != ui::Transform::ROT_INVALID) {
Angel Aguayob084e0c2021-08-04 23:27:28 +0000180 const auto displaySize = outputState.displaySpace.getBoundsAsRect();
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200181 rotation.set(transformOrientationFlags, displaySize.width(), displaySize.height());
182 }
Angel Aguayob084e0c2021-08-04 23:27:28 +0000183 outputState.displaySpace.setContent(rotation.transform(orientedDisplaySpaceRect));
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200184
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200185 // Compute framebufferSpace
Angel Aguayob084e0c2021-08-04 23:27:28 +0000186 outputState.framebufferSpace.setOrientation(orientation);
187 LOG_FATAL_IF(outputState.framebufferSpace.getBoundsAsRect() == Rect::INVALID_RECT,
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200188 "The framebuffer bounds are unknown.");
Angel Aguayob084e0c2021-08-04 23:27:28 +0000189 const auto scale = getScale(outputState.displaySpace.getBoundsAsRect(),
190 outputState.framebufferSpace.getBoundsAsRect());
191 outputState.framebufferSpace.setContent(
192 outputState.displaySpace.getContent().scale(scale.x, scale.y));
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200193
194 // Compute layerStackSpace
Angel Aguayob084e0c2021-08-04 23:27:28 +0000195 outputState.layerStackSpace.setContent(layerStackSpaceRect);
196 outputState.layerStackSpace.setBounds(
197 ui::Size(layerStackSpaceRect.getWidth(), layerStackSpaceRect.getHeight()));
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200198
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200199 outputState.transform = outputState.layerStackSpace.getTransform(outputState.displaySpace);
200 outputState.needsFiltering = outputState.transform.needsBilinearFiltering();
Lloyd Pique32cbe282018-10-19 13:09:22 -0700201 dirtyEntireOutput();
202}
203
Alec Mouricdf16792021-12-10 13:16:06 -0800204void Output::setNextBrightness(float brightness) {
205 editState().displayBrightness = brightness;
206}
207
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200208void Output::setDisplaySize(const ui::Size& size) {
Lloyd Pique31cb2942018-10-19 17:23:03 -0700209 mRenderSurface->setDisplaySize(size);
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200210
211 auto& state = editState();
212
213 // Update framebuffer space
Angel Aguayob084e0c2021-08-04 23:27:28 +0000214 const ui::Size newBounds(size);
215 state.framebufferSpace.setBounds(newBounds);
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200216
217 // Update display space
Angel Aguayob084e0c2021-08-04 23:27:28 +0000218 state.displaySpace.setBounds(newBounds);
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200219 state.transform = state.layerStackSpace.getTransform(state.displaySpace);
220
221 // Update oriented display space
Angel Aguayob084e0c2021-08-04 23:27:28 +0000222 const auto orientation = state.displaySpace.getOrientation();
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200223 ui::Size orientedSize = size;
224 if (orientation == ui::ROTATION_90 || orientation == ui::ROTATION_270) {
225 std::swap(orientedSize.width, orientedSize.height);
226 }
Angel Aguayob084e0c2021-08-04 23:27:28 +0000227 const ui::Size newOrientedBounds(orientedSize);
228 state.orientedDisplaySpace.setBounds(newOrientedBounds);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700229
Dan Stoza6166c312021-01-15 16:34:05 -0800230 if (mPlanner) {
231 mPlanner->setDisplaySize(size);
232 }
233
Lloyd Pique32cbe282018-10-19 13:09:22 -0700234 dirtyEntireOutput();
235}
236
Garfield Tan54edd912020-10-21 16:31:41 -0700237ui::Transform::RotationFlags Output::getTransformHint() const {
238 return static_cast<ui::Transform::RotationFlags>(getState().transform.getOrientation());
239}
240
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700241void Output::setLayerFilter(ui::LayerFilter filter) {
242 editState().layerFilter = filter;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700243 dirtyEntireOutput();
244}
245
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800246void Output::setColorTransform(const compositionengine::CompositionRefreshArgs& args) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700247 auto& colorTransformMatrix = editState().colorTransformMatrix;
248 if (!args.colorTransformMatrix || colorTransformMatrix == args.colorTransformMatrix) {
Lloyd Pique77f79a22019-04-29 15:55:40 -0700249 return;
250 }
251
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700252 colorTransformMatrix = *args.colorTransformMatrix;
Lloyd Piqueef958122019-02-05 18:00:12 -0800253
254 dirtyEntireOutput();
Lloyd Pique32cbe282018-10-19 13:09:22 -0700255}
256
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800257void Output::setColorProfile(const ColorProfile& colorProfile) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700258 ui::Dataspace targetDataspace =
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800259 getDisplayColorProfile()->getTargetDataspace(colorProfile.mode, colorProfile.dataspace,
260 colorProfile.colorSpaceAgnosticDataspace);
Lloyd Piquef5275482019-01-29 18:42:42 -0800261
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700262 auto& outputState = editState();
263 if (outputState.colorMode == colorProfile.mode &&
264 outputState.dataspace == colorProfile.dataspace &&
265 outputState.renderIntent == colorProfile.renderIntent &&
266 outputState.targetDataspace == targetDataspace) {
Lloyd Piqueef958122019-02-05 18:00:12 -0800267 return;
268 }
269
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700270 outputState.colorMode = colorProfile.mode;
271 outputState.dataspace = colorProfile.dataspace;
272 outputState.renderIntent = colorProfile.renderIntent;
273 outputState.targetDataspace = targetDataspace;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700274
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800275 mRenderSurface->setBufferDataspace(colorProfile.dataspace);
Lloyd Pique31cb2942018-10-19 17:23:03 -0700276
Lloyd Pique32cbe282018-10-19 13:09:22 -0700277 ALOGV("Set active color mode: %s (%d), active render intent: %s (%d)",
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800278 decodeColorMode(colorProfile.mode).c_str(), colorProfile.mode,
279 decodeRenderIntent(colorProfile.renderIntent).c_str(), colorProfile.renderIntent);
Lloyd Piqueef958122019-02-05 18:00:12 -0800280
281 dirtyEntireOutput();
Lloyd Pique32cbe282018-10-19 13:09:22 -0700282}
283
John Reckac09e452021-04-07 16:35:37 -0400284void Output::setDisplayBrightness(float sdrWhitePointNits, float displayBrightnessNits) {
285 auto& outputState = editState();
286 if (outputState.sdrWhitePointNits == sdrWhitePointNits &&
287 outputState.displayBrightnessNits == displayBrightnessNits) {
288 // Nothing changed
289 return;
290 }
291 outputState.sdrWhitePointNits = sdrWhitePointNits;
292 outputState.displayBrightnessNits = displayBrightnessNits;
293 dirtyEntireOutput();
294}
295
Lloyd Pique32cbe282018-10-19 13:09:22 -0700296void Output::dump(std::string& out) const {
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700297 base::StringAppendF(&out, "Output \"%s\"", mName.c_str());
298 out.append("\n Composition Output State:\n");
Lloyd Pique32cbe282018-10-19 13:09:22 -0700299
300 dumpBase(out);
301}
302
303void Output::dumpBase(std::string& out) const {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700304 dumpState(out);
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700305 out += '\n';
Lloyd Pique31cb2942018-10-19 17:23:03 -0700306
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700307 if (mDisplayColorProfile) {
308 mDisplayColorProfile->dump(out);
309 } else {
310 out.append(" No display color profile!\n");
311 }
312
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700313 out += '\n';
314
Lloyd Pique31cb2942018-10-19 17:23:03 -0700315 if (mRenderSurface) {
316 mRenderSurface->dump(out);
317 } else {
318 out.append(" No render surface!\n");
319 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800320
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700321 base::StringAppendF(&out, "\n %zu Layers\n", getOutputLayerCount());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700322 for (const auto* outputLayer : getOutputLayersOrderedByZ()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800323 if (!outputLayer) {
324 continue;
325 }
326 outputLayer->dump(out);
327 }
Lloyd Pique31cb2942018-10-19 17:23:03 -0700328}
329
Dan Stoza269dc4d2021-01-15 15:07:43 -0800330void Output::dumpPlannerInfo(const Vector<String16>& args, std::string& out) const {
331 if (!mPlanner) {
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700332 out.append("Planner is disabled\n");
Dan Stoza269dc4d2021-01-15 15:07:43 -0800333 return;
334 }
335 base::StringAppendF(&out, "Planner info for display [%s]\n", mName.c_str());
336 mPlanner->dump(args, out);
337}
338
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700339compositionengine::DisplayColorProfile* Output::getDisplayColorProfile() const {
340 return mDisplayColorProfile.get();
341}
342
343void Output::setDisplayColorProfile(std::unique_ptr<compositionengine::DisplayColorProfile> mode) {
344 mDisplayColorProfile = std::move(mode);
345}
346
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800347const Output::ReleasedLayers& Output::getReleasedLayersForTest() const {
348 return mReleasedLayers;
349}
350
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700351void Output::setDisplayColorProfileForTest(
352 std::unique_ptr<compositionengine::DisplayColorProfile> mode) {
353 mDisplayColorProfile = std::move(mode);
354}
355
Lloyd Pique31cb2942018-10-19 17:23:03 -0700356compositionengine::RenderSurface* Output::getRenderSurface() const {
357 return mRenderSurface.get();
358}
359
360void Output::setRenderSurface(std::unique_ptr<compositionengine::RenderSurface> surface) {
361 mRenderSurface = std::move(surface);
Dan Stoza6166c312021-01-15 16:34:05 -0800362 const auto size = mRenderSurface->getSize();
Angel Aguayob084e0c2021-08-04 23:27:28 +0000363 editState().framebufferSpace.setBounds(size);
Dan Stoza6166c312021-01-15 16:34:05 -0800364 if (mPlanner) {
365 mPlanner->setDisplaySize(size);
366 }
Lloyd Pique31cb2942018-10-19 17:23:03 -0700367 dirtyEntireOutput();
368}
369
Vishnu Nair9b079a22020-01-21 14:36:08 -0800370void Output::cacheClientCompositionRequests(uint32_t cacheSize) {
371 if (cacheSize == 0) {
372 mClientCompositionRequestCache.reset();
373 } else {
374 mClientCompositionRequestCache = std::make_unique<ClientCompositionRequestCache>(cacheSize);
375 }
376};
377
Lloyd Pique31cb2942018-10-19 17:23:03 -0700378void Output::setRenderSurfaceForTest(std::unique_ptr<compositionengine::RenderSurface> surface) {
379 mRenderSurface = std::move(surface);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700380}
381
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700382Region Output::getDirtyRegion() const {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700383 const auto& outputState = getState();
Angel Aguayob084e0c2021-08-04 23:27:28 +0000384 return outputState.dirtyRegion.intersect(outputState.layerStackSpace.getContent());
Lloyd Pique32cbe282018-10-19 13:09:22 -0700385}
386
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700387bool Output::includesLayer(ui::LayerFilter filter) const {
388 return getState().layerFilter.includes(filter);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700389}
390
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700391bool Output::includesLayer(const sp<LayerFE>& layerFE) const {
Lloyd Piquede196652020-01-22 17:29:58 -0800392 const auto* layerFEState = layerFE->getCompositionState();
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700393 return layerFEState && includesLayer(layerFEState->outputFilter);
Lloyd Pique66c20c42019-03-07 21:44:02 -0800394}
395
Lloyd Piquedf336d92019-03-07 21:38:42 -0800396std::unique_ptr<compositionengine::OutputLayer> Output::createOutputLayer(
Lloyd Piquede196652020-01-22 17:29:58 -0800397 const sp<LayerFE>& layerFE) const {
398 return impl::createOutputLayer(*this, layerFE);
Lloyd Piquecc01a452018-12-04 17:24:00 -0800399}
400
Lloyd Piquede196652020-01-22 17:29:58 -0800401compositionengine::OutputLayer* Output::getOutputLayerForLayer(const sp<LayerFE>& layerFE) const {
402 auto index = findCurrentOutputLayerForLayer(layerFE);
Lloyd Pique01c77c12019-04-17 12:48:32 -0700403 return index ? getOutputLayerOrderedByZByIndex(*index) : nullptr;
Lloyd Piquecc01a452018-12-04 17:24:00 -0800404}
405
Lloyd Pique01c77c12019-04-17 12:48:32 -0700406std::optional<size_t> Output::findCurrentOutputLayerForLayer(
Lloyd Piquede196652020-01-22 17:29:58 -0800407 const sp<compositionengine::LayerFE>& layer) const {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700408 for (size_t i = 0; i < getOutputLayerCount(); i++) {
409 auto outputLayer = getOutputLayerOrderedByZByIndex(i);
Lloyd Piquede196652020-01-22 17:29:58 -0800410 if (outputLayer && &outputLayer->getLayerFE() == layer.get()) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700411 return i;
412 }
413 }
414 return std::nullopt;
Lloyd Piquecc01a452018-12-04 17:24:00 -0800415}
416
Lloyd Piquec7ef21b2019-01-29 18:43:00 -0800417void Output::setReleasedLayers(Output::ReleasedLayers&& layers) {
418 mReleasedLayers = std::move(layers);
419}
420
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800421void Output::prepare(const compositionengine::CompositionRefreshArgs& refreshArgs,
422 LayerFESet& geomSnapshots) {
423 ATRACE_CALL();
424 ALOGV(__FUNCTION__);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800425
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800426 rebuildLayerStacks(refreshArgs, geomSnapshots);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800427}
428
Lloyd Piqued7b429f2019-03-07 21:11:02 -0800429void Output::present(const compositionengine::CompositionRefreshArgs& refreshArgs) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800430 ATRACE_CALL();
431 ALOGV(__FUNCTION__);
432
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800433 updateColorProfile(refreshArgs);
Dan Stoza269dc4d2021-01-15 15:07:43 -0800434 updateCompositionState(refreshArgs);
435 planComposition();
436 writeCompositionState(refreshArgs);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800437 setColorTransform(refreshArgs);
Lloyd Piqued7b429f2019-03-07 21:11:02 -0800438 beginFrame();
Vishnu Naira3140382022-02-24 14:07:11 -0800439
440 GpuCompositionResult result;
441 const bool predictCompositionStrategy = canPredictCompositionStrategy(refreshArgs);
442 if (predictCompositionStrategy) {
443 result = prepareFrameAsync(refreshArgs);
444 } else {
445 prepareFrame();
446 }
447
Lloyd Piqued7b429f2019-03-07 21:11:02 -0800448 devOptRepaintFlash(refreshArgs);
Vishnu Naira3140382022-02-24 14:07:11 -0800449 finishFrame(refreshArgs, std::move(result));
Lloyd Piqued7b429f2019-03-07 21:11:02 -0800450 postFramebuffer();
Alec Mouriaa831582021-06-07 16:23:01 -0700451 renderCachedSets(refreshArgs);
Lloyd Piqued7b429f2019-03-07 21:11:02 -0800452}
453
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800454void Output::rebuildLayerStacks(const compositionengine::CompositionRefreshArgs& refreshArgs,
455 LayerFESet& layerFESet) {
456 ATRACE_CALL();
457 ALOGV(__FUNCTION__);
458
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700459 auto& outputState = editState();
460
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800461 // Do nothing if this output is not enabled or there is no need to perform this update
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700462 if (!outputState.isEnabled || CC_LIKELY(!refreshArgs.updatingOutputGeometryThisFrame)) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800463 return;
464 }
465
466 // Process the layers to determine visibility and coverage
467 compositionengine::Output::CoverageState coverage{layerFESet};
468 collectVisibleLayers(refreshArgs, coverage);
469
470 // Compute the resulting coverage for this output, and store it for later
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700471 const ui::Transform& tr = outputState.transform;
Angel Aguayob084e0c2021-08-04 23:27:28 +0000472 Region undefinedRegion{outputState.displaySpace.getBoundsAsRect()};
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800473 undefinedRegion.subtractSelf(tr.transform(coverage.aboveOpaqueLayers));
474
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700475 outputState.undefinedRegion = undefinedRegion;
476 outputState.dirtyRegion.orSelf(coverage.dirtyRegion);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800477}
478
479void Output::collectVisibleLayers(const compositionengine::CompositionRefreshArgs& refreshArgs,
480 compositionengine::Output::CoverageState& coverage) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800481 // Evaluate the layers from front to back to determine what is visible. This
482 // also incrementally calculates the coverage information for each layer as
483 // well as the entire output.
Lloyd Piquede196652020-01-22 17:29:58 -0800484 for (auto layer : reversed(refreshArgs.layers)) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700485 // Incrementally process the coverage for each layer
486 ensureOutputLayerIfVisible(layer, coverage);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800487
488 // TODO(b/121291683): Stop early if the output is completely covered and
489 // no more layers could even be visible underneath the ones on top.
490 }
491
Lloyd Pique01c77c12019-04-17 12:48:32 -0700492 setReleasedLayers(refreshArgs);
493
494 finalizePendingOutputLayers();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800495}
496
Lloyd Piquede196652020-01-22 17:29:58 -0800497void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE,
Lloyd Pique01c77c12019-04-17 12:48:32 -0700498 compositionengine::Output::CoverageState& coverage) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800499 // Ensure we have a snapshot of the basic geometry layer state. Limit the
500 // snapshots to once per frame for each candidate layer, as layers may
501 // appear on multiple outputs.
502 if (!coverage.latchedLayers.count(layerFE)) {
503 coverage.latchedLayers.insert(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800504 }
505
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700506 // Only consider the layers on this output
507 if (!includesLayer(layerFE)) {
Lloyd Piquede196652020-01-22 17:29:58 -0800508 return;
509 }
510
511 // Obtain a read-only pointer to the front-end layer state
512 const auto* layerFEState = layerFE->getCompositionState();
513 if (CC_UNLIKELY(!layerFEState)) {
514 return;
515 }
516
517 // handle hidden surfaces by setting the visible region to empty
518 if (CC_UNLIKELY(!layerFEState->isVisible)) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700519 return;
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800520 }
521
522 /*
523 * opaqueRegion: area of a surface that is fully opaque.
524 */
525 Region opaqueRegion;
526
527 /*
528 * visibleRegion: area of a surface that is visible on screen and not fully
529 * transparent. This is essentially the layer's footprint minus the opaque
530 * regions above it. Areas covered by a translucent surface are considered
531 * visible.
532 */
533 Region visibleRegion;
534
535 /*
536 * coveredRegion: area of a surface that is covered by all visible regions
537 * above it (which includes the translucent areas).
538 */
539 Region coveredRegion;
540
541 /*
542 * transparentRegion: area of a surface that is hinted to be completely
Leon Scroggins III9a0afda2022-01-11 16:53:09 -0500543 * transparent.
544 * This is used to tell when the layer has no visible non-transparent
545 * regions and can be removed from the layer list. It does not affect the
546 * visibleRegion of this layer or any layers beneath it. The hint may not
547 * be correct if apps don't respect the SurfaceView restrictions (which,
548 * sadly, some don't).
549 *
550 * In addition, it is used on DISPLAY_DECORATION layers to specify the
551 * blockingRegion, allowing the DPU to skip it to save power. Once we have
552 * hardware that supports a blockingRegion on frames with AFBC, it may be
553 * useful to use this for other layers, too, so long as we can prevent
554 * regressions on b/7179570.
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800555 */
556 Region transparentRegion;
557
Vishnu Naira483b4a2019-12-12 15:07:52 -0800558 /*
559 * shadowRegion: Region cast by the layer's shadow.
560 */
561 Region shadowRegion;
562
Lloyd Piquede196652020-01-22 17:29:58 -0800563 const ui::Transform& tr = layerFEState->geomLayerTransform;
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800564
565 // Get the visible region
566 // TODO(b/121291683): Is it worth creating helper methods on LayerFEState
567 // for computations like this?
Lloyd Piquede196652020-01-22 17:29:58 -0800568 const Rect visibleRect(tr.transform(layerFEState->geomLayerBounds));
Vishnu Naira483b4a2019-12-12 15:07:52 -0800569 visibleRegion.set(visibleRect);
570
Lloyd Piquede196652020-01-22 17:29:58 -0800571 if (layerFEState->shadowRadius > 0.0f) {
Vishnu Naira483b4a2019-12-12 15:07:52 -0800572 // if the layer casts a shadow, offset the layers visible region and
573 // calculate the shadow region.
Lloyd Piquede196652020-01-22 17:29:58 -0800574 const auto inset = static_cast<int32_t>(ceilf(layerFEState->shadowRadius) * -1.0f);
Vishnu Naira483b4a2019-12-12 15:07:52 -0800575 Rect visibleRectWithShadows(visibleRect);
576 visibleRectWithShadows.inset(inset, inset, inset, inset);
577 visibleRegion.set(visibleRectWithShadows);
578 shadowRegion = visibleRegion.subtract(visibleRect);
579 }
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800580
581 if (visibleRegion.isEmpty()) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700582 return;
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800583 }
584
585 // Remove the transparent area from the visible region
Lloyd Piquede196652020-01-22 17:29:58 -0800586 if (!layerFEState->isOpaque) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800587 if (tr.preserveRects()) {
Alec Mourie60f0b92022-06-10 19:15:20 +0000588 // Clip the transparent region to geomLayerBounds first
589 // The transparent region may be influenced by applications, for
590 // instance, by overriding ViewGroup#gatherTransparentRegion with a
591 // custom view. Once the layer stack -> display mapping is known, we
592 // must guard against very wrong inputs to prevent underflow or
593 // overflow errors. We do this here by constraining the transparent
594 // region to be within the pre-transform layer bounds, since the
595 // layer bounds are expected to play nicely with the full
596 // transform.
597 const Region clippedTransparentRegionHint =
598 layerFEState->transparentRegionHint.intersect(
599 Rect(layerFEState->geomLayerBounds));
600
601 if (clippedTransparentRegionHint.isEmpty()) {
602 if (!layerFEState->transparentRegionHint.isEmpty()) {
603 ALOGD("Layer: %s had an out of bounds transparent region",
604 layerFE->getDebugName());
605 layerFEState->transparentRegionHint.dump("transparentRegionHint");
606 }
607 transparentRegion.clear();
608 } else {
609 transparentRegion = tr.transform(clippedTransparentRegionHint);
610 }
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800611 } else {
612 // transformation too complex, can't do the
613 // transparent region optimization.
614 transparentRegion.clear();
615 }
616 }
617
618 // compute the opaque region
Lloyd Pique0a456232020-01-16 17:51:13 -0800619 const auto layerOrientation = tr.getOrientation();
Lloyd Piquede196652020-01-22 17:29:58 -0800620 if (layerFEState->isOpaque && ((layerOrientation & ui::Transform::ROT_INVALID) == 0)) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800621 // If we one of the simple category of transforms (0/90/180/270 rotation
622 // + any flip), then the opaque region is the layer's footprint.
623 // Otherwise we don't try and compute the opaque region since there may
624 // be errors at the edges, and we treat the entire layer as
625 // translucent.
Vishnu Naira483b4a2019-12-12 15:07:52 -0800626 opaqueRegion.set(visibleRect);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800627 }
628
629 // Clip the covered region to the visible region
630 coveredRegion = coverage.aboveCoveredLayers.intersect(visibleRegion);
631
632 // Update accumAboveCoveredLayers for next (lower) layer
633 coverage.aboveCoveredLayers.orSelf(visibleRegion);
634
635 // subtract the opaque region covered by the layers above us
636 visibleRegion.subtractSelf(coverage.aboveOpaqueLayers);
637
638 if (visibleRegion.isEmpty()) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700639 return;
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800640 }
641
642 // Get coverage information for the layer as previously displayed,
643 // also taking over ownership from mOutputLayersorderedByZ.
Lloyd Piquede196652020-01-22 17:29:58 -0800644 auto prevOutputLayerIndex = findCurrentOutputLayerForLayer(layerFE);
Lloyd Pique01c77c12019-04-17 12:48:32 -0700645 auto prevOutputLayer =
646 prevOutputLayerIndex ? getOutputLayerOrderedByZByIndex(*prevOutputLayerIndex) : nullptr;
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800647
648 // Get coverage information for the layer as previously displayed
649 // TODO(b/121291683): Define kEmptyRegion as a constant in Region.h
650 const Region kEmptyRegion;
651 const Region& oldVisibleRegion =
652 prevOutputLayer ? prevOutputLayer->getState().visibleRegion : kEmptyRegion;
653 const Region& oldCoveredRegion =
654 prevOutputLayer ? prevOutputLayer->getState().coveredRegion : kEmptyRegion;
655
656 // compute this layer's dirty region
657 Region dirty;
Lloyd Piquede196652020-01-22 17:29:58 -0800658 if (layerFEState->contentDirty) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800659 // we need to invalidate the whole region
660 dirty = visibleRegion;
661 // as well, as the old visible region
662 dirty.orSelf(oldVisibleRegion);
663 } else {
664 /* compute the exposed region:
665 * the exposed region consists of two components:
666 * 1) what's VISIBLE now and was COVERED before
667 * 2) what's EXPOSED now less what was EXPOSED before
668 *
669 * note that (1) is conservative, we start with the whole visible region
670 * but only keep what used to be covered by something -- which mean it
671 * may have been exposed.
672 *
673 * (2) handles areas that were not covered by anything but got exposed
674 * because of a resize.
675 *
676 */
677 const Region newExposed = visibleRegion - coveredRegion;
678 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
679 dirty = (visibleRegion & oldCoveredRegion) | (newExposed - oldExposed);
680 }
681 dirty.subtractSelf(coverage.aboveOpaqueLayers);
682
683 // accumulate to the screen dirty region
684 coverage.dirtyRegion.orSelf(dirty);
685
686 // Update accumAboveOpaqueLayers for next (lower) layer
687 coverage.aboveOpaqueLayers.orSelf(opaqueRegion);
688
689 // Compute the visible non-transparent region
690 Region visibleNonTransparentRegion = visibleRegion.subtract(transparentRegion);
691
Vishnu Naira483b4a2019-12-12 15:07:52 -0800692 // Perform the final check to see if this layer is visible on this output
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800693 // TODO(b/121291683): Why does this not use visibleRegion? (see outputSpaceVisibleRegion below)
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700694 const auto& outputState = getState();
695 Region drawRegion(outputState.transform.transform(visibleNonTransparentRegion));
Angel Aguayob084e0c2021-08-04 23:27:28 +0000696 drawRegion.andSelf(outputState.displaySpace.getBoundsAsRect());
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800697 if (drawRegion.isEmpty()) {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700698 return;
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800699 }
700
Vishnu Naira483b4a2019-12-12 15:07:52 -0800701 Region visibleNonShadowRegion = visibleRegion.subtract(shadowRegion);
702
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800703 // The layer is visible. Either reuse the existing outputLayer if we have
704 // one, or create a new one if we do not.
Lloyd Piquede196652020-01-22 17:29:58 -0800705 auto result = ensureOutputLayer(prevOutputLayerIndex, layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800706
707 // Store the layer coverage information into the layer state as some of it
708 // is useful later.
709 auto& outputLayerState = result->editState();
710 outputLayerState.visibleRegion = visibleRegion;
711 outputLayerState.visibleNonTransparentRegion = visibleNonTransparentRegion;
712 outputLayerState.coveredRegion = coveredRegion;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200713 outputLayerState.outputSpaceVisibleRegion = outputState.transform.transform(
Angel Aguayob084e0c2021-08-04 23:27:28 +0000714 visibleNonShadowRegion.intersect(outputState.layerStackSpace.getContent()));
Vishnu Naira483b4a2019-12-12 15:07:52 -0800715 outputLayerState.shadowRegion = shadowRegion;
Leon Scroggins III9a0afda2022-01-11 16:53:09 -0500716 outputLayerState.outputSpaceBlockingRegionHint =
Leon Scroggins III7f7ad2c2022-03-17 17:06:20 -0400717 layerFEState->compositionType == Composition::DISPLAY_DECORATION
718 ? outputState.transform.transform(
719 transparentRegion.intersect(outputState.layerStackSpace.getContent()))
720 : Region();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800721}
722
723void Output::setReleasedLayers(const compositionengine::CompositionRefreshArgs&) {
724 // The base class does nothing with this call.
725}
726
Dan Stoza269dc4d2021-01-15 15:07:43 -0800727void Output::updateCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800728 ATRACE_CALL();
729 ALOGV(__FUNCTION__);
730
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800731 if (!getState().isEnabled) {
732 return;
733 }
734
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800735 mLayerRequestingBackgroundBlur = findLayerRequestingBackgroundComposition();
736 bool forceClientComposition = mLayerRequestingBackgroundBlur != nullptr;
737
Lloyd Pique01c77c12019-04-17 12:48:32 -0700738 for (auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Pique7a234912019-10-03 11:54:27 -0700739 layer->updateCompositionState(refreshArgs.updatingGeometryThisFrame,
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800740 refreshArgs.devOptForceClientComposition ||
Snild Dolkow9e217d62020-04-22 15:53:42 +0200741 forceClientComposition,
742 refreshArgs.internalDisplayRotationFlags);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800743
744 if (mLayerRequestingBackgroundBlur == layer) {
745 forceClientComposition = false;
746 }
Dan Stoza269dc4d2021-01-15 15:07:43 -0800747 }
Tianhao Yao67dd7122022-02-22 17:48:33 +0000748
749 updateCompositionStateForBorder(refreshArgs);
750}
751
752void Output::updateCompositionStateForBorder(
753 const compositionengine::CompositionRefreshArgs& refreshArgs) {
754 std::unordered_map<int32_t, const Region*> layerVisibleRegionMap;
755 // Store a map of layerId to their computed visible region.
756 for (auto* layer : getOutputLayersOrderedByZ()) {
757 int layerId = (layer->getLayerFE()).getSequence();
758 layerVisibleRegionMap[layerId] = &((layer->getState()).visibleRegion);
759 }
760 OutputCompositionState& outputCompositionState = editState();
761 outputCompositionState.borderInfoList.clear();
762 bool clientComposeTopLayer = false;
763 for (const auto& borderInfo : refreshArgs.borderInfoList) {
764 renderengine::BorderRenderInfo info;
765 for (const auto& id : borderInfo.layerIds) {
766 info.combinedRegion.orSelf(*(layerVisibleRegionMap[id]));
767 }
Tianhao Yao10cea3c2022-03-30 01:37:22 +0000768
769 if (!info.combinedRegion.isEmpty()) {
770 info.width = borderInfo.width;
771 info.color = borderInfo.color;
772 outputCompositionState.borderInfoList.emplace_back(std::move(info));
773 clientComposeTopLayer = true;
774 }
Tianhao Yao67dd7122022-02-22 17:48:33 +0000775 }
776
777 // In this situation we must client compose the top layer instead of using hwc
778 // because we want to draw the border above all else.
779 // This could potentially cause a bit of a performance regression if the top
780 // layer would have been rendered using hwc originally.
781 // TODO(b/227656283): Measure system's performance before enabling the border feature
782 if (clientComposeTopLayer) {
783 auto topLayer = getOutputLayerOrderedByZByIndex(getOutputLayerCount() - 1);
784 (topLayer->editState()).forceClientComposition = true;
785 }
Dan Stoza269dc4d2021-01-15 15:07:43 -0800786}
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800787
Dan Stoza269dc4d2021-01-15 15:07:43 -0800788void Output::planComposition() {
789 if (!mPlanner || !getState().isEnabled) {
790 return;
791 }
792
793 ATRACE_CALL();
794 ALOGV(__FUNCTION__);
795
796 mPlanner->plan(getOutputLayersOrderedByZ());
797}
798
799void Output::writeCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {
800 ATRACE_CALL();
801 ALOGV(__FUNCTION__);
802
803 if (!getState().isEnabled) {
804 return;
805 }
806
Ady Abraham3645e642021-04-20 18:39:00 -0700807 editState().earliestPresentTime = refreshArgs.earliestPresentTime;
Ady Abrahamec7aa8a2021-06-28 12:37:09 -0700808 editState().previousPresentFence = refreshArgs.previousPresentFence;
Ady Abraham43065bd2021-12-10 17:22:15 -0800809 editState().expectedPresentTime = refreshArgs.expectedPresentTime;
Ady Abraham3645e642021-04-20 18:39:00 -0700810
Leon Scroggins III2e74a4c2021-04-09 13:41:14 -0400811 compositionengine::OutputLayer* peekThroughLayer = nullptr;
Dan Stoza6166c312021-01-15 16:34:05 -0800812 sp<GraphicBuffer> previousOverride = nullptr;
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400813 bool includeGeometry = refreshArgs.updatingGeometryThisFrame;
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400814 uint32_t z = 0;
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400815 bool overrideZ = false;
Robert Carrec8ccca2022-05-04 09:36:14 -0700816 uint64_t outputLayerHash = 0;
Dan Stoza269dc4d2021-01-15 15:07:43 -0800817 for (auto* layer : getOutputLayersOrderedByZ()) {
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400818 if (layer == peekThroughLayer) {
819 // No longer needed, although it should not show up again, so
820 // resetting it is not truly needed either.
821 peekThroughLayer = nullptr;
822
823 // peekThroughLayer was already drawn ahead of its z order.
824 continue;
825 }
Dan Stoza6166c312021-01-15 16:34:05 -0800826 bool skipLayer = false;
Leon Scroggins IIId305ef22021-04-06 09:53:26 -0400827 const auto& overrideInfo = layer->getState().overrideInfo;
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400828 if (overrideInfo.buffer != nullptr) {
829 if (previousOverride && overrideInfo.buffer->getBuffer() == previousOverride) {
Dan Stoza6166c312021-01-15 16:34:05 -0800830 ALOGV("Skipping redundant buffer");
831 skipLayer = true;
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400832 } else {
833 // First layer with the override buffer.
834 if (overrideInfo.peekThroughLayer) {
835 peekThroughLayer = overrideInfo.peekThroughLayer;
Leon Scroggins IIId305ef22021-04-06 09:53:26 -0400836
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400837 // Draw peekThroughLayer first.
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400838 overrideZ = true;
839 includeGeometry = true;
840 constexpr bool isPeekingThrough = true;
841 peekThroughLayer->writeStateToHWC(includeGeometry, false, z++, overrideZ,
842 isPeekingThrough);
Robert Carrec8ccca2022-05-04 09:36:14 -0700843 outputLayerHash ^= android::hashCombine(
844 reinterpret_cast<uint64_t>(&peekThroughLayer->getLayerFE()),
845 z, includeGeometry, overrideZ, isPeekingThrough,
846 peekThroughLayer->requiresClientComposition());
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400847 }
848
849 previousOverride = overrideInfo.buffer->getBuffer();
Dan Stoza6166c312021-01-15 16:34:05 -0800850 }
Dan Stoza6166c312021-01-15 16:34:05 -0800851 }
852
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400853 constexpr bool isPeekingThrough = false;
854 layer->writeStateToHWC(includeGeometry, skipLayer, z++, overrideZ, isPeekingThrough);
Robert Carrec8ccca2022-05-04 09:36:14 -0700855 if (!skipLayer) {
856 outputLayerHash ^= android::hashCombine(
857 reinterpret_cast<uint64_t>(&layer->getLayerFE()),
858 z, includeGeometry, overrideZ, isPeekingThrough,
859 layer->requiresClientComposition());
860 }
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800861 }
Robert Carrec8ccca2022-05-04 09:36:14 -0700862 editState().outputLayerHash = outputLayerHash;
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800863}
864
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800865compositionengine::OutputLayer* Output::findLayerRequestingBackgroundComposition() const {
866 compositionengine::OutputLayer* layerRequestingBgComposition = nullptr;
867 for (auto* layer : getOutputLayersOrderedByZ()) {
Galia Peycheva66eaf4a2020-11-09 13:17:57 +0100868 auto* compState = layer->getLayerFE().getCompositionState();
869
870 // If any layer has a sideband stream, we will disable blurs. In that case, we don't
871 // want to force client composition because of the blur.
872 if (compState->sidebandStream != nullptr) {
873 return nullptr;
874 }
Lucas Dupin084a6d42021-08-26 22:10:29 +0000875 if (compState->isOpaque) {
876 continue;
877 }
Galia Peycheva66eaf4a2020-11-09 13:17:57 +0100878 if (compState->backgroundBlurRadius > 0 || compState->blurRegions.size() > 0) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800879 layerRequestingBgComposition = layer;
880 }
881 }
882 return layerRequestingBgComposition;
883}
884
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800885void Output::updateColorProfile(const compositionengine::CompositionRefreshArgs& refreshArgs) {
886 setColorProfile(pickColorProfile(refreshArgs));
887}
888
889// Returns a data space that fits all visible layers. The returned data space
890// can only be one of
891// - Dataspace::SRGB (use legacy dataspace and let HWC saturate when colors are enhanced)
892// - Dataspace::DISPLAY_P3
893// - Dataspace::DISPLAY_BT2020
894// The returned HDR data space is one of
895// - Dataspace::UNKNOWN
896// - Dataspace::BT2020_HLG
897// - Dataspace::BT2020_PQ
898ui::Dataspace Output::getBestDataspace(ui::Dataspace* outHdrDataSpace,
899 bool* outIsHdrClientComposition) const {
900 ui::Dataspace bestDataSpace = ui::Dataspace::V0_SRGB;
901 *outHdrDataSpace = ui::Dataspace::UNKNOWN;
902
Vishnu Naire14c6b32022-08-06 04:20:15 +0000903 // An Output's layers may be stale when it is disabled. As a consequence, the layers returned by
904 // getOutputLayersOrderedByZ may not be in a valid state and it is not safe to access their
905 // properties. Return a default dataspace value in this case.
906 if (!getState().isEnabled) {
907 return ui::Dataspace::V0_SRGB;
908 }
909
Lloyd Pique01c77c12019-04-17 12:48:32 -0700910 for (const auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Piquede196652020-01-22 17:29:58 -0800911 switch (layer->getLayerFE().getCompositionState()->dataspace) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800912 case ui::Dataspace::V0_SCRGB:
913 case ui::Dataspace::V0_SCRGB_LINEAR:
914 case ui::Dataspace::BT2020:
915 case ui::Dataspace::BT2020_ITU:
916 case ui::Dataspace::BT2020_LINEAR:
917 case ui::Dataspace::DISPLAY_BT2020:
918 bestDataSpace = ui::Dataspace::DISPLAY_BT2020;
919 break;
920 case ui::Dataspace::DISPLAY_P3:
921 bestDataSpace = ui::Dataspace::DISPLAY_P3;
922 break;
923 case ui::Dataspace::BT2020_PQ:
924 case ui::Dataspace::BT2020_ITU_PQ:
925 bestDataSpace = ui::Dataspace::DISPLAY_P3;
926 *outHdrDataSpace = ui::Dataspace::BT2020_PQ;
Lloyd Piquede196652020-01-22 17:29:58 -0800927 *outIsHdrClientComposition =
928 layer->getLayerFE().getCompositionState()->forceClientComposition;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800929 break;
930 case ui::Dataspace::BT2020_HLG:
931 case ui::Dataspace::BT2020_ITU_HLG:
932 bestDataSpace = ui::Dataspace::DISPLAY_P3;
933 // When there's mixed PQ content and HLG content, we set the HDR
934 // data space to be BT2020_PQ and convert HLG to PQ.
935 if (*outHdrDataSpace == ui::Dataspace::UNKNOWN) {
936 *outHdrDataSpace = ui::Dataspace::BT2020_HLG;
937 }
938 break;
939 default:
940 break;
941 }
942 }
943
944 return bestDataSpace;
945}
946
947compositionengine::Output::ColorProfile Output::pickColorProfile(
948 const compositionengine::CompositionRefreshArgs& refreshArgs) const {
949 if (refreshArgs.outputColorSetting == OutputColorSetting::kUnmanaged) {
950 return ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
951 ui::RenderIntent::COLORIMETRIC,
952 refreshArgs.colorSpaceAgnosticDataspace};
953 }
954
955 ui::Dataspace hdrDataSpace;
956 bool isHdrClientComposition = false;
957 ui::Dataspace bestDataSpace = getBestDataspace(&hdrDataSpace, &isHdrClientComposition);
958
959 switch (refreshArgs.forceOutputColorMode) {
960 case ui::ColorMode::SRGB:
961 bestDataSpace = ui::Dataspace::V0_SRGB;
962 break;
963 case ui::ColorMode::DISPLAY_P3:
964 bestDataSpace = ui::Dataspace::DISPLAY_P3;
965 break;
966 default:
967 break;
968 }
969
970 // respect hdrDataSpace only when there is no legacy HDR support
971 const bool isHdr = hdrDataSpace != ui::Dataspace::UNKNOWN &&
972 !mDisplayColorProfile->hasLegacyHdrSupport(hdrDataSpace) && !isHdrClientComposition;
973 if (isHdr) {
974 bestDataSpace = hdrDataSpace;
975 }
976
977 ui::RenderIntent intent;
978 switch (refreshArgs.outputColorSetting) {
979 case OutputColorSetting::kManaged:
980 case OutputColorSetting::kUnmanaged:
981 intent = isHdr ? ui::RenderIntent::TONE_MAP_COLORIMETRIC
982 : ui::RenderIntent::COLORIMETRIC;
983 break;
984 case OutputColorSetting::kEnhanced:
985 intent = isHdr ? ui::RenderIntent::TONE_MAP_ENHANCE : ui::RenderIntent::ENHANCE;
986 break;
987 default: // vendor display color setting
988 intent = static_cast<ui::RenderIntent>(refreshArgs.outputColorSetting);
989 break;
990 }
991
992 ui::ColorMode outMode;
993 ui::Dataspace outDataSpace;
994 ui::RenderIntent outRenderIntent;
995 mDisplayColorProfile->getBestColorMode(bestDataSpace, intent, &outDataSpace, &outMode,
996 &outRenderIntent);
997
998 return ColorProfile{outMode, outDataSpace, outRenderIntent,
999 refreshArgs.colorSpaceAgnosticDataspace};
1000}
1001
Lloyd Piqued0a92a02019-02-19 17:47:26 -08001002void Output::beginFrame() {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001003 auto& outputState = editState();
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001004 const bool dirty = !getDirtyRegion().isEmpty();
Lloyd Pique01c77c12019-04-17 12:48:32 -07001005 const bool empty = getOutputLayerCount() == 0;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001006 const bool wasEmpty = !outputState.lastCompositionHadVisibleLayers;
Lloyd Piqued0a92a02019-02-19 17:47:26 -08001007
1008 // If nothing has changed (!dirty), don't recompose.
1009 // If something changed, but we don't currently have any visible layers,
1010 // and didn't when we last did a composition, then skip it this time.
1011 // The second rule does two things:
1012 // - When all layers are removed from a display, we'll emit one black
1013 // frame, then nothing more until we get new layers.
1014 // - When a display is created with a private layer stack, we won't
1015 // emit any black frames until a layer is added to the layer stack.
Chavi Weingarten09fa1d62022-08-17 21:57:04 +00001016 mMustRecompose = dirty && !(empty && wasEmpty);
Lloyd Piqued0a92a02019-02-19 17:47:26 -08001017
1018 const char flagPrefix[] = {'-', '+'};
1019 static_cast<void>(flagPrefix);
Chavi Weingarten09fa1d62022-08-17 21:57:04 +00001020 ALOGV("%s: %s composition for %s (%cdirty %cempty %cwasEmpty)", __func__,
1021 mMustRecompose ? "doing" : "skipping", getName().c_str(), flagPrefix[dirty],
1022 flagPrefix[empty], flagPrefix[wasEmpty]);
Lloyd Piqued0a92a02019-02-19 17:47:26 -08001023
Chavi Weingarten09fa1d62022-08-17 21:57:04 +00001024 mRenderSurface->beginFrame(mMustRecompose);
Lloyd Piqued0a92a02019-02-19 17:47:26 -08001025
Chavi Weingarten09fa1d62022-08-17 21:57:04 +00001026 if (mMustRecompose) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001027 outputState.lastCompositionHadVisibleLayers = !empty;
Lloyd Piqued0a92a02019-02-19 17:47:26 -08001028 }
1029}
1030
Lloyd Pique66d68602019-02-13 14:23:31 -08001031void Output::prepareFrame() {
1032 ATRACE_CALL();
1033 ALOGV(__FUNCTION__);
1034
Vishnu Naira3140382022-02-24 14:07:11 -08001035 auto& outputState = editState();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001036 if (!outputState.isEnabled) {
Lloyd Pique66d68602019-02-13 14:23:31 -08001037 return;
1038 }
1039
Vishnu Naira3140382022-02-24 14:07:11 -08001040 std::optional<android::HWComposer::DeviceRequestedChanges> changes;
1041 bool success = chooseCompositionStrategy(&changes);
1042 resetCompositionStrategy();
Vishnu Nair9cf89262022-02-26 09:17:49 -08001043 outputState.strategyPrediction = CompositionStrategyPredictionState::DISABLED;
Vishnu Naira3140382022-02-24 14:07:11 -08001044 outputState.previousDeviceRequestedChanges = changes;
1045 outputState.previousDeviceRequestedSuccess = success;
1046 if (success) {
1047 applyCompositionStrategy(changes);
1048 }
1049 finishPrepareFrame();
1050}
Lloyd Pique66d68602019-02-13 14:23:31 -08001051
Vishnu Naira3140382022-02-24 14:07:11 -08001052std::future<bool> Output::chooseCompositionStrategyAsync(
1053 std::optional<android::HWComposer::DeviceRequestedChanges>* changes) {
1054 return mHwComposerAsyncWorker->send(
1055 [&, changes]() { return chooseCompositionStrategy(changes); });
1056}
1057
1058GpuCompositionResult Output::prepareFrameAsync(const CompositionRefreshArgs& refreshArgs) {
1059 ATRACE_CALL();
1060 ALOGV(__FUNCTION__);
1061 auto& state = editState();
1062 const auto& previousChanges = state.previousDeviceRequestedChanges;
1063 std::optional<android::HWComposer::DeviceRequestedChanges> changes;
1064 resetCompositionStrategy();
1065 auto hwcResult = chooseCompositionStrategyAsync(&changes);
1066 if (state.previousDeviceRequestedSuccess) {
1067 applyCompositionStrategy(previousChanges);
1068 }
1069 finishPrepareFrame();
1070
1071 base::unique_fd bufferFence;
1072 std::shared_ptr<renderengine::ExternalTexture> buffer;
1073 updateProtectedContentState();
1074 const bool dequeueSucceeded = dequeueRenderBuffer(&bufferFence, &buffer);
1075 GpuCompositionResult compositionResult;
1076 if (dequeueSucceeded) {
1077 std::optional<base::unique_fd> optFd =
1078 composeSurfaces(Region::INVALID_REGION, refreshArgs, buffer, bufferFence);
1079 if (optFd) {
1080 compositionResult.fence = std::move(*optFd);
1081 }
Dan Stoza47437bb2021-01-15 16:21:07 -08001082 }
1083
Vishnu Naira3140382022-02-24 14:07:11 -08001084 auto chooseCompositionSuccess = hwcResult.get();
1085 const bool predictionSucceeded = dequeueSucceeded && changes == previousChanges;
Vishnu Nair9cf89262022-02-26 09:17:49 -08001086 state.strategyPrediction = predictionSucceeded ? CompositionStrategyPredictionState::SUCCESS
1087 : CompositionStrategyPredictionState::FAIL;
Vishnu Naira3140382022-02-24 14:07:11 -08001088 if (!predictionSucceeded) {
1089 ATRACE_NAME("CompositionStrategyPredictionMiss");
1090 resetCompositionStrategy();
1091 if (chooseCompositionSuccess) {
1092 applyCompositionStrategy(changes);
1093 }
1094 finishPrepareFrame();
1095 // Track the dequeued buffer to reuse so we don't need to dequeue another one.
1096 compositionResult.buffer = buffer;
1097 } else {
1098 ATRACE_NAME("CompositionStrategyPredictionHit");
1099 }
1100 state.previousDeviceRequestedChanges = std::move(changes);
1101 state.previousDeviceRequestedSuccess = chooseCompositionSuccess;
1102 return compositionResult;
Lloyd Pique66d68602019-02-13 14:23:31 -08001103}
1104
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08001105void Output::devOptRepaintFlash(const compositionengine::CompositionRefreshArgs& refreshArgs) {
1106 if (CC_LIKELY(!refreshArgs.devOptFlashDirtyRegionsDelay)) {
1107 return;
1108 }
1109
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001110 if (getState().isEnabled) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001111 if (const auto dirtyRegion = getDirtyRegion(); !dirtyRegion.isEmpty()) {
Vishnu Naira3140382022-02-24 14:07:11 -08001112 base::unique_fd bufferFence;
1113 std::shared_ptr<renderengine::ExternalTexture> buffer;
1114 updateProtectedContentState();
1115 dequeueRenderBuffer(&bufferFence, &buffer);
1116 static_cast<void>(composeSurfaces(dirtyRegion, refreshArgs, buffer, bufferFence));
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001117 mRenderSurface->queueBuffer(base::unique_fd());
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08001118 }
1119 }
1120
1121 postFramebuffer();
1122
1123 std::this_thread::sleep_for(*refreshArgs.devOptFlashDirtyRegionsDelay);
1124
1125 prepareFrame();
1126}
1127
Vishnu Naira3140382022-02-24 14:07:11 -08001128void Output::finishFrame(const CompositionRefreshArgs& refreshArgs, GpuCompositionResult&& result) {
Lloyd Piqued3d69882019-02-28 16:03:46 -08001129 ATRACE_CALL();
1130 ALOGV(__FUNCTION__);
Vishnu Nair9cf89262022-02-26 09:17:49 -08001131 const auto& outputState = getState();
1132 if (!outputState.isEnabled) {
Lloyd Piqued3d69882019-02-28 16:03:46 -08001133 return;
1134 }
1135
Vishnu Naira3140382022-02-24 14:07:11 -08001136 std::optional<base::unique_fd> optReadyFence;
1137 std::shared_ptr<renderengine::ExternalTexture> buffer;
1138 base::unique_fd bufferFence;
Vishnu Nair9cf89262022-02-26 09:17:49 -08001139 if (outputState.strategyPrediction == CompositionStrategyPredictionState::SUCCESS) {
Vishnu Naira3140382022-02-24 14:07:11 -08001140 optReadyFence = std::move(result.fence);
1141 } else {
1142 if (result.bufferAvailable()) {
1143 buffer = std::move(result.buffer);
1144 bufferFence = std::move(result.fence);
1145 } else {
1146 updateProtectedContentState();
1147 if (!dequeueRenderBuffer(&bufferFence, &buffer)) {
1148 return;
1149 }
1150 }
1151 // Repaint the framebuffer (if needed), getting the optional fence for when
1152 // the composition completes.
1153 optReadyFence = composeSurfaces(Region::INVALID_REGION, refreshArgs, buffer, bufferFence);
1154 }
Lloyd Piqued3d69882019-02-28 16:03:46 -08001155 if (!optReadyFence) {
1156 return;
1157 }
1158
Matt Buckley50c44062022-01-17 20:48:10 +00001159 if (isPowerHintSessionEnabled()) {
1160 // get fence end time to know when gpu is complete in display
Ady Abrahamd11bade2022-08-01 16:18:03 -07001161 setHintSessionGpuFence(
1162 std::make_unique<FenceTime>(sp<Fence>::make(dup(optReadyFence->get()))));
Matt Buckley50c44062022-01-17 20:48:10 +00001163 }
Lloyd Piqued3d69882019-02-28 16:03:46 -08001164 // swap buffers (presentation)
1165 mRenderSurface->queueBuffer(std::move(*optReadyFence));
1166}
1167
Vishnu Naira3140382022-02-24 14:07:11 -08001168void Output::updateProtectedContentState() {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001169 const auto& outputState = getState();
Lloyd Piquee9eff972020-05-05 12:36:44 -07001170 auto& renderEngine = getCompositionEngine().getRenderEngine();
1171 const bool supportsProtectedContent = renderEngine.supportsProtectedContent();
1172
1173 // If we the display is secure, protected content support is enabled, and at
1174 // least one layer has protected content, we need to use a secure back
1175 // buffer.
1176 if (outputState.isSecure && supportsProtectedContent) {
1177 auto layers = getOutputLayersOrderedByZ();
1178 bool needsProtected = std::any_of(layers.begin(), layers.end(), [](auto* layer) {
1179 return layer->getLayerFE().getCompositionState()->hasProtectedContent;
1180 });
Patrick Williams8aed5d22022-10-31 22:18:10 +00001181 if (needsProtected != mRenderSurface->isProtected()) {
Lloyd Piquee9eff972020-05-05 12:36:44 -07001182 mRenderSurface->setProtected(needsProtected);
1183 }
1184 }
Vishnu Naira3140382022-02-24 14:07:11 -08001185}
Lloyd Piquee9eff972020-05-05 12:36:44 -07001186
Vishnu Naira3140382022-02-24 14:07:11 -08001187bool Output::dequeueRenderBuffer(base::unique_fd* bufferFence,
1188 std::shared_ptr<renderengine::ExternalTexture>* tex) {
1189 const auto& outputState = getState();
Lloyd Piquee9eff972020-05-05 12:36:44 -07001190
1191 // If we aren't doing client composition on this output, but do have a
1192 // flipClientTarget request for this frame on this output, we still need to
1193 // dequeue a buffer.
Vishnu Naira3140382022-02-24 14:07:11 -08001194 if (outputState.usesClientComposition || outputState.flipClientTarget) {
1195 *tex = mRenderSurface->dequeueBuffer(bufferFence);
1196 if (*tex == nullptr) {
Lloyd Piquee9eff972020-05-05 12:36:44 -07001197 ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
1198 "client composition for this frame",
1199 mName.c_str());
Vishnu Naira3140382022-02-24 14:07:11 -08001200 return false;
Lloyd Piquee9eff972020-05-05 12:36:44 -07001201 }
1202 }
Vishnu Naira3140382022-02-24 14:07:11 -08001203 return true;
1204}
Lloyd Piquee9eff972020-05-05 12:36:44 -07001205
Vishnu Naira3140382022-02-24 14:07:11 -08001206std::optional<base::unique_fd> Output::composeSurfaces(
1207 const Region& debugRegion, const compositionengine::CompositionRefreshArgs& refreshArgs,
1208 std::shared_ptr<renderengine::ExternalTexture> tex, base::unique_fd& fd) {
1209 ATRACE_CALL();
1210 ALOGV(__FUNCTION__);
1211
1212 const auto& outputState = getState();
1213 const TracedOrdinal<bool> hasClientComposition = {"hasClientComposition",
1214 outputState.usesClientComposition};
Lloyd Pique688abd42019-02-15 15:42:24 -08001215 if (!hasClientComposition) {
Lloyd Piquea76ce462020-01-14 13:06:37 -08001216 setExpensiveRenderingExpected(false);
Sally Qi4cabdd02021-08-05 16:45:57 -07001217 return base::unique_fd();
Lloyd Pique688abd42019-02-15 15:42:24 -08001218 }
1219
Vishnu Naira3140382022-02-24 14:07:11 -08001220 if (tex == nullptr) {
1221 ALOGW("Buffer not valid for display [%s], bailing out of "
1222 "client composition for this frame",
1223 mName.c_str());
1224 return {};
1225 }
1226
Lloyd Pique688abd42019-02-15 15:42:24 -08001227 ALOGV("hasClientComposition");
1228
Lloyd Pique688abd42019-02-15 15:42:24 -08001229 renderengine::DisplaySettings clientCompositionDisplay;
Angel Aguayob084e0c2021-08-04 23:27:28 +00001230 clientCompositionDisplay.physicalDisplay = outputState.framebufferSpace.getContent();
1231 clientCompositionDisplay.clip = outputState.layerStackSpace.getContent();
Marin Shalamanov68933fb2020-09-10 17:58:12 +02001232 clientCompositionDisplay.orientation =
Angel Aguayob084e0c2021-08-04 23:27:28 +00001233 ui::Transform::toRotationFlags(outputState.displaySpace.getOrientation());
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001234 clientCompositionDisplay.outputDataspace = mDisplayColorProfile->hasWideColorGamut()
1235 ? outputState.dataspace
1236 : ui::Dataspace::UNKNOWN;
John Reckac09e452021-04-07 16:35:37 -04001237
1238 // If we have a valid current display brightness use that, otherwise fall back to the
1239 // display's max desired
Alec Mourib21d94e2022-01-13 17:44:10 -08001240 clientCompositionDisplay.currentLuminanceNits = outputState.displayBrightnessNits > 0.f
John Reckac09e452021-04-07 16:35:37 -04001241 ? outputState.displayBrightnessNits
1242 : mDisplayColorProfile->getHdrCapabilities().getDesiredMaxLuminance();
Alec Mourib21d94e2022-01-13 17:44:10 -08001243 clientCompositionDisplay.maxLuminance =
1244 mDisplayColorProfile->getHdrCapabilities().getDesiredMaxLuminance();
Alec Mourif8d093d2022-02-10 15:16:59 -08001245 clientCompositionDisplay.targetLuminanceNits =
1246 outputState.clientTargetBrightness * outputState.displayBrightnessNits;
Alec Mouri85065692022-03-18 00:58:26 +00001247 clientCompositionDisplay.dimmingStage = outputState.clientTargetDimmingStage;
Alec Mourifcedb9c2022-04-11 20:02:17 +00001248 clientCompositionDisplay.renderIntent =
1249 static_cast<aidl::android::hardware::graphics::composer3::RenderIntent>(
1250 outputState.renderIntent);
Lloyd Pique688abd42019-02-15 15:42:24 -08001251
1252 // Compute the global color transform matrix.
Leon Scroggins III745dcaa2022-01-26 11:55:58 -05001253 clientCompositionDisplay.colorTransform = outputState.colorTransformMatrix;
Tianhao Yao67dd7122022-02-22 17:48:33 +00001254 for (auto& info : outputState.borderInfoList) {
1255 renderengine::BorderRenderInfo borderInfo;
Tianhao Yao10cea3c2022-03-30 01:37:22 +00001256 borderInfo.width = info.width;
1257 borderInfo.color = info.color;
Tianhao Yao67dd7122022-02-22 17:48:33 +00001258 borderInfo.combinedRegion = info.combinedRegion;
1259 clientCompositionDisplay.borderInfoList.emplace_back(std::move(borderInfo));
1260 }
Leon Scroggins III745dcaa2022-01-26 11:55:58 -05001261 clientCompositionDisplay.deviceHandlesColorTransform =
1262 outputState.usesDeviceComposition || getSkipColorTransform();
Lloyd Pique688abd42019-02-15 15:42:24 -08001263
Lloyd Pique688abd42019-02-15 15:42:24 -08001264 // Generate the client composition requests for the layers on this output.
Vishnu Naira3140382022-02-24 14:07:11 -08001265 auto& renderEngine = getCompositionEngine().getRenderEngine();
1266 const bool supportsProtectedContent = renderEngine.supportsProtectedContent();
Robert Carrccab4242021-09-28 16:53:03 -07001267 std::vector<LayerFE*> clientCompositionLayersFE;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001268 std::vector<LayerFE::LayerSettings> clientCompositionLayers =
Lloyd Pique688abd42019-02-15 15:42:24 -08001269 generateClientCompositionRequests(supportsProtectedContent,
Robert Carrccab4242021-09-28 16:53:03 -07001270 clientCompositionDisplay.outputDataspace,
1271 clientCompositionLayersFE);
Lloyd Pique688abd42019-02-15 15:42:24 -08001272 appendRegionFlashRequests(debugRegion, clientCompositionLayers);
1273
Vishnu Naira3140382022-02-24 14:07:11 -08001274 OutputCompositionState& outputCompositionState = editState();
Vishnu Nair9b079a22020-01-21 14:36:08 -08001275 // Check if the client composition requests were rendered into the provided graphic buffer. If
1276 // so, we can reuse the buffer and avoid client composition.
1277 if (mClientCompositionRequestCache) {
Alec Mouria90a5702021-04-16 16:36:21 +00001278 if (mClientCompositionRequestCache->exists(tex->getBuffer()->getId(),
1279 clientCompositionDisplay,
Vishnu Nair9b079a22020-01-21 14:36:08 -08001280 clientCompositionLayers)) {
Vishnu Naira3140382022-02-24 14:07:11 -08001281 ATRACE_NAME("ClientCompositionCacheHit");
Vishnu Nair9b079a22020-01-21 14:36:08 -08001282 outputCompositionState.reusedClientComposition = true;
1283 setExpensiveRenderingExpected(false);
Vishnu Nair3a49f0a2022-07-29 21:52:53 +00001284 // b/239944175 pass the fence associated with the buffer.
1285 return base::unique_fd(std::move(fd));
Vishnu Nair9b079a22020-01-21 14:36:08 -08001286 }
Vishnu Naira3140382022-02-24 14:07:11 -08001287 ATRACE_NAME("ClientCompositionCacheMiss");
Alec Mouria90a5702021-04-16 16:36:21 +00001288 mClientCompositionRequestCache->add(tex->getBuffer()->getId(), clientCompositionDisplay,
Vishnu Nair9b079a22020-01-21 14:36:08 -08001289 clientCompositionLayers);
1290 }
1291
Lloyd Pique688abd42019-02-15 15:42:24 -08001292 // We boost GPU frequency here because there will be color spaces conversion
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08001293 // or complex GPU shaders and it's expensive. We boost the GPU frequency so that
1294 // GPU composition can finish in time. We must reset GPU frequency afterwards,
1295 // because high frequency consumes extra battery.
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001296 const bool expensiveBlurs =
1297 refreshArgs.blursAreExpensive && mLayerRequestingBackgroundBlur != nullptr;
Leon Scroggins IIIcf17ebc2022-03-03 14:54:00 -05001298 const bool expensiveRenderingExpected = expensiveBlurs ||
1299 std::any_of(clientCompositionLayers.begin(), clientCompositionLayers.end(),
1300 [outputDataspace =
1301 clientCompositionDisplay.outputDataspace](const auto& layer) {
1302 return layer.sourceDataspace != outputDataspace;
1303 });
Lloyd Pique688abd42019-02-15 15:42:24 -08001304 if (expensiveRenderingExpected) {
1305 setExpensiveRenderingExpected(true);
1306 }
1307
Sally Qi59a9f502021-10-12 18:53:23 +00001308 std::vector<renderengine::LayerSettings> clientRenderEngineLayers;
1309 clientRenderEngineLayers.reserve(clientCompositionLayers.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08001310 std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
Sally Qi59a9f502021-10-12 18:53:23 +00001311 std::back_inserter(clientRenderEngineLayers),
1312 [](LayerFE::LayerSettings& settings) -> renderengine::LayerSettings {
1313 return settings;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001314 });
1315
Alec Mourie4034bb2019-11-19 12:45:54 -08001316 const nsecs_t renderEngineStart = systemTime();
Alec Mouri1684c702021-02-04 12:27:26 -08001317 // Only use the framebuffer cache when rendering to an internal display
1318 // TODO(b/173560331): This is only to help mitigate memory leaks from virtual displays because
1319 // right now we don't have a concrete eviction policy for output buffers: GLESRenderEngine
1320 // bounds its framebuffer cache but Skia RenderEngine has no current policy. The best fix is
1321 // probably to encapsulate the output buffer into a structure that dispatches resource cleanup
1322 // over to RenderEngine, in which case this flag can be removed from the drawLayers interface.
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001323 const bool useFramebufferCache = outputState.layerFilter.toInternalDisplay;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001324
Patrick Williams2e9748f2022-08-09 22:48:18 +00001325 auto fenceResult = renderEngine
1326 .drawLayers(clientCompositionDisplay, clientRenderEngineLayers, tex,
1327 useFramebufferCache, std::move(fd))
1328 .get();
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001329
1330 if (mClientCompositionRequestCache && fenceStatus(fenceResult) != NO_ERROR) {
Vishnu Nair9b079a22020-01-21 14:36:08 -08001331 // If rendering was not successful, remove the request from the cache.
Alec Mouria90a5702021-04-16 16:36:21 +00001332 mClientCompositionRequestCache->remove(tex->getBuffer()->getId());
Vishnu Nair9b079a22020-01-21 14:36:08 -08001333 }
1334
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001335 const auto fence = std::move(fenceResult).value_or(Fence::NO_FENCE);
1336
1337 if (auto& timeStats = getCompositionEngine().getTimeStats(); fence->isValid()) {
1338 timeStats.recordRenderEngineDuration(renderEngineStart, std::make_shared<FenceTime>(fence));
Alec Mourie4034bb2019-11-19 12:45:54 -08001339 } else {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001340 timeStats.recordRenderEngineDuration(renderEngineStart, systemTime());
Alec Mourie4034bb2019-11-19 12:45:54 -08001341 }
Lloyd Pique688abd42019-02-15 15:42:24 -08001342
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001343 for (auto* clientComposedLayer : clientCompositionLayersFE) {
1344 clientComposedLayer->setWasClientComposed(fence);
Robert Carrccab4242021-09-28 16:53:03 -07001345 }
1346
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001347 return base::unique_fd(fence->dup());
Lloyd Pique688abd42019-02-15 15:42:24 -08001348}
1349
Vishnu Nair9b079a22020-01-21 14:36:08 -08001350std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests(
Robert Carrccab4242021-09-28 16:53:03 -07001351 bool supportsProtectedContent, ui::Dataspace outputDataspace, std::vector<LayerFE*>& outLayerFEs) {
Vishnu Nair9b079a22020-01-21 14:36:08 -08001352 std::vector<LayerFE::LayerSettings> clientCompositionLayers;
Lloyd Pique688abd42019-02-15 15:42:24 -08001353 ALOGV("Rendering client layers");
1354
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001355 const auto& outputState = getState();
Angel Aguayob084e0c2021-08-04 23:27:28 +00001356 const Region viewportRegion(outputState.layerStackSpace.getContent());
Lloyd Pique688abd42019-02-15 15:42:24 -08001357 bool firstLayer = true;
Lloyd Pique688abd42019-02-15 15:42:24 -08001358
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01001359 bool disableBlurs = false;
Patrick Williams16d8b2c2022-08-08 17:29:05 +00001360 uint64_t previousOverrideBufferId = 0;
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01001361
Lloyd Pique01c77c12019-04-17 12:48:32 -07001362 for (auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Pique688abd42019-02-15 15:42:24 -08001363 const auto& layerState = layer->getState();
Lloyd Piquede196652020-01-22 17:29:58 -08001364 const auto* layerFEState = layer->getLayerFE().getCompositionState();
Lloyd Pique688abd42019-02-15 15:42:24 -08001365 auto& layerFE = layer->getLayerFE();
Robert Carr05da0082022-05-25 23:29:34 -07001366 layerFE.setWasClientComposed(nullptr);
Lloyd Pique688abd42019-02-15 15:42:24 -08001367
Lloyd Piquea2468662019-03-07 21:31:06 -08001368 const Region clip(viewportRegion.intersect(layerState.visibleRegion));
Lloyd Pique688abd42019-02-15 15:42:24 -08001369 ALOGV("Layer: %s", layerFE.getDebugName());
1370 if (clip.isEmpty()) {
1371 ALOGV(" Skipping for empty clip");
1372 firstLayer = false;
1373 continue;
1374 }
1375
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01001376 disableBlurs |= layerFEState->sidebandStream != nullptr;
1377
Vishnu Naira483b4a2019-12-12 15:07:52 -08001378 const bool clientComposition = layer->requiresClientComposition();
Lloyd Pique688abd42019-02-15 15:42:24 -08001379
1380 // We clear the client target for non-client composed layers if
1381 // requested by the HWC. We skip this if the layer is not an opaque
1382 // rectangle, as by definition the layer must blend with whatever is
1383 // underneath. We also skip the first layer as the buffer target is
1384 // guaranteed to start out cleared.
Vishnu Nairb87d94f2020-02-13 09:17:36 -08001385 const bool clearClientComposition =
Lloyd Piquede196652020-01-22 17:29:58 -08001386 layerState.clearClientTarget && layerFEState->isOpaque && !firstLayer;
Lloyd Pique688abd42019-02-15 15:42:24 -08001387
1388 ALOGV(" Composition type: client %d clear %d", clientComposition, clearClientComposition);
1389
Vishnu Nairb87d94f2020-02-13 09:17:36 -08001390 // If the layer casts a shadow but the content casting the shadow is occluded, skip
1391 // composing the non-shadow content and only draw the shadows.
1392 const bool realContentIsVisible = clientComposition &&
1393 !layerState.visibleRegion.subtract(layerState.shadowRegion).isEmpty();
1394
Lloyd Pique688abd42019-02-15 15:42:24 -08001395 if (clientComposition || clearClientComposition) {
Patrick Williams16d8b2c2022-08-08 17:29:05 +00001396 if (auto overrideSettings = layer->getOverrideCompositionSettings()) {
1397 if (overrideSettings->bufferId != previousOverrideBufferId) {
1398 previousOverrideBufferId = overrideSettings->bufferId;
1399 clientCompositionLayers.push_back(std::move(*overrideSettings));
Huihong Luo91ac3b52021-04-08 11:07:41 -07001400 ALOGV("Replacing [%s] with override in RE", layer->getLayerFE().getDebugName());
1401 } else {
1402 ALOGV("Skipping redundant override buffer for [%s] in RE",
1403 layer->getLayerFE().getDebugName());
1404 }
Dan Stoza6166c312021-01-15 16:34:05 -08001405 } else {
Alec Mourif54453c2021-05-13 16:28:28 -07001406 LayerFE::ClientCompositionTargetSettings::BlurSetting blurSetting = disableBlurs
1407 ? LayerFE::ClientCompositionTargetSettings::BlurSetting::Disabled
1408 : (layer->getState().overrideInfo.disableBackgroundBlur
1409 ? LayerFE::ClientCompositionTargetSettings::BlurSetting::
1410 BlurRegionsOnly
1411 : LayerFE::ClientCompositionTargetSettings::BlurSetting::
1412 Enabled);
1413 compositionengine::LayerFE::ClientCompositionTargetSettings
1414 targetSettings{.clip = clip,
1415 .needsFiltering = layer->needsFiltering() ||
1416 outputState.needsFiltering,
1417 .isSecure = outputState.isSecure,
1418 .supportsProtectedContent = supportsProtectedContent,
Angel Aguayob084e0c2021-08-04 23:27:28 +00001419 .viewport = outputState.layerStackSpace.getContent(),
Alec Mourif54453c2021-05-13 16:28:28 -07001420 .dataspace = outputDataspace,
1421 .realContentIsVisible = realContentIsVisible,
1422 .clearContent = !clientComposition,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001423 .blurSetting = blurSetting,
Vishnu Naire14c6b32022-08-06 04:20:15 +00001424 .whitePointNits = layerState.whitePointNits,
1425 .treat170mAsSrgb = outputState.treat170mAsSrgb};
Patrick Williams16d8b2c2022-08-08 17:29:05 +00001426 if (auto clientCompositionSettings =
1427 layerFE.prepareClientComposition(targetSettings)) {
1428 clientCompositionLayers.push_back(std::move(*clientCompositionSettings));
1429 if (realContentIsVisible) {
1430 layer->editState().clientCompositionTimestamp = systemTime();
1431 }
Dan Stoza6166c312021-01-15 16:34:05 -08001432 }
Lloyd Pique688abd42019-02-15 15:42:24 -08001433 }
Vishnu Nairb87d94f2020-02-13 09:17:36 -08001434
Tianhua Sunf91f1402022-05-09 05:45:46 +00001435 if (clientComposition) {
1436 outLayerFEs.push_back(&layerFE);
1437 }
Lloyd Pique688abd42019-02-15 15:42:24 -08001438 }
1439
1440 firstLayer = false;
1441 }
1442
1443 return clientCompositionLayers;
1444}
1445
1446void Output::appendRegionFlashRequests(
Vishnu Nair9b079a22020-01-21 14:36:08 -08001447 const Region& flashRegion, std::vector<LayerFE::LayerSettings>& clientCompositionLayers) {
Lloyd Pique688abd42019-02-15 15:42:24 -08001448 if (flashRegion.isEmpty()) {
1449 return;
1450 }
1451
Vishnu Nair9b079a22020-01-21 14:36:08 -08001452 LayerFE::LayerSettings layerSettings;
Lloyd Pique688abd42019-02-15 15:42:24 -08001453 layerSettings.source.buffer.buffer = nullptr;
1454 layerSettings.source.solidColor = half3(1.0, 0.0, 1.0);
1455 layerSettings.alpha = half(1.0);
1456
1457 for (const auto& rect : flashRegion) {
1458 layerSettings.geometry.boundaries = rect.toFloatRect();
1459 clientCompositionLayers.push_back(layerSettings);
1460 }
1461}
1462
1463void Output::setExpensiveRenderingExpected(bool) {
1464 // The base class does nothing with this call.
1465}
1466
Matt Buckley50c44062022-01-17 20:48:10 +00001467void Output::setHintSessionGpuFence(std::unique_ptr<FenceTime>&&) {
1468 // The base class does nothing with this call.
1469}
1470
1471bool Output::isPowerHintSessionEnabled() {
1472 return false;
1473}
1474
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001475void Output::postFramebuffer() {
1476 ATRACE_CALL();
1477 ALOGV(__FUNCTION__);
1478
1479 if (!getState().isEnabled) {
1480 return;
1481 }
1482
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001483 auto& outputState = editState();
1484 outputState.dirtyRegion.clear();
Lloyd Piqued3d69882019-02-28 16:03:46 -08001485
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001486 auto frame = presentAndGetFrameFences();
1487
Lloyd Pique7d90ba52019-08-08 11:57:53 -07001488 mRenderSurface->onPresentDisplayCompleted();
1489
Lloyd Pique01c77c12019-04-17 12:48:32 -07001490 for (auto* layer : getOutputLayersOrderedByZ()) {
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001491 // The layer buffer from the previous frame (if any) is released
1492 // by HWC only when the release fence from this frame (if any) is
1493 // signaled. Always get the release fence from HWC first.
1494 sp<Fence> releaseFence = Fence::NO_FENCE;
1495
1496 if (auto hwcLayer = layer->getHwcLayer()) {
1497 if (auto f = frame.layerFences.find(hwcLayer); f != frame.layerFences.end()) {
1498 releaseFence = f->second;
1499 }
1500 }
1501
1502 // If the layer was client composited in the previous frame, we
1503 // need to merge with the previous client target acquire fence.
1504 // Since we do not track that, always merge with the current
1505 // client target acquire fence when it is available, even though
1506 // this is suboptimal.
1507 // TODO(b/121291683): Track previous frame client target acquire fence.
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001508 if (outputState.usesClientComposition) {
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001509 releaseFence =
1510 Fence::merge("LayerRelease", releaseFence, frame.clientTargetAcquireFence);
1511 }
Sally Qi59a9f502021-10-12 18:53:23 +00001512 layer->getLayerFE().onLayerDisplayed(
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001513 ftl::yield<FenceResult>(std::move(releaseFence)).share());
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001514 }
1515
1516 // We've got a list of layers needing fences, that are disjoint with
Lloyd Pique01c77c12019-04-17 12:48:32 -07001517 // OutputLayersOrderedByZ. The best we can do is to
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001518 // supply them with the present fence.
1519 for (auto& weakLayer : mReleasedLayers) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07001520 if (const auto layer = weakLayer.promote()) {
1521 layer->onLayerDisplayed(ftl::yield<FenceResult>(frame.presentFence).share());
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001522 }
1523 }
1524
1525 // Clear out the released layers now that we're done with them.
1526 mReleasedLayers.clear();
1527}
1528
Alec Mouriaa831582021-06-07 16:23:01 -07001529void Output::renderCachedSets(const CompositionRefreshArgs& refreshArgs) {
Dan Stoza6166c312021-01-15 16:34:05 -08001530 if (mPlanner) {
Brian Johnson869e28f2022-08-12 22:20:19 +00001531 mPlanner->renderCachedSets(getState(), refreshArgs.scheduledFrameTime,
1532 getState().usesDeviceComposition || getSkipColorTransform());
Dan Stoza6166c312021-01-15 16:34:05 -08001533 }
1534}
1535
Lloyd Pique32cbe282018-10-19 13:09:22 -07001536void Output::dirtyEntireOutput() {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001537 auto& outputState = editState();
Angel Aguayob084e0c2021-08-04 23:27:28 +00001538 outputState.dirtyRegion.set(outputState.displaySpace.getBoundsAsRect());
Lloyd Pique32cbe282018-10-19 13:09:22 -07001539}
1540
Vishnu Naira3140382022-02-24 14:07:11 -08001541void Output::resetCompositionStrategy() {
Lloyd Pique66d68602019-02-13 14:23:31 -08001542 // The base output implementation can only do client composition
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001543 auto& outputState = editState();
1544 outputState.usesClientComposition = true;
1545 outputState.usesDeviceComposition = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001546 outputState.reusedClientComposition = false;
Lloyd Pique66d68602019-02-13 14:23:31 -08001547}
1548
Lloyd Pique688abd42019-02-15 15:42:24 -08001549bool Output::getSkipColorTransform() const {
1550 return true;
1551}
1552
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001553compositionengine::Output::FrameFences Output::presentAndGetFrameFences() {
1554 compositionengine::Output::FrameFences result;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001555 if (getState().usesClientComposition) {
Lloyd Pique35fca9d2019-02-13 14:24:11 -08001556 result.clientTargetAcquireFence = mRenderSurface->getClientTargetAcquireFence();
1557 }
1558 return result;
1559}
1560
Vishnu Naira3140382022-02-24 14:07:11 -08001561void Output::setPredictCompositionStrategy(bool predict) {
1562 if (predict) {
1563 mHwComposerAsyncWorker = std::make_unique<HwcAsyncWorker>();
1564 } else {
1565 mHwComposerAsyncWorker.reset(nullptr);
1566 }
1567}
1568
Alec Mouridda07d92022-04-25 22:39:25 +00001569void Output::setTreat170mAsSrgb(bool enable) {
1570 editState().treat170mAsSrgb = enable;
1571}
1572
Vishnu Naira3140382022-02-24 14:07:11 -08001573bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refreshArgs) {
Robert Carrec8ccca2022-05-04 09:36:14 -07001574 uint64_t lastOutputLayerHash = getState().lastOutputLayerHash;
1575 uint64_t outputLayerHash = getState().outputLayerHash;
1576 editState().lastOutputLayerHash = outputLayerHash;
1577
Vishnu Naira3140382022-02-24 14:07:11 -08001578 if (!getState().isEnabled || !mHwComposerAsyncWorker) {
1579 ALOGV("canPredictCompositionStrategy disabled");
1580 return false;
1581 }
1582
1583 if (!getState().previousDeviceRequestedChanges) {
1584 ALOGV("canPredictCompositionStrategy previous changes not available");
1585 return false;
1586 }
1587
1588 if (!mRenderSurface->supportsCompositionStrategyPrediction()) {
1589 ALOGV("canPredictCompositionStrategy surface does not support");
1590 return false;
1591 }
1592
1593 if (refreshArgs.devOptFlashDirtyRegionsDelay) {
1594 ALOGV("canPredictCompositionStrategy devOptFlashDirtyRegionsDelay");
1595 return false;
1596 }
1597
Robert Carrec8ccca2022-05-04 09:36:14 -07001598 if (lastOutputLayerHash != outputLayerHash) {
1599 ALOGV("canPredictCompositionStrategy output layers changed");
1600 return false;
1601 }
1602
Vishnu Naira3140382022-02-24 14:07:11 -08001603 // If no layer uses clientComposition, then don't predict composition strategy
1604 // because we have less work to do in parallel.
1605 if (!anyLayersRequireClientComposition()) {
1606 ALOGV("canPredictCompositionStrategy no layer uses clientComposition");
1607 return false;
1608 }
1609
Robert Carrec8ccca2022-05-04 09:36:14 -07001610 return true;
Vishnu Naira3140382022-02-24 14:07:11 -08001611}
1612
1613bool Output::anyLayersRequireClientComposition() const {
1614 const auto layers = getOutputLayersOrderedByZ();
1615 return std::any_of(layers.begin(), layers.end(),
1616 [](const auto& layer) { return layer->requiresClientComposition(); });
1617}
1618
1619void Output::finishPrepareFrame() {
1620 const auto& state = getState();
1621 if (mPlanner) {
1622 mPlanner->reportFinalPlan(getOutputLayersOrderedByZ());
1623 }
1624 mRenderSurface->prepareFrame(state.usesClientComposition, state.usesDeviceComposition);
1625}
1626
Chavi Weingarten09fa1d62022-08-17 21:57:04 +00001627bool Output::mustRecompose() const {
1628 return mMustRecompose;
1629}
1630
Lloyd Piquefeb73d72018-12-04 17:23:44 -08001631} // namespace impl
1632} // namespace android::compositionengine