1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/*
* Copyright 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
#include <ui/Transform.h>
#include <utils/StrongPointer.h>
// TODO(b/129481165): remove the #pragma below and fix conversion issues
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wconversion"
#pragma clang diagnostic ignored "-Wextra"
#include <ui/DisplayIdentification.h>
#include "DisplayHardware/ComposerHal.h"
#include "LayerFE.h"
#include <aidl/android/hardware/graphics/composer3/Composition.h>
// TODO(b/129481165): remove the #pragma below and fix conversion issues
#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
namespace android {
namespace HWC2 {
class Layer;
} // namespace HWC2
namespace compositionengine {
class CompositionEngine;
class Output;
namespace impl {
struct OutputLayerCompositionState;
} // namespace impl
/**
* An output layer contains the output-dependent composition state for a layer
*/
class OutputLayer {
public:
virtual ~OutputLayer();
// Sets the HWC2::Layer associated with this layer
virtual void setHwcLayer(std::shared_ptr<HWC2::Layer>) = 0;
// Gets the output which owns this output layer
virtual const Output& getOutput() const = 0;
// Gets the front-end layer interface this output layer represents
virtual LayerFE& getLayerFE() const = 0;
using CompositionState = compositionengine::impl::OutputLayerCompositionState;
// Gets the raw composition state data for the layer
// TODO(lpique): Make this protected once it is only internally called.
virtual const CompositionState& getState() const = 0;
// Allows mutable access to the raw composition state data for the layer.
// This is meant to be used by the various functions that are part of the
// composition process.
// TODO(lpique): Make this protected once it is only internally called.
virtual CompositionState& editState() = 0;
// Clear the cache entries for a set of buffers that SurfaceFlinger no
// longer cares about.
virtual void uncacheBuffers(const std::vector<uint64_t>& bufferIdsToUncache) = 0;
// Recalculates the state of the output layer from the output-independent
// layer. If includeGeometry is false, the geometry state can be skipped.
// internalDisplayRotationFlags must be set to the rotation flags for the
// internal display, and is used to properly compute the inverse-display
// transform, if needed.
virtual void updateCompositionState(
bool includeGeometry, bool forceClientComposition,
ui::Transform::RotationFlags internalDisplayRotationFlags) = 0;
// Writes the geometry state to the HWC, or does nothing if this layer does
// not use the HWC. If includeGeometry is false, the geometry state can be
// skipped. If skipLayer is true, then the alpha of the layer is forced to
// 0 so that HWC will ignore it. z specifies the order to draw the layer in
// (starting with 0 for the back layer, and increasing for each following
// layer). zIsOverridden specifies whether the layer has been reordered.
// isPeekingThrough specifies whether this layer will be shown through a
// hole punch in a layer above it.
virtual void writeStateToHWC(bool includeGeometry, bool skipLayer, uint32_t z,
bool zIsOverridden, bool isPeekingThrough) = 0;
// Updates the cursor position with the HWC
virtual void writeCursorPositionToHWC() const = 0;
// Returns the HWC2::Layer associated with this layer, if it exists
virtual HWC2::Layer* getHwcLayer() const = 0;
// Returns true if the current layer state requires client composition
virtual bool requiresClientComposition() const = 0;
// Returns true if the current layer should be treated as a cursor layer
virtual bool isHardwareCursor() const = 0;
// Applies a HWC device requested composition type change
virtual void applyDeviceCompositionTypeChange(
aidl::android::hardware::graphics::composer3::Composition) = 0;
// Prepares to apply any HWC device layer requests
virtual void prepareForDeviceLayerRequests() = 0;
// Applies a HWC device layer request
virtual void applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest request) = 0;
// Returns true if the composition settings scale pixels
virtual bool needsFiltering() const = 0;
// Returns LayerSettings to be used by RenderEngine if the layer has been overridden
// during the composition process
virtual std::optional<LayerFE::LayerSettings> getOverrideCompositionSettings() const = 0;
// Debugging
virtual void dump(std::string& result) const = 0;
};
} // namespace compositionengine
} // namespace android
|
