1 /*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <compositionengine/CompositionRefreshArgs.h>
18 #include <compositionengine/LayerFE.h>
19 #include <compositionengine/LayerFECompositionState.h>
20 #include <compositionengine/OutputLayer.h>
21 #include <compositionengine/impl/CompositionEngine.h>
22 #include <compositionengine/impl/Display.h>
23
24 #include <renderengine/RenderEngine.h>
25 #include <utils/Trace.h>
26
27 // TODO(b/129481165): remove the #pragma below and fix conversion issues
28 #pragma clang diagnostic push
29 #pragma clang diagnostic ignored "-Wconversion"
30
31 #include "DisplayHardware/HWComposer.h"
32
33 // TODO(b/129481165): remove the #pragma below and fix conversion issues
34 #pragma clang diagnostic pop // ignored "-Wconversion"
35
36 namespace android::compositionengine {
37
38 CompositionEngine::~CompositionEngine() = default;
39
40 namespace impl {
41
createCompositionEngine()42 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() {
43 return std::make_unique<CompositionEngine>();
44 }
45
46 CompositionEngine::CompositionEngine() = default;
47 CompositionEngine::~CompositionEngine() = default;
48
createDisplay(const DisplayCreationArgs & args)49 std::shared_ptr<compositionengine::Display> CompositionEngine::createDisplay(
50 const DisplayCreationArgs& args) {
51 return compositionengine::impl::createDisplay(*this, args);
52 }
53
54 std::unique_ptr<compositionengine::LayerFECompositionState>
createLayerFECompositionState()55 CompositionEngine::createLayerFECompositionState() {
56 return std::make_unique<compositionengine::LayerFECompositionState>();
57 }
58
getHwComposer() const59 HWComposer& CompositionEngine::getHwComposer() const {
60 return *mHwComposer.get();
61 }
62
setHwComposer(std::unique_ptr<HWComposer> hwComposer)63 void CompositionEngine::setHwComposer(std::unique_ptr<HWComposer> hwComposer) {
64 mHwComposer = std::move(hwComposer);
65 }
66
getRenderEngine() const67 renderengine::RenderEngine& CompositionEngine::getRenderEngine() const {
68 return *mRenderEngine;
69 }
70
setRenderEngine(renderengine::RenderEngine * renderEngine)71 void CompositionEngine::setRenderEngine(renderengine::RenderEngine* renderEngine) {
72 mRenderEngine = renderEngine;
73 }
74
getTimeStats() const75 TimeStats* CompositionEngine::getTimeStats() const {
76 return mTimeStats.get();
77 }
78
setTimeStats(const std::shared_ptr<TimeStats> & timeStats)79 void CompositionEngine::setTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
80 mTimeStats = timeStats;
81 }
82
needsAnotherUpdate() const83 bool CompositionEngine::needsAnotherUpdate() const {
84 return mNeedsAnotherUpdate;
85 }
86
getLastFrameRefreshTimestamp() const87 nsecs_t CompositionEngine::getLastFrameRefreshTimestamp() const {
88 return mRefreshStartTime;
89 }
90
present(CompositionRefreshArgs & args)91 void CompositionEngine::present(CompositionRefreshArgs& args) {
92 ATRACE_CALL();
93 ALOGV(__FUNCTION__);
94
95 preComposition(args);
96
97 {
98 // latchedLayers is used to track the set of front-end layer state that
99 // has been latched across all outputs for the prepare step, and is not
100 // needed for anything else.
101 LayerFESet latchedLayers;
102
103 for (const auto& output : args.outputs) {
104 output->prepare(args, latchedLayers);
105 }
106 }
107
108 for (const auto& output : args.outputs) {
109 output->present(args);
110 }
111 }
112
updateCursorAsync(CompositionRefreshArgs & args)113 void CompositionEngine::updateCursorAsync(CompositionRefreshArgs& args) {
114 std::unordered_map<compositionengine::LayerFE*, compositionengine::LayerFECompositionState*>
115 uniqueVisibleLayers;
116
117 for (const auto& output : args.outputs) {
118 for (auto* layer : output->getOutputLayersOrderedByZ()) {
119 if (layer->isHardwareCursor()) {
120 layer->writeCursorPositionToHWC();
121 }
122 }
123 }
124 }
125
preComposition(CompositionRefreshArgs & args)126 void CompositionEngine::preComposition(CompositionRefreshArgs& args) {
127 ATRACE_CALL();
128 ALOGV(__FUNCTION__);
129
130 bool needsAnotherUpdate = false;
131
132 mRefreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
133
134 for (auto& layer : args.layers) {
135 if (layer->onPreComposition(mRefreshStartTime, args.updatingOutputGeometryThisFrame)) {
136 needsAnotherUpdate = true;
137 }
138 }
139
140 mNeedsAnotherUpdate = needsAnotherUpdate;
141 }
142
getFeatureFlags() const143 FeatureFlags CompositionEngine::getFeatureFlags() const {
144 return {};
145 }
146
dump(std::string &) const147 void CompositionEngine::dump(std::string&) const {
148 // The base class has no state to dump, but derived classes might.
149 }
150
setNeedsAnotherUpdateForTest(bool value)151 void CompositionEngine::setNeedsAnotherUpdateForTest(bool value) {
152 mNeedsAnotherUpdate = value;
153 }
154
155 } // namespace impl
156 } // namespace android::compositionengine
157