1 /*
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 
17 #pragma once
18 
19 #include <ftl/optional.h>
20 #include <memory>
21 #include <utility>
22 #include <vector>
23 
24 #include <compositionengine/CompositionEngine.h>
25 #include <compositionengine/LayerFECompositionState.h>
26 #include <compositionengine/Output.h>
27 #include <compositionengine/impl/ClientCompositionRequestCache.h>
28 #include <compositionengine/impl/GpuCompositionResult.h>
29 #include <compositionengine/impl/HwcAsyncWorker.h>
30 #include <compositionengine/impl/OutputCompositionState.h>
31 #include <compositionengine/impl/OutputLayerCompositionState.h>
32 #include <compositionengine/impl/planner/Planner.h>
33 #include <renderengine/DisplaySettings.h>
34 #include <renderengine/LayerSettings.h>
35 
36 namespace android::compositionengine::impl {
37 
38 // The implementation class contains the common implementation, but does not
39 // actually contain the final output state.
40 class Output : public virtual compositionengine::Output {
41 public:
42     Output() = default;
43     ~Output() override;
44 
45     // compositionengine::Output overrides
46     bool isValid() const override;
47     ftl::Optional<DisplayId> getDisplayId() const override;
48     void setCompositionEnabled(bool) override;
49     void setLayerCachingEnabled(bool) override;
50     void setLayerCachingTexturePoolEnabled(bool) override;
51     void setProjection(ui::Rotation orientation, const Rect& layerStackSpaceRect,
52                        const Rect& orientedDisplaySpaceRect) override;
53     void setNextBrightness(float brightness) override;
54     void setDisplaySize(const ui::Size&) override;
55     void setLayerFilter(ui::LayerFilter) override;
56     ui::Transform::RotationFlags getTransformHint() const override;
57 
58     void setColorTransform(const compositionengine::CompositionRefreshArgs&) override;
59     void setColorProfile(const ColorProfile&) override;
60     void setDisplayBrightness(float sdrWhitePointNits, float displayBrightnessNits) override;
61 
62     void dump(std::string&) const override;
63     void dumpPlannerInfo(const Vector<String16>& args, std::string&) const override;
64 
65     const std::string& getName() const override;
66     void setName(const std::string&) override;
67 
68     compositionengine::DisplayColorProfile* getDisplayColorProfile() const override;
69     void setDisplayColorProfile(std::unique_ptr<compositionengine::DisplayColorProfile>) override;
70 
71     compositionengine::RenderSurface* getRenderSurface() const override;
72     void setRenderSurface(std::unique_ptr<compositionengine::RenderSurface>) override;
73 
74     Region getDirtyRegion() const override;
75 
76     bool includesLayer(ui::LayerFilter) const override;
77     bool includesLayer(const sp<LayerFE>&) const override;
78 
79     compositionengine::OutputLayer* getOutputLayerForLayer(const sp<LayerFE>&) const override;
80 
81     void setReleasedLayers(ReleasedLayers&&) override;
82 
83     void prepare(const CompositionRefreshArgs&, LayerFESet&) override;
84     ftl::Future<std::monostate> present(const CompositionRefreshArgs&) override;
supportsOffloadPresent()85     bool supportsOffloadPresent() const override { return false; }
86     void offloadPresentNextFrame() override;
87 
88     void rebuildLayerStacks(const CompositionRefreshArgs&, LayerFESet&) override;
89     void collectVisibleLayers(const CompositionRefreshArgs&,
90                               compositionengine::Output::CoverageState&) override;
91     void ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>&,
92                                     compositionengine::Output::CoverageState&) override;
93     void setReleasedLayers(const compositionengine::CompositionRefreshArgs&) override;
94     void uncacheBuffers(const std::vector<uint64_t>& bufferIdsToUncache) override;
95     void commitPictureProfilesToCompositionState();
96 
97     void updateCompositionState(const compositionengine::CompositionRefreshArgs&) override;
98     void planComposition() override;
99     void writeCompositionState(const compositionengine::CompositionRefreshArgs&) override;
100     void updateColorProfile(const compositionengine::CompositionRefreshArgs&) override;
101     void beginFrame() override;
102     void prepareFrame() override;
103     GpuCompositionResult prepareFrameAsync() override;
104     void devOptRepaintFlash(const CompositionRefreshArgs&) override;
105     void finishFrame(GpuCompositionResult&&) override;
106     std::optional<base::unique_fd> composeSurfaces(const Region&,
107                                                    std::shared_ptr<renderengine::ExternalTexture>,
108                                                    base::unique_fd&) override;
109     void presentFrameAndReleaseLayers(bool flushEvenWhenDisabled) override;
110     void renderCachedSets(const CompositionRefreshArgs&) override;
111     void cacheClientCompositionRequests(uint32_t) override;
112     bool canPredictCompositionStrategy(const CompositionRefreshArgs&) override;
113     void setPredictCompositionStrategy(bool) override;
114     void setTreat170mAsSrgb(bool) override;
115 
116     // Testing
117     const ReleasedLayers& getReleasedLayersForTest() const;
118     void setDisplayColorProfileForTest(std::unique_ptr<compositionengine::DisplayColorProfile>);
119     void setRenderSurfaceForTest(std::unique_ptr<compositionengine::RenderSurface>);
plannerEnabled()120     bool plannerEnabled() const { return mPlanner != nullptr; }
121     virtual bool anyLayersRequireClientComposition() const;
122     virtual void updateProtectedContentState();
123     virtual bool dequeueRenderBuffer(base::unique_fd*,
124                                      std::shared_ptr<renderengine::ExternalTexture>*);
125     virtual std::future<bool> chooseCompositionStrategyAsync(
126             std::optional<android::HWComposer::DeviceRequestedChanges>*);
127     virtual void resetCompositionStrategy();
128     virtual ftl::Future<std::monostate> presentFrameAndReleaseLayersAsync(
129             bool flushEvenWhenDisabled);
130 
131 protected:
132     std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(const sp<LayerFE>&) const;
133     std::optional<size_t> findCurrentOutputLayerForLayer(
134             const sp<compositionengine::LayerFE>&) const;
135     using DeviceRequestedChanges = android::HWComposer::DeviceRequestedChanges;
chooseCompositionStrategy(std::optional<android::HWComposer::DeviceRequestedChanges> *)136     bool chooseCompositionStrategy(
137             std::optional<android::HWComposer::DeviceRequestedChanges>*) override {
138         return true;
139     };
applyCompositionStrategy(const std::optional<DeviceRequestedChanges> &)140     void applyCompositionStrategy(const std::optional<DeviceRequestedChanges>&) override{};
141     bool getSkipColorTransform() const override;
142     compositionengine::Output::FrameFences presentFrame() override;
executeCommands()143     void executeCommands() override {}
144     virtual renderengine::DisplaySettings generateClientCompositionDisplaySettings(
145             const std::shared_ptr<renderengine::ExternalTexture>& buffer) const;
146     std::vector<LayerFE::LayerSettings> generateClientCompositionRequests(
147             bool supportsProtectedContent, ui::Dataspace outputDataspace,
148             std::vector<LayerFE*>& outLayerFEs) override;
149     void appendRegionFlashRequests(const Region&, std::vector<LayerFE::LayerSettings>&) override;
150     void setExpensiveRenderingExpected(bool enabled) override;
151     void setHintSessionGpuStart(TimePoint startTime) override;
152     void setHintSessionGpuFence(std::unique_ptr<FenceTime>&& gpuFence) override;
153     void setHintSessionRequiresRenderEngine(bool requiresRenderEngine) override;
154     bool isPowerHintSessionEnabled() override;
155     bool isPowerHintSessionGpuReportingEnabled() override;
156     bool hasPictureProcessing() const override;
157     int32_t getMaxLayerPictureProfiles() const override;
158     void applyPictureProfile() override;
159     void dumpBase(std::string&) const;
160 
161     // Implemented by the final implementation for the final state it uses.
162     virtual compositionengine::OutputLayer* ensureOutputLayer(std::optional<size_t>,
163                                                               const sp<LayerFE>&) = 0;
164     virtual compositionengine::OutputLayer* injectOutputLayerForTest(const sp<LayerFE>&) = 0;
165     virtual void finalizePendingOutputLayers() = 0;
166     virtual const compositionengine::CompositionEngine& getCompositionEngine() const = 0;
167     virtual void dumpState(std::string& out) const = 0;
168 
169     bool mustRecompose() const;
170 
getNamePlusId()171     const std::string& getNamePlusId() const { return mNamePlusId; }
172     const aidl::android::hardware::graphics::composer3::OverlayProperties* getOverlaySupport()
173             override;
174 
175 private:
176     void dirtyEntireOutput();
177     compositionengine::OutputLayer* findLayerRequestingBackgroundComposition() const;
178     void finishPrepareFrame();
179     ui::Dataspace getBestDataspace(ui::Dataspace*, bool*) const;
180     compositionengine::Output::ColorProfile pickColorProfile(
181             const compositionengine::CompositionRefreshArgs&) const;
182     void updateHwcAsyncWorker();
183     float getHdrSdrRatio(const std::shared_ptr<renderengine::ExternalTexture>& buffer) const;
184 
185     std::string mName;
186     std::string mNamePlusId;
187 
188     std::unique_ptr<compositionengine::DisplayColorProfile> mDisplayColorProfile;
189     std::unique_ptr<compositionengine::RenderSurface> mRenderSurface;
190 
191     ReleasedLayers mReleasedLayers;
192     OutputLayer* mLayerRequestingBackgroundBlur = nullptr;
193     std::unique_ptr<ClientCompositionRequestCache> mClientCompositionRequestCache;
194     std::unique_ptr<planner::Planner> mPlanner;
195     std::unique_ptr<HwcAsyncWorker> mHwComposerAsyncWorker;
196 
197     bool mPredictCompositionStrategy = false;
198     bool mOffloadPresent = false;
199 
200     // Whether the content must be recomposed this frame.
201     bool mMustRecompose = false;
202 };
203 
204 // This template factory function standardizes the implementation details of the
205 // final class using the types actually required by the implementation. This is
206 // not possible to do in the base class as those types may not even be visible
207 // to the base code.
208 template <typename BaseOutput, typename CompositionEngine, typename... Args>
createOutputTemplated(const CompositionEngine & compositionEngine,Args...args)209 std::shared_ptr<BaseOutput> createOutputTemplated(const CompositionEngine& compositionEngine,
210                                                   Args... args) {
211     class Output final : public BaseOutput {
212     public:
213 // Clang incorrectly complains that these are unused.
214 #pragma clang diagnostic push
215 #pragma clang diagnostic ignored "-Wunused-local-typedef"
216 
217         using OutputCompositionState = std::remove_const_t<
218                 std::remove_reference_t<decltype(std::declval<BaseOutput>().getState())>>;
219         using OutputLayer = std::remove_pointer_t<decltype(
220                 std::declval<BaseOutput>().getOutputLayerOrderedByZByIndex(0))>;
221 
222 #pragma clang diagnostic pop
223 
224         explicit Output(const CompositionEngine& compositionEngine, Args... args)
225               : BaseOutput(std::forward<Args>(args)...), mCompositionEngine(compositionEngine) {}
226         ~Output() override = default;
227 
228     private:
229         // compositionengine::Output overrides
230         const OutputCompositionState& getState() const override { return mState; }
231 
232         OutputCompositionState& editState() override { return mState; }
233 
234         size_t getOutputLayerCount() const override {
235             return mCurrentOutputLayersOrderedByZ.size();
236         }
237 
238         OutputLayer* getOutputLayerOrderedByZByIndex(size_t index) const override {
239             if (index >= mCurrentOutputLayersOrderedByZ.size()) {
240                 return nullptr;
241             }
242             return mCurrentOutputLayersOrderedByZ[index].get();
243         }
244 
245         // compositionengine::impl::Output overrides
246         const CompositionEngine& getCompositionEngine() const override {
247             return mCompositionEngine;
248         };
249 
250         OutputLayer* ensureOutputLayer(std::optional<size_t> prevIndex,
251                                        const sp<LayerFE>& layerFE) {
252             auto outputLayer = (prevIndex && *prevIndex <= mCurrentOutputLayersOrderedByZ.size())
253                     ? std::move(mCurrentOutputLayersOrderedByZ[*prevIndex])
254                     : BaseOutput::createOutputLayer(layerFE);
255             auto result = outputLayer.get();
256             mPendingOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
257             return result;
258         }
259 
260         void finalizePendingOutputLayers() override {
261             // The pending layers are added in reverse order. Reverse them to
262             // get the back-to-front ordered list of layers.
263             std::reverse(mPendingOutputLayersOrderedByZ.begin(),
264                          mPendingOutputLayersOrderedByZ.end());
265 
266             mCurrentOutputLayersOrderedByZ = std::move(mPendingOutputLayersOrderedByZ);
267         }
268 
269         void dumpState(std::string& out) const override { mState.dump(out); }
270 
271         OutputLayer* injectOutputLayerForTest(const sp<LayerFE>& layerFE) override {
272             auto outputLayer = BaseOutput::createOutputLayer(layerFE);
273             auto result = outputLayer.get();
274             mCurrentOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
275             return result;
276         }
277 
278         // Note: This is declared as a private virtual non-override so it can be
279         // an override implementation in the unit tests, but otherwise is not an
280         // accessible override for the normal implementation.
281         virtual void injectOutputLayerForTest(std::unique_ptr<OutputLayer> outputLayer) {
282             mCurrentOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
283         }
284 
285         void clearOutputLayers() override {
286             mCurrentOutputLayersOrderedByZ.clear();
287             mPendingOutputLayersOrderedByZ.clear();
288         }
289 
290         const CompositionEngine& mCompositionEngine;
291         OutputCompositionState mState;
292         std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ;
293         std::vector<std::unique_ptr<OutputLayer>> mPendingOutputLayersOrderedByZ;
294     };
295 
296     return std::make_shared<Output>(compositionEngine, std::forward<Args>(args)...);
297 }
298 
299 std::shared_ptr<Output> createOutput(const compositionengine::CompositionEngine&);
300 
301 } // namespace android::compositionengine::impl
302