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 <memory>
20 #include <string>
21 
22 #include <compositionengine/OutputLayer.h>
23 #include <ui/FloatRect.h>
24 #include <ui/Rect.h>
25 
26 #include "DisplayHardware/DisplayIdentification.h"
27 
28 namespace android::compositionengine {
29 
30 struct LayerFECompositionState;
31 
32 namespace impl {
33 
34 // The implementation class contains the common implementation, but does not
35 // actually contain the final layer state.
36 class OutputLayer : public virtual compositionengine::OutputLayer {
37 public:
38     ~OutputLayer() override;
39 
40     void setHwcLayer(std::shared_ptr<HWC2::Layer>) override;
41 
42     void updateCompositionState(bool includeGeometry, bool forceClientComposition,
43                                 ui::Transform::RotationFlags) override;
44     void writeStateToHWC(bool) override;
45     void writeCursorPositionToHWC() const override;
46 
47     HWC2::Layer* getHwcLayer() const override;
48     bool requiresClientComposition() const override;
49     bool isHardwareCursor() const override;
50     void applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition) override;
51     void prepareForDeviceLayerRequests() override;
52     void applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest request) override;
53     bool needsFiltering() const override;
54 
55     void dump(std::string&) const override;
56 
57     virtual FloatRect calculateOutputSourceCrop() const;
58     virtual Rect calculateOutputDisplayFrame() const;
59     virtual uint32_t calculateOutputRelativeBufferTransform(
60             uint32_t internalDisplayRotationFlags) const;
61 
62 protected:
63     // Implemented by the final implementation for the final state it uses.
64     virtual void dumpState(std::string&) const = 0;
65 
66 private:
67     Rect calculateInitialCrop() const;
68     void writeOutputDependentGeometryStateToHWC(HWC2::Layer*, Hwc2::IComposerClient::Composition);
69     void writeOutputIndependentGeometryStateToHWC(HWC2::Layer*, const LayerFECompositionState&);
70     void writeOutputDependentPerFrameStateToHWC(HWC2::Layer*);
71     void writeOutputIndependentPerFrameStateToHWC(HWC2::Layer*, const LayerFECompositionState&);
72     void writeSolidColorStateToHWC(HWC2::Layer*, const LayerFECompositionState&);
73     void writeSidebandStateToHWC(HWC2::Layer*, const LayerFECompositionState&);
74     void writeBufferStateToHWC(HWC2::Layer*, const LayerFECompositionState&);
75     void writeCompositionTypeToHWC(HWC2::Layer*, Hwc2::IComposerClient::Composition);
76     void detectDisallowedCompositionTypeChange(Hwc2::IComposerClient::Composition from,
77                                                Hwc2::IComposerClient::Composition to) const;
78 };
79 
80 // This template factory function standardizes the implementation details of the
81 // final class using the types actually required by the implementation. This is
82 // not possible to do in the base class as those types may not even be visible
83 // to the base code.
84 template <typename BaseOutputLayer>
createOutputLayerTemplated(const Output & output,sp<LayerFE> layerFE)85 std::unique_ptr<BaseOutputLayer> createOutputLayerTemplated(const Output& output,
86                                                             sp<LayerFE> layerFE) {
87     class OutputLayer final : public BaseOutputLayer {
88     public:
89 // Clang incorrectly complains that these are unused.
90 #pragma clang diagnostic push
91 #pragma clang diagnostic ignored "-Wunused-local-typedef"
92 
93         using OutputLayerCompositionState = std::remove_const_t<
94                 std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getState())>>;
95         using Output = std::remove_const_t<
96                 std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getOutput())>>;
97         using LayerFE =
98                 std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getLayerFE())>;
99 
100 #pragma clang diagnostic pop
101 
102         OutputLayer(const Output& output, const sp<LayerFE>& layerFE)
103               : mOutput(output), mLayerFE(layerFE) {}
104         ~OutputLayer() override = default;
105 
106     private:
107         // compositionengine::OutputLayer overrides
108         const Output& getOutput() const override { return mOutput; }
109         LayerFE& getLayerFE() const override { return *mLayerFE; }
110         const OutputLayerCompositionState& getState() const override { return mState; }
111         OutputLayerCompositionState& editState() override { return mState; }
112 
113         // compositionengine::impl::OutputLayer overrides
114         void dumpState(std::string& out) const override { mState.dump(out); }
115 
116         const Output& mOutput;
117         const sp<LayerFE> mLayerFE;
118         OutputLayerCompositionState mState;
119     };
120 
121     return std::make_unique<OutputLayer>(output, layerFE);
122 }
123 
124 std::unique_ptr<OutputLayer> createOutputLayer(const compositionengine::Output&,
125                                                const sp<LayerFE>&);
126 
127 } // namespace impl
128 } // namespace android::compositionengine
129