blob: 28cb24a64f0e86553c0079892714115bd0cbcb05 [file] [log] [blame]
Ady Abraham8a82ba62020-01-17 12:43:17 -08001/*
2 * Copyright 2020 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
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080019#include <chrono>
20#include <deque>
21#include <optional>
22#include <string>
23#include <unordered_map>
24
Ady Abrahambdda8f02021-04-01 16:06:11 -070025#include <ui/Transform.h>
Ady Abraham8a82ba62020-01-17 12:43:17 -080026#include <utils/Timers.h>
27
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080028#include <scheduler/Seamlessness.h>
Ady Abraham8a82ba62020-01-17 12:43:17 -080029
30#include "LayerHistory.h"
31#include "RefreshRateConfigs.h"
Ady Abraham8a82ba62020-01-17 12:43:17 -080032
33namespace android {
34
35class Layer;
36
37namespace scheduler {
38
39using namespace std::chrono_literals;
40
41// Maximum period between presents for a layer to be considered active.
42constexpr std::chrono::nanoseconds MAX_ACTIVE_LAYER_PERIOD_NS = 1200ms;
43
44// Earliest present time for a layer to be considered active.
45constexpr nsecs_t getActiveLayerThreshold(nsecs_t now) {
46 return now - MAX_ACTIVE_LAYER_PERIOD_NS.count();
47}
48
49// Stores history of present times and refresh rates for a layer.
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010050class LayerInfo {
Ady Abraham5def7332020-05-29 16:13:47 -070051 using LayerUpdateType = LayerHistory::LayerUpdateType;
52
Ady Abraham8a82ba62020-01-17 12:43:17 -080053 // Layer is considered frequent if the earliest value in the window of most recent present times
54 // is within a threshold. If a layer is infrequent, its average refresh rate is disregarded in
55 // favor of a low refresh rate.
Marin Shalamanov2045d5b2020-12-28 18:11:41 +010056 static constexpr size_t kFrequentLayerWindowSize = 3;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070057 static constexpr Fps kMinFpsForFrequentLayer = 10_Hz;
Marin Shalamanov2045d5b2020-12-28 18:11:41 +010058 static constexpr auto kMaxPeriodForFrequentLayerNs =
59 std::chrono::nanoseconds(kMinFpsForFrequentLayer.getPeriodNsecs()) + 1ms;
Ady Abraham8a82ba62020-01-17 12:43:17 -080060
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010061 friend class LayerHistoryTest;
Marin Shalamanov2045d5b2020-12-28 18:11:41 +010062 friend class LayerInfoTest;
Ady Abraham8a82ba62020-01-17 12:43:17 -080063
64public:
Marin Shalamanov46084422020-10-13 12:33:42 +020065 // Holds information about the layer vote
66 struct LayerVote {
67 LayerHistory::LayerVoteType type = LayerHistory::LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070068 Fps fps;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +010069 Seamlessness seamlessness = Seamlessness::Default;
Marin Shalamanov46084422020-10-13 12:33:42 +020070 };
71
Ady Abrahambdda8f02021-04-01 16:06:11 -070072 // FrameRateCompatibility specifies how we should interpret the frame rate associated with
73 // the layer.
74 enum class FrameRateCompatibility {
75 Default, // Layer didn't specify any specific handling strategy
76
Andy Labrada096227e2022-06-15 16:58:11 +000077 Min, // Layer needs the minimum frame rate.
78
Ady Abrahambdda8f02021-04-01 16:06:11 -070079 Exact, // Layer needs the exact frame rate.
80
81 ExactOrMultiple, // Layer needs the exact frame rate (or a multiple of it) to present the
82 // content properly. Any other value will result in a pull down.
83
84 NoVote, // Layer doesn't have any requirements for the refresh rate and
85 // should not be considered when the display refresh rate is determined.
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -070086
87 ftl_last = NoVote
Ady Abrahambdda8f02021-04-01 16:06:11 -070088 };
89
90 // Encapsulates the frame rate and compatibility of the layer. This information will be used
91 // when the display refresh rate is determined.
92 struct FrameRate {
93 using Seamlessness = scheduler::Seamlessness;
94
95 Fps rate;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070096 FrameRateCompatibility type = FrameRateCompatibility::Default;
97 Seamlessness seamlessness = Seamlessness::Default;
Ady Abrahambdda8f02021-04-01 16:06:11 -070098
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070099 FrameRate() = default;
100
Ady Abrahambdda8f02021-04-01 16:06:11 -0700101 FrameRate(Fps rate, FrameRateCompatibility type,
102 Seamlessness seamlessness = Seamlessness::OnlySeamless)
103 : rate(rate), type(type), seamlessness(getSeamlessness(rate, seamlessness)) {}
104
105 bool operator==(const FrameRate& other) const {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700106 return isApproxEqual(rate, other.rate) && type == other.type &&
Ady Abrahambdda8f02021-04-01 16:06:11 -0700107 seamlessness == other.seamlessness;
108 }
109
110 bool operator!=(const FrameRate& other) const { return !(*this == other); }
111
112 // Convert an ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* value to a
113 // Layer::FrameRateCompatibility. Logs fatal if the compatibility value is invalid.
114 static FrameRateCompatibility convertCompatibility(int8_t compatibility);
115 static scheduler::Seamlessness convertChangeFrameRateStrategy(int8_t strategy);
116
117 private:
118 static Seamlessness getSeamlessness(Fps rate, Seamlessness seamlessness) {
119 if (!rate.isValid()) {
120 // Refresh rate of 0 is a special value which should reset the vote to
121 // its default value.
122 return Seamlessness::Default;
123 }
124 return seamlessness;
125 }
126 };
127
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700128 static void setTraceEnabled(bool enabled) { sTraceEnabled = enabled; }
129
Ady Abrahambdda8f02021-04-01 16:06:11 -0700130 LayerInfo(const std::string& name, uid_t ownerUid, LayerHistory::LayerVoteType defaultVote);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800131
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100132 LayerInfo(const LayerInfo&) = delete;
133 LayerInfo& operator=(const LayerInfo&) = delete;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800134
Ady Abrahambdda8f02021-04-01 16:06:11 -0700135 struct LayerProps {
136 bool visible = false;
137 FloatRect bounds;
138 ui::Transform transform;
139 FrameRate setFrameRateVote;
140 int32_t frameRateSelectionPriority = -1;
141 };
142
Ady Abraham8a82ba62020-01-17 12:43:17 -0800143 // Records the last requested present time. It also stores information about when
144 // the layer was last updated. If the present time is farther in the future than the
145 // updated time, the updated time is the present time.
Ady Abraham5def7332020-05-29 16:13:47 -0700146 void setLastPresentTime(nsecs_t lastPresentTime, nsecs_t now, LayerUpdateType updateType,
Ady Abrahambdda8f02021-04-01 16:06:11 -0700147 bool pendingModeChange, LayerProps props);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800148
Ady Abraham8a82ba62020-01-17 12:43:17 -0800149 // Sets an explicit layer vote. This usually comes directly from the application via
150 // ANativeWindow_setFrameRate API
Marin Shalamanov46084422020-10-13 12:33:42 +0200151 void setLayerVote(LayerVote vote) { mLayerVote = vote; }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800152
153 // Sets the default layer vote. This will be the layer vote after calling to resetLayerVote().
154 // This is used for layers that called to setLayerVote() and then removed the vote, so that the
155 // layer can go back to whatever vote it had before the app voted for it.
156 void setDefaultLayerVote(LayerHistory::LayerVoteType type) { mDefaultVote = type; }
157
158 // Resets the layer vote to its default.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700159 void resetLayerVote() { mLayerVote = {mDefaultVote, Fps(), Seamlessness::Default}; }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800160
Ady Abrahambdda8f02021-04-01 16:06:11 -0700161 std::string getName() const { return mName; }
162
163 uid_t getOwnerUid() const { return mOwnerUid; }
164
Ady Abraham3efa3942021-06-24 19:01:25 -0700165 LayerVote getRefreshRateVote(const RefreshRateConfigs&, nsecs_t now);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800166
167 // Return the last updated time. If the present time is farther in the future than the
168 // updated time, the updated time is the present time.
169 nsecs_t getLastUpdatedTime() const { return mLastUpdatedTime; }
170
Ady Abrahambdda8f02021-04-01 16:06:11 -0700171 FrameRate getSetFrameRateVote() const { return mLayerProps.setFrameRateVote; }
172 bool isVisible() const { return mLayerProps.visible; }
173 int32_t getFrameRateSelectionPriority() const { return mLayerProps.frameRateSelectionPriority; }
174
175 FloatRect getBounds() const { return mLayerProps.bounds; }
176
177 ui::Transform getTransform() const { return mLayerProps.transform; }
178
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700179 // Returns a C string for tracing a vote
180 const char* getTraceTag(LayerHistory::LayerVoteType type) const;
181
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400182 // Return the framerate of this layer.
183 Fps getFps(nsecs_t now) const;
184
Ady Abraham983e5682020-05-28 16:49:18 -0700185 void onLayerInactive(nsecs_t now) {
Ady Abrahamdfb63ba2020-05-27 20:05:05 +0000186 // Mark mFrameTimeValidSince to now to ignore all previous frame times.
187 // We are not deleting the old frame to keep track of whether we should treat the first
188 // buffer as Max as we don't know anything about this layer or Min as this layer is
189 // posting infrequent updates.
Ady Abraham983e5682020-05-28 16:49:18 -0700190 const auto timePoint = std::chrono::nanoseconds(now);
191 mFrameTimeValidSince = std::chrono::time_point<std::chrono::steady_clock>(timePoint);
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700192 mLastRefreshRate = {};
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700193 mRefreshRateHistory.clear();
Ady Abrahama61edcb2020-01-30 18:32:03 -0800194 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800195
Ady Abraham983e5682020-05-28 16:49:18 -0700196 void clearHistory(nsecs_t now) {
197 onLayerInactive(now);
198 mFrameTimes.clear();
199 }
200
Ady Abraham8a82ba62020-01-17 12:43:17 -0800201private:
Ady Abrahama61edcb2020-01-30 18:32:03 -0800202 // Used to store the layer timestamps
203 struct FrameTimeData {
Marin Shalamanov2045d5b2020-12-28 18:11:41 +0100204 nsecs_t presentTime; // desiredPresentTime, if provided
Ady Abrahama61edcb2020-01-30 18:32:03 -0800205 nsecs_t queueTime; // buffer queue time
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100206 bool pendingModeChange;
Ady Abrahama61edcb2020-01-30 18:32:03 -0800207 };
208
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700209 // Holds information about the calculated and reported refresh rate
210 struct RefreshRateHeuristicData {
211 // Rate calculated on the layer
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700212 Fps calculated;
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100213 // Last reported rate for LayerInfo::getRefreshRate()
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700214 Fps reported;
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100215 // Whether the last reported rate for LayerInfo::getRefreshRate()
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700216 // was due to animation or infrequent updates
217 bool animatingOrInfrequent = false;
218 };
219
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700220 // Class to store past calculated refresh rate and determine whether
221 // the refresh rate calculated is consistent with past values
222 class RefreshRateHistory {
223 public:
224 static constexpr auto HISTORY_SIZE = 90;
225 static constexpr std::chrono::nanoseconds HISTORY_DURATION = 2s;
226
227 RefreshRateHistory(const std::string& name) : mName(name) {}
228
229 // Clears History
230 void clear();
231
232 // Adds a new refresh rate and returns true if it is consistent
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100233 bool add(Fps refreshRate, nsecs_t now);
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700234
235 private:
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100236 friend class LayerHistoryTest;
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700237
238 // Holds the refresh rate when it was calculated
239 struct RefreshRateData {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700240 Fps refreshRate;
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700241 nsecs_t timestamp = 0;
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700242 };
243
244 // Holds tracing strings
245 struct HeuristicTraceTagData {
246 std::string min;
247 std::string max;
248 std::string consistent;
249 std::string average;
250 };
251
252 bool isConsistent() const;
253 HeuristicTraceTagData makeHeuristicTraceTagData() const;
254
255 const std::string mName;
256 mutable std::optional<HeuristicTraceTagData> mHeuristicTraceTagData;
257 std::deque<RefreshRateData> mRefreshRates;
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100258 static constexpr float MARGIN_CONSISTENT_FPS = 1.0;
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700259 };
260
Ady Abrahamaf6d8a42020-05-27 19:56:15 +0000261 bool isFrequent(nsecs_t now) const;
Ady Abraham5def7332020-05-29 16:13:47 -0700262 bool isAnimating(nsecs_t now) const;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800263 bool hasEnoughDataForHeuristic() const;
Ady Abraham3efa3942021-06-24 19:01:25 -0700264 std::optional<Fps> calculateRefreshRateIfPossible(const RefreshRateConfigs&, nsecs_t now);
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700265 std::optional<nsecs_t> calculateAverageFrameTime() const;
Ady Abrahamdfb63ba2020-05-27 20:05:05 +0000266 bool isFrameTimeValid(const FrameTimeData&) const;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800267
Ady Abrahama6b676e2020-05-27 14:29:09 -0700268 const std::string mName;
Ady Abrahambdda8f02021-04-01 16:06:11 -0700269 const uid_t mOwnerUid;
Ady Abrahama6b676e2020-05-27 14:29:09 -0700270
Marin Shalamanov4ad8b302020-12-11 15:50:08 +0100271 // Used for sanitizing the heuristic data. If two frames are less than
272 // this period apart from each other they'll be considered as duplicates.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700273 static constexpr nsecs_t kMinPeriodBetweenFrames = (240_Hz).getPeriodNsecs();
Marin Shalamanov2045d5b2020-12-28 18:11:41 +0100274 // Used for sanitizing the heuristic data. If two frames are more than
275 // this period apart from each other, the interval between them won't be
276 // taken into account when calculating average frame rate.
277 static constexpr nsecs_t kMaxPeriodBetweenFrames = kMinFpsForFrequentLayer.getPeriodNsecs();
Ady Abraham8a82ba62020-01-17 12:43:17 -0800278 LayerHistory::LayerVoteType mDefaultVote;
279
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700280 LayerVote mLayerVote;
281
Ady Abraham8a82ba62020-01-17 12:43:17 -0800282 nsecs_t mLastUpdatedTime = 0;
283
Ady Abraham5def7332020-05-29 16:13:47 -0700284 nsecs_t mLastAnimationTime = 0;
285
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700286 RefreshRateHeuristicData mLastRefreshRate;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800287
Ady Abraham8a82ba62020-01-17 12:43:17 -0800288 std::deque<FrameTimeData> mFrameTimes;
Ady Abrahamdfb63ba2020-05-27 20:05:05 +0000289 std::chrono::time_point<std::chrono::steady_clock> mFrameTimeValidSince =
290 std::chrono::steady_clock::now();
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700291 static constexpr size_t HISTORY_SIZE = RefreshRateHistory::HISTORY_SIZE;
292 static constexpr std::chrono::nanoseconds HISTORY_DURATION = 1s;
293
Ady Abrahambdda8f02021-04-01 16:06:11 -0700294 LayerProps mLayerProps;
295
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700296 RefreshRateHistory mRefreshRateHistory;
297
298 mutable std::unordered_map<LayerHistory::LayerVoteType, std::string> mTraceTags;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700299
300 // Shared for all LayerInfo instances
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700301 static bool sTraceEnabled;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800302};
303
304} // namespace scheduler
305} // namespace android