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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
/*
* 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 "aidl/android/hardware/graphics/composer3/DimmingStage.h"
#include <math/mat4.h>
#include <ui/FenceTime.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/GraphicTypes.h>
// TODO(b/129481165): remove the #pragma below and fix conversion issues
#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
#include <compositionengine/CompositionRefreshArgs.h>
#include <compositionengine/ProjectionSpace.h>
#include <renderengine/BorderRenderInfo.h>
#include <ui/LayerStack.h>
#include <ui/Rect.h>
#include <ui/Region.h>
#include <ui/Transform.h>
#include "DisplayHardware/HWComposer.h"
namespace android {
namespace compositionengine::impl {
struct OutputCompositionState {
// If false, composition will not be performed for this display
bool isEnabled{false};
// If false, this output is not considered secure
bool isSecure{false};
// If false, this output is not considered protected
bool isProtected{false};
// If true, the current frame on this output uses client composition
bool usesClientComposition{false};
// If true, the current frame on this output uses device composition
bool usesDeviceComposition{false};
// If true, the client target should be flipped when performing client composition
bool flipClientTarget{false};
// If true, the current frame reused the buffer from a previous client composition
bool reusedClientComposition{false};
// The conditions for including a layer on this output
ui::LayerFilter layerFilter;
// The common space for all layers in the layer stack. layerStackSpace.content is the Rect
// which gets projected on the display. The orientation of this space is always ROTATION_0.
ProjectionSpace layerStackSpace;
// Oriented physical display space. It will have the same size as displaySpace oriented to
// match the orientation of layerStackSpace. The orientation of this space is always ROTATION_0.
ProjectionSpace orientedDisplaySpace;
// The space of the framebuffer. Its bounds match the size of the framebuffer and its
// orientation matches the orientation of the display. Typically the framebuffer space will
// be identical to the physical display space.
ProjectionSpace framebufferSpace;
// The space of the physical display. It is as big as the currently active display mode. The
// content in this space can be rotated.
ProjectionSpace displaySpace;
// Transformation from layerStackSpace to displaySpace
ui::Transform transform;
// If true, RenderEngine filtering should be enabled
bool needsFiltering{false};
// The logical coordinates for the dirty region for the display.
// dirtyRegion is semi-persistent state. Dirty rectangles are added to it
// by the FE until composition happens, at which point it is cleared.
Region dirtyRegion;
// The logical coordinates for the undefined region for the display.
// The undefined region is internal to the composition engine. It is
// updated every time the geometry changes.
Region undefinedRegion;
// True if the last composition frame had visible layers
bool lastCompositionHadVisibleLayers{false};
// The color transform matrix to apply
mat4 colorTransformMatrix;
// Current active color mode
ui::ColorMode colorMode{ui::ColorMode::NATIVE};
// Current active render intent
ui::RenderIntent renderIntent{ui::RenderIntent::COLORIMETRIC};
// Current active dataspace
ui::Dataspace dataspace{ui::Dataspace::UNKNOWN};
std::optional<android::HWComposer::DeviceRequestedChanges> previousDeviceRequestedChanges{};
bool previousDeviceRequestedSuccess = false;
// Optional.
// The earliest time to send the present command to the HAL
std::optional<std::chrono::steady_clock::time_point> earliestPresentTime;
// The expected time for the next present
nsecs_t expectedPresentTime{0};
// The frameInterval for the next present
Fps frameInterval{};
// Current display brightness
float displayBrightnessNits{-1.f};
// SDR white point
float sdrWhitePointNits{-1.f};
// Brightness of the client target, normalized to display brightness
float clientTargetBrightness{1.f};
// Stage in which the client target should apply dimming
aidl::android::hardware::graphics::composer3::DimmingStage clientTargetDimmingStage{
aidl::android::hardware::graphics::composer3::DimmingStage::NONE};
// Display brightness that will take effect this frame.
// This is slightly distinct from nits, in that nits cannot be passed to hw composer.
std::optional<float> displayBrightness = std::nullopt;
enum class CompositionStrategyPredictionState : uint32_t {
// Composition strategy prediction did not run for this frame.
DISABLED = 0,
// Composition strategy predicted successfully for this frame.
SUCCESS = 1,
// Composition strategy prediction failed for this frame.
FAIL = 2,
ftl_last = FAIL
};
CompositionStrategyPredictionState strategyPrediction =
CompositionStrategyPredictionState::DISABLED;
bool treat170mAsSrgb = false;
std::vector<renderengine::BorderRenderInfo> borderInfoList;
uint64_t lastOutputLayerHash = 0;
uint64_t outputLayerHash = 0;
ICEPowerCallback* powerCallback = nullptr;
// Debugging
void dump(std::string& result) const;
};
} // namespace compositionengine::impl
} // namespace android
|
